Add files using upload-large-folder tool

EasyR1/.gitignore

@@ -0,0 +1,184 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# 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/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# PyPI configuration file
+.pypirc
+
+# pytorch
+*.pt
+
+# outputs
+outputs/
+checkpoints/
+wandb/
+tensorboard_log/
+
+# data
+images/
+images*

EasyR1/.pre-commit-config.yaml

@@ -0,0 +1,22 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    -   id: check-ast
+    -   id: check-added-large-files
+        args: ['--maxkb=25000']
+    -   id: check-merge-conflict
+    -   id: check-yaml
+    -   id: debug-statements
+    -   id: end-of-file-fixer
+    -   id: requirements-txt-fixer
+    -   id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+    -   id: no-commit-to-branch
+        args: ['--branch', 'main']
+
+-   repo: https://github.com/asottile/pyupgrade
+    rev: v3.17.0
+    hooks:
+    -   id: pyupgrade
+        args: [--py38-plus]

EasyR1/Dockerfile

@@ -0,0 +1,68 @@
+# Start from the NVIDIA official image (ubuntu-24.04 + cuda-12.9 + python-3.12)
+# https://docs.nvidia.com/deeplearning/frameworks/pytorch-release-notes/rel-25-05.html
+FROM nvcr.io/nvidia/pytorch:25.05-py3
+
+# Define environments
+ENV MAX_JOBS=32
+ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
+ENV DEBIAN_FRONTEND=noninteractive
+ENV NODE_OPTIONS=""
+ENV PIP_ROOT_USER_ACTION=ignore
+ENV HF_HUB_ENABLE_HF_TRANSFER="1"
+
+# Define installation arguments
+ARG APT_SOURCE=https://mirrors.tuna.tsinghua.edu.cn/ubuntu/
+ARG PIP_INDEX=https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+
+# Set apt source
+RUN cp /etc/apt/sources.list /etc/apt/sources.list.bak && \
+    { \
+    echo "deb ${APT_SOURCE} jammy main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-updates main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-backports main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-security main restricted universe multiverse"; \
+    } > /etc/apt/sources.list
+
+# Install systemctl
+RUN apt-get update && \
+    apt-get install -y -o Dpkg::Options::="--force-confdef" systemd && \
+    apt-get clean
+
+# Install tini
+RUN apt-get update && \
+    apt-get install -y tini && \
+    apt-get clean
+
+# Change pip source
+RUN pip config set global.index-url "${PIP_INDEX}" && \
+    pip config set global.extra-index-url "${PIP_INDEX}" && \
+    python -m pip install --upgrade pip
+
+# Uninstall nv-pytorch fork
+RUN pip uninstall -y torch torchvision torchaudio \
+    pytorch-quantization pytorch-triton torch-tensorrt \
+    transformer-engine flash-attn apex megatron-core \
+    xgboost opencv grpcio
+
+# Remove nv file
+RUN rm -rf /workspace
+
+# Fix cv2
+RUN rm -rf /usr/local/lib/python3.10/dist-packages/cv2
+
+# Install torch-2.8.0+cu128 + vllm-0.11.0
+RUN pip install --no-cache-dir "vllm==0.11.0" "torch==2.8.0" "torchvision==0.23.0" "torchaudio==2.8.0" tensordict torchdata \
+    "transformers[hf_xet]>=4.51.0" accelerate datasets peft hf-transfer \
+    "numpy<2.0.0" "pyarrow>=15.0.0" "grpcio>=1.62.1" "optree>=0.13.0" pandas \
+    ray[default] codetiming hydra-core pylatexenc qwen-vl-utils wandb liger-kernel mathruler \
+    pytest yapf py-spy pre-commit ruff
+
+# Install flash-attn-2.8.3
+RUN ABI_FLAG=$(python -c "import torch; print('TRUE' if torch._C._GLIBCXX_USE_CXX11_ABI else 'FALSE')") && \
+    URL="https://github.com/Dao-AILab/flash-attention/releases/download/v2.8.3/flash_attn-2.8.3+cu12torch2.8cxx11abi${ABI_FLAG}-cp312-cp312-linux_x86_64.whl" && \
+    wget -nv -P /opt/tiger "${URL}" && \
+    pip install --no-cache-dir "/opt/tiger/$(basename ${URL})"
+
+# Reset pip config
+RUN pip config unset global.index-url && \
+    pip config unset global.extra-index-url

EasyR1/Dockerfile.legacy

@@ -0,0 +1,68 @@
+# Start from the NVIDIA official image (ubuntu-22.04 + cuda-12.6 + python-3.10)
+# https://docs.nvidia.com/deeplearning/frameworks/pytorch-release-notes/rel-24-08.html
+FROM nvcr.io/nvidia/pytorch:24.08-py3
+
+# Define environments
+ENV MAX_JOBS=32
+ENV VLLM_WORKER_MULTIPROC_METHOD=spawn
+ENV DEBIAN_FRONTEND=noninteractive
+ENV NODE_OPTIONS=""
+ENV PIP_ROOT_USER_ACTION=ignore
+ENV HF_HUB_ENABLE_HF_TRANSFER="1"
+
+# Define installation arguments
+ARG APT_SOURCE=https://mirrors.tuna.tsinghua.edu.cn/ubuntu/
+ARG PIP_INDEX=https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+
+# Set apt source
+RUN cp /etc/apt/sources.list /etc/apt/sources.list.bak && \
+    { \
+    echo "deb ${APT_SOURCE} jammy main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-updates main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-backports main restricted universe multiverse"; \
+    echo "deb ${APT_SOURCE} jammy-security main restricted universe multiverse"; \
+    } > /etc/apt/sources.list
+
+# Install systemctl
+RUN apt-get update && \
+    apt-get install -y -o Dpkg::Options::="--force-confdef" systemd && \
+    apt-get clean
+
+# Install tini
+RUN apt-get update && \
+    apt-get install -y tini && \
+    apt-get clean
+
+# Change pip source
+RUN pip config set global.index-url "${PIP_INDEX}" && \
+    pip config set global.extra-index-url "${PIP_INDEX}" && \
+    python -m pip install --upgrade pip
+
+# Uninstall nv-pytorch fork
+RUN pip uninstall -y torch torchvision torchaudio \
+    pytorch-quantization pytorch-triton torch-tensorrt \
+    transformer-engine flash-attn apex megatron-core \
+    xgboost opencv grpcio
+
+# Remove nv file
+RUN rm -rf /workspace
+
+# Fix cv2
+RUN rm -rf /usr/local/lib/python3.10/dist-packages/cv2
+
+# Install torch-2.7.1+cu126 + vllm-0.10.0
+RUN pip install --no-cache-dir "vllm==0.10.0" "torch==2.7.1" "torchvision==0.22.1" "torchaudio==2.7.1" tensordict torchdata \
+    "transformers[hf_xet]>=4.51.0" accelerate datasets peft hf-transfer \
+    "numpy<2.0.0" "pyarrow>=15.0.0" "grpcio>=1.62.1" "optree>=0.13.0" pandas \
+    ray[default] codetiming hydra-core pylatexenc qwen-vl-utils wandb liger-kernel mathruler \
+    pytest yapf py-spy pyext pre-commit ruff
+
+# Install flash-attn-2.8.2
+RUN ABI_FLAG=$(python -c "import torch; print('TRUE' if torch._C._GLIBCXX_USE_CXX11_ABI else 'FALSE')") && \
+    URL="https://github.com/Dao-AILab/flash-attention/releases/download/v2.8.2/flash_attn-2.8.2+cu12torch2.7cxx11abi${ABI_FLAG}-cp310-cp310-linux_x86_64.whl" && \
+    wget -nv -P /opt/tiger "${URL}" && \
+    pip install --no-cache-dir "/opt/tiger/$(basename ${URL})"
+
+# Reset pip config
+RUN pip config unset global.index-url && \
+    pip config unset global.extra-index-url

EasyR1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

EasyR1/Makefile

@@ -0,0 +1,30 @@
+.PHONY: build commit license quality style test
+
+check_dirs := examples scripts tests verl setup.py
+
+code_dirs := scripts tests verl setup.py
+
+RUN := $(shell command -v uv >/dev/null 2>&1 && echo "uv run" || echo "")
+BUILD := $(shell command -v uv >/dev/null 2>&1 && echo "uv build" || echo "python -m build")
+TOOL := $(shell command -v uv >/dev/null 2>&1 && echo "uvx" || echo "")
+
+build:
+	$(RUN) python3 setup.py sdist bdist_wheel
+
+commit:
+	$(TOOL) pre-commit install
+	$(TOOL) pre-commit run --all-files
+
+license:
+	$(RUN) python3 tests/check_license.py $(code_dirs)
+
+quality:
+	$(TOOL) ruff check $(check_dirs)
+	$(TOOL) ruff format --check $(check_dirs)
+
+style:
+	$(TOOL) ruff check $(check_dirs) --fix
+	$(TOOL) ruff format $(check_dirs)
+
+test:
+	$(RUN) pytest -vv tests/

EasyR1/README.md

@@ -0,0 +1,249 @@
+# EasyR1: An Efficient, Scalable, Multi-Modality RL Training Framework
+
+[![GitHub Repo stars](https://img.shields.io/github/stars/hiyouga/EasyR1)](https://github.com/hiyouga/EasyR1/stargazers)
+[![Twitter](https://img.shields.io/twitter/follow/llamafactory_ai)](https://twitter.com/llamafactory_ai)
+[![Docker Pulls](https://img.shields.io/docker/pulls/hiyouga/verl)](https://hub.docker.com/r/hiyouga/verl/tags)
+
+### Used by [Amazon Web Services](https://aws.amazon.com/cn/blogs/china/building-llm-model-hub-based-on-llamafactory-and-easyr1/)
+
+This project is a clean fork of the original [veRL](https://github.com/volcengine/verl) project to support vision language models, we thank all the authors for providing such a high-performance RL training framework.
+
+EasyR1 is efficient and scalable due to the design of **[HybirdEngine](https://arxiv.org/abs/2409.19256)** and the latest release of **[vLLM](https://github.com/vllm-project/vllm)**'s SPMD mode.
+
+## Features
+
+- Supported models
+  - Llama3/Qwen2/Qwen2.5/Qwen3 language models
+  - Qwen2-VL/Qwen2.5-VL/Qwen3-VL vision language models
+  - DeepSeek-R1 distill models
+
+- Supported algorithms
+  - GRPO
+  - DAPO ![new](https://img.shields.io/badge/new-orange)
+  - Reinforce++
+  - ReMax
+  - RLOO
+  - GSPO ![new](https://img.shields.io/badge/new-orange)
+  - CISPO ![new](https://img.shields.io/badge/new-orange)
+
+- Supported datasets
+  - Any text, vision-text dataset in a [specific format](#custom-dataset)
+
+- Supported tricks
+  - Padding-free training
+  - LoRA training ![new](https://img.shields.io/badge/new-orange)
+  - Resuming from the latest/best checkpoint
+  - Wandb & SwanLab & Mlflow & Tensorboard tracking
+
+## Requirements
+
+### Software Requirements
+
+- Python 3.9+
+- transformers>=4.54.0
+- flash-attn>=2.4.3
+- vllm>=0.8.3
+
+We provide a [Dockerfile](./Dockerfile) to easily build environments.
+
+We recommend using the [pre-built docker image](https://hub.docker.com/r/hiyouga/verl) in EasyR1.
+
+```bash
+docker pull hiyouga/verl:ngc-th2.8.0-cu12.9-vllm0.11.0
+docker run -it --ipc=host --gpus=all hiyouga/verl:ngc-th2.8.0-cu12.9-vllm0.11.0
+```
+
+If your environment does not support Docker, you can consider using **Apptainer**:
+
+```bash
+apptainer pull easyr1.sif docker://hiyouga/verl:ngc-th2.8.0-cu12.9-vllm0.11.0
+apptainer shell --nv --cleanenv --bind /mnt/your_dir:/mnt/your_dir easyr1.sif
+```
+
+Use `USE_MODELSCOPE_HUB=1` to download models from the ModelScope hub.
+
+### Hardware Requirements
+
+\* *estimated*
+
+| Method                   | Bits |  1.5B  |   3B   |   7B   |   32B   |   72B   |
+| ------------------------ | ---- | ------ | ------ | ------ | ------- | ------- |
+| GRPO Full Fine-Tuning    |  AMP | 2*24GB | 4*40GB | 8*40GB | 16*80GB | 32*80GB |
+| GRPO Full Fine-Tuning    | BF16 | 1*24GB | 1*40GB | 4*40GB |  8*80GB | 16*80GB |
+| GRPO LoRA Fine-Tuning    |  AMP | 1*12GB | 1*24GB | 2*32GB |  2*80GB |  4*80GB |
+
+> [!NOTE]
+> Use `worker.actor.fsdp.torch_dtype=bf16` and `worker.actor.optim.strategy=adamw_bf16` to enable bf16 training.
+
+## Tutorial: Run Qwen2.5-VL GRPO on [Geometry3K](https://huggingface.co/datasets/hiyouga/geometry3k) Dataset in Just 3 Steps
+
+![image](assets/qwen2_5_vl_7b_geo.png)
+
+### Installation
+
+```bash
+git clone https://github.com/hiyouga/EasyR1.git
+cd EasyR1
+pip install -e .
+```
+
+### GRPO Full Training
+
+```bash
+bash examples/qwen2_5_vl_7b_geo3k_grpo.sh
+```
+
+### GRPO LoRA Training
+
+```bash
+bash examples/qwen3_vl_4b_geo3k_grpo_lora.sh
+```
+
+### Merge Checkpoint in Hugging Face Format
+
+```bash
+python3 scripts/model_merger.py --local_dir checkpoints/easy_r1/exp_name/global_step_1/actor
+```
+
+> [!TIP]
+> If you encounter issues with connecting to Hugging Face, consider using `export HF_ENDPOINT=https://hf-mirror.com`.
+>
+> If you want to use SwanLab logger, consider using `bash examples/qwen2_5_vl_7b_geo3k_swanlab.sh`.
+
+## Custom Dataset
+
+Please refer to the example datasets to prepare your own dataset.
+
+- Text dataset: https://huggingface.co/datasets/hiyouga/math12k
+- Image-text dataset: https://huggingface.co/datasets/hiyouga/geometry3k
+- Multi-image-text dataset: https://huggingface.co/datasets/hiyouga/journeybench-multi-image-vqa
+- Text-image mixed dataset: https://huggingface.co/datasets/hiyouga/rl-mixed-dataset
+
+## How to Understand GRPO in EasyR1
+
+![image](assets/easyr1_grpo.png)
+
+- To learn about the GRPO algorithm, you can refer to [Hugging Face's blog](https://huggingface.co/docs/trl/v0.16.1/en/grpo_trainer).
+
+## How to Run 70B+ Model in Multi-node Environment
+
+1. Start the Ray head node.
+
+```bash
+ray start --head --port=6379 --dashboard-host=0.0.0.0
+```
+
+2. Start the Ray worker node and connect to the head node.
+
+```bash
+ray start --address=<head_node_ip>:6379
+```
+
+3. Check the Ray resource pool.
+
+```bash
+ray status
+```
+
+4. Run training script on the Ray head node only.
+
+```bash
+bash examples/qwen2_5_vl_7b_geo3k_grpo.sh
+```
+
+See the **[veRL's official doc](https://verl.readthedocs.io/en/latest/start/multinode.html)** for more details about multi-node training and Ray debugger.
+
+## Other Baselines
+
+We also reproduced the following two baselines of the [R1-V](https://github.com/deep-agent/R1-V) project.
+- [CLEVR-70k-Counting](examples/baselines/qwen2_5_vl_3b_clevr.sh): Train the Qwen2.5-VL-3B-Instruct model on counting problem.
+- [GeoQA-8k](examples/baselines/qwen2_5_vl_3b_geoqa8k.sh): Train the Qwen2.5-VL-3B-Instruct model on GeoQA problem.
+
+## Performance Baselines
+
+See [baselines.md](assets/baselines.md).
+
+## Awesome Work using EasyR1
+
+- **MMR1**: Enhancing Multimodal Reasoning with Variance-Aware Sampling and Open Resources. [![[code]](https://img.shields.io/github/stars/LengSicong/MMR1)](https://github.com/LengSicong/MMR1) [![[arxiv]](https://img.shields.io/badge/arxiv-2509.21268-blue)](https://arxiv.org/abs/2509.21268)
+- **Vision-R1**: Incentivizing Reasoning Capability in Multimodal Large Language Models. [![[code]](https://img.shields.io/github/stars/Osilly/Vision-R1)](https://github.com/Osilly/Vision-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2503.06749-blue)](https://arxiv.org/abs/2503.06749)
+- **Seg-Zero**: Reasoning-Chain Guided Segmentation via Cognitive Reinforcement. [![[code]](https://img.shields.io/github/stars/dvlab-research/Seg-Zero)](https://github.com/dvlab-research/Seg-Zero) [![[arxiv]](https://img.shields.io/badge/arxiv-2503.06520-blue)](https://arxiv.org/abs/2503.06520)
+- **MetaSpatial**: Reinforcing 3D Spatial Reasoning in VLMs for the Metaverse. [![[code]](https://img.shields.io/github/stars/PzySeere/MetaSpatial)](https://github.com/PzySeere/MetaSpatial) [![[arxiv]](https://img.shields.io/badge/arxiv-2503.18470-blue)](https://arxiv.org/abs/2503.18470)
+- **Temporal-R1**: Envolving Temporal Reasoning Capability into LMMs via Temporal Consistent Reward. [![[code]](https://img.shields.io/github/stars/appletea233/Temporal-R1)](https://github.com/appletea233/Temporal-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2506.01908-blue)](https://arxiv.org/abs/2506.01908)
+- **NoisyRollout**: Reinforcing Visual Reasoning with Data Augmentation. [![[code]](https://img.shields.io/github/stars/John-AI-Lab/NoisyRollout)](https://github.com/John-AI-Lab/NoisyRollout) [![[arxiv]](https://img.shields.io/badge/arxiv-2504.13055-blue)](https://arxiv.org/pdf/2504.13055)
+- **GUI-R1**: A Generalist R1-Style Vision-Language Action Model For GUI Agents. [![[code]](https://img.shields.io/github/stars/ritzz-ai/GUI-R1)](https://github.com/ritzz-ai/GUI-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2504.10458-blue)](https://arxiv.org/abs/2504.10458)
+- **FAST-GRPO**: Fast-Slow Thinking framework that dynamically adapts reasoning depth based on question characteristics. [![[code]](https://img.shields.io/github/stars/Mr-Loevan/FAST)](https://github.com/Mr-Loevan/FAST) [![[arxiv]](https://img.shields.io/badge/arxiv-2504.18458-blue)](https://arxiv.org/abs/2504.18458)
+- **R1-Track**: Direct Application of MLLMs to Visual Object Tracking via Reinforcement Learning. [![[code]](https://img.shields.io/github/stars/Wangbiao2/R1-Track)](https://github.com/Wangbiao2/R1-Track)
+- **VisionReasoner**: Unified Visual Perception and Reasoning via Reinforcement Learning. [![[code]](https://img.shields.io/github/stars/dvlab-research/VisionReasoner)](https://github.com/dvlab-research/VisionReasoner) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.12081-blue)](https://arxiv.org/abs/2505.12081)
+- **MM-UPT**: Unsupervised Post-Training for Multi-Modal LLM Reasoning via GRPO. [![[code]](https://img.shields.io/github/stars/waltonfuture/MM-UPT)](https://github.com/waltonfuture/MM-UPT) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.22453-blue)](https://arxiv.org/pdf/2505.22453)
+- **RL-with-Cold-Start**: Advancing Multimodal Reasoning via Reinforcement Learning with Cold Start. [![[code]](https://img.shields.io/github/stars/waltonfuture/RL-with-Cold-Start)](https://github.com/waltonfuture/RL-with-Cold-Start) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.22334-blue)](https://arxiv.org/pdf/2505.22334)
+- **ViGoRL**: Grounded Reinforcement Learning for Visual Reasoning. [![[code]](https://img.shields.io/github/stars/Gabesarch/grounded-rl)](https://github.com/Gabesarch/grounded-rl) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.22334-blue)](https://arxiv.org/abs/2505.23678)
+- **Revisual-R1**: Advancing Multimodal Reasoning: From Optimized Cold Start to Staged Reinforcement Learning. [![[code]](https://img.shields.io/github/stars/CSfufu/Revisual-R1)](https://github.com/CSfufu/Revisual-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2506.04207-blue)](https://arxiv.org/abs/2506.04207)
+- **SophiaVL-R1**: Reinforcing MLLMs Reasoning with Thinking Reward. [![[code]](https://img.shields.io/github/stars/kxfan2002/SophiaVL-R1)](https://github.com/kxfan2002/SophiaVL-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.17018-blue)](https://arxiv.org/abs/2505.17018)
+- **Vision-Matters**: Simple Visual Perturbations Can Boost Multimodal Math Reasoning. [![[code]](https://img.shields.io/github/stars/YutingLi0606/Vision-Matters)](https://github.com/YutingLi0606/Vision-Matters) [![[arxiv]](https://img.shields.io/badge/arxiv-2506.09736-blue)](https://arxiv.org/abs/2506.09736)
+- **VTool-R1**: VLMs Learn to Think with Images via Reinforcement Learning on Multimodal Tool Use. [![[code]](https://img.shields.io/github/stars/VTOOL-R1/vtool-r1)](https://github.com/VTOOL-R1/vtool-r1) [![[arxiv]](https://img.shields.io/badge/arxiv-2505.19255-blue)](https://arxiv.org/abs/2505.19255)
+- **Long-RL**: Scaling RL to Long Sequences. [![[code]](https://img.shields.io/github/stars/NVlabs/Long-RL)](https://github.com/NVlabs/Long-RL) [![[arxiv]](https://img.shields.io/badge/arxiv-2507.07966-blue)](https://arxiv.org/abs/2507.07966)
+- **EditGRPO**: Reinforcement Learning with Post-Rollout Edits for Clinically Accurate Chest X-Ray Report Generation. [![[code]](https://img.shields.io/github/stars/taokz/EditGRPO)](https://github.com/taokz/EditGRPO)
+- **ARES**: Multimodal Adaptive Reasoning via Difficulty-Aware Token-Level Entropy Shaping. [![[code]](https://img.shields.io/github/stars/shawn0728/ARES)](https://github.com/shawn0728/ARES) [![[arxiv]](https://img.shields.io/badge/arxiv-2510.08457-blue)](https://arxiv.org/abs/2510.08457)
+- **VPPO**: Spotlight on Token Perception for Multimodal Reinforcement Learning. [![[code]](https://img.shields.io/github/stars/huaixuheqing/VPPO-RL)](https://github.com/huaixuheqing/VPPO-RL) [![[arxiv]](https://img.shields.io/badge/arxiv-2510.09285-blue)](https://arxiv.org/abs/2510.09285)
+- **IE-Critic-R1**: Advancing the Explanatory Measurement of Text-Driven Image Editing for Human Perception Alignment. [![[code]](https://img.shields.io/github/stars/Coobiw/IE-Critic-R1)](https://github.com/Coobiw/IE-Critic-R1) [![[arxiv]](https://img.shields.io/badge/arxiv-2511.18055-blue)](https://arxiv.org/abs/2511.18055)
+- **OneThinker**: All-in-one Reasoning Model for Image and Video. [![[code]](https://img.shields.io/github/stars/tulerfeng/OneThinker)](https://github.com/tulerfeng/OneThinker) [![[arxiv]](https://img.shields.io/badge/arxiv-2512.03043-blue)](https://arxiv.org/abs/2512.03043)
+- **MetaphorStar**: Image Metaphor Understanding and Reasoning with End-to-End Visual Reinforcement Learning. [![[code]](https://img.shields.io/github/stars/MING-ZCH/MetaphorStar)](https://github.com/MING-ZCH/MetaphorStar) [![[arxiv]](https://img.shields.io/badge/arxiv-2602.10575-blue)](https://arxiv.org/abs/2602.10575)
+
+## TODO
+
+- Support ulysses parallelism for VLMs (middle priority).
+- Support more VLM architectures.
+
+> [!NOTE]
+> We will not provide scripts for supervised fine-tuning and inference in this project. If you have such requirements, we recommend using [LlamaFactory](https://github.com/hiyouga/LlamaFactory).
+
+### Known bugs
+
+These features are temporarily disabled for now, we plan to fix them one-by-one in the future updates.
+
+- Vision language models are not compatible with ulysses parallelism yet.
+
+## Discussion Group
+
+👋 Join our [WeChat group](https://github.com/hiyouga/llamafactory-community/blob/main/wechat/easyr1.jpg).
+
+## FAQs
+
+> ValueError: Image features and image tokens do not match: tokens: 8192, features 9800
+
+Increase the `data.max_prompt_length` or reduce the `data.max_pixels`.
+
+> RuntimeError: CUDA Error: out of memory at /workspace/csrc/cumem_allocator.cpp:62
+
+Reduce the `worker.rollout.gpu_memory_utilization` and enable `worker.actor.offload.offload_params`.
+
+> RuntimeError: 0 active drivers ([]). There should only be one.
+
+Uninstall `deepspeed` from the current python environment.
+
+## Citation
+
+Core contributors: [Yaowei Zheng](https://github.com/hiyouga), [Junting Lu](https://github.com/AL-377), [Shenzhi Wang](https://github.com/Shenzhi-Wang), [Zhangchi Feng](https://github.com/BUAADreamer), [Dongdong Kuang](https://github.com/Kuangdd01), Yuwen Xiong and Richong Zhang
+
+We also thank Guangming Sheng and Chi Zhang for helpful discussions.
+
+```bibtex
+@misc{zheng2025easyr1,
+  title        = {EasyR1: An Efficient, Scalable, Multi-Modality RL Training Framework},
+  author       = {Yaowei Zheng, Junting Lu, Shenzhi Wang, Zhangchi Feng, Dongdong Kuang, Yuwen Xiong, Richong Zhang},
+  howpublished = {\url{https://github.com/hiyouga/EasyR1}},
+  year         = {2025}
+}
+```
+
+We recommend to also cite the original work.
+
+```bibtex
+@article{sheng2024hybridflow,
+  title   = {HybridFlow: A Flexible and Efficient RLHF Framework},
+  author  = {Guangming Sheng and Chi Zhang and Zilingfeng Ye and Xibin Wu and Wang Zhang and Ru Zhang and Yanghua Peng and Haibin Lin and Chuan Wu},
+  year    = {2024},
+  journal = {arXiv preprint arXiv: 2409.19256}
+}
+```

EasyR1/assets/baselines.md

@@ -0,0 +1,78 @@
+# Baselines
+
+Environment: [hiyouga/verl:ngc-th2.7.1-cu12.6-vllm0.10.0](https://hub.docker.com/layers/hiyouga/verl/ngc-th2.7.1-cu12.6-vllm0.10.0/images/sha256-cfc8c1ce3ea52dee0444f3e58e900d0b1d3b6b315deaf5f58c44b5fbb52fa989)
+
+EasyR1 version: [v0.3.2](https://github.com/hiyouga/EasyR1/tree/v0.3.2)
+
+Welcome to contribute new data points!
+
+## Algorithm Baselines
+
+### [Qwen2.5-Instruct](https://huggingface.co/Qwen/Qwen2.5-7B-Instruct) on [Math12k](https://huggingface.co/datasets/hiyouga/math12k)
+
+| Size | Algorithm   | Bits | LR   | KL   | Test Accuracy        |
+| ---- | ----------- | ---- | ---- | ---- | -------------------- |
+| 7B   | GRPO        | AMP  | 1e-6 | 1e-2 | 0.75 -> 0.77 (+0.02) |
+
+### [Qwen2.5-VL-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+| Size | Algorithm   | Bits | LR   | KL   | Test Accuracy        |
+| ---- | ----------- | ---- | ---- | ---- | -------------------- |
+| 7B   | GRPO        | AMP  | 1e-6 | 1e-2 | 0.37 -> 0.48 (+0.11) |
+| 7B   | GRPO        | BF16 | 1e-6 | 1e-2 | 0.37 -> 0.48 (+0.11) |
+| 7B   | DAPO        | AMP  | 1e-6 | 1e-2 | 0.37 -> 0.50 (+0.13) |
+| 7B   | GSPO        | AMP  | 1e-6 |    0 | 0.37 -> 0.48 (+0.11) |
+| 7B   | CISPO       | AMP  | 1e-6 | 1e-2 | 0.37 -> 0.50 (+0.13) |
+| 7B   | SAPO        | AMP  | 1e-6 |    0 | 0.37 -> 0.54 (+0.17) |
+| 3B   | GRPO        | AMP  | 1e-6 | 1e-2 | 0.24 -> 0.38 (+0.14) |
+| 32B  | GRPO        | BF16 | 1e-6 | 1e-2 | 0.50 -> 0.56 (+0.06) |
+
+### [Qwen3-VL-Instruct](https://huggingface.co/Qwen/Qwen3-VL-30B-A3B-Instruct) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+|  Size   | Algorithm   | Bits | LR   | KL   | Test Accuracy        |
+| ------- | ----------- | ---- | ---- | ---- | -------------------- |
+| 30B-A3B | GRPO        | BF16 | 1e-6 | 1e-2 | 0.55 -> 0.78 (+0.23) |
+
+### [Qwen3-VL-Thinking](https://huggingface.co/Qwen/Qwen3-VL-30B-A3B-Thinking) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+|  Size   | Algorithm   | Bits | LR   | KL   | Test Accuracy        |
+| ------- | ----------- | ---- | ---- | ---- | -------------------- |
+| 30B-A3B | GRPO        | BF16 | 1e-6 | 1e-2 | 0.49 -> 0.77 (+0.28) |
+
+> [!NOTE]
+> The hyper-parameters not listed are all the same as the default values.
+
+## Performance Baselines
+
+### [Qwen2.5-VL-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+| Size | GPU Type      | Bits | Batch Size | vLLM TP | Peak Mem | Peak VRAM | Throughput  | Sec per step | Actor MFU |
+| ---- | ------------- | ---- | ---------- | ------- | -------- | --------- | ----------- | ------------ | --------- |
+| 3B   | 8 * H100 80GB | AMP  | 1 / 2      | 2       | 120GB    | 54GB      | 1800 (+600) | 120s         | 8.1%      |
+| 7B   | 8 * H100 80GB | AMP  | 1 / 2      | 2       | 120GB    | 68GB      | 1600 (+400) | 145s         | 16.0%     |
+| 7B   | 8 * H100 80GB | AMP  | 4 / 8      | 2       | 200GB    | 72GB      | 2000 (+600) | 120s         | 23.2%     |
+| 7B   | 8 * L20 48GB  | AMP  | 1 / 2      | 2       | 120GB    | 42GB      | 410  (+0)   | 580s         | 26.5%     |
+| 7B   | 8 * H100 80GB | BF16 | 1 / 2      | 2       | 120GB    | 58GB      | 1600 (+320) | 145s         | 16.0%     |
+| 32B  | 8 * H100 80GB | BF16 | 1 / 2      | 8       | 260GB    | 72GB      | 620  (+260) | 530s         | 25.8%     |
+
+### [Qwen3-VL-Instruct](https://huggingface.co/Qwen/Qwen3-VL-30B-A3B-Instruct) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+| Size    | GPU Type      | Bits | Batch Size | vLLM TP | Peak Mem | Peak VRAM | Throughput  | Sec per step | Actor MFU |
+| ------- | ------------- | ---- | ---------- | ------- | -------- | --------- | ----------- | ------------ | --------- |
+| 30B-A3B | 8 * H800 80GB | BF16 | 1 / 2      | 8       | 170GB    | 50GB      | 80          | 4600s        | 1.8%      |
+
+### [Qwen3-VL-Thinking](https://huggingface.co/Qwen/Qwen3-VL-30B-A3B-Thinking) on [Geometry3k](https://huggingface.co/datasets/hiyouga/geometry3k)
+
+| Size    | GPU Type      | Bits | Batch Size | vLLM TP | Peak Mem | Peak VRAM | Throughput  | Sec per step | Actor MFU |
+| ------- | ------------- | ---- | ---------- | ------- | -------- | --------- | ----------- | ------------ | --------- |
+| 30B-A3B | 8 * H800 80GB | BF16 | 1 / 2      | 8       | 210GB    | 50GB      | 65          | 8000s        | 1.4%      |
+
+- Batch Size: micro_batch_size_per_device_for_update / micro_batch_size_per_device_for_experience
+- vLLM TP: rollout.tensor_parallel_size
+- Peak Mem: Peak CPU memory usage
+- Peak VRAM: Peak GPU memory usage
+- Throughput: Number of tokens per second per GPU by one training step (including the improvement compared to the [previous version](https://github.com/hiyouga/EasyR1/blob/v0.3.1/assets/baselines.md))
+- Sec per step: Average time per step in seconds
+
+> [!NOTE]
+> The hyper-parameters not listed are all the same as the default values.

EasyR1/examples/android_gui_cookbook/COLLECT_DATA_README.md

@@ -0,0 +1,18 @@
+# 连接 android 设备收集训练数据步骤
+
+# 1. 在 Android 中打开游戏
+```shell
+adb -s <android_ip>:5555 shell am start -a android.intent.action.VIEW -d "http://<game_ip>:8000/number_game.html"
+```
+
+# 2. 收集训练数据
+max-workers: number of devices
+
+```shell
+python examples/android_gui_cookbook/collect_data.py \
+    --devices <android_ip1>:5555 <android_ip2>:5555 <android_ip3>:5555 \
+    --episodes 1 \
+    --parallel \
+    --max-workers 3 \
+    --output-dir game_data_raw
+```

EasyR1/examples/android_gui_cookbook/PLAY_GAME_README.md

@@ -0,0 +1,38 @@
+# 连接 android 设备玩游戏步骤
+
+android 云端 android 设备创建可参考: https://github.com/tkestack/tke-ai-playbook/pull/20
+
+## 1.在Android浏览器中打开游戏：
+adb -s <android_ip>:5555 shell am start -a android.intent.action.VIEW -d "http://<game_ip>:8000/number_game.html"
+
+## 2. 确保设备已连接
+adb connect <android_ip>:5555
+
+## 3. 执行游戏脚本
+- ollama
+```shell
+python examples/android_gui_cookbook/play_agent.py \
+    --model-type ollama \
+    --api-url http://localhost:11434 \
+    --model-name qwen2.5vl:3b \
+    --devices <android_ip>:5555 \
+    --debug
+```
+- vllm
+```shell
+python examples/android_gui_cookbook/play_agent.py \
+    --model-type vllm \
+    --api-url <vllm_ip> \
+    --model-name <model_id> \
+    --devices <android_ip>:5555 \
+    --debug
+```
+
+# 参数说明
+
+- --model-type: 模型类型（ollama 或 vllm），默认 ollama
+- --api-url: API地址，默认 http://localhost:11434
+- --model-name: 模型名称，默认 qwen2.5vl:3b
+- --devices: 设备列表
+- --episodes: 运行局数，默认 1
+- --debug: 开启调试模式，显示VLM输出

EasyR1/examples/android_gui_cookbook/README.md

@@ -0,0 +1,224 @@
+# Android GUI 数字游戏强化学习教程
+
+本教程涵盖：**云端环境部署** → **模型训练** → **模型测试** 三个完整流程。
+
+---
+
+## 1. 云端 Android 部署和游戏部署
+
+### 1.1 游戏部署
+
+#### Docker 部署
+
+```bash
+# 拉取并运行游戏容器
+docker run -d \
+  --name number-game \
+  -p 8000:8000 \
+  ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl:v1.4
+
+# 访问游戏
+# http://localhost:8000/number_game.html
+```
+
+#### Kubernetes 部署
+
+```bash
+# 使用提供的配置文件
+kubectl apply -f examples/android_gui_cookbook/game_docker/game.yaml
+
+# 获取外部访问地址
+kubectl get svc number-game -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
+
+# 访问: http://<EXTERNAL-IP>:8000/number_game.html
+```
+
+### 1.2 Android 设备连接
+
+#### 创建云端 Android 设备
+参考文档：https://github.com/tkestack/tke-ai-playbook/pull/20
+
+#### 连接设备并打开游戏
+
+```bash
+# 连接设备
+adb connect <android_ip>:5555
+
+# 在设备浏览器打开游戏
+adb -s <android_ip>:5555 shell am start -a android.intent.action.VIEW \
+  -d "http://<game_ip>:8000/number_game.html"
+
+# 验证连接
+adb devices
+```
+
+---
+
+## 2. 模型训练
+
+### 2.1 训练脚本说明
+
+**核心文件**：
+- `examples/qwen2_5_vl_3b_android_gui_grpo.sh` - 训练启动脚本
+- `examples/format_prompt/android_gui.jinja` - 提示词模板
+- `examples/reward_function/android_gui.py` - 奖励函数
+
+**游戏规则**（由 `android_gui.jinja` 定义）：
+- 🟢 绿灯：选择**最大**数字 → 位置索引 (0/1/2)
+- 🔴 红灯：选择**最小**数字 → 位置索引 (0/1/2)
+- 🟡 黄灯：选择**中间**数字 → 位置索引 (0/1/2)
+
+**评分规则**（由 `android_gui.py` 实现）：
+- 正确选择：`+1.0`
+- 错误选择：`0.0`
+
+### 2.2 启动训练
+
+```bash
+# 切换到 EasyR1 根目录
+cd /path/to/EasyR1
+
+# 运行训练脚本
+bash examples/qwen2_5_vl_3b_android_gui_grpo.sh
+```
+
+### 2.3 关键训练参数
+
+脚本使用以下配置（基于 `config.yaml`，通过命令行覆盖）：
+
+| 参数 | 值 | 说明 |
+|------|-----|------|
+| `data.train_files` | `yuehua-s/numbergame@train` | 训练数据集 |
+| `data.val_files` | `yuehua-s/numbergame@test` | 验证数据集 |
+| `data.rollout_batch_size` | `32` | Rollout 批次大小 |
+| `algorithm.kl_coef` | `0.04` | KL 散度系数 |
+| `worker.actor.optim.lr` | `1e-5` | 学习率 |
+| `worker.rollout.n` | `8` | 每步生成响应数 |
+| `trainer.total_epochs` | `3` | 训练轮数 |
+| `trainer.n_gpus_per_node` | `2` | 每节点 GPU 数 |
+
+### 2.4 导出模型
+
+训练完成后，检查点保存在 `checkpoints/<experiment_name>/global_step_<N>/actor`。
+
+```bash
+# 合并模型（转换为 HuggingFace 格式）
+python3 scripts/model_merger.py \
+  --local_dir /path/to/EasyR1/checkpoints/<experiment_name>/global_step_35/actor
+
+# 导出目录：checkpoints/<experiment_name>/global_step_35/actor/huggingface/
+```
+
+---
+
+## 3. 使用 Agent 玩游戏测试模型效果
+
+### 3.1 启动推理服务
+
+使用 vLLM 部署训练好的模型：
+
+```bash
+vllm serve /path/to/checkpoints/<experiment_name>/global_step_35/actor/huggingface/ \
+  --host 0.0.0.0 \
+  --port 8000
+```
+
+### 3.2 运行 Agent 测试
+
+**核心文件**：
+- `examples/android_gui_cookbook/play_agent.py` - Agent 主程序
+- `examples/android_gui_cookbook/adb_controller.py` - ADB 控制
+- `examples/android_gui_cookbook/vlm_client.py` - VLM 推理客户端
+
+#### 使用 vLLM 模型
+
+```bash
+python examples/android_gui_cookbook/play_agent.py \
+  --model-type vllm \
+  --api-url http://<vllm_server_ip>:8000 \
+  --model-name /path/to/checkpoints/xxx/global_step_35/actor/huggingface/ \
+  --devices <android_ip>:5555 \
+  --episodes 5 \
+  --debug
+```
+
+#### 使用 Ollama 模型
+
+```bash
+python examples/android_gui_cookbook/play_agent.py \
+  --model-type ollama \
+  --api-url http://localhost:11434 \
+  --model-name qwen2.5vl:3b \
+  --devices <android_ip1>:5555 <android_ip2>:5555 \
+  --episodes 3 \
+  --debug
+```
+
+### 3.3 参数说明
+
+| 参数 | 默认值 | 说明 |
+|------|--------|------|
+| `--model-type` | `ollama` | 模型服务类型（`ollama` 或 `vllm`） |
+| `--api-url` | `http://localhost:11434` | 模型 API 地址 |
+| `--model-name` | `qwen2.5vl:3b` | 模型名称或路径 |
+| `--devices` | `101.43.137.83:5555` | Android 设备列表（空格分隔） |
+| `--episodes` | `1` | 每个设备运行局数 |
+| `--debug` | `False` | 开启调试模式（显示 VLM 输出） |
+| `--screenshot-dir` | `game_screenshots` | 截图保存目录 |
+
+### 3.4 测试流程
+
+Agent 自动执行以下操作（每局 10 轮）：
+
+1. **截图** - 捕获当前游戏画面
+2. **VLM 推理** - 识别指示灯颜色和数字，做出决策
+3. **点击卡片** - 点击选择的数字（位置 0/1/2）
+4. **验证点击** - 检查卡片颜色是否改变
+5. **点击下一轮** - 进入下一轮游戏
+
+### 3.5 查看结果
+
+测试完成后，结果保存在 `game_screenshots/<device_id>/`：
+
+```
+game_screenshots/
+└── <android_ip>_5555/
+    ├── round_01_<timestamp>.png           # 每轮决策前截图
+    ├── round_01_after_click_<timestamp>.png  # 点击后截图
+    ├── final_score_<timestamp>.png        # 最终得分截图
+    └── result_<timestamp>.json            # 游戏结果（JSON）
+```
+
+**结果文件示例**：
+```json
+{
+  "device_id": "101.43.137.83:5555",
+  "timestamp": "20251123_143025",
+  "total_rounds": 10,
+  "final_score": 80,
+  "model_type": "vllm",
+  "model_name": "/path/to/model"
+}
+```
+
+---
+
+## 附录：文件结构
+
+```
+examples/
+├── qwen2_5_vl_3b_android_gui_grpo.sh    # 训练脚本
+├── config.yaml                           # 基础配置
+├── format_prompt/
+│   └── android_gui.jinja                 # 提示词模板
+├── reward_function/
+│   └── android_gui.py                    # 奖励函数
+└── android_gui_cookbook/
+    ├── README.md                         # 本文档
+    ├── play_agent.py                     # Agent 主程序
+    ├── adb_controller.py                 # ADB 控制器
+    ├── vlm_client.py                     # VLM 客户端
+    └── game_docker/
+        ├── game.yaml                     # K8s 部署配置
+        └── DOCKER_README.md              # Docker 详细说明
+```

EasyR1/examples/android_gui_cookbook/adb_controller.py

@@ -0,0 +1,143 @@
+"""
+ADB 设备控制器
+
+功能:
+- 连接 Android 设备
+- 执行点击、滑动、输入等操作
+- 截图获取
+- 设备状态检测
+"""
+
+import io
+import subprocess
+import time
+from typing import Optional, Tuple
+
+from PIL import Image
+
+
+class ADBController:
+    """Android Debug Bridge 控制器"""
+
+    def __init__(self, device_id: str = "emulator-5554"):
+        """
+        初始化 ADB 控制器
+
+        Args:
+            device_id: 设备 ID (通过 `adb devices` 查看)
+        """
+        self.device_id = device_id
+        self._check_connection()
+
+    def _check_connection(self):
+        """检查设备连接"""
+        try:
+            result = subprocess.run(["adb", "devices"], capture_output=True, text=True, timeout=5)
+
+            if self.device_id not in result.stdout:
+                raise ConnectionError(f"设备 {self.device_id} 未连接。请运行 'adb devices' 查看可用设备。")
+
+            print(f"✓ 设备 {self.device_id} 已连接")
+
+        except FileNotFoundError:
+            raise RuntimeError("ADB 未安装或未添加到 PATH。请安装 Android SDK Platform-Tools。")
+        except subprocess.TimeoutExpired:
+            raise TimeoutError("ADB 连接超时，请检查设备状态。")
+
+    def execute_command(self, command: str, timeout: int = 10) -> str:
+        """
+        执行 ADB 命令
+
+        Args:
+            command: ADB 命令 (不包含 'adb -s device_id' 前缀)
+            timeout: 超时时间 (秒)
+
+        Returns:
+            命令输出结果
+        """
+        full_command = f"adb -s {self.device_id} {command}"
+
+        try:
+            result = subprocess.run(full_command.split(), capture_output=True, text=True, timeout=timeout)
+
+            if result.returncode != 0:
+                raise RuntimeError(f"命令执行失败: {result.stderr}")
+
+            return result.stdout
+
+        except subprocess.TimeoutExpired:
+            raise TimeoutError(f"命令执行超时: {command}")
+
+    def capture_screenshot(self, save_path: Optional[str] = None) -> Image.Image:
+        """
+        截取屏幕截图
+
+        Args:
+            save_path: 保存路径 (可选)
+
+        Returns:
+            PIL Image 对象
+        """
+        try:
+            # 使用 screencap 命令
+            cmd = f"adb -s {self.device_id} exec-out screencap -p"
+            result = subprocess.run(
+                cmd.split(),
+                capture_output=True,
+                timeout=15,  # 增加超时时间，特别是远程设备或并发时
+            )
+
+            if result.returncode != 0:
+                raise RuntimeError("截图失败")
+
+            # 将字节流转换为 PIL Image
+            image = Image.open(io.BytesIO(result.stdout))
+
+            if save_path:
+                image.save(save_path)
+                print(f"✓ 截图已保存: {save_path}")
+
+            return image
+
+        except Exception as e:
+            raise RuntimeError(f"截图失败: {e}")
+
+    def tap(self, x: int, y: int, delay: float = 0.5) -> bool:
+        """
+        点击屏幕坐标
+
+        Args:
+            x: X 坐标
+            y: Y 坐标
+            delay: 点击后等待时间 (秒)
+
+        Returns:
+            是否成功
+        """
+        try:
+            self.execute_command(f"shell input tap {x} {y}")
+            time.sleep(delay)
+            print(f"✓ 点击坐标: ({x}, {y})")
+            return True
+
+        except Exception as e:
+            print(f"✗ 点击失败: {e}")
+            return False
+
+    def get_screen_resolution(self) -> Tuple[int, int]:
+        """
+        获取屏幕分辨率
+
+        Returns:
+            (width, height)
+        """
+        try:
+            output = self.execute_command("shell wm size")
+            # 输出格式: Physical size: 1080x2400
+            size_str = output.split(":")[-1].strip()
+            width, height = map(int, size_str.split("x"))
+            return width, height
+
+        except Exception as e:
+            print(f"⚠ 无法获取分辨率，使用默认值 (1080, 2400): {e}")
+            return 1080, 2400

EasyR1/examples/android_gui_cookbook/collect_data.py

@@ -0,0 +1,489 @@
+"""
+数据收集脚本 - 用于离线训练数据集构建
+
+功能:
+1. 支持多设备并发收集游戏截图
+2. 截图命名格式规范，方便后续批量标注
+3. 只收集截图，不调用VLM（节省时间和资源）
+4. 自动重试失败的轮次
+5. 记录每局游戏的元数据
+"""
+
+import argparse
+import json
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from adb_controller import ADBController
+
+
+class DataCollector:
+    """游戏数据收集器"""
+
+    def __init__(self, device_id: str, output_dir: str = "game_data_raw", debug: bool = False):
+        self.device_id = device_id
+        self.debug = debug
+
+        # 创建输出目录（使用安全的文件名）
+        safe_device_id = device_id.replace(":", "_").replace(".", "_")
+        self.output_dir = Path(output_dir) / safe_device_id
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # 检查已有的episode，自动续集
+        self.start_episode_id = self._find_next_episode_id()
+        if self.start_episode_id > 1:
+            print(f"[{device_id}] 检测到已有数据，从 Episode {self.start_episode_id} 继续收集")
+
+        # 初始化 ADB 控制器
+        print(f"[{device_id}] 连接 Android 设备...")
+        self.controller = ADBController(device_id=device_id)
+
+        # 获取屏幕分辨率
+        self.screen_width, self.screen_height = self.controller.get_screen_resolution()
+        print(f"[{device_id}] 屏幕分辨率: {self.screen_width}x{self.screen_height}")
+
+        # 游戏元数据
+        self.episodes = []
+
+    def _find_next_episode_id(self) -> int:
+        """
+        查找下一个可用的episode_id（避免覆盖已有数据）
+
+        Returns:
+            下一个episode_id（从1开始）
+        """
+        existing_episodes = list(self.output_dir.glob("episode_*_metadata.json"))
+
+        if not existing_episodes:
+            return 1
+
+        # 提取所有已有的episode_id
+        episode_ids = []
+        for metadata_file in existing_episodes:
+            # 文件名格式: episode_001_metadata.json
+            match = re.match(r"episode_(\d+)_metadata\.json", metadata_file.name)
+            if match:
+                episode_ids.append(int(match.group(1)))
+
+        if episode_ids:
+            return max(episode_ids) + 1
+        else:
+            return 1
+
+    def calculate_card_positions(self) -> List[Tuple[int, int]]:
+        """计算 3 个选项按钮的点击位置"""
+        # 根据截图分析，选项按钮在屏幕约65-68%高度处
+        y = 860  # 调整后的坐标（720x1280屏幕，避免触发键盘）
+        positions = [
+            (135, y),  # 左边（选项a）
+            (360, y),  # 中间（选项b）
+            (585, y),  # 右边（选项c）
+        ]
+        return positions
+
+    def calculate_next_button_position(self) -> Tuple[int, int]:
+        """计算"下一轮"按钮的位置"""
+        # 下一轮按钮在屏幕约80-82%高度处
+        return (360, 1040)
+
+    def random_choice(self) -> int:
+        """随机选择一个索引（0, 1, 2）"""
+        import random
+
+        return random.choice([0, 1, 2])
+
+    def capture_and_save(self, episode_id: int, round_num: int, suffix: str = "") -> Optional[str]:
+        """
+        截图并保存，使用标准化的文件名
+
+        文件名格式: episode_{ep}_round_{rd}_{suffix}.png
+        例如: episode_001_round_03_question.png, episode_001_round_03_result.png
+
+        Args:
+            episode_id: 局数
+            round_num: 轮数
+            suffix: 文件名后缀，如 "question" 或 "result"
+
+        Returns:
+            保存的文件路径（相对路径），失败返回 None
+        """
+        try:
+            screenshot = self.controller.capture_screenshot()
+
+            # 标准化文件名
+            if suffix:
+                filename = f"episode_{episode_id:03d}_round_{round_num:02d}_{suffix}.png"
+            else:
+                filename = f"episode_{episode_id:03d}_round_{round_num:02d}.png"
+            filepath = self.output_dir / filename
+
+            screenshot.save(filepath)
+
+            if self.debug:
+                print(f"[{self.device_id}] 截图已保存: {filepath}")
+
+            return str(filepath.relative_to(self.output_dir.parent))
+
+        except Exception as e:
+            print(f"⚠ [{self.device_id}] 截图失败: {e}")
+            return None
+
+    def check_card_color_changed(self) -> bool:
+        """
+        简单检查：等待一下后重新截图，看是否有颜色变化
+        这里用简化的方法：如果点击后界面没报错，就认为成功
+        """
+        time.sleep(0.8)
+        return True  # 简化处理，假设点击总是成功
+
+    def play_one_round(self, episode_id: int, round_num: int) -> Optional[Dict]:
+        """
+        玩一轮游戏并收集数据
+
+        收集两张截图：
+        1. question.png - 操作前的状态（灯光+数字选项）
+        2. result.png - 操作后的反馈（显示正确答案）
+
+        Returns:
+            该轮的元数据字典，失败返回 None
+        """
+        print(f"[{self.device_id}] Round {round_num}/10")
+
+        # 短暂延迟，避免并发时ADB冲突
+        time.sleep(0.3)
+
+        # 1. 截图1：question（操作前状态）
+        question_screenshot = self.capture_and_save(episode_id, round_num, "question")
+        if question_screenshot is None:
+            return None
+
+        # 2. 随机选择一个卡片点击
+        selected_index = self.random_choice()
+
+        if self.debug:
+            print(f"[{self.device_id}] 随机选择索引: {selected_index}")
+
+        # 3. 点击卡片
+        positions = self.calculate_card_positions()
+        x, y = positions[selected_index]
+
+        max_retry = 3
+        click_success = False
+
+        for retry in range(max_retry):
+            success = self.controller.tap(x, y, delay=1.0)
+            if not success:
+                if retry < max_retry - 1:
+                    print(f"⚠ [{self.device_id}] 点击失败，重试 {retry + 1}/{max_retry}")
+                    time.sleep(0.5)
+                    continue
+                else:
+                    print(f"⚠ [{self.device_id}] 点击失败，跳过此轮")
+                    return None
+
+            # 检查点击是否成功
+            if self.check_card_color_changed():
+                click_success = True
+                break
+            else:
+                if retry < max_retry - 1:
+                    print(f"⚠ [{self.device_id}] 点击未生效，重试 {retry + 1}/{max_retry}")
+                    time.sleep(0.5)
+
+        if not click_success:
+            print(f"⚠ [{self.device_id}] 多次点击均未成功")
+            return None
+
+        # 4. 等待反馈显示
+        time.sleep(1.5)
+
+        # 5. 截图2：result（操作后反馈，包含正确答案）
+        # 增加短暂延迟避免并发冲突
+        time.sleep(0.2)
+        result_screenshot = self.capture_and_save(episode_id, round_num, "result")
+        if result_screenshot is None:
+            print(f"⚠ [{self.device_id}] result截图失败")
+            return None
+
+        # 6. 点击"下一轮"按钮
+        next_x, next_y = self.calculate_next_button_position()
+        success = self.controller.tap(next_x, next_y, delay=1.0)
+
+        if not success:
+            print(f"⚠ [{self.device_id}] 点击下一轮失败")
+            return None
+
+        # 7. 返回该轮的元数据
+        metadata = {
+            "round": round_num,
+            "question_screenshot": question_screenshot,
+            "result_screenshot": result_screenshot,
+            "selected_index": selected_index,
+            "click_position": [x, y],
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        return metadata
+
+    def collect_one_episode(self, episode_id: int) -> Dict:
+        """
+        收集一局游戏的数据（10轮）
+
+        Returns:
+            该局的元数据字典
+        """
+        print(f"\n{'=' * 60}")
+        print(f"[{self.device_id}] Episode {episode_id} 开始")
+        print(f"{'=' * 60}\n")
+
+        episode_metadata = {
+            "episode_id": episode_id,
+            "device_id": self.device_id,
+            "start_time": datetime.now().isoformat(),
+            "rounds": [],
+            "completed_rounds": 0,
+            "success": False,
+        }
+
+        # 收集10轮数据
+        completed_rounds = 0
+        attempt_count = 0
+        max_attempts = 20  # 最多尝试20次
+
+        while completed_rounds < 10 and attempt_count < max_attempts:
+            attempt_count += 1
+            round_num = completed_rounds + 1
+
+            round_metadata = self.play_one_round(episode_id, round_num)
+
+            if round_metadata is not None:
+                episode_metadata["rounds"].append(round_metadata)
+                completed_rounds += 1
+                print(f"✓ [{self.device_id}] Round {completed_rounds}/10 完成")
+
+                # 轮次间等待
+                if completed_rounds < 10:
+                    time.sleep(1.0)
+            else:
+                print(f"⚠ [{self.device_id}] Round {round_num} 失败，重试...")
+                time.sleep(1.5)
+
+        episode_metadata["completed_rounds"] = completed_rounds
+        episode_metadata["success"] = completed_rounds == 10
+        episode_metadata["end_time"] = datetime.now().isoformat()
+
+        # 截取最终得分界面
+        time.sleep(2.0)
+        final_screenshot_path = self.capture_and_save(episode_id, 99, "final")  # 用99表示final
+        if final_screenshot_path:
+            episode_metadata["final_screenshot"] = final_screenshot_path
+
+        # 保存该局的元数据
+        metadata_file = self.output_dir / f"episode_{episode_id:03d}_metadata.json"
+        with open(metadata_file, "w", encoding="utf-8") as f:
+            json.dump(episode_metadata, f, ensure_ascii=False, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print(f"[{self.device_id}] Episode {episode_id} 完成")
+        print(f"[{self.device_id}] 成功轮数: {completed_rounds}/10")
+        print(f"[{self.device_id}] 元数据已保存: {metadata_file}")
+        print(f"{'=' * 60}\n")
+
+        self.episodes.append(episode_metadata)
+        return episode_metadata
+
+    def refresh_browser(self):
+        """刷新浏览器页面，准备下一局"""
+        print(f"[{self.device_id}] 刷新浏览器...")
+
+        # 点击刷新按钮
+        refresh_button_x = 380
+        refresh_button_y = 130
+        self.controller.tap(refresh_button_x, refresh_button_y, delay=1.0)
+
+        time.sleep(3.0)  # 等待页面加载
+        print(f"[{self.device_id}] 浏览器已刷新")
+
+    def collect_data(self, num_episodes: int) -> List[Dict]:
+        """
+        收集多局游戏数据
+
+        Args:
+            num_episodes: 要收集的局数
+
+        Returns:
+            所有局的元数据列表
+        """
+        # 从续集ID开始
+        for i in range(num_episodes):
+            episode_id = self.start_episode_id + i
+            self.collect_one_episode(episode_id)
+
+            # 局间刷新浏览器（最后一局不需要）
+            if i < num_episodes - 1:
+                self.refresh_browser()
+                time.sleep(2.0)
+
+        # 保存汇总信息
+        summary = {
+            "device_id": self.device_id,
+            "total_episodes": num_episodes,
+            "successful_episodes": sum(1 for ep in self.episodes if ep["success"]),
+            "total_rounds_collected": sum(ep["completed_rounds"] for ep in self.episodes),
+            "collection_time": datetime.now().isoformat(),
+            "output_dir": str(self.output_dir),
+            "episodes": self.episodes,
+        }
+
+        summary_file = self.output_dir / "collection_summary.json"
+        with open(summary_file, "w", encoding="utf-8") as f:
+            json.dump(summary, f, ensure_ascii=False, indent=2)
+
+        print(f"\n{'=' * 60}")
+        print(f"[{self.device_id}] 数据收集完成！")
+        print(f"[{self.device_id}] 总局数: {num_episodes}")
+        print(f"[{self.device_id}] 成功局数: {summary['successful_episodes']}")
+        print(f"[{self.device_id}] 总轮数: {summary['total_rounds_collected']}")
+        print(f"[{self.device_id}] 汇总文件: {summary_file}")
+        print(f"{'=' * 60}\n")
+
+        return self.episodes
+
+
+def collect_from_device(device_id: str, num_episodes: int, output_dir: str, debug: bool) -> Dict:
+    """
+    从单个设备收集数据（用于并发执行）
+
+    Returns:
+        收集汇总信息
+    """
+    try:
+        collector = DataCollector(device_id=device_id, output_dir=output_dir, debug=debug)
+
+        collector.collect_data(num_episodes)
+
+        # 读取汇总文件
+        summary_file = collector.output_dir / "collection_summary.json"
+        with open(summary_file, encoding="utf-8") as f:
+            return json.load(f)
+
+    except Exception as e:
+        print(f"⚠ 设备 {device_id} 收集失败: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return {"device_id": device_id, "error": str(e), "success": False}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="游戏数据收集脚本（用于离线训练）")
+
+    # 设备配置
+    parser.add_argument(
+        "--devices",
+        type=str,
+        nargs="+",
+        required=True,
+        help="Android 设备地址列表，如: 101.43.137.83:5555 192.168.1.100:5555",
+    )
+
+    # 收集配置
+    parser.add_argument("--episodes", type=int, default=10, help="每个设备收集多少局游戏（默认10局）")
+
+    parser.add_argument("--output-dir", type=str, default="game_data_raw", help="输出目录（默认 game_data_raw）")
+
+    # 执行模式
+    parser.add_argument("--parallel", action="store_true", help="并发执行多个设备（默认顺序执行）")
+
+    parser.add_argument("--max-workers", type=int, default=4, help="并发执行时的最大线程数（默认4）")
+
+    parser.add_argument("--debug", action="store_true", help="开启调试模式")
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("游戏数据收集脚本")
+    print("=" * 60)
+    print(f"设备数量: {len(args.devices)}")
+    print(f"每设备局数: {args.episodes}")
+    print(f"预计总轮数: {len(args.devices) * args.episodes * 10}")
+    print(f"输出目录: {args.output_dir}")
+    print(f"执行模式: {'并发' if args.parallel else '顺序'}")
+    print("=" * 60)
+    print()
+
+    start_time = time.time()
+    all_summaries = []
+
+    if args.parallel and len(args.devices) > 1:
+        # 并发执行
+        print(f"使用 {min(args.max_workers, len(args.devices))} 个线程并发收集数据...\n")
+
+        with ThreadPoolExecutor(max_workers=min(args.max_workers, len(args.devices))) as executor:
+            # 提交所有任务
+            future_to_device = {
+                executor.submit(collect_from_device, device_id, args.episodes, args.output_dir, args.debug): device_id
+                for device_id in args.devices
+            }
+
+            # 等待完成
+            for future in as_completed(future_to_device):
+                device_id = future_to_device[future]
+                try:
+                    summary = future.result()
+                    all_summaries.append(summary)
+                    print(f"✓ 设备 {device_id} 数据收集完成")
+                except Exception as e:
+                    print(f"⚠ 设备 {device_id} 发生异常: {e}")
+    else:
+        # 顺序执行
+        for device_id in args.devices:
+            print(f"\n处理设备: {device_id}")
+            print("-" * 60)
+
+            summary = collect_from_device(device_id, args.episodes, args.output_dir, args.debug)
+            all_summaries.append(summary)
+
+    # 生成总汇总
+    elapsed_time = time.time() - start_time
+    total_summary = {
+        "total_devices": len(args.devices),
+        "episodes_per_device": args.episodes,
+        "total_episodes_collected": sum(s.get("total_episodes", 0) for s in all_summaries),
+        "successful_episodes": sum(s.get("successful_episodes", 0) for s in all_summaries),
+        "total_rounds_collected": sum(s.get("total_rounds_collected", 0) for s in all_summaries),
+        "collection_time_seconds": elapsed_time,
+        "output_dir": args.output_dir,
+        "timestamp": datetime.now().isoformat(),
+        "device_summaries": all_summaries,
+    }
+
+    # 保存总汇总
+    output_path = Path(args.output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    total_summary_file = output_path / "total_summary.json"
+    with open(total_summary_file, "w", encoding="utf-8") as f:
+        json.dump(total_summary, f, ensure_ascii=False, indent=2)
+
+    # 打印最终结果
+    print("\n" + "=" * 60)
+    print("所有数据收集完成！")
+    print("=" * 60)
+    print(f"总设备数: {total_summary['total_devices']}")
+    print(f"总局数: {total_summary['total_episodes_collected']}")
+    print(f"成功局数: {total_summary['successful_episodes']}")
+    print(f"总轮数: {total_summary['total_rounds_collected']}")
+    print(f"耗时: {elapsed_time:.1f} 秒 ({elapsed_time / 60:.1f} 分钟)")
+    print(f"输出目录: {args.output_dir}")
+    print(f"总汇总文件: {total_summary_file}")
+    print("=" * 60)
+    print("\n下一步: 使用标注脚本对收集的截图进行批量标注")
+
+
+if __name__ == "__main__":
+    main()

EasyR1/examples/android_gui_cookbook/game_docker/.dockerignore

@@ -0,0 +1,9 @@
+# Docker ignore file
+*.pyc
+__pycache__/
+.git/
+.gitignore
+*.md
+.DS_Store
+DOCKER_README.md
+game.yaml

EasyR1/examples/android_gui_cookbook/game_docker/DOCKER_README.md

@@ -0,0 +1,170 @@
+# 数字选择游戏 - Docker 镜像
+
+## 📦 镜像信息
+
+**镜像名称**: `number-game-rl`  
+**当前版本**: `v1.4`  
+**镜像仓库**: `ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl`  
+**架构**: `linux/amd64`  
+**大小**: ~124MB
+**基础镜像**: `python:3.11-slim`
+
+## 🚀 使用方法
+
+### 1. Docker 部署
+
+```bash
+# 从腾讯云镜像仓库拉取并运行
+docker run -d \
+  --name number-game \
+  -p 8000:8000 \
+  ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl:v1.4
+
+# 自定义端口（例如映射到9000）
+docker run -d \
+  --name number-game \
+  -p 9000:8000 \
+  ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl:v1.4
+```
+
+### 2. 访问游戏
+
+打开浏览器访问：
+```
+http://localhost:8000/number_game.html
+```
+
+### 3. Kubernetes 部署（推荐）
+
+使用提供的 `game.yaml` 配置文件进行部署：
+
+```bash
+# 部署到 Kubernetes 集群
+kubectl apply -f game.yaml
+```
+
+**game.yaml 配置说明：**
+
+```yaml
+# Deployment 配置
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: number-game
+spec:
+  replicas: 1                                    # 副本数
+  template:
+    spec:
+      containers:
+      - name: number-game
+        image: ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl:v1.4
+        imagePullPolicy: IfNotPresent            # 镜像拉取策略
+        ports:
+        - containerPort: 8000
+        resources:
+          limits:
+            cpu: "2"                             # CPU限制：2核
+            memory: 4Gi                          # 内存限制：4GB
+          requests:
+            cpu: "2"                             # CPU请求：2核
+            memory: 4Gi                          # 内存请求：4GB
+
+---
+# Service 配置（LoadBalancer类型）
+apiVersion: v1
+kind: Service
+metadata:
+  name: number-game
+  annotations:
+    service.cloud.tencent.com/direct-access: "true"  # 腾讯云直连
+spec:
+  type: LoadBalancer                             # 使用负载均衡器
+  allocateLoadBalancerNodePorts: false           # 不分配节点端口
+  ports:
+  - name: 8000-8000-tcp
+    port: 8000
+    targetPort: 8000
+    protocol: TCP
+  selector:
+    k8s-app: number-game
+```
+
+**部署后访问：**
+
+```bash
+# 查看服务状态
+kubectl get svc number-game
+
+# 获取 LoadBalancer 外部IP
+kubectl get svc number-game -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
+
+# 访问游戏（替换为实际的外部IP）
+# http://<EXTERNAL-IP>:8000/number_game.html
+```
+
+**扩缩容：**
+
+```bash
+# 扩展副本数
+kubectl scale deployment number-game --replicas=3
+
+# 查看 Pod 状态
+kubectl get pods -l k8s-app=number-game
+```
+
+**删除部署：**
+
+```bash
+kubectl delete -f game.yaml
+```
+
+## 🎮 游戏说明
+
+这是一个**条件反转数字选择游戏**，用于强化学习训练。
+
+### 游戏规则
+
+1. **观察指示灯**（屏幕上方3个圆形）：
+   - 🟢 绿灯亮：选择**最大**的数字
+   - 🔴 红灯亮：选择**最小**的数字
+   - 🟡 黄灯亮：选择**中间**的数字
+
+2. **得分规则**：
+   - 选对：+10 分
+   - 选错：-10 分
+
+3. **游戏目标**：完成10轮，获得最高分
+
+### 适配分辨率
+
+- 优化适配：720x1280（Android设备）
+- 兼容：桌面浏览器、平板、手机
+
+## 🔧 镜像内容
+
+```
+/app/
+  └── number_game.html  # 游戏HTML文件（包含CSS和JavaScript）
+```
+
+## 📝 环境变量
+
+无需配置环境变量，开箱即用。
+
+## 🐛 故障排查
+
+### 容器无法启动
+```bash
+docker logs number-game
+```
+
+### 端口冲突
+```bash
+# 更换端口
+docker run -d --name number-game -p 9000:8000 number-game-rl:v1.0
+```
+
+### 查看容器状态
+```bash
+docker ps -a | grep number-game
+```

EasyR1/examples/android_gui_cookbook/game_docker/Dockerfile

@@ -0,0 +1,15 @@
+# 数字选择游戏 - Docker镜像
+# 平台: linux/amd64
+FROM --platform=linux/amd64 python:3.11-slim
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制游戏文件
+COPY number_game.html /app/
+
+# 暴露端口
+EXPOSE 8000
+
+# 启动HTTP服务器
+CMD ["python", "-m", "http.server", "8000"]

EasyR1/examples/android_gui_cookbook/game_docker/game-deployment.yaml

@@ -0,0 +1,33 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    k8s-app: number-game
+    qcloud-app: number-game
+  name: number-game
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      k8s-app: number-game
+      qcloud-app: number-game
+  template:
+    metadata:
+      labels:
+        k8s-app: number-game
+        qcloud-app: number-game
+    spec:
+      containers:
+      - image: ccr.ccs.tencentyun.com/yuehuazhang/number-game-rl:v1.4
+        imagePullPolicy: IfNotPresent
+        name: number-game
+        ports:
+        - containerPort: 8000
+          protocol: TCP
+        resources:
+          limits:
+            cpu: "2"
+            memory: 4Gi
+          requests:
+            cpu: "2"
+            memory: 4Gi

EasyR1/examples/android_gui_cookbook/game_docker/game-service.yaml

@@ -0,0 +1,24 @@
+apiVersion: v1
+kind: Service
+metadata:
+  annotations:
+    service.cloud.tencent.com/direct-access: "true"
+  labels:
+    k8s-app: number-game
+    qcloud-app: number-game
+    service.cloud.tencent.com/loadbalance-type: OPEN
+  name: number-game
+spec:
+  allocateLoadBalancerNodePorts: false
+  ipFamilies:
+  - IPv4
+  ipFamilyPolicy: SingleStack
+  ports:
+  - name: 8000-8000-tcp
+    port: 8000
+    protocol: TCP
+    targetPort: 8000
+  selector:
+    k8s-app: number-game
+    qcloud-app: number-game
+  type: LoadBalancer

EasyR1/examples/android_gui_cookbook/game_docker/number_game.html

@@ -0,0 +1,603 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <title>数字选择游戏 - RL 训练</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            -webkit-tap-highlight-color: transparent;
+        }
+
+        body {
+            font-family: 'Arial', sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            display: flex;
+            justify-content: center;
+            align-items: flex-start;
+            min-height: 100vh;
+            padding: 5px;
+            overflow-y: auto;
+        }
+
+        .game-container {
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 8px 20px rgba(0,0,0,0.3);
+            padding: 8px 10px;
+            max-width: 500px;
+            width: 100%;
+            margin-top: 5px;
+        }
+
+        .title {
+            text-align: center;
+            color: #333;
+            font-size: 16px;
+            font-weight: bold;
+            margin-bottom: 3px;
+        }
+
+        .subtitle {
+            text-align: center;
+            color: #666;
+            font-size: 10px;
+            margin-bottom: 6px;
+        }
+
+        .score-board {
+            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+            border-radius: 8px;
+            padding: 8px;
+            margin-bottom: 6px;
+            text-align: center;
+            color: white;
+        }
+
+        .score-label {
+            font-size: 11px;
+            margin-bottom: 3px;
+            opacity: 0.9;
+        }
+
+        .score-value {
+            font-size: 28px;
+            font-weight: bold;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
+        }
+
+        .round-info {
+            display: flex;
+            justify-content: space-between;
+            margin-top: 5px;
+            font-size: 10px;
+            opacity: 0.9;
+        }
+
+        .instruction {
+            background: #f8f9fa;
+            border-radius: 6px;
+            padding: 6px;
+            margin-bottom: 6px;
+            text-align: center;
+            color: #333;
+            font-size: 11px;
+            font-weight: 500;
+        }
+
+        /* 指示灯容器 */
+        .indicator-container {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            gap: 10px;
+            margin-bottom: 6px;
+            padding: 8px;
+            background: #f8f9fa;
+            border-radius: 8px;
+        }
+
+        .indicator-light {
+            width: 45px;
+            height: 45px;
+            border-radius: 50%;
+            border: 2px solid #ddd;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 9px;
+            font-weight: bold;
+            color: #999;
+            transition: all 0.3s ease;
+            position: relative;
+        }
+
+        .indicator-light.active {
+            border-color: #333;
+            box-shadow: 0 0 12px rgba(0,0,0,0.3), inset 0 0 12px rgba(255,255,255,0.3);
+            animation: glow 1.5s ease-in-out infinite;
+        }
+
+        .indicator-light.green {
+            background: radial-gradient(circle, #38ef7d, #11998e);
+        }
+
+        .indicator-light.red {
+            background: radial-gradient(circle, #f45c43, #eb3349);
+        }
+
+        .indicator-light.yellow {
+            background: radial-gradient(circle, #ffd200, #f7971e);
+        }
+
+        .indicator-light.inactive {
+            background: #ccc;
+        }
+
+        @keyframes glow {
+            0%, 100% { box-shadow: 0 0 12px rgba(0,0,0,0.3), inset 0 0 12px rgba(255,255,255,0.3); }
+            50% { box-shadow: 0 0 18px rgba(0,0,0,0.5), inset 0 0 18px rgba(255,255,255,0.5); }
+        }
+
+        .indicator-label {
+            text-align: center;
+            font-size: 9px;
+            color: #666;
+            margin-top: 3px;
+        }
+
+        .cards-container {
+            display: flex;
+            justify-content: space-around;
+            gap: 6px;
+            margin-bottom: 8px;
+        }
+
+        .card {
+            flex: 1;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            border-radius: 10px;
+            padding: 20px 10px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            box-shadow: 0 6px 15px rgba(0,0,0,0.2);
+            position: relative;
+            overflow: hidden;
+        }
+
+        .card:hover {
+            transform: translateY(-3px);
+            box-shadow: 0 8px 20px rgba(0,0,0,0.3);
+        }
+
+        .card:active {
+            transform: translateY(-1px);
+        }
+
+        .card.selected {
+            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+            animation: pulse 0.5s ease;
+        }
+
+        .card.correct {
+            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+        }
+
+        .card.wrong {
+            background: linear-gradient(135deg, #eb3349 0%, #f45c43 100%);
+        }
+
+        .card.medium {
+            background: linear-gradient(135deg, #f7971e 0%, #ffd200 100%);
+        }
+
+        .card-number {
+            font-size: 42px;
+            font-weight: bold;
+            color: white;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+
+        .card-label {
+            font-size: 9px;
+            color: white;
+            margin-top: 5px;
+            opacity: 0.9;
+        }
+
+        @keyframes pulse {
+            0%, 100% { transform: scale(1); }
+            50% { transform: scale(1.05); }
+        }
+
+        .feedback {
+            text-align: center;
+            font-size: 13px;
+            font-weight: bold;
+            min-height: 20px;
+            margin-bottom: 8px;
+            transition: all 0.3s ease;
+        }
+
+        .feedback.correct {
+            color: #38ef7d;
+        }
+
+        .feedback.wrong {
+            color: #f45c43;
+        }
+
+        .feedback.medium {
+            color: #ffd200;
+        }
+
+        .next-button {
+            width: 100%;
+            padding: 10px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            box-shadow: 0 3px 10px rgba(0,0,0,0.2);
+        }
+
+        .next-button:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 12px rgba(0,0,0,0.3);
+        }
+
+        .next-button:active {
+            transform: translateY(0);
+        }
+
+        .next-button:disabled {
+            background: #ccc;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .game-over {
+            text-align: center;
+            padding: 15px;
+        }
+
+        .game-over-title {
+            font-size: 20px;
+            color: #333;
+            margin-bottom: 10px;
+            font-weight: bold;
+        }
+
+        .final-score {
+            font-size: 40px;
+            font-weight: bold;
+            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 15px;
+        }
+
+        .restart-button {
+            padding: 10px 25px;
+            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
+            color: white;
+            border: none;
+            border-radius: 6px;
+            font-size: 14px;
+            font-weight: bold;
+            cursor: pointer;
+            box-shadow: 0 3px 10px rgba(0,0,0,0.2);
+        }
+
+        .stats {
+            margin-top: 15px;
+            background: #f8f9fa;
+            border-radius: 6px;
+            padding: 10px;
+        }
+
+        .stats-row {
+            display: flex;
+            justify-content: space-between;
+            margin: 5px 0;
+            font-size: 12px;
+            color: #333;
+        }
+    </style>
+</head>
+<body>
+    <div class="game-container">
+        <div id="gameView">
+            <h1 class="title">🎯 数字选择游戏</h1>
+            <p class="subtitle">观察指示灯，按规则选择数字</p>
+
+            <div class="score-board">
+                <div class="score-label">当前分数</div>
+                <div class="score-value" id="scoreDisplay">100</div>
+                <div class="round-info">
+                    <span>回合: <span id="roundDisplay">1</span>/10</span>
+                    <span>本轮: <span id="roundScoreDisplay">0</span></span>
+                </div>
+            </div>
+
+            <!-- 指示灯 -->
+            <div class="indicator-container">
+                <div>
+                    <div class="indicator-light inactive" id="greenLight"></div>
+                    <div class="indicator-label">选最大</div>
+                </div>
+                <div>
+                    <div class="indicator-light inactive" id="redLight"></div>
+                    <div class="indicator-label">选最小</div>
+                </div>
+                <div>
+                    <div class="indicator-light inactive" id="yellowLight"></div>
+                    <div class="indicator-label">选中间</div>
+                </div>
+            </div>
+
+            <div class="instruction" id="instructionText">
+                📌 观察指示灯，按照规则选择数字
+            </div>
+
+            <div class="feedback" id="feedback"></div>
+
+            <div class="cards-container" id="cardsContainer">
+                <!-- 卡片将由 JavaScript 生成 -->
+            </div>
+
+            <button class="next-button" id="nextButton" onclick="nextRound()" disabled>
+                下一轮 →
+            </button>
+        </div>
+
+        <div id="gameOverView" style="display: none;">
+            <div class="game-over">
+                <h1 class="game-over-title">🎉 游戏结束</h1>
+                <div class="final-score" id="finalScore">100</div>
+
+                <div class="stats">
+                    <div class="stats-row">
+                        <span>初始分数:</span>
+                        <span>100</span>
+                    </div>
+                    <div class="stats-row">
+                        <span>最终分数:</span>
+                        <span id="finalScoreText">100</span>
+                    </div>
+                    <div class="stats-row">
+                        <span>分数变化:</span>
+                        <span id="scoreChange" style="font-weight: bold;">0</span>
+                    </div>
+                    <div class="stats-row">
+                        <span>正确次数:</span>
+                        <span id="correctCount">0</span>
+                    </div>
+                    <div class="stats-row">
+                        <span>错误次数:</span>
+                        <span id="wrongCount">0</span>
+                    </div>
+                </div>
+
+                <button class="restart-button" onclick="restartGame()">
+                    🔄 重新开始
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        // 游戏状态
+        let score = 100;
+        let round = 1;
+        let maxRounds = 10;
+        let currentNumbers = [];
+        let selectedIndex = null;
+        let roundScore = 0;
+        let correctCount = 0;
+        let wrongCount = 0;
+        let currentRule = null; // 'max', 'min', 'mid'
+
+        // 初始化游戏
+        function initGame() {
+            score = 100;
+            round = 1;
+            selectedIndex = null;
+            roundScore = 0;
+            correctCount = 0;
+            wrongCount = 0;
+            generateNumbers();
+            updateDisplay();
+            document.getElementById('gameView').style.display = 'block';
+            document.getElementById('gameOverView').style.display = 'none';
+        }
+
+        // 生成随机数字和规则
+        function generateNumbers() {
+            currentNumbers = [];
+            const usedNumbers = new Set();
+
+            // 生成3个不重复的数字
+            while (currentNumbers.length < 3) {
+                const num = Math.floor(Math.random() * 9) + 1;
+                if (!usedNumbers.has(num)) {
+                    currentNumbers.push(num);
+                    usedNumbers.add(num);
+                }
+            }
+
+            // 随机选择规则
+            const rules = ['max', 'min', 'mid'];
+            currentRule = rules[Math.floor(Math.random() * rules.length)];
+
+            updateIndicators();
+            renderCards();
+        }
+
+        // 更新指示灯
+        function updateIndicators() {
+            const greenLight = document.getElementById('greenLight');
+            const redLight = document.getElementById('redLight');
+            const yellowLight = document.getElementById('yellowLight');
+
+            // 重置所有灯
+            greenLight.className = 'indicator-light inactive';
+            redLight.className = 'indicator-light inactive';
+            yellowLight.className = 'indicator-light inactive';
+
+            // 激活对应的灯
+            if (currentRule === 'max') {
+                greenLight.className = 'indicator-light green active';
+            } else if (currentRule === 'min') {
+                redLight.className = 'indicator-light red active';
+            } else if (currentRule === 'mid') {
+                yellowLight.className = 'indicator-light yellow active';
+            }
+        }
+
+        // 渲染卡片
+        function renderCards() {
+            const container = document.getElementById('cardsContainer');
+            container.innerHTML = '';
+
+            const labels = ['a', 'b', 'c'];
+            currentNumbers.forEach((num, index) => {
+                const card = document.createElement('div');
+                card.className = 'card';
+                card.innerHTML = `
+                    <div class="card-number">${num}</div>
+                    <div class="card-label">选项 ${labels[index]}</div>
+                `;
+                card.onclick = () => selectCard(index);
+                container.appendChild(card);
+            });
+
+            selectedIndex = null;
+            document.getElementById('nextButton').disabled = true;
+            document.getElementById('feedback').textContent = '';
+            document.getElementById('feedback').className = 'feedback';
+        }
+
+        // 选择卡片
+        function selectCard(index) {
+            if (selectedIndex !== null) return; // 已选择，不能重复选
+
+            selectedIndex = index;
+            const selected = currentNumbers[index];
+            const maxNum = Math.max(...currentNumbers);
+            const minNum = Math.min(...currentNumbers);
+
+            // 计算中间值：排序后取中间位置
+            const sortedNumbers = [...currentNumbers].sort((a, b) => a - b);
+            const midNum = sortedNumbers[1]; // 3个数字，中间位置是索引1
+
+            // 根据规则判断正确答案
+            let correctNum;
+            let ruleName;
+            if (currentRule === 'max') {
+                correctNum = maxNum;
+                ruleName = '最大';
+            } else if (currentRule === 'min') {
+                correctNum = minNum;
+                ruleName = '最小';
+            } else {
+                correctNum = midNum;
+                ruleName = '中间';
+            }
+
+            // 计算奖励
+            if (selected === correctNum) {
+                roundScore = 10;
+                showFeedback('correct', `✓ 正确！按规则选择了${ruleName}数字 ${selected}，+10 分`);
+                correctCount++;
+            } else {
+                roundScore = -10;
+                showFeedback('wrong', `✗ 错误！应该选择${ruleName}数字 ${correctNum}，-10 分`);
+                wrongCount++;
+            }
+
+            // 更新卡片样式
+            const cards = document.querySelectorAll('.card');
+            cards[index].classList.add('selected');
+
+            if (selected === correctNum) {
+                cards[index].classList.add('correct');
+            } else {
+                cards[index].classList.add('wrong');
+            }
+
+            // 显示正确答案
+            currentNumbers.forEach((num, i) => {
+                if (i !== index && num === correctNum) {
+                    cards[i].classList.add('correct');
+                }
+            });
+
+            score += roundScore;
+            updateDisplay();
+            document.getElementById('nextButton').disabled = false;
+        }
+
+        // 显示反馈
+        function showFeedback(type, message) {
+            const feedback = document.getElementById('feedback');
+            feedback.textContent = message;
+            feedback.className = `feedback ${type}`;
+        }
+
+        // 更新显示
+        function updateDisplay() {
+            document.getElementById('scoreDisplay').textContent = score;
+            document.getElementById('roundDisplay').textContent = round;
+            document.getElementById('roundScoreDisplay').textContent =
+                roundScore > 0 ? `+${roundScore}` : roundScore;
+        }
+
+        // 下一轮
+        function nextRound() {
+            round++;
+            roundScore = 0;
+
+            if (round > maxRounds) {
+                gameOver();
+            } else {
+                generateNumbers();
+                updateDisplay();
+            }
+        }
+
+        // 游戏结束
+        function gameOver() {
+            document.getElementById('gameView').style.display = 'none';
+            document.getElementById('gameOverView').style.display = 'block';
+
+            document.getElementById('finalScore').textContent = score;
+            document.getElementById('finalScoreText').textContent = score;
+
+            const change = score - 100;
+            const changeElement = document.getElementById('scoreChange');
+            changeElement.textContent = change > 0 ? `+${change}` : change;
+            changeElement.style.color = change > 0 ? '#38ef7d' : '#f45c43';
+
+            document.getElementById('correctCount').textContent = correctCount;
+            document.getElementById('wrongCount').textContent = wrongCount;
+        }
+
+        // 重新开始
+        function restartGame() {
+            initGame();
+        }
+
+        // 页面加载时初始化
+        window.onload = initGame;
+    </script>
+</body>
+</html>

EasyR1/examples/android_gui_cookbook/vlm_client.py

@@ -0,0 +1,107 @@
+"""
+VLM 模型客户端
+
+支持 Ollama 和 vLLM 两种模型服务
+"""
+
+import base64
+from io import BytesIO
+
+import requests
+from PIL import Image
+
+
+class VLMClient:
+    """VLM 模型客户端（支持 Ollama 和 vLLM）"""
+
+    def __init__(self, model_type: str, api_url: str, model_name: str):
+        """
+        Args:
+            model_type: "ollama" 或 "vllm"
+            api_url: API 地址，如 "http://localhost:11434" 或 "http://localhost:8000"
+            model_name: 模型名称
+        """
+        self.model_type = model_type.lower()
+        self.api_url = api_url.rstrip("/")
+        self.model_name = model_name
+
+        if self.model_type not in ["ollama", "vllm"]:
+            raise ValueError(f"不支持的模型类型: {model_type}, 仅支持 'ollama' 或 'vllm'")
+
+    def _image_to_base64(self, image: Image.Image) -> str:
+        """将 PIL Image 转换为 base64 字符串"""
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        img_bytes = buffered.getvalue()
+        img_base64 = base64.b64encode(img_bytes).decode("utf-8")
+        return img_base64
+
+    def query(self, image: Image.Image, prompt: str) -> str:
+        """
+        查询 VLM 模型
+
+        Args:
+            image: PIL Image 对象
+            prompt: 文本提示
+
+        Returns:
+            模型响应文本
+        """
+        img_base64 = self._image_to_base64(image)
+
+        if self.model_type == "ollama":
+            return self._query_ollama(img_base64, prompt)
+        elif self.model_type == "vllm":
+            return self._query_vllm(img_base64, prompt)
+
+    def _query_ollama(self, img_base64: str, prompt: str) -> str:
+        """查询 Ollama API"""
+        try:
+            payload = {"model": self.model_name, "prompt": prompt, "images": [img_base64], "stream": False}
+
+            response = requests.post(f"{self.api_url}/api/generate", json=payload, timeout=60)
+
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("response", "")
+            else:
+                print(f"⚠ Ollama API 错误: {response.status_code}")
+                return ""
+        except Exception as e:
+            print(f"⚠ Ollama 查询失败: {e}")
+            return ""
+
+    def _query_vllm(self, img_base64: str, prompt: str) -> str:
+        """查询 vLLM API (OpenAI compatible)"""
+        try:
+            payload = {
+                "model": self.model_name,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img_base64}"}},
+                        ],
+                    }
+                ],
+                "max_tokens": 512,
+                "temperature": 0.7,
+            }
+
+            response = requests.post(
+                f"{self.api_url}/v1/chat/completions",
+                json=payload,
+                headers={"Content-Type": "application/json"},
+                timeout=60,
+            )
+
+            if response.status_code == 200:
+                result = response.json()
+                return result["choices"][0]["message"]["content"]
+            else:
+                print(f"⚠ vLLM API 错误: {response.status_code}")
+                return ""
+        except Exception as e:
+            print(f"⚠ vLLM 查询失败: {e}")
+            return ""

EasyR1/examples/baselines/qwen2_5_vl_3b_clevr.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -x
+
+export PYTHONUNBUFFERED=1
+
+MODEL_PATH=Qwen/Qwen2.5-VL-3B-Instruct  # replace it with your local file path
+
+python3 -m verl.trainer.main \
+    config=examples/config.yaml \
+    data.train_files=BUAADreamer/clevr_count_70k@train \
+    data.val_files=BUAADreamer/clevr_count_70k@test \
+    data.format_prompt=./examples/format_prompt/r1v.jinja \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    worker.rollout.tensor_parallel_size=1 \
+    worker.reward.reward_function=./examples/reward_function/r1v.py:compute_score \
+    trainer.experiment_name=qwen2_5_vl_3b_clevr \
+    trainer.n_gpus_per_node=2

EasyR1/examples/baselines/qwen2_5_vl_3b_geoqa8k.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -x
+
+export PYTHONUNBUFFERED=1
+
+MODEL_PATH=Qwen/Qwen2.5-VL-3B-Instruct  # replace it with your local file path
+
+python3 -m verl.trainer.main \
+    config=examples/config.yaml \
+    data.train_files=leonardPKU/GEOQA_8K_R1V@train \
+    data.val_files=leonardPKU/GEOQA_8K_R1V@test \
+    data.format_prompt=./examples/format_prompt/r1v.jinja \
+    worker.actor.model.model_path=${MODEL_PATH} \
+    worker.rollout.tensor_parallel_size=1 \
+    worker.reward.reward_function=./examples/reward_function/r1v.py:compute_score \
+    trainer.experiment_name=qwen2_5_vl_3b_geoqa8k \
+    trainer.n_gpus_per_node=8

EasyR1/examples/format_prompt/dapo.jinja

@@ -0,0 +1 @@
+Solve the following math problem step by step. The last line of your response should be of the form Answer: $Answer (without quotes) where $Answer is the answer to the problem.\n\n{{ content | trim }}\n\nRemember to put your answer on its own line after "Answer:".

EasyR1/examples/format_prompt/math.jinja

@@ -0,0 +1 @@
+{{ content | trim }} You FIRST think about the reasoning process as an internal monologue and then provide the final answer. The reasoning process MUST BE enclosed within <think> </think> tags. The final answer MUST BE put in \boxed{}.

EasyR1/examples/format_prompt/r1v.jinja

@@ -0,0 +1 @@
+{{ content | trim }} A conversation between User and Assistant. The user asks a question, and the Assistant solves it. The assistant first thinks about the reasoning process in the mind and then provides the user with the answer. The reasoning process and answer are enclosed within <think> </think> and <answer> </answer> tags, respectively, i.e., <think> reasoning process here </think><answer> answer here </answer>

EasyR1/examples/reward_function/android_gui.py

@@ -0,0 +1,117 @@
+"""
+Number Game Reward Function
+
+评分规则：
+- 选择正确的数字: +1.0
+- 选择错误的数字: 0.0
+
+输入格式:
+reward_input = {
+    "response": "1",  # 模型输出的答案 (0/1/2)
+    "response_length": 10,  # 响应长度（token数）
+    "ground_truth": "1"  # 正确答案 (0/1/2)
+}
+
+输出格式:
+{
+    "overall": 1.0,  # 总分（必需字段）
+    "accuracy": 1.0  # 准确率（可选，用于监控）
+}
+"""
+
+import re
+from typing import Any
+
+
+# Metadata - EasyR1框架要求
+REWARD_NAME = "number_game"
+REWARD_TYPE = "batch"  # 批量处理模式
+
+
+def extract_answer(response: str) -> str:
+    """
+    从模型响应中提取答案索引
+
+    Args:
+        response: 模型的原始响应
+
+    Returns:
+        "0", "1", "2" 或 ""（提取失败）
+    """
+    # 情况1: 响应本身就是单个数字
+    response = response.strip()
+    if response in ["0", "1", "2"]:
+        return response
+
+    # 情况2: 响应包含多余文字，提取第一个出现的0/1/2
+    match = re.search(r"[012]", response)
+    if match:
+        return match.group(0)
+
+    # 提取失败
+    return ""
+
+
+def compute_score(reward_inputs: list[dict[str, Any]]) -> list[dict[str, float]]:
+    """
+    计算一批样本的得分
+
+    Args:
+        reward_inputs: 包含多个样本的列表，每个样本包含:
+            - response: 模型的响应
+            - response_length: 响应长度
+            - ground_truth: 正确答案
+
+    Returns:
+        每个样本的得分字典列表，包含:
+            - overall: 总分（1.0表示正确，0.0表示错误）
+            - accuracy: 准确率（同overall，用于监控）
+    """
+    scores = []
+
+    for reward_input in reward_inputs:
+        response = reward_input.get("response", "")
+        ground_truth = reward_input.get("ground_truth", "")
+
+        # 提取答案
+        predicted = extract_answer(response)
+
+        # 计算得分
+        if predicted == ground_truth:
+            score = 1.0
+        else:
+            score = 0.0
+
+        # 返回格式：必须包含overall字段
+        scores.append({"overall": score, "accuracy": score})
+
+    return scores
+
+
+# 测试用例
+if __name__ == "__main__":
+    test_cases = [
+        # 完美匹配
+        {"response": "0", "response_length": 1, "ground_truth": "0"},
+        {"response": "1", "response_length": 1, "ground_truth": "1"},
+        {"response": "2", "response_length": 1, "ground_truth": "2"},
+        # 响应包含额外文字
+        {"response": "The answer is 1", "response_length": 15, "ground_truth": "1"},
+        {"response": "I choose option 2", "response_length": 18, "ground_truth": "2"},
+        # 错误答案
+        {"response": "0", "response_length": 1, "ground_truth": "1"},
+        {"response": "2", "response_length": 1, "ground_truth": "0"},
+        # 提取失败
+        {"response": "I don't know", "response_length": 12, "ground_truth": "1"},
+        {"response": "", "response_length": 0, "ground_truth": "2"},
+    ]
+
+    scores = compute_score(test_cases)
+
+    print("Reward Function Test Results:")
+    print("=" * 60)
+    for i, (test, score) in enumerate(zip(test_cases, scores), 1):
+        print(f"{i}. Response: {test['response']!r}")
+        print(f"   Ground Truth: {test['ground_truth']!r}")
+        print(f"   Score: {score}")
+        print()

EasyR1/examples/reward_function/dapo.py

@@ -0,0 +1,165 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from typing import Any
+
+
+# Metadata
+REWARD_NAME = "dapo"
+REWARD_TYPE = "batch"
+
+
+# Constants for normalization
+SUBSTITUTIONS = [
+    ("an ", ""),
+    ("a ", ""),
+    (".$", "$"),
+    ("\\$", ""),
+    (r"\ ", ""),
+    (" ", ""),
+    ("mbox", "text"),
+    (",\\text{and}", ","),
+    ("\\text{and}", ","),
+    ("\\text{m}", "\\text{}"),
+]
+
+REMOVED_EXPRESSIONS = [
+    "square",
+    "ways",
+    "integers",
+    "dollars",
+    "mph",
+    "inches",
+    "hours",
+    "km",
+    "units",
+    "\\ldots",
+    "sue",
+    "points",
+    "feet",
+    "minutes",
+    "digits",
+    "cents",
+    "degrees",
+    "cm",
+    "gm",
+    "pounds",
+    "meters",
+    "meals",
+    "edges",
+    "students",
+    "childrentickets",
+    "multiples",
+    "\\text{s}",
+    "\\text{.}",
+    "\\text{\ns}",
+    "\\text{}^2",
+    "\\text{}^3",
+    "\\text{\n}",
+    "\\text{}",
+    r"\mathrm{th}",
+    r"^\circ",
+    r"^{\circ}",
+    r"\;",
+    r",\!",
+    "{,}",
+    '"',
+    "\\dots",
+]
+
+
+def normalize_final_answer(final_answer: str) -> str:
+    """Normalize a final answer to a quantitative reasoning question.
+
+    Args:
+        final_answer: The answer string to normalize
+
+    Returns:
+        Normalized answer string
+    """
+    final_answer = final_answer.split("=")[-1]
+
+    # Apply substitutions and removals
+    for before, after in SUBSTITUTIONS:
+        final_answer = final_answer.replace(before, after)
+    for expr in REMOVED_EXPRESSIONS:
+        final_answer = final_answer.replace(expr, "")
+
+    # Extract and normalize LaTeX math
+    final_answer = re.sub(r"(.*?)(\$)(.*?)(\$)(.*)", "$\\3$", final_answer)
+    final_answer = re.sub(r"(\\text\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\textbf\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\overline\{)(.*?)(\})", "\\2", final_answer)
+    final_answer = re.sub(r"(\\boxed\{)(.*)(\})", "\\2", final_answer)
+
+    # Normalize shorthand TeX:
+    #  \fracab -> \frac{a}{b}
+    #  \frac{abc}{bef} -> \frac{abc}{bef}
+    #  \fracabc -> \frac{a}{b}c
+    #  \sqrta -> \sqrt{a}
+    #  \sqrtab -> sqrt{a}b
+    final_answer = re.sub(r"(frac)([^{])(.)", "frac{\\2}{\\3}", final_answer)
+    final_answer = re.sub(r"(sqrt)([^{])", "sqrt{\\2}", final_answer)
+    final_answer = final_answer.replace("$", "")
+
+    # Normalize numbers
+    if final_answer.replace(",", "").isdigit():
+        final_answer = final_answer.replace(",", "")
+
+    return final_answer.strip()
+
+
+def accuracy_reward(response: str, ground_truth: str) -> float:
+    match = re.findall(r"(?i)Answer\s*:\s*([^\n]+)", response)
+    answer = match[-1] if match else "[INVALID]"
+    if normalize_final_answer(answer) == normalize_final_answer(ground_truth):
+        return 1.0
+    else:
+        return -1.0
+
+
+def soft_overlong_punishment(response_length: int, max_response_length: int, overlong_buffer_length: int):
+    expected_len = max_response_length - overlong_buffer_length
+    if response_length <= expected_len:
+        return 0.0
+    elif response_length <= max_response_length:
+        return (expected_len - response_length) / overlong_buffer_length
+    else:
+        return -1.0
+
+
+def compute_score(
+    reward_inputs: list[dict[str, Any]],
+    max_response_length: int,
+    overlong_buffer_length: int,
+    overlong_penalty_factor: float,
+) -> list[dict[str, float]]:
+    scores = []
+    for reward_input in reward_inputs:
+        response = reward_input["response"][-300:]  # The longest answer in MATH-500 has 159 characters
+        accuracy_score = accuracy_reward(response, reward_input["ground_truth"])
+        overlong_score = soft_overlong_punishment(
+            reward_input["response_length"], max_response_length, overlong_buffer_length
+        )
+        scores.append(
+            {
+                "overall": accuracy_score + overlong_score * overlong_penalty_factor,
+                "accuracy": accuracy_score,
+                "overlong": overlong_score,
+                "accuracy_normalized": 0.5 * (accuracy_score + 1.0),
+            }
+        )
+
+    return scores

EasyR1/examples/reward_function/file_queue_judge_worker.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+import os
+import socket
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any
+
+
+CURRENT_DIR = Path(__file__).resolve().parent
+if str(CURRENT_DIR) not in sys.path:
+    sys.path.insert(0, str(CURRENT_DIR))
+
+from paper_conclusion_judge_common import score_prepared_item_via_http
+
+
+DEFAULT_QUEUE_ROOT = CURRENT_DIR.parent.parent / "shared_judge_queue"
+
+
+def queue_dirs(queue_root: Path) -> dict[str, Path]:
+    requests_dir = queue_root / "requests"
+    results_dir = queue_root / "results"
+    return {
+        "pending": requests_dir / "pending",
+        "processing": requests_dir / "processing",
+        "ok": results_dir / "ok",
+        "error": results_dir / "error",
+    }
+
+
+def ensure_queue_dirs(queue_root: Path) -> dict[str, Path]:
+    dirs = queue_dirs(queue_root)
+    for directory in dirs.values():
+        directory.mkdir(parents=True, exist_ok=True)
+    return dirs
+
+
+def atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(path.name + ".tmp")
+    with tmp_path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False)
+    os.replace(tmp_path, path)
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def claim_pending_request(dirs: dict[str, Path]) -> Path | None:
+    for pending_path in sorted(dirs["pending"].glob("*.json")):
+        claimed_path = dirs["processing"] / pending_path.name
+        try:
+            os.replace(pending_path, claimed_path)
+            return claimed_path
+        except FileNotFoundError:
+            continue
+    return None
+
+
+def recover_stale_requests(dirs: dict[str, Path], stale_processing_timeout: float) -> None:
+    if stale_processing_timeout <= 0:
+        return
+
+    now = time.time()
+    for processing_path in dirs["processing"].glob("*.json"):
+        result_ok_path = dirs["ok"] / processing_path.name
+        result_error_path = dirs["error"] / processing_path.name
+        if result_ok_path.exists() or result_error_path.exists():
+            continue
+
+        age_seconds = now - processing_path.stat().st_mtime
+        if age_seconds <= stale_processing_timeout:
+            continue
+
+        recovered_path = dirs["pending"] / processing_path.name
+        try:
+            os.replace(processing_path, recovered_path)
+            print(f"Recovered stale request {processing_path.name} back to pending.")
+        except FileNotFoundError:
+            continue
+
+
+def process_request(
+    request_path: Path,
+    dirs: dict[str, Path],
+    *,
+    base_url: str,
+    model: str,
+    api_key: str,
+    timeout: float,
+    max_retries: int,
+    max_workers: int,
+    format_weight: float,
+    fallback_judge_score: float,
+    suppress_judge_errors: bool,
+    worker_name: str,
+) -> None:
+    request_payload = read_json(request_path)
+    request_id = str(request_payload["request_id"])
+    items = request_payload.get("items", [])
+    judge_config = request_payload.get("judge_config", {})
+    if not isinstance(items, list) or not items:
+        raise RuntimeError(f"Request {request_id} does not contain any items.")
+
+    worker_count = max(1, min(max_workers, len(items)))
+    request_model = str(judge_config.get("model") or model)
+    request_format_weight = float(judge_config.get("format_weight", format_weight))
+
+    def score_item(item: dict[str, Any]) -> dict[str, Any]:
+        score = score_prepared_item_via_http(
+            item,
+            base_url=base_url,
+            model=request_model,
+            api_key=api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            format_weight=request_format_weight,
+            fallback_judge_score=fallback_judge_score,
+            suppress_judge_errors=suppress_judge_errors,
+        )
+        return {"item_id": int(item["item_id"]), "score": score}
+
+    if worker_count == 1:
+        scores = [score_item(item) for item in items]
+    else:
+        with ThreadPoolExecutor(max_workers=worker_count) as executor:
+            futures = [executor.submit(score_item, item) for item in items]
+            scores = [future.result() for future in futures]
+
+    scores.sort(key=lambda item: item["item_id"])
+    result_payload = {
+        "request_id": request_id,
+        "status": "ok",
+        "processed_at": time.time(),
+        "worker": {
+            "host": socket.gethostname(),
+            "pid": os.getpid(),
+            "name": worker_name,
+        },
+        "scores": scores,
+    }
+    atomic_write_json(dirs["ok"] / f"{request_id}.json", result_payload)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Process shared-directory judge requests for EasyR1 reward scoring.")
+    parser.add_argument("--queue-root", default=str(DEFAULT_QUEUE_ROOT))
+    parser.add_argument("--base-url", default="http://127.0.0.1:8000/v1")
+    parser.add_argument("--model", default="qwen3-4b-judge")
+    parser.add_argument("--api-key", default=None)
+    parser.add_argument("--api-key-env", default="OPENAI_API_KEY")
+    parser.add_argument("--timeout", type=float, default=120.0)
+    parser.add_argument("--max-retries", type=int, default=2)
+    parser.add_argument("--max-workers", type=int, default=8)
+    parser.add_argument("--format-weight", type=float, default=0.05)
+    parser.add_argument("--fallback-judge-score", type=float, default=0.0)
+    parser.add_argument("--poll-interval", type=float, default=0.25)
+    parser.add_argument("--poll-interval-max", type=float, default=1.0)
+    parser.add_argument("--stale-processing-timeout", type=float, default=1800.0)
+    parser.add_argument("--worker-name", default=socket.gethostname())
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    queue_root = Path(args.queue_root).expanduser().resolve()
+    dirs = ensure_queue_dirs(queue_root)
+    api_key = args.api_key if args.api_key is not None else os.environ.get(args.api_key_env, "EMPTY")
+
+    idle_sleep = args.poll_interval
+    print(f"Watching queue at {queue_root}")
+
+    while True:
+        recover_stale_requests(dirs, args.stale_processing_timeout)
+        request_path = claim_pending_request(dirs)
+        if request_path is None:
+            time.sleep(idle_sleep)
+            idle_sleep = min(args.poll_interval_max, max(args.poll_interval, idle_sleep * 2))
+            continue
+
+        idle_sleep = args.poll_interval
+        try:
+            process_request(
+                request_path,
+                dirs,
+                base_url=args.base_url,
+                model=args.model,
+                api_key=api_key,
+                timeout=args.timeout,
+                max_retries=args.max_retries,
+                max_workers=args.max_workers,
+                format_weight=args.format_weight,
+                fallback_judge_score=args.fallback_judge_score,
+                suppress_judge_errors=True,
+                worker_name=args.worker_name,
+            )
+            print(f"Processed request {request_path.stem}")
+        except Exception as exc:
+            request_id = request_path.stem
+            error_payload = {
+                "request_id": request_id,
+                "status": "error",
+                "processed_at": time.time(),
+                "worker": {
+                    "host": socket.gethostname(),
+                    "pid": os.getpid(),
+                    "name": args.worker_name,
+                },
+                "error": repr(exc),
+            }
+            atomic_write_json(dirs["error"] / f"{request_id}.json", error_payload)
+            print(f"Failed request {request_id}: {exc}")
+        finally:
+            try:
+                request_path.unlink()
+            except FileNotFoundError:
+                pass
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

EasyR1/examples/reward_function/math.py

@@ -0,0 +1,51 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from typing import Any
+
+from mathruler.grader import extract_boxed_content, grade_answer
+
+
+# Metadata
+REWARD_NAME = "math"
+REWARD_TYPE = "batch"
+
+
+def format_reward(response: str) -> float:
+    pattern = re.compile(r"<think>.*</think>.*\\boxed\{.*\}.*", re.DOTALL)
+    format_match = re.fullmatch(pattern, response)
+    return 1.0 if format_match else 0.0
+
+
+def accuracy_reward(response: str, ground_truth: str) -> float:
+    answer = extract_boxed_content(response)
+    return 1.0 if grade_answer(answer, ground_truth) else 0.0
+
+
+def compute_score(reward_inputs: list[dict[str, Any]], format_weight: float = 0.1) -> list[dict[str, float]]:
+    scores = []
+    for reward_input in reward_inputs:
+        response = re.sub(r"\s*(<|>|/)\s*", r"\1", reward_input["response"])  # handle qwen2.5vl-32b format
+        format_score = format_reward(response)
+        accuracy_score = accuracy_reward(response, reward_input["ground_truth"])
+        scores.append(
+            {
+                "overall": (1 - format_weight) * accuracy_score + format_weight * format_score,
+                "format": format_score,
+                "accuracy": accuracy_score,
+            }
+        )
+
+    return scores

EasyR1/examples/reward_function/paper_conclusion_file_queue_judge.py

@@ -0,0 +1,201 @@
+import json
+import os
+import socket
+import sys
+import time
+import uuid
+from pathlib import Path
+from typing import Any
+
+
+CURRENT_DIR = Path(__file__).resolve().parent
+if str(CURRENT_DIR) not in sys.path:
+    sys.path.insert(0, str(CURRENT_DIR))
+
+from paper_conclusion_judge_common import get_cached_score, prepare_reward_item, store_cached_score
+
+
+REWARD_NAME = "paper_conclusion_file_queue_judge"
+REWARD_TYPE = "batch"
+
+DEFAULT_QUEUE_ROOT = CURRENT_DIR.parent.parent / "shared_judge_queue"
+
+
+def _queue_dirs(queue_root: Path) -> dict[str, Path]:
+    requests_dir = queue_root / "requests"
+    results_dir = queue_root / "results"
+    return {
+        "pending": requests_dir / "pending",
+        "processing": requests_dir / "processing",
+        "ok": results_dir / "ok",
+        "error": results_dir / "error",
+    }
+
+
+def _ensure_queue_dirs(queue_root: Path) -> dict[str, Path]:
+    dirs = _queue_dirs(queue_root)
+    for directory in dirs.values():
+        directory.mkdir(parents=True, exist_ok=True)
+    return dirs
+
+
+def _atomic_write_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(path.name + ".tmp")
+    with tmp_path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False)
+    os.replace(tmp_path, path)
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _compute_wait_interval(
+    elapsed: float,
+    *,
+    poll_interval: float,
+    poll_interval_medium: float,
+    poll_interval_max: float,
+    poll_fast_seconds: float,
+    poll_medium_seconds: float,
+) -> float:
+    if elapsed < poll_fast_seconds:
+        return poll_interval
+    if elapsed < poll_medium_seconds:
+        return max(poll_interval, poll_interval_medium)
+    return max(poll_interval_medium, poll_interval_max)
+
+
+def _normalize_score(score: dict[str, Any]) -> dict[str, float]:
+    return {
+        "overall": float(score["overall"]),
+        "format": float(score["format"]),
+        "judge": float(score["judge"]),
+        "matched": float(score["matched"]),
+    }
+
+
+def compute_score(
+    reward_inputs: list[dict[str, Any]],
+    *,
+    queue_root: str = str(DEFAULT_QUEUE_ROOT),
+    model: str = "qwen3-4b-judge",
+    result_timeout: float = 1800.0,
+    poll_interval: float = 0.25,
+    poll_interval_medium: float = 0.5,
+    poll_interval_max: float = 1.0,
+    poll_fast_seconds: float = 10.0,
+    poll_medium_seconds: float = 60.0,
+    format_weight: float = 0.05,
+    experiment_name: str | None = None,
+    cleanup_results: bool = True,
+    **_: Any,
+) -> list[dict[str, float]]:
+    queue_root_path = Path(queue_root).expanduser().resolve()
+    dirs = _ensure_queue_dirs(queue_root_path)
+
+    final_scores: list[dict[str, float] | None] = [None] * len(reward_inputs)
+    pending_items: list[dict[str, Any]] = []
+    pending_cache_keys: dict[int, str | None] = {}
+
+    for item_id, reward_input in enumerate(reward_inputs):
+        prepared_item = prepare_reward_item(reward_input, model=model, format_weight=format_weight)
+        direct_score = prepared_item.get("direct_score")
+        if isinstance(direct_score, dict):
+            final_scores[item_id] = _normalize_score(direct_score)
+            continue
+
+        cache_key = prepared_item.get("cache_key")
+        cached_score = get_cached_score(cache_key)
+        if cached_score is not None:
+            final_scores[item_id] = _normalize_score(cached_score)
+            continue
+
+        pending_cache_keys[item_id] = cache_key
+        pending_items.append(
+            {
+                "item_id": item_id,
+                "paper_id": prepared_item["paper_id"],
+                "reference_conclusions": prepared_item["reference_conclusions"],
+                "predicted_conclusions": prepared_item["predicted_conclusions"],
+                "rubrics": prepared_item["rubrics"],
+                "format_score": float(prepared_item["format_score"]),
+                "cache_key": cache_key,
+            }
+        )
+
+    if not pending_items:
+        return [_normalize_score(score) for score in final_scores if score is not None]
+
+    request_id = str(uuid.uuid4())
+    request_path = dirs["pending"] / f"{request_id}.json"
+    ok_path = dirs["ok"] / f"{request_id}.json"
+    error_path = dirs["error"] / f"{request_id}.json"
+
+    request_payload = {
+        "request_id": request_id,
+        "version": 1,
+        "created_at": time.time(),
+        "source": {
+            "host": socket.gethostname(),
+            "pid": os.getpid(),
+            "experiment": experiment_name or os.environ.get("EXPERIMENT_NAME", ""),
+        },
+        "judge_config": {
+            "model": model,
+            "format_weight": format_weight,
+        },
+        "items": pending_items,
+    }
+    _atomic_write_json(request_path, request_payload)
+
+    start_time = time.time()
+    try:
+        while True:
+            if ok_path.exists():
+                result_payload = _read_json(ok_path)
+                if result_payload.get("request_id") != request_id:
+                    raise RuntimeError(f"Mismatched result file for request {request_id}")
+                for item in result_payload.get("scores", []):
+                    item_id = int(item["item_id"])
+                    score = _normalize_score(item["score"])
+                    final_scores[item_id] = score
+                    store_cached_score(pending_cache_keys.get(item_id), score)
+
+                missing_ids = [idx for idx, score in enumerate(final_scores) if score is None]
+                if missing_ids:
+                    raise RuntimeError(f"Missing scores for request {request_id}: {missing_ids}")
+
+                return [_normalize_score(score) for score in final_scores if score is not None]
+
+            if error_path.exists():
+                error_payload = _read_json(error_path)
+                raise RuntimeError(
+                    f"Judge worker failed for request {request_id}: {error_payload.get('error', 'unknown error')}"
+                )
+
+            elapsed = time.time() - start_time
+            if elapsed > result_timeout:
+                raise TimeoutError(
+                    f"Timed out waiting for judge result after {result_timeout:.1f}s for request {request_id}"
+                )
+
+            time.sleep(
+                _compute_wait_interval(
+                    elapsed,
+                    poll_interval=poll_interval,
+                    poll_interval_medium=poll_interval_medium,
+                    poll_interval_max=poll_interval_max,
+                    poll_fast_seconds=poll_fast_seconds,
+                    poll_medium_seconds=poll_medium_seconds,
+                )
+            )
+    finally:
+        if cleanup_results:
+            for result_path in (ok_path, error_path):
+                try:
+                    result_path.unlink()
+                except FileNotFoundError:
+                    pass

EasyR1/examples/reward_function/paper_conclusion_judge_common.py

@@ -0,0 +1,482 @@
+import json
+import math
+import re
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any
+from urllib import error, request
+
+
+DEFAULT_RUBRIC = """You are evaluating whether the predicted conclusions for a single machine learning research paper match the reference conclusions.
+
+You will be given all reference conclusions and all predicted conclusions for one paper.
+
+Your task is to compare them and score the predictions strictly based on whether they express the same core scientific findings.
+
+Matching rules:
+- A predicted conclusion matches a reference conclusion only if they express the same core scientific finding.
+- Ignore wording differences.
+- Be strict: partial overlap, vagueness, or missing important qualifiers should NOT count as a match.
+- Use one-to-one matching: each reference conclusion can match at most one predicted conclusion, and each predicted conclusion can match at most one reference conclusion.
+
+Scoring rule:
+- Let x be the number of reference conclusions.
+- Let y be the number of predicted conclusions.
+- Let a be the number of matched predicted conclusions.
+- Let b = y - a.
+- The final score is: max(0, a - b) / x.
+
+Return the final score for this paper only."""
+
+JSON_RESPONSE_SCHEMA = {
+    "matched_prediction_indices": [0],
+    "matched_reference_indices": [0],
+    "matched_count": 1,
+    "score": 0.5,
+    "reason": "brief explanation",
+}
+
+_CACHE_LOCK = threading.Lock()
+_SCORE_CACHE: dict[str, dict[str, float]] = {}
+
+
+def normalize_whitespace(text: str) -> str:
+    return re.sub(r"\s+", " ", text or "").strip()
+
+
+def extract_answer_block(response: str) -> str:
+    match = re.search(r"<answer>(.*?)</answer>", response, re.DOTALL | re.IGNORECASE)
+    return match.group(1).strip() if match else response.strip()
+
+
+def extract_json_object(text: str) -> dict[str, Any] | None:
+    text = text.strip()
+    if not text:
+        return None
+
+    candidates = [text]
+
+    fenced = re.findall(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL | re.IGNORECASE)
+    candidates.extend(fenced)
+
+    first = text.find("{")
+    last = text.rfind("}")
+    if first != -1 and last != -1 and last > first:
+        candidates.append(text[first : last + 1])
+
+    for candidate in candidates:
+        try:
+            loaded = json.loads(candidate)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(loaded, dict):
+            return loaded
+
+    return None
+
+
+def normalize_conclusions(items: Any) -> list[str]:
+    if not isinstance(items, list):
+        return []
+
+    normalized: list[str] = []
+    for item in items:
+        if not isinstance(item, str):
+            continue
+        text = normalize_whitespace(item)
+        if text:
+            normalized.append(text)
+    return normalized
+
+
+def parse_numbered_conclusions(text: str) -> list[str]:
+    conclusions: list[str] = []
+    in_section = False
+    for line in text.splitlines():
+        stripped = line.strip()
+
+        if re.match(r"^conclusions?\s*[:：]?\s*$", stripped, re.IGNORECASE):
+            in_section = True
+            continue
+
+        match = re.match(r"^(\d+)[.．)）、-]\s*(.+)$", stripped)
+        if match:
+            conclusions.append(normalize_whitespace(match.group(2)))
+            in_section = True
+            continue
+
+        if in_section and stripped and re.match(r"^[A-Z][A-Za-z0-9 _-]*[:：]$", stripped):
+            break
+
+    return [item for item in conclusions if item]
+
+
+def extract_predicted_conclusions(response: str) -> list[str]:
+    answer_block = extract_answer_block(response)
+    json_obj = extract_json_object(answer_block)
+
+    if json_obj is not None:
+        for key in ("conclusions", "predicted_conclusions", "answers"):
+            conclusions = normalize_conclusions(json_obj.get(key))
+            if conclusions:
+                return conclusions
+
+    return parse_numbered_conclusions(answer_block)
+
+
+def format_reward(response: str) -> float:
+    return 1.0 if extract_predicted_conclusions(response) else 0.0
+
+
+def make_score(*, format_score: float, judge_score: float, matched_count: float, format_weight: float) -> dict[str, float]:
+    overall = (1.0 - format_weight) * judge_score + format_weight * format_score
+    return {
+        "overall": overall,
+        "format": format_score,
+        "judge": judge_score,
+        "matched": matched_count,
+    }
+
+
+def make_zero_score(format_score: float, format_weight: float) -> dict[str, float]:
+    return make_score(format_score=format_score, judge_score=0.0, matched_count=0.0, format_weight=format_weight)
+
+
+def safe_float(value: Any, default: float = 0.0) -> float:
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return default
+    if math.isnan(result) or math.isinf(result):
+        return default
+    return result
+
+
+def safe_int(value: Any, default: int = 0) -> int:
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def build_cache_key(model: str, paper_id: str, reference_conclusions: list[str], predicted_conclusions: list[str]) -> str:
+    payload = {
+        "model": model,
+        "paper_id": paper_id,
+        "reference_conclusions": reference_conclusions,
+        "predicted_conclusions": predicted_conclusions,
+    }
+    return json.dumps(payload, ensure_ascii=False, sort_keys=True)
+
+
+def get_cached_score(cache_key: str | None) -> dict[str, float] | None:
+    if not cache_key:
+        return None
+    with _CACHE_LOCK:
+        cached = _SCORE_CACHE.get(cache_key)
+    if cached is None:
+        return None
+    return {
+        "overall": cached["overall"],
+        "format": cached["format"],
+        "judge": cached["judge"],
+        "matched": cached["matched"],
+    }
+
+
+def store_cached_score(cache_key: str | None, score: dict[str, float]) -> None:
+    if not cache_key:
+        return
+    with _CACHE_LOCK:
+        _SCORE_CACHE[cache_key] = {
+            "overall": float(score["overall"]),
+            "format": float(score["format"]),
+            "judge": float(score["judge"]),
+            "matched": float(score["matched"]),
+        }
+
+
+def format_indexed_list(items: list[str]) -> str:
+    if not items:
+        return "(empty)"
+    return "\n".join(f"{idx}. {item}" for idx, item in enumerate(items))
+
+
+def build_messages(
+    reference_conclusions: list[str],
+    predicted_conclusions: list[str],
+    rubrics: str,
+) -> list[dict[str, str]]:
+    user_prompt = f"""Evaluate the predicted conclusion list against the reference conclusion list for exactly one paper.
+
+Use strict one-to-one semantic matching between the two lists.
+
+Rubric:
+{rubrics}
+
+Reference conclusions:
+{format_indexed_list(reference_conclusions)}
+
+Predicted conclusions:
+{format_indexed_list(predicted_conclusions)}
+
+Return a JSON object only, with this schema:
+{json.dumps(JSON_RESPONSE_SCHEMA, ensure_ascii=False)}
+
+Rules:
+- `matched_prediction_indices` and `matched_reference_indices` must describe the one-to-one matches you used.
+- `matched_count` must equal the number of matched pairs.
+- `score` must follow the rubric exactly.
+- If there are no valid matches, return empty index lists and score 0.
+"""
+
+    return [
+        {
+            "role": "system",
+            "content": "You are a strict evaluator for research-paper conclusion matching. Return JSON only.",
+        },
+        {"role": "user", "content": user_prompt},
+    ]
+
+
+def post_json(
+    url: str,
+    payload: dict[str, Any],
+    timeout: float,
+    api_key: str,
+) -> dict[str, Any]:
+    body = json.dumps(payload).encode("utf-8")
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    req = request.Request(
+        url,
+        data=body,
+        headers=headers,
+        method="POST",
+    )
+    with request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def judge_once(
+    *,
+    base_url: str,
+    model: str,
+    api_key: str,
+    timeout: float,
+    reference_conclusions: list[str],
+    predicted_conclusions: list[str],
+    rubrics: str,
+) -> dict[str, Any]:
+    messages = build_messages(reference_conclusions, predicted_conclusions, rubrics)
+    payload = {
+        "model": model,
+        "messages": messages,
+        "temperature": 0.0,
+        "max_tokens": 512,
+    }
+    url = base_url.rstrip("/") + "/chat/completions"
+
+    response_data = post_json(url, payload, timeout=timeout, api_key=api_key)
+    choices = response_data.get("choices") or []
+    if not choices:
+        raise RuntimeError("Judge response does not contain choices.")
+
+    content = choices[0].get("message", {}).get("content", "")
+    json_obj = extract_json_object(content)
+    if json_obj is None:
+        raise RuntimeError(f"Judge output is not valid JSON: {content[:200]}")
+
+    matched_count = safe_int(json_obj.get("matched_count"), default=-1)
+    if matched_count < 0:
+        matched_preds = json_obj.get("matched_prediction_indices")
+        matched_refs = json_obj.get("matched_reference_indices")
+        matched_count = min(
+            len(matched_preds) if isinstance(matched_preds, list) else 0,
+            len(matched_refs) if isinstance(matched_refs, list) else 0,
+        )
+
+    ref_count = len(reference_conclusions)
+    pred_count = len(predicted_conclusions)
+    wrong_count = max(0, pred_count - matched_count)
+    computed_score = max(0.0, matched_count - wrong_count) / ref_count if ref_count > 0 else 0.0
+    reported_score = safe_float(json_obj.get("score"), default=computed_score)
+
+    return {
+        "judge_score": max(0.0, min(1.0, reported_score)),
+        "computed_score": max(0.0, min(1.0, computed_score)),
+        "matched_count": float(matched_count),
+    }
+
+
+def judge_with_retries(
+    *,
+    base_url: str,
+    model: str,
+    api_key: str,
+    timeout: float,
+    max_retries: int,
+    reference_conclusions: list[str],
+    predicted_conclusions: list[str],
+    rubrics: str,
+) -> dict[str, float]:
+    last_error: Exception | None = None
+
+    for attempt in range(max_retries + 1):
+        try:
+            return judge_once(
+                base_url=base_url,
+                model=model,
+                api_key=api_key,
+                timeout=timeout,
+                reference_conclusions=reference_conclusions,
+                predicted_conclusions=predicted_conclusions,
+                rubrics=rubrics,
+            )
+        except (RuntimeError, error.URLError, error.HTTPError, TimeoutError, OSError, ValueError) as exc:
+            last_error = exc
+            if attempt < max_retries:
+                time.sleep(min(2**attempt, 8))
+
+    raise RuntimeError(f"Judge request failed after retries: {last_error}")
+
+
+def prepare_reward_item(
+    reward_input: dict[str, Any],
+    *,
+    model: str,
+    format_weight: float,
+) -> dict[str, Any]:
+    response = reward_input.get("response", "") or ""
+    ground_truth = reward_input.get("ground_truth", {}) or {}
+
+    if not isinstance(ground_truth, dict):
+        return {"direct_score": make_zero_score(format_score=0.0, format_weight=format_weight)}
+
+    reference_conclusions = normalize_conclusions(ground_truth.get("reference_conclusions"))
+    predicted_conclusions = extract_predicted_conclusions(response)
+    paper_id = str(ground_truth.get("paper_id") or ground_truth.get("md5") or "unknown")
+    rubrics = ground_truth.get("rubrics") or DEFAULT_RUBRIC
+
+    format_score = 1.0 if predicted_conclusions else 0.0
+    if not reference_conclusions or not predicted_conclusions:
+        return {
+            "direct_score": make_zero_score(format_score=format_score, format_weight=format_weight),
+            "paper_id": paper_id,
+            "format_score": format_score,
+        }
+
+    cache_key = build_cache_key(model, paper_id, reference_conclusions, predicted_conclusions)
+    return {
+        "paper_id": paper_id,
+        "reference_conclusions": reference_conclusions,
+        "predicted_conclusions": predicted_conclusions,
+        "rubrics": rubrics,
+        "format_score": format_score,
+        "cache_key": cache_key,
+    }
+
+
+def score_prepared_item_via_http(
+    prepared_item: dict[str, Any],
+    *,
+    base_url: str,
+    model: str,
+    api_key: str,
+    timeout: float,
+    max_retries: int,
+    format_weight: float,
+    fallback_judge_score: float,
+    suppress_judge_errors: bool,
+) -> dict[str, float]:
+    direct_score = prepared_item.get("direct_score")
+    if isinstance(direct_score, dict):
+        return direct_score
+
+    cache_key = prepared_item.get("cache_key")
+    cached = get_cached_score(cache_key)
+    if cached is not None:
+        return cached
+
+    try:
+        judge_result = judge_with_retries(
+            base_url=base_url,
+            model=model,
+            api_key=api_key,
+            timeout=timeout,
+            max_retries=max_retries,
+            reference_conclusions=prepared_item["reference_conclusions"],
+            predicted_conclusions=prepared_item["predicted_conclusions"],
+            rubrics=prepared_item["rubrics"],
+        )
+        judge_score = judge_result["computed_score"]
+        matched_count = judge_result["matched_count"]
+    except Exception:
+        if not suppress_judge_errors:
+            raise
+        judge_score = max(0.0, min(1.0, fallback_judge_score))
+        matched_count = 0.0
+
+    score = make_score(
+        format_score=float(prepared_item["format_score"]),
+        judge_score=judge_score,
+        matched_count=matched_count,
+        format_weight=format_weight,
+    )
+    store_cached_score(cache_key, score)
+    return score
+
+
+def compute_scores_http(
+    reward_inputs: list[dict[str, Any]],
+    *,
+    base_url: str,
+    model: str,
+    api_key: str,
+    timeout: float,
+    max_retries: int,
+    max_workers: int,
+    format_weight: float,
+    fallback_judge_score: float,
+    suppress_judge_errors: bool,
+) -> list[dict[str, float]]:
+    prepared_items = [
+        prepare_reward_item(reward_input, model=model, format_weight=format_weight) for reward_input in reward_inputs
+    ]
+
+    worker_count = max(1, min(max_workers, len(prepared_items)))
+    if worker_count == 1:
+        return [
+            score_prepared_item_via_http(
+                prepared_item,
+                base_url=base_url,
+                model=model,
+                api_key=api_key,
+                timeout=timeout,
+                max_retries=max_retries,
+                format_weight=format_weight,
+                fallback_judge_score=fallback_judge_score,
+                suppress_judge_errors=suppress_judge_errors,
+            )
+            for prepared_item in prepared_items
+        ]
+
+    with ThreadPoolExecutor(max_workers=worker_count) as executor:
+        futures = [
+            executor.submit(
+                score_prepared_item_via_http,
+                prepared_item,
+                base_url=base_url,
+                model=model,
+                api_key=api_key,
+                timeout=timeout,
+                max_retries=max_retries,
+                format_weight=format_weight,
+                fallback_judge_score=fallback_judge_score,
+                suppress_judge_errors=suppress_judge_errors,
+            )
+            for prepared_item in prepared_items
+        ]
+        return [future.result() for future in futures]

EasyR1/examples/reward_function/paper_conclusion_list_judge.py

@@ -0,0 +1,44 @@
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+CURRENT_DIR = Path(__file__).resolve().parent
+if str(CURRENT_DIR) not in sys.path:
+    sys.path.insert(0, str(CURRENT_DIR))
+
+from paper_conclusion_judge_common import compute_scores_http, extract_predicted_conclusions, format_reward
+
+
+REWARD_NAME = "paper_conclusion_list_judge"
+REWARD_TYPE = "batch"
+
+
+def compute_score(
+    reward_inputs: list[dict[str, Any]],
+    *,
+    base_url: str = "http://127.0.0.1:8000/v1",
+    model: str = "qwen3-4b-judge",
+    api_key: str | None = None,
+    api_key_env: str = "OPENAI_API_KEY",
+    timeout: float = 120.0,
+    max_retries: int = 2,
+    max_workers: int = 8,
+    format_weight: float = 0.05,
+    fallback_judge_score: float = 0.0,
+    suppress_judge_errors: bool = True,
+) -> list[dict[str, float]]:
+    api_key = api_key if api_key is not None else os.environ.get(api_key_env, "EMPTY")
+    return compute_scores_http(
+        reward_inputs,
+        base_url=base_url,
+        model=model,
+        api_key=api_key,
+        timeout=timeout,
+        max_retries=max_retries,
+        max_workers=max_workers,
+        format_weight=format_weight,
+        fallback_judge_score=fallback_judge_score,
+        suppress_judge_errors=suppress_judge_errors,
+    )

EasyR1/examples/reward_function/r1v.py

@@ -0,0 +1,52 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+from typing import Any
+
+from mathruler.grader import grade_answer
+
+
+# Metadata
+REWARD_NAME = "r1v"
+REWARD_TYPE = "sequential"
+
+
+def format_reward(response: str) -> float:
+    pattern = re.compile(r"<think>.*?</think>\s*<answer>.*?</answer>", re.DOTALL)
+    format_match = re.fullmatch(pattern, response)
+    return 1.0 if format_match else 0.0
+
+
+def accuracy_reward(response: str, ground_truth: str) -> float:
+    try:
+        content_match = re.search(r"<answer>(.*?)</answer>", response)
+        given_answer = content_match.group(1).strip() if content_match else response.strip()
+        if grade_answer(given_answer, ground_truth.strip()):
+            return 1.0
+
+    except Exception:
+        pass
+
+    return 0.0
+
+
+def compute_score(reward_input: dict[str, Any], format_weight: float = 0.5) -> dict[str, float]:
+    format_score = format_reward(reward_input["response"])
+    accuracy_score = accuracy_reward(reward_input["response"], reward_input["ground_truth"])
+    return {
+        "overall": (1 - format_weight) * accuracy_score + format_weight * format_score,
+        "format": format_score,
+        "accuracy": accuracy_score,
+    }

EasyR1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "verl"
+dynamic = [
+    "version",
+    "dependencies",
+    "optional-dependencies",
+    "requires-python",
+    "authors",
+    "description",
+    "readme",
+    "license"
+]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 119
+indent-width = 4
+
+[tool.ruff.lint]
+ignore = ["C901", "E501", "E741", "W605", "C408"]
+select = ["C", "E", "F", "I", "W", "RUF022"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["E402", "F401", "F403", "F811"]
+
+[tool.ruff.lint.isort]
+lines-after-imports = 2
+known-first-party = ["verl"]
+known-third-party = ["torch", "transformers", "wandb"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

EasyR1/requirements.txt

@@ -0,0 +1,20 @@
+accelerate
+codetiming
+datasets
+flash-attn>=2.4.3
+liger-kernel
+mathruler
+numpy
+omegaconf
+pandas
+peft
+pillow
+pyarrow>=15.0.0
+pylatexenc
+qwen-vl-utils
+ray[default]
+tensordict
+torchdata
+transformers>=4.54.0,<5.0.0
+vllm>=0.8.0
+wandb

EasyR1/setup.py

@@ -0,0 +1,61 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import re
+
+from setuptools import find_packages, setup
+
+
+def get_version() -> str:
+    with open(os.path.join("verl", "__init__.py"), encoding="utf-8") as f:
+        file_content = f.read()
+        pattern = r"__version__\W*=\W*\"([^\"]+)\""
+        (version,) = re.findall(pattern, file_content)
+        return version
+
+
+def get_requires() -> list[str]:
+    with open("requirements.txt", encoding="utf-8") as f:
+        file_content = f.read()
+        lines = [line.strip() for line in file_content.strip().split("\n") if not line.startswith("#")]
+        return lines
+
+
+extra_require = {
+    "dev": ["pre-commit", "ruff"],
+}
+
+
+def main():
+    setup(
+        name="verl",
+        version=get_version(),
+        description="An Efficient, Scalable, Multi-Modality RL Training Framework based on veRL",
+        long_description=open("README.md", encoding="utf-8").read(),
+        long_description_content_type="text/markdown",
+        author="verl",
+        author_email="zhangchi.usc1992@bytedance.com, gmsheng@connect.hku.hk, hiyouga@buaa.edu.cn",
+        license="Apache 2.0 License",
+        url="https://github.com/volcengine/verl",
+        package_dir={"": "."},
+        packages=find_packages(where="."),
+        python_requires=">=3.9.0",
+        install_requires=get_requires(),
+        extras_require=extra_require,
+    )
+
+
+if __name__ == "__main__":
+    main()

EasyR1/tests/check_license.py

@@ -0,0 +1,39 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from pathlib import Path
+
+
+KEYWORDS = ("Copyright", "2024", "Bytedance")
+
+
+def main():
+    path_list: list[Path] = []
+    for check_dir in sys.argv[1:]:
+        path_list.extend(Path(check_dir).glob("**/*.py"))
+
+    for path in path_list:
+        with open(path.absolute(), encoding="utf-8") as f:
+            file_content = f.read().strip().split("\n")
+            license = "\n".join(file_content[:5])
+            if not license:
+                continue
+
+            print(f"Check license: {path}")
+            assert all(keyword in license for keyword in KEYWORDS), f"File {path} does not contain license."
+
+
+if __name__ == "__main__":
+    main()

EasyR1/tests/test_checkpoint.py

@@ -0,0 +1,50 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import json
+import os
+import shutil
+import uuid
+
+import pytest
+
+from verl.utils.checkpoint import CHECKPOINT_TRACKER, find_latest_ckpt, remove_obsolete_ckpt
+
+
+@pytest.fixture
+def save_checkpoint_path():
+    ckpt_dir = os.path.join("checkpoints", str(uuid.uuid4()))
+    os.makedirs(ckpt_dir, exist_ok=True)
+    yield ckpt_dir
+    shutil.rmtree(ckpt_dir, ignore_errors=True)
+
+
+def test_find_latest_ckpt(save_checkpoint_path):
+    with open(os.path.join(save_checkpoint_path, CHECKPOINT_TRACKER), "w") as f:
+        json.dump({"last_global_step": 10}, f, ensure_ascii=False, indent=2)
+
+    assert find_latest_ckpt(save_checkpoint_path)[0] is None
+    os.makedirs(os.path.join(save_checkpoint_path, "global_step_10"), exist_ok=True)
+    assert find_latest_ckpt(save_checkpoint_path)[0] == os.path.join(save_checkpoint_path, "global_step_10")
+
+
+def test_remove_obsolete_ckpt(save_checkpoint_path):
+    for step in range(5, 30, 5):
+        os.makedirs(os.path.join(save_checkpoint_path, f"global_step_{step}"), exist_ok=True)
+
+    remove_obsolete_ckpt(save_checkpoint_path, global_step=30, best_global_step=10, save_limit=3)
+    for step in range(5, 30, 5):
+        is_exist = step in [10, 25]
+        assert os.path.exists(os.path.join(save_checkpoint_path, f"global_step_{step}")) == is_exist

EasyR1/tests/test_dataproto.py

@@ -0,0 +1,183 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import os
+from typing import Any, Optional
+
+import numpy as np
+import pytest
+import torch
+
+from verl.protocol import DataProto, pad_dataproto_to_divisor, unpad_dataproto
+
+
+def _get_data_proto(
+    tensors: Optional[dict[str, list[Any]]] = None,
+    non_tensors: Optional[dict[str, list[Any]]] = None,
+    meta_info: Optional[dict[str, Any]] = None,
+) -> DataProto:
+    if tensors is None and non_tensors is None:
+        tensors = {"obs": [1, 2, 3, 4, 5, 6]}
+        non_tensors = {"labels": ["a", "b", "c", "d", "e", "f"]}
+
+    if tensors is not None:
+        tensors = {k: torch.tensor(v) if not isinstance(v, torch.Tensor) else v for k, v in tensors.items()}
+
+    if non_tensors is not None:
+        non_tensors = {
+            k: np.array(v, dtype=object) if not isinstance(v, np.ndarray) else v for k, v in non_tensors.items()
+        }
+
+    meta_info = meta_info or {"info": "test_info"}
+    return DataProto.from_dict(tensors=tensors, non_tensors=non_tensors, meta_info=meta_info)
+
+
+def _assert_equal(data1: DataProto, data2: Optional[DataProto] = None):
+    data2 = data2 or _get_data_proto()
+    if data1.batch is not None:
+        assert data1.batch.keys() == data2.batch.keys()
+        for key in data1.batch.keys():
+            assert torch.all(data1.batch[key] == data2.batch[key])
+    else:
+        assert data2.batch is None
+
+    if data1.non_tensor_batch is not None:
+        assert data1.non_tensor_batch.keys() == data2.non_tensor_batch.keys()
+        for key in data1.non_tensor_batch.keys():
+            assert np.all(data1.non_tensor_batch[key] == data2.non_tensor_batch[key])
+    else:
+        assert data2.non_tensor_batch is None
+
+    assert data1.meta_info == data2.meta_info
+
+
+def test_tensor_dict_constructor():
+    obs = torch.randn(100, 10)
+    act = torch.randn(100, 10, 3)
+    data = DataProto.from_dict(tensors={"obs": obs, "act": act})
+    assert len(data) == 100
+
+    with pytest.raises(AssertionError):
+        data = DataProto.from_dict(tensors={"obs": obs, "act": act}, num_batch_dims=2)
+
+    with pytest.raises(AssertionError):
+        data = DataProto.from_dict(tensors={"obs": obs, "act": act}, num_batch_dims=3)
+
+    labels = np.array(["a", "b", "c"], dtype=object)
+    data = DataProto.from_dict(non_tensors={"labels": labels})
+    assert len(data) == 3
+
+
+def test_getitem():
+    data = _get_data_proto()
+    assert data[0].batch["obs"] == torch.tensor(1)
+    assert data[0].non_tensor_batch["labels"] == "a"
+    _assert_equal(data[1:3], _get_data_proto({"obs": [2, 3]}, {"labels": ["b", "c"]}))
+    _assert_equal(data[[0, 2]], _get_data_proto({"obs": [1, 3]}, {"labels": ["a", "c"]}))
+    _assert_equal(data[torch.tensor([1])], _get_data_proto({"obs": [2]}, {"labels": ["b"]}))
+
+
+def test_select_pop():
+    obs = torch.randn(100, 10)
+    act = torch.randn(100, 3)
+    dataset = _get_data_proto(tensors={"obs": obs, "act": act}, meta_info={"p": 1, "q": 2})
+    selected_dataset = dataset.select(batch_keys=["obs"], meta_info_keys=["p"])
+
+    assert selected_dataset.batch.keys() == {"obs"}
+    assert selected_dataset.meta_info.keys() == {"p"}
+    assert dataset.batch.keys() == {"obs", "act"}
+    assert dataset.meta_info.keys() == {"p", "q"}
+
+    popped_dataset = dataset.pop(batch_keys=["obs"], meta_info_keys=["p"])
+    assert popped_dataset.batch.keys() == {"obs"}
+    assert popped_dataset.meta_info.keys() == {"p"}
+    assert dataset.batch.keys() == {"act"}
+    assert dataset.meta_info.keys() == {"q"}
+
+
+def test_chunk_concat_split():
+    data = _get_data_proto()
+    with pytest.raises(AssertionError):
+        data.chunk(5)
+
+    chunked_data = data.chunk(2)
+
+    assert len(chunked_data) == 2
+    expected_data = _get_data_proto({"obs": [1, 2, 3]}, {"labels": ["a", "b", "c"]})
+    _assert_equal(chunked_data[0], expected_data)
+
+    concat_data = DataProto.concat(chunked_data)
+    _assert_equal(concat_data, data)
+
+    splitted_data = data.split(2)
+    assert len(splitted_data) == 3
+    expected_data = _get_data_proto({"obs": [1, 2]}, {"labels": ["a", "b"]})
+    _assert_equal(splitted_data[0], expected_data)
+
+
+def test_reorder():
+    data = _get_data_proto()
+    data.reorder(torch.tensor([3, 4, 2, 0, 1, 5]))
+    expected_data = _get_data_proto({"obs": [4, 5, 3, 1, 2, 6]}, {"labels": ["d", "e", "c", "a", "b", "f"]})
+    _assert_equal(data, expected_data)
+
+
+@pytest.mark.parametrize("interleave", [True, False])
+def test_repeat(interleave: bool):
+    data = _get_data_proto({"obs": [1, 2]}, {"labels": ["a", "b"]})
+    repeated_data = data.repeat(repeat_times=2, interleave=interleave)
+    expected_tensors = {"obs": [1, 1, 2, 2] if interleave else [1, 2, 1, 2]}
+    expected_non_tensors = {"labels": ["a", "a", "b", "b"] if interleave else ["a", "b", "a", "b"]}
+    _assert_equal(repeated_data, _get_data_proto(expected_tensors, expected_non_tensors))
+
+
+@pytest.mark.parametrize("size_divisor", [2, 3])
+def test_dataproto_pad_unpad(size_divisor: int):
+    data = _get_data_proto({"obs": [1, 2, 3]}, {"labels": ["a", "b", "c"]})
+    # test size_divisor=2
+    padded_data, pad_size = pad_dataproto_to_divisor(data, size_divisor=size_divisor)
+    unpadded_data = unpad_dataproto(padded_data, pad_size=pad_size)
+
+    if size_divisor == 2:
+        assert pad_size == 1
+        expected_tensors = {"obs": [1, 2, 3, 1]}
+        expected_non_tensors = {"labels": ["a", "b", "c", "a"]}
+        expected_data = _get_data_proto(expected_tensors, expected_non_tensors)
+    else:
+        assert pad_size == 0
+        expected_data = data
+
+    _assert_equal(padded_data, expected_data)
+    _assert_equal(unpadded_data, data)
+
+
+def test_data_proto_save_load():
+    data = _get_data_proto()
+    data.save_to_disk("test_data.pt")
+    loaded_data = DataProto.load_from_disk("test_data.pt")
+    os.remove("test_data.pt")
+    _assert_equal(data, loaded_data)
+
+
+def test_union_tensor_dict():
+    obs = torch.randn(100, 10)
+    data1 = _get_data_proto({"obs": obs, "act": torch.randn(100, 3)})
+    data2 = _get_data_proto({"obs": obs, "rew": torch.randn(100)})
+    data1.union(data2)
+
+    data1 = _get_data_proto({"obs": obs, "act": torch.randn(100, 3)})
+    data2 = _get_data_proto({"obs": obs + 1, "rew": torch.randn(100)})
+    with pytest.raises(ValueError):
+        data1.union(data2)

EasyR1/tests/test_dynamic_batch.py

@@ -0,0 +1,78 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import torch
+
+from verl.protocol import DataProto
+from verl.utils.seqlen_balancing import prepare_dynamic_batch, restore_dynamic_batch
+
+
+def _create_random_mask(
+    input_ids: torch.Tensor,
+    max_ratio_of_valid_token: float,
+    max_ratio_of_left_padding: float,
+    min_ratio_of_valid_token: float = 0,
+) -> torch.Tensor:
+    """Create a random mask given input_ids. Support left padding and right padding.
+
+    Process:
+    - Sample valid token length
+    - Sample left_padding length
+    - Generate padding
+
+    Args:
+        input_ids:
+            shape (batch_size, seq_len)
+
+    Returns:
+        mask:
+            shape (batch_size, seq_len)
+    """
+    assert max_ratio_of_valid_token > 0 and max_ratio_of_valid_token <= 1.0
+    assert max_ratio_of_left_padding >= 0 and max_ratio_of_left_padding < 1.0
+    assert min_ratio_of_valid_token <= max_ratio_of_valid_token
+
+    batch_size, sequence_length = input_ids.shape
+    max_num_valid_tokens = int(sequence_length * max_ratio_of_valid_token)
+    min_num_valid_tokens = max(1, int(sequence_length * min_ratio_of_valid_token))
+    max_left_padding = int(sequence_length * max_ratio_of_left_padding)
+    assert max_num_valid_tokens + max_left_padding <= sequence_length
+    assert max_num_valid_tokens > 0 and max_ratio_of_valid_token <= sequence_length
+    mask = torch.ones_like(input_ids, dtype=torch.int64)
+    # TODO: we can make this faster
+    for i in range(batch_size):
+        num_left_padding = np.random.randint(low=0, high=max_left_padding + 1, dtype=np.int64)
+        num_valid = np.random.randint(low=min_num_valid_tokens, high=max_num_valid_tokens + 1, dtype=np.int64)
+
+        for index in range(num_left_padding):
+            mask[i, index] = 0
+
+        for index in range(num_left_padding + num_valid, sequence_length):
+            mask[i, index] = 0
+
+    return mask
+
+
+def test_dynamic_batch():
+    input_ids = torch.randint(low=0, high=10, size=(20, 100))
+    attention_mask = _create_random_mask(
+        input_ids=input_ids, max_ratio_of_left_padding=0.1, max_ratio_of_valid_token=0.9, min_ratio_of_valid_token=0.5
+    )
+    data = {"input_ids": input_ids, "attention_mask": attention_mask}
+    dataproto = DataProto.from_single_dict(data)
+    micro_batches, micro_bsz_idx_lst = prepare_dynamic_batch(dataproto, max_token_len=300)
+    input_ids = torch.cat([micro_batch.batch["input_ids"] for micro_batch in micro_batches], dim=0)
+    input_ids = restore_dynamic_batch(input_ids, micro_bsz_idx_lst)
+    torch.testing.assert_close(input_ids, dataproto.batch["input_ids"])

EasyR1/verl/models/transformers/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

EasyR1/verl/models/transformers/qwen2_vl.py

@@ -0,0 +1,230 @@
+# Copyright 2024 The Qwen team, Alibaba Group and the HuggingFace Inc. team
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Based on:
+# https://github.com/huggingface/transformers/blob/v4.49.0/src/transformers/models/qwen2_vl/modeling_qwen2_vl.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+from transformers.models.qwen2_vl.modeling_qwen2_vl import (
+    Qwen2VLCausalLMOutputWithPast,
+    Qwen2VLForConditionalGeneration,
+    Qwen2VLModel,
+    Qwen2VLModelOutputWithPast,
+)
+from transformers.models.qwen2_vl.processing_qwen2_vl import Qwen2VLProcessor
+
+
+def get_rope_index(
+    processor: "Qwen2VLProcessor",
+    input_ids: torch.Tensor,
+    image_grid_thw: Optional[torch.Tensor] = None,
+    video_grid_thw: Optional[torch.Tensor] = None,
+    second_per_grid_ts: Optional[torch.Tensor] = None,
+    attention_mask: Optional[torch.Tensor] = None,
+) -> torch.Tensor:
+    """
+    Gets the position ids for Qwen2-VL, it should be generated before sharding the sequence.
+    The batch dim has been removed and the input_ids should be a 1D tensor representing a single example.
+    https://github.com/huggingface/transformers/blob/v4.52.4/src/transformers/models/qwen2_5_vl/modeling_qwen2_5_vl.py#L1405
+    """
+    spatial_merge_size = processor.image_processor.merge_size
+    tokens_per_second = 2
+    image_token_id = processor.tokenizer.convert_tokens_to_ids("<|image_pad|>")
+    video_token_id = processor.tokenizer.convert_tokens_to_ids("<|video_pad|>")
+    vision_start_token_id = processor.tokenizer.convert_tokens_to_ids("<|vision_start|>")
+    if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):
+        if attention_mask is None:
+            attention_mask = torch.ones_like(input_ids)
+
+        position_ids = torch.ones(3, input_ids.size(0), dtype=input_ids.dtype, device=input_ids.device)  # (3, seqlen)
+        image_index, video_index = 0, 0
+        input_ids = input_ids[attention_mask == 1]
+        image_nums, video_nums = 0, 0
+        vision_start_indices = torch.argwhere(input_ids == vision_start_token_id)
+        vision_tokens = input_ids[vision_start_indices + 1]
+        image_nums = (vision_tokens == image_token_id).sum()
+        video_nums = (vision_tokens == video_token_id).sum()
+        input_tokens = input_ids.tolist()
+        llm_pos_ids_list: list = []
+        st = 0
+        remain_images, remain_videos = image_nums, video_nums
+        for _ in range(image_nums + video_nums):
+            if image_token_id in input_tokens and remain_images > 0:
+                ed_image = input_tokens.index(image_token_id, st)
+            else:
+                ed_image = len(input_tokens) + 1
+            if video_token_id in input_tokens and remain_videos > 0:
+                ed_video = input_tokens.index(video_token_id, st)
+            else:
+                ed_video = len(input_tokens) + 1
+            if ed_image < ed_video:
+                t, h, w = (
+                    image_grid_thw[image_index][0],
+                    image_grid_thw[image_index][1],
+                    image_grid_thw[image_index][2],
+                )
+                second_per_grid_t = 0
+                image_index += 1
+                remain_images -= 1
+                ed = ed_image
+            else:
+                t, h, w = (
+                    video_grid_thw[video_index][0],
+                    video_grid_thw[video_index][1],
+                    video_grid_thw[video_index][2],
+                )
+                if second_per_grid_ts is not None:
+                    second_per_grid_t = second_per_grid_ts[video_index]
+                else:
+                    second_per_grid_t = 1.0
+
+                video_index += 1
+                remain_videos -= 1
+                ed = ed_video
+
+            llm_grid_t, llm_grid_h, llm_grid_w = (
+                t.item(),
+                h.item() // spatial_merge_size,
+                w.item() // spatial_merge_size,
+            )
+            text_len = ed - st
+
+            st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0
+            llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+
+            t_index = torch.arange(llm_grid_t).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w)
+            t_index = (t_index * second_per_grid_t * tokens_per_second).long().flatten()
+            h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()
+            w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()
+            llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + text_len + st_idx)
+            st = ed + llm_grid_t * llm_grid_h * llm_grid_w
+
+        if st < len(input_tokens):
+            st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0
+            text_len = len(input_tokens) - st
+            llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+
+        llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)
+        position_ids[..., attention_mask == 1] = llm_positions.to(position_ids.device)
+    else:
+        if attention_mask is not None:
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            position_ids = position_ids.unsqueeze(0).expand(3, -1).to(input_ids.device)
+        else:
+            position_ids = torch.arange(input_ids.shape[1], device=input_ids.device).view(1, -1).expand(3, -1)
+
+    return position_ids
+
+
+def _get_input_embeds(
+    model: "Qwen2VLModel",
+    input_ids: torch.LongTensor,
+    attention_mask: Optional[torch.Tensor] = None,
+    pixel_values: Optional[torch.FloatTensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+):
+    inputs_embeds = model.get_input_embeddings()(input_ids)
+    if pixel_values is not None:
+        pixel_values = pixel_values.type(model.visual.dtype)
+        image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)
+        n_image_tokens = (input_ids == model.config.image_token_id).sum().item()
+        n_image_features = image_embeds.shape[0]
+        if n_image_tokens != n_image_features:
+            raise ValueError(
+                f"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}"
+            )
+
+        mask = input_ids == model.config.image_token_id
+        mask_unsqueezed = mask.unsqueeze(-1)
+        mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)
+        image_mask = mask_expanded.to(inputs_embeds.device)
+
+        image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        pixel_values_videos = pixel_values_videos.type(model.visual.dtype)
+        video_embeds = model.visual(pixel_values_videos, grid_thw=video_grid_thw)
+        n_video_tokens = (input_ids == model.config.video_token_id).sum().item()
+        n_video_features = video_embeds.shape[0]
+        if n_video_tokens != n_video_features:
+            raise ValueError(
+                f"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}"
+            )
+
+        mask = input_ids == model.config.video_token_id
+        mask_unsqueezed = mask.unsqueeze(-1)
+        mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)
+        video_mask = mask_expanded.to(inputs_embeds.device)
+
+        video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    if pixel_values is None and pixel_values_videos is None:
+        config = model.config.vision_config
+        patch_dim = config.in_channels * config.temporal_patch_size * config.patch_size**2
+        pixel_values = torch.zeros((16, patch_dim), dtype=inputs_embeds.dtype, device=inputs_embeds.device)
+        image_grid_thw = torch.tensor([[1, 4, 4]], dtype=torch.long, device=inputs_embeds.device)
+        image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)
+        inputs_embeds += 0.0 * image_embeds.mean()
+
+    if attention_mask is not None:
+        attention_mask = attention_mask.to(inputs_embeds.device)
+
+    return {
+        "inputs_embeds": inputs_embeds,
+        "attention_mask": attention_mask,
+    }
+
+
+def qwen2_vl_base_forward(
+    self: "Qwen2VLModel",
+    input_ids: torch.LongTensor,
+    attention_mask: Optional[torch.Tensor] = None,
+    pixel_values: Optional[torch.FloatTensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    **kwargs,
+):
+    position_ids = kwargs.get("position_ids")
+    if isinstance(position_ids, torch.Tensor) and (position_ids.ndim != 3 or position_ids.size(0) != 4):
+        # we concat the text position ids with the 3D vision position ids by default
+        # see https://github.com/huggingface/transformers/pull/39447
+        raise ValueError("position_ids should be a 3D tensor of shape (4, batch_size, seq_length).")
+
+    input_kwargs = _get_input_embeds(
+        self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw
+    )
+    kwargs.update(input_kwargs)  # avoid lora module to have multiple keyword arguments
+    outputs = self.language_model(input_ids=None, **kwargs)
+    return Qwen2VLModelOutputWithPast(last_hidden_state=outputs.last_hidden_state)
+
+
+def qwen2_vl_model_forward(
+    self: "Qwen2VLForConditionalGeneration",
+    input_ids: torch.LongTensor,
+    labels: Optional[torch.LongTensor] = None,
+    **kwargs,
+) -> "Qwen2VLCausalLMOutputWithPast":
+    outputs = self.model(input_ids=input_ids, **kwargs)
+    hidden_states = outputs[0]
+    logits = self.lm_head(hidden_states)
+
+    return Qwen2VLCausalLMOutputWithPast(logits=logits)

EasyR1/verl/models/transformers/qwen3_vl.py

@@ -0,0 +1,261 @@
+# Copyright 2024 The Qwen team, Alibaba Group and the HuggingFace Inc. team
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Based on:
+# https://github.com/huggingface/transformers/blob/v4.49.0/src/transformers/models/qwen2_vl/modeling_qwen2_vl.py
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional
+
+import torch
+from transformers.models.qwen3_vl.modeling_qwen3_vl import (
+    Qwen3VLCausalLMOutputWithPast,
+    Qwen3VLForConditionalGeneration,
+    Qwen3VLModel,
+    Qwen3VLModelOutputWithPast,
+)
+from transformers.models.qwen3_vl.processing_qwen3_vl import Qwen3VLProcessor
+
+
+def get_rope_index(
+    processor: "Qwen3VLProcessor",
+    input_ids: torch.Tensor,
+    image_grid_thw: Optional[torch.Tensor] = None,
+    video_grid_thw: Optional[torch.Tensor] = None,
+    attention_mask: Optional[torch.Tensor] = None,
+    **kwargs,
+) -> torch.Tensor:
+    """
+    Gets the position ids for Qwen3-VL, it should be generated before sharding the sequence.
+    The batch dim has been removed and the input_ids should be a 1D tensor representing a single example.
+    https://github.com/huggingface/transformers/blob/v4.57.0/src/transformers/models/qwen3_vl/modeling_qwen3_vl.py#L916
+    """
+    spatial_merge_size = processor.image_processor.merge_size
+    image_token_id = processor.image_token_id
+    video_token_id = processor.video_token_id
+    vision_start_token_id = processor.vision_start_token_id
+
+    # Since we use timestamps to seperate videos,
+    # like <t1> <vision_start> <frame1> <vision_end> <t2> <vision_start> <frame2> <vision_end>,
+    # the video_grid_thw should also be split
+    if video_grid_thw is not None:
+        video_grid_thw = torch.repeat_interleave(video_grid_thw, video_grid_thw[:, 0], dim=0)
+        video_grid_thw[:, 0] = 1
+
+    if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):
+        if attention_mask is None:
+            attention_mask = torch.ones_like(input_ids)
+
+        position_ids = torch.ones(3, input_ids.shape[0], dtype=input_ids.dtype, device=input_ids.device)
+        image_index, video_index = 0, 0
+        attention_mask = attention_mask.to(input_ids.device)
+        input_ids = input_ids[attention_mask == 1]
+        image_nums, video_nums = 0, 0
+        vision_start_indices = torch.argwhere(input_ids == vision_start_token_id)
+        vision_tokens = input_ids[vision_start_indices + 1]
+        image_nums = (vision_tokens == image_token_id).sum()
+        video_nums = (vision_tokens == video_token_id).sum()
+        input_tokens = input_ids.tolist()
+        llm_pos_ids_list: list = []
+        st = 0
+        remain_images, remain_videos = image_nums, video_nums
+        for _ in range(image_nums + video_nums):
+            if image_token_id in input_tokens and remain_images > 0:
+                ed_image = input_tokens.index(image_token_id, st)
+            else:
+                ed_image = len(input_tokens) + 1
+            if video_token_id in input_tokens and remain_videos > 0:
+                ed_video = input_tokens.index(video_token_id, st)
+            else:
+                ed_video = len(input_tokens) + 1
+            if ed_image < ed_video:
+                t, h, w = (
+                    image_grid_thw[image_index][0],
+                    image_grid_thw[image_index][1],
+                    image_grid_thw[image_index][2],
+                )
+                image_index += 1
+                remain_images -= 1
+                ed = ed_image
+            else:
+                t, h, w = (
+                    video_grid_thw[video_index][0],
+                    video_grid_thw[video_index][1],
+                    video_grid_thw[video_index][2],
+                )
+                video_index += 1
+                remain_videos -= 1
+                ed = ed_video
+
+            llm_grid_t, llm_grid_h, llm_grid_w = (
+                t.item(),
+                h.item() // spatial_merge_size,
+                w.item() // spatial_merge_size,
+            )
+            text_len = ed - st
+
+            st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0
+            llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+
+            # t_index is always 0 because llm_grid_t is always 1 (we use timestamps to encode the temporal information for videos)
+            t_index = torch.arange(llm_grid_t).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w).flatten()
+            h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()
+            w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()
+            llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + text_len + st_idx)
+            st = ed + llm_grid_t * llm_grid_h * llm_grid_w
+
+        if st < len(input_tokens):
+            st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0
+            text_len = len(input_tokens) - st
+            llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)
+
+        llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)
+        position_ids[..., attention_mask == 1] = llm_positions.to(position_ids.device)
+    else:
+        if attention_mask is not None:
+            position_ids = attention_mask.long().cumsum(-1) - 1
+            position_ids.masked_fill_(attention_mask == 0, 1)
+            position_ids = position_ids.unsqueeze(0).expand(3, -1).to(attention_mask.device)
+        else:
+            position_ids = torch.arange(input_ids.shape[1], device=input_ids.device).view(1, -1).expand(3, -1)
+
+    return position_ids
+
+
+def _get_input_embeds(
+    model: "Qwen3VLModel",
+    input_ids: torch.LongTensor,
+    attention_mask: Optional[torch.Tensor] = None,
+    pixel_values: Optional[torch.FloatTensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+):
+    inputs_embeds = model.get_input_embeddings()(input_ids)
+    image_mask, video_mask = None, None
+    if pixel_values is not None:
+        pixel_values = pixel_values.type(model.visual.dtype)
+        image_embeds, deepstack_image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)
+        n_image_tokens = (input_ids == model.config.image_token_id).sum().item()
+        n_image_features = image_embeds.shape[0]
+        if n_image_tokens != n_image_features:
+            raise ValueError(
+                f"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}"
+            )
+
+        mask = input_ids == model.config.image_token_id
+        mask_unsqueezed = mask.unsqueeze(-1)
+        mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)
+        image_mask = mask_expanded.to(inputs_embeds.device)
+
+        image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+        inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)
+
+    if pixel_values_videos is not None:
+        pixel_values_videos = pixel_values_videos.type(model.visual.dtype)
+        video_embeds, deepstack_video_embeds = model.visual(pixel_values_videos, grid_thw=video_grid_thw)
+        n_video_tokens = (input_ids == model.config.video_token_id).sum().item()
+        n_video_features = video_embeds.shape[0]
+        if n_video_tokens != n_video_features:
+            raise ValueError(
+                f"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}"
+            )
+
+        mask = input_ids == model.config.video_token_id
+        mask_unsqueezed = mask.unsqueeze(-1)
+        mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)
+        video_mask = mask_expanded.to(inputs_embeds.device)
+
+        video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)
+        inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)
+
+    visual_pos_masks = None
+    deepstack_visual_embeds = None
+    if image_mask is not None and video_mask is not None:
+        # aggregate visual_pos_masks and deepstack_visual_embeds
+        image_mask = image_mask[..., 0]
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = image_mask | video_mask
+        deepstack_visual_embeds = []
+        image_mask_joint = image_mask[visual_pos_masks]
+        video_mask_joint = video_mask[visual_pos_masks]
+        for img_embed, vid_embed in zip(deepstack_image_embeds, deepstack_video_embeds):
+            embed_joint = img_embed.new_zeros(visual_pos_masks.sum(), img_embed.shape[-1]).to(img_embed.device)
+            embed_joint[image_mask_joint, :] = img_embed
+            embed_joint[video_mask_joint, :] = vid_embed
+            deepstack_visual_embeds.append(embed_joint)
+    elif image_mask is not None:
+        image_mask = image_mask[..., 0]
+        visual_pos_masks = image_mask
+        deepstack_visual_embeds = deepstack_image_embeds
+    elif video_mask is not None:
+        video_mask = video_mask[..., 0]
+        visual_pos_masks = video_mask
+        deepstack_visual_embeds = deepstack_video_embeds
+
+    if pixel_values is None and pixel_values_videos is None:
+        config = model.config.vision_config
+        patch_dim = config.in_channels * config.temporal_patch_size * config.patch_size**2
+        pixel_values = torch.zeros((16, patch_dim), dtype=inputs_embeds.dtype, device=inputs_embeds.device)
+        image_grid_thw = torch.tensor([[1, 4, 4]], dtype=torch.long, device=inputs_embeds.device)
+        image_embeds, dummy_deepstack_image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)
+        inputs_embeds += 0.0 * image_embeds.mean()
+        for emb in dummy_deepstack_image_embeds or []:
+            inputs_embeds += 0.0 * emb.mean()
+
+    if attention_mask is not None:
+        attention_mask = attention_mask.to(inputs_embeds.device)
+
+    return {
+        "inputs_embeds": inputs_embeds,
+        "attention_mask": attention_mask,
+        "visual_pos_masks": visual_pos_masks,
+        "deepstack_visual_embeds": deepstack_visual_embeds,
+    }
+
+
+def qwen3_vl_base_forward(
+    self: "Qwen3VLModel",
+    input_ids: torch.LongTensor,
+    attention_mask: Optional[torch.Tensor] = None,
+    pixel_values: Optional[torch.FloatTensor] = None,
+    pixel_values_videos: Optional[torch.FloatTensor] = None,
+    image_grid_thw: Optional[torch.LongTensor] = None,
+    video_grid_thw: Optional[torch.LongTensor] = None,
+    **kwargs,
+):
+    position_ids = kwargs.get("position_ids")
+    if isinstance(position_ids, torch.Tensor) and (position_ids.ndim != 3 or position_ids.size(0) != 4):
+        # we concat the text position ids with the 3D vision position ids by default
+        # see https://github.com/huggingface/transformers/pull/39447
+        raise ValueError("position_ids should be a 3D tensor of shape (4, batch_size, seq_length).")
+
+    input_kwargs = _get_input_embeds(
+        self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw
+    )
+    kwargs.update(input_kwargs)  # avoid lora module to have multiple keyword arguments
+    outputs = self.language_model(input_ids=None, **kwargs)
+    return Qwen3VLModelOutputWithPast(last_hidden_state=outputs.last_hidden_state)
+
+
+def qwen3_vl_model_forward(
+    self: "Qwen3VLForConditionalGeneration",
+    input_ids: torch.LongTensor,
+    labels: Optional[torch.LongTensor] = None,
+    **kwargs,
+) -> "Qwen3VLCausalLMOutputWithPast":
+    outputs = self.model(input_ids=input_ids, **kwargs)
+    hidden_states = outputs[0]
+    logits = self.lm_head(hidden_states)
+
+    return Qwen3VLCausalLMOutputWithPast(logits=logits)

EasyR1/verl/single_controller/base/register_center/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

EasyR1/verl/single_controller/base/worker_group.py

@@ -0,0 +1,194 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+the class of WorkerGroup
+"""
+
+import logging
+import signal
+import threading
+import time
+from typing import Any, Callable, Optional
+
+from .decorator import MAGIC_ATTR, Dispatch, get_predefined_dispatch_fn, get_predefined_execute_fn
+
+
+class ResourcePool:
+    """The resource pool with meta info such as world size."""
+
+    def __init__(
+        self, process_on_nodes: Optional[Any] = None, max_colocate_count: int = 10, n_gpus_per_node: int = 8
+    ) -> None:
+        if process_on_nodes is None:
+            process_on_nodes = []
+
+        self._store = process_on_nodes
+        self.max_colocate_count = max_colocate_count
+        self.n_gpus_per_node = n_gpus_per_node  # this is left for future huawei GPU that contains 16 GPUs per node
+
+    def add_node(self, process_count):
+        self._store.append(process_count)
+
+    @property
+    def world_size(self):
+        return sum(self._store)
+
+    def __call__(self) -> Any:
+        return self._store
+
+    @property
+    def store(self):
+        return self._store
+
+    def local_world_size_list(self) -> list[int]:
+        nested_local_world_size_list = [
+            [local_world_size for _ in range(local_world_size)] for local_world_size in self._store
+        ]
+        return [item for row in nested_local_world_size_list for item in row]
+
+    def local_rank_list(self) -> list[int]:
+        nested_local_rank_list = [[i for i in range(local_world_size)] for local_world_size in self._store]  # noqa: C416
+        return [item for row in nested_local_rank_list for item in row]
+
+
+class ClassWithInitArgs:
+    """
+    This class stores a class constructor and the args/kwargs to construct the class.
+    It is used to instantiate the remote class.
+    """
+
+    def __init__(self, cls, *args, **kwargs) -> None:
+        self.cls = cls
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self) -> Any:
+        return self.cls(*self.args, **self.kwargs)
+
+
+def check_workers_alive(workers: list, is_alive: Callable, gap_time: float = 1) -> None:
+    while True:
+        for worker in workers:
+            if not is_alive(worker):
+                logging.warning(f"Worker {worker} is not alive, sending signal to main thread")
+                signal.raise_signal(signal.SIGABRT)
+
+        time.sleep(gap_time)
+
+
+class WorkerGroup:
+    """A group of workers"""
+
+    def __init__(self, resource_pool: ResourcePool, **kwargs) -> None:
+        self._is_init_with_detached_workers = True if resource_pool is None else False
+
+        if resource_pool is not None:
+            # handle the case when WorkGroup is attached to an existing one
+            self._procecss_dispatch_config = resource_pool()
+        else:
+            self._procecss_dispatch_config = None
+
+        self._workers = []
+        self._worker_names = []
+
+        self._master_addr = None
+        self._master_port = None
+
+        self._checker_thread: threading.Thread = None
+
+    def _is_worker_alive(self, worker):
+        raise NotImplementedError("WorkerGroup._is_worker_alive called, should be implemented in derived class.")
+
+    def _block_until_all_workers_alive(self) -> None:
+        while True:
+            all_state = [self._is_worker_alive(worker) for worker in self._workers]
+            if False in all_state:
+                time.sleep(1)
+            else:
+                break
+
+    def start_worker_aliveness_check(self, every_n_seconds=1) -> None:
+        # before starting checking worker aliveness, make sure all workers are already alive
+        self._block_until_all_workers_alive()
+
+        self._checker_thread = threading.Thread(
+            target=check_workers_alive, args=(self._workers, self._is_worker_alive, every_n_seconds)
+        )
+        self._checker_thread.start()
+
+    @property
+    def world_size(self):
+        return len(self._workers)
+
+    def _bind_worker_method(self, user_defined_cls, func_generator):
+        """
+        Bind the worker method to the WorkerGroup
+        """
+        for method_name in dir(user_defined_cls):
+            try:
+                method = getattr(user_defined_cls, method_name)
+                assert callable(method), f"{method_name} in {user_defined_cls} is not callable"
+            except Exception:
+                # if it is a property, it will fail because Class doesn't have instance property
+                continue
+
+            if hasattr(method, MAGIC_ATTR):
+                # this method is decorated by register
+                attribute = getattr(method, MAGIC_ATTR)
+                assert isinstance(attribute, dict), f"attribute must be a dictionary. Got {type(attribute)}"
+                assert "dispatch_mode" in attribute, "attribute must contain dispatch_mode in its key"
+
+                dispatch_mode = attribute["dispatch_mode"]
+                execute_mode = attribute["execute_mode"]
+                blocking = attribute["blocking"]
+
+                # get dispatch fn
+                if isinstance(dispatch_mode, Dispatch):
+                    # get default dispatch fn
+                    fn = get_predefined_dispatch_fn(dispatch_mode=dispatch_mode)
+                    dispatch_fn = fn["dispatch_fn"]
+                    collect_fn = fn["collect_fn"]
+                else:
+                    assert isinstance(dispatch_mode, dict)
+                    assert "dispatch_fn" in dispatch_mode
+                    assert "collect_fn" in dispatch_mode
+                    dispatch_fn = dispatch_mode["dispatch_fn"]
+                    collect_fn = dispatch_mode["collect_fn"]
+
+                # get execute_fn_name
+                execute_mode = get_predefined_execute_fn(execute_mode=execute_mode)
+                wg_execute_fn_name = execute_mode["execute_fn_name"]
+
+                # get execute_fn from string
+                try:
+                    execute_fn = getattr(self, wg_execute_fn_name)
+                    assert callable(execute_fn), "execute_fn must be callable"
+                except Exception:
+                    print(f"execute_fn {wg_execute_fn_name} is invalid")
+                    raise
+
+                # bind a new method to the RayWorkerGroup
+                func = func_generator(
+                    self,
+                    method_name,
+                    dispatch_fn=dispatch_fn,
+                    collect_fn=collect_fn,
+                    execute_fn=execute_fn,
+                    blocking=blocking,
+                )
+
+                try:
+                    setattr(self, method_name, func)
+                except Exception:
+                    raise ValueError(f"Fail to set method_name {method_name}")

EasyR1/verl/single_controller/ray/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .base import RayClassWithInitArgs, RayResourcePool, RayWorkerGroup, create_colocated_worker_cls
+
+
+__all__ = ["RayClassWithInitArgs", "RayResourcePool", "RayWorkerGroup", "create_colocated_worker_cls"]

EasyR1/verl/single_controller/ray/base.py

@@ -0,0 +1,493 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+import re
+import string
+import time
+from typing import Any, Optional
+from unittest.mock import patch
+
+import ray
+from ray.actor import ActorHandle
+from ray.experimental.state.api import get_actor
+from ray.util import list_named_actors
+from ray.util.placement_group import PlacementGroup, placement_group
+from ray.util.scheduling_strategies import NodeAffinitySchedulingStrategy, PlacementGroupSchedulingStrategy
+
+from ..base import ClassWithInitArgs, ResourcePool, Worker, WorkerGroup
+from ..base.decorator import MAGIC_ATTR
+
+
+__all__ = ["Worker"]
+
+
+def get_random_string(length: int) -> str:
+    letters_digits = string.ascii_letters + string.digits
+    return "".join(random.choice(letters_digits) for _ in range(length))
+
+
+def func_generator(self, method_name, dispatch_fn, collect_fn, execute_fn, blocking):
+    def func(*args, **kwargs):
+        args, kwargs = dispatch_fn(self, *args, **kwargs)
+        output = execute_fn(method_name, *args, **kwargs)
+        if blocking:
+            output = ray.get(output)
+        output = collect_fn(self, output)
+        return output
+
+    return func
+
+
+def sort_placement_group_by_node_ip(pgs: list[PlacementGroup]) -> list[PlacementGroup]:
+    """
+    Sort the placement groups by node ip, all bundles in a single placement group should be on the same node.
+
+    FSDPCheckpointManager saves sharded model states and optimizer states in local storage, which requires RANK
+    to be consistent across nodes when resume from checkpoint.
+
+    With this function, if there's only one resource pool and there's no node change, RANK should be consistent
+    across nodes in multiple ray jobs, even if the whole ray cluster is restarted.
+    """
+    node_ip = {node["NodeID"]: node["NodeManagerAddress"] for node in ray.nodes()}
+    pg_ip = {}
+    for pg in pgs:
+        specs = ray._private.state.state.placement_group_table(pg.id)
+        # all bunles should be on the same node
+        node_id = specs["bundles_to_node_id"][0]
+        pg_ip[pg.id] = node_ip[node_id]
+
+    return sorted(pgs, key=lambda pg: pg_ip[pg.id])
+
+
+class RayResourcePool(ResourcePool):
+    def __init__(
+        self,
+        process_on_nodes: list[int] = None,
+        use_gpu: bool = True,
+        name_prefix: str = "",
+        max_colocate_count: int = 5,
+        detached: bool = False,
+    ) -> None:
+        super().__init__(process_on_nodes, max_colocate_count)
+        self.use_gpu = use_gpu
+        # print(f"in RayProcessDispatchConfiguration: name_prefix = {name_prefix}")
+        self.name_prefix = name_prefix
+        self.pgs = None
+        self.detached = detached
+
+    def get_placement_groups(self, strategy: str = "STRICT_PACK", name: Optional[str] = None) -> list[PlacementGroup]:
+        if self.pgs is not None:
+            return self.pgs
+
+        pg_name_prefix = (
+            name if name else f"{self.name_prefix}verl_group_{'_'.join([str(count) for count in self._store])}:"
+        )
+        # print(f"pg_name_prefix = {pg_name_prefix}")
+        pg_scheme = [
+            [
+                {"CPU": self.max_colocate_count, "GPU": 1} if self.use_gpu else {"CPU": self.max_colocate_count}
+                for _ in range(process_count)
+            ]
+            for process_count in self._store
+        ]
+
+        lifetime = "detached" if self.detached else None
+
+        pgs = [
+            placement_group(bundles=bundles, strategy=strategy, name=pg_name_prefix + str(idx), lifetime=lifetime)
+            for idx, bundles in enumerate(pg_scheme)
+        ]
+
+        ray.get([pg.ready() for pg in pgs])
+
+        self.pgs = pgs
+        return pgs
+
+
+def extract_pg_from_exist(
+    resource_pools: dict[str, RayResourcePool], src_role_names: list[str], resource_pool: RayResourcePool
+) -> list[PlacementGroup]:
+    src_pgs = [
+        pg
+        for role_name, resource_pool in resource_pools.items()
+        for pg in resource_pool.get_placement_groups()
+        if role_name in src_role_names
+    ]
+
+    sorted_src_pgs = sorted(src_pgs, key=lambda pg: pg.bundle_count, reverse=True)
+    sorted_process_on_nodes = sorted([(val, idx) for idx, val in enumerate(resource_pool.store)], reverse=True)
+
+    unsorted_pgs: list[tuple[int, PlacementGroup]] = []
+    searching_idx = 0
+    for request_process, original_idx in sorted_process_on_nodes:
+        assert searching_idx < len(sorted_src_pgs), f"no enough nodes for request: searching {searching_idx} th node"
+        assert request_process <= sorted_src_pgs[searching_idx].bundle_count, (
+            f"requesting {request_process} processes, bundle count cannot satisfy"
+        )
+        unsorted_pgs.append((original_idx, sorted_src_pgs[searching_idx]))
+        searching_idx += 1
+
+    return [pg for _, pg in sorted(unsorted_pgs)]
+
+
+def merge_resource_pool(rp1: RayResourcePool, rp2: RayResourcePool) -> RayResourcePool:
+    assert rp1.use_gpu == rp2.use_gpu, "Both RayResourcePool must either use_gpu or not"
+    assert rp1.max_colocate_count == rp2.max_colocate_count, (
+        "Both RayResourcePool must has the same max_colocate_count"
+    )
+    assert rp1.n_gpus_per_node == rp2.n_gpus_per_node, "Both RayResourcePool must has the same n_gpus_per_node"
+    assert rp1.detached == rp2.detached, "Detached ResourcePool cannot be merged with non-detached ResourcePool"
+
+    new_store = rp1.store + rp2.store
+
+    merged = RayResourcePool(new_store, rp1.use_gpu, f"{rp1.name_prefix}_{rp2.name_prefix}")
+    merged.pgs = rp1.get_placement_groups() + rp2.get_placement_groups()
+
+    return merged
+
+
+class RayClassWithInitArgs(ClassWithInitArgs):
+    def __init__(self, cls, *args, **kwargs) -> None:
+        # self._options = kwargs.pop('options', dict())
+        super().__init__(cls, *args, **kwargs)
+        self._options = {}
+        self._additional_resource = {}
+
+    def set_additional_resource(self, additional_resource):
+        self._additional_resource = additional_resource
+
+    def update_options(self, options: dict):
+        self._options.update(options)
+
+    def __call__(
+        self,
+        placement_group: PlacementGroup,
+        placement_group_bundle_idx: int,
+        use_gpu: bool = True,
+        num_gpus: int = 1,
+        sharing_with: Worker = None,
+    ) -> Any:
+        if sharing_with is not None:
+            target_node_id = ray.get(sharing_with.get_node_id.remote())
+            cuda_visible_devices = ray.get(sharing_with.get_cuda_visible_devices.remote())
+            options = {"scheduling_strategy": NodeAffinitySchedulingStrategy(node_id=target_node_id, soft=False)}
+            return self.cls.options(**options).remote(
+                *self.args, cuda_visible_devices=cuda_visible_devices, **self.kwargs
+            )
+
+        options = {
+            "scheduling_strategy": PlacementGroupSchedulingStrategy(
+                placement_group=placement_group, placement_group_bundle_index=placement_group_bundle_idx
+            )
+        }
+        options.update(self._options)
+
+        if use_gpu:
+            options["num_gpus"] = num_gpus
+
+        if len(self._additional_resource) > 1:
+            for k, v in self._additional_resource.items():
+                options[k] = v
+
+        # print("cls:", self.cls)
+        # print("args: ", self.args)
+        # print("kwargs: ", self.kwargs)
+        return self.cls.options(**options).remote(*self.args, **self.kwargs)
+
+
+class RayWorkerGroup(WorkerGroup):
+    def __init__(
+        self,
+        resource_pool: RayResourcePool = None,
+        ray_cls_with_init: RayClassWithInitArgs = None,
+        bin_pack: bool = True,
+        name_prefix: str = None,
+        detached: bool = False,
+        worker_names: list[str] = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(resource_pool=resource_pool, **kwargs)
+        self.ray_cls_with_init = ray_cls_with_init
+        self.name_prefix = get_random_string(length=6) if name_prefix is None else name_prefix
+
+        if worker_names is not None:
+            assert self._is_init_with_detached_workers
+            self._worker_names = worker_names
+
+        if self._is_init_with_detached_workers:
+            self._init_with_detached_workers(worker_names=worker_names)
+        else:
+            self._init_with_resource_pool(
+                resource_pool=resource_pool, ray_cls_with_init=ray_cls_with_init, bin_pack=bin_pack, detached=detached
+            )
+
+        if ray_cls_with_init is not None:
+            self._bind_worker_method(self.ray_cls_with_init.cls, func_generator)
+
+    def _is_worker_alive(self, worker: ActorHandle) -> bool:
+        worker_state_dict = get_actor(worker._actor_id.hex())
+        return worker_state_dict.get("state", "undefined") == "ALIVE" if worker_state_dict is not None else False
+
+    def _init_with_detached_workers(self, worker_names: list[str]) -> None:
+        workers = [ray.get_actor(name=name) for name in worker_names]
+        self._workers = workers
+        self._world_size = len(worker_names)
+
+    def _init_with_resource_pool(
+        self, resource_pool: RayResourcePool, ray_cls_with_init: RayClassWithInitArgs, bin_pack: bool, detached: bool
+    ):
+        use_gpu = resource_pool.use_gpu
+
+        strategy = "PACK"
+        if bin_pack:
+            strategy = "STRICT_PACK"
+
+        pgs = resource_pool.get_placement_groups(strategy=strategy)
+        world_size = resource_pool.world_size
+        self._world_size = world_size
+        # cia.add_kwarg("_world_size", world_size)
+        num_gpus = 1 / resource_pool.max_colocate_count
+
+        rank = -1
+        local_world_size = resource_pool.store[0]
+        for pg_idx, pg in enumerate(sort_placement_group_by_node_ip(pgs)):
+            assert local_world_size <= pg.bundle_count, f"when generating for {self.name_prefix}, for the "
+            for local_rank in range(local_world_size):
+                rank += 1
+
+                # we pass in environment variable at option so that Worker can use environment variable to set
+                env_vars = {
+                    "WORLD_SIZE": str(world_size),
+                    "RANK": str(rank),
+                    "WG_PREFIX": self.name_prefix,
+                    "WG_BACKEND": "ray",
+                    "RAY_LOCAL_WORLD_SIZE": str(local_world_size),
+                    "RAY_LOCAL_RANK": str(local_rank),
+                }
+                if rank != 0:
+                    env_vars["MASTER_ADDR"] = self._master_addr
+                    env_vars["MASTER_PORT"] = self._master_port
+
+                cia_name = type(ray_cls_with_init.cls).__name__
+                match = re.search(r"ActorClass\(([^)]+)\)", cia_name)  # ray.remote(Obj) -> "ActorClass(Obj)"
+                cia_name = match.group(1) if match else cia_name  # "ActorClass(Obj)" -> "Obj"
+                name = f"{self.name_prefix}{cia_name}_{pg_idx}:{local_rank}"  # e.g. Worker_2:5
+
+                ray_cls_with_init.update_options({"runtime_env": {"env_vars": env_vars}, "name": name})
+
+                if detached:
+                    ray_cls_with_init.update_options({"lifetime": "detached"})
+
+                # create a worker
+                worker = ray_cls_with_init(
+                    placement_group=pg, placement_group_bundle_idx=local_rank, use_gpu=use_gpu, num_gpus=num_gpus
+                )
+                self._workers.append(worker)
+                self._worker_names.append(name)
+
+                if rank == 0:
+                    register_center_actor = None
+                    for _ in range(120):
+                        if f"{self.name_prefix}_register_center" not in list_named_actors():
+                            time.sleep(1)
+                        else:
+                            register_center_actor = ray.get_actor(f"{self.name_prefix}_register_center")
+                            break
+                    assert register_center_actor is not None, (
+                        f"failed to get register_center_actor: {self.name_prefix}_register_center in {list_named_actors(all_namespaces=True)}"
+                    )
+                    rank_zero_info = ray.get(register_center_actor.get_rank_zero_info.remote())
+                    self._master_addr, self._master_port = rank_zero_info["MASTER_ADDR"], rank_zero_info["MASTER_PORT"]
+                    # print(f"rank_zero_info: {rank_zero_info}")
+                    # print(f"master_addr: {self._master_addr}, master_port: {self._master_port}")
+
+    @property
+    def worker_names(self):
+        return self._worker_names
+
+    @classmethod
+    def from_detached(cls, worker_names=None, ray_cls_with_init=None):
+        worker_group = cls(
+            resource_pool=None, ray_cls_with_init=ray_cls_with_init, name_prefix=None, worker_names=worker_names
+        )
+        return worker_group
+
+    def spawn(self, prefix_set):
+        """
+        spawn to a dictionary of worker groups, each with a subset of method with prefix.
+
+        """
+
+        def _rebind_actor_methods(worker_group, actor_name):
+            """
+            bind the method with actor_prefix to its original name
+            """
+            prefix: str = actor_name + "_"
+            for method_name in dir(worker_group):
+                if method_name.startswith(prefix):
+                    # only valid when Python >= 3.9
+                    original_method_name = method_name.removeprefix(prefix)
+                    method = getattr(worker_group, method_name)
+                    setattr(worker_group, original_method_name, method)
+
+        new_worker_group_dict = {}
+        for prefix in prefix_set:
+            new_worker_group = self.from_detached(
+                worker_names=self._worker_names, ray_cls_with_init=self.ray_cls_with_init
+            )
+
+            _rebind_actor_methods(new_worker_group, prefix)
+            new_worker_group_dict[prefix] = new_worker_group
+        return new_worker_group_dict
+
+    def execute_rank_zero_sync(self, method_name: str, *args, **kwargs):
+        return ray.get(self.execute_rank_zero_async(method_name, *args, **kwargs))
+
+    def execute_rank_zero_async(self, method_name: str, *args, **kwargs):
+        remote_call = getattr(self._workers[0], method_name)
+        return remote_call.remote(*args, **kwargs)
+
+    def execute_rank_zero(self, method_name: str, *args, **kwargs):
+        return self.execute_rank_zero_async(method_name, *args, **kwargs)
+
+    def execute_all(self, method_name: str, *args, **kwargs):
+        return self.execute_all_async(method_name, *args, **kwargs)
+
+    def execute_all_sync(self, method_name: str, *args, **kwargs):
+        return ray.get(self.execute_all_async(method_name, *args, **kwargs))
+
+    def execute_all_async(self, method_name: str, *args, **kwargs):
+        # Here we assume that if all the parameters in args and kwargs are lists,
+        # and the lengths of all these lists are the same as len(self._workers),
+        # then we will send each element in the list to the corresponding worker.
+        # print(f"execute_all_async: method {method_name}({args}, {kwargs})")
+        length = len(self._workers)
+        if all(isinstance(arg, list) for arg in args) and all(isinstance(kwarg, list) for kwarg in kwargs.values()):
+            if all(len(arg) == length for arg in args) and all(len(kwarg) == length for kwarg in kwargs.values()):
+                # print(f"splitting args and kwargs into {length} shards")
+                result = []
+                for i in range(length):
+                    sliced_args = tuple(arg[i] for arg in args)
+                    sliced_kwargs = {k: v[i] for k, v in kwargs.items()}
+                    remote_call = getattr(self._workers[i], method_name)
+                    result.append(remote_call.remote(*sliced_args, **sliced_kwargs))
+                return result
+
+        return [getattr(worker, method_name).remote(*args, **kwargs) for worker in self._workers]
+
+    @property
+    def master_address(self):
+        return self._master_addr
+
+    @property
+    def master_port(self):
+        return self._master_port
+
+    @property
+    def workers(self):
+        return self._workers
+
+    @property
+    def world_size(self):
+        return self._world_size
+
+
+"""
+Utilities that enables creating workers inside the same ray.Actor,
+with code written in separate ray.Actors.
+"""
+
+
+def _bind_workers_method_to_parent(cls, key, user_defined_cls):
+    """
+    Binds the methods of each worker to the WorkerDict.
+    Note that we only bind public methods that are decorated by register
+    """
+    for method_name in dir(user_defined_cls):
+        try:
+            method = getattr(user_defined_cls, method_name)
+            assert callable(method), f"{method_name} in {user_defined_cls} is not callable"
+        except Exception:
+            # if it is a property, it will fail because Class doesn't have instance property
+            continue
+
+        if hasattr(method, MAGIC_ATTR):
+
+            def generate_function(name):
+                def func(self, *args, **kwargs):
+                    # dispatch to the actual worker
+                    return getattr(self.worker_dict[key], name)(*args, **kwargs)
+
+                return func
+
+            func = generate_function(method_name)
+            # pass MAGIC_ATTR for outer worker group
+            setattr(func, MAGIC_ATTR, getattr(method, MAGIC_ATTR))
+            try:
+                method_name_with_prefix = key + "_" + method_name
+                setattr(cls, method_name_with_prefix, func)
+                # print(f'Binding {method_name_with_prefix}')
+            except Exception:
+                raise ValueError(f"Fail to set method_name {method_name}")
+
+
+def _unwrap_ray_remote(cls):
+    if hasattr(cls, "__ray_actor_class__"):
+        cls = cls.__ray_actor_class__
+    return cls
+
+
+def create_colocated_worker_cls(class_dict: dict[str, RayClassWithInitArgs]):
+    """
+    This function should return a class instance that delegates the calls to every
+    cls in cls_dict
+    """
+    cls_dict = {}
+    init_args_dict = {}
+    worker_cls = None
+    for key, cls in class_dict.items():
+        if worker_cls is None:
+            worker_cls = cls.cls.__ray_actor_class__.__base__
+        else:
+            assert worker_cls == cls.cls.__ray_actor_class__.__base__, (
+                "the worker class should be the same when share the same process"
+            )
+        cls_dict[key] = cls.cls
+        init_args_dict[key] = {"args": cls.args, "kwargs": cls.kwargs}
+
+    assert cls_dict.keys() == init_args_dict.keys()
+
+    # TODO: create a class with customizable name
+    class WorkerDict(worker_cls):
+        def __init__(self):
+            super().__init__()
+            self.worker_dict = {}
+            for key, user_defined_cls in cls_dict.items():
+                user_defined_cls = _unwrap_ray_remote(user_defined_cls)
+                # directly instantiate the class without remote
+                with patch.dict(os.environ, {"DISABLE_WORKER_INIT": "1"}):
+                    self.worker_dict[key] = user_defined_cls(
+                        *init_args_dict[key].get("args", ()), **init_args_dict[key].get("kwargs", {})
+                    )
+
+    # now monkey-patch the methods from inner class to WorkerDict
+    for key, user_defined_cls in cls_dict.items():
+        user_defined_cls = _unwrap_ray_remote(user_defined_cls)
+        _bind_workers_method_to_parent(WorkerDict, key, user_defined_cls)
+
+    remote_cls = ray.remote(WorkerDict)
+    remote_cls = RayClassWithInitArgs(cls=remote_cls)
+    return remote_cls

EasyR1/verl/utils/checkpoint/checkpoint_manager.py

@@ -0,0 +1,169 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+import random
+import re
+import shutil
+import tempfile
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Union
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from filelock import FileLock
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from transformers import PreTrainedTokenizer, ProcessorMixin
+
+
+CHECKPOINT_TRACKER = "checkpoint_tracker.json"
+
+
+class BaseCheckpointManager(ABC):
+    """
+    A checkpoint manager that saves and loads
+    - model
+    - optimizer
+    - lr_scheduler
+    - extra_states
+    in a SPMD way.
+
+    We save
+    - sharded model states and optimizer states
+    - full lr_scheduler states
+    - huggingface tokenizer and config for ckpt merge
+    """
+
+    def __init__(
+        self,
+        model: FSDP,
+        optimizer: torch.optim.Optimizer,
+        lr_scheduler: torch.optim.lr_scheduler.LRScheduler,
+        processing_class: Union[PreTrainedTokenizer, ProcessorMixin],
+    ):
+        self.model = model
+        self.optimizer = optimizer
+        self.lr_scheduler = lr_scheduler
+        self.processing_class = processing_class
+
+        assert isinstance(self.model, FSDP)
+        self.rank = dist.get_rank()
+        self.world_size = dist.get_world_size()
+
+    @abstractmethod
+    def load_checkpoint(self, *args, **kwargs):
+        raise NotImplementedError
+
+    @abstractmethod
+    def save_checkpoint(self, *args, **kwargs):
+        raise NotImplementedError
+
+    @staticmethod
+    def local_mkdir(path: str) -> str:
+        if not os.path.isabs(path):
+            working_dir = os.getcwd()
+            path = os.path.join(working_dir, path)
+
+        # Using hash value of path as lock file name to avoid long file name
+        lock_filename = f"ckpt_{hash(path) & 0xFFFFFFFF:08x}.lock"
+        lock_path = os.path.join(tempfile.gettempdir(), lock_filename)
+
+        try:
+            with FileLock(lock_path, timeout=60):
+                os.makedirs(path, exist_ok=True)
+        except Exception as e:
+            print(f"Warning: Failed to acquire lock for {path}: {e}")
+            os.makedirs(path, exist_ok=True)  # even if the lock is not acquired, try to create the directory
+
+        return path
+
+    @staticmethod
+    def get_rng_state() -> dict[str, Any]:
+        rng_state = {
+            "cpu": torch.get_rng_state(),
+            "cuda": torch.cuda.get_rng_state(),
+            "numpy": np.random.get_state(),
+            "random": random.getstate(),
+        }
+        return rng_state
+
+    @staticmethod
+    def load_rng_state(rng_state: dict[str, Any]):
+        torch.set_rng_state(rng_state["cpu"])
+        torch.cuda.set_rng_state(rng_state["cuda"])
+        np.random.set_state(rng_state["numpy"])
+        random.setstate(rng_state["random"])
+
+
+def get_checkpoint_tracker_filename(root_path: str) -> str:
+    """
+    Tracker file rescords the latest chckpoint during training to restart from.
+    """
+    return os.path.join(root_path, CHECKPOINT_TRACKER)
+
+
+def find_latest_ckpt(
+    path: str, directory_format: str = "global_step_{}"
+) -> tuple[Optional[str], Optional[dict[str, Any]]]:
+    """
+    Find the latest checkpoint in the save path.
+    """
+    tracker_file = get_checkpoint_tracker_filename(path)
+    if not os.path.exists(tracker_file):
+        return None, None
+
+    with open(tracker_file, "rb") as f:
+        checkpointer_tracker_info = json.load(f)
+
+    ckpt_path = os.path.join(path, directory_format.format(checkpointer_tracker_info["last_global_step"]))
+    if not os.path.exists(ckpt_path):
+        print(f"Checkpoint does not exist: {ckpt_path}")
+        return None, None
+
+    print(f"Found latest checkpoint: {ckpt_path}, will resume from it. Turn off `find_last_checkpoint` to disable it.")
+    return ckpt_path, checkpointer_tracker_info
+
+
+def remove_obsolete_ckpt(
+    path: str, global_step: int, best_global_step: int, save_limit: int = -1, directory_format: str = "global_step_{}"
+):
+    """
+    Remove the obsolete checkpoints that exceed the save limit.
+    """
+    if save_limit <= 0 or not os.path.exists(path):
+        return
+
+    num_ckpt_to_keep = save_limit - 1  # exclude the current ckpt
+    pattern = re.escape(directory_format).replace(r"\{\}", r"(\d+)")
+    ckpt_global_steps = []
+    for folder in os.listdir(path):
+        if match := re.match(pattern, folder):
+            step = int(match.group(1))
+            if step < global_step:
+                ckpt_global_steps.append(step)
+
+    ckpt_global_steps.sort(reverse=True)
+    if best_global_step in ckpt_global_steps:  # do not remove the best ckpt
+        ckpt_global_steps.remove(best_global_step)
+        num_ckpt_to_keep = max(num_ckpt_to_keep - 1, 0)
+
+    for step in ckpt_global_steps[num_ckpt_to_keep:]:
+        folder_path = os.path.join(path, directory_format.format(step))
+        try:
+            shutil.rmtree(folder_path, ignore_errors=True)
+            print(f"Removed obsolete checkpoint: {folder_path}")
+        except Exception as e:
+            print(f"Failed to remove {folder_path}: {e}")

EasyR1/verl/utils/checkpoint/fsdp_checkpoint_manager.py

@@ -0,0 +1,158 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import json
+import os
+from dataclasses import asdict
+from typing import Optional, Union
+
+import torch
+import torch.distributed as dist
+from peft import PeftModel, get_peft_model_state_dict
+from safetensors.torch import save_file
+from torch.distributed._tensor import DTensor
+from torch.distributed.checkpoint.state_dict import (
+    StateDictOptions,
+    get_model_state_dict,
+    get_state_dict,
+    set_state_dict,
+)
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from transformers import PreTrainedModel, PreTrainedTokenizer, ProcessorMixin
+
+from .checkpoint_manager import BaseCheckpointManager
+
+
+class FSDPCheckpointManager(BaseCheckpointManager):
+    """
+    A checkpoint manager that saves and loads
+    - model
+    - optimizer
+    - lr_scheduler
+    - extra_states
+    in a SPMD way.
+
+    We save
+    - sharded model states and optimizer states
+    - full lr_scheduler states
+    - huggingface tokenizer and config for ckpt merge
+    """
+
+    def __init__(
+        self,
+        model: FSDP,
+        optimizer: torch.optim.Optimizer,
+        lr_scheduler: torch.optim.lr_scheduler.LRScheduler,
+        processing_class: Union[PreTrainedTokenizer, ProcessorMixin],
+    ):
+        super().__init__(model, optimizer, lr_scheduler, processing_class)
+
+    def load_checkpoint(self, path: Optional[str] = None):
+        if path is None:
+            return
+
+        # every rank download its own checkpoint
+        model_path = os.path.join(path, f"model_world_size_{self.world_size}_rank_{self.rank}.pt")
+        optim_path = os.path.join(path, f"optim_world_size_{self.world_size}_rank_{self.rank}.pt")
+        extra_path = os.path.join(path, f"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt")
+        print(f"[rank-{self.rank}]: Loading model from {os.path.abspath(model_path)}.")
+        print(f"[rank-{self.rank}]: Loading optimizer from {os.path.abspath(optim_path)}.")
+        print(f"[rank-{self.rank}]: Loading extra_state from {os.path.abspath(extra_path)}.")
+        model_state_dict = torch.load(model_path, weights_only=False)
+        optim_state_dict = torch.load(optim_path, weights_only=False)
+        extra_state_dict = torch.load(extra_path, weights_only=False)
+
+        state_dict_options = StateDictOptions(cpu_offload=True)
+        set_state_dict(
+            model=self.model,
+            optimizers=self.optimizer,
+            model_state_dict=model_state_dict,
+            optim_state_dict=optim_state_dict,
+            options=state_dict_options,
+        )
+        self.lr_scheduler.load_state_dict(extra_state_dict["lr_scheduler"])
+
+        # recover random state
+        if "rng" in extra_state_dict:
+            self.load_rng_state(extra_state_dict["rng"])
+
+    def save_checkpoint(self, path: str, save_model_only: bool = False):
+        path = self.local_mkdir(path)
+        dist.barrier()
+
+        # every rank will save its own model and optim shard
+        model_path = os.path.join(path, f"model_world_size_{self.world_size}_rank_{self.rank}.pt")
+        optim_path = os.path.join(path, f"optim_world_size_{self.world_size}_rank_{self.rank}.pt")
+        extra_path = os.path.join(path, f"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt")
+
+        state_dict_options = StateDictOptions(cpu_offload=True)
+        if save_model_only:
+            model_state_dict = get_model_state_dict(self.model, options=state_dict_options)
+            print(f"[rank-{self.rank}]: Saving model to {os.path.abspath(model_path)}.")
+            torch.save(model_state_dict, model_path)
+        else:
+            model_state_dict, optim_state_dict = get_state_dict(self.model, self.optimizer, options=state_dict_options)
+            extra_state_dict = {
+                "lr_scheduler": self.lr_scheduler.state_dict(),
+                "rng": self.get_rng_state(),
+            }
+            print(f"[rank-{self.rank}]: Saving model to {os.path.abspath(model_path)}.")
+            print(f"[rank-{self.rank}]: Saving optimizer to {os.path.abspath(optim_path)}.")
+            print(f"[rank-{self.rank}]: Saving extra_state to {os.path.abspath(extra_path)}.")
+            torch.save(model_state_dict, model_path)
+            torch.save(optim_state_dict, optim_path)
+            torch.save(extra_state_dict, extra_path)
+
+        # wait for everyone to dump to local
+        dist.barrier()
+
+        if self.rank == 0:
+            hf_path = os.path.join(path, "huggingface")
+            os.makedirs(hf_path, exist_ok=True)
+            assert isinstance(self.model._fsdp_wrapped_module, (PreTrainedModel, PeftModel))
+            self.model._fsdp_wrapped_module.config.save_pretrained(hf_path)
+            self.model._fsdp_wrapped_module.generation_config.save_pretrained(hf_path)
+            self.processing_class.save_pretrained(hf_path)
+
+        if isinstance(self.model._fsdp_wrapped_module, PeftModel):
+            lora_path = os.path.join(path, "lora_adapter")
+            peft_config = {}
+            if self.rank == 0:
+                os.makedirs(lora_path, exist_ok=True)
+                peft_config = asdict(self.model._fsdp_wrapped_module.peft_config.get("default", {}))
+                peft_config["task_type"] = peft_config["task_type"].value
+                peft_config["peft_type"] = peft_config["peft_type"].value
+                peft_config["target_modules"] = list(peft_config["target_modules"])
+
+            sharded_lora_weights = get_peft_model_state_dict(
+                self.model._fsdp_wrapped_module, state_dict=model_state_dict
+            )
+            cuda_device = torch.device("cuda")
+            lora_weights = {
+                name: sharded_weight.to(cuda_device).full_tensor().detach().cpu()
+                if isinstance(sharded_weight, DTensor)
+                else sharded_weight.detach().cpu()
+                for name, sharded_weight in sharded_lora_weights.items()
+            }
+            torch.cuda.empty_cache()
+            if self.rank == 0:
+                save_file(lora_weights, os.path.join(lora_path, "adapter_model.safetensors"))
+                with open(os.path.join(lora_path, "adapter_config.json"), "w", encoding="utf-8") as f:
+                    json.dump(peft_config, f, ensure_ascii=False, indent=4)
+
+            dist.barrier()
+            if self.rank == 0:
+                print(f"[rank-{self.rank}]: Saved LoRA adapter to: {lora_path}")
+
+        dist.barrier()

EasyR1/verl/workers/sharding_manager/fsdp_vllm.py

@@ -0,0 +1,227 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import re
+import time
+from dataclasses import asdict
+from typing import Iterable, Union
+
+import torch
+import torch.distributed as dist
+from peft import PeftModel, get_peft_model_state_dict
+from torch.distributed._tensor import DTensor
+from torch.distributed.checkpoint.state_dict import get_model_state_dict
+from torch.distributed.device_mesh import DeviceMesh
+from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
+from transformers import PreTrainedModel
+from vllm import LLM
+from vllm.distributed import parallel_state as vllm_ps
+
+from ...protocol import DataProto, all_gather_data_proto
+from ...utils.fsdp_utils import (
+    load_fsdp_model,
+    load_fsdp_submodule,
+    offload_fsdp_model,
+    offload_fsdp_submodule,
+)
+from ...utils.model_utils import print_gpu_memory_usage
+from ...utils.vllm_utils import TensorLoRARequest
+from .base import BaseShardingManager
+
+
+class FSDPVLLMShardingManager(BaseShardingManager):
+    def __init__(
+        self,
+        module: FSDP,
+        inference_engine: LLM,
+        device_mesh: DeviceMesh,
+        use_param_offload: bool,
+    ):
+        self.module = module
+        self.inference_engine = inference_engine
+        self.device_mesh = device_mesh
+        self.use_param_offload = use_param_offload
+        self.loaded = False
+        self.is_lora = isinstance(self.module._fsdp_wrapped_module, PeftModel)
+
+        self.world_size = dist.get_world_size()
+        self.tp_size = vllm_ps.get_tensor_model_parallel_world_size()
+        self.tp_rank = vllm_ps.get_tensor_model_parallel_rank()
+        self.tp_group = vllm_ps.get_tensor_model_parallel_group().device_group
+
+        # Record freed bytes to estimate memory usage correctly
+        # https://github.com/vllm-project/vllm/pull/11743#issuecomment-2754338119
+        self.freed_bytes = 0
+
+        # Note that torch_random_states may be different on each dp rank
+        self.torch_random_states = torch.cuda.get_rng_state()
+        # get a random rng states
+        gen_dp_rank = self.device_mesh["dp"].get_local_rank()
+        torch.cuda.manual_seed(gen_dp_rank + 1000)  # make sure all tp ranks have the same random states
+        self.gen_random_states = torch.cuda.get_rng_state()
+        torch.cuda.set_rng_state(self.torch_random_states)
+
+    def _rename_weight_keys(self, actor_weights: dict[str, Union[torch.Tensor, DTensor]], model: PreTrainedModel):
+        # convert state dict keys: https://github.com/huggingface/transformers/pull/38385
+        if not hasattr(model, "_checkpoint_conversion_mapping"):
+            return actor_weights
+
+        reverse_key_mapping = {v: k for k, v in model._checkpoint_conversion_mapping.items()}
+        original_weights = {}
+        for key, value in actor_weights.items():
+            for pattern, replacement in reverse_key_mapping.items():
+                replacement = replacement.lstrip("^")  # strip off un-needed chars and patterns
+                replacement = re.sub(r"\(.*\)", "", replacement)
+                key, n_replace = re.subn(pattern, replacement, key)
+                # Early exit of the loop
+                if n_replace > 0:
+                    break
+
+            original_weights[key] = value
+
+        return original_weights
+
+    def _make_weight_iterator(
+        self, actor_weights: dict[str, Union[torch.Tensor, DTensor]]
+    ) -> Iterable[tuple[str, torch.Tensor]]:
+        for name, tensor in actor_weights.items():
+            yield name, tensor.full_tensor() if isinstance(tensor, DTensor) else tensor
+
+    def _collect_lora_weights(self) -> dict:
+        """Collect LoRA weights from each transformer layer."""
+        lora_weights = {}
+        peft_model = getattr(self.module, "_fsdp_wrapped_module", self.module)
+        for name, submodule in self.module.named_modules():
+            # Transformer layers are typically named ...layers.N (numeric suffix).
+            if not name.rsplit("layers.", 1)[-1].isdigit():
+                continue
+
+            if self.use_param_offload:
+                load_fsdp_submodule(submodule)
+
+            peft_prefix = name.replace("_fsdp_wrapped_module.base_model.model.", "base_model.model.")
+            layer_weights = get_model_state_dict(submodule)
+            layer_lora_weights = get_peft_model_state_dict(peft_model, state_dict=layer_weights)
+            for lora_module_name, lora_weight in layer_lora_weights.items():
+                key = f"{peft_prefix}.{lora_module_name}"
+                if isinstance(lora_weight, DTensor):
+                    lora_weights[key] = lora_weight.full_tensor().detach().cpu()
+                else:
+                    lora_weights[key] = lora_weight.detach().cpu()
+
+            submodule._is_root = False
+            if self.use_param_offload:
+                offload_fsdp_submodule(submodule)
+
+            torch.cuda.empty_cache()
+
+        return lora_weights
+
+    def _sync_weight_to_vllm(self):
+        if self.use_param_offload and not self.is_lora:
+            load_fsdp_model(self.module)
+
+        if self.is_lora:
+            peft_config = self.module._fsdp_wrapped_module.peft_config.get("default", None)
+            actor_weights = self._collect_lora_weights()
+        else:
+            actor_weights = get_model_state_dict(self.module)
+            actor_weights = self._rename_weight_keys(actor_weights, self.module._fsdp_wrapped_module)
+
+        print_gpu_memory_usage("After gather model weights in sharding manager")
+
+        model = self.inference_engine.llm_engine.model_executor.driver_worker.worker.model_runner.model
+        if not self.is_lora:
+            model.load_weights(self._make_weight_iterator(actor_weights))
+        else:
+            lora_int_id = int(time.time_ns() % 0x7FFFFFFF)
+            lora_reqest = TensorLoRARequest(
+                lora_name=f"{lora_int_id}",
+                lora_int_id=lora_int_id,
+                lora_path="simon_lora_path",
+                peft_config=asdict(peft_config),
+                lora_tensors=actor_weights,
+            )
+            self.inference_engine.llm_engine.add_lora(lora_reqest)
+            print_gpu_memory_usage("After load LoRA weights in sharding manager")
+
+        del actor_weights
+        if self.use_param_offload and not self.is_lora:
+            offload_fsdp_model(self.module)
+
+        torch.cuda.empty_cache()
+        print_gpu_memory_usage("After sync model weights in sharding manager")
+
+    def load_vllm_and_sync_weights(self):
+        """Load vllm engine and sync model weights to vllm model."""
+        # NOTE: Basically, we only need `torch.cuda.empty_cache()` before vllm wake_up and
+        # after vllm sleep, since vllm has its own caching memory allocator CuMemAllocator.
+        # Out of vllm scope, we should avoid empty cache to let pytorch using caching memory
+        # to speed up memory allocations.
+        #
+        # pytorch: https://pytorch.org/docs/stable/notes/cuda.html#memory-management
+        # vllm: https://github.com/vllm-project/vllm/blob/v0.7.3/vllm/device_allocator/cumem.py#L103
+        torch.cuda.empty_cache()
+        assert self.loaded is False, "vllm engine has already been loaded"
+        self.loaded = True
+
+        print_gpu_memory_usage("Before vllm wake up in sharding manager")
+        if "tags" in inspect.signature(self.inference_engine.wake_up).parameters:
+            self.inference_engine.wake_up(tags=["weights"])
+        else:
+            self.inference_engine.wake_up()
+
+        self._sync_weight_to_vllm()
+
+        if "tags" in inspect.signature(self.inference_engine.wake_up).parameters:
+            self.inference_engine.wake_up(tags=["kv_cache"])
+
+        print_gpu_memory_usage("After vllm wake up in sharding manager")
+        # important: need to manually set the random states of each tp to be identical.
+        if self.device_mesh is not None:
+            self.torch_random_states = torch.cuda.get_rng_state()
+            torch.cuda.set_rng_state(self.gen_random_states)
+
+    def offload_vllm(self):
+        """Offload vllm engine."""
+        assert self.loaded is True, "vllm engine has not been loaded"
+        self.loaded = False
+
+        print_gpu_memory_usage("Before vllm offload in sharding manager")
+        free_bytes_before_sleep = torch.cuda.mem_get_info()[0]
+        self.inference_engine.sleep(level=1)
+        free_bytes_after_sleep = torch.cuda.mem_get_info()[0]
+        self.freed_bytes = free_bytes_after_sleep - free_bytes_before_sleep
+        print_gpu_memory_usage("After vllm offload in sharding manager")
+
+        self.module.train()
+        torch.cuda.empty_cache()  # add empty cache after each compute
+
+        # restore random states
+        if self.device_mesh is not None:
+            self.gen_random_states = torch.cuda.get_rng_state()
+            torch.cuda.set_rng_state(self.torch_random_states)
+
+    def preprocess_data(self, data: DataProto) -> DataProto:
+        """All gather across tp group to make each rank has identical input."""
+        all_gather_data_proto(data, size=self.tp_size, group=self.tp_group)
+        return data
+
+    def postprocess_data(self, data: DataProto) -> DataProto:
+        """Get chunk data of this tp rank since we do all gather in preprocess."""
+        if self.tp_size > 1:
+            data = data.chunk(chunks=self.tp_size)[self.tp_rank]
+
+        return data