Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,126 @@
+**/*.pt
+**/checkpoints
+**/wget-log
+**/_build/
+**/*.ckpt
+**/outputs
+**/*.tar.gz
+**/playground
+**/wandb
+/verl
+/scripts
+/saves
+/runs
+/results
+/cleanrl
+/train_*.sh
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+dataset/*
+tensorflow/my_graph/*
+.idea/
+# C extensions
+*.so
+data
+results/
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*,cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+image_outputs
+
+checkpoints
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# IPython Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+
+# virtualenv
+venv/
+
+
+# Spyder project settings
+.spyderproject
+
+# Rope project settings
+.ropeproject
+
+# vscode
+.vscode
+
+# Mac
+.DS_Store
+
+# output logs
+tests/e2e/toy_examples/deepspeed/synchronous/output.txt
+
+# vim
+*.swp
+
+
+log/

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "verl"]
+	path = verl
+	url = https://github.com/volcengine/verl.git
+[submodule "external/webshop-minimal"]
+	path = external/webshop-minimal
+	url = https://github.com/ZihanWang314/webshop-minimal.git
+[submodule "external/kimina-lean-server"]
+	path = external/kimina-lean-server
+	url = https://github.com/project-numina/kimina-lean-server.git

LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 RAGEN 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.

cleanrl/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [vwxyzjn]# Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: ['https://www.buymeacoffee.com/dosssman']# Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

cleanrl/.github/issue_template.md

@@ -0,0 +1,24 @@
+## Problem Description
+<!--- Provide a general summary of the issue in the Title above -->
+
+## Checklist
+- [ ] I have installed dependencies via `uv pip install` (see [CleanRL's installation guideline](https://docs.cleanrl.dev/get-started/installation/).
+- [ ] I have checked that there is no similar [issue](https://github.com/vwxyzjn/cleanrl/issues) in the repo.
+- [ ] I have checked the [documentation site](https://docs.cleanrl.dev/) and found not relevant information in [GitHub issues](https://github.com/vwxyzjn/cleanrl/issues).
+
+## Current Behavior
+<!--- Tell us what happens instead of the expected behavior -->
+
+## Expected Behavior
+<!--- Tell us what should happen -->
+
+## Possible Solution
+<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+
+## Steps to Reproduce
+<!--- Provide a link to a live example, or an unambiguous set of steps to -->
+<!--- reproduce this bug. Include code to reproduce, if relevant -->
+1.
+2.
+3.
+4.

cleanrl/.github/pull_request_template.md

@@ -0,0 +1,33 @@
+## Description
+<!--- Provide a general summary of your changes in here-->
+
+## Types of changes
+<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
+- [ ] Bug fix
+- [ ] New feature
+- [ ] New algorithm
+- [ ] Documentation
+
+## Checklist:
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+- [ ] I've read the [CONTRIBUTION](https://docs.cleanrl.dev/contribution/) guide (**required**).
+- [ ] I have ensured `pre-commit run --all-files` passes (**required**).
+- [ ] I have updated the tests accordingly (if applicable).
+- [ ] I have updated the documentation and previewed the changes via `mkdocs serve`.
+    - [ ] I have explained note-worthy implementation details.
+    - [ ] I have explained the logged metrics.
+    - [ ] I have added links to the original paper and related papers.
+
+If you need to run benchmark experiments for a performance-impacting changes:
+
+- [ ] I have contacted @vwxyzjn to obtain access to the [openrlbenchmark W&B team](https://wandb.ai/openrlbenchmark).
+- [ ] I have used the [benchmark utility](/get-started/benchmark-utility/) to submit the tracked experiments to the [openrlbenchmark/cleanrl](https://wandb.ai/openrlbenchmark/cleanrl) W&B project, optionally with `--capture_video`.
+- [ ] I have performed RLops with `python -m openrlbenchmark.rlops`.
+    - For new feature or bug fix:
+        - [ ] I have used the RLops utility to understand the performance impact of the changes and confirmed there is no regression.
+    - For new algorithm:
+        - [ ] I have created a table comparing my results against those from reputable sources (i.e., the original paper or other reference implementation).
+    - [ ] I have added the learning curves generated by the `python -m openrlbenchmark.rlops` utility to the documentation.
+    - [ ] I have added links to the tracked experiments in W&B, generated by `python -m openrlbenchmark.rlops ....your_args... --report`,  to the documentation.
+

cleanrl/.github/workflows/pre-commit.yml

@@ -0,0 +1,25 @@
+name: pre-commit
+
+on:
+  pull_request:
+    paths-ignore:
+      - 'docs/blog/*' # dummy ignore
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.9]
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: recursive
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: pre-commit/action@v3.0.1
+        with:
+          extra_args: --hook-stage manual --all-files

cleanrl/.github/workflows/tests.yaml

@@ -0,0 +1,201 @@
+name: tests
+on:
+  pull_request:
+    paths-ignore:
+      - '**/README.md'
+      - 'docs/**/*'
+      - 'cloud/**/*'
+jobs:
+  test-core-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # classic control tests
+      - name: Install core dependencies
+        run: uv pip install ".[pytest]"
+      - name: Run core tests
+        run: uv run pytest tests/test_classic_control.py
+      - name: Install jax
+        if: runner.os == 'Linux' || runner.os == 'macOS'
+        run: uv pip install ".[pytest, jax]"
+      - name: Run gymnasium tests
+        run: uv run pytest tests/test_classic_control_gymnasium.py
+      - name: Run core tests with jax
+        if: runner.os == 'Linux' || runner.os == 'macOS'
+        run: uv run pytest tests/test_classic_control_jax_gymnasium.py
+      - name: Run gae tests with jax
+        if: runner.os == 'Linux' || runner.os == 'macOS'
+        run: uv run pytest tests/test_jax_compute_gae.py
+      - name: Install tuner dependencies
+        run: uv pip install ".[pytest, optuna]"
+      - name: Run tuner tests
+        run: uv run pytest tests/test_tuner.py
+
+  test-atari-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # atari tests
+      - name: Install atari dependencies
+        run: uv pip install ".[pytest, atari]"
+      - name: Run atari tests
+        run: uv run pytest tests/test_atari.py
+      - name: Install jax
+        if: runner.os == 'Linux' || runner.os == 'macOS'
+        run: uv pip install ".[pytest, atari, jax]"
+      - name: Run gymnasium migration dependencies
+        run: uv run pip install "gymnasium[atari,accept-rom-license]==0.28.1" "ale-py==0.8.1"
+      - name: Run gymnasium tests
+        run: uv run pytest tests/test_atari_gymnasium.py
+      - name: Run gymnasium tests with jax
+        if: runner.os == 'Linux' || runner.os == 'macOS'
+        run: uv run pytest tests/test_atari_jax_gymnasium.py
+
+  test-procgen-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # procgen tests
+      - name: Install core dependencies
+        run: uv pip install ".[pytest, procgen]"
+      - name: Downgrade setuptools
+        run: uv run pip install setuptools==59.5.0
+      - name: Run procgen tests
+        run: uv run pytest tests/test_procgen.py
+
+  test-mujoco-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+      - name: Setup virtual display
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xvfb
+          export DISPLAY=:99
+          Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
+
+      # mujoco tests
+      - name: Install dependencies
+        run: uv pip install ".[pytest, mujoco, dm_control, jax]"
+      - name: install mujoco dependencies
+        run: |
+          sudo apt-get update && sudo apt-get -y install libgl1-mesa-glx libosmesa6 libglfw3
+      - name: Run mujoco tests
+        run: uv run pytest tests/test_mujoco.py
+        env:
+          DISPLAY: :99
+
+  test-envpool-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # envpool tests
+      - name: Install envpool dependencies
+        run: uv pip install ".[pytest, envpool, jax]"
+      - name: Run envpool tests
+        run: uv run pytest tests/test_envpool.py
+
+  test-atari-multigpu-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # atari multigpu tests
+      - name: Install atari dependencies
+        run: uv pip install ".[pytest, atari]"
+      - name: Run atari tests
+        run: uv run pytest tests/test_atari_multigpu.py
+
+  test-pettingzoo-envs:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      # pettingzoo tests
+      - name: Install pettingzoo dependencies
+        run: uv pip install ".[pytest, pettingzoo, atari]"
+      - name: Install ROMs
+        run: uv run AutoROM --accept-license
+      - name: Run pettingzoo tests
+        run: uv run pytest tests/test_pettingzoo_ma_atari.py

cleanrl/.github/workflows/utils_test.yaml

@@ -0,0 +1,32 @@
+name: utils_test
+on:
+  pull_request:
+    paths-ignore:
+      - '**/README.md'
+      - 'docs/**/*'
+      - 'cloud/**/*'
+jobs:
+  ci:
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.8", "3.9", "3.10"]
+        os: [ubuntu-22.04]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - run: uv venv
+
+      - name: Install test dependencies
+        run: uv pip install ".[pytest]"
+      - name: Install cloud dependencies
+        run: uv pip install ".[pytest, cloud]"
+      - name: Downgrade setuptools
+        run: uv pip install setuptools==59.5.0
+      - name: Run utils tests
+        run: uv run pytest tests/test_utils.py

cleanrl/Dockerfile

@@ -0,0 +1,21 @@
+FROM nvidia/cuda:11.4.2-runtime-ubuntu20.04
+
+# install ubuntu dependencies
+ENV DEBIAN_FRONTEND=noninteractive 
+RUN apt-get update && \
+    apt-get -y install python3-pip xvfb ffmpeg git build-essential python-opengl
+RUN ln -s /usr/bin/python3 /usr/bin/python
+
+# install python dependencies
+RUN mkdir cleanrl_utils && touch cleanrl_utils/__init__.py
+RUN pip install uv --upgrade
+COPY pyproject.toml pyproject.toml
+COPY uv.lock uv.lock
+RUN uv pip install .
+
+COPY entrypoint.sh /usr/local/bin/
+RUN chmod 777 /usr/local/bin/entrypoint.sh
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]
+
+# copy local files
+COPY ./cleanrl /cleanrl

cleanrl/benchmark/cleanrl_1gpu.slurm_template

@@ -0,0 +1,21 @@
+#!/bin/bash
+#SBATCH --job-name=low-priority
+#SBATCH --partition=production-cluster
+#SBATCH --gpus-per-task={{gpus_per_task}}
+#SBATCH --cpus-per-gpu={{cpus_per_gpu}}
+#SBATCH --ntasks={{ntasks}}
+#SBATCH --output=slurm/logs/%x_%j.out
+#SBATCH --array={{array}}
+#SBATCH --mem-per-cpu=12G
+#SBATCH --exclude=ip-26-0-146-[33,100,122-123,149,183,212,249],ip-26-0-147-[6,94,120,141],ip-26-0-152-[71,101,119,178,186,207,211],ip-26-0-153-[6,62,112,132,166,251],ip-26-0-154-[38,65],ip-26-0-155-[164,174,187,217],ip-26-0-156-[13,40],ip-26-0-157-27
+##SBATCH --nodelist=ip-26-0-147-204
+{{nodes}}
+
+env_ids={{env_ids}}
+seeds={{seeds}}
+env_id=${env_ids[$SLURM_ARRAY_TASK_ID / {{len_seeds}}]}
+seed=${seeds[$SLURM_ARRAY_TASK_ID % {{len_seeds}}]}
+
+echo "Running task $SLURM_ARRAY_TASK_ID with env_id: $env_id and seed: $seed"
+
+srun {{command}} --env-id $env_id --seed $seed # 

cleanrl/benchmark/ddpg.sh

@@ -0,0 +1,22 @@
+uv pip install ".[mujoco]"
+python -m cleanrl_utils.benchmark \
+    --env-ids HalfCheetah-v4 Walker2d-v4 Hopper-v4 InvertedPendulum-v4 Humanoid-v4 Pusher-v4 \
+    --command "uv run python cleanrl/ddpg_continuous_action.py --track" \
+    --num-seeds 3 \
+    --workers 18 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[mujoco, jax]"
+uv pip install --upgrade "jax[cuda11_cudnn82]==0.4.8" -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html
+uv run python -m cleanrl_utils.benchmark \
+    --env-ids HalfCheetah-v4 Walker2d-v4 Hopper-v4 InvertedPendulum-v4 Humanoid-v4 Pusher-v4 \
+    --command "uv run python cleanrl/ddpg_continuous_action_jax.py --track" \
+    --num-seeds 3 \
+    --workers 18 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template

cleanrl/benchmark/ppo.sh

@@ -0,0 +1,145 @@
+# export WANDB_ENTITY=openrlbenchmark
+
+uv pip install .
+OMP_NUM_THREADS=1 xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids CartPole-v1 Acrobot-v1 MountainCar-v0 \
+    --command "uv run python cleanrl/ppo.py --no_cuda --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[atari]"
+OMP_NUM_THREADS=1 xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids PongNoFrameskip-v4 BeamRiderNoFrameskip-v4 BreakoutNoFrameskip-v4 \
+    --command "uv run python cleanrl/ppo_atari.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[mujoco]"
+OMP_NUM_THREADS=1 xvfb-run -a python -m cleanrl_utils.benchmark \
+    --env-ids HalfCheetah-v4 Walker2d-v4 Hopper-v4 InvertedPendulum-v4 Humanoid-v4 Pusher-v4 \
+    --command "uv run python cleanrl/ppo_continuous_action.py --no_cuda --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[mujoco, dm_control]"
+OMP_NUM_THREADS=1 xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids dm_control/acrobot-swingup-v0 dm_control/acrobot-swingup_sparse-v0 dm_control/ball_in_cup-catch-v0 dm_control/cartpole-balance-v0 dm_control/cartpole-balance_sparse-v0 dm_control/cartpole-swingup-v0 dm_control/cartpole-swingup_sparse-v0 dm_control/cartpole-two_poles-v0 dm_control/cartpole-three_poles-v0 dm_control/cheetah-run-v0 dm_control/dog-stand-v0 dm_control/dog-walk-v0 dm_control/dog-trot-v0 dm_control/dog-run-v0 dm_control/dog-fetch-v0 dm_control/finger-spin-v0 dm_control/finger-turn_easy-v0 dm_control/finger-turn_hard-v0 dm_control/fish-upright-v0 dm_control/fish-swim-v0 dm_control/hopper-stand-v0 dm_control/hopper-hop-v0 dm_control/humanoid-stand-v0 dm_control/humanoid-walk-v0 dm_control/humanoid-run-v0 dm_control/humanoid-run_pure_state-v0 dm_control/humanoid_CMU-stand-v0 dm_control/humanoid_CMU-run-v0 dm_control/lqr-lqr_2_1-v0 dm_control/lqr-lqr_6_2-v0 dm_control/manipulator-bring_ball-v0 dm_control/manipulator-bring_peg-v0 dm_control/manipulator-insert_ball-v0 dm_control/manipulator-insert_peg-v0 dm_control/pendulum-swingup-v0 dm_control/point_mass-easy-v0 dm_control/point_mass-hard-v0 dm_control/quadruped-walk-v0 dm_control/quadruped-run-v0 dm_control/quadruped-escape-v0 dm_control/quadruped-fetch-v0 dm_control/reacher-easy-v0 dm_control/reacher-hard-v0 dm_control/stacker-stack_2-v0 dm_control/stacker-stack_4-v0 dm_control/swimmer-swimmer6-v0 dm_control/swimmer-swimmer15-v0 dm_control/walker-stand-v0 dm_control/walker-walk-v0 dm_control/walker-run-v0 \
+    --command "uv run python cleanrl/ppo_continuous_action.py --exp-name ppo_continuous_action_8M  --total-timesteps 8000000 --no_cuda --track" \
+    --num-seeds 10 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[atari]"
+OMP_NUM_THREADS=1 xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids PongNoFrameskip-v4 BeamRiderNoFrameskip-v4 BreakoutNoFrameskip-v4 \
+    --command "uv run python cleanrl/ppo_atari_lstm.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[envpool]"
+uv run python -m cleanrl_utils.benchmark \
+    --env-ids Pong-v5 BeamRider-v5 Breakout-v5 \
+    --command "uv run python cleanrl/ppo_atari_envpool.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[envpool, jax]"
+uv run python -m cleanrl_utils.benchmark \
+    --env-ids Alien-v5 Amidar-v5 Assault-v5 Asterix-v5 Asteroids-v5 Atlantis-v5 BankHeist-v5 BattleZone-v5 BeamRider-v5 Berzerk-v5 Bowling-v5 Boxing-v5 Breakout-v5 Centipede-v5 ChopperCommand-v5 CrazyClimber-v5 Defender-v5 DemonAttack-v5 DoubleDunk-v5 Enduro-v5 FishingDerby-v5 Freeway-v5 Frostbite-v5 Gopher-v5 Gravitar-v5 Hero-v5 IceHockey-v5 Jamesbond-v5 Kangaroo-v5 Krull-v5 KungFuMaster-v5 MontezumaRevenge-v5 MsPacman-v5 NameThisGame-v5 Phoenix-v5 Pitfall-v5 Pong-v5 PrivateEye-v5 Qbert-v5 Riverraid-v5 RoadRunner-v5 Robotank-v5 Seaquest-v5 Skiing-v5 Solaris-v5 SpaceInvaders-v5 StarGunner-v5 Surround-v5 Tennis-v5 TimePilot-v5 Tutankham-v5 UpNDown-v5 Venture-v5 VideoPinball-v5 WizardOfWor-v5 YarsRevenge-v5 Zaxxon-v5 \
+    --command "uv run python ppo_atari_envpool_xla_jax.py --track --wandb-project-name envpool-atari --wandb-entity openrlbenchmark" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[envpool, jax]"
+python -m cleanrl_utils.benchmark \
+    --env-ids Pong-v5 BeamRider-v5 Breakout-v5 \
+    --command "uv run python cleanrl/ppo_atari_envpool_xla_jax_scan.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[procgen]"
+uv run python -m cleanrl_utils.benchmark \
+    --env-ids starpilot bossfight bigfish \
+    --command "uv run python cleanrl/ppo_procgen.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[atari]"
+xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids PongNoFrameskip-v4 BeamRiderNoFrameskip-v4 BreakoutNoFrameskip-v4 \
+    --command "uv run torchrun --standalone --nnodes=1 --nproc_per_node=2 cleanrl/ppo_atari_multigpu.py --local-num-envs 4 --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+uv pip install ".[pettingzoo, atari]"
+uv run AutoROM --accept-license
+xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids pong_v3 surround_v2 tennis_v3  \
+    --command "uv run python cleanrl/ppo_pettingzoo_ma_atari.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+
+# IMPORTANT: see specific Isaac Gym installation at
+# https://docs.cleanrl.dev/rl-algorithms/ppo/#usage_8
+poetry install --with isaacgym
+xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids Cartpole Ant Humanoid BallBalance Anymal  \
+    --command "uv run python cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py --track --capture_video" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template
+xvfb-run -a uv run python -m cleanrl_utils.benchmark \
+    --env-ids AllegroHand ShadowHand \
+    --command "uv run python cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py --track --capture_video --num-envs 8192 --num-steps 8 --update-epochs 5 --num-minibatches 4 --reward-scaler 0.01 --total-timesteps 600000000 --record-video-step-frequency 3660" \
+    --num-seeds 3 \
+    --workers 9 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template

cleanrl/benchmark/sac.sh

@@ -0,0 +1,10 @@
+uv pip install ".[mujoco]"
+uv run python -m cleanrl_utils.benchmark \
+    --env-ids HalfCheetah-v4 Walker2d-v4 Hopper-v4 InvertedPendulum-v4 Humanoid-v4 Pusher-v4 \
+    --command "uv run python cleanrl/sac_continuous_action.py --track" \
+    --num-seeds 3 \
+    --workers 18 \
+    --slurm-gpus-per-task 1 \
+    --slurm-ntasks 1 \
+    --slurm-total-cpus 10 \
+    --slurm-template-path benchmark/cleanrl_1gpu.slurm_template

cleanrl/cleanrl/ppo_atari_multigpu.py

@@ -0,0 +1,403 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_atari_multigpupy
+import os
+import random
+import time
+import warnings
+from dataclasses import dataclass, field
+from typing import List, Literal
+
+import gymnasium as gym
+import numpy as np
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+import torch.optim as optim
+import tyro
+from rich.pretty import pprint
+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"""
+    local_num_envs: int = 8
+    """the number of parallel game environments (in the local rank)"""
+    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"""
+    device_ids: List[int] = field(default_factory=lambda: [])
+    """the device ids that subprocess workers will use"""
+    backend: Literal["gloo", "nccl", "mpi"] = "gloo"
+    """the backend for distributed training"""
+
+    # to be filled in runtime
+    local_batch_size: int = 0
+    """the local batch size in the local rank (computed in runtime)"""
+    local_minibatch_size: int = 0
+    """the local mini-batch size in the local rank (computed in runtime)"""
+    num_envs: int = 0
+    """the number of parallel game environments (computed 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)"""
+    world_size: int = 0
+    """the number of processes (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__":
+    # torchrun --standalone --nnodes=1 --nproc_per_node=2 ppo_atari_multigpu.py
+    # taken from https://pytorch.org/docs/stable/elastic/run.html
+    args = tyro.cli(Args)
+    local_rank = int(os.getenv("LOCAL_RANK", "0"))
+    args.world_size = int(os.getenv("WORLD_SIZE", "1"))
+    args.local_batch_size = int(args.local_num_envs * args.num_steps)
+    args.local_minibatch_size = int(args.local_batch_size // args.num_minibatches)
+    args.num_envs = args.local_num_envs * args.world_size
+    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
+    if args.world_size > 1:
+        dist.init_process_group(args.backend, rank=local_rank, world_size=args.world_size)
+    else:
+        warnings.warn(
+            """
+Not using distributed mode!
+If you want to use distributed mode, please execute this script with 'torchrun'.
+E.g., `torchrun --standalone --nnodes=1 --nproc_per_node=2 ppo_atari_multigpu.py`
+        """
+        )
+    run_name = f"{args.env_id}__{args.exp_name}__{args.seed}__{int(time.time())}"
+    writer = None
+    if local_rank == 0:
+        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()])),
+        )
+        pprint(args)
+
+    # TRY NOT TO MODIFY: seeding
+    # CRUCIAL: note that we needed to pass a different seed for each data parallelism worker
+    args.seed += local_rank
+    random.seed(args.seed)
+    np.random.seed(args.seed)
+    torch.manual_seed(args.seed - local_rank)
+    torch.backends.cudnn.deterministic = args.torch_deterministic
+
+    if len(args.device_ids) > 0:
+        assert len(args.device_ids) == args.world_size, "you must specify the same number of device ids as `--nproc_per_node`"
+        device = torch.device(f"cuda:{args.device_ids[local_rank]}" if torch.cuda.is_available() and args.cuda else "cpu")
+    else:
+        device_count = torch.cuda.device_count()
+        if device_count < args.world_size:
+            device = torch.device("cuda" if torch.cuda.is_available() and args.cuda else "cpu")
+        else:
+            device = torch.device(f"cuda:{local_rank}" 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.local_num_envs)],
+    )
+    assert isinstance(envs.single_action_space, gym.spaces.Discrete), "only discrete action space is supported"
+
+    agent = Agent(envs).to(device)
+    torch.manual_seed(args.seed)
+    optimizer = optim.Adam(agent.parameters(), lr=args.learning_rate, eps=1e-5)
+
+    # ALGO Logic: Storage setup
+    obs = torch.zeros((args.num_steps, args.local_num_envs) + envs.single_observation_space.shape).to(device)
+    actions = torch.zeros((args.num_steps, args.local_num_envs) + envs.single_action_space.shape).to(device)
+    logprobs = torch.zeros((args.num_steps, args.local_num_envs)).to(device)
+    rewards = torch.zeros((args.num_steps, args.local_num_envs)).to(device)
+    dones = torch.zeros((args.num_steps, args.local_num_envs)).to(device)
+    values = torch.zeros((args.num_steps, args.local_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.local_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 not writer:
+                continue
+
+            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)
+
+        print(
+            f"local_rank: {local_rank}, action.sum(): {action.sum()}, iteration: {iteration}, agent.actor.weight.sum(): {agent.actor.weight.sum()}"
+        )
+        # 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.local_batch_size)
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            np.random.shuffle(b_inds)
+            for start in range(0, args.local_batch_size, args.local_minibatch_size):
+                end = start + args.local_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()
+
+                if args.world_size > 1:
+                    # batch allreduce ops: see https://github.com/entity-neural-network/incubator/pull/220
+                    all_grads_list = []
+                    for param in agent.parameters():
+                        if param.grad is not None:
+                            all_grads_list.append(param.grad.view(-1))
+                    all_grads = torch.cat(all_grads_list)
+                    dist.all_reduce(all_grads, op=dist.ReduceOp.SUM)
+                    offset = 0
+                    for param in agent.parameters():
+                        if param.grad is not None:
+                            param.grad.data.copy_(
+                                all_grads[offset : offset + param.numel()].view_as(param.grad.data) / args.world_size
+                            )
+                            offset += param.numel()
+
+                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
+        if local_rank == 0:
+            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()
+    if local_rank == 0:
+        writer.close()
+        if args.track:
+            wandb.finish()

cleanrl/cleanrl/ppo_blackjack.py

@@ -0,0 +1,564 @@
+# PPO with small MLP for RAGEN Blackjack using the improved Wrapper logic
+import os
+import random
+import time
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Any, Tuple, 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/env/blackjack/
+# 如果报错找不到 ragen，请调整这里的路径或者在项目根目录运行
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '../../'))
+
+from ragen.env.blackjack.env import BlackjackEnv
+from ragen.env.blackjack.config import BlackjackEnvConfig
+
+
+class BlackjackWrapper(gym.Env):
+    """
+    改进后的适配器，用于处理新的 text observation 格式。
+    - 增加了 _last_dealer_show 记忆，防止游戏结算画面丢失 Dealer 明牌信息。
+    - 使用正则解析，更稳健。
+    """
+    metadata = {"render_modes": ["ansi", "human", "text"]}
+
+    def __init__(self):
+        super().__init__()
+        # 强制使用 text 模式以便解析
+        cfg = BlackjackEnvConfig(render_mode='text')
+        self._env = BlackjackEnv(cfg)
+        
+        # 8维特征向量: 
+        # [player_sum/31, dealer_show/11, usable_ace, done_flag,
+        #  is_20_21, player_sum_sq, dealer_ge_7, bias]
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(8,), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(2)
+        
+        # 记忆变量
+        self._last_dealer_show = 0
+
+    @staticmethod
+    def _safe_extract_ints(line: str) -> List[int]:
+        """使用正则提取行内所有整数"""
+        return [int(x) for x in re.findall(r'-?\d+', line)]
+
+    def _encode_obs(self, text_obs: str, done_flag: bool) -> np.ndarray:
+        # 默认值
+        p_sum = 0
+        usable = 0
+        # 如果是 Done 状态，Environment 可能不显示 Visible Card，使用记忆值
+        dealer_show = self._last_dealer_show 
+        
+        lines = text_obs.split('\n')
+        for ln in lines:
+            # 1. 解析玩家点数
+            # 格式示例: "Your Hand: [10, 8] (Total: 18)."
+            if "Your Hand" in ln:
+                if "Total:" in ln:
+                    try:
+                        # 截取 Total: 之后的部分进行数字提取
+                        part = ln.split("Total:")[1]
+                        ints = self._safe_extract_ints(part)
+                        if ints: p_sum = ints[0]
+                    except:
+                        pass
+                else:
+                    # 兼容旧格式或兜底：取该行最后一个数字
+                    ints = self._safe_extract_ints(ln)
+                    if ints: p_sum = ints[-1]
+
+            # 2. 解析 Usable Ace
+            elif "usable Ace" in ln:
+                if "do NOT" not in ln and "possess" in ln:
+                    usable = 1
+
+            # 3. 解析庄家明牌
+            # 只有在非 Done 状态下，才有这一行
+            elif "Dealer's Visible Card:" in ln:
+                ints = self._safe_extract_ints(ln)
+                if len(ints) >= 1:
+                    dealer_show = ints[0]
+                    self._last_dealer_show = dealer_show # 更新记忆
+
+        # 特征归一化与构建
+        ps = float(p_sum) / 31.0
+        ds = float(dealer_show) / 11.0
+        ua = float(usable)
+        df = 1.0 if done_flag else 0.0
+        
+        # 辅助特征 (Heuristic features)
+        is_20_21 = 1.0 if (p_sum >= 20) else 0.0
+        ps_sq = (float(p_sum) ** 2) / (31.0 ** 2)
+        dealer_ge_7 = 1.0 if dealer_show >= 7 else 0.0
+        bias = 1.0
+
+        feat = np.array([ps, ds, ua, df, is_20_21, ps_sq, dealer_ge_7, bias], dtype=np.float32)
+        return feat
+
+    def reset(self, *, seed: int | None = None, options: Dict[str, Any] | None = None):
+        text_obs = self._env.reset(seed=seed)
+        self._last_dealer_show = 0 # 重置
+        # 第一次 encode 会自动更新 _last_dealer_show
+        obs = self._encode_obs(text_obs, done_flag=False)
+        return obs, {}
+
+    def step(self, action: int):
+        # 映射: Agent 0/1 -> Env 1(Stick)/2(Hit)
+        mapped = int(action) + 1  
+        text_obs, reward, done, info = self._env.step(mapped)
+        
+        # 即使 done=True，也会根据 _last_dealer_show 生成稳定的 observation
+        obs = self._encode_obs(text_obs, done_flag=bool(done))
+        
+        terminated = bool(done)
+        truncated = False
+        info = info or {}
+        return obs, float(reward), terminated, truncated, 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，设为 True
+    wandb_project_name: str = "ragen_blackjack"
+    wandb_entity: str | None = None
+    capture_video: bool = False
+
+    # Algorithm
+    env_id: str = "Blackjack"
+    total_timesteps: int = 2000_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.05 
+    vf_coef: float = 0.5
+    max_grad_norm: float = 0.5
+    target_kl: float | None = None
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+    # eval config
+    eval_splits: int = 10
+    eval_episodes: int = 1000
+
+
+def make_env(idx, run_name, seed, capture_video=False):
+    def thunk():
+        env = BlackjackWrapper()
+        # Blackjack 每一局很短，设置一个安全上限即可
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=64)
+        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 = 64
+        # Critic: 评估当前状态好坏
+        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),
+        )
+        # Actor: 输出动作概率
+        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,
+        )
+
+    # 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")
+    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)
+
+    # 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)
+
+    # Start loop
+    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)
+
+    # Evaluation helper function
+    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"
+        
+        # 独立的 Eval 环境
+        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
+                
+                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))
+                    
+                    d = bool(terminated) or bool(truncated)
+                    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,
+            }
+            with (out_dir / "metrics.json").open("w") as mf:
+                json.dump(metrics, mf)
+            return metrics
+        except Exception as e:
+            print(f"Warning: failed to write eval metrics: {e}")
+            return {
+                "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,
+            }
+
+    # Training Loop
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+    # Convergence trackers
+    recent_winrates = deque(maxlen=50)
+    winrate_ema = None
+    
+    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
+
+        # Per-iteration episode outcome accumulators
+        iter_outcomes: List[int] = []  # +1 win, 0 draw, -1 loss
+        iter_ep_returns: List[float] = []
+
+        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
+
+            # Step Env
+            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)
+
+            # Collect per-episode stats robustly across Gymnasium vector API variants
+            # Preferred: infos.get("final_info") contains a list of infos for envs that ended this step
+            if isinstance(infos, dict):
+                final_infos = infos.get("final_info", None)
+                if final_infos is not None:
+                    for finfo in final_infos:
+                        if finfo:
+                            ep_r = float(finfo.get("episode", {}).get("r", 0.0))
+                            # success flag may be propagated; fallback to reward sign
+                            succ = bool(finfo.get("success", ep_r > 0))
+                            if succ:
+                                iter_outcomes.append(1)
+                            else:
+                                # draw if zero, else loss
+                                if ep_r == 0.0:
+                                    iter_outcomes.append(0)
+                                else:
+                                    iter_outcomes.append(-1)
+                            iter_ep_returns.append(ep_r)
+                # Fallback: some vector envs expose aggregated episode arrays directly
+                elif "episode" in infos:
+                    ep = infos.get("episode", {})
+                    # ep["r"] may be array-like aligned with envs where episode ended
+                    ep_r_vals = ep.get("r", [])
+                    try:
+                        for ep_r in list(np.atleast_1d(ep_r_vals)):
+                            ep_r = float(ep_r)
+                            if ep_r > 0:
+                                iter_outcomes.append(1)
+                            elif ep_r < 0:
+                                iter_outcomes.append(-1)
+                            else:
+                                iter_outcomes.append(0)
+                            iter_ep_returns.append(ep_r)
+                    except Exception:
+                        pass
+
+        # GAE Calculation
+        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)
+
+        # 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():
+                    # 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 = 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
+
+        # Output / Logging
+        sps = int(global_step / (time.time() - start_time))
+        progress = 100 * iteration / args.num_iterations
+        # Compute iteration-level win/draw/loss rates from finished episodes
+        if len(iter_outcomes) > 0:
+            wins = sum(1 for o in iter_outcomes if o == 1)
+            draws = sum(1 for o in iter_outcomes if o == 0)
+            losses = sum(1 for o in iter_outcomes if o == -1)
+            total_eps = len(iter_outcomes)
+            win_rate = wins / total_eps
+            draw_rate = draws / total_eps
+            loss_rate = losses / total_eps
+            avg_ep_return = float(np.mean(iter_ep_returns)) if len(iter_ep_returns) else 0.0
+            recent_winrates.append(win_rate)
+            if winrate_ema is None:
+                winrate_ema = win_rate
+            else:
+                winrate_ema = 0.1 * win_rate + 0.9 * winrate_ema
+            winrate_std_50 = float(np.std(list(recent_winrates))) if len(recent_winrates) > 1 else 0.0
+        else:
+            win_rate = draw_rate = loss_rate = avg_ep_return = 0.0
+            winrate_std_50 = float(np.std(list(recent_winrates))) if len(recent_winrates) > 1 else 0.0
+            if winrate_ema is None:
+                winrate_ema = 0.0
+
+        print(f"[{progress:5.1f}%] Iter {iteration:4d} | SPS: {sps:4d} | Rew: {rewards.mean().item():.3f} | PLoss: {pg_loss.item():.3f} | VLoss: {v_loss.item():.3f} | WinRate: {win_rate:.3f} (EMA {winrate_ema:.3f})")
+
+        if args.track:
+            import wandb
+            wandb.log({
+                "charts/avg_reward": float(rewards.mean().item()),
+                "losses/policy_loss": float(pg_loss.item()),
+                "losses/value_loss": float(v_loss.item()),
+                "global_step": global_step,
+                "charts/SPS": sps,
+                "charts/win_rate": float(win_rate),
+                "charts/draw_rate": float(draw_rate),
+                "charts/loss_rate": float(loss_rate),
+                "charts/avg_ep_return": float(avg_ep_return),
+                "charts/winrate_ema": float(winrate_ema),
+                "charts/winrate_std_50": float(winrate_std_50),
+            })
+
+        # Eval
+        if iteration == 1 or iteration % eval_every_iters == 0:
+            print(f"Running evaluation at step {global_step}...")
+            try:
+                def eval_thunk():
+                    return make_env(0, run_name, args.seed + 9999, False)()
+                eval_metrics = collect_eval_trajectories(agent, eval_thunk, n_episodes=args.eval_episodes, step_tag=global_step)
+                if args.track:
+                    import wandb
+                    wandb.log({
+                        "eval/success_rate": float(eval_metrics.get("success_rate", 0.0)),
+                        "eval/avg_return": float(eval_metrics.get("avg_return", 0.0)),
+                        "global_step": global_step,
+                    })
+            except Exception as e:
+                print(f"Eval failed: {e}")
+
+    envs.close()

cleanrl/cleanrl/ppo_continuous_action_isaacgym/ppo_continuous_action_isaacgym.py

@@ -0,0 +1,393 @@
+# Copyright (c) 2018-2022, NVIDIA Corporation
+# All rights reserved.
+#
+# 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.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+#    contributors may be used to endorse or promote products derived from
+#    this software without specific prior written permission.
+#
+# 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 HOLDER 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.
+
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_continuous_action_isaacgympy
+import os
+import random
+import time
+from dataclasses import dataclass
+
+import gym
+import isaacgym  # noqa
+import isaacgymenvs
+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)"""
+
+    # Algorithm specific arguments
+    env_id: str = "Ant"
+    """the id of the environment"""
+    total_timesteps: int = 30000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 0.0026
+    """the learning rate of the optimizer"""
+    num_envs: int = 4096
+    """the number of parallel game environments"""
+    num_steps: int = 16
+    """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.99
+    """the discount factor gamma"""
+    gae_lambda: float = 0.95
+    """the lambda for the general advantage estimation"""
+    num_minibatches: int = 2
+    """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 = False
+    """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 = 2
+    """coefficient of the value function"""
+    max_grad_norm: float = 1
+    """the maximum norm for the gradient clipping"""
+    target_kl: float = None
+    """the target KL divergence threshold"""
+    reward_scaler: float = 1
+    """the scale factor applied to the reward during training"""
+    record_video_step_frequency: int = 1464
+    """the frequency at which to record the videos"""
+
+    # 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 RecordEpisodeStatisticsTorch(gym.Wrapper):
+    def __init__(self, env, device):
+        super().__init__(env)
+        self.num_envs = getattr(env, "num_envs", 1)
+        self.device = device
+        self.episode_returns = None
+        self.episode_lengths = None
+
+    def reset(self, **kwargs):
+        observations = super().reset(**kwargs)
+        self.episode_returns = torch.zeros(self.num_envs, dtype=torch.float32, device=self.device)
+        self.episode_lengths = torch.zeros(self.num_envs, dtype=torch.int32, device=self.device)
+        self.returned_episode_returns = torch.zeros(self.num_envs, dtype=torch.float32, device=self.device)
+        self.returned_episode_lengths = torch.zeros(self.num_envs, dtype=torch.int32, device=self.device)
+        return observations
+
+    def step(self, action):
+        observations, rewards, dones, infos = super().step(action)
+        self.episode_returns += rewards
+        self.episode_lengths += 1
+        self.returned_episode_returns[:] = self.episode_returns
+        self.returned_episode_lengths[:] = self.episode_lengths
+        self.episode_returns *= 1 - dones
+        self.episode_lengths *= 1 - dones
+        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.critic = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 1), std=1.0),
+        )
+        self.actor_mean = nn.Sequential(
+            layer_init(nn.Linear(np.array(envs.single_observation_space.shape).prod(), 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, 256)),
+            nn.Tanh(),
+            layer_init(nn.Linear(256, np.prod(envs.single_action_space.shape)), std=0.01),
+        )
+        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)
+
+
+class ExtractObsWrapper(gym.ObservationWrapper):
+    def observation(self, obs):
+        return obs["obs"]
+
+
+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 = isaacgymenvs.make(
+        seed=args.seed,
+        task=args.env_id,
+        num_envs=args.num_envs,
+        sim_device="cuda:0" if torch.cuda.is_available() and args.cuda else "cpu",
+        rl_device="cuda:0" if torch.cuda.is_available() and args.cuda else "cpu",
+        graphics_device_id=0 if torch.cuda.is_available() and args.cuda else -1,
+        headless=False if torch.cuda.is_available() and args.cuda else True,
+        multi_gpu=False,
+        virtual_screen_capture=args.capture_video,
+        force_render=False,
+    )
+    if args.capture_video:
+        envs.is_vector_env = True
+        print(f"record_video_step_frequency={args.record_video_step_frequency}")
+        envs = gym.wrappers.RecordVideo(
+            envs,
+            f"videos/{run_name}",
+            step_trigger=lambda step: step % args.record_video_step_frequency == 0,
+            video_length=100,  # for each video record up to 100 steps
+        )
+    envs = ExtractObsWrapper(envs)
+    envs = RecordEpisodeStatisticsTorch(envs, device)
+    envs.single_action_space = envs.action_space
+    envs.single_observation_space = envs.observation_space
+    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, dtype=torch.float).to(device)
+    actions = torch.zeros((args.num_steps, args.num_envs) + envs.single_action_space.shape, dtype=torch.float).to(device)
+    logprobs = torch.zeros((args.num_steps, args.num_envs), dtype=torch.float).to(device)
+    rewards = torch.zeros((args.num_steps, args.num_envs), dtype=torch.float).to(device)
+    dones = torch.zeros((args.num_steps, args.num_envs), dtype=torch.float).to(device)
+    values = torch.zeros((args.num_steps, args.num_envs), dtype=torch.float).to(device)
+    advantages = torch.zeros_like(rewards, dtype=torch.float).to(device)
+
+    # TRY NOT TO MODIFY: start the game
+    global_step = 0
+    start_time = time.time()
+    next_obs = envs.reset()
+    next_done = torch.zeros(args.num_envs, dtype=torch.float).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, rewards[step], next_done, info = envs.step(action)
+            if 0 <= step <= 2:
+                for idx, d in enumerate(next_done):
+                    if d:
+                        episodic_return = info["r"][idx].item()
+                        print(f"global_step={global_step}, episodic_return={episodic_return}")
+                        writer.add_scalar("charts/episodic_return", episodic_return, global_step)
+                        writer.add_scalar("charts/episodic_length", info["l"][idx], global_step)
+                        if "consecutive_successes" in info:  # ShadowHand and AllegroHand metric
+                            writer.add_scalar(
+                                "charts/consecutive_successes", info["consecutive_successes"].item(), 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)
+
+        # Optimizing the policy and value network
+        clipfracs = []
+        for epoch in range(args.update_epochs):
+            b_inds = torch.randperm(args.batch_size, device=device)
+            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
+
+        # 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)
+        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_frozenlake.py

@@ -0,0 +1,567 @@
+# PPO implementation for RAGEN FrozenLake environment
+import os
+import random
+import time
+from dataclasses import dataclass
+import json
+from pathlib import Path
+
+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.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+from ragen_wrappers import FrozenLakeWrapper
+
+
+@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 = "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 = "FrozenLake"
+    """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 = 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.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"""
+    save_plots: bool = True
+    """whether to save PNG/CSV curves for training trend"""
+    eval_splits: int = 5
+    """number of test checkpoints (every 1/eval_splits of training)"""
+    eval_episodes: int = 4000
+    """number of test trajectories to collect per checkpoint"""
+    
+    # FrozenLake specific
+    grid_size: int = 4
+    """size of the frozen lake grid"""
+    is_slippery: bool = True
+    """whether the ice is slippery"""
+
+    # 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, grid_size, is_slippery):
+    def thunk():
+        config = FrozenLakeEnvConfig(
+            size=grid_size,
+            p=0.8,
+            is_slippery=is_slippery,
+            map_seed=seed + idx
+        )
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        # Add a time limit to prevent infinite loops during evaluation/training
+        max_steps = int(grid_size * grid_size * 4)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        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, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 1), std=1.0),
+        )
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(obs_shape, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 128)),
+            nn.Tanh(),
+            layer_init(nn.Linear(128, 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,
+        )
+        # Define step metric and groups for better chart organization
+        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
+    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, args.grid_size, args.is_slippery) 
+         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)
+
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+    # Helper: evaluate greedy policy rollout and dump trajectories
+    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:
+                # Make sure to reseed and also guard against long 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.grid_size * args.grid_size * 4)
+                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.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()
+        # write summary metrics
+        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}")
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+    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)
+            # Vectorized episode end handling: use RecordEpisodeStatistics outputs
+            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):
+                    # For each finished sub-env, log its episode stats
+                    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)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        ep_r = float(r_arr[i])
+                        ep_l = int(l_arr[i])
+                        ep_succ = float(succ_arr[i])
+                        episode_returns.append(ep_r)
+                        episode_steps.append(global_step)
+                        episode_successes.append(ep_succ)
+                        # print(f"global_step={global_step}, episodic_return={ep_r}")
+                        writer.add_scalar("charts/episodic_return", ep_r, global_step)
+                        writer.add_scalar("charts/episodic_length", ep_l, global_step)
+                        writer.add_scalar("charts/success", ep_succ, global_step)
+                    if len(episode_successes) >= 100:
+                        writer.add_scalar("charts/success_rate_100", float(np.mean(episode_successes[-100:])), global_step)
+                    if args.track:
+                        try:
+                            import wandb
+                            log_dict = {
+                                "global_step": int(global_step),
+                                # per-step averages across finished episodes
+                                "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,
+                            }
+                            # Also log the latest episode stats individually for convenience
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 else None,
+                                })
+                            wandb.log(log_dict, step=global_step)
+                        except Exception:
+                            pass
+            except Exception:
+                # Be robust to any unexpected info structure
+                pass
+
+        # 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)
+        # Mirror key metrics to W&B explicitly (in addition to TB sync)
+        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()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "train/clipfrac": float(np.mean(clipfracs)),
+                    "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(args.env_id, 0, False, run_name, args.seed + 9999, args.grid_size, args.is_slippery)
+                # collect trajectories and write metrics.json
+                collect_eval_trajectories(agent, eval_thunk, args.eval_episodes, step_tag=global_step)
+                # also log summary metrics to W&B
+                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)
+                            import wandb
+                            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()
+    writer.close()
+    # Persist episodic log and optional plot for visible trend
+    try:
+        import csv
+        from pathlib import Path
+        out_dir = Path(f"runs/{run_name}")
+        out_dir.mkdir(parents=True, exist_ok=True)
+        csv_path = out_dir / "episodic_log.csv"
+        with csv_path.open("w", newline="") as f:
+            writer_csv = csv.writer(f)
+            writer_csv.writerow(["global_step", "episode_return"]) 
+            for s, r in zip(episode_steps, episode_returns):
+                writer_csv.writerow([int(s), float(r)])
+        print(f"Saved episodic CSV to {csv_path}")
+    except Exception as e:
+        print(f"Warning: failed to save episodic CSV: {e}")
+
+    if args.save_plots and len(episode_returns) > 0:
+        try:
+            import matplotlib.pyplot as plt
+            import numpy as np
+            def moving_avg(x, w=50):
+                if len(x) == 0:
+                    return np.array([])
+                w = max(1, min(w, len(x)))
+                c = np.cumsum(np.insert(x, 0, 0))
+                return (c[w:] - c[:-w]) / float(w)
+            fig, ax = plt.subplots(1, 1, figsize=(8, 4))
+            ax.plot(episode_steps, episode_returns, alpha=0.3, label="return")
+            ma = moving_avg(episode_returns, w=50)
+            if len(ma) > 0:
+                ax.plot(episode_steps[49:], ma, label="MA@50")
+            ax.set_title("FrozenLake: Episodic Return")
+            ax.set_xlabel("global_step")
+            ax.set_ylabel("return")
+            ax.legend()
+            png_path = f"runs/{run_name}/training_curve.png"
+            fig.tight_layout()
+            plt.savefig(png_path)
+            plt.close(fig)
+            print(f"Saved training curve to {png_path}")
+        except Exception as e:
+            print(f"Warning: failed to save training plot: {e}")

cleanrl/cleanrl/ppo_frozenlake_nochangeenv.py

@@ -0,0 +1,494 @@
+# PPO with small MLP for RAGEN FrozenLake 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
+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.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+
+# python /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake_nochangeenv.py --total-timesteps 2000000 --num-envs 8 --num-steps 128 --grid-size 4 --is-slippery --track
+class FrozenLakeWrapper(gym.Env):
+    """
+    Adapter to use ragen FrozenLakeEnv with Gymnasium vector API.
+    - Converts text observation to one-hot grid vector (6 tokens per cell).
+    - Maps agent actions [0..3] to env actions [1..4].
+    - Exposes proper observation_space and action_space.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: FrozenLakeEnv):
+        super().__init__()
+        self._env = env
+        self._size = int(self._env.nrow)  # square grid
+        self._tokens = ['P', '_', 'O', 'G', 'X', '√']
+        self._token_to_idx = {t: i for i, t in enumerate(self._tokens)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * len(self._tokens),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # text_obs is multi-line grid with tokens above
+        rows = text_obs.split('\n')
+        # handle any accidental extra whitespace
+        rows = [list(r) for r in rows if len(r) > 0]
+        h = len(rows)
+        w = len(rows[0]) if h > 0 else self._size
+        grid = np.zeros((h, w, len(self._tokens)), dtype=np.float32)
+        for i in range(h):
+            for j in range(w):
+                ch = rows[i][j]
+                idx = self._token_to_idx.get(ch, 0)
+                grid[i, j, idx] = 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):
+        # map 0..3 -> 1..4 for the underlying env
+        mapped = int(action) + 1
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        # propagate success if present
+        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 = "FrozenLake"
+    total_timesteps: int = 200_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
+
+    # FrozenLake specific
+    grid_size: int = 4
+    is_slippery: bool = False
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    # eval config to mirror reference script
+    eval_splits: int = 20
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, is_slippery, capture_video=False):
+    def thunk():
+        config = FrozenLakeEnvConfig(size=grid_size, p=0.8, success_rate = 0.8, is_slippery=is_slippery, map_seed=seed + idx, render_mode='text')
+        # import pdb;pdb.set_trace()
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        max_steps = int(grid_size * grid_size * 4)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        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 = 64
+        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.grid_size, args.is_slippery, 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)
+
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper identical to reference
+    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.grid_size * args.grid_size * 4)
+                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.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}")
+
+    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
+
+        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 as in reference
+            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)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        ep_r = float(r_arr[i])
+                        ep_l = int(l_arr[i])
+                        ep_succ = float(succ_arr[i])
+                        episode_returns.append(ep_r)
+                        episode_steps.append(global_step)
+                        episode_successes.append(ep_succ)
+                    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,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 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
+
+        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()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "train/clipfrac": float(np.mean(clipfracs)),
+                    "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==1 or iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.grid_size, args.is_slippery, 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/ppo_pettingzoo_ma_atari.py

@@ -0,0 +1,313 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/ppo/#ppo_pettingzoo_ma_ataripy
+import argparse
+import importlib
+import os
+import random
+import time
+from distutils.util import strtobool
+
+import gym
+import numpy as np
+import supersuit as ss
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.distributions.categorical import Categorical
+from torch.utils.tensorboard import SummaryWriter
+
+
+def parse_args():
+    # fmt: off
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--exp-name", type=str, default=os.path.basename(__file__).rstrip(".py"),
+        help="the name of this experiment")
+    parser.add_argument("--seed", type=int, default=1,
+        help="seed of the experiment")
+    parser.add_argument("--torch-deterministic", type=lambda x: bool(strtobool(x)), default=True, nargs="?", const=True,
+        help="if toggled, `torch.backends.cudnn.deterministic=False`")
+    parser.add_argument("--cuda", type=lambda x: bool(strtobool(x)), default=True, nargs="?", const=True,
+        help="if toggled, cuda will be enabled by default")
+    parser.add_argument("--track", type=lambda x: bool(strtobool(x)), default=False, nargs="?", const=True,
+        help="if toggled, this experiment will be tracked with Weights and Biases")
+    parser.add_argument("--wandb-project-name", type=str, default="cleanRL",
+        help="the wandb's project name")
+    parser.add_argument("--wandb-entity", type=str, default=None,
+        help="the entity (team) of wandb's project")
+    parser.add_argument("--capture_video", type=lambda x: bool(strtobool(x)), default=False, nargs="?", const=True,
+        help="whether to capture videos of the agent performances (check out `videos` folder)")
+
+    # Algorithm specific arguments
+    parser.add_argument("--env-id", type=str, default="pong_v3",
+        help="the id of the environment")
+    parser.add_argument("--total-timesteps", type=int, default=20000000,
+        help="total timesteps of the experiments")
+    parser.add_argument("--learning-rate", type=float, default=2.5e-4,
+        help="the learning rate of the optimizer")
+    parser.add_argument("--num-envs", type=int, default=16,
+        help="the number of parallel game environments")
+    parser.add_argument("--num-steps", type=int, default=128,
+        help="the number of steps to run in each environment per policy rollout")
+    parser.add_argument("--anneal-lr", type=lambda x: bool(strtobool(x)), default=True, nargs="?", const=True,
+        help="Toggle learning rate annealing for policy and value networks")
+    parser.add_argument("--gamma", type=float, default=0.99,
+        help="the discount factor gamma")
+    parser.add_argument("--gae-lambda", type=float, default=0.95,
+        help="the lambda for the general advantage estimation")
+    parser.add_argument("--num-minibatches", type=int, default=4,
+        help="the number of mini-batches")
+    parser.add_argument("--update-epochs", type=int, default=4,
+        help="the K epochs to update the policy")
+    parser.add_argument("--norm-adv", type=lambda x: bool(strtobool(x)), default=True, nargs="?", const=True,
+        help="Toggles advantages normalization")
+    parser.add_argument("--clip-coef", type=float, default=0.1,
+        help="the surrogate clipping coefficient")
+    parser.add_argument("--clip-vloss", type=lambda x: bool(strtobool(x)), default=True, nargs="?", const=True,
+        help="Toggles whether or not to use a clipped loss for the value function, as per the paper.")
+    parser.add_argument("--ent-coef", type=float, default=0.01,
+        help="coefficient of the entropy")
+    parser.add_argument("--vf-coef", type=float, default=0.5,
+        help="coefficient of the value function")
+    parser.add_argument("--max-grad-norm", type=float, default=0.5,
+        help="the maximum norm for the gradient clipping")
+    parser.add_argument("--target-kl", type=float, default=None,
+        help="the target KL divergence threshold")
+    args = parser.parse_args()
+    args.batch_size = int(args.num_envs * args.num_steps)
+    args.minibatch_size = int(args.batch_size // args.num_minibatches)
+    # fmt: on
+    return args
+
+
+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(6, 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):
+        x = x.clone()
+        x[:, :, :, [0, 1, 2, 3]] /= 255.0
+        return self.critic(self.network(x.permute((0, 3, 1, 2))))
+
+    def get_action_and_value(self, x, action=None):
+        x = x.clone()
+        x[:, :, :, [0, 1, 2, 3]] /= 255.0
+        hidden = self.network(x.permute((0, 3, 1, 2)))
+        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 = parse_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,
+            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
+    env = importlib.import_module(f"pettingzoo.atari.{args.env_id}").parallel_env()
+    env = ss.max_observation_v0(env, 2)
+    env = ss.frame_skip_v0(env, 4)
+    env = ss.clip_reward_v0(env, lower_bound=-1, upper_bound=1)
+    env = ss.color_reduction_v0(env, mode="B")
+    env = ss.resize_v1(env, x_size=84, y_size=84)
+    env = ss.frame_stack_v1(env, 4)
+    env = ss.agent_indicator_v0(env, type_only=False)
+    env = ss.pettingzoo_env_to_vec_env_v1(env)
+    envs = ss.concat_vec_envs_v1(env, args.num_envs // 2, num_cpus=0, base_class="gym")
+    envs.single_observation_space = envs.observation_space
+    envs.single_action_space = envs.action_space
+    envs.is_vector_env = True
+    envs = gym.wrappers.RecordEpisodeStatistics(envs)
+    if args.capture_video:
+        envs = gym.wrappers.RecordVideo(envs, f"videos/{run_name}")
+    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 = torch.Tensor(envs.reset()).to(device)
+    next_done = torch.zeros(args.num_envs).to(device)
+    num_updates = args.total_timesteps // args.batch_size
+
+    for update in range(1, num_updates + 1):
+        # Annealing the rate if instructed to do so.
+        if args.anneal_lr:
+            frac = 1.0 - (update - 1.0) / num_updates
+            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 idx, item in enumerate(info):
+                player_idx = idx % 2
+                if "episode" in item.keys():
+                    print(f"global_step={global_step}, {player_idx}-episodic_return={item['episode']['r']}")
+                    writer.add_scalar(f"charts/episodic_return-player{player_idx}", item["episode"]["r"], global_step)
+                    writer.add_scalar(f"charts/episodic_length-player{player_idx}", item["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:
+                if 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_sudoku.py

@@ -0,0 +1,538 @@
+# PPO with small MLP for RAGEN Sudoku 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 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.sudoku.env import SudokuEnv
+from ragen.env.sudoku.config import SudokuEnvConfig
+
+
+class SudokuWrapper(gym.Env):
+    """
+    Adapter to use ragen SudokuEnv with Gymnasium vector API.
+    - Converts text observation (simple format) to one-hot grid vector ((GxG) * (G+1)).
+    - Maps discrete action id to action string "row,col,num" (1-indexed) for the env.
+    - Exposes proper observation_space and action_space.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: SudokuEnv, grid_size: int):
+        super().__init__()
+        self._env = env
+        self._size = grid_size
+        # observation: one-hot per cell for value in {0..grid_size}, 0 denotes empty
+        self._val_dim = self._size + 1
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * self._val_dim,), dtype=np.float32)
+        # actions: (row, col, num) with row/col in [0..G-1], num in [1..G]
+        self._act_n = self._size * self._size * self._size
+        self.action_space = gym.spaces.Discrete(self._act_n)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # Parse the 'simple' grid format; skip separator lines and '|' tokens
+        vals: List[int] = []
+        for line in text_obs.splitlines():
+            ls = line.strip()
+            if len(ls) == 0:
+                continue
+            # separator lines look like '-----' etc.
+            if set(ls) <= {'-'}:
+                continue
+            tokens = [t for t in ls.split() if t != '|']
+            # tolerate short lines (e.g., headers) by skipping
+            if len(tokens) == 0:
+                continue
+            for t in tokens:
+                if t == '.':
+                    vals.append(0)
+                else:
+                    # numeric token (handles multi-digit for 16x16)
+                    try:
+                        v = int(t)
+                    except ValueError:
+                        # unexpected token, treat as empty
+                        v = 0
+                    vals.append(v)
+        # Ensure we have exactly G*G cells; if more due to formatting, crop; if less, pad
+        target = self._size * self._size
+        if len(vals) < target:
+            vals.extend([0] * (target - len(vals)))
+        if len(vals) > target:
+            vals = vals[:target]
+        # One-hot encode
+        grid = np.zeros((target, self._val_dim), dtype=np.float32)
+        for i, v in enumerate(vals):
+            v_clamped = int(v)
+            if v_clamped < 0 or v_clamped > self._size:
+                v_clamped = 0
+            grid[i, v_clamped] = 1.0
+        return grid.reshape(-1)
+
+    @staticmethod
+    def _decode_action(action_id: int, grid_size: int) -> Tuple[int, int, int]:
+        # Map discrete id -> (row, col, num) with 0-index row/col, 1-index num
+        g = grid_size
+        row = action_id // (g * g)
+        rem = action_id % (g * g)
+        col = rem // g
+        num = (rem % g) + 1
+        return row, col, num
+
+    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):
+        row, col, num = self._decode_action(int(action), self._size)
+        # env expects 1-indexed row/col in action string
+        act_str = f"{row+1},{col+1},{num}"
+        text_obs, reward, done, info = self._env.step(act_str)
+        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 = "Sudoku"
+    total_timesteps: int = 2000_000
+    learning_rate: float = 3e-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
+
+    # Sudoku specific
+    grid_size: int = 4  # 4 or 9 recommended
+    difficulty: str = "easy"  # easy/medium/hard
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+
+    # eval
+    eval_splits: int = 2
+    eval_episodes: int = 4000
+
+
+def make_env(idx, run_name, seed, grid_size, difficulty, capture_video=False):
+    def thunk():
+        config = SudokuEnvConfig(
+            grid_size=grid_size,
+            difficulty=difficulty,
+            render_mode='text',
+            render_format='simple',  # easier to parse; no env modification
+        )
+        env = SudokuEnv(config)
+        env = SudokuWrapper(env, grid_size)
+        # Use env's own max_steps default if available, otherwise a sane cap
+        max_steps = int(grid_size * grid_size * 6)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        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.grid_size, args.difficulty, 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)
+    
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper identical to FrozenLake script
+    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 + 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.grid_size * args.grid_size * 6)
+                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())
+                        probs = Categorical(logits=logits)
+                        action = int(probs.sample().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.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}")
+
+    eval_every_iters = max(1, args.num_iterations // args.eval_splits)
+
+    # training loop
+    for iteration in range(1, args.num_iterations + 1):
+        # Anneal LR
+        if args.anneal_lr:
+            frac = 1.0 - (iteration - 1.0) / args.num_iterations
+            optimizer.param_groups[0]["lr"] = frac * args.learning_rate
+
+        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 as in 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)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        ep_r = float(r_arr[i])
+                        ep_l = int(l_arr[i])
+                        ep_succ = float(succ_arr[i])
+                        episode_returns.append(ep_r)
+                        episode_steps.append(global_step)
+                        episode_successes.append(ep_succ)
+                    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,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 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)
+        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
+
+        # logging
+        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()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.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.grid_size, args.difficulty, 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/ppo_trxl/enjoy.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+
+import gymnasium as gym
+import torch
+import tyro
+from ppo_trxl import Agent, make_env
+
+
+@dataclass
+class Args:
+    hub: bool = False
+    """whether to load the model from the huggingface hub or from the local disk"""
+    name: str = "Endless-MortarMayhem-v0_12.nn"
+    """path to the model file"""
+
+
+if __name__ == "__main__":
+    # Parse command line arguments and retrieve model path
+    cli_args = tyro.cli(Args)
+    if cli_args.hub:
+        try:
+            from huggingface_hub import hf_hub_download
+
+            path = hf_hub_download(repo_id="LilHairdy/cleanrl_memory_gym", filename=cli_args.name)
+        except:
+            raise RuntimeError(
+                "Cannot load model from the huggingface hub. Please install the huggingface_hub pypi package and verify the model name. You can also download the model from the hub manually and load it from disk."
+            )
+    else:
+        path = cli_args.name
+
+    # Load the pre-trained model and the original args used to train it
+    checkpoint = torch.load(path)
+    args = checkpoint["args"]
+    args = type("Args", (), args)
+
+    # Init environment and reset
+    env = make_env(args.env_id, 0, False, "", "human")()
+    obs, _ = env.reset()
+    env.render()
+
+    # Determine maximum episode steps
+    max_episode_steps = env.spec.max_episode_steps
+    if not max_episode_steps:
+        max_episode_steps = env.max_episode_steps
+    if max_episode_steps <= 0:
+        max_episode_steps = 1024  # Memory Gym envs have max_episode_steps set to -1
+        # May episode impacts positional encoding, so make sure to set this accordingly
+
+    # Setup agent and load its model parameters
+    action_space_shape = (
+        (env.action_space.n,) if isinstance(env.action_space, gym.spaces.Discrete) else tuple(env.action_space.nvec)
+    )
+    agent = Agent(args, env.observation_space, action_space_shape, max_episode_steps)
+    agent.load_state_dict(checkpoint["model_weights"])
+
+    # Setup Transformer-XL memory, mask and indices
+    memory = torch.zeros((1, max_episode_steps, args.trxl_num_layers, args.trxl_dim), dtype=torch.float32)
+    memory_mask = torch.tril(torch.ones((args.trxl_memory_length, args.trxl_memory_length)), diagonal=-1)
+    repetitions = torch.repeat_interleave(
+        torch.arange(0, args.trxl_memory_length).unsqueeze(0), args.trxl_memory_length - 1, dim=0
+    ).long()
+    memory_indices = torch.stack(
+        [torch.arange(i, i + args.trxl_memory_length) for i in range(max_episode_steps - args.trxl_memory_length + 1)]
+    ).long()
+    memory_indices = torch.cat((repetitions, memory_indices))
+
+    # Run episode
+    done = False
+    t = 0
+    while not done:
+        # Prepare observation and memory
+        obs = torch.Tensor(obs).unsqueeze(0)
+        memory_window = memory[0, memory_indices[t].unsqueeze(0)]
+        t_ = max(0, min(t, args.trxl_memory_length - 1))
+        mask = memory_mask[t_].unsqueeze(0)
+        indices = memory_indices[t].unsqueeze(0)
+        # Forward agent
+        action, _, _, _, new_memory = agent.get_action_and_value(obs, memory_window, mask, indices)
+        memory[:, t] = new_memory
+        # Step
+        obs, reward, termination, truncation, info = env.step(action.cpu().squeeze().numpy())
+        env.render()
+        done = termination or truncation
+        t += 1
+
+    if "r" in info["episode"].keys():
+        print(f"Episode return: {info['episode']['r'][0]}, Episode length: {info['episode']['l'][0]}")
+    else:
+        print(f"Episode return: {info['reward']}, Episode length: {info['length']}")
+    env.close()

cleanrl/cleanrl/pqn_atari_envpool.py

@@ -0,0 +1,291 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/pqn/#pqn_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.nn.functional as F
+import torch.optim as optim
+import tyro
+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"""
+    num_minibatches: int = 4
+    """the number of mini-batches"""
+    update_epochs: int = 4
+    """the K epochs to update the policy"""
+    max_grad_norm: float = 10.0
+    """the maximum norm for the gradient clipping"""
+    start_e: float = 1
+    """the starting epsilon for exploration"""
+    end_e: float = 0.01
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.10
+    """the fraction of `total_timesteps` it takes from start_e to end_e"""
+    q_lambda: float = 0.65
+    """the lambda for the Q-Learning algorithm"""
+
+    # 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 QNetwork(nn.Module):
+    def __init__(self, env):
+        super().__init__()
+        self.network = nn.Sequential(
+            layer_init(nn.Conv2d(4, 32, 8, stride=4)),
+            nn.LayerNorm([32, 20, 20]),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(32, 64, 4, stride=2)),
+            nn.LayerNorm([64, 9, 9]),
+            nn.ReLU(),
+            layer_init(nn.Conv2d(64, 64, 3, stride=1)),
+            nn.LayerNorm([64, 7, 7]),
+            nn.ReLU(),
+            nn.Flatten(),
+            layer_init(nn.Linear(3136, 512)),
+            nn.LayerNorm(512),
+            nn.ReLU(),
+            layer_init(nn.Linear(512, env.single_action_space.n)),
+        )
+
+    def forward(self, x):
+        return self.network(x / 255.0)
+
+
+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)
+    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"
+
+    q_network = QNetwork(envs).to(device)
+    optimizer = optim.RAdam(q_network.parameters(), lr=args.learning_rate)
+
+    # 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)
+    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
+
+            epsilon = linear_schedule(args.start_e, args.end_e, args.exploration_fraction * args.total_timesteps, global_step)
+
+            random_actions = torch.randint(0, envs.single_action_space.n, (args.num_envs,)).to(device)
+            with torch.no_grad():
+                q_values = q_network(next_obs)
+                max_actions = torch.argmax(q_values, dim=1)
+                values[step] = q_values[torch.arange(args.num_envs), max_actions].flatten()
+
+            explore = torch.rand((args.num_envs,)).to(device) < epsilon
+            action = torch.where(explore, random_actions, max_actions)
+            actions[step] = action
+
+            # 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)
+
+        # Compute Q(lambda) targets
+        with torch.no_grad():
+            returns = torch.zeros_like(rewards).to(device)
+            for t in reversed(range(args.num_steps)):
+                if t == args.num_steps - 1:
+                    next_value, _ = torch.max(q_network(next_obs), dim=-1)
+                    nextnonterminal = 1.0 - next_done
+                    returns[t] = rewards[t] + args.gamma * next_value * nextnonterminal
+                else:
+                    nextnonterminal = 1.0 - dones[t + 1]
+                    next_value = values[t + 1]
+                    returns[t] = (
+                        rewards[t]
+                        + args.gamma * (args.q_lambda * returns[t + 1] + (1 - args.q_lambda) * next_value) * nextnonterminal
+                    )
+
+        # flatten the batch
+        b_obs = obs.reshape((-1,) + envs.single_observation_space.shape)
+        b_actions = actions.reshape((-1,) + envs.single_action_space.shape)
+        b_returns = returns.reshape(-1)
+
+        # Optimizing the Q-network
+        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]
+
+                old_val = q_network(b_obs[mb_inds]).gather(1, b_actions[mb_inds].unsqueeze(-1).long()).squeeze()
+                loss = F.mse_loss(b_returns[mb_inds], old_val)
+
+                # optimize the model
+                optimizer.zero_grad()
+                loss.backward()
+                nn.utils.clip_grad_norm_(q_network.parameters(), args.max_grad_norm)
+                optimizer.step()
+
+        writer.add_scalar("losses/td_loss", loss, global_step)
+        writer.add_scalar("losses/q_values", old_val.mean().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)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/qdagger_dqn_atari_jax_impalacnn.py

@@ -0,0 +1,475 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/qdagger/#qdagger_dqn_atari_jax_impalacnnpy
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+from typing import Sequence
+
+# see https://github.com/google/jax/discussions/6332#discussioncomment-1279991
+os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.7"
+
+import flax
+import flax.linen as nn
+import gymnasium as gym
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import tyro
+from flax.training.train_state import TrainState
+from huggingface_hub import hf_hub_download
+from rich.progress import track
+from torch.utils.tensorboard import SummaryWriter
+
+from cleanrl.dqn_atari_jax import QNetwork as TeacherModel
+from cleanrl_utils.atari_wrappers import (
+    ClipRewardEnv,
+    EpisodicLifeEnv,
+    FireResetEnv,
+    MaxAndSkipEnv,
+    NoopResetEnv,
+)
+from cleanrl_utils.buffers import ReplayBuffer
+from cleanrl_utils.evals.dqn_jax_eval import evaluate
+
+
+@dataclass
+class Args:
+    exp_name: str = os.path.basename(__file__)[: -len(".py")]
+    """the name of this experiment"""
+    seed: int = 1
+    """seed of the experiment"""
+    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 = "BreakoutNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 1e-4
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments"""
+    buffer_size: int = 1000000
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 1.0
+    """the target network update rate"""
+    target_network_frequency: int = 1000
+    """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.01
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.10
+    """the fraction of `total-timesteps` it takes from start-e to go end-e"""
+    learning_starts: int = 80000
+    """timestep to start learning"""
+    train_frequency: int = 4
+    """the frequency of training"""
+
+    # QDagger specific arguments
+    teacher_policy_hf_repo: str = None
+    """the huggingface repo of the teacher policy"""
+    teacher_model_exp_name: str = "dqn_atari_jax"
+    """the experiment name of the teacher model"""
+    teacher_eval_episodes: int = 10
+    """the number of episodes to run the teacher policy evaluate"""
+    teacher_steps: int = 500000
+    """the number of steps to run the teacher policy to generate the replay buffer"""
+    offline_steps: int = 500000
+    """the number of steps to run the student policy with the teacher's replay buffer"""
+    temperature: float = 1.0
+    """the temperature parameter for qdagger"""
+
+
+def make_env(env_id, seed, 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)
+        env.action_space.seed(seed)
+
+        return env
+
+    return thunk
+
+
+# taken from https://github.com/AIcrowd/neurips2020-procgen-starter-kit/blob/142d09586d2272a17f44481a115c4bd817cf6a94/models/impala_cnn_torch.py
+class ResidualBlock(nn.Module):
+    channels: int
+
+    @nn.compact
+    def __call__(self, x):
+        inputs = x
+        x = nn.relu(x)
+        x = nn.Conv(
+            self.channels,
+            kernel_size=(3, 3),
+        )(x)
+        x = nn.relu(x)
+        x = nn.Conv(
+            self.channels,
+            kernel_size=(3, 3),
+        )(x)
+        return x + inputs
+
+
+class ConvSequence(nn.Module):
+    channels: int
+
+    @nn.compact
+    def __call__(self, x):
+        x = nn.Conv(
+            self.channels,
+            kernel_size=(3, 3),
+        )(x)
+        x = nn.max_pool(x, window_shape=(3, 3), strides=(2, 2), padding="SAME")
+        x = ResidualBlock(self.channels)(x)
+        x = ResidualBlock(self.channels)(x)
+        return x
+
+
+# ALGO LOGIC: initialize agent here:
+class QNetwork(nn.Module):
+    action_dim: int
+    channelss: Sequence[int] = (16, 32, 32)
+
+    @nn.compact
+    def __call__(self, x):
+        x = jnp.transpose(x, (0, 2, 3, 1))
+        x = x / (255.0)
+        for channels in self.channelss:
+            x = ConvSequence(channels)(x)
+        x = nn.relu(x)
+        x = x.reshape((x.shape[0], -1))
+        x = nn.Dense(256)(x)
+        x = nn.relu(x)
+        x = nn.Dense(self.action_dim)(x)
+        return x
+
+
+class TrainState(TrainState):
+    target_params: flax.core.FrozenDict
+
+
+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"
+    if args.teacher_policy_hf_repo is None:
+        args.teacher_policy_hf_repo = f"cleanrl/{args.env_id}-{args.teacher_model_exp_name}-seed1"
+    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, q_key = jax.random.split(key, 2)
+
+    # env setup
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, 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"
+
+    q_network = QNetwork(channelss=(16, 32, 32), action_dim=envs.single_action_space.n)
+
+    q_state = TrainState.create(
+        apply_fn=q_network.apply,
+        params=q_network.init(q_key, envs.observation_space.sample()),
+        target_params=q_network.init(q_key, envs.observation_space.sample()),
+        tx=optax.adam(learning_rate=args.learning_rate),
+    )
+    q_network.apply = jax.jit(q_network.apply)
+
+    # QDAGGER LOGIC:
+    teacher_model_path = hf_hub_download(
+        repo_id=args.teacher_policy_hf_repo, filename=f"{args.teacher_model_exp_name}.cleanrl_model"
+    )
+    teacher_model = TeacherModel(action_dim=envs.single_action_space.n)
+    teacher_model_key = jax.random.PRNGKey(args.seed)
+    teacher_params = teacher_model.init(teacher_model_key, envs.observation_space.sample())
+    with open(teacher_model_path, "rb") as f:
+        teacher_params = flax.serialization.from_bytes(teacher_params, f.read())
+    teacher_model.apply = jax.jit(teacher_model.apply)
+
+    # evaluate the teacher model
+    teacher_episodic_returns = evaluate(
+        teacher_model_path,
+        make_env,
+        args.env_id,
+        eval_episodes=args.teacher_eval_episodes,
+        run_name=f"{run_name}-teacher-eval",
+        Model=TeacherModel,
+        epsilon=args.end_e,
+        capture_video=False,
+    )
+    writer.add_scalar("charts/teacher/avg_episodic_return", np.mean(teacher_episodic_returns), 0)
+
+    # collect teacher data for args.teacher_steps
+    # we assume we don't have access to the teacher's replay buffer
+    # see Fig. A.19 in Agarwal et al. 2022 for more detail
+    teacher_rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        "cpu",
+        optimize_memory_usage=True,
+        handle_timeout_termination=False,
+    )
+
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in track(range(args.teacher_steps), description="filling teacher's replay buffer"):
+        epsilon = linear_schedule(args.start_e, args.end_e, args.teacher_steps, global_step)
+        if random.random() < epsilon:
+            actions = np.array([envs.single_action_space.sample() for _ in range(envs.num_envs)])
+        else:
+            q_values = teacher_model.apply(teacher_params, obs)
+            actions = q_values.argmax(axis=-1)
+            actions = jax.device_get(actions)
+        next_obs, rewards, terminated, truncated, infos = envs.step(actions)
+        real_next_obs = next_obs.copy()
+        for idx, d in enumerate(truncated):
+            if d:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        teacher_rb.add(obs, real_next_obs, actions, rewards, terminated, infos)
+        obs = next_obs
+
+    def kl_divergence_with_logits(target_logits, prediction_logits):
+        """Implementation of on-policy distillation loss."""
+        out = -nn.softmax(target_logits) * (nn.log_softmax(prediction_logits) - nn.log_softmax(target_logits))
+        return jnp.sum(out)
+
+    @jax.jit
+    def update(q_state, observations, actions, next_observations, rewards, dones, distill_coeff):
+        q_next_target = q_network.apply(q_state.target_params, next_observations)  # (batch_size, num_actions)
+        q_next_target = jnp.max(q_next_target, axis=-1)  # (batch_size,)
+        td_target = rewards + (1 - dones) * args.gamma * q_next_target
+        teacher_q_values = teacher_model.apply(teacher_params, observations)
+
+        def loss(params, td_target, teacher_q_values, distill_coeff):
+            student_q_values = q_network.apply(params, observations)  # (batch_size, num_actions)
+            q_pred = student_q_values[np.arange(student_q_values.shape[0]), actions.squeeze()]  # (batch_size,)
+            q_loss = ((q_pred - td_target) ** 2).mean()
+            teacher_q_values = teacher_q_values / args.temperature
+            student_q_values = student_q_values / args.temperature
+            distill_loss = jnp.mean(jax.vmap(kl_divergence_with_logits)(teacher_q_values, student_q_values))
+            overall_loss = q_loss + distill_coeff * distill_loss
+            return overall_loss, (q_loss, q_pred, distill_loss)
+
+        (loss_value, (q_loss, q_pred, distill_loss)), grads = jax.value_and_grad(loss, has_aux=True)(
+            q_state.params, td_target, teacher_q_values, distill_coeff
+        )
+        q_state = q_state.apply_gradients(grads=grads)
+        return loss_value, q_loss, q_pred, distill_loss, q_state
+
+    # offline training phase: train the student model using the qdagger loss
+    for global_step in track(range(args.offline_steps), description="offline student training"):
+        data = teacher_rb.sample(args.batch_size)
+        # perform a gradient-descent step
+        loss, q_loss, old_val, distill_loss, q_state = update(
+            q_state,
+            data.observations.numpy(),
+            data.actions.numpy(),
+            data.next_observations.numpy(),
+            data.rewards.flatten().numpy(),
+            data.dones.flatten().numpy(),
+            1.0,
+        )
+
+        # update the target network
+        if global_step % args.target_network_frequency == 0:
+            q_state = q_state.replace(target_params=optax.incremental_update(q_state.params, q_state.target_params, args.tau))
+
+        if global_step % 100 == 0:
+            writer.add_scalar("charts/offline/loss", jax.device_get(loss), global_step)
+            writer.add_scalar("charts/offline/q_loss", jax.device_get(q_loss), global_step)
+            writer.add_scalar("charts/offline/distill_loss", jax.device_get(distill_loss), global_step)
+
+        if global_step % 100000 == 0:
+            # evaluate the student model
+            model_path = f"runs/{run_name}/{args.exp_name}-offline-{global_step}.cleanrl_model"
+            with open(model_path, "wb") as f:
+                f.write(flax.serialization.to_bytes(q_state.params))
+            print(f"model saved to {model_path}")
+
+            episodic_returns = evaluate(
+                model_path,
+                make_env,
+                args.env_id,
+                eval_episodes=10,
+                run_name=f"{run_name}-eval",
+                Model=QNetwork,
+                epsilon=args.end_e,
+            )
+            print(episodic_returns)
+            writer.add_scalar("charts/offline/avg_episodic_return", np.mean(episodic_returns), global_step)
+
+    rb = ReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space,
+        envs.single_action_space,
+        "cpu",
+        optimize_memory_usage=True,
+        handle_timeout_termination=False,
+    )
+    start_time = time.time()
+
+    # TRY NOT TO MODIFY: start the game
+    envs = gym.vector.SyncVectorEnv(
+        [make_env(args.env_id, args.seed + i, i, args.capture_video, run_name) for i in range(args.num_envs)]
+    )
+    obs, _ = envs.reset(seed=args.seed)
+    episodic_returns = deque(maxlen=10)
+    # online training phase
+    for global_step in track(range(args.total_timesteps), description="online student training"):
+        global_step += args.offline_steps
+        # 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.apply(q_state.params, obs)
+            actions = q_values.argmax(axis=-1)
+            actions = jax.device_get(actions)
+
+        # TRY NOT TO MODIFY: execute the game and log data.
+        next_obs, rewards, terminated, truncated, infos = envs.step(actions)
+
+        # TRY NOT TO MODIFY: record rewards for plotting purposes
+        if "final_info" in infos:
+            for info in infos["final_info"]:
+                # Skip the envs that are not done
+                if "episode" not in info:
+                    continue
+                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)
+                writer.add_scalar("charts/epsilon", epsilon, global_step)
+                episodic_returns.append(info["episode"]["r"])
+                break
+
+        # TRY NOT TO MODIFY: save data to reply buffer; handle `final_observation`
+        real_next_obs = next_obs.copy()
+        for idx, d in enumerate(truncated):
+            if d:
+                real_next_obs[idx] = infos["final_observation"][idx]
+        rb.add(obs, real_next_obs, actions, rewards, terminated, 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)
+                # perform a gradient-descent step
+                if len(episodic_returns) < 10:
+                    distill_coeff = 1.0
+                else:
+                    distill_coeff = max(1 - np.mean(episodic_returns) / np.mean(teacher_episodic_returns), 0)
+                loss, q_loss, old_val, distill_loss, q_state = update(
+                    q_state,
+                    data.observations.numpy(),
+                    data.actions.numpy(),
+                    data.next_observations.numpy(),
+                    data.rewards.flatten().numpy(),
+                    data.dones.flatten().numpy(),
+                    distill_coeff,
+                )
+
+                if global_step % 100 == 0:
+                    writer.add_scalar("losses/loss", jax.device_get(loss), global_step)
+                    writer.add_scalar("losses/td_loss", jax.device_get(q_loss), global_step)
+                    writer.add_scalar("losses/distill_loss", jax.device_get(distill_loss), global_step)
+                    writer.add_scalar("losses/q_values", jax.device_get(old_val).mean(), global_step)
+                    writer.add_scalar("charts/distill_coeff", distill_coeff, global_step)
+                    print("SPS:", int(global_step / (time.time() - start_time)))
+                    print(distill_coeff)
+                    writer.add_scalar("charts/SPS", int(global_step / (time.time() - start_time)), global_step)
+
+            # update the target network
+            if global_step % args.target_network_frequency == 0:
+                q_state = q_state.replace(
+                    target_params=optax.incremental_update(q_state.params, q_state.target_params, args.tau)
+                )
+
+    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(q_state.params))
+        print(f"model saved to {model_path}")
+        from cleanrl_utils.evals.dqn_jax_eval import evaluate
+
+        episodic_returns = evaluate(
+            model_path,
+            make_env,
+            args.env_id,
+            eval_episodes=10,
+            run_name=f"{run_name}-eval",
+            Model=QNetwork,
+            epsilon=args.end_e,
+        )
+        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, "Qdagger", f"runs/{run_name}", f"videos/{run_name}-eval")
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/rainbow_atari.py

@@ -0,0 +1,529 @@
+# docs and experiment results can be found at https://docs.cleanrl.dev/rl-algorithms/rainbow/#rainbow_ataripy
+import collections
+import math
+import os
+import random
+import time
+from collections import deque
+from dataclasses import dataclass
+
+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 cleanrl_utils.atari_wrappers import (
+    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)"""
+    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"""
+
+    env_id: str = "BreakoutNoFrameskip-v4"
+    """the id of the environment"""
+    total_timesteps: int = 10000000
+    """total timesteps of the experiments"""
+    learning_rate: float = 0.0000625
+    """the learning rate of the optimizer"""
+    num_envs: int = 1
+    """the number of parallel game environments"""
+    buffer_size: int = 1000000
+    """the replay memory buffer size"""
+    gamma: float = 0.99
+    """the discount factor gamma"""
+    tau: float = 1.0
+    """the target network update rate"""
+    target_network_frequency: int = 8000
+    """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
+    """the starting epsilon for exploration"""
+    end_e: float = 0.01
+    """the ending epsilon for exploration"""
+    exploration_fraction: float = 0.10
+    """the fraction of `total-timesteps` it takes from start-e to go end-e"""
+    learning_starts: int = 80000
+    """timestep to start learning"""
+    train_frequency: int = 4
+    """the frequency of training"""
+    n_step: int = 3
+    """the number of steps to look ahead for n-step Q learning"""
+    prioritized_replay_alpha: float = 0.5
+    """alpha parameter for prioritized replay buffer"""
+    prioritized_replay_beta: float = 0.4
+    """beta parameter for prioritized replay buffer"""
+    prioritized_replay_eps: float = 1e-6
+    """epsilon parameter for prioritized replay buffer"""
+    n_atoms: int = 51
+    """the number of atoms"""
+    v_min: float = -10
+    """the return lower bound"""
+    v_max: float = 10
+    """the return upper bound"""
+
+
+def make_env(env_id, seed, 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)
+
+        env.action_space.seed(seed)
+        return env
+
+    return thunk
+
+
+class NoisyLinear(nn.Module):
+    def __init__(self, in_features, out_features, std_init=0.5):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.std_init = std_init
+
+        self.weight_mu = nn.Parameter(torch.FloatTensor(out_features, in_features))
+        self.weight_sigma = nn.Parameter(torch.FloatTensor(out_features, in_features))
+        self.register_buffer("weight_epsilon", torch.FloatTensor(out_features, in_features))
+        self.bias_mu = nn.Parameter(torch.FloatTensor(out_features))
+        self.bias_sigma = nn.Parameter(torch.FloatTensor(out_features))
+        self.register_buffer("bias_epsilon", torch.FloatTensor(out_features))
+        # factorized gaussian noise
+        self.reset_parameters()
+        self.reset_noise()
+
+    def reset_parameters(self):
+        mu_range = 1 / math.sqrt(self.in_features)
+        self.weight_mu.data.uniform_(-mu_range, mu_range)
+        self.weight_sigma.data.fill_(self.std_init / math.sqrt(self.in_features))
+        self.bias_mu.data.uniform_(-mu_range, mu_range)
+        self.bias_sigma.data.fill_(self.std_init / math.sqrt(self.out_features))
+
+    def reset_noise(self):
+        self.weight_epsilon.normal_()
+        self.bias_epsilon.normal_()
+
+    def forward(self, input):
+        if self.training:
+            weight = self.weight_mu + self.weight_sigma * self.weight_epsilon
+            bias = self.bias_mu + self.bias_sigma * self.bias_epsilon
+        else:
+            weight = self.weight_mu
+            bias = self.bias_mu
+        return F.linear(input, weight, bias)
+
+
+# ALGO LOGIC: initialize agent here:
+class NoisyDuelingDistributionalNetwork(nn.Module):
+    def __init__(self, env, n_atoms, v_min, v_max):
+        super().__init__()
+        self.n_atoms = n_atoms
+        self.v_min = v_min
+        self.v_max = v_max
+        self.delta_z = (v_max - v_min) / (n_atoms - 1)
+        self.n_actions = env.single_action_space.n
+        self.register_buffer("support", torch.linspace(v_min, v_max, n_atoms))
+
+        self.network = nn.Sequential(
+            nn.Conv2d(4, 32, 8, stride=4),
+            nn.ReLU(),
+            nn.Conv2d(32, 64, 4, stride=2),
+            nn.ReLU(),
+            nn.Conv2d(64, 64, 3, stride=1),
+            nn.ReLU(),
+            nn.Flatten(),
+        )
+        conv_output_size = 3136
+
+        self.value_head = nn.Sequential(NoisyLinear(conv_output_size, 512), nn.ReLU(), NoisyLinear(512, n_atoms))
+
+        self.advantage_head = nn.Sequential(
+            NoisyLinear(conv_output_size, 512), nn.ReLU(), NoisyLinear(512, n_atoms * self.n_actions)
+        )
+
+    def forward(self, x):
+        h = self.network(x / 255.0)
+        value = self.value_head(h).view(-1, 1, self.n_atoms)
+        advantage = self.advantage_head(h).view(-1, self.n_actions, self.n_atoms)
+        q_atoms = value + advantage - advantage.mean(dim=1, keepdim=True)
+        q_dist = F.softmax(q_atoms, dim=2)
+        return q_dist
+
+    def reset_noise(self):
+        for layer in self.value_head:
+            if isinstance(layer, NoisyLinear):
+                layer.reset_noise()
+        for layer in self.advantage_head:
+            if isinstance(layer, NoisyLinear):
+                layer.reset_noise()
+
+
+PrioritizedBatch = collections.namedtuple(
+    "PrioritizedBatch", ["observations", "actions", "rewards", "next_observations", "dones", "indices", "weights"]
+)
+
+
+# adapted from: https://github.com/openai/baselines/blob/master/baselines/common/segment_tree.py
+class SumSegmentTree:
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.tree_size = 2 * capacity - 1
+        self.tree = np.zeros(self.tree_size, dtype=np.float32)
+
+    def _propagate(self, idx):
+        parent = (idx - 1) // 2
+        while parent >= 0:
+            self.tree[parent] = self.tree[parent * 2 + 1] + self.tree[parent * 2 + 2]
+            parent = (parent - 1) // 2
+
+    def update(self, idx, value):
+        tree_idx = idx + self.capacity - 1
+        self.tree[tree_idx] = value
+        self._propagate(tree_idx)
+
+    def total(self):
+        return self.tree[0]
+
+    def retrieve(self, value):
+        idx = 0
+        while idx * 2 + 1 < self.tree_size:
+            left = idx * 2 + 1
+            right = left + 1
+            if value <= self.tree[left]:
+                idx = left
+            else:
+                value -= self.tree[left]
+                idx = right
+        return idx - (self.capacity - 1)
+
+
+# adapted from: https://github.com/openai/baselines/blob/master/baselines/common/segment_tree.py
+class MinSegmentTree:
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.tree_size = 2 * capacity - 1
+        self.tree = np.full(self.tree_size, float("inf"), dtype=np.float32)
+
+    def _propagate(self, idx):
+        parent = (idx - 1) // 2
+        while parent >= 0:
+            self.tree[parent] = min(self.tree[parent * 2 + 1], self.tree[parent * 2 + 2])
+            parent = (parent - 1) // 2
+
+    def update(self, idx, value):
+        tree_idx = idx + self.capacity - 1
+        self.tree[tree_idx] = value
+        self._propagate(tree_idx)
+
+    def min(self):
+        return self.tree[0]
+
+
+class PrioritizedReplayBuffer:
+    def __init__(self, capacity, obs_shape, device, n_step, gamma, alpha=0.6, beta=0.4, eps=1e-6):
+        self.capacity = capacity
+        self.device = device
+        self.n_step = n_step
+        self.gamma = gamma
+        self.alpha = alpha
+        self.beta = beta
+        self.eps = eps
+
+        self.buffer_obs = np.zeros((capacity,) + obs_shape, dtype=np.uint8)
+        self.buffer_next_obs = np.zeros((capacity,) + obs_shape, dtype=np.uint8)
+        self.buffer_actions = np.zeros(capacity, dtype=np.int64)
+        self.buffer_rewards = np.zeros(capacity, dtype=np.float32)
+        self.buffer_dones = np.zeros(capacity, dtype=np.bool_)
+
+        self.pos = 0
+        self.size = 0
+        self.max_priority = 1.0
+
+        self.sum_tree = SumSegmentTree(capacity)
+        self.min_tree = MinSegmentTree(capacity)
+
+        # For n-step returns
+        self.n_step_buffer = deque(maxlen=n_step)
+
+    def _get_n_step_info(self):
+        reward = 0.0
+        next_obs = self.n_step_buffer[-1][3]
+        done = self.n_step_buffer[-1][4]
+
+        for i in range(len(self.n_step_buffer)):
+            reward += self.gamma**i * self.n_step_buffer[i][2]
+            if self.n_step_buffer[i][4]:
+                next_obs = self.n_step_buffer[i][3]
+                done = True
+                break
+        return reward, next_obs, done
+
+    def add(self, obs, action, reward, next_obs, done):
+        self.n_step_buffer.append((obs, action, reward, next_obs, done))
+
+        if len(self.n_step_buffer) < self.n_step:
+            return
+
+        reward, next_obs, done = self._get_n_step_info()
+        obs = self.n_step_buffer[0][0]
+        action = self.n_step_buffer[0][1]
+
+        idx = self.pos
+        self.buffer_obs[idx] = obs
+        self.buffer_next_obs[idx] = next_obs
+        self.buffer_actions[idx] = action
+        self.buffer_rewards[idx] = reward
+        self.buffer_dones[idx] = done
+
+        priority = self.max_priority**self.alpha
+        self.sum_tree.update(idx, priority)
+        self.min_tree.update(idx, priority)
+
+        self.pos = (self.pos + 1) % self.capacity
+        self.size = min(self.size + 1, self.capacity)
+
+        if done:
+            self.n_step_buffer.clear()
+
+    def sample(self, batch_size):
+        indices = []
+        p_total = self.sum_tree.total()
+        segment = p_total / batch_size
+
+        for i in range(batch_size):
+            a = segment * i
+            b = segment * (i + 1)
+            upperbound = np.random.uniform(a, b)
+            idx = self.sum_tree.retrieve(upperbound)
+            indices.append(idx)
+
+        samples = {
+            "observations": torch.from_numpy(self.buffer_obs[indices]).to(self.device),
+            "actions": torch.from_numpy(self.buffer_actions[indices]).to(self.device).unsqueeze(1),
+            "rewards": torch.from_numpy(self.buffer_rewards[indices]).to(self.device).unsqueeze(1),
+            "next_observations": torch.from_numpy(self.buffer_next_obs[indices]).to(self.device),
+            "dones": torch.from_numpy(self.buffer_dones[indices]).to(self.device).unsqueeze(1),
+        }
+
+        probs = np.array([self.sum_tree.tree[idx + self.capacity - 1] for idx in indices])
+        weights = (self.size * probs / p_total) ** -self.beta
+        weights = weights / weights.max()
+        samples["weights"] = torch.from_numpy(weights).to(self.device).unsqueeze(1)
+        samples["indices"] = indices
+
+        return PrioritizedBatch(**samples)
+
+    def update_priorities(self, indices, priorities):
+        priorities = np.abs(priorities) + self.eps
+        self.max_priority = max(self.max_priority, priorities.max())
+
+        for idx, priority in zip(indices, priorities):
+            priority = priority**self.alpha
+            self.sum_tree.update(idx, priority)
+            self.min_tree.update(idx, priority)
+
+
+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, args.seed + i, 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"
+
+    q_network = NoisyDuelingDistributionalNetwork(envs, args.n_atoms, args.v_min, args.v_max).to(device)
+    optimizer = optim.Adam(q_network.parameters(), lr=args.learning_rate, eps=1.5e-4)
+    target_network = NoisyDuelingDistributionalNetwork(envs, args.n_atoms, args.v_min, args.v_max).to(device)
+    target_network.load_state_dict(q_network.state_dict())
+
+    rb = PrioritizedReplayBuffer(
+        args.buffer_size,
+        envs.single_observation_space.shape,
+        device,
+        args.n_step,
+        args.gamma,
+        args.prioritized_replay_alpha,
+        args.prioritized_replay_beta,
+        args.prioritized_replay_eps,
+    )
+
+    start_time = time.time()
+
+    # TRY NOT TO MODIFY: start the game
+    obs, _ = envs.reset(seed=args.seed)
+    for global_step in range(args.total_timesteps):
+        # anneal PER beta to 1
+        rb.beta = min(
+            1.0, args.prioritized_replay_beta + global_step * (1.0 - args.prioritized_replay_beta) / args.total_timesteps
+        )
+
+        # ALGO LOGIC: put action logic here
+        with torch.no_grad():
+            q_dist = q_network(torch.Tensor(obs).to(device))
+            q_values = torch.sum(q_dist * q_network.support, dim=2)
+            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)
+
+        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)
+
+        # 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, actions, rewards, real_next_obs, terminations)
+
+        # 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:
+                # reset the noise for both networks
+                q_network.reset_noise()
+                target_network.reset_noise()
+                data = rb.sample(args.batch_size)
+
+                with torch.no_grad():
+                    next_dist = target_network(data.next_observations)  # [B, num_actions, n_atoms]
+                    support = target_network.support  # [n_atoms]
+                    next_q_values = torch.sum(next_dist * support, dim=2)  # [B, num_actions]
+
+                    # double q-learning
+                    next_dist_online = q_network(data.next_observations)  # [B, num_actions, n_atoms]
+                    next_q_online = torch.sum(next_dist_online * support, dim=2)  # [B, num_actions]
+                    best_actions = torch.argmax(next_q_online, dim=1)  # [B]
+                    next_pmfs = next_dist[torch.arange(args.batch_size), best_actions]  # [B, n_atoms]
+
+                    # compute the n-step Bellman update.
+                    gamma_n = args.gamma**args.n_step
+                    next_atoms = data.rewards + gamma_n * support * (1 - data.dones.float())
+                    tz = next_atoms.clamp(q_network.v_min, q_network.v_max)
+
+                    # projection
+                    delta_z = q_network.delta_z
+                    b = (tz - q_network.v_min) / delta_z  # shape: [B, n_atoms]
+                    l = b.floor().clamp(0, args.n_atoms - 1)
+                    u = b.ceil().clamp(0, args.n_atoms - 1)
+
+                    # (l == u).float() handles the case where bj is exactly an integer
+                    # example bj = 1, then the upper ceiling should be uj= 2, and lj= 1
+                    d_m_l = (u.float() + (l == b).float() - b) * next_pmfs  # [B, n_atoms]
+                    d_m_u = (b - l) * next_pmfs  # [B, n_atoms]
+
+                    target_pmfs = torch.zeros_like(next_pmfs)
+                    for i in range(target_pmfs.size(0)):
+                        target_pmfs[i].index_add_(0, l[i].long(), d_m_l[i])
+                        target_pmfs[i].index_add_(0, u[i].long(), d_m_u[i])
+
+                dist = q_network(data.observations)  # [B, num_actions, n_atoms]
+                pred_dist = dist.gather(1, data.actions.unsqueeze(-1).expand(-1, -1, args.n_atoms)).squeeze(1)
+                log_pred = torch.log(pred_dist.clamp(min=1e-5, max=1 - 1e-5))
+
+                loss_per_sample = -(target_pmfs * log_pred).sum(dim=1)
+                loss = (loss_per_sample * data.weights.squeeze()).mean()
+
+                # update priorities
+                new_priorities = loss_per_sample.detach().cpu().numpy()
+                rb.update_priorities(data.indices, new_priorities)
+
+                if global_step % 100 == 0:
+                    writer.add_scalar("losses/td_loss", loss.item(), global_step)
+                    q_values = (pred_dist * q_network.support).sum(dim=1)  # [B]
+                    writer.add_scalar("losses/q_values", q_values.mean().item(), global_step)
+                    sps = int(global_step / (time.time() - start_time))
+                    print("SPS:", sps)
+                    writer.add_scalar("charts/SPS", sps, global_step)
+                    writer.add_scalar("charts/beta", rb.beta, 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_param, param in zip(target_network.parameters(), q_network.parameters()):
+                    target_param.data.copy_(args.tau * param.data + (1.0 - args.tau) * target_param.data)
+
+    envs.close()
+    writer.close()

cleanrl/cleanrl/scout_dqn/noisy_dqn_2048_5000score.py

@@ -0,0 +1,737 @@
+# 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__), '../../'))
+
+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, terminated, truncated, info = self._env.step(int(action))
+        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)
+        # 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, float(reward), bool(terminated), bool(truncated), ret_info
+        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 = 3_000_000
+    learning_rate: float = 2.5e-4
+    gamma: float = 0.997
+    batch_size: int = 256
+    buffer_size: int = 300_000
+    target_network_frequency: int = 8000
+    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 由 Environment Config 控制，此处仅作 Args 占位
+    reward_clip_abs: float | None = None
+    reward_transform: str = "log2"  # choices: "none", "log2"
+
+    # n-step and PER
+    n_step: int = 3
+    per_alpha: float = 0.6
+    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
+
+
+def make_env(run_name: str, seed: int, args: Args, capture_video: bool = False):
+    # === Adapt: 开启环境内部 Log Reward ===
+    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
+
+
+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))
+                    
+                    # === Adapt: 使用 Raw Reward (Pre-regularization) ===
+                    # 确保 Eval 阶段记录的是原始分数
+                    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 {}
+    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)
+
+    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)
+
+        # === Adapt: 移除手动正则化，直接使用 Env 返回的 reward ===
+        r = float(reward)
+        # (已删除原有的 if/elif 手动 log2/clip 逻辑，防止双重 log)
+
+        n_out = nbuf.push(obs.astype(np.float32), int(action), float(r), bool(done), next_obs.astype(np.float32))
+        if n_out is not None:
+            s0, a0, Rn, dN, sN = n_out
+            rb.add(s0, a0, Rn, dN, sN)
+
+        obs = next_obs
+        current_info = info or {}
+        
+        # === Adapt: 记录 Raw Score (来自 info) ===
+        raw_r = float(info.get('raw_reward', reward))
+        ep_return += raw_r
+        
+        try:
+            step_reward_window.append(float(reward)) # Keep tracking training reward stability
+        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
+                    # compute PPO-compatible metrics (use None where N/A)
+                    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()),
+                        # PPO-compatible keys below (None when not applicable to DQN)
+                        "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))
+            ep_success_window.append(1.0 if succ else 0.0)
+            ep_return_window.append(float(ep_return))
+            for out_tr in nbuf.flush():
+                s0, a0, Rn, dN, sN = out_tr
+                rb.add(s0, a0, Rn, dN, sN)
+            # print per-episode process metrics (match PPO format)
+            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
+                    # average episode return over recent 100 episodes
+                    try:
+                        avg_ep_ret = float(np.mean(ep_return_window)) if len(ep_return_window) > 0 else 0.0
+                    except Exception:
+                        avg_ep_ret = float(ep_return)
+                    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,
+                        # 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/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
+
+        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/scout_ppo/ppo_frozenlake_nochangeenv.py

@@ -0,0 +1,494 @@
+# PPO with small MLP for RAGEN FrozenLake 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
+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.frozen_lake.env import FrozenLakeEnv
+from ragen.env.frozen_lake.config import FrozenLakeEnvConfig
+
+# python /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake_nochangeenv.py --total-timesteps 2000000 --num-envs 8 --num-steps 128 --grid-size 4 --is-slippery --track
+class FrozenLakeWrapper(gym.Env):
+    """
+    Adapter to use ragen FrozenLakeEnv with Gymnasium vector API.
+    - Converts text observation to one-hot grid vector (6 tokens per cell).
+    - Maps agent actions [0..3] to env actions [1..4].
+    - Exposes proper observation_space and action_space.
+    """
+    metadata = {"render_modes": ["rgb_array", "human", "ansi"]}
+
+    def __init__(self, env: FrozenLakeEnv):
+        super().__init__()
+        self._env = env
+        self._size = int(self._env.nrow)  # square grid
+        self._tokens = ['P', '_', 'O', 'G', 'X', '√']
+        self._token_to_idx = {t: i for i, t in enumerate(self._tokens)}
+        self.observation_space = gym.spaces.Box(low=0.0, high=1.0, shape=(self._size * self._size * len(self._tokens),), dtype=np.float32)
+        self.action_space = gym.spaces.Discrete(4)
+
+    def _encode_obs(self, text_obs: str) -> np.ndarray:
+        # text_obs is multi-line grid with tokens above
+        rows = text_obs.split('\n')
+        # handle any accidental extra whitespace
+        rows = [list(r) for r in rows if len(r) > 0]
+        h = len(rows)
+        w = len(rows[0]) if h > 0 else self._size
+        grid = np.zeros((h, w, len(self._tokens)), dtype=np.float32)
+        for i in range(h):
+            for j in range(w):
+                ch = rows[i][j]
+                idx = self._token_to_idx.get(ch, 0)
+                grid[i, j, idx] = 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):
+        # map 0..3 -> 1..4 for the underlying env
+        mapped = int(action) + 1
+        text_obs, reward, done, info = self._env.step(mapped)
+        obs = self._encode_obs(text_obs)
+        terminated = bool(done)
+        truncated = False
+        # propagate success if present
+        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 = "FrozenLake"
+    total_timesteps: int = 200_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
+
+    # FrozenLake specific
+    grid_size: int = 4
+    is_slippery: bool = True
+
+    # runtime filled
+    batch_size: int = 0
+    minibatch_size: int = 0
+    num_iterations: int = 0
+    # eval config to mirror reference script
+    eval_splits: int = 2
+    eval_episodes: int = 4
+
+
+def make_env(idx, run_name, seed, grid_size, is_slippery, capture_video=False):
+    def thunk():
+        config = FrozenLakeEnvConfig(size=grid_size, p=0.9, success_rate = 0.8, is_slippery=is_slippery, map_seed=seed + idx, render_mode='text')
+        # import pdb;pdb.set_trace()
+        env = FrozenLakeEnv(config)
+        env = FrozenLakeWrapper(env)
+        max_steps = int(grid_size * grid_size * 4)
+        env = gym.wrappers.TimeLimit(env, max_episode_steps=max_steps)
+        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 = 64
+        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.grid_size, args.is_slippery, 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)
+
+    episode_returns = []
+    episode_steps = []
+    episode_successes = []
+
+    # Eval helper identical to reference
+    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.grid_size * args.grid_size * 4)
+                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.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}")
+
+    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
+
+        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 as in reference
+            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)))
+                    succ_arr = np.asarray(infos.get("success", np.zeros_like(mask, dtype=bool))).astype(float)
+                    for i in np.where(mask)[0]:
+                        ep_r = float(r_arr[i])
+                        ep_l = int(l_arr[i])
+                        ep_succ = float(succ_arr[i])
+                        episode_returns.append(ep_r)
+                        episode_steps.append(global_step)
+                        episode_successes.append(ep_succ)
+                    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,
+                            }
+                            if np.any(mask):
+                                last_idx = np.where(mask)[0][-1]
+                                log_dict.update({
+                                    "train/episodic_return": float(r_arr[last_idx]),
+                                    "train/episodic_length": int(l_arr[last_idx]),
+                                    "train/success": float(succ_arr[last_idx]),
+                                    "train/success_rate_100": float(np.mean(episode_successes[-100:])) if len(episode_successes) >= 100 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
+
+        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()),
+                    "train/old_approx_kl": float(old_approx_kl.item()),
+                    "train/approx_kl": float(approx_kl.item()),
+                    "train/clipfrac": float(np.mean(clipfracs)),
+                    "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==1 or iteration % eval_every_iters == 0:
+            try:
+                eval_thunk = make_env(0, run_name, args.seed + 9999, args.grid_size, args.is_slippery, 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/run-20251107_100619-gm3bobw8/logs/debug-internal.log

@@ -0,0 +1,31 @@
+{"time":"2025-11-07T10:06:19.994658211+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T10:06:20.365926969+08:00","level":"INFO","msg":"stream: created new stream","id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:20.366125989+08:00","level":"INFO","msg":"handler: started","stream_id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:20.369029103+08:00","level":"INFO","msg":"stream: started","id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:20.36904409+08:00","level":"INFO","msg":"writer: started","stream_id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:20.36904757+08:00","level":"INFO","msg":"sender: started","stream_id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:20.813587305+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T10:06:30.950807532+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T10:06:30.951607455+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__1762481172\")","namespace":""}
+{"time":"2025-11-07T10:06:30.95391652+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__ppo_bandit__1__1762481172/events.out.tfevents.1762481180.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.131343.0","runPath":"runs/Bandit__ppo_bandit__1__1762481172/events.out.tfevents.1762481180.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.131343.0"}
+{"time":"2025-11-07T10:06:30.957133707+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":71}
+{"time":"2025-11-07T10:06:30.961555078+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":472}
+{"time":"2025-11-07T10:06:35.966080652+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":596}
+{"time":"2025-11-07T10:06:36.315508554+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:06:40.972626238+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":964}
+{"time":"2025-11-07T10:06:40.972681395+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:06:40.973207934+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":996}
+{"time":"2025-11-07T10:06:40.975801472+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:06:50.990421903+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1662}
+{"time":"2025-11-07T10:06:51.298917777+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":279}
+{"time":"2025-11-07T10:06:55.996470006+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1991}
+{"time":"2025-11-07T10:06:55.996583551+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:06:55.997028739+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2023}
+{"time":"2025-11-07T10:06:55.999621336+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:06:59.151408238+08:00","level":"INFO","msg":"stream: closing","id":"gm3bobw8"}
+{"time":"2025-11-07T10:06:59.154021485+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2314}
+{"time":"2025-11-07T10:06:59.156923599+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":201}
+{"time":"2025-11-07T10:07:00.878858934+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T10:07:01.313956448+08:00","level":"INFO","msg":"handler: closed","stream_id":"gm3bobw8"}
+{"time":"2025-11-07T10:07:01.315667095+08:00","level":"INFO","msg":"sender: closed","stream_id":"gm3bobw8"}
+{"time":"2025-11-07T10:07:01.31578248+08:00","level":"INFO","msg":"stream: closed","id":"gm3bobw8"}

cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/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 = True
+    """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 = 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/wandb/run-20251107_100911-8xuf7idy/files/config.yaml

@@ -0,0 +1,153 @@
+_wandb:
+    value:
+        cli_version: 0.22.3
+        code_path: code/cleanrl/ppo_bandit.py
+        e:
+            afa72m1ss75e8tywa8la2dtqpijhj6o8:
+                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: "30509883392"
+                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:09:11.693292Z"
+                writerId: afa72m1ss75e8tywa8la2dtqpijhj6o8
+        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: 610
+num_minibatches:
+    value: 4
+num_steps:
+    value: 512
+seed:
+    value: 1
+target_kl:
+    value: null
+torch_deterministic:
+    value: true
+total_timesteps:
+    value: 10000000
+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_100911-8xuf7idy/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:09:11.693292Z",
+  "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":  "30509883392"
+    }
+  },
+  "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":  "afa72m1ss75e8tywa8la2dtqpijhj6o8"
+}

cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_step":7929,"losses/approx_kl":1.38243195e-08,"losses/policy_loss":1.4365651e-07,"losses/clipfrac":0,"global_step":9994240,"charts/learning_rate":4.0983608e-07,"charts/avg_reward":0.08695068,"charts/max_reward":1,"charts/SPS":27464,"_runtime":365,"losses/entropy":0.6929781,"losses/value_loss":0.043968797,"losses/old_approx_kl":7.185736e-08,"charts/avg_value":0.17424533,"losses/explained_variance":-2.8371811e-05,"charts/min_reward":0,"_timestamp":1.7624817181982253e+09,"_wandb":{"runtime":365}}

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

@@ -0,0 +1,24 @@
+2025-11-07 10:09:11,744 INFO    MainThread:131665 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 10:09:11,745 INFO    MainThread:131665 [wandb_setup.py:_flush():81] Configure stats pid to 131665
+2025-11-07 10:09:11,745 INFO    MainThread:131665 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 10:09:11,745 INFO    MainThread:131665 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 10:09:11,745 INFO    MainThread:131665 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 10:09:11,745 INFO    MainThread:131665 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/logs/debug.log
+2025-11-07 10:09:11,746 INFO    MainThread:131665 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_100911-8xuf7idy/logs/debug-internal.log
+2025-11-07 10:09:11,747 INFO    MainThread:131665 [wandb_init.py:init():833] calling init triggers
+2025-11-07 10:09:11,747 INFO    MainThread:131665 [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': 10000000, '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': 610, '_wandb': {'code_path': 'code/cleanrl/ppo_bandit.py'}}
+2025-11-07 10:09:11,747 INFO    MainThread:131665 [wandb_init.py:init():881] starting backend
+2025-11-07 10:09:11,953 INFO    MainThread:131665 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 10:09:11,964 INFO    MainThread:131665 [wandb_init.py:init():892] backend started and connected
+2025-11-07 10:09:11,966 INFO    MainThread:131665 [wandb_init.py:init():962] updated telemetry
+2025-11-07 10:09:12,000 INFO    MainThread:131665 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 10:09:12,663 INFO    MainThread:131665 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 10:09:12,806 INFO    MainThread:131665 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 10:09:12,806 INFO    MainThread:131665 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 10:09:12,807 INFO    MainThread:131665 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 10:09:12,807 INFO    MainThread:131665 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 10:09:12,809 INFO    MainThread:131665 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 10:09:12,809 INFO    MainThread:131665 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Bandit__ppo_bandit__1__1762481344, True
+2025-11-07 10:15:18,220 INFO    wandb-AsyncioManager-main:131665 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 10:15:18,220 INFO    wandb-AsyncioManager-main:131665 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/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 = True
+    """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 = 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/wandb/run-20251107_102633-lu2iu68t/files/output.log

@@ -0,0 +1,610 @@
+[  0.2%] Iter    1/610 | SPS: 17989 | Reward:  0.087 | Value: -0.004 | VLoss: 0.0479 | PLoss: -0.0007 | Ent: 0.6929
+[  0.3%] Iter    2/610 | SPS: 22081 | Reward:  0.084 | Value:  0.127 | VLoss: 0.0450 | PLoss: 0.0001 | Ent: 0.6925
+[  0.5%] Iter    3/610 | SPS: 23843 | Reward:  0.087 | Value:  0.138 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6924
+[  0.7%] Iter    4/610 | SPS: 24871 | Reward:  0.088 | Value:  0.149 | VLoss: 0.0454 | PLoss: -0.0002 | Ent: 0.6919
+[  0.8%] Iter    5/610 | SPS: 25514 | Reward:  0.088 | Value:  0.167 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6916
+[  1.0%] Iter    6/610 | SPS: 25956 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0475 | PLoss: -0.0001 | Ent: 0.6915
+[  1.1%] Iter    7/610 | SPS: 26293 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0482 | PLoss: -0.0002 | Ent: 0.6912
+[  1.3%] Iter    8/610 | SPS: 26556 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0472 | PLoss: -0.0001 | Ent: 0.6913
+[  1.5%] Iter    9/610 | SPS: 26765 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0476 | PLoss: 0.0001 | Ent: 0.6912
+[  1.6%] Iter   10/610 | SPS: 26925 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6911
+[  1.8%] Iter   11/610 | SPS: 27059 | Reward:  0.091 | Value:  0.166 | VLoss: 0.0489 | PLoss: 0.0000 | Ent: 0.6908
+[  2.0%] Iter   12/610 | SPS: 27177 | Reward:  0.086 | Value:  0.183 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6910
+[  2.1%] Iter   13/610 | SPS: 27282 | Reward:  0.084 | Value:  0.169 | VLoss: 0.0464 | PLoss: -0.0002 | Ent: 0.6913
+[  2.3%] Iter   14/610 | SPS: 27352 | Reward:  0.086 | Value:  0.169 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6918
+[  2.5%] Iter   15/610 | SPS: 27379 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6923
+[  2.6%] Iter   16/610 | SPS: 27451 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0493 | PLoss: -0.0001 | Ent: 0.6926
+[  2.8%] Iter   17/610 | SPS: 27516 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6929
+[  3.0%] Iter   18/610 | SPS: 27566 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0460 | PLoss: -0.0001 | Ent: 0.6930
+[  3.1%] Iter   19/610 | SPS: 27600 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0492 | PLoss: -0.0001 | Ent: 0.6931
+[  3.3%] Iter   20/610 | SPS: 27645 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0461 | PLoss: -0.0002 | Ent: 0.6930
+[  3.4%] Iter   21/610 | SPS: 27677 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0461 | PLoss: 0.0001 | Ent: 0.6927
+[  3.6%] Iter   22/610 | SPS: 27715 | Reward:  0.092 | Value:  0.171 | VLoss: 0.0507 | PLoss: -0.0000 | Ent: 0.6926
+[  3.8%] Iter   23/610 | SPS: 27750 | Reward:  0.083 | Value:  0.184 | VLoss: 0.0424 | PLoss: -0.0001 | Ent: 0.6927
+[  3.9%] Iter   24/610 | SPS: 27776 | Reward:  0.084 | Value:  0.165 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6926
+[  4.1%] Iter   25/610 | SPS: 27777 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6926
+[  4.3%] Iter   26/610 | SPS: 27803 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0460 | PLoss: 0.0001 | Ent: 0.6927
+[  4.4%] Iter   27/610 | SPS: 27826 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0478 | PLoss: -0.0001 | Ent: 0.6928
+[  4.6%] Iter   28/610 | SPS: 27848 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6929
+[  4.8%] Iter   29/610 | SPS: 27869 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6927
+[  4.9%] Iter   30/610 | SPS: 27890 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0483 | PLoss: 0.0001 | Ent: 0.6925
+[  5.1%] Iter   31/610 | SPS: 27887 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6927
+[  5.2%] Iter   32/610 | SPS: 27879 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6927
+[  5.4%] Iter   33/610 | SPS: 27880 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0437 | PLoss: -0.0001 | Ent: 0.6925
+[  5.6%] Iter   34/610 | SPS: 27888 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0451 | PLoss: -0.0002 | Ent: 0.6924
+[  5.7%] Iter   35/610 | SPS: 27892 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6923
+[  5.9%] Iter   36/610 | SPS: 27898 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0450 | PLoss: -0.0001 | Ent: 0.6922
+[  6.1%] Iter   37/610 | SPS: 27879 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6920
+[  6.2%] Iter   38/610 | SPS: 27886 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0474 | PLoss: -0.0004 | Ent: 0.6915
+[  6.4%] Iter   39/610 | SPS: 27891 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0485 | PLoss: 0.0002 | Ent: 0.6904
+[  6.6%] Iter   40/610 | SPS: 27898 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6907
+[  6.7%] Iter   41/610 | SPS: 27905 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0475 | PLoss: 0.0001 | Ent: 0.6916
+[  6.9%] Iter   42/610 | SPS: 27907 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6917
+[  7.0%] Iter   43/610 | SPS: 27908 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0475 | PLoss: -0.0003 | Ent: 0.6912
+[  7.2%] Iter   44/610 | SPS: 27910 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6913
+[  7.4%] Iter   45/610 | SPS: 27911 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0458 | PLoss: -0.0005 | Ent: 0.6919
+[  7.5%] Iter   46/610 | SPS: 27914 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0482 | PLoss: -0.0001 | Ent: 0.6922
+[  7.7%] Iter   47/610 | SPS: 27920 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0452 | PLoss: -0.0002 | Ent: 0.6924
+[  7.9%] Iter   48/610 | SPS: 27921 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0478 | PLoss: -0.0001 | Ent: 0.6927
+[  8.0%] Iter   49/610 | SPS: 27910 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6929
+[  8.2%] Iter   50/610 | SPS: 27906 | Reward:  0.084 | Value:  0.174 | VLoss: 0.0429 | PLoss: 0.0000 | Ent: 0.6930
+[  8.4%] Iter   51/610 | SPS: 27910 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0459 | PLoss: 0.0002 | Ent: 0.6930
+[  8.5%] Iter   52/610 | SPS: 27913 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6930
+[  8.7%] Iter   53/610 | SPS: 27915 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0489 | PLoss: -0.0002 | Ent: 0.6929
+[  8.9%] Iter   54/610 | SPS: 27918 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0484 | PLoss: -0.0003 | Ent: 0.6930
+[  9.0%] Iter   55/610 | SPS: 27922 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0465 | PLoss: -0.0001 | Ent: 0.6931
+[  9.2%] Iter   56/610 | SPS: 27925 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0461 | PLoss: -0.0002 | Ent: 0.6931
+[  9.3%] Iter   57/610 | SPS: 27921 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0458 | PLoss: 0.0001 | Ent: 0.6930
+[  9.5%] Iter   58/610 | SPS: 27923 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0459 | PLoss: -0.0002 | Ent: 0.6928
+[  9.7%] Iter   59/610 | SPS: 27926 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6926
+[  9.8%] Iter   60/610 | SPS: 27924 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6925
+[ 10.0%] Iter   61/610 | SPS: 27919 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0483 | PLoss: -0.0001 | Ent: 0.6922
+[ 10.2%] Iter   62/610 | SPS: 27923 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6921
+[ 10.3%] Iter   63/610 | SPS: 27925 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0458 | PLoss: -0.0003 | Ent: 0.6920
+[ 10.5%] Iter   64/610 | SPS: 27928 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0469 | PLoss: -0.0002 | Ent: 0.6916
+[ 10.7%] Iter   65/610 | SPS: 27930 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0001 | Ent: 0.6915
+[ 10.8%] Iter   66/610 | SPS: 27894 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0459 | PLoss: -0.0001 | Ent: 0.6917
+[ 11.0%] Iter   67/610 | SPS: 27895 | Reward:  0.082 | Value:  0.175 | VLoss: 0.0431 | PLoss: -0.0001 | Ent: 0.6917
+[ 11.1%] Iter   68/610 | SPS: 27896 | Reward:  0.088 | Value:  0.165 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6914
+[ 11.3%] Iter   69/610 | SPS: 27900 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0456 | PLoss: -0.0001 | Ent: 0.6909
+[ 11.5%] Iter   70/610 | SPS: 27902 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0460 | PLoss: -0.0001 | Ent: 0.6904
+[ 11.6%] Iter   71/610 | SPS: 27904 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0477 | PLoss: -0.0000 | Ent: 0.6908
+[ 11.8%] Iter   72/610 | SPS: 27908 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0454 | PLoss: 0.0002 | Ent: 0.6917
+[ 12.0%] Iter   73/610 | SPS: 27910 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0447 | PLoss: -0.0003 | Ent: 0.6919
+[ 12.1%] Iter   74/610 | SPS: 27913 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6923
+[ 12.3%] Iter   75/610 | SPS: 27915 | Reward:  0.085 | Value:  0.170 | VLoss: 0.0476 | PLoss: -0.0002 | Ent: 0.6924
+[ 12.5%] Iter   76/610 | SPS: 27917 | Reward:  0.089 | Value:  0.169 | VLoss: 0.0460 | PLoss: -0.0001 | Ent: 0.6926
+[ 12.6%] Iter   77/610 | SPS: 27919 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0482 | PLoss: 0.0001 | Ent: 0.6926
+[ 12.8%] Iter   78/610 | SPS: 27923 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6927
+[ 13.0%] Iter   79/610 | SPS: 27924 | Reward:  0.092 | Value:  0.177 | VLoss: 0.0491 | PLoss: 0.0002 | Ent: 0.6926
+[ 13.1%] Iter   80/610 | SPS: 27925 | Reward:  0.086 | Value:  0.183 | VLoss: 0.0475 | PLoss: -0.0002 | Ent: 0.6925
+[ 13.3%] Iter   81/610 | SPS: 27926 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6925
+[ 13.4%] Iter   82/610 | SPS: 27925 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6924
+[ 13.6%] Iter   83/610 | SPS: 27918 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6921
+[ 13.8%] Iter   84/610 | SPS: 27916 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0428 | PLoss: -0.0000 | Ent: 0.6922
+[ 13.9%] Iter   85/610 | SPS: 27918 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6924
+[ 14.1%] Iter   86/610 | SPS: 27920 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6925
+[ 14.3%] Iter   87/610 | SPS: 27920 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6926
+[ 14.4%] Iter   88/610 | SPS: 27921 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6925
+[ 14.6%] Iter   89/610 | SPS: 27922 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0447 | PLoss: 0.0001 | Ent: 0.6922
+[ 14.8%] Iter   90/610 | SPS: 27925 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0431 | PLoss: -0.0001 | Ent: 0.6920
+[ 14.9%] Iter   91/610 | SPS: 27926 | Reward:  0.091 | Value:  0.175 | VLoss: 0.0493 | PLoss: -0.0001 | Ent: 0.6923
+[ 15.1%] Iter   92/610 | SPS: 27926 | Reward:  0.084 | Value:  0.181 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6925
+[ 15.2%] Iter   93/610 | SPS: 27928 | Reward:  0.083 | Value:  0.170 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6926
+[ 15.4%] Iter   94/610 | SPS: 27930 | Reward:  0.088 | Value:  0.162 | VLoss: 0.0452 | PLoss: -0.0001 | Ent: 0.6924
+[ 15.6%] Iter   95/610 | SPS: 27932 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0499 | PLoss: -0.0000 | Ent: 0.6924
+[ 15.7%] Iter   96/610 | SPS: 27935 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6927
+[ 15.9%] Iter   97/610 | SPS: 27939 | Reward:  0.090 | Value:  0.177 | VLoss: 0.0497 | PLoss: 0.0000 | Ent: 0.6928
+[ 16.1%] Iter   98/610 | SPS: 27941 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0481 | PLoss: -0.0001 | Ent: 0.6929
+[ 16.2%] Iter   99/610 | SPS: 27941 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0490 | PLoss: -0.0001 | Ent: 0.6929
+[ 16.4%] Iter  100/610 | SPS: 27937 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0495 | PLoss: -0.0000 | Ent: 0.6929
+[ 16.6%] Iter  101/610 | SPS: 27937 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0438 | PLoss: -0.0002 | Ent: 0.6930
+[ 16.7%] Iter  102/610 | SPS: 27939 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0001 | Ent: 0.6930
+[ 16.9%] Iter  103/610 | SPS: 27942 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0466 | PLoss: 0.0001 | Ent: 0.6929
+[ 17.0%] Iter  104/610 | SPS: 27942 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0436 | PLoss: -0.0001 | Ent: 0.6929
+[ 17.2%] Iter  105/610 | SPS: 27945 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6929
+[ 17.4%] Iter  106/610 | SPS: 27947 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6929
+[ 17.5%] Iter  107/610 | SPS: 27950 | Reward:  0.091 | Value:  0.172 | VLoss: 0.0497 | PLoss: -0.0003 | Ent: 0.6928
+[ 17.7%] Iter  108/610 | SPS: 27953 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0460 | PLoss: -0.0004 | Ent: 0.6924
+[ 17.9%] Iter  109/610 | SPS: 27955 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6921
+[ 18.0%] Iter  110/610 | SPS: 27958 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6918
+[ 18.2%] Iter  111/610 | SPS: 27963 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0484 | PLoss: -0.0002 | Ent: 0.6911
+[ 18.4%] Iter  112/610 | SPS: 27969 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6905
+[ 18.5%] Iter  113/610 | SPS: 27975 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6902
+[ 18.7%] Iter  114/610 | SPS: 27981 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6909
+[ 18.9%] Iter  115/610 | SPS: 27987 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6920
+[ 19.0%] Iter  116/610 | SPS: 27992 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0455 | PLoss: 0.0001 | Ent: 0.6922
+[ 19.2%] Iter  117/610 | SPS: 27994 | Reward:  0.085 | Value:  0.168 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6923
+[ 19.3%] Iter  118/610 | SPS: 27993 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0482 | PLoss: 0.0000 | Ent: 0.6924
+[ 19.5%] Iter  119/610 | SPS: 27999 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0497 | PLoss: -0.0001 | Ent: 0.6922
+[ 19.7%] Iter  120/610 | SPS: 28005 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6921
+[ 19.8%] Iter  121/610 | SPS: 28011 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6921
+[ 20.0%] Iter  122/610 | SPS: 28017 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6920
+[ 20.2%] Iter  123/610 | SPS: 28022 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0440 | PLoss: -0.0001 | Ent: 0.6920
+[ 20.3%] Iter  124/610 | SPS: 28027 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0488 | PLoss: -0.0000 | Ent: 0.6921
+[ 20.5%] Iter  125/610 | SPS: 28033 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0475 | PLoss: -0.0001 | Ent: 0.6923
+[ 20.7%] Iter  126/610 | SPS: 28037 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0464 | PLoss: -0.0002 | Ent: 0.6926
+[ 20.8%] Iter  127/610 | SPS: 28040 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0489 | PLoss: 0.0000 | Ent: 0.6925
+[ 21.0%] Iter  128/610 | SPS: 28045 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0466 | PLoss: 0.0001 | Ent: 0.6923
+[ 21.1%] Iter  129/610 | SPS: 28050 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0467 | PLoss: -0.0001 | Ent: 0.6923
+[ 21.3%] Iter  130/610 | SPS: 28054 | Reward:  0.084 | Value:  0.170 | VLoss: 0.0436 | PLoss: -0.0001 | Ent: 0.6920
+[ 21.5%] Iter  131/610 | SPS: 28058 | Reward:  0.088 | Value:  0.166 | VLoss: 0.0476 | PLoss: -0.0001 | Ent: 0.6921
+[ 21.6%] Iter  132/610 | SPS: 28063 | Reward:  0.091 | Value:  0.172 | VLoss: 0.0480 | PLoss: -0.0002 | Ent: 0.6924
+[ 21.8%] Iter  133/610 | SPS: 28067 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6924
+[ 22.0%] Iter  134/610 | SPS: 28071 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6923
+[ 22.1%] Iter  135/610 | SPS: 28064 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6920
+[ 22.3%] Iter  136/610 | SPS: 28063 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6916
+[ 22.5%] Iter  137/610 | SPS: 28063 | Reward:  0.086 | Value:  0.168 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6916
+[ 22.6%] Iter  138/610 | SPS: 28062 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0465 | PLoss: 0.0001 | Ent: 0.6918
+[ 22.8%] Iter  139/610 | SPS: 28062 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0444 | PLoss: -0.0001 | Ent: 0.6917
+[ 23.0%] Iter  140/610 | SPS: 28063 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0464 | PLoss: -0.0001 | Ent: 0.6916
+[ 23.1%] Iter  141/610 | SPS: 28064 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6914
+[ 23.3%] Iter  142/610 | SPS: 28065 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0478 | PLoss: -0.0001 | Ent: 0.6915
+[ 23.4%] Iter  143/610 | SPS: 28066 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6909
+[ 23.6%] Iter  144/610 | SPS: 28066 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0472 | PLoss: 0.0000 | Ent: 0.6908
+[ 23.8%] Iter  145/610 | SPS: 28067 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6909
+[ 23.9%] Iter  146/610 | SPS: 28066 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0506 | PLoss: -0.0001 | Ent: 0.6911
+[ 24.1%] Iter  147/610 | SPS: 28067 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0479 | PLoss: -0.0001 | Ent: 0.6915
+[ 24.3%] Iter  148/610 | SPS: 28067 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0424 | PLoss: -0.0000 | Ent: 0.6916
+[ 24.4%] Iter  149/610 | SPS: 28068 | Reward:  0.086 | Value:  0.168 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6914
+[ 24.6%] Iter  150/610 | SPS: 28068 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0483 | PLoss: -0.0004 | Ent: 0.6914
+[ 24.8%] Iter  151/610 | SPS: 28069 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6916
+[ 24.9%] Iter  152/610 | SPS: 28066 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0492 | PLoss: -0.0002 | Ent: 0.6917
+[ 25.1%] Iter  153/610 | SPS: 28063 | Reward:  0.092 | Value:  0.176 | VLoss: 0.0498 | PLoss: -0.0000 | Ent: 0.6918
+[ 25.2%] Iter  154/610 | SPS: 28066 | Reward:  0.089 | Value:  0.181 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6919
+[ 25.4%] Iter  155/610 | SPS: 28069 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0435 | PLoss: -0.0000 | Ent: 0.6919
+[ 25.6%] Iter  156/610 | SPS: 28071 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0453 | PLoss: 0.0001 | Ent: 0.6920
+[ 25.7%] Iter  157/610 | SPS: 28074 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0492 | PLoss: -0.0001 | Ent: 0.6921
+[ 25.9%] Iter  158/610 | SPS: 28076 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6921
+[ 26.1%] Iter  159/610 | SPS: 28080 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6921
+[ 26.2%] Iter  160/610 | SPS: 28082 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6920
+[ 26.4%] Iter  161/610 | SPS: 28085 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6915
+[ 26.6%] Iter  162/610 | SPS: 28088 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6912
+[ 26.7%] Iter  163/610 | SPS: 28090 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0467 | PLoss: 0.0000 | Ent: 0.6909
+[ 26.9%] Iter  164/610 | SPS: 28093 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0466 | PLoss: -0.0001 | Ent: 0.6905
+[ 27.0%] Iter  165/610 | SPS: 28093 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0486 | PLoss: -0.0002 | Ent: 0.6908
+[ 27.2%] Iter  166/610 | SPS: 28093 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0492 | PLoss: 0.0000 | Ent: 0.6914
+[ 27.4%] Iter  167/610 | SPS: 28093 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6918
+[ 27.5%] Iter  168/610 | SPS: 28093 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0448 | PLoss: -0.0001 | Ent: 0.6921
+[ 27.7%] Iter  169/610 | SPS: 28091 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0472 | PLoss: -0.0003 | Ent: 0.6923
+[ 27.9%] Iter  170/610 | SPS: 28089 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0475 | PLoss: -0.0001 | Ent: 0.6925
+[ 28.0%] Iter  171/610 | SPS: 28089 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0457 | PLoss: 0.0001 | Ent: 0.6927
+[ 28.2%] Iter  172/610 | SPS: 28090 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0464 | PLoss: 0.0001 | Ent: 0.6926
+[ 28.4%] Iter  173/610 | SPS: 28091 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0453 | PLoss: -0.0001 | Ent: 0.6924
+[ 28.5%] Iter  174/610 | SPS: 28094 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0461 | PLoss: -0.0001 | Ent: 0.6923
+[ 28.7%] Iter  175/610 | SPS: 28097 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6924
+[ 28.9%] Iter  176/610 | SPS: 28101 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0468 | PLoss: -0.0002 | Ent: 0.6925
+[ 29.0%] Iter  177/610 | SPS: 28103 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6926
+[ 29.2%] Iter  178/610 | SPS: 28106 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0452 | PLoss: 0.0000 | Ent: 0.6927
+[ 29.3%] Iter  179/610 | SPS: 28109 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0500 | PLoss: -0.0001 | Ent: 0.6928
+[ 29.5%] Iter  180/610 | SPS: 28111 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0439 | PLoss: -0.0001 | Ent: 0.6927
+[ 29.7%] Iter  181/610 | SPS: 28114 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0456 | PLoss: 0.0001 | Ent: 0.6928
+[ 29.8%] Iter  182/610 | SPS: 28117 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0459 | PLoss: 0.0001 | Ent: 0.6928
+[ 30.0%] Iter  183/610 | SPS: 28120 | Reward:  0.091 | Value:  0.172 | VLoss: 0.0504 | PLoss: -0.0001 | Ent: 0.6930
+[ 30.2%] Iter  184/610 | SPS: 28122 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0493 | PLoss: -0.0002 | Ent: 0.6930
+[ 30.3%] Iter  185/610 | SPS: 28125 | Reward:  0.084 | Value:  0.174 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6930
+[ 30.5%] Iter  186/610 | SPS: 28128 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6930
+[ 30.7%] Iter  187/610 | SPS: 28113 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6930
+[ 30.8%] Iter  188/610 | SPS: 28117 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0447 | PLoss: -0.0000 | Ent: 0.6930
+[ 31.0%] Iter  189/610 | SPS: 28121 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6931
+[ 31.1%] Iter  190/610 | SPS: 28125 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0484 | PLoss: -0.0001 | Ent: 0.6931
+[ 31.3%] Iter  191/610 | SPS: 28129 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0461 | PLoss: -0.0001 | Ent: 0.6930
+[ 31.5%] Iter  192/610 | SPS: 28132 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6930
+[ 31.6%] Iter  193/610 | SPS: 28135 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6930
+[ 31.8%] Iter  194/610 | SPS: 28139 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6929
+[ 32.0%] Iter  195/610 | SPS: 28142 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0445 | PLoss: -0.0002 | Ent: 0.6929
+[ 32.1%] Iter  196/610 | SPS: 28145 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6930
+[ 32.3%] Iter  197/610 | SPS: 28149 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6930
+[ 32.5%] Iter  198/610 | SPS: 28152 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0488 | PLoss: -0.0004 | Ent: 0.6930
+[ 32.6%] Iter  199/610 | SPS: 28155 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0006 | Ent: 0.6928
+[ 32.8%] Iter  200/610 | SPS: 28159 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6927
+[ 33.0%] Iter  201/610 | SPS: 28162 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0483 | PLoss: -0.0001 | Ent: 0.6927
+[ 33.1%] Iter  202/610 | SPS: 28165 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0487 | PLoss: -0.0001 | Ent: 0.6927
+[ 33.3%] Iter  203/610 | SPS: 28169 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6926
+[ 33.4%] Iter  204/610 | SPS: 28169 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6928
+[ 33.6%] Iter  205/610 | SPS: 28166 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6926
+[ 33.8%] Iter  206/610 | SPS: 28166 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0433 | PLoss: -0.0001 | Ent: 0.6925
+[ 33.9%] Iter  207/610 | SPS: 28166 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6926
+[ 34.1%] Iter  208/610 | SPS: 28167 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6925
+[ 34.3%] Iter  209/610 | SPS: 28167 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0517 | PLoss: 0.0001 | Ent: 0.6924
+[ 34.4%] Iter  210/610 | SPS: 28168 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0413 | PLoss: -0.0000 | Ent: 0.6925
+[ 34.6%] Iter  211/610 | SPS: 28169 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0480 | PLoss: -0.0002 | Ent: 0.6924
+[ 34.8%] Iter  212/610 | SPS: 28169 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6921
+[ 34.9%] Iter  213/610 | SPS: 28169 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0481 | PLoss: -0.0000 | Ent: 0.6920
+[ 35.1%] Iter  214/610 | SPS: 28169 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0455 | PLoss: -0.0003 | Ent: 0.6924
+[ 35.2%] Iter  215/610 | SPS: 28168 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0445 | PLoss: 0.0000 | Ent: 0.6925
+[ 35.4%] Iter  216/610 | SPS: 28167 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6924
+[ 35.6%] Iter  217/610 | SPS: 28166 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6921
+[ 35.7%] Iter  218/610 | SPS: 28166 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0491 | PLoss: 0.0000 | Ent: 0.6920
+[ 35.9%] Iter  219/610 | SPS: 28166 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0456 | PLoss: -0.0002 | Ent: 0.6919
+[ 36.1%] Iter  220/610 | SPS: 28167 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0464 | PLoss: 0.0000 | Ent: 0.6915
+[ 36.2%] Iter  221/610 | SPS: 28167 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0448 | PLoss: -0.0004 | Ent: 0.6906
+[ 36.4%] Iter  222/610 | SPS: 28164 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0482 | PLoss: -0.0001 | Ent: 0.6901
+[ 36.6%] Iter  223/610 | SPS: 28164 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0478 | PLoss: 0.0001 | Ent: 0.6906
+[ 36.7%] Iter  224/610 | SPS: 28164 | Reward:  0.091 | Value:  0.178 | VLoss: 0.0479 | PLoss: -0.0002 | Ent: 0.6915
+[ 36.9%] Iter  225/610 | SPS: 28164 | Reward:  0.090 | Value:  0.183 | VLoss: 0.0489 | PLoss: 0.0000 | Ent: 0.6918
+[ 37.0%] Iter  226/610 | SPS: 28164 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0468 | PLoss: -0.0002 | Ent: 0.6920
+[ 37.2%] Iter  227/610 | SPS: 28164 | Reward:  0.084 | Value:  0.175 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6918
+[ 37.4%] Iter  228/610 | SPS: 28164 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6918
+[ 37.5%] Iter  229/610 | SPS: 28163 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6918
+[ 37.7%] Iter  230/610 | SPS: 28163 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6922
+[ 37.9%] Iter  231/610 | SPS: 28162 | Reward:  0.083 | Value:  0.169 | VLoss: 0.0432 | PLoss: -0.0002 | Ent: 0.6924
+[ 38.0%] Iter  232/610 | SPS: 28162 | Reward:  0.087 | Value:  0.167 | VLoss: 0.0477 | PLoss: -0.0002 | Ent: 0.6922
+[ 38.2%] Iter  233/610 | SPS: 28161 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0493 | PLoss: -0.0001 | Ent: 0.6921
+[ 38.4%] Iter  234/610 | SPS: 28161 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6919
+[ 38.5%] Iter  235/610 | SPS: 28161 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6920
+[ 38.7%] Iter  236/610 | SPS: 28161 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0495 | PLoss: -0.0000 | Ent: 0.6922
+[ 38.9%] Iter  237/610 | SPS: 28160 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6923
+[ 39.0%] Iter  238/610 | SPS: 28158 | Reward:  0.085 | Value:  0.175 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6922
+[ 39.2%] Iter  239/610 | SPS: 28154 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6922
+[ 39.3%] Iter  240/610 | SPS: 28153 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0478 | PLoss: -0.0001 | Ent: 0.6922
+[ 39.5%] Iter  241/610 | SPS: 28152 | Reward:  0.085 | Value:  0.176 | VLoss: 0.0444 | PLoss: -0.0001 | Ent: 0.6922
+[ 39.7%] Iter  242/610 | SPS: 28152 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6924
+[ 39.8%] Iter  243/610 | SPS: 28152 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6925
+[ 40.0%] Iter  244/610 | SPS: 28151 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0465 | PLoss: -0.0001 | Ent: 0.6925
+[ 40.2%] Iter  245/610 | SPS: 28151 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6925
+[ 40.3%] Iter  246/610 | SPS: 28151 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0466 | PLoss: -0.0002 | Ent: 0.6926
+[ 40.5%] Iter  247/610 | SPS: 28150 | Reward:  0.091 | Value:  0.174 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6926
+[ 40.7%] Iter  248/610 | SPS: 28150 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6925
+[ 40.8%] Iter  249/610 | SPS: 28148 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6924
+[ 41.0%] Iter  250/610 | SPS: 28148 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6923
+[ 41.1%] Iter  251/610 | SPS: 28146 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6921
+[ 41.3%] Iter  252/610 | SPS: 28146 | Reward:  0.091 | Value:  0.174 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6919
+[ 41.5%] Iter  253/610 | SPS: 28145 | Reward:  0.088 | Value:  0.182 | VLoss: 0.0487 | PLoss: -0.0001 | Ent: 0.6919
+[ 41.6%] Iter  254/610 | SPS: 28145 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6919
+[ 41.8%] Iter  255/610 | SPS: 28143 | Reward:  0.090 | Value:  0.169 | VLoss: 0.0436 | PLoss: -0.0000 | Ent: 0.6919
+[ 42.0%] Iter  256/610 | SPS: 28142 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6919
+[ 42.1%] Iter  257/610 | SPS: 28144 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0454 | PLoss: -0.0001 | Ent: 0.6918
+[ 42.3%] Iter  258/610 | SPS: 28145 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0428 | PLoss: -0.0001 | Ent: 0.6918
+[ 42.5%] Iter  259/610 | SPS: 28147 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6917
+[ 42.6%] Iter  260/610 | SPS: 28148 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6919
+[ 42.8%] Iter  261/610 | SPS: 28149 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6919
+[ 43.0%] Iter  262/610 | SPS: 28150 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6919
+[ 43.1%] Iter  263/610 | SPS: 28152 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0465 | PLoss: -0.0001 | Ent: 0.6918
+[ 43.3%] Iter  264/610 | SPS: 28153 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0498 | PLoss: -0.0000 | Ent: 0.6917
+[ 43.4%] Iter  265/610 | SPS: 28155 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6917
+[ 43.6%] Iter  266/610 | SPS: 28157 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0461 | PLoss: -0.0002 | Ent: 0.6920
+[ 43.8%] Iter  267/610 | SPS: 28159 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0503 | PLoss: 0.0000 | Ent: 0.6921
+[ 43.9%] Iter  268/610 | SPS: 28160 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0484 | PLoss: -0.0002 | Ent: 0.6924
+[ 44.1%] Iter  269/610 | SPS: 28162 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6926
+[ 44.3%] Iter  270/610 | SPS: 28163 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0446 | PLoss: -0.0000 | Ent: 0.6926
+[ 44.4%] Iter  271/610 | SPS: 28165 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0441 | PLoss: -0.0001 | Ent: 0.6927
+[ 44.6%] Iter  272/610 | SPS: 28167 | Reward:  0.084 | Value:  0.170 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6923
+[ 44.8%] Iter  273/610 | SPS: 28167 | Reward:  0.086 | Value:  0.168 | VLoss: 0.0458 | PLoss: 0.0001 | Ent: 0.6918
+[ 44.9%] Iter  274/610 | SPS: 28168 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6913
+[ 45.1%] Iter  275/610 | SPS: 28170 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0463 | PLoss: -0.0001 | Ent: 0.6905
+[ 45.2%] Iter  276/610 | SPS: 28171 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0477 | PLoss: 0.0000 | Ent: 0.6905
+[ 45.4%] Iter  277/610 | SPS: 28172 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6908
+[ 45.6%] Iter  278/610 | SPS: 28173 | Reward:  0.087 | Value:  0.171 | VLoss: 0.0470 | PLoss: 0.0001 | Ent: 0.6910
+[ 45.7%] Iter  279/610 | SPS: 28175 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0495 | PLoss: -0.0001 | Ent: 0.6911
+[ 45.9%] Iter  280/610 | SPS: 28177 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0437 | PLoss: -0.0002 | Ent: 0.6910
+[ 46.1%] Iter  281/610 | SPS: 28178 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6905
+[ 46.2%] Iter  282/610 | SPS: 28180 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0440 | PLoss: -0.0001 | Ent: 0.6901
+[ 46.4%] Iter  283/610 | SPS: 28182 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0468 | PLoss: -0.0001 | Ent: 0.6897
+[ 46.6%] Iter  284/610 | SPS: 28183 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6901
+[ 46.7%] Iter  285/610 | SPS: 28185 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0459 | PLoss: -0.0002 | Ent: 0.6908
+[ 46.9%] Iter  286/610 | SPS: 28187 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0443 | PLoss: 0.0000 | Ent: 0.6913
+[ 47.0%] Iter  287/610 | SPS: 28189 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6914
+[ 47.2%] Iter  288/610 | SPS: 28190 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6916
+[ 47.4%] Iter  289/610 | SPS: 28192 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0468 | PLoss: -0.0001 | Ent: 0.6919
+[ 47.5%] Iter  290/610 | SPS: 28193 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6918
+[ 47.7%] Iter  291/610 | SPS: 28193 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6916
+[ 47.9%] Iter  292/610 | SPS: 28180 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6918
+[ 48.0%] Iter  293/610 | SPS: 28182 | Reward:  0.092 | Value:  0.178 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6918
+[ 48.2%] Iter  294/610 | SPS: 28185 | Reward:  0.088 | Value:  0.185 | VLoss: 0.0492 | PLoss: -0.0001 | Ent: 0.6920
+[ 48.4%] Iter  295/610 | SPS: 28187 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0474 | PLoss: -0.0003 | Ent: 0.6923
+[ 48.5%] Iter  296/610 | SPS: 28190 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6925
+[ 48.7%] Iter  297/610 | SPS: 28192 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6926
+[ 48.9%] Iter  298/610 | SPS: 28194 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6927
+[ 49.0%] Iter  299/610 | SPS: 28197 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6927
+[ 49.2%] Iter  300/610 | SPS: 28198 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0443 | PLoss: -0.0000 | Ent: 0.6928
+[ 49.3%] Iter  301/610 | SPS: 28199 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0447 | PLoss: -0.0001 | Ent: 0.6928
+[ 49.5%] Iter  302/610 | SPS: 28200 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0460 | PLoss: -0.0003 | Ent: 0.6929
+[ 49.7%] Iter  303/610 | SPS: 28202 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0429 | PLoss: 0.0000 | Ent: 0.6929
+[ 49.8%] Iter  304/610 | SPS: 28203 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0466 | PLoss: -0.0001 | Ent: 0.6929
+[ 50.0%] Iter  305/610 | SPS: 28205 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6929
+[ 50.2%] Iter  306/610 | SPS: 28207 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6929
+[ 50.3%] Iter  307/610 | SPS: 28208 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0450 | PLoss: -0.0001 | Ent: 0.6929
+[ 50.5%] Iter  308/610 | SPS: 28206 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6928
+[ 50.7%] Iter  309/610 | SPS: 28207 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6929
+[ 50.8%] Iter  310/610 | SPS: 28209 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0482 | PLoss: -0.0001 | Ent: 0.6928
+[ 51.0%] Iter  311/610 | SPS: 28210 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6928
+[ 51.1%] Iter  312/610 | SPS: 28209 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6928
+[ 51.3%] Iter  313/610 | SPS: 28210 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6928
+[ 51.5%] Iter  314/610 | SPS: 28211 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0458 | PLoss: 0.0000 | Ent: 0.6927
+[ 51.6%] Iter  315/610 | SPS: 28213 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6927
+[ 51.8%] Iter  316/610 | SPS: 28214 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6926
+[ 52.0%] Iter  317/610 | SPS: 28215 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0447 | PLoss: -0.0001 | Ent: 0.6926
+[ 52.1%] Iter  318/610 | SPS: 28216 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0450 | PLoss: 0.0000 | Ent: 0.6923
+[ 52.3%] Iter  319/610 | SPS: 28213 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0425 | PLoss: 0.0000 | Ent: 0.6921
+[ 52.5%] Iter  320/610 | SPS: 28214 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6921
+[ 52.6%] Iter  321/610 | SPS: 28215 | Reward:  0.092 | Value:  0.176 | VLoss: 0.0518 | PLoss: 0.0001 | Ent: 0.6922
+[ 52.8%] Iter  322/610 | SPS: 28216 | Reward:  0.087 | Value:  0.182 | VLoss: 0.0458 | PLoss: -0.0001 | Ent: 0.6923
+[ 53.0%] Iter  323/610 | SPS: 28217 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6924
+[ 53.1%] Iter  324/610 | SPS: 28218 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0480 | PLoss: 0.0000 | Ent: 0.6924
+[ 53.3%] Iter  325/610 | SPS: 28217 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0468 | PLoss: -0.0001 | Ent: 0.6924
+[ 53.4%] Iter  326/610 | SPS: 28217 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6924
+[ 53.6%] Iter  327/610 | SPS: 28218 | Reward:  0.090 | Value:  0.170 | VLoss: 0.0500 | PLoss: -0.0000 | Ent: 0.6924
+[ 53.8%] Iter  328/610 | SPS: 28218 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6926
+[ 53.9%] Iter  329/610 | SPS: 28219 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0451 | PLoss: -0.0001 | Ent: 0.6927
+[ 54.1%] Iter  330/610 | SPS: 28220 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6927
+[ 54.3%] Iter  331/610 | SPS: 28221 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0439 | PLoss: -0.0001 | Ent: 0.6927
+[ 54.4%] Iter  332/610 | SPS: 28223 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6927
+[ 54.6%] Iter  333/610 | SPS: 28224 | Reward:  0.085 | Value:  0.169 | VLoss: 0.0498 | PLoss: -0.0000 | Ent: 0.6928
+[ 54.8%] Iter  334/610 | SPS: 28225 | Reward:  0.089 | Value:  0.168 | VLoss: 0.0473 | PLoss: -0.0001 | Ent: 0.6927
+[ 54.9%] Iter  335/610 | SPS: 28226 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0477 | PLoss: -0.0000 | Ent: 0.6927
+[ 55.1%] Iter  336/610 | SPS: 28227 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0475 | PLoss: -0.0001 | Ent: 0.6928
+[ 55.2%] Iter  337/610 | SPS: 28228 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6929
+[ 55.4%] Iter  338/610 | SPS: 28229 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0435 | PLoss: -0.0001 | Ent: 0.6928
+[ 55.6%] Iter  339/610 | SPS: 28229 | Reward:  0.087 | Value:  0.169 | VLoss: 0.0453 | PLoss: 0.0000 | Ent: 0.6927
+[ 55.7%] Iter  340/610 | SPS: 28231 | Reward:  0.083 | Value:  0.173 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6927
+[ 55.9%] Iter  341/610 | SPS: 28231 | Reward:  0.089 | Value:  0.165 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6928
+[ 56.1%] Iter  342/610 | SPS: 28231 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0490 | PLoss: -0.0001 | Ent: 0.6929
+[ 56.2%] Iter  343/610 | SPS: 28221 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6929
+[ 56.4%] Iter  344/610 | SPS: 28220 | Reward:  0.091 | Value:  0.172 | VLoss: 0.0501 | PLoss: 0.0000 | Ent: 0.6929
+[ 56.6%] Iter  345/610 | SPS: 28218 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0462 | PLoss: -0.0001 | Ent: 0.6928
+[ 56.7%] Iter  346/610 | SPS: 28216 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6929
+[ 56.9%] Iter  347/610 | SPS: 28214 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0462 | PLoss: 0.0001 | Ent: 0.6929
+[ 57.0%] Iter  348/610 | SPS: 28212 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0465 | PLoss: 0.0000 | Ent: 0.6930
+[ 57.2%] Iter  349/610 | SPS: 28211 | Reward:  0.085 | Value:  0.177 | VLoss: 0.0461 | PLoss: 0.0001 | Ent: 0.6930
+[ 57.4%] Iter  350/610 | SPS: 28210 | Reward:  0.086 | Value:  0.167 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6930
+[ 57.5%] Iter  351/610 | SPS: 28208 | Reward:  0.089 | Value:  0.171 | VLoss: 0.0512 | PLoss: 0.0000 | Ent: 0.6930
+[ 57.7%] Iter  352/610 | SPS: 28205 | Reward:  0.085 | Value:  0.179 | VLoss: 0.0463 | PLoss: -0.0002 | Ent: 0.6930
+[ 57.9%] Iter  353/610 | SPS: 28203 | Reward:  0.088 | Value:  0.167 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6930
+[ 58.0%] Iter  354/610 | SPS: 28201 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0448 | PLoss: 0.0000 | Ent: 0.6930
+[ 58.2%] Iter  355/610 | SPS: 28199 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6930
+[ 58.4%] Iter  356/610 | SPS: 28198 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6930
+[ 58.5%] Iter  357/610 | SPS: 28196 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6930
+[ 58.7%] Iter  358/610 | SPS: 28195 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0457 | PLoss: -0.0001 | Ent: 0.6929
+[ 58.9%] Iter  359/610 | SPS: 28192 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6929
+[ 59.0%] Iter  360/610 | SPS: 28188 | Reward:  0.088 | Value:  0.179 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.2%] Iter  361/610 | SPS: 28187 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6929
+[ 59.3%] Iter  362/610 | SPS: 28186 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.5%] Iter  363/610 | SPS: 28184 | Reward:  0.089 | Value:  0.172 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.7%] Iter  364/610 | SPS: 28183 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6930
+[ 59.8%] Iter  365/610 | SPS: 28181 | Reward:  0.090 | Value:  0.177 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6930
+[ 60.0%] Iter  366/610 | SPS: 28180 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0432 | PLoss: -0.0001 | Ent: 0.6930
+[ 60.2%] Iter  367/610 | SPS: 28179 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6930
+[ 60.3%] Iter  368/610 | SPS: 28177 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0462 | PLoss: -0.0000 | Ent: 0.6930
+[ 60.5%] Iter  369/610 | SPS: 28175 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6930
+[ 60.7%] Iter  370/610 | SPS: 28176 | Reward:  0.085 | Value:  0.182 | VLoss: 0.0464 | PLoss: -0.0001 | Ent: 0.6931
+[ 60.8%] Iter  371/610 | SPS: 28178 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6930
+[ 61.0%] Iter  372/610 | SPS: 28180 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6930
+[ 61.1%] Iter  373/610 | SPS: 28182 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.3%] Iter  374/610 | SPS: 28183 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0490 | PLoss: 0.0000 | Ent: 0.6931
+[ 61.5%] Iter  375/610 | SPS: 28185 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6931
+[ 61.6%] Iter  376/610 | SPS: 28186 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6931
+[ 61.8%] Iter  377/610 | SPS: 28187 | Reward:  0.083 | Value:  0.170 | VLoss: 0.0431 | PLoss: 0.0000 | Ent: 0.6931
+[ 62.0%] Iter  378/610 | SPS: 28187 | Reward:  0.087 | Value:  0.163 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6931
+[ 62.1%] Iter  379/610 | SPS: 28190 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0452 | PLoss: 0.0000 | Ent: 0.6931
+[ 62.3%] Iter  380/610 | SPS: 28191 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.5%] Iter  381/610 | SPS: 28193 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0477 | PLoss: -0.0001 | Ent: 0.6931
+[ 62.6%] Iter  382/610 | SPS: 28195 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6931
+[ 62.8%] Iter  383/610 | SPS: 28197 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.0%] Iter  384/610 | SPS: 28199 | Reward:  0.092 | Value:  0.170 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.1%] Iter  385/610 | SPS: 28201 | Reward:  0.083 | Value:  0.184 | VLoss: 0.0446 | PLoss: -0.0001 | Ent: 0.6931
+[ 63.3%] Iter  386/610 | SPS: 28202 | Reward:  0.084 | Value:  0.163 | VLoss: 0.0448 | PLoss: 0.0000 | Ent: 0.6931
+[ 63.4%] Iter  387/610 | SPS: 28204 | Reward:  0.085 | Value:  0.167 | VLoss: 0.0437 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.6%] Iter  388/610 | SPS: 28205 | Reward:  0.090 | Value:  0.171 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.8%] Iter  389/610 | SPS: 28206 | Reward:  0.087 | Value:  0.182 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6931
+[ 63.9%] Iter  390/610 | SPS: 28207 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6931
+[ 64.1%] Iter  391/610 | SPS: 28207 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0501 | PLoss: -0.0001 | Ent: 0.6931
+[ 64.3%] Iter  392/610 | SPS: 28208 | Reward:  0.087 | Value:  0.181 | VLoss: 0.0488 | PLoss: 0.0000 | Ent: 0.6931
+[ 64.4%] Iter  393/610 | SPS: 28206 | Reward:  0.085 | Value:  0.172 | VLoss: 0.0459 | PLoss: -0.0001 | Ent: 0.6931
+[ 64.6%] Iter  394/610 | SPS: 28205 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0487 | PLoss: 0.0000 | Ent: 0.6931
+[ 64.8%] Iter  395/610 | SPS: 28202 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6931
+[ 64.9%] Iter  396/610 | SPS: 28202 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.1%] Iter  397/610 | SPS: 28204 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.2%] Iter  398/610 | SPS: 28206 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.4%] Iter  399/610 | SPS: 28208 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0431 | PLoss: 0.0000 | Ent: 0.6931
+[ 65.6%] Iter  400/610 | SPS: 28210 | Reward:  0.083 | Value:  0.173 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.7%] Iter  401/610 | SPS: 28211 | Reward:  0.088 | Value:  0.165 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6931
+[ 65.9%] Iter  402/610 | SPS: 28213 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0486 | PLoss: 0.0000 | Ent: 0.6930
+[ 66.1%] Iter  403/610 | SPS: 28214 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0479 | PLoss: 0.0000 | Ent: 0.6930
+[ 66.2%] Iter  404/610 | SPS: 28216 | Reward:  0.091 | Value:  0.173 | VLoss: 0.0505 | PLoss: 0.0000 | Ent: 0.6930
+[ 66.4%] Iter  405/610 | SPS: 28218 | Reward:  0.088 | Value:  0.182 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6930
+[ 66.6%] Iter  406/610 | SPS: 28219 | Reward:  0.084 | Value:  0.172 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6930
+[ 66.7%] Iter  407/610 | SPS: 28221 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0490 | PLoss: 0.0000 | Ent: 0.6930
+[ 66.9%] Iter  408/610 | SPS: 28223 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0447 | PLoss: -0.0000 | Ent: 0.6930
+[ 67.0%] Iter  409/610 | SPS: 28224 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0445 | PLoss: -0.0000 | Ent: 0.6930
+[ 67.2%] Iter  410/610 | SPS: 28226 | Reward:  0.089 | Value:  0.169 | VLoss: 0.0480 | PLoss: 0.0000 | Ent: 0.6929
+[ 67.4%] Iter  411/610 | SPS: 28227 | Reward:  0.090 | Value:  0.177 | VLoss: 0.0503 | PLoss: -0.0000 | Ent: 0.6930
+[ 67.5%] Iter  412/610 | SPS: 28227 | Reward:  0.085 | Value:  0.180 | VLoss: 0.0460 | PLoss: 0.0000 | Ent: 0.6930
+[ 67.7%] Iter  413/610 | SPS: 28228 | Reward:  0.089 | Value:  0.167 | VLoss: 0.0469 | PLoss: -0.0001 | Ent: 0.6930
+[ 67.9%] Iter  414/610 | SPS: 28230 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0500 | PLoss: -0.0000 | Ent: 0.6929
+[ 68.0%] Iter  415/610 | SPS: 28231 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0501 | PLoss: 0.0000 | Ent: 0.6929
+[ 68.2%] Iter  416/610 | SPS: 28233 | Reward:  0.085 | Value:  0.181 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6929
+[ 68.4%] Iter  417/610 | SPS: 28234 | Reward:  0.088 | Value:  0.167 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6929
+[ 68.5%] Iter  418/610 | SPS: 28236 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6929
+[ 68.7%] Iter  419/610 | SPS: 28238 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6929
+[ 68.9%] Iter  420/610 | SPS: 28239 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6928
+[ 69.0%] Iter  421/610 | SPS: 28241 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6928
+[ 69.2%] Iter  422/610 | SPS: 28242 | Reward:  0.087 | Value:  0.180 | VLoss: 0.0471 | PLoss: -0.0001 | Ent: 0.6929
+[ 69.3%] Iter  423/610 | SPS: 28244 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0431 | PLoss: -0.0000 | Ent: 0.6928
+[ 69.5%] Iter  424/610 | SPS: 28244 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0436 | PLoss: 0.0000 | Ent: 0.6928
+[ 69.7%] Iter  425/610 | SPS: 28245 | Reward:  0.090 | Value:  0.171 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6928
+[ 69.8%] Iter  426/610 | SPS: 28246 | Reward:  0.086 | Value:  0.181 | VLoss: 0.0431 | PLoss: -0.0001 | Ent: 0.6928
+[ 70.0%] Iter  427/610 | SPS: 28248 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6927
+[ 70.2%] Iter  428/610 | SPS: 28249 | Reward:  0.086 | Value:  0.178 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6927
+[ 70.3%] Iter  429/610 | SPS: 28249 | Reward:  0.089 | Value:  0.170 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6927
+[ 70.5%] Iter  430/610 | SPS: 28251 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6927
+[ 70.7%] Iter  431/610 | SPS: 28252 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6927
+[ 70.8%] Iter  432/610 | SPS: 28253 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0481 | PLoss: -0.0001 | Ent: 0.6927
+[ 71.0%] Iter  433/610 | SPS: 28255 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0431 | PLoss: 0.0000 | Ent: 0.6926
+[ 71.1%] Iter  434/610 | SPS: 28256 | Reward:  0.087 | Value:  0.168 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6926
+[ 71.3%] Iter  435/610 | SPS: 28258 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0425 | PLoss: 0.0000 | Ent: 0.6926
+[ 71.5%] Iter  436/610 | SPS: 28259 | Reward:  0.087 | Value:  0.167 | VLoss: 0.0482 | PLoss: -0.0000 | Ent: 0.6927
+[ 71.6%] Iter  437/610 | SPS: 28260 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0478 | PLoss: -0.0001 | Ent: 0.6926
+[ 71.8%] Iter  438/610 | SPS: 28262 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0501 | PLoss: -0.0000 | Ent: 0.6926
+[ 72.0%] Iter  439/610 | SPS: 28263 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6926
+[ 72.1%] Iter  440/610 | SPS: 28265 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6927
+[ 72.3%] Iter  441/610 | SPS: 28266 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6927
+[ 72.5%] Iter  442/610 | SPS: 28268 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6926
+[ 72.6%] Iter  443/610 | SPS: 28269 | Reward:  0.084 | Value:  0.177 | VLoss: 0.0440 | PLoss: 0.0000 | Ent: 0.6926
+[ 72.8%] Iter  444/610 | SPS: 28270 | Reward:  0.087 | Value:  0.165 | VLoss: 0.0489 | PLoss: -0.0000 | Ent: 0.6926
+[ 73.0%] Iter  445/610 | SPS: 28272 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0477 | PLoss: -0.0000 | Ent: 0.6926
+[ 73.1%] Iter  446/610 | SPS: 28273 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6926
+[ 73.3%] Iter  447/610 | SPS: 28273 | Reward:  0.089 | Value:  0.176 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6926
+[ 73.4%] Iter  448/610 | SPS: 28274 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0452 | PLoss: -0.0001 | Ent: 0.6925
+[ 73.6%] Iter  449/610 | SPS: 28275 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0452 | PLoss: 0.0000 | Ent: 0.6924
+[ 73.8%] Iter  450/610 | SPS: 28276 | Reward:  0.089 | Value:  0.179 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6924
+[ 73.9%] Iter  451/610 | SPS: 28277 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0486 | PLoss: -0.0001 | Ent: 0.6925
+[ 74.1%] Iter  452/610 | SPS: 28278 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6925
+[ 74.3%] Iter  453/610 | SPS: 28279 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6925
+[ 74.4%] Iter  454/610 | SPS: 28280 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0481 | PLoss: 0.0000 | Ent: 0.6926
+[ 74.6%] Iter  455/610 | SPS: 28281 | Reward:  0.090 | Value:  0.175 | VLoss: 0.0494 | PLoss: -0.0001 | Ent: 0.6927
+[ 74.8%] Iter  456/610 | SPS: 28282 | Reward:  0.089 | Value:  0.181 | VLoss: 0.0455 | PLoss: -0.0000 | Ent: 0.6927
+[ 74.9%] Iter  457/610 | SPS: 28283 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6926
+[ 75.1%] Iter  458/610 | SPS: 28284 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6927
+[ 75.2%] Iter  459/610 | SPS: 28285 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6927
+[ 75.4%] Iter  460/610 | SPS: 28286 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0461 | PLoss: -0.0000 | Ent: 0.6927
+[ 75.6%] Iter  461/610 | SPS: 28287 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0476 | PLoss: -0.0000 | Ent: 0.6927
+[ 75.7%] Iter  462/610 | SPS: 28288 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0454 | PLoss: 0.0000 | Ent: 0.6927
+[ 75.9%] Iter  463/610 | SPS: 28289 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0472 | PLoss: 0.0000 | Ent: 0.6927
+[ 76.1%] Iter  464/610 | SPS: 28289 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6928
+[ 76.2%] Iter  465/610 | SPS: 28290 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6927
+[ 76.4%] Iter  466/610 | SPS: 28292 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0439 | PLoss: -0.0000 | Ent: 0.6927
+[ 76.6%] Iter  467/610 | SPS: 28293 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0460 | PLoss: -0.0001 | Ent: 0.6925
+[ 76.7%] Iter  468/610 | SPS: 28294 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6925
+[ 76.9%] Iter  469/610 | SPS: 28295 | Reward:  0.088 | Value:  0.168 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6925
+[ 77.0%] Iter  470/610 | SPS: 28296 | Reward:  0.093 | Value:  0.176 | VLoss: 0.0517 | PLoss: -0.0000 | Ent: 0.6924
+[ 77.2%] Iter  471/610 | SPS: 28297 | Reward:  0.091 | Value:  0.185 | VLoss: 0.0451 | PLoss: -0.0001 | Ent: 0.6924
+[ 77.4%] Iter  472/610 | SPS: 28298 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0455 | PLoss: -0.0001 | Ent: 0.6923
+[ 77.5%] Iter  473/610 | SPS: 28299 | Reward:  0.085 | Value:  0.170 | VLoss: 0.0462 | PLoss: -0.0000 | Ent: 0.6922
+[ 77.7%] Iter  474/610 | SPS: 28300 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0468 | PLoss: 0.0000 | Ent: 0.6922
+[ 77.9%] Iter  475/610 | SPS: 28301 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6922
+[ 78.0%] Iter  476/610 | SPS: 28302 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0439 | PLoss: -0.0001 | Ent: 0.6922
+[ 78.2%] Iter  477/610 | SPS: 28303 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6922
+[ 78.4%] Iter  478/610 | SPS: 28303 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6922
+[ 78.5%] Iter  479/610 | SPS: 28304 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0001 | Ent: 0.6922
+[ 78.7%] Iter  480/610 | SPS: 28305 | Reward:  0.087 | Value:  0.178 | VLoss: 0.0449 | PLoss: -0.0000 | Ent: 0.6923
+[ 78.9%] Iter  481/610 | SPS: 28305 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6924
+[ 79.0%] Iter  482/610 | SPS: 28305 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0432 | PLoss: 0.0000 | Ent: 0.6923
+[ 79.2%] Iter  483/610 | SPS: 28305 | Reward:  0.090 | Value:  0.168 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6923
+[ 79.3%] Iter  484/610 | SPS: 28305 | Reward:  0.088 | Value:  0.180 | VLoss: 0.0461 | PLoss: 0.0000 | Ent: 0.6923
+[ 79.5%] Iter  485/610 | SPS: 28306 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0510 | PLoss: -0.0000 | Ent: 0.6922
+[ 79.7%] Iter  486/610 | SPS: 28306 | Reward:  0.089 | Value:  0.180 | VLoss: 0.0449 | PLoss: -0.0001 | Ent: 0.6921
+[ 79.8%] Iter  487/610 | SPS: 28307 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0471 | PLoss: -0.0000 | Ent: 0.6920
+[ 80.0%] Iter  488/610 | SPS: 28308 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6920
+[ 80.2%] Iter  489/610 | SPS: 28308 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6921
+[ 80.3%] Iter  490/610 | SPS: 28308 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0484 | PLoss: -0.0000 | Ent: 0.6921
+[ 80.5%] Iter  491/610 | SPS: 28309 | Reward:  0.091 | Value:  0.176 | VLoss: 0.0474 | PLoss: 0.0000 | Ent: 0.6921
+[ 80.7%] Iter  492/610 | SPS: 28309 | Reward:  0.087 | Value:  0.183 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6921
+[ 80.8%] Iter  493/610 | SPS: 28309 | Reward:  0.086 | Value:  0.172 | VLoss: 0.0440 | PLoss: -0.0000 | Ent: 0.6922
+[ 81.0%] Iter  494/610 | SPS: 28310 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0493 | PLoss: 0.0000 | Ent: 0.6922
+[ 81.1%] Iter  495/610 | SPS: 28310 | Reward:  0.086 | Value:  0.180 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6923
+[ 81.3%] Iter  496/610 | SPS: 28310 | Reward:  0.088 | Value:  0.170 | VLoss: 0.0460 | PLoss: 0.0000 | Ent: 0.6924
+[ 81.5%] Iter  497/610 | SPS: 28311 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0502 | PLoss: -0.0000 | Ent: 0.6924
+[ 81.6%] Iter  498/610 | SPS: 28311 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0448 | PLoss: -0.0000 | Ent: 0.6924
+[ 81.8%] Iter  499/610 | SPS: 28311 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6924
+[ 82.0%] Iter  500/610 | SPS: 28311 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0473 | PLoss: 0.0000 | Ent: 0.6924
+[ 82.1%] Iter  501/610 | SPS: 28311 | Reward:  0.084 | Value:  0.176 | VLoss: 0.0475 | PLoss: -0.0000 | Ent: 0.6924
+[ 82.3%] Iter  502/610 | SPS: 28312 | Reward:  0.091 | Value:  0.166 | VLoss: 0.0502 | PLoss: -0.0000 | Ent: 0.6924
+[ 82.5%] Iter  503/610 | SPS: 28312 | Reward:  0.088 | Value:  0.183 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6924
+[ 82.6%] Iter  504/610 | SPS: 28313 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0490 | PLoss: 0.0000 | Ent: 0.6924
+[ 82.8%] Iter  505/610 | SPS: 28313 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0495 | PLoss: 0.0000 | Ent: 0.6924
+[ 83.0%] Iter  506/610 | SPS: 28313 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0436 | PLoss: 0.0000 | Ent: 0.6925
+[ 83.1%] Iter  507/610 | SPS: 28314 | Reward:  0.090 | Value:  0.172 | VLoss: 0.0485 | PLoss: 0.0000 | Ent: 0.6924
+[ 83.3%] Iter  508/610 | SPS: 28314 | Reward:  0.089 | Value:  0.181 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6924
+[ 83.4%] Iter  509/610 | SPS: 28314 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0486 | PLoss: -0.0000 | Ent: 0.6924
+[ 83.6%] Iter  510/610 | SPS: 28314 | Reward:  0.089 | Value:  0.168 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6924
+[ 83.8%] Iter  511/610 | SPS: 28314 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6924
+[ 83.9%] Iter  512/610 | SPS: 28314 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0483 | PLoss: 0.0000 | Ent: 0.6924
+[ 84.1%] Iter  513/610 | SPS: 28314 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6923
+[ 84.3%] Iter  514/610 | SPS: 28315 | Reward:  0.090 | Value:  0.173 | VLoss: 0.0479 | PLoss: -0.0000 | Ent: 0.6922
+[ 84.4%] Iter  515/610 | SPS: 28316 | Reward:  0.085 | Value:  0.180 | VLoss: 0.0436 | PLoss: -0.0000 | Ent: 0.6923
+[ 84.6%] Iter  516/610 | SPS: 28317 | Reward:  0.090 | Value:  0.168 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6924
+[ 84.8%] Iter  517/610 | SPS: 28317 | Reward:  0.085 | Value:  0.178 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6925
+[ 84.9%] Iter  518/610 | SPS: 28317 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6925
+[ 85.1%] Iter  519/610 | SPS: 28319 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0481 | PLoss: -0.0001 | Ent: 0.6926
+[ 85.2%] Iter  520/610 | SPS: 28319 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6926
+[ 85.4%] Iter  521/610 | SPS: 28320 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0444 | PLoss: -0.0000 | Ent: 0.6926
+[ 85.6%] Iter  522/610 | SPS: 28321 | Reward:  0.088 | Value:  0.172 | VLoss: 0.0470 | PLoss: -0.0000 | Ent: 0.6926
+[ 85.7%] Iter  523/610 | SPS: 28321 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0469 | PLoss: 0.0000 | Ent: 0.6926
+[ 85.9%] Iter  524/610 | SPS: 28322 | Reward:  0.088 | Value:  0.175 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6926
+[ 86.1%] Iter  525/610 | SPS: 28323 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6926
+[ 86.2%] Iter  526/610 | SPS: 28324 | Reward:  0.086 | Value:  0.171 | VLoss: 0.0452 | PLoss: -0.0000 | Ent: 0.6926
+[ 86.4%] Iter  527/610 | SPS: 28325 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0477 | PLoss: 0.0000 | Ent: 0.6926
+[ 86.6%] Iter  528/610 | SPS: 28326 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0451 | PLoss: -0.0000 | Ent: 0.6927
+[ 86.7%] Iter  529/610 | SPS: 28327 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0455 | PLoss: 0.0000 | Ent: 0.6927
+[ 86.9%] Iter  530/610 | SPS: 28327 | Reward:  0.087 | Value:  0.170 | VLoss: 0.0457 | PLoss: -0.0000 | Ent: 0.6927
+[ 87.0%] Iter  531/610 | SPS: 28328 | Reward:  0.091 | Value:  0.173 | VLoss: 0.0493 | PLoss: -0.0000 | Ent: 0.6927
+[ 87.2%] Iter  532/610 | SPS: 28329 | Reward:  0.089 | Value:  0.181 | VLoss: 0.0453 | PLoss: -0.0000 | Ent: 0.6926
+[ 87.4%] Iter  533/610 | SPS: 28329 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6927
+[ 87.5%] Iter  534/610 | SPS: 28330 | Reward:  0.088 | Value:  0.169 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6927
+[ 87.7%] Iter  535/610 | SPS: 28331 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0494 | PLoss: -0.0000 | Ent: 0.6926
+[ 87.9%] Iter  536/610 | SPS: 28332 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0456 | PLoss: 0.0000 | Ent: 0.6926
+[ 88.0%] Iter  537/610 | SPS: 28333 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6926
+[ 88.2%] Iter  538/610 | SPS: 28334 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0500 | PLoss: -0.0000 | Ent: 0.6926
+[ 88.4%] Iter  539/610 | SPS: 28335 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6926
+[ 88.5%] Iter  540/610 | SPS: 28337 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0480 | PLoss: 0.0000 | Ent: 0.6926
+[ 88.7%] Iter  541/610 | SPS: 28338 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0465 | PLoss: -0.0000 | Ent: 0.6926
+[ 88.9%] Iter  542/610 | SPS: 28339 | Reward:  0.090 | Value:  0.179 | VLoss: 0.0485 | PLoss: -0.0000 | Ent: 0.6926
+[ 89.0%] Iter  543/610 | SPS: 28339 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6926
+[ 89.2%] Iter  544/610 | SPS: 28340 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6926
+[ 89.3%] Iter  545/610 | SPS: 28341 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0474 | PLoss: -0.0000 | Ent: 0.6925
+[ 89.5%] Iter  546/610 | SPS: 28342 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6925
+[ 89.7%] Iter  547/610 | SPS: 28343 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0480 | PLoss: -0.0000 | Ent: 0.6925
+[ 89.8%] Iter  548/610 | SPS: 28344 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6924
+[ 90.0%] Iter  549/610 | SPS: 28344 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0456 | PLoss: 0.0000 | Ent: 0.6924
+[ 90.2%] Iter  550/610 | SPS: 28345 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0473 | PLoss: -0.0000 | Ent: 0.6924
+[ 90.3%] Iter  551/610 | SPS: 28346 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0454 | PLoss: -0.0000 | Ent: 0.6925
+[ 90.5%] Iter  552/610 | SPS: 28346 | Reward:  0.085 | Value:  0.171 | VLoss: 0.0424 | PLoss: -0.0000 | Ent: 0.6925
+[ 90.7%] Iter  553/610 | SPS: 28347 | Reward:  0.086 | Value:  0.170 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6925
+[ 90.8%] Iter  554/610 | SPS: 28348 | Reward:  0.088 | Value:  0.171 | VLoss: 0.0440 | PLoss: -0.0000 | Ent: 0.6926
+[ 91.0%] Iter  555/610 | SPS: 28349 | Reward:  0.092 | Value:  0.174 | VLoss: 0.0494 | PLoss: 0.0000 | Ent: 0.6926
+[ 91.1%] Iter  556/610 | SPS: 28350 | Reward:  0.088 | Value:  0.181 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6925
+[ 91.3%] Iter  557/610 | SPS: 28351 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6925
+[ 91.5%] Iter  558/610 | SPS: 28352 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6925
+[ 91.6%] Iter  559/610 | SPS: 28352 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6925
+[ 91.8%] Iter  560/610 | SPS: 28353 | Reward:  0.087 | Value:  0.176 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6925
+[ 92.0%] Iter  561/610 | SPS: 28354 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0484 | PLoss: 0.0000 | Ent: 0.6925
+[ 92.1%] Iter  562/610 | SPS: 28355 | Reward:  0.090 | Value:  0.178 | VLoss: 0.0492 | PLoss: -0.0000 | Ent: 0.6925
+[ 92.3%] Iter  563/610 | SPS: 28356 | Reward:  0.087 | Value:  0.179 | VLoss: 0.0466 | PLoss: 0.0000 | Ent: 0.6925
+[ 92.5%] Iter  564/610 | SPS: 28357 | Reward:  0.089 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6925
+[ 92.6%] Iter  565/610 | SPS: 28358 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6925
+[ 92.8%] Iter  566/610 | SPS: 28358 | Reward:  0.086 | Value:  0.177 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6925
+[ 93.0%] Iter  567/610 | SPS: 28359 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0466 | PLoss: -0.0000 | Ent: 0.6925
+[ 93.1%] Iter  568/610 | SPS: 28360 | Reward:  0.084 | Value:  0.173 | VLoss: 0.0449 | PLoss: 0.0000 | Ent: 0.6925
+[ 93.3%] Iter  569/610 | SPS: 28359 | Reward:  0.091 | Value:  0.170 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6925
+[ 93.4%] Iter  570/610 | SPS: 28357 | Reward:  0.084 | Value:  0.176 | VLoss: 0.0484 | PLoss: 0.0000 | Ent: 0.6925
+[ 93.6%] Iter  571/610 | SPS: 28357 | Reward:  0.085 | Value:  0.173 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6925
+[ 93.8%] Iter  572/610 | SPS: 28358 | Reward:  0.092 | Value:  0.169 | VLoss: 0.0506 | PLoss: -0.0000 | Ent: 0.6925
+[ 93.9%] Iter  573/610 | SPS: 28359 | Reward:  0.088 | Value:  0.177 | VLoss: 0.0441 | PLoss: -0.0000 | Ent: 0.6925
+[ 94.1%] Iter  574/610 | SPS: 28360 | Reward:  0.088 | Value:  0.178 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6925
+[ 94.3%] Iter  575/610 | SPS: 28361 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0467 | PLoss: -0.0000 | Ent: 0.6925
+[ 94.4%] Iter  576/610 | SPS: 28362 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6925
+[ 94.6%] Iter  577/610 | SPS: 28363 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0462 | PLoss: 0.0000 | Ent: 0.6925
+[ 94.8%] Iter  578/610 | SPS: 28364 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0468 | PLoss: -0.0000 | Ent: 0.6924
+[ 94.9%] Iter  579/610 | SPS: 28364 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0469 | PLoss: -0.0000 | Ent: 0.6924
+[ 95.1%] Iter  580/610 | SPS: 28366 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0479 | PLoss: 0.0000 | Ent: 0.6924
+[ 95.2%] Iter  581/610 | SPS: 28367 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0442 | PLoss: -0.0000 | Ent: 0.6924
+[ 95.4%] Iter  582/610 | SPS: 28368 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0457 | PLoss: 0.0000 | Ent: 0.6924
+[ 95.6%] Iter  583/610 | SPS: 28368 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0483 | PLoss: -0.0000 | Ent: 0.6924
+[ 95.7%] Iter  584/610 | SPS: 28369 | Reward:  0.088 | Value:  0.173 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6924
+[ 95.9%] Iter  585/610 | SPS: 28370 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0456 | PLoss: -0.0000 | Ent: 0.6924
+[ 96.1%] Iter  586/610 | SPS: 28370 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0458 | PLoss: -0.0000 | Ent: 0.6924
+[ 96.2%] Iter  587/610 | SPS: 28370 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0476 | PLoss: 0.0000 | Ent: 0.6924
+[ 96.4%] Iter  588/610 | SPS: 28371 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0456 | PLoss: 0.0000 | Ent: 0.6924
+[ 96.6%] Iter  589/610 | SPS: 28372 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0499 | PLoss: 0.0000 | Ent: 0.6923
+[ 96.7%] Iter  590/610 | SPS: 28373 | Reward:  0.090 | Value:  0.174 | VLoss: 0.0490 | PLoss: -0.0000 | Ent: 0.6923
+[ 96.9%] Iter  591/610 | SPS: 28375 | Reward:  0.088 | Value:  0.176 | VLoss: 0.0478 | PLoss: -0.0000 | Ent: 0.6923
+[ 97.0%] Iter  592/610 | SPS: 28376 | Reward:  0.089 | Value:  0.177 | VLoss: 0.0460 | PLoss: -0.0000 | Ent: 0.6923
+[ 97.2%] Iter  593/610 | SPS: 28376 | Reward:  0.087 | Value:  0.177 | VLoss: 0.0471 | PLoss: 0.0000 | Ent: 0.6923
+[ 97.4%] Iter  594/610 | SPS: 28377 | Reward:  0.090 | Value:  0.176 | VLoss: 0.0491 | PLoss: 0.0000 | Ent: 0.6923
+[ 97.5%] Iter  595/610 | SPS: 28378 | Reward:  0.086 | Value:  0.176 | VLoss: 0.0478 | PLoss: 0.0000 | Ent: 0.6923
+[ 97.7%] Iter  596/610 | SPS: 28379 | Reward:  0.087 | Value:  0.175 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6923
+[ 97.9%] Iter  597/610 | SPS: 28380 | Reward:  0.088 | Value:  0.174 | VLoss: 0.0486 | PLoss: 0.0000 | Ent: 0.6923
+[ 98.0%] Iter  598/610 | SPS: 28381 | Reward:  0.085 | Value:  0.174 | VLoss: 0.0472 | PLoss: -0.0000 | Ent: 0.6924
+[ 98.2%] Iter  599/610 | SPS: 28382 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0450 | PLoss: -0.0000 | Ent: 0.6924
+[ 98.4%] Iter  600/610 | SPS: 28383 | Reward:  0.087 | Value:  0.173 | VLoss: 0.0475 | PLoss: 0.0000 | Ent: 0.6924
+[ 98.5%] Iter  601/610 | SPS: 28384 | Reward:  0.086 | Value:  0.173 | VLoss: 0.0463 | PLoss: 0.0000 | Ent: 0.6923
+[ 98.7%] Iter  602/610 | SPS: 28385 | Reward:  0.087 | Value:  0.172 | VLoss: 0.0463 | PLoss: -0.0000 | Ent: 0.6924
+[ 98.9%] Iter  603/610 | SPS: 28386 | Reward:  0.089 | Value:  0.173 | VLoss: 0.0491 | PLoss: -0.0000 | Ent: 0.6924
+[ 99.0%] Iter  604/610 | SPS: 28386 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6923
+[ 99.2%] Iter  605/610 | SPS: 28386 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0451 | PLoss: 0.0000 | Ent: 0.6924
+[ 99.3%] Iter  606/610 | SPS: 28387 | Reward:  0.086 | Value:  0.175 | VLoss: 0.0464 | PLoss: -0.0000 | Ent: 0.6923
+[ 99.5%] Iter  607/610 | SPS: 28388 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0470 | PLoss: 0.0000 | Ent: 0.6924
+[ 99.7%] Iter  608/610 | SPS: 28389 | Reward:  0.086 | Value:  0.174 | VLoss: 0.0459 | PLoss: -0.0000 | Ent: 0.6923
+[ 99.8%] Iter  609/610 | SPS: 28389 | Reward:  0.087 | Value:  0.174 | VLoss: 0.0487 | PLoss: -0.0000 | Ent: 0.6923
+[100.0%] Iter  610/610 | SPS: 28390 | Reward:  0.089 | Value:  0.174 | VLoss: 0.0446 | PLoss: -0.0000 | Ent: 0.6924

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/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_102633-lu2iu68t/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:26:33.725426Z",
+  "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":  "30509887488"
+    }
+  },
+  "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":  "6ymqnqubvr99vvj2hajaxngee30bwzdk"
+}

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/logs/debug-internal.log

@@ -0,0 +1,225 @@
+{"time":"2025-11-07T10:26:33.988521172+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T10:26:34.459274234+08:00","level":"INFO","msg":"stream: created new stream","id":"lu2iu68t"}
+{"time":"2025-11-07T10:26:34.459631305+08:00","level":"INFO","msg":"handler: started","stream_id":"lu2iu68t"}
+{"time":"2025-11-07T10:26:34.462877596+08:00","level":"INFO","msg":"stream: started","id":"lu2iu68t"}
+{"time":"2025-11-07T10:26:34.462890194+08:00","level":"INFO","msg":"writer: started","stream_id":"lu2iu68t"}
+{"time":"2025-11-07T10:26:34.462896873+08:00","level":"INFO","msg":"sender: started","stream_id":"lu2iu68t"}
+{"time":"2025-11-07T10:26:34.849513804+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T10:26:44.983958473+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T10:26:44.984581369+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__1762482386\")","namespace":""}
+{"time":"2025-11-07T10:26:44.986307004+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Bandit__ppo_bandit__1__1762482386/events.out.tfevents.1762482394.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.132004.0","runPath":"runs/Bandit__ppo_bandit__1__1762482386/events.out.tfevents.1762482394.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.132004.0"}
+{"time":"2025-11-07T10:26:44.990870062+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":527}
+{"time":"2025-11-07T10:26:44.990963594+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:26:49.995612799+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":595}
+{"time":"2025-11-07T10:26:50.232894155+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":319}
+{"time":"2025-11-07T10:26:55.002055348+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":966}
+{"time":"2025-11-07T10:26:55.002149962+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:26:55.002562082+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":998}
+{"time":"2025-11-07T10:26:55.009356397+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:27:05.018193552+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1664}
+{"time":"2025-11-07T10:27:05.331667668+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:27:10.031761756+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2307}
+{"time":"2025-11-07T10:27:10.031836934+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:15.03775749+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2500}
+{"time":"2025-11-07T10:27:15.037865133+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:15.038270114+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2532}
+{"time":"2025-11-07T10:27:15.039543895+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":147}
+{"time":"2025-11-07T10:27:20.044229233+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2730}
+{"time":"2025-11-07T10:27:20.326495928+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":281}
+{"time":"2025-11-07T10:27:25.050848255+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3097}
+{"time":"2025-11-07T10:27:25.05091684+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:25.051418353+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3129}
+{"time":"2025-11-07T10:27:25.053863604+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":249}
+{"time":"2025-11-07T10:27:30.057397574+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3429}
+{"time":"2025-11-07T10:27:30.057494707+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:30.057854865+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3461}
+{"time":"2025-11-07T10:27:30.060495635+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":259}
+{"time":"2025-11-07T10:27:35.07649203+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3797}
+{"time":"2025-11-07T10:27:35.27622333+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":280}
+{"time":"2025-11-07T10:27:40.083967862+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4128}
+{"time":"2025-11-07T10:27:40.084146434+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:40.084472099+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4160}
+{"time":"2025-11-07T10:27:40.086936595+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:27:45.092861781+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4496}
+{"time":"2025-11-07T10:27:45.092928318+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:45.093417362+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4528}
+{"time":"2025-11-07T10:27:45.09732899+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:27:50.100469955+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4827}
+{"time":"2025-11-07T10:27:50.339439289+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:27:55.107527698+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5203}
+{"time":"2025-11-07T10:27:55.107591925+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:27:55.108033547+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5235}
+{"time":"2025-11-07T10:27:55.111821673+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":279}
+{"time":"2025-11-07T10:28:05.122107602+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5895}
+{"time":"2025-11-07T10:28:05.236283223+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:28:10.128830958+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6266}
+{"time":"2025-11-07T10:28:10.128925836+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:10.129460344+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6298}
+{"time":"2025-11-07T10:28:10.13199436+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":284}
+{"time":"2025-11-07T10:28:15.137230668+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6727}
+{"time":"2025-11-07T10:28:15.137336027+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:15.137720284+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6759}
+{"time":"2025-11-07T10:28:15.138856926+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":151}
+{"time":"2025-11-07T10:28:20.14295049+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6962}
+{"time":"2025-11-07T10:28:20.274436083+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":319}
+{"time":"2025-11-07T10:28:25.152046634+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7626}
+{"time":"2025-11-07T10:28:25.15216733+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:30.161394355+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7846}
+{"time":"2025-11-07T10:28:30.161474969+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:30.161877754+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7878}
+{"time":"2025-11-07T10:28:30.163607669+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":100}
+{"time":"2025-11-07T10:28:35.167466563+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8031}
+{"time":"2025-11-07T10:28:35.283489533+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:28:40.174265357+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8442}
+{"time":"2025-11-07T10:28:40.174349051+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:40.174769736+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8474}
+{"time":"2025-11-07T10:28:40.178530405+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":244}
+{"time":"2025-11-07T10:28:45.184290307+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8866}
+{"time":"2025-11-07T10:28:45.18446969+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:28:45.184790363+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8898}
+{"time":"2025-11-07T10:28:45.185974572+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":148}
+{"time":"2025-11-07T10:28:50.190177678+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9099}
+{"time":"2025-11-07T10:28:50.309608655+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:29:00.204935353+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9859}
+{"time":"2025-11-07T10:29:00.205034074+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:00.205462661+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9891}
+{"time":"2025-11-07T10:29:00.207011094+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":223}
+{"time":"2025-11-07T10:29:05.21154651+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10165}
+{"time":"2025-11-07T10:29:05.253318623+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:29:10.219829464+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10551}
+{"time":"2025-11-07T10:29:10.21991712+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:10.22034466+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10583}
+{"time":"2025-11-07T10:29:10.22287408+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":230}
+{"time":"2025-11-07T10:29:15.228375922+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11048}
+{"time":"2025-11-07T10:29:15.228428694+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:15.228890991+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11080}
+{"time":"2025-11-07T10:29:15.230953936+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":102}
+{"time":"2025-11-07T10:29:20.235020269+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11233}
+{"time":"2025-11-07T10:29:20.314026917+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":320}
+{"time":"2025-11-07T10:29:25.24166487+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11619}
+{"time":"2025-11-07T10:29:25.241780056+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:25.242814382+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11652}
+{"time":"2025-11-07T10:29:25.246017883+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":270}
+{"time":"2025-11-07T10:29:30.249524383+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12023}
+{"time":"2025-11-07T10:29:30.249602423+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:30.250043012+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12055}
+{"time":"2025-11-07T10:29:30.252450902+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":195}
+{"time":"2025-11-07T10:29:35.256840642+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12303}
+{"time":"2025-11-07T10:29:35.273715662+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:29:40.262878908+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12672}
+{"time":"2025-11-07T10:29:40.263010145+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:40.264085587+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12705}
+{"time":"2025-11-07T10:29:40.266025691+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:29:45.27048696+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13040}
+{"time":"2025-11-07T10:29:45.270586377+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:29:45.270990672+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13072}
+{"time":"2025-11-07T10:29:45.27372833+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:29:50.277657296+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13371}
+{"time":"2025-11-07T10:29:50.323990746+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":318}
+{"time":"2025-11-07T10:30:00.289980525+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14107}
+{"time":"2025-11-07T10:30:00.290096526+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:00.290474489+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14139}
+{"time":"2025-11-07T10:30:00.293801683+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":247}
+{"time":"2025-11-07T10:30:10.50009327+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14924}
+{"time":"2025-11-07T10:30:10.500155877+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:10.500665245+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14956}
+{"time":"2025-11-07T10:30:10.502914625+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":129}
+{"time":"2025-11-07T10:30:15.507664487+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15163}
+{"time":"2025-11-07T10:30:15.50775712+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:15.508234394+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15195}
+{"time":"2025-11-07T10:30:15.510794899+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":259}
+{"time":"2025-11-07T10:30:20.513938488+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15507}
+{"time":"2025-11-07T10:30:20.514102014+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:20.514489935+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15539}
+{"time":"2025-11-07T10:30:20.518286051+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:30:30.529576756+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16206}
+{"time":"2025-11-07T10:30:30.529673928+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:30.530082694+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16238}
+{"time":"2025-11-07T10:30:30.532515502+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":284}
+{"time":"2025-11-07T10:30:35.538915645+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16805}
+{"time":"2025-11-07T10:30:35.539012451+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:35.53942978+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16837}
+{"time":"2025-11-07T10:30:35.540269789+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":56}
+{"time":"2025-11-07T10:30:40.544226242+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16944}
+{"time":"2025-11-07T10:30:40.544343441+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:40.544779826+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16976}
+{"time":"2025-11-07T10:30:40.548714455+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:30:45.554068318+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17393}
+{"time":"2025-11-07T10:30:45.554160917+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:45.555212294+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17426}
+{"time":"2025-11-07T10:30:45.556956894+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":205}
+{"time":"2025-11-07T10:30:50.564112084+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17818}
+{"time":"2025-11-07T10:30:50.564991459+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:50.567275445+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17850}
+{"time":"2025-11-07T10:30:50.568448329+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":111}
+{"time":"2025-11-07T10:30:55.575175818+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18012}
+{"time":"2025-11-07T10:30:55.575313884+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:30:55.575718877+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18044}
+{"time":"2025-11-07T10:30:55.57816212+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:31:00.582052443+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18417}
+{"time":"2025-11-07T10:31:00.582137728+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:00.582667455+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18449}
+{"time":"2025-11-07T10:31:00.585301219+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":250}
+{"time":"2025-11-07T10:31:10.596861654+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19363}
+{"time":"2025-11-07T10:31:10.596914261+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:10.597466165+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19395}
+{"time":"2025-11-07T10:31:10.598123022+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":44}
+{"time":"2025-11-07T10:31:20.610659076+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19820}
+{"time":"2025-11-07T10:31:20.610764714+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:20.611124722+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19852}
+{"time":"2025-11-07T10:31:20.613309934+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:31:25.617061073+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20198}
+{"time":"2025-11-07T10:31:25.61719025+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:25.617706379+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20230}
+{"time":"2025-11-07T10:31:25.621751248+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":277}
+{"time":"2025-11-07T10:31:35.641998758+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20929}
+{"time":"2025-11-07T10:31:35.64212159+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:35.642553825+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20961}
+{"time":"2025-11-07T10:31:35.645901846+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":245}
+{"time":"2025-11-07T10:31:40.64944534+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21257}
+{"time":"2025-11-07T10:31:40.649572308+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:40.649925229+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21289}
+{"time":"2025-11-07T10:31:40.652748134+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:31:45.656732285+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21627}
+{"time":"2025-11-07T10:31:45.656804166+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:45.657157332+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21659}
+{"time":"2025-11-07T10:31:45.659331659+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:31:50.663524025+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22068}
+{"time":"2025-11-07T10:31:50.663644198+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:50.664544855+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22101}
+{"time":"2025-11-07T10:31:50.666148276+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":214}
+{"time":"2025-11-07T10:31:55.670845697+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22485}
+{"time":"2025-11-07T10:31:55.670921361+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:31:55.671330596+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22517}
+{"time":"2025-11-07T10:31:55.673056616+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":126}
+{"time":"2025-11-07T10:32:00.676947335+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22694}
+{"time":"2025-11-07T10:32:00.677057913+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:00.677427193+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22726}
+{"time":"2025-11-07T10:32:00.680283995+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":286}
+{"time":"2025-11-07T10:32:05.683856877+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23090}
+{"time":"2025-11-07T10:32:05.68395789+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:05.684365549+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23122}
+{"time":"2025-11-07T10:32:05.688121324+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":261}
+{"time":"2025-11-07T10:32:10.69230954+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23483}
+{"time":"2025-11-07T10:32:10.692383474+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:10.69277669+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23515}
+{"time":"2025-11-07T10:32:10.694559666+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":237}
+{"time":"2025-11-07T10:32:15.698531312+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23804}
+{"time":"2025-11-07T10:32:15.698590195+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:15.699153865+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23836}
+{"time":"2025-11-07T10:32:15.70155554+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":285}
+{"time":"2025-11-07T10:32:20.70670464+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24213}
+{"time":"2025-11-07T10:32:20.706773936+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:20.7071748+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24245}
+{"time":"2025-11-07T10:32:20.708921999+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":206}
+{"time":"2025-11-07T10:32:25.715336191+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24557}
+{"time":"2025-11-07T10:32:25.715410672+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:32:25.715858076+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24589}
+{"time":"2025-11-07T10:32:25.718257413+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":231}
+{"time":"2025-11-07T10:32:28.712161761+08:00","level":"INFO","msg":"stream: closing","id":"lu2iu68t"}
+{"time":"2025-11-07T10:32:28.714878124+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24866}
+{"time":"2025-11-07T10:32:28.716691076+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":200}
+{"time":"2025-11-07T10:32:30.640307526+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T10:32:31.028402195+08:00","level":"INFO","msg":"handler: closed","stream_id":"lu2iu68t"}
+{"time":"2025-11-07T10:32:31.030068564+08:00","level":"INFO","msg":"sender: closed","stream_id":"lu2iu68t"}
+{"time":"2025-11-07T10:32:31.030166843+08:00","level":"INFO","msg":"stream: closed","id":"lu2iu68t"}

cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/logs/debug.log

@@ -0,0 +1,24 @@
+2025-11-07 10:26:33,767 INFO    MainThread:132004 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 10:26:33,768 INFO    MainThread:132004 [wandb_setup.py:_flush():81] Configure stats pid to 132004
+2025-11-07 10:26:33,768 INFO    MainThread:132004 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 10:26:33,768 INFO    MainThread:132004 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 10:26:33,768 INFO    MainThread:132004 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 10:26:33,768 INFO    MainThread:132004 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/logs/debug.log
+2025-11-07 10:26:33,769 INFO    MainThread:132004 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_102633-lu2iu68t/logs/debug-internal.log
+2025-11-07 10:26:33,770 INFO    MainThread:132004 [wandb_init.py:init():833] calling init triggers
+2025-11-07 10:26:33,770 INFO    MainThread:132004 [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': 10000000, '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': 610, '_wandb': {'code_path': 'code/cleanrl/ppo_bandit.py'}}
+2025-11-07 10:26:33,770 INFO    MainThread:132004 [wandb_init.py:init():881] starting backend
+2025-11-07 10:26:33,976 INFO    MainThread:132004 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 10:26:33,986 INFO    MainThread:132004 [wandb_init.py:init():892] backend started and connected
+2025-11-07 10:26:33,987 INFO    MainThread:132004 [wandb_init.py:init():962] updated telemetry
+2025-11-07 10:26:34,019 INFO    MainThread:132004 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 10:26:34,837 INFO    MainThread:132004 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 10:26:34,980 INFO    MainThread:132004 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 10:26:34,980 INFO    MainThread:132004 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 10:26:34,980 INFO    MainThread:132004 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 10:26:34,980 INFO    MainThread:132004 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 10:26:34,982 INFO    MainThread:132004 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 10:26:34,983 INFO    MainThread:132004 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/Bandit__ppo_bandit__1__1762482386, True
+2025-11-07 10:32:28,712 INFO    wandb-AsyncioManager-main:132004 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 10:32:28,712 INFO    wandb-AsyncioManager-main:132004 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/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_103331-e2e7wd2b/files/wandb-summary.json

@@ -0,0 +1 @@
+{"losses/entropy":0.24892157,"charts/SPS":3573,"charts/learning_rate":2.5614753e-07,"_step":12687,"_wandb":{"runtime":281},"charts/avg_value":0.63738394,"_timestamp":1.762483093763157e+09,"losses/policy_loss":-1.9334257e-05,"charts/min_reward":0,"losses/approx_kl":2.8405339e-08,"_runtime":281,"global_step":999424,"losses/clipfrac":0,"losses/explained_variance":0.47075754,"losses/old_approx_kl":-1.279125e-05,"charts/max_reward":1,"charts/avg_reward":0.068359375,"losses/value_loss":0.044154726}

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/logs/debug-internal.log

@@ -0,0 +1,215 @@
+{"time":"2025-11-07T10:33:31.614061411+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T10:33:31.984255546+08:00","level":"INFO","msg":"stream: created new stream","id":"e2e7wd2b"}
+{"time":"2025-11-07T10:33:31.984490658+08:00","level":"INFO","msg":"handler: started","stream_id":"e2e7wd2b"}
+{"time":"2025-11-07T10:33:31.987878921+08:00","level":"INFO","msg":"stream: started","id":"e2e7wd2b"}
+{"time":"2025-11-07T10:33:31.987895518+08:00","level":"INFO","msg":"writer: started","stream_id":"e2e7wd2b"}
+{"time":"2025-11-07T10:33:31.987900181+08:00","level":"INFO","msg":"sender: started","stream_id":"e2e7wd2b"}
+{"time":"2025-11-07T10:33:32.409366358+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T10:33:42.545223339+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T10:33:42.545754694+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/FrozenLake__ppo_frozenlake__1__1762482804\")","namespace":""}
+{"time":"2025-11-07T10:33:42.547582969+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/FrozenLake__ppo_frozenlake__1__1762482804/events.out.tfevents.1762482812.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.132354.0","runPath":"runs/FrozenLake__ppo_frozenlake__1__1762482804/events.out.tfevents.1762482812.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.132354.0"}
+{"time":"2025-11-07T10:33:42.550551293+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":144}
+{"time":"2025-11-07T10:33:42.550636768+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:33:42.55069706+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":176}
+{"time":"2025-11-07T10:33:42.556834201+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":723}
+{"time":"2025-11-07T10:33:47.562448213+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1270}
+{"time":"2025-11-07T10:33:47.811128663+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":671}
+{"time":"2025-11-07T10:33:52.574443041+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2361}
+{"time":"2025-11-07T10:33:52.574536664+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:33:52.57506063+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2393}
+{"time":"2025-11-07T10:33:52.577088323+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":278}
+{"time":"2025-11-07T10:33:57.586920766+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3222}
+{"time":"2025-11-07T10:33:57.587008682+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:33:57.587517901+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3254}
+{"time":"2025-11-07T10:33:57.588639877+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":120}
+{"time":"2025-11-07T10:34:02.596123897+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3445}
+{"time":"2025-11-07T10:34:02.852404015+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":671}
+{"time":"2025-11-07T10:34:07.60408084+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4214}
+{"time":"2025-11-07T10:34:07.604176707+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:07.604622587+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":4246}
+{"time":"2025-11-07T10:34:07.610388793+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":606}
+{"time":"2025-11-07T10:34:12.617556092+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5312}
+{"time":"2025-11-07T10:34:12.617741948+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:12.618562139+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5344}
+{"time":"2025-11-07T10:34:12.620356592+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":246}
+{"time":"2025-11-07T10:34:17.62454859+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":5661}
+{"time":"2025-11-07T10:34:17.890320497+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":671}
+{"time":"2025-11-07T10:34:22.636094998+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6572}
+{"time":"2025-11-07T10:34:22.636173084+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:22.636651662+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":6604}
+{"time":"2025-11-07T10:34:22.639405547+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":464}
+{"time":"2025-11-07T10:34:27.645638559+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7137}
+{"time":"2025-11-07T10:34:27.645753433+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:27.646109854+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7169}
+{"time":"2025-11-07T10:34:27.652363469+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":637}
+{"time":"2025-11-07T10:34:32.681515613+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":7916}
+{"time":"2025-11-07T10:34:32.915240594+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":673}
+{"time":"2025-11-07T10:34:37.69085891+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8827}
+{"time":"2025-11-07T10:34:37.690946672+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:37.691338382+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":8859}
+{"time":"2025-11-07T10:34:37.694474541+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":466}
+{"time":"2025-11-07T10:34:42.70107648+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9812}
+{"time":"2025-11-07T10:34:42.70113031+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:42.70156025+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":9844}
+{"time":"2025-11-07T10:34:42.703109465+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":219}
+{"time":"2025-11-07T10:34:47.708115179+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":10131}
+{"time":"2025-11-07T10:34:47.818784531+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":672}
+{"time":"2025-11-07T10:34:52.7178812+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11075}
+{"time":"2025-11-07T10:34:52.717944337+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:52.718390497+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":11107}
+{"time":"2025-11-07T10:34:52.722639082+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":434}
+{"time":"2025-11-07T10:34:57.727392949+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12009}
+{"time":"2025-11-07T10:34:57.727469401+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:34:57.72793627+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12041}
+{"time":"2025-11-07T10:34:57.729845282+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":238}
+{"time":"2025-11-07T10:35:02.734452342+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":12348}
+{"time":"2025-11-07T10:35:02.87983679+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":671}
+{"time":"2025-11-07T10:35:07.745676237+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13086}
+{"time":"2025-11-07T10:35:07.745797535+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:07.746314425+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13118}
+{"time":"2025-11-07T10:35:07.752368686+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":598}
+{"time":"2025-11-07T10:35:12.757217156+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13790}
+{"time":"2025-11-07T10:35:12.757301003+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:12.758521266+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":13823}
+{"time":"2025-11-07T10:35:12.763861607+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":607}
+{"time":"2025-11-07T10:35:17.774861994+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":14515}
+{"time":"2025-11-07T10:35:17.818026612+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":638}
+{"time":"2025-11-07T10:35:22.783137701+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15352}
+{"time":"2025-11-07T10:35:22.783262767+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:22.783594236+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":15384}
+{"time":"2025-11-07T10:35:22.78903687+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":466}
+{"time":"2025-11-07T10:35:27.793419415+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16054}
+{"time":"2025-11-07T10:35:27.793474126+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:27.794054602+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16086}
+{"time":"2025-11-07T10:35:27.798455809+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":461}
+{"time":"2025-11-07T10:35:32.802503923+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":16614}
+{"time":"2025-11-07T10:35:32.890905379+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":632}
+{"time":"2025-11-07T10:35:37.811947009+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17422}
+{"time":"2025-11-07T10:35:37.812001508+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:37.8129594+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":17455}
+{"time":"2025-11-07T10:35:37.818115269+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":529}
+{"time":"2025-11-07T10:35:42.821455742+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18052}
+{"time":"2025-11-07T10:35:42.821574802+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:42.822404969+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18085}
+{"time":"2025-11-07T10:35:42.827493199+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":596}
+{"time":"2025-11-07T10:35:47.829869179+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18750}
+{"time":"2025-11-07T10:35:47.8300214+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:47.830472363+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":18782}
+{"time":"2025-11-07T10:35:47.836490956+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":598}
+{"time":"2025-11-07T10:35:52.838832173+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19449}
+{"time":"2025-11-07T10:35:52.838948252+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:52.839686209+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":19482}
+{"time":"2025-11-07T10:35:52.845167183+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":636}
+{"time":"2025-11-07T10:35:57.850237976+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20234}
+{"time":"2025-11-07T10:35:57.850307289+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:35:57.850722633+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":20266}
+{"time":"2025-11-07T10:35:57.855770193+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":590}
+{"time":"2025-11-07T10:36:02.861578838+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21050}
+{"time":"2025-11-07T10:36:02.861662775+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:02.862067037+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21082}
+{"time":"2025-11-07T10:36:02.866762453+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":473}
+{"time":"2025-11-07T10:36:07.870746776+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21663}
+{"time":"2025-11-07T10:36:07.870846506+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:07.871280938+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":21695}
+{"time":"2025-11-07T10:36:07.877814374+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":598}
+{"time":"2025-11-07T10:36:12.882238564+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22400}
+{"time":"2025-11-07T10:36:12.882318668+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:12.882852217+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":22432}
+{"time":"2025-11-07T10:36:12.888180029+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":558}
+{"time":"2025-11-07T10:36:17.892127298+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23072}
+{"time":"2025-11-07T10:36:17.892204759+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:17.893317454+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23105}
+{"time":"2025-11-07T10:36:17.898573523+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":584}
+{"time":"2025-11-07T10:36:22.902720548+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":23759}
+{"time":"2025-11-07T10:36:22.908628832+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":668}
+{"time":"2025-11-07T10:36:27.912557424+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":24495}
+{"time":"2025-11-07T10:36:27.918401209+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":629}
+{"time":"2025-11-07T10:36:32.9237659+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":25246}
+{"time":"2025-11-07T10:36:32.923903707+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:32.924341981+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":25278}
+{"time":"2025-11-07T10:36:32.927950632+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":545}
+{"time":"2025-11-07T10:36:37.931818699+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":25899}
+{"time":"2025-11-07T10:36:37.931931329+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:37.932441952+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":25931}
+{"time":"2025-11-07T10:36:37.937479402+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":589}
+{"time":"2025-11-07T10:36:42.941415016+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":26629}
+{"time":"2025-11-07T10:36:42.941540111+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:42.94202926+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":26661}
+{"time":"2025-11-07T10:36:42.945415017+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":570}
+{"time":"2025-11-07T10:36:47.952442993+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":27309}
+{"time":"2025-11-07T10:36:47.952576601+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:47.953668183+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":27342}
+{"time":"2025-11-07T10:36:47.959317083+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":615}
+{"time":"2025-11-07T10:36:52.962886709+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":28055}
+{"time":"2025-11-07T10:36:52.962990505+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:52.963498877+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":28087}
+{"time":"2025-11-07T10:36:52.969988279+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":567}
+{"time":"2025-11-07T10:36:57.973769293+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":28793}
+{"time":"2025-11-07T10:36:57.973877683+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:36:57.974266339+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":28825}
+{"time":"2025-11-07T10:36:57.979357622+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":526}
+{"time":"2025-11-07T10:37:02.983984785+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":29699}
+{"time":"2025-11-07T10:37:02.984085119+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:02.984738027+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":29732}
+{"time":"2025-11-07T10:37:02.988536482+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":359}
+{"time":"2025-11-07T10:37:07.992552162+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":30158}
+{"time":"2025-11-07T10:37:07.992641364+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:07.993144794+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":30190}
+{"time":"2025-11-07T10:37:07.999768666+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":598}
+{"time":"2025-11-07T10:37:13.003169537+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":30855}
+{"time":"2025-11-07T10:37:13.003306029+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:13.020595078+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":30887}
+{"time":"2025-11-07T10:37:13.026684616+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":598}
+{"time":"2025-11-07T10:37:18.031472188+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":31625}
+{"time":"2025-11-07T10:37:18.031549787+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:18.032131463+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":31657}
+{"time":"2025-11-07T10:37:18.037060268+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":541}
+{"time":"2025-11-07T10:37:23.047236833+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":32283}
+{"time":"2025-11-07T10:37:23.04739144+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:23.047851158+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":32315}
+{"time":"2025-11-07T10:37:23.053879662+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":607}
+{"time":"2025-11-07T10:37:28.05709474+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":32990}
+{"time":"2025-11-07T10:37:28.057182567+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:28.057616661+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":33022}
+{"time":"2025-11-07T10:37:28.063515514+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":597}
+{"time":"2025-11-07T10:37:33.067449513+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":33767}
+{"time":"2025-11-07T10:37:33.067554161+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:33.067988265+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":33799}
+{"time":"2025-11-07T10:37:33.073352637+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":519}
+{"time":"2025-11-07T10:37:38.079532496+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":34571}
+{"time":"2025-11-07T10:37:38.079665041+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:38.080211537+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":34603}
+{"time":"2025-11-07T10:37:38.084573199+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":444}
+{"time":"2025-11-07T10:37:43.091705653+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":35169}
+{"time":"2025-11-07T10:37:43.091894152+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:43.092335781+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":35201}
+{"time":"2025-11-07T10:37:43.098259744+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":552}
+{"time":"2025-11-07T10:37:48.102251363+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":35823}
+{"time":"2025-11-07T10:37:48.102370693+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:48.102926689+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":35855}
+{"time":"2025-11-07T10:37:48.1081816+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":597}
+{"time":"2025-11-07T10:37:53.115144307+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":36789}
+{"time":"2025-11-07T10:37:53.115224588+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:53.115621649+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":36821}
+{"time":"2025-11-07T10:37:53.118244946+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":328}
+{"time":"2025-11-07T10:37:58.123271446+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":37217}
+{"time":"2025-11-07T10:37:58.123403735+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:37:58.123799568+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":37249}
+{"time":"2025-11-07T10:37:58.129687573+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":597}
+{"time":"2025-11-07T10:38:03.136981758+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":38275}
+{"time":"2025-11-07T10:38:03.139718906+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":270}
+{"time":"2025-11-07T10:38:08.147352578+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":38933}
+{"time":"2025-11-07T10:38:08.147441059+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:38:08.147893762+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":38965}
+{"time":"2025-11-07T10:38:08.150157021+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":277}
+{"time":"2025-11-07T10:38:13.154973622+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":39310}
+{"time":"2025-11-07T10:38:13.155110147+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T10:38:13.155522998+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":39342}
+{"time":"2025-11-07T10:38:13.161765885+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":597}
+{"time":"2025-11-07T10:38:13.785119903+08:00","level":"INFO","msg":"stream: closing","id":"e2e7wd2b"}
+{"time":"2025-11-07T10:38:13.788036429+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":39983}
+{"time":"2025-11-07T10:38:13.789237148+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":79}
+{"time":"2025-11-07T10:38:15.846666009+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T10:38:16.491451351+08:00","level":"INFO","msg":"handler: closed","stream_id":"e2e7wd2b"}
+{"time":"2025-11-07T10:38:16.493970964+08:00","level":"INFO","msg":"sender: closed","stream_id":"e2e7wd2b"}
+{"time":"2025-11-07T10:38:16.494069974+08:00","level":"INFO","msg":"stream: closed","id":"e2e7wd2b"}

cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/logs/debug.log

@@ -0,0 +1,24 @@
+2025-11-07 10:33:31,391 INFO    MainThread:132354 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 10:33:31,391 INFO    MainThread:132354 [wandb_setup.py:_flush():81] Configure stats pid to 132354
+2025-11-07 10:33:31,392 INFO    MainThread:132354 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 10:33:31,392 INFO    MainThread:132354 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 10:33:31,392 INFO    MainThread:132354 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 10:33:31,392 INFO    MainThread:132354 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/logs/debug.log
+2025-11-07 10:33:31,393 INFO    MainThread:132354 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_103331-e2e7wd2b/logs/debug-internal.log
+2025-11-07 10:33:31,394 INFO    MainThread:132354 [wandb_init.py:init():833] calling init triggers
+2025-11-07 10:33:31,394 INFO    MainThread:132354 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'ppo_frozenlake', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'env_id': 'FrozenLake', 'total_timesteps': 1000000, 'learning_rate': 0.00025, 'num_envs': 8, 'num_steps': 128, '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, 'grid_size': 4, 'is_slippery': True, 'batch_size': 1024, 'minibatch_size': 256, 'num_iterations': 976, '_wandb': {'code_path': 'code/cleanrl/ppo_frozenlake.py'}}
+2025-11-07 10:33:31,394 INFO    MainThread:132354 [wandb_init.py:init():881] starting backend
+2025-11-07 10:33:31,600 INFO    MainThread:132354 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 10:33:31,611 INFO    MainThread:132354 [wandb_init.py:init():892] backend started and connected
+2025-11-07 10:33:31,612 INFO    MainThread:132354 [wandb_init.py:init():962] updated telemetry
+2025-11-07 10:33:31,657 INFO    MainThread:132354 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 10:33:32,396 INFO    MainThread:132354 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 10:33:32,541 INFO    MainThread:132354 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 10:33:32,541 INFO    MainThread:132354 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 10:33:32,541 INFO    MainThread:132354 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 10:33:32,542 INFO    MainThread:132354 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 10:33:32,544 INFO    MainThread:132354 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 10:33:32,544 INFO    MainThread:132354 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/FrozenLake__ppo_frozenlake__1__1762482804, True
+2025-11-07 10:38:13,785 INFO    wandb-AsyncioManager-main:132354 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 10:38:13,785 INFO    wandb-AsyncioManager-main:132354 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/files/wandb-summary.json

@@ -0,0 +1 @@
+{"_runtime":10,"_wandb":{"runtime":10}}

cleanrl/cleanrl/wandb/run-20251107_112647-9utis4xx/logs/debug-internal.log

@@ -0,0 +1,15 @@
+{"time":"2025-11-07T11:26:47.408857285+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T11:26:47.785862786+08:00","level":"INFO","msg":"stream: created new stream","id":"9utis4xx"}
+{"time":"2025-11-07T11:26:47.7861195+08:00","level":"INFO","msg":"handler: started","stream_id":"9utis4xx"}
+{"time":"2025-11-07T11:26:47.789374485+08:00","level":"INFO","msg":"stream: started","id":"9utis4xx"}
+{"time":"2025-11-07T11:26:47.789386794+08:00","level":"INFO","msg":"writer: started","stream_id":"9utis4xx"}
+{"time":"2025-11-07T11:26:47.789396256+08:00","level":"INFO","msg":"sender: started","stream_id":"9utis4xx"}
+{"time":"2025-11-07T11:26:48.283337823+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T11:26:48.527340569+08:00","level":"INFO","msg":"stream: closing","id":"9utis4xx"}
+{"time":"2025-11-07T11:26:58.418279955+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T11:26:58.421915183+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Sokoban__ppo_sokoban__1__1762486000\")","namespace":""}
+{"time":"2025-11-07T11:26:58.425154477+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/Sokoban__ppo_sokoban__1__1762486000/events.out.tfevents.1762486008.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.212707.0","runPath":"runs/Sokoban__ppo_sokoban__1__1762486000/events.out.tfevents.1762486008.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.212707.0"}
+{"time":"2025-11-07T11:26:59.120221237+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T11:26:59.418043752+08:00","level":"INFO","msg":"handler: closed","stream_id":"9utis4xx"}
+{"time":"2025-11-07T11:26:59.420537182+08:00","level":"INFO","msg":"sender: closed","stream_id":"9utis4xx"}
+{"time":"2025-11-07T11:26:59.420626397+08:00","level":"INFO","msg":"stream: closed","id":"9utis4xx"}

cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/files/output.log

@@ -0,0 +1,113 @@
+[  0.2%] Iter    1/610 | SPS:  2969 | Reward:  0.031 | Value:  0.452 | VLoss: 0.0581 | PLoss: -0.0004 | Ent: 1.3845
+[  0.3%] Iter    2/610 | SPS:  3156 | Reward:  0.031 | Value:  0.424 | VLoss: 0.0470 | PLoss: -0.0009 | Ent: 1.3818
+[  0.5%] Iter    3/610 | SPS:  2981 | Reward:  0.030 | Value:  0.410 | VLoss: 0.0447 | PLoss: -0.0015 | Ent: 1.3800
+[  0.7%] Iter    4/610 | SPS:  3308 | Reward:  0.031 | Value:  0.349 | VLoss: 0.0472 | PLoss: -0.0018 | Ent: 1.3813
+[  0.8%] Iter    5/610 | SPS:  3194 | Reward:  0.028 | Value:  0.353 | VLoss: 0.0429 | PLoss: -0.0001 | Ent: 1.3836
+[  1.0%] Iter    6/610 | SPS:  3252 | Reward:  0.028 | Value:  0.351 | VLoss: 0.0437 | PLoss: -0.0008 | Ent: 1.3848
+[  1.1%] Iter    7/610 | SPS:  3521 | Reward:  0.030 | Value:  0.344 | VLoss: 0.0445 | PLoss: -0.0005 | Ent: 1.3844
+[  1.3%] Iter    8/610 | SPS:  3629 | Reward:  0.032 | Value:  0.349 | VLoss: 0.0453 | PLoss: -0.0011 | Ent: 1.3828
+[  1.5%] Iter    9/610 | SPS:  3651 | Reward:  0.031 | Value:  0.357 | VLoss: 0.0457 | PLoss: -0.0006 | Ent: 1.3818
+[  1.6%] Iter   10/610 | SPS:  3663 | Reward:  0.029 | Value:  0.364 | VLoss: 0.0438 | PLoss: -0.0015 | Ent: 1.3807
+[  1.8%] Iter   11/610 | SPS:  3661 | Reward:  0.030 | Value:  0.378 | VLoss: 0.0445 | PLoss: -0.0010 | Ent: 1.3734
+[  2.0%] Iter   12/610 | SPS:  3624 | Reward:  0.034 | Value:  0.362 | VLoss: 0.0486 | PLoss: -0.0032 | Ent: 1.3547
+[  2.1%] Iter   13/610 | SPS:  3578 | Reward:  0.030 | Value:  0.379 | VLoss: 0.0438 | PLoss: -0.0027 | Ent: 1.3387
+[  2.3%] Iter   14/610 | SPS:  3558 | Reward:  0.034 | Value:  0.365 | VLoss: 0.0473 | PLoss: -0.0017 | Ent: 1.3347
+[  2.5%] Iter   15/610 | SPS:  3539 | Reward:  0.032 | Value:  0.371 | VLoss: 0.0470 | PLoss: -0.0028 | Ent: 1.3035
+[  2.6%] Iter   16/610 | SPS:  3523 | Reward:  0.029 | Value:  0.382 | VLoss: 0.0428 | PLoss: -0.0027 | Ent: 1.3432
+[  2.8%] Iter   17/610 | SPS:  3517 | Reward:  0.033 | Value:  0.390 | VLoss: 0.0447 | PLoss: -0.0025 | Ent: 1.3308
+[  3.0%] Iter   18/610 | SPS:  3453 | Reward:  0.034 | Value:  0.406 | VLoss: 0.0444 | PLoss: -0.0035 | Ent: 1.3329
+[  3.1%] Iter   19/610 | SPS:  3294 | Reward:  0.034 | Value:  0.399 | VLoss: 0.0465 | PLoss: -0.0021 | Ent: 1.3239
+[  3.3%] Iter   20/610 | SPS:  3162 | Reward:  0.035 | Value:  0.408 | VLoss: 0.0480 | PLoss: -0.0035 | Ent: 1.3201
+[  3.4%] Iter   21/610 | SPS:  3052 | Reward:  0.038 | Value:  0.420 | VLoss: 0.0490 | PLoss: -0.0057 | Ent: 1.2753
+[  3.6%] Iter   22/610 | SPS:  2958 | Reward:  0.038 | Value:  0.434 | VLoss: 0.0480 | PLoss: -0.0042 | Ent: 1.2446
+[  3.8%] Iter   23/610 | SPS:  2878 | Reward:  0.035 | Value:  0.425 | VLoss: 0.0458 | PLoss: -0.0034 | Ent: 1.2134
+[  3.9%] Iter   24/610 | SPS:  2808 | Reward:  0.037 | Value:  0.395 | VLoss: 0.0472 | PLoss: -0.0044 | Ent: 1.2284
+[  4.1%] Iter   25/610 | SPS:  2746 | Reward:  0.039 | Value:  0.407 | VLoss: 0.0502 | PLoss: -0.0053 | Ent: 1.1897
+[  4.3%] Iter   26/610 | SPS:  2691 | Reward:  0.042 | Value:  0.421 | VLoss: 0.0497 | PLoss: -0.0044 | Ent: 1.1790
+[  4.4%] Iter   27/610 | SPS:  2643 | Reward:  0.041 | Value:  0.445 | VLoss: 0.0483 | PLoss: -0.0035 | Ent: 1.1575
+[  4.6%] Iter   28/610 | SPS:  2599 | Reward:  0.042 | Value:  0.470 | VLoss: 0.0495 | PLoss: -0.0047 | Ent: 1.1303
+[  4.8%] Iter   29/610 | SPS:  2559 | Reward:  0.046 | Value:  0.480 | VLoss: 0.0517 | PLoss: -0.0017 | Ent: 1.1191
+[  4.9%] Iter   30/610 | SPS:  2523 | Reward:  0.047 | Value:  0.483 | VLoss: 0.0508 | PLoss: -0.0043 | Ent: 1.0895
+[  5.1%] Iter   31/610 | SPS:  2491 | Reward:  0.045 | Value:  0.508 | VLoss: 0.0488 | PLoss: -0.0063 | Ent: 1.0355
+[  5.2%] Iter   32/610 | SPS:  2461 | Reward:  0.044 | Value:  0.506 | VLoss: 0.0480 | PLoss: -0.0043 | Ent: 1.0273
+[  5.4%] Iter   33/610 | SPS:  2434 | Reward:  0.045 | Value:  0.492 | VLoss: 0.0480 | PLoss: -0.0031 | Ent: 0.9835
+[  5.6%] Iter   34/610 | SPS:  2408 | Reward:  0.046 | Value:  0.497 | VLoss: 0.0476 | PLoss: -0.0048 | Ent: 0.9524
+[  5.7%] Iter   35/610 | SPS:  2436 | Reward:  0.047 | Value:  0.522 | VLoss: 0.0478 | PLoss: -0.0026 | Ent: 0.9470
+[  5.9%] Iter   36/610 | SPS:  2478 | Reward:  0.048 | Value:  0.535 | VLoss: 0.0462 | PLoss: -0.0040 | Ent: 0.9404
+[  6.1%] Iter   37/610 | SPS:  2503 | Reward:  0.049 | Value:  0.537 | VLoss: 0.0482 | PLoss: -0.0034 | Ent: 0.9172
+[  6.2%] Iter   38/610 | SPS:  2526 | Reward:  0.051 | Value:  0.544 | VLoss: 0.0482 | PLoss: -0.0034 | Ent: 0.8812
+[  6.4%] Iter   39/610 | SPS:  2546 | Reward:  0.050 | Value:  0.532 | VLoss: 0.0478 | PLoss: -0.0020 | Ent: 0.8758
+[  6.6%] Iter   40/610 | SPS:  2556 | Reward:  0.049 | Value:  0.530 | VLoss: 0.0486 | PLoss: -0.0034 | Ent: 0.8411
+[  6.7%] Iter   41/610 | SPS:  2569 | Reward:  0.052 | Value:  0.545 | VLoss: 0.0445 | PLoss: -0.0033 | Ent: 0.8379
+[  6.9%] Iter   42/610 | SPS:  2582 | Reward:  0.049 | Value:  0.554 | VLoss: 0.0451 | PLoss: -0.0040 | Ent: 0.8258
+[  7.0%] Iter   43/610 | SPS:  2616 | Reward:  0.052 | Value:  0.546 | VLoss: 0.0453 | PLoss: -0.0043 | Ent: 0.8102
+[  7.2%] Iter   44/610 | SPS:  2643 | Reward:  0.050 | Value:  0.569 | VLoss: 0.0418 | PLoss: -0.0023 | Ent: 0.7770
+[  7.4%] Iter   45/610 | SPS:  2650 | Reward:  0.050 | Value:  0.564 | VLoss: 0.0413 | PLoss: -0.0034 | Ent: 0.7727
+[  7.5%] Iter   46/610 | SPS:  2659 | Reward:  0.048 | Value:  0.578 | VLoss: 0.0426 | PLoss: -0.0023 | Ent: 0.7614
+[  7.7%] Iter   47/610 | SPS:  2686 | Reward:  0.051 | Value:  0.591 | VLoss: 0.0421 | PLoss: -0.0034 | Ent: 0.7443
+[  7.9%] Iter   48/610 | SPS:  2703 | Reward:  0.052 | Value:  0.554 | VLoss: 0.0450 | PLoss: -0.0031 | Ent: 0.7543
+[  8.0%] Iter   49/610 | SPS:  2718 | Reward:  0.052 | Value:  0.576 | VLoss: 0.0424 | PLoss: -0.0034 | Ent: 0.7374
+[  8.2%] Iter   50/610 | SPS:  2723 | Reward:  0.052 | Value:  0.597 | VLoss: 0.0399 | PLoss: -0.0024 | Ent: 0.7337
+[  8.4%] Iter   51/610 | SPS:  2730 | Reward:  0.055 | Value:  0.573 | VLoss: 0.0441 | PLoss: -0.0028 | Ent: 0.7120
+[  8.5%] Iter   52/610 | SPS:  2733 | Reward:  0.054 | Value:  0.558 | VLoss: 0.0432 | PLoss: -0.0037 | Ent: 0.7162
+[  8.7%] Iter   53/610 | SPS:  2706 | Reward:  0.054 | Value:  0.591 | VLoss: 0.0423 | PLoss: -0.0035 | Ent: 0.6823
+[  8.9%] Iter   54/610 | SPS:  2681 | Reward:  0.056 | Value:  0.590 | VLoss: 0.0436 | PLoss: -0.0049 | Ent: 0.6676
+[  9.0%] Iter   55/610 | SPS:  2657 | Reward:  0.053 | Value:  0.592 | VLoss: 0.0405 | PLoss: -0.0015 | Ent: 0.6676
+[  9.2%] Iter   56/610 | SPS:  2634 | Reward:  0.058 | Value:  0.616 | VLoss: 0.0433 | PLoss: -0.0033 | Ent: 0.6467
+[  9.3%] Iter   57/610 | SPS:  2612 | Reward:  0.058 | Value:  0.618 | VLoss: 0.0427 | PLoss: -0.0034 | Ent: 0.6535
+[  9.5%] Iter   58/610 | SPS:  2592 | Reward:  0.053 | Value:  0.602 | VLoss: 0.0422 | PLoss: -0.0024 | Ent: 0.6411
+[  9.7%] Iter   59/610 | SPS:  2572 | Reward:  0.054 | Value:  0.606 | VLoss: 0.0388 | PLoss: -0.0043 | Ent: 0.6400
+[  9.8%] Iter   60/610 | SPS:  2554 | Reward:  0.055 | Value:  0.597 | VLoss: 0.0413 | PLoss: -0.0016 | Ent: 0.6419
+[ 10.0%] Iter   61/610 | SPS:  2536 | Reward:  0.057 | Value:  0.593 | VLoss: 0.0431 | PLoss: -0.0035 | Ent: 0.6297
+[ 10.2%] Iter   62/610 | SPS:  2519 | Reward:  0.054 | Value:  0.607 | VLoss: 0.0406 | PLoss: -0.0026 | Ent: 0.6072
+[ 10.3%] Iter   63/610 | SPS:  2503 | Reward:  0.052 | Value:  0.590 | VLoss: 0.0384 | PLoss: -0.0037 | Ent: 0.5959
+[ 10.5%] Iter   64/610 | SPS:  2487 | Reward:  0.061 | Value:  0.601 | VLoss: 0.0418 | PLoss: -0.0025 | Ent: 0.5980
+[ 10.7%] Iter   65/610 | SPS:  2473 | Reward:  0.058 | Value:  0.614 | VLoss: 0.0404 | PLoss: -0.0036 | Ent: 0.5794
+[ 10.8%] Iter   66/610 | SPS:  2458 | Reward:  0.061 | Value:  0.617 | VLoss: 0.0419 | PLoss: -0.0032 | Ent: 0.5619
+[ 11.0%] Iter   67/610 | SPS:  2445 | Reward:  0.055 | Value:  0.603 | VLoss: 0.0391 | PLoss: -0.0017 | Ent: 0.5527
+[ 11.1%] Iter   68/610 | SPS:  2432 | Reward:  0.058 | Value:  0.627 | VLoss: 0.0399 | PLoss: -0.0033 | Ent: 0.5474
+[ 11.3%] Iter   69/610 | SPS:  2419 | Reward:  0.055 | Value:  0.617 | VLoss: 0.0385 | PLoss: -0.0048 | Ent: 0.5250
+[ 11.5%] Iter   70/610 | SPS:  2407 | Reward:  0.058 | Value:  0.631 | VLoss: 0.0398 | PLoss: -0.0037 | Ent: 0.5213
+[ 11.6%] Iter   71/610 | SPS:  2408 | Reward:  0.057 | Value:  0.634 | VLoss: 0.0379 | PLoss: -0.0040 | Ent: 0.5129
+[ 11.8%] Iter   72/610 | SPS:  2426 | Reward:  0.055 | Value:  0.636 | VLoss: 0.0387 | PLoss: -0.0041 | Ent: 0.5090
+[ 12.0%] Iter   73/610 | SPS:  2431 | Reward:  0.058 | Value:  0.605 | VLoss: 0.0431 | PLoss: -0.0028 | Ent: 0.5213
+[ 12.1%] Iter   74/610 | SPS:  2442 | Reward:  0.055 | Value:  0.611 | VLoss: 0.0370 | PLoss: -0.0028 | Ent: 0.4909
+[ 12.3%] Iter   75/610 | SPS:  2458 | Reward:  0.053 | Value:  0.621 | VLoss: 0.0426 | PLoss: -0.0041 | Ent: 0.4855
+[ 12.5%] Iter   76/610 | SPS:  2470 | Reward:  0.056 | Value:  0.611 | VLoss: 0.0374 | PLoss: -0.0038 | Ent: 0.4799
+[ 12.6%] Iter   77/610 | SPS:  2477 | Reward:  0.056 | Value:  0.623 | VLoss: 0.0359 | PLoss: -0.0030 | Ent: 0.4851
+[ 12.8%] Iter   78/610 | SPS:  2488 | Reward:  0.060 | Value:  0.660 | VLoss: 0.0398 | PLoss: -0.0036 | Ent: 0.4659
+[ 13.0%] Iter   79/610 | SPS:  2484 | Reward:  0.054 | Value:  0.655 | VLoss: 0.0357 | PLoss: -0.0026 | Ent: 0.4619
+[ 13.1%] Iter   80/610 | SPS:  2472 | Reward:  0.059 | Value:  0.619 | VLoss: 0.0385 | PLoss: -0.0039 | Ent: 0.4868
+[ 13.3%] Iter   81/610 | SPS:  2469 | Reward:  0.061 | Value:  0.624 | VLoss: 0.0397 | PLoss: -0.0026 | Ent: 0.4633
+[ 13.4%] Iter   82/610 | SPS:  2484 | Reward:  0.063 | Value:  0.633 | VLoss: 0.0420 | PLoss: -0.0039 | Ent: 0.4571
+[ 13.6%] Iter   83/610 | SPS:  2487 | Reward:  0.058 | Value:  0.646 | VLoss: 0.0396 | PLoss: -0.0025 | Ent: 0.4559
+[ 13.8%] Iter   84/610 | SPS:  2496 | Reward:  0.061 | Value:  0.645 | VLoss: 0.0388 | PLoss: -0.0040 | Ent: 0.4552
+Traceback (most recent call last):
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ppo_frozenlake.py", line 224, in <module>
+    next_obs, reward, terminations, truncations, infos = envs.step(action.cpu().numpy())
+                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/vector/sync_vector_env.py", line 265, in step
+    ) = self.envs[i].step(action)
+        ^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/wrappers/common.py", line 513, in step
+    obs, reward, terminated, truncated, info = super().step(action)
+                                               ^^^^^^^^^^^^^^^^^^^^
+  File "/root/local/miniconda3/envs/ragen/lib/python3.12/site-packages/gymnasium/core.py", line 327, in step
+    return self.env.step(action)
+           ^^^^^^^^^^^^^^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/ragen_wrappers.py", line 140, in step
+    text_obs, reward, done, info = self.env.step(ragen_action)
+                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/../../ragen/env/frozen_lake/env.py", line 42, in step
+    next_obs = self.render()
+               ^^^^^^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/../../ragen/env/frozen_lake/env.py", line 57, in render
+    return '\n'.join(''.join(self.GRID_LOOKUP.get(cell, "?") for cell in row) for row in room)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/../../ragen/env/frozen_lake/env.py", line 57, in <genexpr>
+    return '\n'.join(''.join(self.GRID_LOOKUP.get(cell, "?") for cell in row) for row in room)
+                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/../../ragen/env/frozen_lake/env.py", line 57, in <genexpr>
+    return '\n'.join(''.join(self.GRID_LOOKUP.get(cell, "?") for cell in row) for row in room)
+                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+KeyboardInterrupt

cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/files/wandb-summary.json

@@ -0,0 +1 @@
+{"charts/avg_reward":0.061462402,"losses/value_loss":0.038800143,"charts/avg_value":0.6450379,"losses/entropy":0.4552039,"charts/min_reward":0,"_runtime":552,"losses/old_approx_kl":0.002151668,"_step":1091,"_wandb":{"runtime":552},"charts/max_reward":1,"charts/SPS":2496,"losses/clipfrac":0.012161255,"global_step":1376256,"losses/approx_kl":0.0012194765,"losses/explained_variance":0.34000987,"_timestamp":1.762486697135544e+09,"charts/learning_rate":0.0002159836,"losses/policy_loss":-0.004004655}

cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/logs/debug-internal.log

@@ -0,0 +1,61 @@
+{"time":"2025-11-07T11:29:03.809590629+08:00","level":"INFO","msg":"stream: starting","core version":"0.22.3"}
+{"time":"2025-11-07T11:29:04.17891044+08:00","level":"INFO","msg":"stream: created new stream","id":"8xop3upl"}
+{"time":"2025-11-07T11:29:04.179154693+08:00","level":"INFO","msg":"handler: started","stream_id":"8xop3upl"}
+{"time":"2025-11-07T11:29:04.182809549+08:00","level":"INFO","msg":"stream: started","id":"8xop3upl"}
+{"time":"2025-11-07T11:29:04.182826865+08:00","level":"INFO","msg":"writer: started","stream_id":"8xop3upl"}
+{"time":"2025-11-07T11:29:04.182830482+08:00","level":"INFO","msg":"sender: started","stream_id":"8xop3upl"}
+{"time":"2025-11-07T11:29:04.561507055+08:00","level":"ERROR","msg":"git repo not found","error":"repository does not exist"}
+{"time":"2025-11-07T11:29:14.697521027+08:00","level":"WARN","msg":"tensorboard: no root directory","error":"timed out after 10s"}
+{"time":"2025-11-07T11:29:14.699498441+08:00","level":"INFO","msg":"tensorboard: tracking new log directory","rootDir":{},"logDir":"LocalOrCloudPath(LocalPath=\"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/FrozenLake__ppo_frozenlake__1__1762486136\")","namespace":""}
+{"time":"2025-11-07T11:29:14.702330111+08:00","level":"INFO","msg":"tensorboard: saving file","fileLocation":"/mnt/general/wanghy/RAGEN/cleanrl/cleanrl/runs/FrozenLake__ppo_frozenlake__1__1762486136/events.out.tfevents.1762486144.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.213027.0","runPath":"runs/FrozenLake__ppo_frozenlake__1__1762486136/events.out.tfevents.1762486144.pt-4d654cf4576f4d23ad3d3919f12932fe-worker-0.213027.0"}
+{"time":"2025-11-07T11:29:19.714087234+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":88}
+{"time":"2025-11-07T11:29:20.046069837+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:29:29.731549556+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":173}
+{"time":"2025-11-07T11:29:29.73170942+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:29:34.741827173+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":213}
+{"time":"2025-11-07T11:29:34.940387001+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:29:39.749382062+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":263}
+{"time":"2025-11-07T11:29:39.749551017+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:29:39.749993195+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":295}
+{"time":"2025-11-07T11:29:39.751604253+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:29:44.759731315+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":337}
+{"time":"2025-11-07T11:29:44.759864472+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:29:49.770216089+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":379}
+{"time":"2025-11-07T11:29:49.964405356+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:30:04.802231794+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":504}
+{"time":"2025-11-07T11:30:04.964986531+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:30:19.832686975+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":629}
+{"time":"2025-11-07T11:30:19.969389812+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:30:34.863632824+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":754}
+{"time":"2025-11-07T11:30:34.99163122+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:30:44.880442978+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":796}
+{"time":"2025-11-07T11:30:44.880515345+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:30:49.886783384+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":838}
+{"time":"2025-11-07T11:30:50.053853179+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:31:19.93192999+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":965}
+{"time":"2025-11-07T11:31:19.95978197+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:32:05.003752828+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1176}
+{"time":"2025-11-07T11:32:05.011888005+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":6}
+{"time":"2025-11-07T11:32:15.019977901+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1222}
+{"time":"2025-11-07T11:32:15.02008222+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:33:40.173090751+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":1846}
+{"time":"2025-11-07T11:33:40.173188566+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:34:20.257965996+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2181}
+{"time":"2025-11-07T11:34:20.258025713+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:35:25.366060068+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2474}
+{"time":"2025-11-07T11:35:25.366167371+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:36:30.460497096+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2769}
+{"time":"2025-11-07T11:36:30.460618588+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:36:45.480377706+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":2853}
+{"time":"2025-11-07T11:36:45.480526292+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:37:20.534469663+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3066}
+{"time":"2025-11-07T11:37:20.53457352+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:37:30.54888915+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3148}
+{"time":"2025-11-07T11:37:30.54905724+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":1}
+{"time":"2025-11-07T11:37:30.550096767+08:00","level":"INFO","msg":"flowcontrol: backed up, offloading to disk","recordNumber":3181}
+{"time":"2025-11-07T11:37:30.551104053+08:00","level":"INFO","msg":"flowcontrol: unblocked","totalOffloaded":11}
+{"time":"2025-11-07T11:38:17.365980222+08:00","level":"INFO","msg":"stream: closing","id":"8xop3upl"}
+{"time":"2025-11-07T11:38:18.37714031+08:00","level":"INFO","msg":"fileTransfer: Close: file transfer manager closed"}
+{"time":"2025-11-07T11:38:18.683948729+08:00","level":"INFO","msg":"handler: closed","stream_id":"8xop3upl"}
+{"time":"2025-11-07T11:38:18.686201474+08:00","level":"INFO","msg":"sender: closed","stream_id":"8xop3upl"}
+{"time":"2025-11-07T11:38:18.68630277+08:00","level":"INFO","msg":"stream: closed","id":"8xop3upl"}

cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/logs/debug.log

@@ -0,0 +1,362 @@
+2025-11-07 11:29:03,586 INFO    MainThread:213027 [wandb_setup.py:_flush():81] Current SDK version is 0.22.3
+2025-11-07 11:29:03,586 INFO    MainThread:213027 [wandb_setup.py:_flush():81] Configure stats pid to 213027
+2025-11-07 11:29:03,586 INFO    MainThread:213027 [wandb_setup.py:_flush():81] Loading settings from /root/.config/wandb/settings
+2025-11-07 11:29:03,587 INFO    MainThread:213027 [wandb_setup.py:_flush():81] Loading settings from /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/settings
+2025-11-07 11:29:03,587 INFO    MainThread:213027 [wandb_setup.py:_flush():81] Loading settings from environment variables
+2025-11-07 11:29:03,587 INFO    MainThread:213027 [wandb_init.py:setup_run_log_directory():706] Logging user logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/logs/debug.log
+2025-11-07 11:29:03,587 INFO    MainThread:213027 [wandb_init.py:setup_run_log_directory():707] Logging internal logs to /mnt/general/wanghy/RAGEN/cleanrl/cleanrl/wandb/run-20251107_112903-8xop3upl/logs/debug-internal.log
+2025-11-07 11:29:03,589 INFO    MainThread:213027 [wandb_init.py:init():833] calling init triggers
+2025-11-07 11:29:03,589 INFO    MainThread:213027 [wandb_init.py:init():838] wandb.init called with sweep_config: {}
+config: {'exp_name': 'ppo_frozenlake', 'seed': 1, 'torch_deterministic': True, 'cuda': True, 'track': True, 'wandb_project_name': 'ragen-bandit', 'wandb_entity': None, 'capture_video': False, 'env_id': 'FrozenLake', 'total_timesteps': 10000000, '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, 'grid_size': 4, 'is_slippery': True, 'batch_size': 16384, 'minibatch_size': 4096, 'num_iterations': 610, '_wandb': {'code_path': 'code/cleanrl/ppo_frozenlake.py'}}
+2025-11-07 11:29:03,589 INFO    MainThread:213027 [wandb_init.py:init():881] starting backend
+2025-11-07 11:29:03,795 INFO    MainThread:213027 [wandb_init.py:init():884] sending inform_init request
+2025-11-07 11:29:03,807 INFO    MainThread:213027 [wandb_init.py:init():892] backend started and connected
+2025-11-07 11:29:03,808 INFO    MainThread:213027 [wandb_init.py:init():962] updated telemetry
+2025-11-07 11:29:03,841 INFO    MainThread:213027 [wandb_init.py:init():986] communicating run to backend with 90.0 second timeout
+2025-11-07 11:29:04,549 INFO    MainThread:213027 [wandb_init.py:init():1033] starting run threads in backend
+2025-11-07 11:29:04,693 INFO    MainThread:213027 [wandb_run.py:_console_start():2506] atexit reg
+2025-11-07 11:29:04,693 INFO    MainThread:213027 [wandb_run.py:_redirect():2354] redirect: wrap_raw
+2025-11-07 11:29:04,694 INFO    MainThread:213027 [wandb_run.py:_redirect():2423] Wrapping output streams.
+2025-11-07 11:29:04,694 INFO    MainThread:213027 [wandb_run.py:_redirect():2446] Redirects installed.
+2025-11-07 11:29:04,696 INFO    MainThread:213027 [wandb_init.py:init():1073] run started, returning control to user process
+2025-11-07 11:29:04,696 INFO    MainThread:213027 [wandb_run.py:_tensorboard_callback():1598] tensorboard callback: runs/FrozenLake__ppo_frozenlake__1__1762486136, True
+2025-11-07 11:38:17,366 INFO    wandb-AsyncioManager-main:213027 [service_client.py:_forward_responses():80] Reached EOF.
+2025-11-07 11:38:17,366 INFO    wandb-AsyncioManager-main:213027 [mailbox.py:close():137] Closing mailbox, abandoning 1 handles.
+2025-11-07 11:38:17,715 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,718 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,719 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,719 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,720 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,726 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,727 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,728 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,728 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,728 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,729 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,729 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,730 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,730 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,730 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,731 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,731 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,731 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,732 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,733 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,733 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,734 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,735 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,736 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,738 ERROR   wandb-AsyncioManager-main:213027 [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 11:38:17,739 ERROR   wandb-AsyncioManager-main:213027 [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