Add files using upload-large-folder tool

.gitattributes

@@ -397,3 +397,7 @@ saves/qwen7B_it_fromit_326_think_sudoku_sequence_multitask/global_step_200/qwen2
 saves/qwen7B_it_fromit_think_cube3_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf/tokenizer.json filter=lfs diff=lfs merge=lfs -text
 saves/qwen7B_it_fromit_think_frozenlake_sequence_multitask/global_step_200/qwen2.5_7B_actor_hf/tokenizer.json filter=lfs diff=lfs merge=lfs -text
 saves/qwen7B_it_fromit_think_sokobanbox2_sequence_multitask/global_step_100/qwen2.5_7B_actor_hf/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+wandb/latest-run/run-1fkf5bo1.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/offline-run-20251216_100052-vp4li00f/run-vp4li00f.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/offline-run-20251216_142423-iypt06ne/run-iypt06ne.wandb filter=lfs diff=lfs merge=lfs -text
+wandb/offline-run-20251216_185932-u0k07wxi/run-u0k07wxi.wandb filter=lfs diff=lfs merge=lfs -text

verl/verl.egg-info/PKG-INFO

@@ -0,0 +1,327 @@
+Metadata-Version: 2.4
+Name: verl
+Version: 0.5.0.dev0
+Summary: verl: Volcano Engine Reinforcement Learning for LLM
+Home-page: https://github.com/volcengine/verl
+Author: Bytedance - Seed - MLSys
+Author-email: zhangchi.usc1992@bytedance.com, gmsheng@connect.hku.hk
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: accelerate
+Requires-Dist: codetiming
+Requires-Dist: datasets
+Requires-Dist: dill
+Requires-Dist: hydra-core
+Requires-Dist: numpy<2.0.0
+Requires-Dist: pandas
+Requires-Dist: peft
+Requires-Dist: pyarrow>=19.0.0
+Requires-Dist: pybind11
+Requires-Dist: pylatexenc
+Requires-Dist: ray[default]>=2.41.0
+Requires-Dist: torchdata
+Requires-Dist: tensordict!=0.9.0,<=0.10.0,>=0.8.0
+Requires-Dist: transformers
+Requires-Dist: wandb
+Requires-Dist: packaging>=20.0
+Requires-Dist: tensorboard
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pre-commit; extra == "test"
+Requires-Dist: py-spy; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Provides-Extra: prime
+Requires-Dist: pyext; extra == "prime"
+Provides-Extra: geo
+Requires-Dist: mathruler; extra == "geo"
+Requires-Dist: torchvision; extra == "geo"
+Requires-Dist: qwen_vl_utils; extra == "geo"
+Provides-Extra: gpu
+Requires-Dist: liger-kernel; extra == "gpu"
+Requires-Dist: flash-attn; extra == "gpu"
+Provides-Extra: math
+Requires-Dist: math-verify; extra == "math"
+Provides-Extra: vllm
+Requires-Dist: tensordict!=0.9.0,<=0.10.0,>=0.8.0; extra == "vllm"
+Requires-Dist: vllm<=0.9.1,>=0.7.3; extra == "vllm"
+Provides-Extra: sglang
+Requires-Dist: tensordict!=0.9.0,<=0.10.0,>=0.8.0; extra == "sglang"
+Requires-Dist: sglang[openai,srt]==0.5.2; extra == "sglang"
+Requires-Dist: torch==2.8.0; extra == "sglang"
+Provides-Extra: trl
+Requires-Dist: trl<=0.9.6; extra == "trl"
+Provides-Extra: mcore
+Requires-Dist: mbridge; extra == "mcore"
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+
+<div align="center">
+ 👋 Hi, everyone! 
+    verl is a RL training library initiated by <b>ByteDance Seed team</b> and maintained by the verl community.
+    <br>
+    <br>
+</div>
+
+<div align="center">
+
+<a href="https://deepwiki.com/volcengine/verl"><img src="https://devin.ai/assets/deepwiki-badge.png" alt="Ask DeepWiki.com" style="height:20px;"></a>
+[![GitHub Repo stars](https://img.shields.io/github/stars/volcengine/verl)](https://github.com/volcengine/verl/stargazers)
+[![Twitter](https://img.shields.io/twitter/follow/verl_project)](https://twitter.com/verl_project)
+<a href="https://join.slack.com/t/verl-project/shared_invite/zt-3c6mc2khw-v0lo6NfDPuFP6OnkrZwfqw"><img src="https://img.shields.io/badge/Slack-verl-blueviolet?logo=slack&amp"></a>
+<a href="https://arxiv.org/pdf/2409.19256"><img src="https://img.shields.io/static/v1?label=EuroSys&message=Paper&color=red"></a>
+[![Documentation](https://img.shields.io/badge/documentation-blue)](https://verl.readthedocs.io/en/latest/)
+<a href="https://raw.githubusercontent.com/eric-haibin-lin/verl-community/refs/heads/main/WeChat.JPG"><img src="https://img.shields.io/badge/微信-green?logo=wechat&amp"></a>
+
+</div>
+
+![seed logo](https://github.com/user-attachments/assets/c42e675e-497c-4508-8bb9-093ad4d1f216)
+
+<h1 style="text-align: center;">verl: Volcano Engine Reinforcement Learning for LLMs</h1>
+
+verl is a flexible, efficient and production-ready RL training library for large language models (LLMs).
+
+verl is the open-source version of **[HybridFlow: A Flexible and Efficient RLHF Framework](https://arxiv.org/abs/2409.19256v2)** paper.
+
+verl is flexible and easy to use with:
+
+- **Easy extension of diverse RL algorithms**: The hybrid-controller programming model enables flexible representation and efficient execution of complex post-training dataflows. Build RL dataflows such as GRPO, PPO in a few lines of code.
+
+- **Seamless integration of existing LLM infra with modular APIs**: Decouples computation and data dependencies, enabling seamless integration with existing LLM frameworks, such as FSDP, Megatron-LM, vLLM, SGLang, etc
+
+- **Flexible device mapping**: Supports various placement of models onto different sets of GPUs for efficient resource utilization and scalability across different cluster sizes.
+
+- Ready integration with popular HuggingFace models
+
+verl is fast with:
+
+- **State-of-the-art throughput**: SOTA LLM training and inference engine integrations and SOTA RL throughput.
+
+- **Efficient actor model resharding with 3D-HybridEngine**: Eliminates memory redundancy and significantly reduces communication overhead during transitions between training and generation phases.
+
+</p>
+
+## News
+- [2025/08] verl is presented in the [PyTorch Expert Exchange Webinar](https://www.youtube.com/watch?v=Vd79NmmqY3Q&t=2s). [Slides](https://github.com/eric-haibin-lin/verl-community/blob/main/slides/verl_talk_pytorch_2025_08.pdf) available.
+- [2025/07] The [ReTool](https://arxiv.org/pdf/2504.11536) recipe is fully open sourced. [Blog](https://www.notion.so/verl-reTool-recipe-Using-multi-round-conversations-and-code-sandboxing-to-improve-the-math-of-large-23a8b5b7feba80b386b2e5b5e3c1cde0)
+- [2025/07] The first verl meetup will be held at ICML Vancouver on July 16th! Please [join us](https://lu.ma/0ek2nyao) if you are at ICML! (onsite only)
+- [2025/06] verl with Megatron backend enables large MoE models such as [DeepSeek-671B and Qwen3-235B](https://verl.readthedocs.io/en/latest/perf/dpsk.html).
+- [2025/03] [DAPO](https://dapo-sia.github.io/) is the open-sourced SOTA RL algorithm that achieves 50 points on AIME 2024 based on the Qwen2.5-32B pre-trained model, surpassing the previous SOTA achieved by DeepSeek's GRPO (DeepSeek-R1-Zero-Qwen-32B). DAPO's training is fully powered by verl and the reproduction code is available in `recipe/dapo` now.
+<details><summary> more... </summary>
+<ul>
+  <li>[2025/04] [Seed-Thinking-v1.5](https://github.com/ByteDance-Seed/Seed-Thinking-v1.5/blob/main/seed-thinking-v1.5.pdf) tech report is released! Trained with verl, Seed-Thinking-v1.5 achieves 86.7 on AIME 2024, 55.0 on Codeforces and 77.3 on GPQA, demonstrating excellent reasoning abilities in STEM and coding. Beyond reasoning tasks, the method demonstrates notable generalization across diverse domains.</li>
+  <li>[2025/07] verl keynote at [AWS AI Hours Singapore](https://pages.awscloud.com/aws-ai-hours-sg.html#agenda) on 7/8, verl & verl-agent project updates at [Agent for SWE meetup](https://lu.ma/e498qhsi) by LF AI & Data Singapore on 7/11.</li>
+  <li>[2025/06] verl team will provide latest project updates at [PyTorch Day China](https://www.lfasiallc.com/pytorch-day-china/) on June 7th. Meet our dev team in Beijing!</li>
+  <li> [2025/04] [VAPO](https://arxiv.org/pdf/2504.05118) (value-based augmented PPO) paper covers our latest RL method for reasoning models. Trained from Qwen-32B-base model, VAPO achieves 60.4 on AIME 2024, outperforming DAPO-32B.</li>
+  <li>[2025/05] [PF-PPO](https://arxiv.org/abs/2409.06957), accepted to ICML 2025, is now supported in verl! PF-PPO enhances policy learning efficiency and robustness by filtering potentially noisy reward signals and reusing high-quality experiences via a replay buffer.</li>
+  <li>[2025/04] We will give a tutorial about latest post-training techniques and programming guide for verl at [ICLR 2025 Expo](https://iclr.cc/virtual/2025/calendar?filter_events=Expo+Talk+Panel&filter_rooms=), [SCI-FM workshop](https://open-foundation-model.github.io/) and [LMSys afterparty](https://lu.ma/d23nyynm). Talk materials available [here](https://github.com/eric-haibin-lin/verl-community/tree/main/iclr25). </li>
+  <li>[2025/03] verl v0.3.0.post1 is released! See [release note](https://github.com/volcengine/verl/releases/) for details. It achieves [~1.4x speedup](https://tongyx361.github.io/blogs/posts/verl-intro/#/verl-flexible-and-efficient-rl-for-llms) compared to prev versions.</li>
+  <li>[2025/05] verl will be presented at [A2M Shanghai](https://a2m.msup.com.cn/home/?aid=4488&city=shanghai) on 5/16 - 5/17.</li>
+  <li>[2025/05] verl will be presented at [GOSIM x PyTorch Day 2025](https://paris2025.gosim.org/). See you in Paris! </li>
+  <li>[2025/03] We introduced the programming model of verl at the [vLLM Beijing Meetup](https://mp.weixin.qq.com/s/n77GibL2corAtQHtVEAzfg) and [verl intro and updates](https://github.com/eric-haibin-lin/verl-community/blob/main/slides/verl-lmsys-meetup.pdf) at the [SGLang-LMSYS Org Meetup](https://lu.ma/ntjrr7ig) in Sunnyvale mid-March.</li>
+  <li>[2025/03] We will present verl(HybridFlow) at EuroSys 2025. See you in Rotterdam!</li>
+  <li>[2025/02] verl v0.2.0.post2 is released!</li>
+  <li>[2025/02] We presented verl in the <a href="https://lu.ma/ji7atxux">Bytedance/NVIDIA/Anyscale Ray Meetup</a>. See you in San Jose!</li>
+  <li>[2025/01] [Doubao-1.5-pro](https://team.doubao.com/zh/special/doubao_1_5_pro) is released with SOTA-level performance on LLM & VLM. The RL scaling preview model is trained using verl, reaching OpenAI O1-level performance on math benchmarks (70.0 pass@1 on AIME).</li>
+  <li>[2024/12] verl is presented at Ray Forward 2024. Slides available <a href="https://github.com/eric-haibin-lin/verl-community/blob/main/slides/Ray_Forward_2024_%E5%B7%AB%E9%94%A1%E6%96%8C.pdf">here</a></li>
+  <li>[2024/12] The team presented <a href="https://neurips.cc/Expo/Conferences/2024/workshop/100677">Post-training LLMs: From Algorithms to Infrastructure</a> at NeurIPS 2024. <a href="https://github.com/eric-haibin-lin/verl-data/tree/neurips">Slides</a> and <a href="https://neurips.cc/Expo/Conferences/2024/workshop/100677">video</a> available.</li>
+  <li>[2024/10] verl is presented at Ray Summit. <a href="https://www.youtube.com/watch?v=MrhMcXkXvJU&list=PLzTswPQNepXntmT8jr9WaNfqQ60QwW7-U&index=37">Youtube video</a> available.</li>
+  <li>[2024/08] HybridFlow (verl) is accepted to EuroSys 2025.</li>
+</ul>   
+</details>
+
+## Key Features
+
+- **FSDP**, **FSDP2** and **Megatron-LM** for training.
+- **vLLM**, **SGLang** and **HF Transformers** for rollout generation.
+- Compatible with Hugging Face Transformers and Modelscope Hub: [Qwen-3](https://github.com/volcengine/verl/blob/main/examples/grpo_trainer/run_qwen3-8b.sh), Qwen-2.5, Llama3.1, Gemma2, DeepSeek-LLM, etc
+- Supervised fine-tuning.
+- Reinforcement learning with [PPO](examples/ppo_trainer/), [GRPO](examples/grpo_trainer/), [GSPO](recipe/gspo/), [ReMax](examples/remax_trainer/), [REINFORCE++](https://verl.readthedocs.io/en/latest/examples/config.html#algorithm), [RLOO](examples/rloo_trainer/), [PRIME](recipe/prime/), [DAPO](recipe/dapo/), [DrGRPO](recipe/drgrpo), [KL_Cov & Clip_Cov](recipe/entropy) etc.
+  - Support model-based reward and function-based reward (verifiable reward) for math, [coding](https://github.com/volcengine/verl/tree/main/recipe/dapo), etc
+  - Support vision-language models (VLMs) and [multi-modal RL](examples/grpo_trainer/run_qwen2_5_vl-7b.sh) with Qwen2.5-vl, Kimi-VL
+  - [Multi-turn with tool calling](https://github.com/volcengine/verl/tree/main/examples/sglang_multiturn)
+- LLM alignment recipes such as [Self-play preference optimization (SPPO)](https://github.com/volcengine/verl/tree/main/recipe/sppo)
+- Flash attention 2, [sequence packing](examples/ppo_trainer/run_qwen2-7b_seq_balance.sh), [sequence parallelism](examples/ppo_trainer/run_deepseek7b_llm_sp2.sh) support via DeepSpeed Ulysses, [LoRA](examples/sft/gsm8k/run_qwen_05_peft.sh), [Liger-kernel](examples/sft/gsm8k/run_qwen_05_sp2_liger.sh).
+- Scales up to 671B models and hundreds of GPUs with [expert parallelism](https://github.com/volcengine/verl/pull/1467)
+- Multi-gpu [LoRA RL](https://verl.readthedocs.io/en/latest/advance/ppo_lora.html) support to save memory.
+- Experiment tracking with wandb, swanlab, mlflow and tensorboard.
+
+## Upcoming Features and Changes
+
+- Q3 Roadmap https://github.com/volcengine/verl/issues/2388
+- DeepSeek 671b optimizations with Megatron https://github.com/volcengine/verl/issues/1033
+- Multi-turn rollout and tools using optimizations https://github.com/volcengine/verl/issues/1882
+- [Agent integration](https://github.com/volcengine/verl/tree/main/verl/experimental/agent_loop)
+- Async and off-policy architecture https://github.com/volcengine/verl/pull/2231
+- List of breaking changes since v0.4 https://github.com/volcengine/verl/discussions/2270
+
+## Getting Started
+
+<a href="https://verl.readthedocs.io/en/latest/index.html"><b>Documentation</b></a>
+
+**Quickstart:**
+
+- [Installation](https://verl.readthedocs.io/en/latest/start/install.html)
+- [Quickstart](https://verl.readthedocs.io/en/latest/start/quickstart.html)
+- [Programming Guide](https://verl.readthedocs.io/en/latest/hybrid_flow.html) & [Tech Talk](https://hcqnc.xetlk.com/sl/3vACOK) (in Chinese)
+- [PPO in verl](https://verl.readthedocs.io/en/latest/algo/ppo.html)
+- [GRPO in verl](https://verl.readthedocs.io/en/latest/algo/grpo.html)
+
+**Running a PPO example step-by-step:**
+
+- [Prepare Data for Post-Training](https://verl.readthedocs.io/en/latest/preparation/prepare_data.html)
+- [Implement Reward Function for Dataset](https://verl.readthedocs.io/en/latest/preparation/reward_function.html)
+- [PPO Example Architecture](https://verl.readthedocs.io/en/latest/examples/ppo_code_architecture.html)
+- [Config Explanation](https://verl.readthedocs.io/en/latest/examples/config.html)
+
+**Reproducible algorithm baselines:**
+
+- [RL performance on coding, math](https://verl.readthedocs.io/en/latest/algo/baseline.html)
+
+**For code explanation and advance usage (extension):**
+
+- PPO Trainer and Workers
+  - [PPO Ray Trainer](https://verl.readthedocs.io/en/latest/workers/ray_trainer.html)
+  - [PyTorch FSDP Backend](https://verl.readthedocs.io/en/latest/workers/fsdp_workers.html)
+  - [Megatron-LM Backend](https://verl.readthedocs.io/en/latest/index.html)
+
+- Advanced Usage and Extension
+  - [Add Models with the FSDP Backend](https://verl.readthedocs.io/en/latest/advance/fsdp_extension.html)
+  - [Add Models with the Megatron-LM Backend](https://verl.readthedocs.io/en/latest/advance/megatron_extension.html)
+  - [Multi-turn Rollout Support](https://verl.readthedocs.io/en/latest/sglang_multiturn/multiturn.html)
+  - [Search Tool Integration](https://verl.readthedocs.io/en/latest/sglang_multiturn/search_tool_example.html)
+  - [Sandbox Fusion Integration](https://verl.readthedocs.io/en/latest/examples/sandbox_fusion_example.html)
+  - [Deployment using Separate GPU Resources](https://github.com/volcengine/verl/tree/main/examples/split_placement)
+  - [Extend to Other RL(HF) algorithms](https://verl.readthedocs.io/en/latest/advance/dpo_extension.html)
+  - [Ray API design tutorial](https://verl.readthedocs.io/en/latest/advance/placement.html)
+
+**Blogs from the community**
+
+- [When Reasoning Models Break Tokenization: The Hidden Complexity of Multiturn Training](https://github.com/zhaochenyang20/Awesome-ML-SYS-Tutorial/blob/main/rlhf/verl/multi-turn/fast_tokenization/multiturn_tokenization_and_masking.md)
+- [verl deployment on AWS SageMaker](https://medium.com/@kaige.yang0110/run-verl-on-sagemaker-using-4x8-l40s-gpus-8e6d5c3c61d3)
+- [verl x SGLang Multi-turn Code Walkthrough](https://github.com/zhaochenyang20/Awesome-ML-SYS-Tutorial/blob/main/rlhf/verl/multi-turn/code-walk-through/readme_EN.md)
+- [Optimizing SGLang Memory Usage in verl](https://hebiao064.github.io/rl-memory-management)
+- [SGLang, verl, OpenBMB and Tsinghua University: Pioneering End-to-End Multi-Turn RLHF](https://github.com/zhaochenyang20/Awesome-ML-SYS-Tutorial/blob/main/rlhf/verl/multi-turn/verl-multiturn-rollout-Release.md)
+- [Reinforcement Learning from Human Feedback on AMD GPUs with verl and ROCm Integration](https://rocm.blogs.amd.com/artificial-intelligence/verl-large-scale/README.html)
+- [veMLP x verl ：玩转强化学习训练](https://mp.weixin.qq.com/s/7nbqxk4knMGd-hQE9ls2tA)
+- [使用 verl 进行 GRPO 分布式强化学习训练最佳实践](https://www.volcengine.com/docs/6459/1463942)
+- [HybridFlow verl 原文浅析](https://github.com/zhaochenyang20/Awesome-ML-SYS-Tutorial/blob/main/rlhf/verl/readme.md)
+- [最高提升 20 倍吞吐量！豆包大模型团队发布全新 RLHF 框架，现已开源！](https://team.doubao.com/en/blog/%E6%9C%80%E9%AB%98%E6%8F%90%E5%8D%8720%E5%80%8D%E5%90%9E%E5%90%90%E9%87%8F-%E8%B1%86%E5%8C%85%E5%A4%A7%E6%A8%A1%E5%9E%8B%E5%9B%A2%E9%98%9F%E5%8F%91%E5%B8%83%E5%85%A8%E6%96%B0-rlhf-%E6%A1%86%E6%9E%B6-%E7%8E%B0%E5%B7%B2%E5%BC%80%E6%BA%90)
+
+## Performance Tuning Guide
+
+The performance is essential for on-policy RL algorithm. We have written a detailed [performance tuning guide](https://verl.readthedocs.io/en/latest/perf/perf_tuning.html) to help you optimize performance.
+
+## Upgrade to vLLM >= v0.8.2
+
+verl now supports vLLM>=0.8.2 when using FSDP as the training backend. Please refer to [this document](https://github.com/volcengine/verl/blob/main/docs/README_vllm0.8.md) for the installation guide and more information. Please avoid vllm 0.7.x, which contains bugs that may lead to OOMs and unexpected errors.
+
+## Use Latest SGLang
+
+SGLang is fully supported with verl, and SGLang RL Group is working extensively on building unique features, including multi-turn agentic RL, VLM RLHF, server-based RL, and partial rollout. Please refer to [this document](https://verl.readthedocs.io/en/latest/workers/sglang_worker.html) for the installation guide and more information.
+
+## Upgrade to FSDP2
+
+verl is fully embracing FSDP2! FSDP2 is recommended by torch distributed team, providing better throughput and memory usage, and is composible with other features (e.g. torch.compile). To enable FSDP2, simply use verl main and set the following options:
+```
+actor_rollout_ref.ref.strategy=fsdp2
+actor_rollout_ref.actor.strategy=fsdp2
+critic.strategy=fsdp2 
+reward_model.strategy=fsdp2 
+```
+Furthermore, FSDP2 cpu offloading is compatible with gradient accumulation. You can turn it on to save memory with `actor_rollout_ref.actor.fsdp_config.offload_policy=True`. For more details, see https://github.com/volcengine/verl/pull/1026
+
+## AMD Support (ROCm Kernel)
+
+verl now supports FSDP as the training engine (Megatron support coming soon) and both integrates with vLLM and SGLang as inference engines. Please refer to [this document](https://github.com/volcengine/verl/blob/main/docs/amd_tutorial/amd_build_dockerfile_page.rst) for the installation guide and more information, and [this document](https://github.com/volcengine/verl/blob/main/docs/amd_tutorial/amd_vllm_page.rst) for the vLLM performance tuning for ROCm.
+
+
+## Citation and acknowledgement
+
+If you find the project helpful, please cite:
+
+- [HybridFlow: A Flexible and Efficient RLHF Framework](https://arxiv.org/abs/2409.19256v2)
+- [A Framework for Training Large Language Models for Code Generation via Proximal Policy Optimization](https://i.cs.hku.hk/~cwu/papers/gmsheng-NL2Code24.pdf)
+
+```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}
+}
+```
+
+verl is inspired by the design of Nemo-Aligner, Deepspeed-chat and OpenRLHF. The project is adopted and contributed by Bytedance, Anyscale, LMSys.org, [Alibaba Qwen team](https://github.com/QwenLM/), Shanghai AI Lab, Tsinghua University, UC Berkeley, UCLA, UIUC, University of Hong Kong, ke.com, [All Hands AI](https://www.all-hands.dev/), [ModelBest](http://modelbest.cn/), JD AI Lab, Microsoft Research, [StepFun](https://www.stepfun.com/), Amazon, LinkedIn, Meituan, [Camel-AI](https://www.camel-ai.org/), [OpenManus](https://github.com/OpenManus), Xiaomi, NVIDIA research, [Baichuan](https://www.baichuan-ai.com/home), [RedNote](https://www.xiaohongshu.com/), [SwissAI](https://www.swiss-ai.org/), [Moonshot AI (Kimi)](https://www.moonshot-ai.com/), Baidu, Snowflake, Skywork.ai, JetBrains, [IceSword Lab](https://www.iceswordlab.com), and many more.
+
+## Awesome work using verl
+
+- [TinyZero](https://github.com/Jiayi-Pan/TinyZero): a reproduction of **DeepSeek R1 Zero** recipe for reasoning tasks ![GitHub Repo stars](https://img.shields.io/github/stars/Jiayi-Pan/TinyZero)
+- [SkyThought](https://github.com/NovaSky-AI/SkyThought): RL training for Sky-T1-7B by NovaSky AI team. ![GitHub Repo stars](https://img.shields.io/github/stars/NovaSky-AI/SkyThought)
+- [simpleRL-reason](https://github.com/hkust-nlp/simpleRL-reason): SimpleRL-Zoo: Investigating and Taming Zero Reinforcement Learning for Open Base Models in the Wild ![GitHub Repo stars](https://img.shields.io/github/stars/hkust-nlp/simpleRL-reason)
+- [Easy-R1](https://github.com/hiyouga/EasyR1): **Multi-modal** RL training framework ![GitHub Repo stars](https://img.shields.io/github/stars/hiyouga/EasyR1)
+- [OpenManus-RL](https://github.com/OpenManus/OpenManus-RL): LLM Agents RL tunning framework for multiple agent environments. ![GitHub Repo stars](https://img.shields.io/github/stars/OpenManus/OpenManus-RL)
+- [rllm](https://github.com/agentica-project/rllm): async RL training with [verl-pipeline](https://github.com/agentica-project/verl-pipeline) ![GitHub Repo stars](https://img.shields.io/github/stars/agentica-project/rllm)
+- [RAGEN](https://github.com/ZihanWang314/ragen): a general-purpose reasoning **agent** training framework ![GitHub Repo stars](https://img.shields.io/github/stars/ZihanWang314/ragen)
+- [Search-R1](https://github.com/PeterGriffinJin/Search-R1): RL with reasoning and **searching (tool-call)** interleaved LLMs ![GitHub Repo stars](https://img.shields.io/github/stars/PeterGriffinJin/Search-R1)
+- [ReSearch](https://github.com/Agent-RL/ReSearch): Learning to **Re**ason with **Search** for LLMs via Reinforcement Learning ![GitHub Repo stars](https://img.shields.io/github/stars/Agent-RL/ReSearch)
+- [Skywork-OR1](https://github.com/SkyworkAI/Skywork-OR1): Skywork open reaonser series ![GitHub Repo stars](https://img.shields.io/github/stars/SkyworkAI/Skywork-OR1)
+- [ToRL](https://github.com/GAIR-NLP/ToRL): Scaling tool-integrated RL ![GitHub Repo stars](https://img.shields.io/github/stars/GAIR-NLP/ToRL)
+- [Absolute Zero Reasoner](https://github.com/LeapLabTHU/Absolute-Zero-Reasoner): [A no human curated data self-play framework for reasoning](https://arxiv.org/abs/2505.03335) ![GitHub Repo stars](https://img.shields.io/github/stars/LeapLabTHU/Absolute-Zero-Reasoner)
+- [verl-agent](https://github.com/langfengQ/verl-agent): A scalable training framework for **long-horizon LLM/VLM agents**, along with a new algorithm **GiGPO** ![GitHub Repo stars](https://img.shields.io/github/stars/langfengQ/verl-agent)
+- [RL-Factory](https://github.com/Simple-Efficient/RL-Factory): An easy and efficient RL post-training framework for Agentic Learning ![GitHub Repo stars](https://img.shields.io/github/stars/Simple-Efficient/RL-Factory)
+- [ReTool](https://retool-rl.github.io/): ReTool: reinforcement learning for strategic tool use in LLMs. Code release is in progress...
+- [verl-tool](https://github.com/TIGER-AI-Lab/verl-tool): An unified and easy-to-extend tool-agent training framework based on verl![GitHub Repo stars](https://img.shields.io/github/stars/TIGER-AI-Lab/verl-tool)
+- [PRIME](https://github.com/PRIME-RL/PRIME): Process reinforcement through implicit rewards ![GitHub Repo stars](https://img.shields.io/github/stars/PRIME-RL/PRIME)
+- [MemAgent](https://github.com/BytedTsinghua-SIA/MemAgent): MemAgent: Reshaping Long-Context LLM with Multi-Conv RL based Memory Agent ![GitHub Repo stars](https://img.shields.io/github/stars/BytedTsinghua-SIA/MemAgent)
+- [POLARIS](https://github.com/ChenxinAn-fdu/POLARIS): A Post-training recipe for scaling RL on Advanced Reasoning models ![GitHub Repo stars](https://img.shields.io/github/stars/ChenxinAn-fdu/POLARIS)
+- [GUI-R1](https://github.com/ritzz-ai/GUI-R1): **GUI-R1**: A Generalist R1-style Vision-Language Action Model For **GUI Agents** ![GitHub Repo stars](https://img.shields.io/github/stars/ritzz-ai/GUI-R1)
+- [DeepRetrieval](https://github.com/pat-jj/DeepRetrieval): RL Training of **Search Agent** with **Search/Retrieval Outcome** ![GitHub Repo stars](https://img.shields.io/github/stars/pat-jj/DeepRetrieval)
+- [Code-R1](https://github.com/ganler/code-r1): Reproducing R1 for **Code** with Reliable Rewards ![GitHub Repo stars](https://img.shields.io/github/stars/ganler/code-r1)
+- [DeepResearcher](https://github.com/GAIR-NLP/DeepResearcher): Scaling deep research via reinforcement learning in real-world environments ![GitHub Repo stars](https://img.shields.io/github/stars/GAIR-NLP/DeepResearcher)
+- [VAGEN](https://github.com/RAGEN-AI/VAGEN): Training VLM agents with multi-turn reinforcement learning ![GitHub Repo stars](https://img.shields.io/github/stars/RAGEN-AI/VAGEN)
+- [RM-R1](https://arxiv.org/abs/2505.02387): RL training of reasoning reward models ![GitHub Repo stars](https://img.shields.io/github/stars/RM-R1-UIUC/RM-R1)
+- [LUFFY](https://arxiv.org/pdf/2504.14945): Learning to Reason under Off-Policy Guidance![GitHub Repo stars](https://img.shields.io/github/stars/ElliottYan/LUFFY)
+- [DeepMath](https://github.com/zwhe99/DeepMath): DeepMath-103K data and series models for math reasoning![GitHub Repo stars](https://img.shields.io/github/stars/zwhe99/DeepMath)
+- [PACS](https://github.com/ritzz-ai/PACS): Implicit Actor Critic Coupling via a Supervised Learning Framework for RLVR ![GitHub Repo stars](https://img.shields.io/github/stars/ritzz-ai/PACS)
+- [Entropy Mechanism of RL](https://github.com/PRIME-RL/Entropy-Mechanism-of-RL): The Entropy Mechanism of Reinforcement Learning for Large Language Model Reasoning![GitHub Repo stars](https://img.shields.io/github/stars/PRIME-RL/Entropy-Mechanism-of-RL)
+- [LLaSA-TTS-GRPO](https://github.com/channel-io/ch-tts-llasa-rl-grpo): TTS fine-tuning with GRPO optimization based on LLASA models ![GitHub Repo stars](https://img.shields.io/github/stars/channel-io/ch-tts-llasa-rl-grpo)
+- [PF-PPO](https://arxiv.org/abs/2409.06957): Policy Filtration for PPO based on the reliability of reward signals for more efficient and robust RLHF.
+- [RACRO](https://github.com/gyhdog99/RACRO2): Build multi-modal reasoning models via decoupling it into query-conditioned captioning and text-only reasoning ![GitHub Repo stars](https://img.shields.io/github/stars/gyhdog99/RACRO2)
+- [Agent Lightning](https://github.com/microsoft/agent-lightning): A flexible and extensible framework that enables seamless agent optimization for any existing agent framework. ![GitHub Repo stars](https://img.shields.io/github/stars/microsoft/agent-lightning)
+- [VTool-R1](https://github.com/VTOOL-R1/vtool-r1): VLMs Learn to Think with Images via Reinforcement Learning on Multimodal Tool Use. ![GitHub Repo stars](https://img.shields.io/github/stars/VTOOL-R1/vtool-r1)
+- [Kimina-Prover-RL](https://github.com/project-numina/kimina-prover-rl/tree/main/recipe/kimina_prover_rl): Training pipeline for formal theorem proving, based on a paradigm inspired by DeepSeek-R1.
+- [RL-PLUS](https://github.com/YihongDong/RL-PLUS): Countering Capability Boundary Collapse of LLMs in Reinforcement Learning with Hybrid-policy Optimization.
+- [rStar2-Agent](https://github.com/microsoft/rStar): Using reinforcement learning with multi-step tool-calling for math tasks, rStar2-Agent-14B reaches frontier-level math reasoning in just 510 RL training steps ![GitHub Repo stars](https://img.shields.io/github/stars/microsoft/rStar)
+- [Vision-SR1](https://github.com/zli12321/Vision-SR1): Self-Rewarding Vision-Language Model via Reasoning Decomposition ![GitHub Repo stars](https://img.shields.io/github/stars/zli12321/Vision-SR1)
+- [SimpleVLA-RL](https://github.com/PRIME-RL/SimpleVLA-RL): SimpleVLA-RL: A Simple yet Effective Vision-Language Action Model for Reinforcement Learning ![GitHub Repo stars](https://img.shields.io/github/stars/PRIME-RL/SimpleVLA-RL)
+- [Table-R1](https://github.com/Table-R1/Table-R1): Table-R1: Inference-Time Scaling for Table Reasoning ![GitHub Repo stars](https://img.shields.io/github/stars/Table-R1/Table-R1)
+
+and many more awesome work listed in [recipe](recipe/README.md).
+
+## Contribution Guide
+
+See [contributions guide](CONTRIBUTING.md)
+
+## About [ByteDance Seed Team](https://team.doubao.com/)
+
+Founded in 2023, ByteDance Seed Team is dedicated to crafting the industry's most advanced AI foundation models. The team aspires to become a world-class research team and make significant contributions to the advancement of science and society. You can get to know Bytedance Seed better through the following channels👇
+<div>
+  <a href="https://team.doubao.com/">
+    <img src="https://img.shields.io/badge/Website-%231e37ff?style=for-the-badge&logo=bytedance&logoColor=white"></a>
+  <a href="https://github.com/user-attachments/assets/469535a8-42f2-4797-acdf-4f7a1d4a0c3e">
+    <img src="https://img.shields.io/badge/WeChat-07C160?style=for-the-badge&logo=wechat&logoColor=white"></a>
+ <a href="https://www.xiaohongshu.com/user/profile/668e7e15000000000303157d?xsec_token=ABl2-aqekpytY6A8TuxjrwnZskU-6BsMRE_ufQQaSAvjc%3D&xsec_source=pc_search">
+    <img src="https://img.shields.io/badge/Xiaohongshu-%23FF2442?style=for-the-badge&logo=xiaohongshu&logoColor=white"></a>
+  <a href="https://www.zhihu.com/org/dou-bao-da-mo-xing-tuan-dui/">
+    <img src="https://img.shields.io/badge/zhihu-%230084FF?style=for-the-badge&logo=zhihu&logoColor=white"></a>
+
+</div>
+---
+
+We are HIRING! Send us an [email](mailto:the.verl.project@gmail.com) if you are interested in internship/FTE opportunities in RL for agents.

verl/verl.egg-info/SOURCES.txt

@@ -0,0 +1,747 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+./scripts/__init__.py
+./scripts/converter_hf_to_mcore.py
+./scripts/diagnose.py
+./scripts/init_random_model.py
+./scripts/legacy_model_merger.py
+./scripts/print_cfg.py
+./scripts/rollout_viewer.py
+./tests/__init__.py
+./tests/test_base_config_on_cpu.py
+./tests/test_protocol_on_cpu.py
+./tests/test_protocol_v2_on_cpu.py
+./tests/interactions/__init__.py
+./tests/interactions/test_gsm8k_interaction.py
+./tests/interactions/test_interaction_registry.py
+./tests/single_controller/__init__.py
+./tests/single_controller/test_auto_padding_on_cpu.py
+./tests/single_controller/test_colocated_workers.py
+./tests/single_controller/test_colocated_workers_fused.py
+./tests/single_controller/test_data_transfer.py
+./tests/single_controller/test_decorator_on_cpu.py
+./tests/single_controller/test_device_mesh_register.py
+./tests/single_controller/test_driverfunc_to_worker.py
+./tests/single_controller/test_fused_workers_on_cpu.py
+./tests/single_controller/test_high_level_scheduling_api.py
+./tests/single_controller/test_nested_worker.py
+./tests/single_controller/test_ray_collectives.py
+./tests/single_controller/test_ray_local_envs_on_cpu.py
+./tests/single_controller/test_ray_utils_on_cpu.py
+./tests/single_controller/test_rvdz.py
+./tests/single_controller/test_worker_group_basics.py
+./tests/single_controller/test_worker_group_torch.py
+./tests/special_e2e/__init__.py
+./tests/special_e2e/check_custom_rwd_fn.py
+./tests/special_e2e/check_results.py
+./tests/special_e2e/envs/__init__.py
+./tests/special_e2e/envs/digit_completion/__init__.py
+./tests/special_e2e/envs/digit_completion/task.py
+./tests/special_e2e/envs/digit_completion/tokenizer.py
+./tests/trainer/__init__.py
+./tests/trainer/config/__init__.py
+./tests/trainer/config/test_algo_config_on_cpu.py
+./tests/trainer/config/test_legacy_config_on_cpu.py
+./tests/trainer/ppo/__init__.py
+./tests/trainer/ppo/test_core_algos_on_cpu.py
+./tests/trainer/ppo/test_metric_utils_on_cpu.py
+./verl/__init__.py
+./verl/base_config.py
+./verl/protocol.py
+./verl/py.typed
+./verl/experimental/__init__.py
+./verl/experimental/agent_loop/__init__.py
+./verl/experimental/agent_loop/agent_loop.py
+./verl/experimental/agent_loop/single_turn_agent_loop.py
+./verl/experimental/agent_loop/tool_agent_loop.py
+./verl/experimental/agent_loop/tool_parser.py
+./verl/experimental/dataset/__init__.py
+./verl/experimental/dataset/sampler.py
+./verl/experimental/dynamic_dataset/__init__.py
+./verl/experimental/dynamic_dataset/dynamicgen_dataset.py
+./verl/interactions/__init__.py
+./verl/interactions/base.py
+./verl/interactions/gsm8k_interaction.py
+./verl/interactions/weather_interaction.py
+./verl/interactions/utils/__init__.py
+./verl/interactions/utils/interaction_registry.py
+./verl/model_merger/__init__.py
+./verl/model_merger/__main__.py
+./verl/model_merger/base_model_merger.py
+./verl/model_merger/fsdp_model_merger.py
+./verl/model_merger/megatron_model_merger.py
+./verl/models/__init__.py
+./verl/models/registry.py
+./verl/models/weight_loader_registry.py
+./verl/models/llama/__init__.py
+./verl/models/llama/megatron/__init__.py
+./verl/models/llama/megatron/modeling_llama_megatron.py
+./verl/models/llama/megatron/checkpoint_utils/__init__.py
+./verl/models/llama/megatron/checkpoint_utils/llama_loader.py
+./verl/models/llama/megatron/checkpoint_utils/llama_loader_depracated.py
+./verl/models/llama/megatron/checkpoint_utils/llama_saver.py
+./verl/models/llama/megatron/layers/__init__.py
+./verl/models/llama/megatron/layers/parallel_attention.py
+./verl/models/llama/megatron/layers/parallel_decoder.py
+./verl/models/llama/megatron/layers/parallel_linear.py
+./verl/models/llama/megatron/layers/parallel_mlp.py
+./verl/models/llama/megatron/layers/parallel_rmsnorm.py
+./verl/models/mcore/__init__.py
+./verl/models/mcore/config_converter.py
+./verl/models/mcore/loader.py
+./verl/models/mcore/mbridge.py
+./verl/models/mcore/model_forward.py
+./verl/models/mcore/model_forward_fused.py
+./verl/models/mcore/model_initializer.py
+./verl/models/mcore/patch_v012.py
+./verl/models/mcore/registry.py
+./verl/models/mcore/saver.py
+./verl/models/mcore/util.py
+./verl/models/mcore/weight_converter.py
+./verl/models/mcore/qwen2_5_vl/__init__.py
+./verl/models/mcore/qwen2_5_vl/attention.py
+./verl/models/mcore/qwen2_5_vl/model.py
+./verl/models/mcore/qwen2_5_vl/rope_utils.py
+./verl/models/mcore/qwen2_5_vl/vision_config.py
+./verl/models/mcore/qwen2_5_vl/vision_model.py
+./verl/models/mcore/qwen2_5_vl/vision_transformer_block.py
+./verl/models/qwen2/__init__.py
+./verl/models/qwen2/megatron/__init__.py
+./verl/models/qwen2/megatron/modeling_qwen2_megatron.py
+./verl/models/qwen2/megatron/checkpoint_utils/__init__.py
+./verl/models/qwen2/megatron/checkpoint_utils/qwen2_loader.py
+./verl/models/qwen2/megatron/checkpoint_utils/qwen2_loader_depracated.py
+./verl/models/qwen2/megatron/checkpoint_utils/qwen2_saver.py
+./verl/models/qwen2/megatron/layers/__init__.py
+./verl/models/qwen2/megatron/layers/parallel_attention.py
+./verl/models/qwen2/megatron/layers/parallel_decoder.py
+./verl/models/qwen2/megatron/layers/parallel_linear.py
+./verl/models/qwen2/megatron/layers/parallel_mlp.py
+./verl/models/qwen2/megatron/layers/parallel_rmsnorm.py
+./verl/models/transformers/__init__.py
+./verl/models/transformers/apertus.py
+./verl/models/transformers/dense_common.py
+./verl/models/transformers/glm4v.py
+./verl/models/transformers/kimi_vl.py
+./verl/models/transformers/llama.py
+./verl/models/transformers/monkey_patch.py
+./verl/models/transformers/npu_patch.py
+./verl/models/transformers/qwen2.py
+./verl/models/transformers/qwen2_vl.py
+./verl/models/transformers/qwen3_vl.py
+./verl/single_controller/__init__.py
+./verl/single_controller/base/__init__.py
+./verl/single_controller/base/decorator.py
+./verl/single_controller/base/worker.py
+./verl/single_controller/base/worker_group.py
+./verl/single_controller/ray/__init__.py
+./verl/single_controller/ray/base.py
+./verl/third_party/__init__.py
+./verl/third_party/sglang/__init__.py
+./verl/third_party/sglang/parallel_state.py
+./verl/third_party/torch/__init__.py
+./verl/third_party/torch/distributed/__init__.py
+./verl/third_party/torch/distributed/_state_dict_utils.py
+./verl/third_party/torch/distributed/checkpoint/__init__.py
+./verl/third_party/torch/distributed/checkpoint/state_dict.py
+./verl/third_party/vllm/__init__.py
+./verl/tools/__init__.py
+./verl/tools/base_tool.py
+./verl/tools/geo3k_tool.py
+./verl/tools/gsm8k_tool.py
+./verl/tools/image_zoom_in_tool.py
+./verl/tools/mcp_base_tool.py
+./verl/tools/mcp_search_tool.py
+./verl/tools/sandbox_fusion_tools.py
+./verl/tools/schemas.py
+./verl/tools/search_tool.py
+./verl/tools/utils/__init__.py
+./verl/tools/utils/search_r1_like_utils.py
+./verl/tools/utils/tool_registry.py
+./verl/trainer/__init__.py
+./verl/trainer/constants_ppo.py
+./verl/trainer/fsdp_sft_trainer.py
+./verl/trainer/main_eval.py
+./verl/trainer/main_generation.py
+./verl/trainer/main_ppo.py
+./verl/trainer/sft_trainer.py
+./verl/trainer/config/__init__.py
+./verl/trainer/config/_generated_ppo_megatron_trainer.yaml
+./verl/trainer/config/_generated_ppo_trainer.yaml
+./verl/trainer/config/algorithm.py
+./verl/trainer/config/config.py
+./verl/trainer/config/evaluation.yaml
+./verl/trainer/config/generation.yaml
+./verl/trainer/config/ppo_megatron_trainer.yaml
+./verl/trainer/config/ppo_trainer.yaml
+./verl/trainer/config/sft_trainer.yaml
+./verl/trainer/config/sft_trainer_engine.yaml
+./verl/trainer/config/actor/actor.yaml
+./verl/trainer/config/actor/dp_actor.yaml
+./verl/trainer/config/actor/megatron_actor.yaml
+./verl/trainer/config/critic/critic.yaml
+./verl/trainer/config/critic/dp_critic.yaml
+./verl/trainer/config/critic/megatron_critic.yaml
+./verl/trainer/config/data/legacy_data.yaml
+./verl/trainer/config/engine/fsdp.yaml
+./verl/trainer/config/engine/megatron.yaml
+./verl/trainer/config/model/hf_model.yaml
+./verl/trainer/config/npu_profile/npu_profile.yaml
+./verl/trainer/config/optim/fsdp.yaml
+./verl/trainer/config/optim/megatron.yaml
+./verl/trainer/config/ref/dp_ref.yaml
+./verl/trainer/config/ref/megatron_ref.yaml
+./verl/trainer/config/ref/ref.yaml
+./verl/trainer/config/reward_model/dp_reward_model.yaml
+./verl/trainer/config/reward_model/megatron_reward_model.yaml
+./verl/trainer/config/reward_model/reward_model.yaml
+./verl/trainer/config/rollout/rollout.yaml
+./verl/trainer/ppo/__init__.py
+./verl/trainer/ppo/core_algos.py
+./verl/trainer/ppo/metric_utils.py
+./verl/trainer/ppo/ray_trainer.py
+./verl/trainer/ppo/reward.py
+./verl/trainer/ppo/utils.py
+./verl/utils/__init__.py
+./verl/utils/activation_offload.py
+./verl/utils/attention_utils.py
+./verl/utils/config.py
+./verl/utils/device.py
+./verl/utils/distributed.py
+./verl/utils/flops_counter.py
+./verl/utils/fs.py
+./verl/utils/fsdp_utils.py
+./verl/utils/groupwise.py
+./verl/utils/hdfs_io.py
+./verl/utils/import_utils.py
+./verl/utils/logging_utils.py
+./verl/utils/megatron_utils.py
+./verl/utils/memory_buffer.py
+./verl/utils/memory_utils.py
+./verl/utils/model.py
+./verl/utils/net_utils.py
+./verl/utils/npu_utils.py
+./verl/utils/py_functional.py
+./verl/utils/ray_utils.py
+./verl/utils/rollout_skip.py
+./verl/utils/rollout_trace.py
+./verl/utils/seqlen_balancing.py
+./verl/utils/tensordict_utils.py
+./verl/utils/tokenizer.py
+./verl/utils/torch_dtypes.py
+./verl/utils/torch_functional.py
+./verl/utils/tracking.py
+./verl/utils/transformers_compat.py
+./verl/utils/ulysses.py
+./verl/utils/checkpoint/__init__.py
+./verl/utils/checkpoint/checkpoint_handler.py
+./verl/utils/checkpoint/checkpoint_manager.py
+./verl/utils/checkpoint/fsdp_checkpoint_manager.py
+./verl/utils/checkpoint/megatron_checkpoint_manager.py
+./verl/utils/dataset/__init__.py
+./verl/utils/dataset/dataset_utils.py
+./verl/utils/dataset/multiturn_sft_dataset.py
+./verl/utils/dataset/rl_dataset.py
+./verl/utils/dataset/rm_dataset.py
+./verl/utils/dataset/sft_dataset.py
+./verl/utils/dataset/vision_utils.py
+./verl/utils/debug/__init__.py
+./verl/utils/debug/metrics.py
+./verl/utils/debug/performance.py
+./verl/utils/debug/trajectory_tracker.py
+./verl/utils/experimental/__init__.py
+./verl/utils/experimental/torch_functional.py
+./verl/utils/kernel/__init__.py
+./verl/utils/kernel/kernels.py
+./verl/utils/kernel/linear_cross_entropy.py
+./verl/utils/logger/__init__.py
+./verl/utils/logger/aggregate_logger.py
+./verl/utils/megatron/__init__.py
+./verl/utils/megatron/dist_checkpointing.py
+./verl/utils/megatron/memory.py
+./verl/utils/megatron/optimizer.py
+./verl/utils/megatron/pipeline_parallel.py
+./verl/utils/megatron/sequence_parallel.py
+./verl/utils/megatron/tensor_parallel.py
+./verl/utils/metric/__init__.py
+./verl/utils/metric/utils.py
+./verl/utils/profiler/__init__.py
+./verl/utils/profiler/config.py
+./verl/utils/profiler/empty_annotations.py
+./verl/utils/profiler/mstx_profile.py
+./verl/utils/profiler/nvtx_profile.py
+./verl/utils/profiler/performance.py
+./verl/utils/profiler/profile.py
+./verl/utils/rendezvous/__init__.py
+./verl/utils/rendezvous/ray_backend.py
+./verl/utils/reward_score/__init__.py
+./verl/utils/reward_score/geo3k.py
+./verl/utils/reward_score/gsm8k.py
+./verl/utils/reward_score/math_batch.py
+./verl/utils/reward_score/math_dapo.py
+./verl/utils/reward_score/math_reward.py
+./verl/utils/reward_score/math_verify.py
+./verl/utils/reward_score/search_r1_like_qa_em.py
+./verl/utils/reward_score/prime_code/__init__.py
+./verl/utils/reward_score/prime_code/testing_util.py
+./verl/utils/reward_score/prime_code/utils.py
+./verl/utils/reward_score/prime_math/__init__.py
+./verl/utils/reward_score/prime_math/grader.py
+./verl/utils/reward_score/prime_math/math_normalize.py
+./verl/utils/reward_score/sandbox_fusion/__init__.py
+./verl/utils/reward_score/sandbox_fusion/utils.py
+./verl/utils/vllm/__init__.py
+./verl/utils/vllm/patch.py
+./verl/utils/vllm/utils.py
+./verl/version/version
+./verl/workers/__init__.py
+./verl/workers/fsdp_workers.py
+./verl/workers/megatron_workers.py
+./verl/workers/actor/__init__.py
+./verl/workers/actor/base.py
+./verl/workers/actor/dp_actor.py
+./verl/workers/actor/megatron_actor.py
+./verl/workers/config/__init__.py
+./verl/workers/config/actor.py
+./verl/workers/config/critic.py
+./verl/workers/config/engine.py
+./verl/workers/config/model.py
+./verl/workers/config/optimizer.py
+./verl/workers/config/reward_model.py
+./verl/workers/config/rollout.py
+./verl/workers/critic/__init__.py
+./verl/workers/critic/base.py
+./verl/workers/critic/dp_critic.py
+./verl/workers/critic/megatron_critic.py
+./verl/workers/engine/__init__.py
+./verl/workers/engine/base.py
+./verl/workers/engine/utils.py
+./verl/workers/engine/fsdp/__init__.py
+./verl/workers/engine/fsdp/transformer_impl.py
+./verl/workers/engine/fsdp/utils.py
+./verl/workers/engine/megatron/__init__.py
+./verl/workers/engine/megatron/transformer_impl.py
+./verl/workers/engine/megatron/utils.py
+./verl/workers/engine/mindspeed/__init__.py
+./verl/workers/engine/mindspeed/transformer_impl.py
+./verl/workers/reward_manager/__init__.py
+./verl/workers/reward_manager/abstract.py
+./verl/workers/reward_manager/batch.py
+./verl/workers/reward_manager/dapo.py
+./verl/workers/reward_manager/naive.py
+./verl/workers/reward_manager/prime.py
+./verl/workers/reward_manager/registry.py
+./verl/workers/reward_model/__init__.py
+./verl/workers/reward_model/base.py
+./verl/workers/reward_model/megatron/__init__.py
+./verl/workers/reward_model/megatron/reward_model.py
+./verl/workers/roles/__init__.py
+./verl/workers/roles/actor.py
+./verl/workers/roles/critic.py
+./verl/workers/roles/hybrid_engine.py
+./verl/workers/roles/reward_model.py
+./verl/workers/roles/reward_model_engine/__init__.py
+./verl/workers/roles/reward_model_engine/base.py
+./verl/workers/roles/reward_model_engine/sglang_reward_model.py
+./verl/workers/roles/utils/__init__.py
+./verl/workers/roles/utils/losses.py
+./verl/workers/rollout/__init__.py
+./verl/workers/rollout/base.py
+./verl/workers/rollout/hf_rollout.py
+./verl/workers/rollout/replica.py
+./verl/workers/rollout/schemas.py
+./verl/workers/rollout/tokenizer.py
+./verl/workers/rollout/utils.py
+./verl/workers/rollout/naive/__init__.py
+./verl/workers/rollout/naive/naive_rollout.py
+./verl/workers/rollout/sglang_rollout/__init__.py
+./verl/workers/rollout/sglang_rollout/async_sglang_server.py
+./verl/workers/rollout/sglang_rollout/http_server_engine.py
+./verl/workers/rollout/sglang_rollout/sglang_rollout.py
+./verl/workers/rollout/sglang_rollout/utils.py
+./verl/workers/rollout/vllm_rollout/__init__.py
+./verl/workers/rollout/vllm_rollout/vllm_async_server.py
+./verl/workers/rollout/vllm_rollout/vllm_rollout_spmd.py
+./verl/workers/sharding_manager/__init__.py
+./verl/workers/sharding_manager/base.py
+./verl/workers/sharding_manager/fsdp_sglang.py
+./verl/workers/sharding_manager/fsdp_ulysses.py
+./verl/workers/sharding_manager/fsdp_vllm.py
+./verl/workers/sharding_manager/megatron_sglang.py
+./verl/workers/sharding_manager/megatron_vllm.py
+scripts/__init__.py
+scripts/converter_hf_to_mcore.py
+scripts/diagnose.py
+scripts/init_random_model.py
+scripts/legacy_model_merger.py
+scripts/print_cfg.py
+scripts/rollout_viewer.py
+tests/__init__.py
+tests/test_base_config_on_cpu.py
+tests/test_protocol_on_cpu.py
+tests/test_protocol_v2_on_cpu.py
+tests/interactions/__init__.py
+tests/interactions/test_gsm8k_interaction.py
+tests/interactions/test_interaction_registry.py
+tests/single_controller/__init__.py
+tests/single_controller/test_auto_padding_on_cpu.py
+tests/single_controller/test_colocated_workers.py
+tests/single_controller/test_colocated_workers_fused.py
+tests/single_controller/test_data_transfer.py
+tests/single_controller/test_decorator_on_cpu.py
+tests/single_controller/test_device_mesh_register.py
+tests/single_controller/test_driverfunc_to_worker.py
+tests/single_controller/test_fused_workers_on_cpu.py
+tests/single_controller/test_high_level_scheduling_api.py
+tests/single_controller/test_nested_worker.py
+tests/single_controller/test_ray_collectives.py
+tests/single_controller/test_ray_local_envs_on_cpu.py
+tests/single_controller/test_ray_utils_on_cpu.py
+tests/single_controller/test_rvdz.py
+tests/single_controller/test_worker_group_basics.py
+tests/single_controller/test_worker_group_torch.py
+tests/special_e2e/__init__.py
+tests/special_e2e/check_custom_rwd_fn.py
+tests/special_e2e/check_results.py
+tests/special_e2e/envs/__init__.py
+tests/special_e2e/envs/digit_completion/__init__.py
+tests/special_e2e/envs/digit_completion/task.py
+tests/special_e2e/envs/digit_completion/tokenizer.py
+tests/trainer/__init__.py
+tests/trainer/config/__init__.py
+tests/trainer/config/test_algo_config_on_cpu.py
+tests/trainer/config/test_legacy_config_on_cpu.py
+tests/trainer/ppo/__init__.py
+tests/trainer/ppo/test_core_algos_on_cpu.py
+tests/trainer/ppo/test_metric_utils_on_cpu.py
+verl/__init__.py
+verl/base_config.py
+verl/protocol.py
+verl/py.typed
+verl.egg-info/PKG-INFO
+verl.egg-info/SOURCES.txt
+verl.egg-info/dependency_links.txt
+verl.egg-info/requires.txt
+verl.egg-info/top_level.txt
+verl/experimental/__init__.py
+verl/experimental/agent_loop/__init__.py
+verl/experimental/agent_loop/agent_loop.py
+verl/experimental/agent_loop/single_turn_agent_loop.py
+verl/experimental/agent_loop/tool_agent_loop.py
+verl/experimental/agent_loop/tool_parser.py
+verl/experimental/dataset/__init__.py
+verl/experimental/dataset/sampler.py
+verl/experimental/dynamic_dataset/__init__.py
+verl/experimental/dynamic_dataset/dynamicgen_dataset.py
+verl/interactions/__init__.py
+verl/interactions/base.py
+verl/interactions/gsm8k_interaction.py
+verl/interactions/weather_interaction.py
+verl/interactions/utils/__init__.py
+verl/interactions/utils/interaction_registry.py
+verl/model_merger/__init__.py
+verl/model_merger/__main__.py
+verl/model_merger/base_model_merger.py
+verl/model_merger/fsdp_model_merger.py
+verl/model_merger/megatron_model_merger.py
+verl/models/__init__.py
+verl/models/registry.py
+verl/models/weight_loader_registry.py
+verl/models/llama/__init__.py
+verl/models/llama/megatron/__init__.py
+verl/models/llama/megatron/modeling_llama_megatron.py
+verl/models/llama/megatron/checkpoint_utils/__init__.py
+verl/models/llama/megatron/checkpoint_utils/llama_loader.py
+verl/models/llama/megatron/checkpoint_utils/llama_loader_depracated.py
+verl/models/llama/megatron/checkpoint_utils/llama_saver.py
+verl/models/llama/megatron/layers/__init__.py
+verl/models/llama/megatron/layers/parallel_attention.py
+verl/models/llama/megatron/layers/parallel_decoder.py
+verl/models/llama/megatron/layers/parallel_linear.py
+verl/models/llama/megatron/layers/parallel_mlp.py
+verl/models/llama/megatron/layers/parallel_rmsnorm.py
+verl/models/mcore/__init__.py
+verl/models/mcore/config_converter.py
+verl/models/mcore/loader.py
+verl/models/mcore/mbridge.py
+verl/models/mcore/model_forward.py
+verl/models/mcore/model_forward_fused.py
+verl/models/mcore/model_initializer.py
+verl/models/mcore/patch_v012.py
+verl/models/mcore/registry.py
+verl/models/mcore/saver.py
+verl/models/mcore/util.py
+verl/models/mcore/weight_converter.py
+verl/models/mcore/qwen2_5_vl/__init__.py
+verl/models/mcore/qwen2_5_vl/attention.py
+verl/models/mcore/qwen2_5_vl/model.py
+verl/models/mcore/qwen2_5_vl/rope_utils.py
+verl/models/mcore/qwen2_5_vl/vision_config.py
+verl/models/mcore/qwen2_5_vl/vision_model.py
+verl/models/mcore/qwen2_5_vl/vision_transformer_block.py
+verl/models/qwen2/__init__.py
+verl/models/qwen2/megatron/__init__.py
+verl/models/qwen2/megatron/modeling_qwen2_megatron.py
+verl/models/qwen2/megatron/checkpoint_utils/__init__.py
+verl/models/qwen2/megatron/checkpoint_utils/qwen2_loader.py
+verl/models/qwen2/megatron/checkpoint_utils/qwen2_loader_depracated.py
+verl/models/qwen2/megatron/checkpoint_utils/qwen2_saver.py
+verl/models/qwen2/megatron/layers/__init__.py
+verl/models/qwen2/megatron/layers/parallel_attention.py
+verl/models/qwen2/megatron/layers/parallel_decoder.py
+verl/models/qwen2/megatron/layers/parallel_linear.py
+verl/models/qwen2/megatron/layers/parallel_mlp.py
+verl/models/qwen2/megatron/layers/parallel_rmsnorm.py
+verl/models/transformers/__init__.py
+verl/models/transformers/apertus.py
+verl/models/transformers/dense_common.py
+verl/models/transformers/glm4v.py
+verl/models/transformers/kimi_vl.py
+verl/models/transformers/llama.py
+verl/models/transformers/monkey_patch.py
+verl/models/transformers/npu_patch.py
+verl/models/transformers/qwen2.py
+verl/models/transformers/qwen2_vl.py
+verl/models/transformers/qwen3_vl.py
+verl/single_controller/__init__.py
+verl/single_controller/base/__init__.py
+verl/single_controller/base/decorator.py
+verl/single_controller/base/worker.py
+verl/single_controller/base/worker_group.py
+verl/single_controller/ray/__init__.py
+verl/single_controller/ray/base.py
+verl/third_party/__init__.py
+verl/third_party/sglang/__init__.py
+verl/third_party/sglang/parallel_state.py
+verl/third_party/torch/__init__.py
+verl/third_party/torch/distributed/__init__.py
+verl/third_party/torch/distributed/_state_dict_utils.py
+verl/third_party/torch/distributed/checkpoint/__init__.py
+verl/third_party/torch/distributed/checkpoint/state_dict.py
+verl/third_party/vllm/__init__.py
+verl/tools/__init__.py
+verl/tools/base_tool.py
+verl/tools/geo3k_tool.py
+verl/tools/gsm8k_tool.py
+verl/tools/image_zoom_in_tool.py
+verl/tools/mcp_base_tool.py
+verl/tools/mcp_search_tool.py
+verl/tools/sandbox_fusion_tools.py
+verl/tools/schemas.py
+verl/tools/search_tool.py
+verl/tools/utils/__init__.py
+verl/tools/utils/search_r1_like_utils.py
+verl/tools/utils/tool_registry.py
+verl/trainer/__init__.py
+verl/trainer/constants_ppo.py
+verl/trainer/fsdp_sft_trainer.py
+verl/trainer/main_eval.py
+verl/trainer/main_generation.py
+verl/trainer/main_ppo.py
+verl/trainer/sft_trainer.py
+verl/trainer/config/__init__.py
+verl/trainer/config/_generated_ppo_megatron_trainer.yaml
+verl/trainer/config/_generated_ppo_trainer.yaml
+verl/trainer/config/algorithm.py
+verl/trainer/config/config.py
+verl/trainer/config/evaluation.yaml
+verl/trainer/config/generation.yaml
+verl/trainer/config/ppo_megatron_trainer.yaml
+verl/trainer/config/ppo_trainer.yaml
+verl/trainer/config/sft_trainer.yaml
+verl/trainer/config/sft_trainer_engine.yaml
+verl/trainer/config/actor/actor.yaml
+verl/trainer/config/actor/dp_actor.yaml
+verl/trainer/config/actor/megatron_actor.yaml
+verl/trainer/config/critic/critic.yaml
+verl/trainer/config/critic/dp_critic.yaml
+verl/trainer/config/critic/megatron_critic.yaml
+verl/trainer/config/data/legacy_data.yaml
+verl/trainer/config/engine/fsdp.yaml
+verl/trainer/config/engine/megatron.yaml
+verl/trainer/config/model/hf_model.yaml
+verl/trainer/config/npu_profile/npu_profile.yaml
+verl/trainer/config/optim/fsdp.yaml
+verl/trainer/config/optim/megatron.yaml
+verl/trainer/config/ref/dp_ref.yaml
+verl/trainer/config/ref/megatron_ref.yaml
+verl/trainer/config/ref/ref.yaml
+verl/trainer/config/reward_model/dp_reward_model.yaml
+verl/trainer/config/reward_model/megatron_reward_model.yaml
+verl/trainer/config/reward_model/reward_model.yaml
+verl/trainer/config/rollout/rollout.yaml
+verl/trainer/ppo/__init__.py
+verl/trainer/ppo/core_algos.py
+verl/trainer/ppo/metric_utils.py
+verl/trainer/ppo/ray_trainer.py
+verl/trainer/ppo/reward.py
+verl/trainer/ppo/utils.py
+verl/utils/__init__.py
+verl/utils/activation_offload.py
+verl/utils/attention_utils.py
+verl/utils/config.py
+verl/utils/device.py
+verl/utils/distributed.py
+verl/utils/flops_counter.py
+verl/utils/fs.py
+verl/utils/fsdp_utils.py
+verl/utils/groupwise.py
+verl/utils/hdfs_io.py
+verl/utils/import_utils.py
+verl/utils/logging_utils.py
+verl/utils/megatron_utils.py
+verl/utils/memory_buffer.py
+verl/utils/memory_utils.py
+verl/utils/model.py
+verl/utils/net_utils.py
+verl/utils/npu_utils.py
+verl/utils/py_functional.py
+verl/utils/ray_utils.py
+verl/utils/rollout_skip.py
+verl/utils/rollout_trace.py
+verl/utils/seqlen_balancing.py
+verl/utils/tensordict_utils.py
+verl/utils/tokenizer.py
+verl/utils/torch_dtypes.py
+verl/utils/torch_functional.py
+verl/utils/tracking.py
+verl/utils/transformers_compat.py
+verl/utils/ulysses.py
+verl/utils/checkpoint/__init__.py
+verl/utils/checkpoint/checkpoint_handler.py
+verl/utils/checkpoint/checkpoint_manager.py
+verl/utils/checkpoint/fsdp_checkpoint_manager.py
+verl/utils/checkpoint/megatron_checkpoint_manager.py
+verl/utils/dataset/__init__.py
+verl/utils/dataset/dataset_utils.py
+verl/utils/dataset/multiturn_sft_dataset.py
+verl/utils/dataset/rl_dataset.py
+verl/utils/dataset/rm_dataset.py
+verl/utils/dataset/sft_dataset.py
+verl/utils/dataset/vision_utils.py
+verl/utils/debug/__init__.py
+verl/utils/debug/metrics.py
+verl/utils/debug/performance.py
+verl/utils/debug/trajectory_tracker.py
+verl/utils/experimental/__init__.py
+verl/utils/experimental/torch_functional.py
+verl/utils/kernel/__init__.py
+verl/utils/kernel/kernels.py
+verl/utils/kernel/linear_cross_entropy.py
+verl/utils/logger/__init__.py
+verl/utils/logger/aggregate_logger.py
+verl/utils/megatron/__init__.py
+verl/utils/megatron/dist_checkpointing.py
+verl/utils/megatron/memory.py
+verl/utils/megatron/optimizer.py
+verl/utils/megatron/pipeline_parallel.py
+verl/utils/megatron/sequence_parallel.py
+verl/utils/megatron/tensor_parallel.py
+verl/utils/metric/__init__.py
+verl/utils/metric/utils.py
+verl/utils/profiler/__init__.py
+verl/utils/profiler/config.py
+verl/utils/profiler/empty_annotations.py
+verl/utils/profiler/mstx_profile.py
+verl/utils/profiler/nvtx_profile.py
+verl/utils/profiler/performance.py
+verl/utils/profiler/profile.py
+verl/utils/rendezvous/__init__.py
+verl/utils/rendezvous/ray_backend.py
+verl/utils/reward_score/__init__.py
+verl/utils/reward_score/geo3k.py
+verl/utils/reward_score/gsm8k.py
+verl/utils/reward_score/math_batch.py
+verl/utils/reward_score/math_dapo.py
+verl/utils/reward_score/math_reward.py
+verl/utils/reward_score/math_verify.py
+verl/utils/reward_score/search_r1_like_qa_em.py
+verl/utils/reward_score/prime_code/__init__.py
+verl/utils/reward_score/prime_code/testing_util.py
+verl/utils/reward_score/prime_code/utils.py
+verl/utils/reward_score/prime_math/__init__.py
+verl/utils/reward_score/prime_math/grader.py
+verl/utils/reward_score/prime_math/math_normalize.py
+verl/utils/reward_score/sandbox_fusion/__init__.py
+verl/utils/reward_score/sandbox_fusion/utils.py
+verl/utils/vllm/__init__.py
+verl/utils/vllm/patch.py
+verl/utils/vllm/utils.py
+verl/version/version
+verl/workers/__init__.py
+verl/workers/fsdp_workers.py
+verl/workers/megatron_workers.py
+verl/workers/actor/__init__.py
+verl/workers/actor/base.py
+verl/workers/actor/dp_actor.py
+verl/workers/actor/megatron_actor.py
+verl/workers/config/__init__.py
+verl/workers/config/actor.py
+verl/workers/config/critic.py
+verl/workers/config/engine.py
+verl/workers/config/model.py
+verl/workers/config/optimizer.py
+verl/workers/config/reward_model.py
+verl/workers/config/rollout.py
+verl/workers/critic/__init__.py
+verl/workers/critic/base.py
+verl/workers/critic/dp_critic.py
+verl/workers/critic/megatron_critic.py
+verl/workers/engine/__init__.py
+verl/workers/engine/base.py
+verl/workers/engine/utils.py
+verl/workers/engine/fsdp/__init__.py
+verl/workers/engine/fsdp/transformer_impl.py
+verl/workers/engine/fsdp/utils.py
+verl/workers/engine/megatron/__init__.py
+verl/workers/engine/megatron/transformer_impl.py
+verl/workers/engine/megatron/utils.py
+verl/workers/engine/mindspeed/__init__.py
+verl/workers/engine/mindspeed/transformer_impl.py
+verl/workers/reward_manager/__init__.py
+verl/workers/reward_manager/abstract.py
+verl/workers/reward_manager/batch.py
+verl/workers/reward_manager/dapo.py
+verl/workers/reward_manager/naive.py
+verl/workers/reward_manager/prime.py
+verl/workers/reward_manager/registry.py
+verl/workers/reward_model/__init__.py
+verl/workers/reward_model/base.py
+verl/workers/reward_model/megatron/__init__.py
+verl/workers/reward_model/megatron/reward_model.py
+verl/workers/roles/__init__.py
+verl/workers/roles/actor.py
+verl/workers/roles/critic.py
+verl/workers/roles/hybrid_engine.py
+verl/workers/roles/reward_model.py
+verl/workers/roles/reward_model_engine/__init__.py
+verl/workers/roles/reward_model_engine/base.py
+verl/workers/roles/reward_model_engine/sglang_reward_model.py
+verl/workers/roles/utils/__init__.py
+verl/workers/roles/utils/losses.py
+verl/workers/rollout/__init__.py
+verl/workers/rollout/base.py
+verl/workers/rollout/hf_rollout.py
+verl/workers/rollout/replica.py
+verl/workers/rollout/schemas.py
+verl/workers/rollout/tokenizer.py
+verl/workers/rollout/utils.py
+verl/workers/rollout/naive/__init__.py
+verl/workers/rollout/naive/naive_rollout.py
+verl/workers/rollout/sglang_rollout/__init__.py
+verl/workers/rollout/sglang_rollout/async_sglang_server.py
+verl/workers/rollout/sglang_rollout/http_server_engine.py
+verl/workers/rollout/sglang_rollout/sglang_rollout.py
+verl/workers/rollout/sglang_rollout/utils.py
+verl/workers/rollout/vllm_rollout/__init__.py
+verl/workers/rollout/vllm_rollout/vllm_async_server.py
+verl/workers/rollout/vllm_rollout/vllm_rollout_spmd.py
+verl/workers/sharding_manager/__init__.py
+verl/workers/sharding_manager/base.py
+verl/workers/sharding_manager/fsdp_sglang.py
+verl/workers/sharding_manager/fsdp_ulysses.py
+verl/workers/sharding_manager/fsdp_vllm.py
+verl/workers/sharding_manager/megatron_sglang.py
+verl/workers/sharding_manager/megatron_vllm.py

verl/verl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

verl/verl.egg-info/requires.txt

@@ -0,0 +1,54 @@
+accelerate
+codetiming
+datasets
+dill
+hydra-core
+numpy<2.0.0
+pandas
+peft
+pyarrow>=19.0.0
+pybind11
+pylatexenc
+ray[default]>=2.41.0
+torchdata
+tensordict!=0.9.0,<=0.10.0,>=0.8.0
+transformers
+wandb
+packaging>=20.0
+tensorboard
+
+[geo]
+mathruler
+torchvision
+qwen_vl_utils
+
+[gpu]
+liger-kernel
+flash-attn
+
+[math]
+math-verify
+
+[mcore]
+mbridge
+
+[prime]
+pyext
+
+[sglang]
+tensordict!=0.9.0,<=0.10.0,>=0.8.0
+sglang[openai,srt]==0.5.2
+torch==2.8.0
+
+[test]
+pytest
+pre-commit
+py-spy
+pytest-asyncio
+
+[trl]
+trl<=0.9.6
+
+[vllm]
+tensordict!=0.9.0,<=0.10.0,>=0.8.0
+vllm<=0.9.1,>=0.7.3

verl/verl.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+scripts
+tests
+verl

verl/verl/utils/checkpoint/__init__.py

@@ -0,0 +1,17 @@
+# 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 .checkpoint_handler import CheckpointHandler
+
+__all__ = ["CheckpointHandler"]

verl/verl/utils/checkpoint/checkpoint_handler.py

@@ -0,0 +1,204 @@
+# Copyright 2025 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.
+
+
+# TODO: add unit tests
+
+import logging
+import os
+import re
+
+import torch
+
+import verl.utils.hdfs_io as hdfs_io
+from verl.utils.checkpoint.checkpoint_manager import find_latest_ckpt_path, get_checkpoint_tracker_filename
+from verl.utils.logger import log_with_rank
+from verl.workers.engine import BaseEngine
+
+
+def extract_step(path):
+    match = re.search(r"global_step_(\d+)", path)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+logger = logging.getLogger(__file__)
+logger.setLevel(os.getenv("VERL_SFT_LOGGING_LEVEL", "WARN"))
+
+
+class CheckpointHandler:
+    """
+    Checkpoint handler handles the path, global_step of a checkpoint folder.
+    Currently, it only works with a single model.
+    We can expand it to support multiple models. It is expected to be used with SPMD style (e.g., torchrun)
+    """
+
+    def __init__(
+        self,
+        engine: BaseEngine,
+        train_dataloader,
+        *,
+        default_local_dir,
+        max_ckpt_to_keep=None,
+        default_hdfs_dir=None,
+        resume_mode="auto",
+        resume_from_path=None,
+    ):
+        self.default_local_dir = default_local_dir
+        self.max_ckpt_to_keep = max_ckpt_to_keep
+        self.default_hdfs_dir = default_hdfs_dir
+        self.resume_mode = resume_mode
+        self.resume_from_path = resume_from_path
+        self.engine = engine
+        self.train_dataloader = train_dataloader
+        self.rank = torch.distributed.get_rank()
+
+    def save_checkpoint(self, step):
+        """Save checkpoint using FSDPCheckpointManager with improved tracking"""
+        from verl.utils.fs import local_mkdir_safe
+
+        # Determine checkpoint path
+        local_global_step_folder = os.path.join(self.default_local_dir, f"global_step_{step}")
+        if self.rank == 0:
+            print(f"Saving checkpoint to: {local_global_step_folder}")
+
+        # Get max checkpoints to keep
+        max_ckpt_to_keep = self.max_ckpt_to_keep
+
+        # Use checkpoint manager to save
+        self.engine.save_checkpoint(
+            local_path=local_global_step_folder, global_step=step, max_ckpt_to_keep=max_ckpt_to_keep
+        )
+
+        # Save dataloader state. Note that we only save the iterator in the train_dataloader.
+        # So it's identical in each dp rank.
+        if self.engine.is_mp_src_rank_with_outputs():
+            dp_rank = self.engine.get_data_parallel_rank()
+            local_mkdir_safe(local_global_step_folder)
+            dataloader_local_path = os.path.join(local_global_step_folder, f"data_{dp_rank}.pt")
+
+            # Use StatefulDataLoader's built-in state dict functionality
+            dataloader_state_dict = self.train_dataloader.state_dict()
+            torch.save(dataloader_state_dict, dataloader_local_path)
+            print(f"Saved dataloader state to: {dataloader_local_path}")
+
+        if self.rank == 0:
+            # Update latest checkpoint tracker (atomic write)
+            tracker_file = get_checkpoint_tracker_filename(self.default_local_dir)
+            temp_tracker_file = tracker_file + ".tmp"
+            with open(temp_tracker_file, "w") as f:
+                f.write(str(step))
+            os.rename(temp_tracker_file, tracker_file)
+            print(f"Updated checkpoint tracker: {tracker_file}")
+
+        # Copy to HDFS if configured
+        if self.rank == 0 and self.default_hdfs_dir:
+            hdfs_io.makedirs(self.default_hdfs_dir, exist_ok=True)
+            hdfs_io.copy(src=local_global_step_folder, dst=self.default_hdfs_dir, dirs_exist_ok=True)
+
+        torch.distributed.barrier()
+
+    def load_checkpoint(self):
+        # Determine resume path based on configuration
+        checkpoint_path = self._determine_resume_path()
+
+        if checkpoint_path is None:
+            return 0
+
+        # extract resume step from checkpoint path
+        resume_step = extract_step(checkpoint_path)
+        if resume_step is None:
+            log_with_rank(
+                f"Warning: Could not extract step number from {checkpoint_path}, starting from step 0",
+                logger=logger,
+                rank=self.rank,
+                level=logging.WARNING,
+                log_only_rank_0=True,
+            )
+            return 0
+        self.resume_global_step = resume_step
+
+        # Use checkpoint manager to load model state
+        self.engine.load_checkpoint(checkpoint_path)
+        # Always load dataloader state for StatefulDataLoader
+        self._load_dataloader_state(checkpoint_path)
+
+        return resume_step
+
+    def _load_dataloader_state(self, checkpoint_path: str):
+        """Load dataloader state from checkpoint"""
+        dp_rank = self.engine.get_data_parallel_rank()
+        dataloader_path = os.path.join(checkpoint_path, f"data_{dp_rank}.pt")
+
+        if os.path.exists(dataloader_path):
+            # Use StatefulDataLoader's built-in state dict functionality
+            dataloader_state_dict = torch.load(dataloader_path, map_location="cpu", weights_only=False)
+            self.train_dataloader.load_state_dict(dataloader_state_dict)
+
+            log_with_rank(
+                f"Successfully loaded dataloader state from {dataloader_path}",
+                logger=logger,
+                rank=self.rank,
+                log_only_rank_0=True,
+            )
+
+        else:
+            log_with_rank(
+                f"Warning: No dataloader state found at {dataloader_path}, will start from scratch",
+                logger=logger,
+                rank=self.rank,
+                level=logging.WARNING,
+                log_only_rank_0=True,
+            )
+
+    def _determine_resume_path(self):
+        """Determine the path to resume from based on resume_mode configuration"""
+        resume_mode = self.resume_mode
+        resume_from_path = self.resume_from_path
+
+        if resume_mode == "disable":
+            return None
+        elif resume_mode == "auto":
+            if resume_from_path is not None:
+                assert os.path.exists(resume_from_path), (
+                    "resume_from_path must be null or an existing path when resume_mode is 'auto'"
+                )
+                assert "global_step_" in resume_from_path, "resume_from_path must specify the global_steps"
+                return resume_from_path
+            # Try to find the latest checkpoint in the default directory
+            return self._find_latest_checkpoint()
+        elif resume_mode == "resume_path":
+            assert os.path.exists(resume_from_path), (
+                "resume_from_path must be an existing path when resume_mode is 'resume_path'"
+            )
+            assert "global_step_" in resume_from_path, "resume_from_path must specify the global_steps"
+            return resume_from_path
+        else:
+            raise ValueError(f"Invalid resume_mode: {resume_mode}. Must be 'auto', 'disable', or 'resume_path'")
+
+    def _find_latest_checkpoint(self):
+        """Find the latest checkpoint in the default local directory"""
+        checkpoint_dir = self.default_local_dir
+
+        if not os.path.exists(checkpoint_dir):
+            return None
+
+        latest_checkpoint = find_latest_ckpt_path(checkpoint_dir)
+
+        if latest_checkpoint and self.rank == 0:
+            step_num = extract_step(latest_checkpoint)
+            print(f"Found latest checkpoint: {latest_checkpoint} (step {step_num})")
+
+        return latest_checkpoint

verl/verl/utils/checkpoint/checkpoint_manager.py

@@ -0,0 +1,237 @@
+# 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 shutil
+
+import numpy as np
+import torch
+import torch.distributed
+from omegaconf import DictConfig
+from transformers import PreTrainedTokenizer, ProcessorMixin
+
+from verl.trainer.config import CheckpointConfig
+from verl.utils.device import get_device_name, get_torch_device
+
+
+class BaseCheckpointManager:
+    """
+    A checkpoint manager that saves and loads the following states in a SPMD way:
+    - model
+    - optimizer
+    - lr_scheduler
+    - extra_states
+
+    We save
+    - sharded model states and optimizer states
+    - full lr_scheduler states
+    - huggingface tokenizer and config for ckpt merge
+    """
+
+    def __init__(
+        self,
+        model,
+        optimizer: torch.optim.Optimizer,
+        lr_scheduler: torch.optim.lr_scheduler.LRScheduler = None,
+        processing_class: PreTrainedTokenizer | ProcessorMixin = None,
+        checkpoint_config: DictConfig | CheckpointConfig = None,
+    ):
+        self.checkpoint_config = checkpoint_config
+        checkpoint_load_contents = checkpoint_config.get("load_contents", None) if checkpoint_config else None
+        checkpoint_save_contents = checkpoint_config.get("save_contents", None) if checkpoint_config else None
+        if checkpoint_load_contents is None:
+            checkpoint_load_contents = ["model", "optimizer", "extra"]
+        if checkpoint_save_contents is None:
+            checkpoint_save_contents = ["model", "optimizer", "extra"]
+        self.previous_global_step = None
+        self.previous_saved_paths = []
+
+        self.model = model
+        self.optimizer = optimizer
+        self.lr_scheduler = lr_scheduler
+        self.processing_class = processing_class
+        self.checkpoint_load_contents = checkpoint_load_contents
+        self.checkpoint_save_contents = checkpoint_save_contents
+
+        self.rank = torch.distributed.get_rank()
+        self.world_size = torch.distributed.get_world_size()
+
+    @property
+    def should_save_model(self) -> bool:
+        """
+        Returns True if 'model' is in checkpoint_save_contents, indicating the model state should be saved.
+        """
+        return "model" in self.checkpoint_save_contents
+
+    @property
+    def should_save_optimizer(self) -> bool:
+        """
+        Returns True if 'optimizer' is in checkpoint_save_contents, indicating the optimizer state should be saved.
+        """
+        return "optimizer" in self.checkpoint_save_contents
+
+    @property
+    def should_save_extra(self) -> bool:
+        """
+        Returns True if 'extra' is in checkpoint_save_contents, indicating the extra state should be saved.
+        """
+        return "extra" in self.checkpoint_save_contents
+
+    @property
+    def should_save_hf_model(self) -> bool:
+        """
+        Returns True if 'hf_model' is in checkpoint_save_contents, indicating the model should be converted to hf
+        model and saved.
+        """
+        return "hf_model" in self.checkpoint_save_contents
+
+    @property
+    def should_load_model(self) -> bool:
+        """
+        Returns True if 'model' is in checkpoint_load_contents, indicating the model state should be loaded.
+        """
+        return "model" in self.checkpoint_load_contents
+
+    @property
+    def should_load_optimizer(self) -> bool:
+        """
+        Returns True if 'optimizer' is in checkpoint_load_contents, indicating the optimizer state should be loaded.
+        """
+        return "optimizer" in self.checkpoint_load_contents
+
+    @property
+    def should_load_extra(self) -> bool:
+        """
+        Returns True if 'extra' is in checkpoint_load_contents, indicating the extra state should be loaded.
+        """
+        return "extra" in self.checkpoint_load_contents
+
+    def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load: bool = False):
+        raise NotImplementedError
+
+    def save_checkpoint(
+        self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep: int = None
+    ):
+        raise NotImplementedError
+
+    @staticmethod
+    def checkpath(local_path: str, hdfs_path: str):
+        assert local_path is not None or hdfs_path is not None, "local_path and hdfs_path cannot be both None"
+        return local_path is not None, local_path if local_path is not None else hdfs_path
+
+    def remove_previous_save_local_path(self, path):
+        if isinstance(path, str):
+            path = [path]
+        for p in path:
+            abs_path = os.path.abspath(p)
+            print(f"Checkpoint manager remove previous save local path: {abs_path}")
+            if not os.path.exists(abs_path):
+                continue
+            shutil.rmtree(abs_path, ignore_errors=True)
+
+    @staticmethod
+    def get_rng_state():
+        rng_state = {
+            "cpu": torch.get_rng_state(),
+            "numpy": np.random.get_state(),
+            "random": random.getstate(),
+        }
+
+        if get_device_name() != "cpu":
+            rng_state[get_device_name()] = get_torch_device().get_rng_state()
+
+        return rng_state
+
+    @staticmethod
+    def load_rng_state(rng_state):
+        torch.set_rng_state(rng_state["cpu"])
+        np.random.set_state(rng_state["numpy"])
+        random.setstate(rng_state["random"])
+
+        if get_device_name() != "cpu":
+            get_torch_device().set_rng_state(rng_state[get_device_name()])
+
+
+def find_latest_ckpt_path(path, directory_format="global_step_{}"):
+    """
+    Return the most recent checkpoint directory based on a tracker file.
+
+    Args:
+        path (str): Base directory containing the checkpoint tracker.
+        directory_format (str): Template for checkpoint subfolders with one
+            placeholder for the iteration number (default "global_step_{}").
+
+    Returns:
+        str or None: Full path to the latest checkpoint directory, or
+        None if the tracker or checkpoint folder is missing.
+    """
+    if path is None:
+        return None
+
+    tracker_file = get_checkpoint_tracker_filename(path)
+    if not os.path.exists(tracker_file):
+        print(f"Checkpoint tracker file does not exist: {tracker_file}")
+        return None
+
+    with open(tracker_file, "rb") as f:
+        iteration = int(f.read().decode())
+    ckpt_path = os.path.join(path, directory_format.format(iteration))
+    if not os.path.exists(ckpt_path):
+        print("Checkpoint does not exist: %s", ckpt_path)
+        return None
+
+    print("Found checkpoint: %s", ckpt_path)
+    return ckpt_path
+
+
+def get_checkpoint_tracker_filename(root_path: str):
+    """
+    Tracker file rescords the latest chckpoint during training to restart from.
+    """
+    return os.path.join(root_path, "latest_checkpointed_iteration.txt")
+
+
+def should_save_ckpt_esi(max_steps_duration: float, save_ckpt_duration: float = 60, redundant_time: float = 0) -> bool:
+    """
+    Determine if checkpoint should be saved based on capacity esi expiration.
+
+    Args:
+        max_steps_duration: Max estimated time (seconds) required to complete one training step
+        save_ckpt_duration: Estimated time (seconds) required to save checkpoint (default: 60)
+        redundant_time: Additional buffer time (seconds) for unexpected delays (default: 0)
+    """
+    exp_ts_mlp = os.getenv("MLP_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP")  # vemlp
+    exp_ts_aws = os.getenv("SAGEMAKER_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP")  # aws
+    if exp_ts_mlp:
+        try:
+            import time
+
+            remaining = float(exp_ts_mlp) - time.time()
+        except ValueError:
+            return False
+        return (
+            remaining > 0
+            and max_steps_duration > 0
+            and remaining <= save_ckpt_duration + max_steps_duration + redundant_time
+        )
+    elif exp_ts_aws:
+        from datetime import datetime, timedelta
+
+        expiration_time = datetime.fromtimestamp(int(exp_ts_aws))
+        time_difference = expiration_time - datetime.now()
+        threshold_minutes = (save_ckpt_duration + max_steps_duration + redundant_time) / 60
+        return time_difference < timedelta(minutes=threshold_minutes)
+    else:
+        return False

verl/verl/utils/checkpoint/fsdp_checkpoint_manager.py

@@ -0,0 +1,367 @@
+# 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 logging
+import os
+import warnings
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+import torch
+import torch.distributed
+from accelerate import init_empty_weights
+from omegaconf import DictConfig
+from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
+from torch.distributed.fsdp import ShardedOptimStateDictConfig, ShardedStateDictConfig, StateDictType
+from transformers import GenerationConfig, PreTrainedTokenizer, ProcessorMixin
+from transformers.dynamic_module_utils import custom_object_save
+
+from verl.utils.device import is_cuda_available
+from verl.utils.fs import copy_to_local, is_non_local, local_mkdir_safe
+from verl.utils.fsdp_utils import fsdp_version, get_fsdp_full_state_dict, get_fsdp_state_ctx
+from verl.utils.logger import log_with_rank
+
+from .checkpoint_manager import BaseCheckpointManager
+
+# Setup logging
+logger = logging.getLogger(__file__)
+logger.setLevel(os.getenv("VERL_LOGGING_LEVEL", "INFO"))
+
+
+@dataclass
+class FSDPConfig:
+    """Configuration for FSDP checkpointing.
+
+    Args:
+        FSDP_version (int): Version of FSDP being used.
+        world_size (int): Number of processes in the distributed training setup.
+    """
+
+    FSDP_version: int
+    world_size: int
+
+
+class FSDPCheckpointManager(BaseCheckpointManager):
+    """
+    Manage FSDP checkpointing in SPMD training.
+
+    - Saves/loads per-rank sharded model & optimizer states
+    - Persists full lr_scheduler and RNG state
+    - Stores HF tokenizer/processor and model/config for unified restore
+
+    Args:
+        model (FSDP): Wrapped model instance.
+        optimizer (Optimizer): Training optimizer.
+        lr_scheduler (LRScheduler): Learning-rate scheduler.
+        processing_class (PreTrainedTokenizer or ProcessorMixin, optional):
+            Pre-/post-processing artifact handler.
+        checkpoint_contents DictConfig: Configuration for checkpoint contents.
+            - 'load': Components to load; must contain 'model'. Defaults to ['model', 'optimizer', 'extra'].
+            - 'save': Components to save; must contain 'model'. Defaults to ['model', 'optimizer', 'extra'].
+    """
+
+    def __init__(
+        self,
+        model: FSDP,
+        optimizer: Optional[torch.optim.Optimizer] = None,
+        lr_scheduler: Optional[torch.optim.lr_scheduler.LRScheduler] = None,
+        processing_class: PreTrainedTokenizer | ProcessorMixin = None,
+        checkpoint_config: DictConfig = None,
+        **kwargs,
+    ):
+        if processing_class is None and "tokenizer" in kwargs:
+            warnings.warn(
+                "`tokenizer` is deprecated. use `processing_class` instead.", DeprecationWarning, stacklevel=2
+            )
+            processing_class = kwargs.pop("tokenizer")
+
+        super().__init__(
+            model,
+            optimizer,
+            lr_scheduler=lr_scheduler,
+            processing_class=processing_class,
+            checkpoint_config=checkpoint_config,
+        )
+
+    def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load=False):
+        """
+        Load an FSDP checkpoint for this rank.
+
+        Downloads and loads:
+          - model and optimizer shards
+          - extra state dict (scheduler + RNG)
+
+        Args:
+            local_path: Directory with per-rank checkpoint files.
+            hdfs_path: Unused (for API compatibility).
+            del_local_after_load: Remove local files after loading.
+        """
+        if local_path is None:
+            return
+
+        # check if the checkpoint_load_contents is valid
+        if self.should_load_model:
+            assert self.model is not None, "model must be provided when checkpoint_contents.load includes ['model']"
+        if self.should_load_optimizer:
+            assert self.optimizer is not None, (
+                "optimizer must be provided when checkpoint_contents.load includes ['optimizer']"
+            )
+
+        # every rank download its own checkpoint
+        state_dict_cfg = (
+            ShardedStateDictConfig(offload_to_cpu=True if is_cuda_available else False)
+            if self.should_load_model
+            else None
+        )
+        optim_cfg = (
+            ShardedOptimStateDictConfig(offload_to_cpu=True if is_cuda_available else False)
+            if self.should_load_optimizer
+            else None
+        )
+        with get_fsdp_state_ctx(self.model, StateDictType.SHARDED_STATE_DICT, state_dict_cfg, optim_cfg):
+            if self.should_load_model:
+                remote_model_path = os.path.join(local_path, f"model_world_size_{self.world_size}_rank_{self.rank}.pt")
+                local_model_path = copy_to_local(remote_model_path)
+                model_state_dict = torch.load(local_model_path, weights_only=False)
+                self.model.load_state_dict(model_state_dict)
+                log_with_rank(f"Loaded model from {remote_model_path}", rank=self.rank, logger=logger)
+
+            if self.should_load_optimizer:
+                remote_optim_path = os.path.join(local_path, f"optim_world_size_{self.world_size}_rank_{self.rank}.pt")
+                local_optim_path = copy_to_local(remote_optim_path)
+                optimizer_state_dict = torch.load(local_optim_path, weights_only=False)
+                self.optimizer.load_state_dict(optimizer_state_dict)
+                log_with_rank(f"Loaded optimizer from {remote_optim_path}", rank=self.rank, logger=logger)
+
+        if self.should_load_extra:
+            remote_extra_state_path = os.path.join(
+                local_path, f"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt"
+            )
+            local_extra_state_path = copy_to_local(remote_extra_state_path)
+            extra_state_dict = torch.load(local_extra_state_path, weights_only=False)
+            # recover random state
+            if "rng" in extra_state_dict:
+                # 'rng' may not exist for backward compatibility
+                self.load_rng_state(extra_state_dict["rng"])
+                log_with_rank(f"Loaded rng from {remote_extra_state_path}", rank=self.rank, logger=logger)
+
+            lr_scheduler_state_dict = extra_state_dict["lr_scheduler"]
+            if lr_scheduler_state_dict is not None and self.lr_scheduler is not None:
+                self.lr_scheduler.load_state_dict(lr_scheduler_state_dict)
+                log_with_rank(f"Loaded lr_scheduler from {remote_extra_state_path}", rank=self.rank, logger=logger)
+
+        if self.rank == 0 and del_local_after_load:
+            try:
+                os.remove(local_model_path) if is_non_local(local_model_path) else None
+                os.remove(local_optim_path) if is_non_local(local_optim_path) else None
+                os.remove(local_extra_state_path) if is_non_local(local_extra_state_path) else None
+            except Exception as e:
+                log_with_rank(
+                    f"remove local resume ckpt file after loading failed, exception {e} will be ignored",
+                    rank=self.rank,
+                    logger=logger,
+                )
+
+        # wait for everyone to load checkpoints
+        torch.distributed.barrier()
+
+    def save_checkpoint(self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep=None):
+        """
+        Save an FSDP checkpoint for this rank.
+
+        Writes:
+          - model & optimizer shard files
+          - extra state dict (scheduler + RNG)
+          - HF tokenizer/processor and model/config on rank 0
+          - optional full HF model under 'huggingface/' if requested
+
+        Rotates old checkpoints, keeping at most `max_ckpt_to_keep`.
+
+        Args:
+            local_path: Target directory for checkpoint files.
+            hdfs_path: Unused (for API compatibility).
+            global_step: Current training step (used for bookkeeping).
+            max_ckpt_to_keep: Number of recent checkpoints to retain.
+        """
+        if local_path is None:
+            return
+
+        # record the previous global step
+        self.previous_global_step = global_step
+
+        # remove previous local_path, only rank 0 should do this
+        if (
+            self.rank == 0
+            and max_ckpt_to_keep
+            and isinstance(max_ckpt_to_keep, int)
+            and max_ckpt_to_keep > 0
+            and len(self.previous_saved_paths) >= max_ckpt_to_keep
+        ):
+            keep_start = len(self.previous_saved_paths) - max_ckpt_to_keep + 1
+            self.remove_previous_save_local_path(self.previous_saved_paths[:keep_start])
+            self.previous_saved_paths = self.previous_saved_paths[keep_start:]
+
+        local_path = local_mkdir_safe(local_path)
+        torch.distributed.barrier()
+
+        # check if the checkpoint_save_contents is valid
+        if self.should_save_model:
+            assert self.model is not None, "model must be provided when checkpoint_contents.save includes ['model']"
+        if self.should_save_optimizer:
+            assert self.optimizer is not None, (
+                "optimizer must be provided when checkpoint_contents.save includes ['optimizer']"
+            )
+
+        # every rank will save its own model and optim shard
+        state_dict_cfg = ShardedStateDictConfig(offload_to_cpu=True if is_cuda_available else False)
+        optim_cfg = ShardedOptimStateDictConfig(offload_to_cpu=True if is_cuda_available else False)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            with get_fsdp_state_ctx(self.model, StateDictType.SHARDED_STATE_DICT, state_dict_cfg, optim_cfg):
+                model_path = os.path.join(local_path, f"model_world_size_{self.world_size}_rank_{self.rank}.pt")
+                optim_path = os.path.join(local_path, f"optim_world_size_{self.world_size}_rank_{self.rank}.pt")
+                extra_path = os.path.join(local_path, f"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt")
+
+                if self.should_save_model:
+                    model_state_dict = self.model.state_dict()
+                    torch.save(model_state_dict, model_path)
+                    log_with_rank(f"Saved model to {os.path.abspath(model_path)}", rank=self.rank, logger=logger)
+
+                if self.should_save_optimizer:
+                    optimizer_state_dict = self.optimizer.state_dict()
+                    torch.save(optimizer_state_dict, optim_path)
+                    log_with_rank(f"Saved optim to {os.path.abspath(optim_path)}", rank=self.rank, logger=logger)
+
+                if self.should_save_extra:
+                    lr_scheduler_state_dict = self.lr_scheduler.state_dict() if self.lr_scheduler is not None else None
+                    extra_state_dict = {
+                        "lr_scheduler": lr_scheduler_state_dict,
+                        "rng": self.get_rng_state(),
+                    }
+                    torch.save(extra_state_dict, extra_path)
+                    log_with_rank(f"Saved extra_state to {os.path.abspath(extra_path)}", rank=self.rank, logger=logger)
+
+        if self.rank == 0:
+            # Save HF tokenizer/processor and model config on rank 0 to huggingface/ directory, no matter whether
+            # huggingface model is requested to be saved or not.
+
+            if fsdp_version(self.model) == 1:
+                unwrap_model = self.model._fsdp_wrapped_module
+            else:
+                unwrap_model = self.model
+
+            hf_config_tokenizer_path = os.path.join(local_path, "huggingface")
+            local_mkdir_safe(hf_config_tokenizer_path)
+            model_config = unwrap_model.config
+            generation_config = None
+            if unwrap_model.can_generate() and hasattr(model_config, "name_or_path") and model_config.name_or_path:
+                try:
+                    # Some model's name_or_path is empty if not initialized from pretrained,
+                    # in this cases, we don't save generation config.
+                    generation_config = GenerationConfig.from_pretrained(model_config.name_or_path)
+                    generation_config.save_pretrained(hf_config_tokenizer_path)
+                except Exception:
+                    # if the generation config isn't available, we don't save it
+                    pass
+
+            model_config.save_pretrained(hf_config_tokenizer_path)
+            if self.processing_class is not None:
+                self.processing_class.save_pretrained(hf_config_tokenizer_path)
+            log_with_rank(
+                f"Saved model config and tokenizer class to {os.path.abspath(hf_config_tokenizer_path)}",
+                rank=self.rank,
+                logger=logger,
+                log_only_rank_0=True,
+            )
+
+            # If we have a custom model, we copy the file defining it in the folder and set the attributes so it can be
+            # loaded from the Hub.
+            if hasattr(model_config, "auto_map"):
+                custom_object_save(unwrap_model, hf_config_tokenizer_path, config=model_config)
+
+            # Also save runtime FSDP config
+            fsdp_config_path = os.path.join(local_path, "fsdp_config.json")
+            fsdp_config = FSDPConfig(
+                FSDP_version=fsdp_version(self.model),
+                world_size=self.world_size,
+            )
+            with open(fsdp_config_path, "w") as f:
+                json.dump(asdict(fsdp_config), f, indent=4)
+
+        # wait for everyone to dump to local
+        torch.distributed.barrier()
+
+        if self.should_save_hf_model:
+            # Only rank 0 will save hf model and,
+            # offload to cpu to save LLMs which may be too large to fit in one GPU
+            state_dict = get_fsdp_full_state_dict(self.model, offload_to_cpu=True, rank0_only=True)
+
+            if self.rank == 0:
+                hf_local_path = os.path.join(local_path, "huggingface")
+                os.makedirs(hf_local_path, exist_ok=True)
+
+                if "ForTokenClassification" in model_config.architectures[0]:
+                    from transformers import AutoModelForTokenClassification
+
+                    auto_model_cls = AutoModelForTokenClassification
+                elif "ForCausalLM" in model_config.architectures[0]:
+                    from transformers import AutoModelForCausalLM
+
+                    auto_model_cls = AutoModelForCausalLM
+                elif "ForConditionalGeneration" in model_config.architectures[0]:
+                    # Handle different transformers versions for Vision2Seq models
+                    import transformers
+                    from packaging import version
+
+                    if version.parse(transformers.__version__) >= version.parse("4.54.0"):
+                        # transformers >= 4.54.0 uses AutoModelForImageTextToText
+                        from transformers import AutoModelForImageTextToText
+
+                        auto_model_cls = AutoModelForImageTextToText
+                    else:
+                        # transformers < 4.54.0 uses AutoModelForVision2Seq
+                        from transformers import AutoModelForVision2Seq
+
+                        auto_model_cls = AutoModelForVision2Seq
+                else:
+                    raise NotImplementedError(f"Unknown architecture {model_config['architectures']}")
+
+                with init_empty_weights():
+                    save_model = auto_model_cls.from_config(model_config, torch_dtype=torch.bfloat16)
+                save_model.to_empty(device="cpu")
+
+                if save_model.can_generate():
+                    if generation_config is not None:
+                        save_model.generation_config = generation_config
+                    else:
+                        print(
+                            f"Warning: {self.__class__.__name__}.save_checkpoint: Generation config file not found "
+                            f"in, using a generation config created from the model config when saving hf_model."
+                        )
+
+                save_model.save_pretrained(hf_local_path, state_dict=state_dict)
+                log_with_rank(
+                    f"Saved hf_model to {os.path.abspath(hf_local_path)}",
+                    rank=self.rank,
+                    logger=logger,
+                    log_only_rank_0=True,
+                )
+                del state_dict
+                del save_model
+
+            # wait for rank0 to dump hf_model to local
+            torch.distributed.barrier()
+
+        self.previous_saved_paths.append(local_path)

verl/verl/utils/checkpoint/megatron_checkpoint_manager.py

@@ -0,0 +1,557 @@
+# 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 logging
+import os
+import random
+from collections.abc import Callable
+from dataclasses import asdict
+
+import numpy as np
+import torch
+import torch.distributed
+from megatron.core import mpu, tensor_parallel
+from megatron.core.dist_checkpointing.mapping import ShardedObject
+from megatron.core.transformer.enums import AttnBackend
+from transformers import GenerationConfig
+
+from verl.models.weight_loader_registry import get_weight_saver
+from verl.utils.device import get_device_name, get_torch_device
+from verl.utils.fs import is_non_local, local_mkdir_safe
+from verl.utils.logger import log_with_rank
+from verl.utils.megatron.dist_checkpointing import load_dist_checkpointing, save_dist_checkpointing
+from verl.utils.megatron_utils import (
+    get_dist_checkpoint_path,
+    get_hf_model_checkpoint_path,
+    get_transformer_config_checkpoint_path,
+)
+
+from .checkpoint_manager import BaseCheckpointManager
+
+# Setup logging
+logger = logging.getLogger(__file__)
+logger.setLevel(os.getenv("VERL_LOGGING_LEVEL", "INFO"))
+
+
+class MegatronCheckpointManager(BaseCheckpointManager):
+    """
+    Checkpoint manager for Megatron-LM distributed training.
+
+    This class manages the saving and loading of model checkpoints in a Megatron-LM
+    distributed training environment. It handles various aspects of checkpointing
+    including model states, optimizer states, learning rate schedulers, and random
+    number generator states, ensuring compatibility with HuggingFace formats.
+
+    Key features:
+    - Distributed checkpoint saving and loading using Megatron's dist_checkpointing
+    - Support for tensor parallel, pipeline parallel, and data parallel configurations
+    - Automatic handling of model state dictionaries across multiple pipeline stages
+    - Integration with HuggingFace model configurations and tokenizers
+    - Random number generator state management for reproducibility
+    - Support for both synchronous and asynchronous checkpoint operations
+
+    The manager automatically handles:
+    - Directory structure creation based on global steps and process ranks
+    - Model configuration and tokenizer saving in HuggingFace format
+    - Optimizer and scheduler state persistence
+    - CUDA RNG state management for deterministic training
+    - Checkpoint cleanup and retention policies
+
+    Args:
+        model: The Megatron model instance to checkpoint
+        optimizer: The optimizer instance (optional)
+        lr_scheduler: The learning rate scheduler instance (optional)
+
+    Attributes:
+        model: Reference to the Megatron model being checkpointed
+        optimizer: Reference to the optimizer (if provided)
+        lr_scheduler: Reference to the learning rate scheduler (if provided)
+        rank: Current process rank in the distributed setup
+
+    Example:
+        ```python
+        checkpoint_manager = MegatronCheckpointManager(
+            model=megatron_model,
+            optimizer=optimizer,
+            lr_scheduler=scheduler
+        )
+
+        checkpoint_manager.save_checkpoint(
+            local_path="checkpoints/step_1000",
+            global_step=1000
+        )
+
+        checkpoint_manager.load_checkpoint(
+            local_path="checkpoints/step_1000"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        config,
+        checkpoint_config,
+        model_config,
+        transformer_config,
+        role,
+        model: torch.nn.ModuleList,
+        arch: str,
+        hf_config,
+        param_dtype: torch.dtype,
+        share_embeddings_and_output_weights: bool,
+        processing_class,
+        optimizer,
+        optimizer_scheduler,
+        use_distributed_optimizer: bool,
+        use_checkpoint_opt_param_scheduler: bool = False,
+        use_dist_checkpointing: bool = True,
+        bridge=None,
+        **kwargs,
+    ):
+        super().__init__(
+            model,
+            optimizer=optimizer,
+            lr_scheduler=optimizer_scheduler,
+            processing_class=processing_class,
+            checkpoint_config=checkpoint_config,
+        )
+        self.arch = arch
+        self.config = config
+        self.transformer_config = transformer_config
+        self.role = role
+        self.is_value_model = False
+        if self.role in ["reward", "critic"]:
+            self.is_value_model = True
+        self.model_config = model_config
+        self.hf_config = hf_config
+        self.param_dtype = param_dtype
+        self.share_embeddings_and_output_weights = share_embeddings_and_output_weights
+        self.model_path = self.config.model.path
+        self.use_distributed_optimizer = use_distributed_optimizer
+        self.use_checkpoint_opt_param_scheduler = use_checkpoint_opt_param_scheduler
+        self.bridge = bridge
+        self.rank = torch.distributed.get_rank()
+        self.use_dist_checkpointing = use_dist_checkpointing or not self.bridge or self.is_value_model
+        self.use_hf_checkpoint = not self.use_dist_checkpointing
+
+        self.weight_saver = None
+        if self.bridge is None:
+            self.weight_saver = get_weight_saver(self.arch)
+
+    def get_rng_state(self, use_dist_ckpt: bool = True, data_parallel_random_init: bool = False):
+        """collect rng state across data parallel ranks"""
+        rng_state = {
+            "random_rng_state": random.getstate(),
+            "np_rng_state": np.random.get_state(),
+            "torch_rng_state": torch.get_rng_state(),
+            "rng_tracker_states": tensor_parallel.get_cuda_rng_tracker().get_states(),
+        }
+
+        if get_device_name() != "cpu":
+            rng_state[f"{get_device_name()}_rng_state"] = get_torch_device().get_rng_state()
+
+        rng_state_list = None
+        if torch.distributed.is_initialized() and mpu.get_data_parallel_world_size() > 1 and data_parallel_random_init:
+            rng_state_list = [None for i in range(mpu.get_data_parallel_world_size())]
+            torch.distributed.all_gather_object(rng_state_list, rng_state, group=mpu.get_data_parallel_group())
+        else:
+            rng_state_list = [rng_state]
+
+        if use_dist_ckpt:
+            pp_rank = mpu.get_pipeline_model_parallel_rank()
+            pp_size = mpu.get_pipeline_model_parallel_world_size()
+            tp_rank = mpu.get_tensor_model_parallel_rank()
+            tp_size = mpu.get_tensor_model_parallel_world_size()
+            rng_state_list = ShardedObject(
+                "rng_state",
+                rng_state_list,
+                (pp_size, tp_size),
+                (pp_rank, tp_rank),
+                replica_id=mpu.get_data_parallel_rank(with_context_parallel=True),
+            )
+
+        return rng_state_list
+
+    def get_checkpoint_name(
+        self,
+        checkpoints_path,
+        pipeline_parallel=None,
+        tensor_rank=None,
+        pipeline_rank=None,
+        cp_rank=None,
+        expert_parallel=None,
+        expert_rank=None,
+        return_base_dir=True,
+        basename="model.pt",
+    ):
+        """Determine the directory name for this rank's checkpoint."""
+        # Use both the tensor and pipeline MP rank.
+        if pipeline_parallel is None:
+            pipeline_parallel = mpu.get_pipeline_model_parallel_world_size() > 1
+        if tensor_rank is None:
+            tensor_rank = mpu.get_tensor_model_parallel_rank()
+        if pipeline_rank is None:
+            pipeline_rank = mpu.get_pipeline_model_parallel_rank()
+        if cp_rank is None:
+            cp_rank = mpu.get_context_parallel_rank()
+        if expert_parallel is None:
+            expert_parallel = mpu.get_expert_model_parallel_world_size() > 1
+        if expert_rank is None:
+            expert_rank = mpu.get_expert_model_parallel_rank()
+
+        # Use both the tensor and pipeline MP rank. If using the distributed
+        # optimizer, then the optimizer's path must additionally include the
+        # data parallel rank.
+
+        # due to the fact that models are identical across cp ranks, cp rank is not used in the checkpoint path
+        if not pipeline_parallel:
+            common_path = os.path.join(checkpoints_path, f"mp_rank_{tensor_rank:02d}")
+        else:
+            common_path = os.path.join(checkpoints_path, f"mp_rank_{tensor_rank:02d}_{pipeline_rank:03d}")
+
+        if expert_parallel:
+            common_path = common_path + f"_{expert_rank:03d}"
+
+        os.makedirs(common_path, exist_ok=True)
+
+        if return_base_dir:
+            return common_path
+        return os.path.join(common_path, basename)
+
+    def generate_state_dict(
+        self, generate_model: bool = True, generate_optimizer: bool = True, generate_extra: bool = True
+    ):
+        # For save dist checkpointing
+        state_dict = {}
+
+        # Should always generate model state dict
+        # All ranks Save Model to reduce memory pressure
+        # Get sharded state dict, notice that state_dict will collect among dp groups, causing memory pressure
+        for vpp_rank, model in enumerate(self.model):
+            if len(self.model) > 1:
+                mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)
+                key = f"model{vpp_rank}" if len(self.model) > 1 else "model"
+            else:
+                key = "model"
+            if hasattr(model, "module"):
+                model = model.module
+            state_dict[key] = model.sharded_state_dict()
+
+        # Optimizer State Dict
+        if generate_optimizer:
+            torch.distributed.barrier()
+            optimizer_sharded_states = self.optimizer.sharded_state_dict(state_dict)
+            state_dict["optimizer"] = optimizer_sharded_states
+
+            if self.lr_scheduler is not None:
+                lr_state_dict = self.lr_scheduler.state_dict()
+                state_dict["lr_scheduler"] = lr_state_dict
+
+        if not generate_model:
+            state_dict.pop("model", None)
+
+        # RNG States State Dict
+        if generate_extra:
+            torch.distributed.barrier()
+            rng_state = self.get_rng_state()
+            state_dict["rng_state"] = rng_state
+
+        return state_dict
+
+    def load_rng_states(self, rng_states, data_parallel_random_init=False, use_dist_ckpt=True):
+        # access rng_state for data parallel rank
+        if data_parallel_random_init:
+            rng_states = rng_states[mpu.get_data_parallel_rank()]
+        else:
+            rng_states = rng_states[0]
+        random.setstate(rng_states["random_rng_state"])
+        np.random.set_state(rng_states["np_rng_state"])
+        torch.set_rng_state(rng_states["torch_rng_state"])
+
+        if get_device_name() != "cpu":
+            get_torch_device().set_rng_state(rng_states[f"{get_device_name()}_rng_state"])
+
+        # Check for empty states array
+        if not rng_states["rng_tracker_states"]:
+            raise KeyError
+        tensor_parallel.get_cuda_rng_tracker().set_states(rng_states["rng_tracker_states"])
+
+    def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load=False):
+        if local_path is not None:
+            assert os.path.exists(local_path), f"Checkpoint path {local_path} does not exist."
+
+        dist_checkpoint_path = get_dist_checkpoint_path(local_path)
+
+        # Get State Dict for loading
+        sharded_state_dict = self.generate_state_dict(
+            self.should_load_model and self.use_dist_checkpointing, self.should_load_optimizer, self.should_load_extra
+        )
+        log_with_rank(f"Generated state dict for loading: {sharded_state_dict.keys()}", rank=self.rank, logger=logger)
+
+        # Load Dist Checkpointing
+        state_dict = load_dist_checkpointing(
+            sharded_state_dict=sharded_state_dict,
+            ckpt_dir=dist_checkpoint_path,
+        )
+
+        if self.should_load_model and self.use_dist_checkpointing:
+            assert "model" in state_dict or any(
+                f"model{vpp_rank}" in state_dict for vpp_rank in range(len(self.model))
+            ), f"Model state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}."
+            for vpp_rank, model in enumerate(self.model):
+                if len(self.model) == 1:
+                    model_state_dict = state_dict["model"]
+                else:
+                    assert f"model{vpp_rank}" in state_dict, f"model{vpp_rank} not found in state_dict"
+                    model_state_dict = state_dict[f"model{vpp_rank}"]
+                mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)
+                self.model[vpp_rank].load_state_dict(model_state_dict)
+            log_with_rank(f"Loaded sharded model checkpoint from {local_path}", rank=self.rank, logger=logger)
+        elif self.should_load_model and self.use_hf_checkpoint:
+            hf_model_path = get_hf_model_checkpoint_path(local_path)
+            self.bridge.load_weights(self.model, hf_model_path)
+            log_with_rank(f"Loaded HF model checkpoint from {hf_model_path} with bridge", rank=self.rank, logger=logger)
+
+        if self.should_load_optimizer:
+            assert "optimizer" in state_dict, (
+                f"Optimizer state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}."
+            )
+            optimizer_state_dict = state_dict["optimizer"]
+            self.optimizer.load_state_dict(optimizer_state_dict)
+            log_with_rank(f"Loaded optimizer checkpoint from {local_path}", rank=self.rank, logger=logger)
+            if self.use_checkpoint_opt_param_scheduler:
+                assert "lr_scheduler" in state_dict, (
+                    f"LR scheduler state dict not found in {state_dict.keys()}. Please check the checkpoint file "
+                    f"{local_path}."
+                )
+                lr_scheduler_state_dict = state_dict["lr_scheduler"]
+                if self.lr_scheduler is not None:
+                    self.lr_scheduler.load_state_dict(lr_scheduler_state_dict)
+                    log_with_rank(f"Loaded LR scheduler checkpoint from {local_path}", rank=self.rank, logger=logger)
+
+        if self.should_load_extra:
+            assert "rng_state" in state_dict, (
+                f"RNG state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}."
+            )
+            rng_state = state_dict["rng_state"]
+            self.load_rng_states(rng_state)
+            log_with_rank(f"Loaded RNG states from {local_path}", rank=self.rank, logger=logger)
+
+        if del_local_after_load:
+            try:
+                os.remove(local_path) if is_non_local(local_path) else None
+            except Exception as e:
+                log_with_rank(
+                    f"remove local resume ckpt file after loading failed, exception {e} will be ignored",
+                    rank=self.rank,
+                    logger=logger,
+                )
+
+    def save_checkpoint(self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep=None):
+        # record the previous global step
+        self.previous_global_step = global_step
+
+        # remove previous local_path
+        if (
+            max_ckpt_to_keep
+            and isinstance(max_ckpt_to_keep, int)
+            and max_ckpt_to_keep > 0
+            and len(self.previous_saved_paths) >= max_ckpt_to_keep
+        ):
+            keep_start = len(self.previous_saved_paths) - max_ckpt_to_keep + 1
+            self.remove_previous_save_local_path(self.previous_saved_paths[:keep_start])
+            self.previous_saved_paths = self.previous_saved_paths[keep_start:]
+
+        local_path = local_mkdir_safe(local_path)
+        dist_checkpoint_path = get_dist_checkpoint_path(local_path)
+
+        # Note that model weights, optimizer states, and extra states are generated
+        # together in a state dict, we save them in one time
+        if self.use_dist_checkpointing:
+            # Generate state dict for saving
+            state_dict = self.generate_state_dict(
+                self.should_save_model, self.should_save_optimizer, self.should_save_extra
+            )
+            log_with_rank(f"Generated state dict for saving: {state_dict.keys()}", rank=self.rank, logger=logger)
+            for vpp_rank, model in enumerate(self.model):
+                if len(self.model) > 1:
+                    model_i_keys = state_dict[f"model{vpp_rank}"].keys()
+                    log_with_rank(f"Generated state dict for saving: {model_i_keys}", rank=self.rank, logger=logger)
+                else:
+                    log_with_rank(
+                        f"Generated state dict for saving: {state_dict['model'].keys()}", rank=self.rank, logger=logger
+                    )
+            # Start Async save if enabled
+            async_save_request = save_dist_checkpointing(
+                sharded_state_dict=state_dict,
+                ckpt_path=dist_checkpoint_path,
+                async_save=self.checkpoint_config.async_save,
+            )
+
+            # Synchronize all async save requests
+            if not self.checkpoint_config.async_save:
+                assert async_save_request is None, "Async save request should be None when not using async save."
+                torch.distributed.barrier()
+        else:
+            assert self.use_hf_checkpoint, "When not using distributed checkpointing, use_hf_checkpoint should be True."
+            # Generate optimizer and exra state dicts
+            state_dict = self.generate_state_dict(
+                generate_model=False,
+                generate_optimizer=self.should_save_optimizer,
+                generate_extra=self.should_save_extra,
+            )
+            # Save optimizer and extra states to local path
+            # Start Async save if enabled
+            async_save_request = save_dist_checkpointing(
+                sharded_state_dict=state_dict,
+                ckpt_path=dist_checkpoint_path,
+                async_save=self.checkpoint_config.async_save,
+            )
+
+            # Synchronize all async save requests
+            if not self.checkpoint_config.async_save:
+                assert async_save_request is None, "Async save request should be None when not using async save."
+                torch.distributed.barrier()
+
+        if self.should_save_model:
+            if self.use_hf_checkpoint:
+                # Use mbridge to save HF model checkpoint
+                log_with_rank(f"Saving HF model checkpoint to {local_path} with bridge", rank=self.rank, logger=logger)
+                hf_ckpt_path = get_hf_model_checkpoint_path(local_path)
+                self.bridge.save_weights(self.model, hf_ckpt_path)
+                log_with_rank(f"Saved bridge checkpoint to {hf_ckpt_path}", rank=self.rank, logger=logger)
+
+            # Only rank 0 saves the hf config and tokenizer to huggingface path
+            # No matter whether we save hf model or not
+            if self.rank == 0:
+                # Save tokenizer
+                hf_config_tokenizer_path = get_hf_model_checkpoint_path(local_path)
+                if self.processing_class is not None:
+                    self.processing_class.save_pretrained(hf_config_tokenizer_path)
+                # Save huggingface config
+                self.hf_config.save_pretrained(hf_config_tokenizer_path)
+                if hasattr(self.hf_config, "name_or_path") and self.hf_config.name_or_path:
+                    try:
+                        generation_config = GenerationConfig.from_pretrained(self.hf_config.name_or_path)
+                        generation_config.save_pretrained(hf_config_tokenizer_path)
+                    except Exception:
+                        # if the generation config isn't available, we don't save it
+                        pass
+                log_with_rank(
+                    f"Saved Huggingface config and tokenizer to {hf_config_tokenizer_path}",
+                    rank=self.rank,
+                    logger=logger,
+                    log_only_rank_0=True,
+                )
+
+        if self.should_save_extra:
+            if self.rank == 0:
+                # Save transformer config
+                print(self.transformer_config)
+                transformer_config_dict = asdict(self.transformer_config)
+                to_convert_types = {torch.dtype: str, AttnBackend: str}
+                ignore_types = [Callable]
+                pop_keys = []
+                for key, value in transformer_config_dict.items():
+                    if type(value) in to_convert_types:
+                        transformer_config_dict[key] = to_convert_types[type(value)](value)
+                    if type(value) in ignore_types:
+                        pop_keys.append(key)
+                    if callable(value):
+                        pop_keys.append(key)
+                for key in pop_keys:
+                    transformer_config_dict.pop(key)
+                transformer_config_path = get_transformer_config_checkpoint_path(local_path)
+                with open(transformer_config_path, "w") as f:
+                    json.dump(transformer_config_dict, f, indent=2)
+
+        if self.should_save_hf_model and not self.use_hf_checkpoint:
+            # wait for everyone to dump to local
+            if self.bridge is not None:
+                hf_model_ckpt_path = get_hf_model_checkpoint_path(local_path)
+                self.bridge.save_weights(self.model, hf_model_ckpt_path)
+            else:
+                state_dict = self.weight_saver(
+                    self.model,
+                    self.hf_config,
+                    dtype=self.param_dtype,
+                    is_value_model=self.is_value_model,
+                    tie_word_embeddings=self.share_embeddings_and_output_weights,
+                )
+
+                torch.distributed.barrier()
+                if self.rank == 0:
+                    hf_model_ckpt_path = get_hf_model_checkpoint_path(local_path)
+                    import warnings
+
+                    from accelerate import init_empty_weights
+
+                    with init_empty_weights(), warnings.catch_warnings():
+                        warnings.simplefilter("ignore")
+                        if "mistral7b-rm" in self.config.model.path:
+                            from transformers import MistralForSequenceClassification
+
+                            model = MistralForSequenceClassification.from_pretrained(
+                                self.config.model.path
+                            )  # use score head instead of lm_head
+                            state_dict["score.weight"] = state_dict["score.weight"]
+                        else:
+                            from transformers import AutoModelForCausalLM
+
+                            model = AutoModelForCausalLM.from_pretrained(self.config.model.path, torch_dtype="auto")
+                    model.save_pretrained(hf_model_ckpt_path, state_dict=state_dict)
+                    log_with_rank(
+                        f"Saved Huggingface config and tokenizer to {hf_model_ckpt_path}",
+                        rank=self.rank,
+                        logger=logger,
+                        log_only_rank_0=True,
+                    )
+
+                    if hdfs_path is not None:
+                        log_with_rank(
+                            f"Uploading checkpoint to {hdfs_path}", rank=self.rank, logger=logger, log_only_rank_0=True
+                        )
+                        from verl.utils import hdfs_io
+
+                        hdfs_io.makedirs(hdfs_path, exist_ok=True)
+                        hdfs_io.copy(src=hf_model_ckpt_path, dst=hdfs_path, dirs_exist_ok=True)
+                        log_with_rank(
+                            f"HDFS checkpoint uploaded to {hdfs_path}",
+                            rank=self.rank,
+                            logger=logger,
+                            log_only_rank_0=True,
+                        )
+
+        def finalize_save_fn():
+            # Rank 0 uploads checkpoint to HDFS if hdfs_path is provided
+            log_with_rank(
+                f"Dist checkpointing save completed for {dist_checkpoint_path}", rank=self.rank, logger=logger
+            )
+            if self.rank == 0:
+                if hdfs_path is not None:
+                    log_with_rank(f"Uploading checkpoint to {hdfs_path}", rank=self.rank, logger=logger)
+                    from verl.utils import hdfs_io
+
+                    hdfs_io.makedirs(hdfs_path, exist_ok=True)
+                    hdfs_io.copy(src=dist_checkpoint_path, dst=hdfs_path, dirs_exist_ok=True)
+                    hdfs_io.copy(src=hf_config_tokenizer_path, dst=hdfs_path, dirs_exist_ok=True)
+
+        if self.checkpoint_config.async_save:
+            assert async_save_request is not None, "Async save request should not be None when using async save."
+            async_save_request.add_finalize_fn(finalize_save_fn)
+        else:
+            finalize_save_fn()
+
+        self.previous_saved_paths.append(local_path)

verl/verl/utils/dataset/README.md

@@ -0,0 +1,16 @@
+# Dataset Format
+## RLHF dataset
+We combine all the data sources into a single parquet files. We directly organize the prompt into the chat format so that multi-turn chats can be easily incorporated. In the prompt, we may add instruction following texts to guide the model output the answers in a particular format so that we can extract the answers.
+
+Math problems
+```json
+{
+    "data_source": "openai/gsm8k",
+    "prompt": [{"role": "user", "content": "Natalia sold clips to 48 of her friends in April, and then she sold half as many clips in May. How many clips did Natalia sell altogether in April and May? Let's think step by step and output the final answer after \"####\""}],
+    "ability": "math",
+    "reward_model": {
+        "style": "rule",
+        "ground_truth": ["72"]
+    },
+}
+```

verl/verl/utils/dataset/__init__.py

@@ -0,0 +1,19 @@
+# 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 .rl_dataset import RLHFDataset
+from .rm_dataset import RMDataset
+from .sft_dataset import SFTDataset
+
+__all__ = ["RLHFDataset", "RMDataset", "SFTDataset"]

verl/verl/utils/dataset/dataset_utils.py

@@ -0,0 +1,70 @@
+# Copyright 2025 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 enum import Enum
+
+import torch
+
+
+class DatasetPadMode(str, Enum):
+    """Padding mode for dataset"""
+
+    RIGHT = "right"
+    LEFT_RIGHT = "left_right"
+    NO_PADDING = "no_padding"
+
+
+class SFTTensorCollator:
+    """
+    A custom collate_fn that handles batching of sequences.
+    1. for variable-length sequences, convert them into NestedTensors.
+    2. for fixed-length sequences, use default_collate.
+    """
+
+    def __init__(self, pad_mode: DatasetPadMode = DatasetPadMode.LEFT_RIGHT):
+        self.pad_mode = pad_mode
+
+    def __call__(self, batch: list[dict[str, any]]) -> dict[str, any]:
+        if self.pad_mode == DatasetPadMode.NO_PADDING:
+            return self.collate_variable_batch(batch)
+        elif self.pad_mode in [DatasetPadMode.RIGHT, DatasetPadMode.LEFT_RIGHT]:
+            from torch.utils.data import default_collate
+
+            return default_collate(batch)
+        else:
+            raise NotImplementedError(f"pad_mode {self.pad_mode} not implemented")
+
+    def collate_variable_batch(self, batch: list[dict[str, any]]) -> dict[str, any]:
+        """
+        Collates a list of samples into a single batch.
+
+        Args:
+            batch: A list of dictionary samples from the dataset.
+
+        Returns:
+            A dictionary representing the batched data, with variable-length
+            sequences converted to NestedTensors.
+        """
+
+        final_batch = {}
+
+        tensor_keys = [key for key in batch[0].keys() if isinstance(batch[0][key], torch.Tensor)]
+
+        # Handle tensor values by creating a NestedTensor.
+        for key in tensor_keys:
+            tensors = [item[key] for item in batch]
+            final_batch[key] = torch.nested.as_nested_tensor(tensors, layout=torch.jagged)
+
+        return final_batch

verl/verl/utils/dataset/multiturn_sft_dataset.py

@@ -0,0 +1,442 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2025 ModelBest Inc. 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.
+"""
+Multi-turn SFT dataset that supports training on conversation data with multiple turns
+"""
+
+import logging
+from typing import Any, Optional
+
+import numpy as np
+import pandas as pd
+import torch
+from omegaconf import ListConfig
+from torch.utils.data import Dataset
+from transformers import PreTrainedTokenizer
+
+from verl.utils import hf_tokenizer
+from verl.utils.dataset.dataset_utils import DatasetPadMode
+from verl.utils.fs import copy_local_path_from_hdfs
+from verl.utils.model import compute_position_id_with_mask
+from verl.utils.torch_functional import pad_sequence_to_length, postprocess_data
+
+
+def convert_nested_value_to_list_recursive(data_item):
+    if isinstance(data_item, dict):
+        return {k: convert_nested_value_to_list_recursive(v) for k, v in data_item.items()}
+    elif isinstance(data_item, list):
+        return [convert_nested_value_to_list_recursive(elem) for elem in data_item]
+    elif isinstance(data_item, np.ndarray):
+        # Convert to list, then recursively process the elements of the new list
+        return convert_nested_value_to_list_recursive(data_item.tolist())
+    else:
+        # Base case: item is already a primitive type (int, str, float, bool, etc.)
+        return data_item
+
+
+class MultiTurnSFTDataset(Dataset):
+    """
+    Dataset for multi-turn conversations where each assistant response should be trained
+    """
+
+    def __init__(self, parquet_files: str | list[str], tokenizer, config=None):
+        # Set defaults and extract parameters from config if provided
+        config = config or {}
+        self.pad_mode = config.get("pad_mode", "right")
+        assert self.pad_mode in ["right", "left_right", "no_padding"], (
+            f"Expect pad_mode to be 'right', 'left_right' or 'no_padding'. Got {self.pad_mode}"
+        )
+        self.truncation = config.get("truncation", "error")
+        # for right padding
+        self.max_length = config.get("max_length", 1024)
+        # for left right paddding to be consistent with RL
+        self.max_prompt_length = config.get("max_prompt_length", 512)
+        self.max_response_length = config.get("max_response_length", 512)
+        # Get messages_key from the new multiturn config structure
+        multiturn_config = config.get("multiturn", {})
+        self.messages_key = multiturn_config.get("messages_key", "messages")
+        self.tools_key = multiturn_config.get("tools_key", "tools")
+        self.enable_thinking_key = multiturn_config.get("enable_thinking_key", "enable_thinking")
+        self.apply_chat_template_kwargs = config.get("apply_chat_template_kwargs", {})
+        assert self.truncation in ["error", "left", "right"]
+
+        if not isinstance(parquet_files, list | ListConfig):
+            parquet_files = [parquet_files]
+
+        self.parquet_files = parquet_files
+        if isinstance(tokenizer, str):
+            tokenizer = hf_tokenizer(tokenizer)
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+        self._download()
+        self._read_files_and_process()
+
+    def _download(self):
+        for i, parquet_file in enumerate(self.parquet_files):
+            self.parquet_files[i] = copy_local_path_from_hdfs(parquet_file, verbose=True)
+
+    def _read_files_and_process(self):
+        def series_to_item(ls):
+            import numpy
+            import pandas
+
+            while isinstance(ls, pandas.core.series.Series | numpy.ndarray) and len(ls) == 1:
+                ls = ls[0]
+            return ls
+
+        dataframes = []
+        for parquet_file in self.parquet_files:
+            dataframe = pd.read_parquet(parquet_file)
+            dataframes.append(dataframe)
+        self.dataframe = pd.concat(dataframes)
+
+        # Extract messages list from dataframe
+        self.messages = self.dataframe[self.messages_key].apply(series_to_item).tolist()
+
+        # Extract tools list from dataframe
+        if self.tools_key in self.dataframe.columns:
+            self.tools = self.dataframe[self.tools_key].apply(convert_nested_value_to_list_recursive).tolist()
+        else:
+            self.tools = None
+        # Extract enable_thinking list from dataframe
+        if self.enable_thinking_key in self.dataframe.columns:
+            self.enable_thinking = self.dataframe[self.enable_thinking_key].tolist()
+        else:
+            self.enable_thinking = None
+
+    def __len__(self):
+        return len(self.messages)
+
+    def _process_message_tokens(
+        self,
+        messages: list[dict[str, Any]],
+        start_idx: int,
+        end_idx: int,
+        is_assistant: bool = False,
+        enable_thinking: Optional[bool] = None,
+        tools: Optional[list[dict[str, Any]]] = None,
+    ) -> tuple[list[int], list[int], list[int]]:
+        """
+        Process tokens for a single message or a group of messages.
+
+        Args:
+            messages: List of message dictionaries
+            start_idx: Start index in messages list
+            end_idx: End index in messages list
+            is_assistant: Whether this is an assistant message
+            enable_thinking: Whether to enable thinking mode
+
+        Returns:
+            Tuple of (tokens, loss_mask, attention_mask)
+        """
+        if start_idx > 0:
+            prev_applied_text = self.tokenizer.apply_chat_template(
+                messages[:start_idx],
+                tokenize=False,
+                add_generation_prompt=False,
+                enable_thinking=enable_thinking,
+                tools=tools,
+                **self.apply_chat_template_kwargs,
+            )
+            if is_assistant:
+                prev_applied_text_w_generation_prompt = self.tokenizer.apply_chat_template(
+                    messages[:start_idx],
+                    tokenize=False,
+                    add_generation_prompt=True,
+                    enable_thinking=enable_thinking,
+                    tools=tools,
+                    **self.apply_chat_template_kwargs,
+                )
+
+        else:
+            prev_applied_text = ""
+
+        cur_applied_text = self.tokenizer.apply_chat_template(
+            messages[:end_idx],
+            tokenize=False,
+            add_generation_prompt=False,
+            enable_thinking=enable_thinking,
+            tools=tools,
+            **self.apply_chat_template_kwargs,
+        )
+        # Get tokens for the current message only
+        if is_assistant:
+            generation_prompt_text = prev_applied_text_w_generation_prompt[len(prev_applied_text) :]
+            generation_prompt_tokens = self.tokenizer.encode(
+                generation_prompt_text,
+                add_special_tokens=False,
+            )
+            _message_tokens = self.tokenizer.encode(
+                cur_applied_text[len(prev_applied_text_w_generation_prompt) :],
+                add_special_tokens=False,
+            )
+            message_tokens = generation_prompt_tokens + _message_tokens
+            loss_mask = [0] * (len(generation_prompt_tokens)) + [1] * (
+                len(message_tokens) - len(generation_prompt_tokens)
+            )
+        else:
+            message_tokens = self.tokenizer.encode(
+                cur_applied_text[len(prev_applied_text) :],
+                add_special_tokens=False,
+            )
+            loss_mask = [0] * len(message_tokens)
+
+        attention_mask = [1] * len(message_tokens)
+
+        return message_tokens, loss_mask, attention_mask
+
+    def _validate_and_convert_tokens(
+        self,
+        full_tokens: torch.Tensor,
+        concat_tokens: list[int],
+        concat_loss_mask: list[int],
+        concat_attention_mask: list[int],
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        """
+        Validate tokenization and convert to tensors.
+
+        Args:
+            full_tokens: Full conversation tokens
+            concat_tokens: Concatenated tokens
+            concat_loss_mask: Concatenated loss mask
+            concat_attention_mask: Concatenated attention mask
+
+        Returns:
+            Tuple of (input_ids, loss_mask, attention_mask) as tensors
+        """
+        full_tokens_list = full_tokens.tolist()
+
+        if len(concat_tokens) != len(full_tokens_list) or not all(
+            a == b for a, b in zip(concat_tokens, full_tokens_list, strict=True)
+        ):
+            logging.warning(
+                f"Token mismatch detected! Full tokenization length: {len(full_tokens_list)}, Concatenated tokens "
+                f"length: {len(concat_tokens)}. Using concatenated version."
+                # f"full tokens text: {self.tokenizer.decode(full_tokens_list)}"
+                # f"concat tokens text: {self.tokenizer.decode(concat_tokens)}"
+            )
+            return (
+                torch.tensor(concat_tokens, dtype=torch.long),
+                torch.tensor(concat_loss_mask, dtype=torch.long),
+                torch.tensor(concat_attention_mask, dtype=torch.long),
+            )
+
+        return (
+            full_tokens,
+            torch.tensor(concat_loss_mask, dtype=torch.long),
+            torch.tensor(concat_attention_mask, dtype=torch.long),
+        )
+
+    def __getitem__(self, item):
+        tokenizer = self.tokenizer
+        messages = self.messages[item]
+        tools = self.tools[item] if self.tools is not None else None
+        enable_thinking = self.enable_thinking[item] if self.enable_thinking is not None else None
+
+        # First, get the full conversation tokens
+        try:
+            full_tokens = tokenizer.apply_chat_template(
+                messages,
+                tools=tools,
+                tokenize=True,
+                return_tensors="pt",
+                add_generation_prompt=False,
+                enable_thinking=enable_thinking,
+                **self.apply_chat_template_kwargs,
+            )
+        except Exception as e:
+            logging.error(
+                f"Error applying chat template: {e}\nMessages: {messages}\nTools: {tools}\nEnable thinking: "
+                f"{enable_thinking}"
+            )
+            raise
+
+        # Track concatenated tokens for validation
+        concat_tokens = []
+        concat_loss_mask = []
+        concat_attention_mask = []
+
+        i = 0
+        while i < len(messages):
+            cur_messages = messages[i]
+            if cur_messages["role"] == "assistant":
+                # Process assistant message
+                tokens, loss_mask, attention_mask = self._process_message_tokens(
+                    messages, i, i + 1, is_assistant=True, enable_thinking=enable_thinking, tools=tools
+                )
+                i += 1
+            elif cur_messages["role"] == "tool":
+                # Process consecutive tool messages
+                st = i
+                ed = i + 1
+                while ed < len(messages) and messages[ed]["role"] == "tool":
+                    ed += 1
+                tokens, loss_mask, attention_mask = self._process_message_tokens(
+                    messages, st, ed, enable_thinking=enable_thinking, tools=tools
+                )
+                i = ed
+            elif cur_messages["role"] in ["user", "system"]:
+                # Process user or system message
+                if cur_messages["role"] == "system" and i != 0:
+                    raise ValueError("System message should be the first message")
+                tokens, loss_mask, attention_mask = self._process_message_tokens(
+                    messages, i, i + 1, enable_thinking=enable_thinking, tools=tools
+                )
+                i += 1
+            else:
+                raise ValueError(f"Unknown role: {cur_messages['role']}")
+
+            # override loss mask with mask in the dataset to handle multi-turn conversation
+            override_loss_mask = cur_messages.get("loss_mask", None)
+            if override_loss_mask is not None:
+                if isinstance(override_loss_mask, np.ndarray):
+                    override_loss_mask = override_loss_mask.item()
+                assert isinstance(override_loss_mask, int), f"loss_mask should be int, got {type(override_loss_mask)}"
+                assert override_loss_mask in [0, 1], f"loss_mask should be 0 or 1, got {override_loss_mask}"
+                loss_mask = [override_loss_mask] * len(tokens)
+
+            concat_tokens.extend(tokens)
+            concat_loss_mask.extend(loss_mask)
+            concat_attention_mask.extend(attention_mask)
+
+        # Validate and convert tokens
+        input_ids, loss_mask, attention_mask = self._validate_and_convert_tokens(
+            full_tokens[0], concat_tokens, concat_loss_mask, concat_attention_mask
+        )
+
+        # encode prompt
+        if messages[0]["role"] == "system":
+            assert messages[1]["role"] == "user"
+            assert messages[2]["role"] == "assistant"
+            prompt_message_length = 2
+        elif messages[0]["role"] == "user":
+            assert messages[1]["role"] == "assistant"
+            prompt_message_length = 1
+        else:
+            raise ValueError(f"Unknown role: {messages[0]['role']}")
+
+        sequence_length = input_ids.shape[0]
+        # Handle sequence length
+        if self.pad_mode == DatasetPadMode.RIGHT:
+            if sequence_length < self.max_length:
+                # Pad sequences
+                pad_token_id = self.tokenizer.pad_token_id if self.tokenizer.pad_token_id is not None else 0
+                padded_input_ids = torch.full((self.max_length - sequence_length,), pad_token_id, dtype=input_ids.dtype)
+                padded_attention_mask = torch.zeros((self.max_length - sequence_length,), dtype=attention_mask.dtype)
+                padded_loss_mask = torch.zeros((self.max_length - sequence_length,), dtype=loss_mask.dtype)
+
+                input_ids = torch.cat((input_ids, padded_input_ids))
+                attention_mask = torch.cat((attention_mask, padded_attention_mask))
+                loss_mask = torch.cat((loss_mask, padded_loss_mask))
+            elif sequence_length > self.max_length:
+                if self.truncation == "left":
+                    input_ids = input_ids[-self.max_length :]
+                    attention_mask = attention_mask[-self.max_length :]
+                    loss_mask = loss_mask[-self.max_length :]
+                elif self.truncation == "right":
+                    input_ids = input_ids[: self.max_length]
+                    attention_mask = attention_mask[: self.max_length]
+                    loss_mask = loss_mask[: self.max_length]
+                elif self.truncation == "error":
+                    raise ValueError(f"{sequence_length=} is larger than {self.max_length=}")
+                else:
+                    raise ValueError(f"Unknown truncation method {self.truncation}")
+
+            # Create position IDs
+            position_ids = torch.arange(len(input_ids), dtype=torch.long)
+            # Zero out position IDs for padding
+            position_ids = position_ids * attention_mask
+
+            return {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "position_ids": position_ids,
+                "loss_mask": loss_mask,
+            }
+        elif self.pad_mode == DatasetPadMode.LEFT_RIGHT:
+            assert self.truncation == "error", "Only support error truncation for left_right pad mode"
+            prompt_str = self.tokenizer.apply_chat_template(
+                messages[:prompt_message_length],
+                tools=tools,
+                tokenize=False,
+                add_generation_prompt=True,
+                enable_thinking=enable_thinking,
+                **self.apply_chat_template_kwargs,
+            )
+            prompt_ids = self.tokenizer.encode(prompt_str, add_special_tokens=False)
+            prompt_length = len(prompt_ids)
+            prompt_ids = input_ids[:prompt_length].unsqueeze(0)
+            prompt_attention_mask = attention_mask[:prompt_length].unsqueeze(0)
+            prompt_loss_mask = loss_mask[:prompt_length].unsqueeze(0)
+            response_ids = input_ids[prompt_length:].unsqueeze(0)
+            response_attention_mask = attention_mask[prompt_length:].unsqueeze(0)
+            response_loss_mask = loss_mask[prompt_length:].unsqueeze(0)
+
+            assert prompt_loss_mask.sum().item() == 0
+
+            prompt_ids, prompt_attention_mask = postprocess_data(
+                input_ids=prompt_ids,
+                attention_mask=prompt_attention_mask,
+                max_length=self.max_prompt_length,
+                pad_token_id=self.tokenizer.pad_token_id,
+                left_pad=True,
+                truncation=self.truncation,
+            )
+
+            response_ids, response_attention_mask = postprocess_data(
+                input_ids=response_ids,
+                attention_mask=response_attention_mask,
+                max_length=self.max_response_length,
+                pad_token_id=self.tokenizer.pad_token_id,
+                left_pad=False,
+                truncation=self.truncation,
+            )
+            response_loss_mask = pad_sequence_to_length(
+                response_loss_mask, max_seq_len=self.max_response_length, pad_token_id=0, left_pad=False
+            )
+
+            prompt_ids = prompt_ids[0]
+            prompt_attention_mask = prompt_attention_mask[0]
+            response_ids = response_ids[0]
+            response_attention_mask = response_attention_mask[0]
+            response_loss_mask = response_loss_mask[0]
+
+            assert response_attention_mask[0].item() == 1
+            assert response_loss_mask[0].item() == 1
+
+            input_ids = torch.cat((prompt_ids, response_ids), dim=0)
+            attention_mask = torch.cat((prompt_attention_mask, response_attention_mask), dim=0)
+            position_ids = compute_position_id_with_mask(attention_mask)
+
+            return {
+                "input_ids": input_ids,
+                "attention_mask": attention_mask,
+                "position_ids": position_ids,
+                "responses": response_ids,
+                "response_mask": response_loss_mask,
+            }
+        elif self.pad_mode == DatasetPadMode.NO_PADDING:
+            # truncate input_ids if it is longer than max_length
+            if len(input_ids) > self.max_length:
+                input_ids = input_ids[: self.max_length]
+                loss_mask = loss_mask[: self.max_length]
+            # create position IDs
+            position_ids = torch.arange(len(input_ids), dtype=torch.long)
+            # return nested tensor with out padding
+            return {
+                "input_ids": input_ids,
+                "position_ids": position_ids,
+                "loss_mask": loss_mask,
+            }

verl/verl/utils/dataset/rl_dataset.py

@@ -0,0 +1,383 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright 2023-2024 SGLang Team
+# Copyright 2025 ModelBest Inc. 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 copy
+import logging
+import os
+import re
+from collections import defaultdict
+from typing import Optional
+
+import datasets
+import numpy as np
+import torch
+from omegaconf import DictConfig, ListConfig
+from torch.utils.data import Dataset
+from transformers import PreTrainedTokenizer, ProcessorMixin
+
+import verl.utils.torch_functional as verl_F
+from verl.utils.model import compute_position_id_with_mask
+
+logger = logging.getLogger(__name__)
+
+
+def collate_fn(data_list: list[dict]) -> dict:
+    """
+    Collate a batch of sample dicts into batched tensors and arrays.
+
+    Args:
+        data_list: List of dicts mapping feature names to torch.Tensor or other values.
+
+    Returns:
+        Dict where tensor entries are stacked into a torch.Tensor of shape
+        (batch_size, \*dims) and non-tensor entries are converted to
+        np.ndarray of dtype object with shape (batch_size,).
+    """
+    tensors = defaultdict(list)
+    non_tensors = defaultdict(list)
+
+    for data in data_list:
+        for key, val in data.items():
+            if isinstance(val, torch.Tensor):
+                tensors[key].append(val)
+            else:
+                non_tensors[key].append(val)
+
+    for key, val in tensors.items():
+        tensors[key] = torch.stack(val, dim=0)
+
+    for key, val in non_tensors.items():
+        non_tensors[key] = np.fromiter(val, dtype=object, count=len(val))
+
+    return {**tensors, **non_tensors}
+
+
+class RLHFDataset(Dataset):
+    """
+    Load and preprocess RLHF data from Parquet files.
+
+    - Caches files locally.
+    - Reads into a HuggingFace Dataset and tokenizes prompts.
+    - Optionally handles images/videos via a ProcessorMixin.
+    - Filters prompts over a max length.
+    - Supports resuming from checkpoints.
+
+    Args:
+        data_files (str or list): Path(s) to Parquet file(s).
+        tokenizer (PreTrainedTokenizer): For the tokenization of text to token IDs.
+        config (DictConfig): Options like cache_dir, prompt_key, max_prompt_length, truncation, etc.
+        processor (ProcessorMixin, optional): Multimodal preprocessor for images/videos.
+    """
+
+    def __init__(
+        self,
+        data_files: str | list[str],
+        tokenizer: PreTrainedTokenizer,
+        config: DictConfig,
+        processor: Optional[ProcessorMixin] = None,
+    ):
+        if not isinstance(data_files, list | ListConfig):
+            data_files = [data_files]
+
+        self.data_files = copy.deepcopy(data_files)
+        self.original_data_files = copy.deepcopy(data_files)  # use for resume
+        self.tokenizer = tokenizer
+        self.processor = processor
+        self.config = config
+
+        self.cache_dir = os.path.expanduser(config.get("cache_dir", "~/.cache/verl/rlhf"))
+        self.prompt_key = config.get("prompt_key", "prompt")
+        self.image_key = config.get("image_key", "images")
+        self.video_key = config.get("video_key", "videos")
+        self.max_prompt_length = config.get("max_prompt_length", 1024)
+        self.return_raw_chat = config.get("return_raw_chat", False)
+        self.return_full_prompt = config.get("return_full_prompt", False)
+        self.truncation = config.get("truncation", "error")
+        self.filter_overlong_prompts = config.get("filter_overlong_prompts", True)
+        self.apply_chat_template_kwargs = config.get("apply_chat_template_kwargs", {})
+
+        self.num_workers = config.get("filter_overlong_prompts_workers", max(1, os.cpu_count() // 4))
+        self.num_workers = min(self.num_workers, os.cpu_count())
+        self.use_shm = config.get("use_shm", False)
+        self.chat_template_func = config.get("chat_template_func", None)
+        self.need_tools_kwargs = config.get("need_tools_kwargs", False)
+        self.filter_prompts = config.get("filter_prompts", True)
+        self.serialize_dataset = False
+        self.return_multi_modal_inputs = config.get("return_multi_modal_inputs", True)
+
+        self._download()
+        self._read_files_and_tokenize()
+
+    def _download(self, use_origin_parquet=False):
+        from verl.utils.fs import copy_to_local
+
+        data_files = self.data_files if not use_origin_parquet else self.original_data_files
+        for i, parquet_file in enumerate(data_files):
+            self.data_files[i] = copy_to_local(src=parquet_file, cache_dir=self.cache_dir, use_shm=self.use_shm)
+
+    def _read_files_and_tokenize(self):
+        dataframes = []
+        for parquet_file in self.data_files:
+            # read parquet files and cache
+            dataframe = datasets.load_dataset("parquet", data_files=parquet_file)["train"]
+            dataframes.append(dataframe)
+        self.dataframe: datasets.Dataset = datasets.concatenate_datasets(dataframes)
+
+        print(f"dataset len: {len(self.dataframe)}")
+
+        self.dataframe = self.maybe_filter_out_long_prompts(self.dataframe)
+
+    def maybe_filter_out_long_prompts(self, dataframe: datasets.Dataset = None):
+        # filter out too long prompts
+        if self.filter_overlong_prompts:
+            tokenizer = self.tokenizer
+            processor = self.processor
+            prompt_key = self.prompt_key
+            image_key = self.image_key
+            video_key = self.video_key
+
+            if processor is not None:
+                from verl.utils.dataset.vision_utils import process_image, process_video
+
+                def doc2len(doc) -> int:
+                    messages = self._build_messages(doc)
+                    raw_prompt = self.processor.apply_chat_template(
+                        messages, add_generation_prompt=True, tokenize=False, **self.apply_chat_template_kwargs
+                    )
+                    images = (
+                        [process_image(image) for image in doc[image_key]]
+                        if image_key in doc and doc[image_key]
+                        else None
+                    )
+                    videos = (
+                        [process_video(video) for video in doc[video_key]]
+                        if video_key in doc and doc[video_key]
+                        else None
+                    )
+
+                    return len(processor(text=[raw_prompt], images=images, videos=videos)["input_ids"][0])
+
+            else:
+
+                def doc2len(doc) -> int:
+                    return len(
+                        tokenizer.apply_chat_template(
+                            doc[prompt_key], add_generation_prompt=True, **self.apply_chat_template_kwargs
+                        )
+                    )
+
+            dataframe = dataframe.filter(
+                lambda doc: doc2len(doc) <= self.max_prompt_length,
+                num_proc=self.num_workers,
+                desc=f"Filtering prompts longer than {self.max_prompt_length} tokens",
+            )
+
+            print(f"filter dataset len: {len(dataframe)}")
+        return dataframe
+
+    def resume_dataset_state(self):
+        self.serialize_dataset = not hasattr(self, "original_data_files")
+        # resume dataframe if not it's serialized in data.pt
+        if not self.serialize_dataset:
+            self._download(use_origin_parquet=True)  # download and resume from original parquet files
+            self._read_files_and_tokenize()
+        else:
+            print(r"old dataloader ckpt file is used, please train from scratch for better ckpt performance")
+
+    def __len__(self):
+        return len(self.dataframe)
+
+    def _build_messages(self, example: dict):
+        messages: list = example.pop(self.prompt_key)
+
+        if self.image_key in example or self.video_key in example:
+            for message in messages:
+                content = message["content"]
+                content_list = []
+                segments = re.split("(<image>|<video>)", content)
+                segments = [item for item in segments if item != ""]
+                for segment in segments:
+                    if segment == "<image>":
+                        content_list.append({"type": "image"})
+                    elif segment == "<video>":
+                        content_list.append({"type": "video"})
+                    else:
+                        content_list.append({"type": "text", "text": segment})
+
+                message["content"] = content_list
+
+        return messages
+
+    def __getitem__(self, item):
+        """
+        Note that we also return the raw_input_ids so that it can be combined with other chat template
+        """
+        row_dict: dict = self.dataframe[item]
+        messages = self._build_messages(row_dict)
+        model_inputs = {}
+
+        if self.processor is not None:
+            from verl.utils.dataset.vision_utils import process_image, process_video
+
+            raw_prompt = self.processor.apply_chat_template(
+                messages, add_generation_prompt=True, tokenize=False, **self.apply_chat_template_kwargs
+            )
+            multi_modal_data = {}
+
+            images = None
+            row_dict_images = row_dict.pop(self.image_key, None)
+            if row_dict_images:
+                images = [process_image(image) for image in row_dict_images]
+
+                # due to the image key is "image" instead of "images" in vllm, we need to use "image" here
+                # link: https://github.com/vllm-project/vllm/blob/3c545c0c3b98ee642373a308197d750d0e449403/vllm/multimodal/parse.py#L205
+                multi_modal_data["image"] = images
+
+            videos = None
+            row_dict_videos = row_dict.pop(self.video_key, None)
+            if row_dict_videos:
+                videos = [process_video(video) for video in row_dict_videos]
+
+                # due to the video key is "video" instead of "videos" in vllm, we need to use "video" here
+                # link: https://github.com/vllm-project/vllm/blob/3c545c0c3b98ee642373a308197d750d0e449403/vllm/multimodal/parse.py#L205
+                multi_modal_data["video"] = [video.numpy() for video in videos]
+
+            model_inputs = self.processor(text=[raw_prompt], images=images, videos=videos, return_tensors="pt")
+
+            input_ids = model_inputs.pop("input_ids")
+            attention_mask = model_inputs.pop("attention_mask")
+
+            if "second_per_grid_ts" in model_inputs:
+                model_inputs.pop("second_per_grid_ts")
+
+            # There's a trap here, multi_modal_inputs has to be a dict, not BatchFeature
+            row_dict["multi_modal_data"] = multi_modal_data
+
+            # We will do batch.union() in the trainer,
+            # so we cannot have "multi_modal_inputs" in row_dict if rollout generates new multi_modal_inputs
+            if self.return_multi_modal_inputs:
+                row_dict["multi_modal_inputs"] = dict(model_inputs)
+
+                # second_per_grid_ts isn't used for training, just for mrope
+                row_dict["multi_modal_inputs"].pop("second_per_grid_ts", None)
+
+        else:
+            if self.apply_chat_template_kwargs.get("chat_template") is None:
+                assert hasattr(self.tokenizer, "chat_template"), (
+                    "chat_template should be provided in apply_chat_template_kwargs or tokenizer config, "
+                    "models like GLM can copy chat_template.jinja from instruct models"
+                )
+            raw_prompt = self.tokenizer.apply_chat_template(
+                messages, add_generation_prompt=True, tokenize=False, **self.apply_chat_template_kwargs
+            )
+            model_inputs = self.tokenizer(raw_prompt, return_tensors="pt", add_special_tokens=False)
+            input_ids = model_inputs.pop("input_ids")
+            attention_mask = model_inputs.pop("attention_mask")
+
+        input_ids, attention_mask = verl_F.postprocess_data(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            max_length=self.max_prompt_length,
+            pad_token_id=self.tokenizer.pad_token_id,
+            left_pad=True,
+            truncation=self.truncation,
+        )
+
+        if self.processor is not None and "Qwen2VLImageProcessor" in self.processor.image_processor.__class__.__name__:
+            # qwen-vl mrope
+            if "Qwen3VLProcessor" in self.processor.__class__.__name__:
+                from verl.models.transformers.qwen3_vl import get_rope_index
+            else:
+                from verl.models.transformers.qwen2_vl import get_rope_index
+
+            vision_position_ids = get_rope_index(
+                self.processor,
+                input_ids=input_ids[0],
+                image_grid_thw=model_inputs.get("image_grid_thw"),
+                video_grid_thw=model_inputs.get("video_grid_thw"),
+                second_per_grid_ts=model_inputs.get("second_per_grid_ts"),
+                attention_mask=attention_mask[0],
+            )  # (3, seq_length)
+            valid_mask = attention_mask[0].bool()
+            text_position_ids = torch.ones((1, len(input_ids[0])), dtype=torch.long)
+            text_position_ids[0, valid_mask] = torch.arange(valid_mask.sum().item())
+            position_ids = [torch.cat((text_position_ids, vision_position_ids), dim=0)]  # (1, 4, seq_length)
+        elif self.processor is not None and "Glm4vImageProcessor" in self.processor.image_processor.__class__.__name__:
+            from verl.models.transformers.glm4v import get_rope_index
+
+            vision_position_ids = get_rope_index(
+                self.processor,
+                input_ids=input_ids[0],
+                image_grid_thw=model_inputs.get("image_grid_thw"),
+                video_grid_thw=model_inputs.get("video_grid_thw"),
+                attention_mask=attention_mask[0],
+            )  # (3, seq_length)
+            valid_mask = attention_mask[0].bool()
+            text_position_ids = torch.ones((1, len(input_ids[0])), dtype=torch.long)
+            text_position_ids[0, valid_mask] = torch.arange(valid_mask.sum().item())
+            position_ids = [torch.cat((text_position_ids, vision_position_ids), dim=0)]  # (1, 4, seq_length)
+        else:
+            position_ids = compute_position_id_with_mask(attention_mask)
+
+        row_dict["input_ids"] = input_ids[0]
+        row_dict["attention_mask"] = attention_mask[0]
+        row_dict["position_ids"] = position_ids[0]
+
+        raw_prompt_ids = self.tokenizer.encode(raw_prompt, add_special_tokens=False)
+        if len(raw_prompt_ids) > self.max_prompt_length:
+            if self.truncation == "left":
+                raw_prompt_ids = raw_prompt_ids[-self.max_prompt_length :]
+            elif self.truncation == "right":
+                raw_prompt_ids = raw_prompt_ids[: self.max_prompt_length]
+            elif self.truncation == "middle":
+                left_half = self.max_prompt_length // 2
+                right_half = self.max_prompt_length - left_half
+                raw_prompt_ids = raw_prompt_ids[:left_half] + raw_prompt_ids[-right_half:]
+            elif self.truncation == "error":
+                raise RuntimeError(f"Prompt length {len(raw_prompt_ids)} is longer than {self.max_prompt_length}.")
+
+        row_dict["raw_prompt_ids"] = raw_prompt_ids
+        # encode prompts without chat template
+        if self.return_raw_chat:
+            row_dict["raw_prompt"] = messages
+
+        # get prompts with chat template
+        if self.return_full_prompt:
+            row_dict["full_prompts"] = raw_prompt  # array of strings
+
+        # add index for each prompt
+        if "extra_info" not in row_dict or row_dict["extra_info"] is None:
+            row_dict["extra_info"] = dict()
+        index = row_dict.get("extra_info", {}).get("index", 0)
+        tools_kwargs = row_dict.get("extra_info", {}).get("tools_kwargs", {})
+        interaction_kwargs = row_dict.get("extra_info", {}).get("interaction_kwargs", {})
+        need_tools_kwargs = row_dict.get("extra_info", {}).get("need_tools_kwargs", self.need_tools_kwargs)
+        if need_tools_kwargs and not tools_kwargs:
+            logger.warning("tools_kwargs is empty for index {}, data source: {}", index, row_dict["data_source"])
+        row_dict["index"] = index
+        row_dict["tools_kwargs"] = tools_kwargs
+        row_dict["interaction_kwargs"] = interaction_kwargs
+        return row_dict
+
+    def __getstate__(self):
+        if not self.serialize_dataset:
+            state = self.__dict__.copy()
+
+            if "dataframe" in state:
+                del state["dataframe"]
+            return state
+
+        return self.__dict__.copy()

verl/verl/utils/dataset/rm_dataset.py

@@ -0,0 +1,144 @@
+# 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 pandas as pd
+import torch
+from torch.utils.data import Dataset
+
+from verl.utils import hf_tokenizer
+
+
+def download_files_distributed(download_fn):
+    import torch.distributed
+
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            # download files
+            download_fn()
+
+        torch.distributed.barrier()
+    else:
+        # download anyway
+        download_fn()
+
+
+class RMDataset(Dataset):
+    def __init__(
+        self,
+        parquet_files: str | list[str],
+        tokenizer,
+        prompt_key="prompt",
+        chosen_key="chosen",
+        rejected_key="rejected",
+        max_length=1024,
+        add_eos=True,
+        cache_dir="~/.cache/verl/rm",
+    ):
+        if not isinstance(parquet_files, list):
+            parquet_files = [parquet_files]
+
+        self.parquet_files = parquet_files
+        self.cache_dir = os.path.expanduser(cache_dir)
+        if isinstance(tokenizer, str):
+            tokenizer = hf_tokenizer(tokenizer)
+        self.tokenizer = tokenizer
+
+        self.prompt_key = prompt_key
+        self.chosen_key = chosen_key
+        self.rejected_key = rejected_key
+
+        self.add_eos = add_eos
+        self.max_length = max_length
+
+        self._download()
+        self._read_files_and_tokenize()
+
+    def _download(self):
+        def _download_files():
+            from verl.utils.fs import copy, is_non_local
+
+            os.makedirs(self.cache_dir, exist_ok=True)
+            assert os.path.exists(self.cache_dir)
+            for i, parquet_file in enumerate(self.parquet_files):
+                if is_non_local(parquet_file):
+                    dst = os.path.join(self.cache_dir, os.path.basename(parquet_file))
+                    if not os.path.exists(dst):
+                        copy(src=parquet_file, dst=dst)
+                    self.parquet_files[i] = dst
+
+        download_files_distributed(_download_files)
+
+    def _read_files_and_tokenize(self):
+        dataframes = []
+        for parquet_file in self.parquet_files:
+            # read parquet files and cache
+            dataframe = pd.read_parquet(parquet_file)
+            dataframes.append(dataframe)
+        self.dataframe = pd.concat(dataframes)
+        self.prompts = self.dataframe[self.prompt_key].tolist()
+        self.chosen_responses = self.dataframe[self.chosen_key].tolist()
+        self.rejected_responses = self.dataframe[self.rejected_key].tolist()
+
+    def __len__(self):
+        return len(self.prompts)
+
+    def _pad_to_length(self, input_ids, attention_mask):
+        curr_length = input_ids.shape[-1]
+
+        if curr_length < self.max_length:
+            input_ids = torch.cat(
+                (input_ids, torch.zeros(size=(self.max_length - curr_length,), dtype=input_ids.dtype)), dim=-1
+            )
+            attention_mask = torch.cat(
+                (attention_mask, torch.zeros(size=(self.max_length - curr_length,), dtype=attention_mask.dtype)), dim=-1
+            )
+        elif curr_length > self.max_length:
+            input_ids = input_ids[: self.max_length]
+            attention_mask = attention_mask[: self.max_length]
+
+        return input_ids, attention_mask
+
+    def __getitem__(self, item):
+        prompt = self.prompts[item]
+        chosen_response = self.chosen_responses[item]
+        rejected_response = self.rejected_responses[item]
+
+        prompt_ids = self.tokenizer(prompt, return_tensors="pt")["input_ids"][0]
+        chosen_response_ids = self.tokenizer(chosen_response, return_tensors="pt")["input_ids"][0]
+        rejected_response_ids = self.tokenizer(rejected_response, return_tensors="pt")["input_ids"][0]
+
+        if self.add_eos:
+            chosen_response_ids = torch.cat((chosen_response_ids, torch.tensor([self.tokenizer.eos_token_id])), dim=-1)
+            rejected_response_ids = torch.cat(
+                (rejected_response_ids, torch.tensor([self.tokenizer.eos_token_id])), dim=-1
+            )
+
+        chosen_input_ids = torch.cat((prompt_ids, chosen_response_ids), dim=-1)
+        chosen_attention_mask = torch.ones_like(chosen_input_ids)
+
+        rejected_input_ids = torch.cat((prompt_ids, rejected_response_ids), dim=-1)
+        rejected_attention_mask = torch.ones_like(rejected_input_ids)
+
+        chosen_input_ids, chosen_attention_mask = self._pad_to_length(chosen_input_ids, chosen_attention_mask)
+        rejected_input_ids, rejected_attention_mask = self._pad_to_length(rejected_input_ids, rejected_attention_mask)
+
+        input_ids = torch.stack((chosen_input_ids, rejected_input_ids), dim=0)
+        attention_mask = torch.stack((chosen_attention_mask, rejected_attention_mask), dim=0)
+
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+        }

verl/verl/utils/dataset/sft_dataset.py

@@ -0,0 +1,186 @@
+# 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.
+"""
+SFT dataset
+- We assume user pass a single parquet file.
+- We load all the data into the memory.
+Each parquet file contains
+"""
+
+import pandas as pd
+import torch
+from omegaconf.listconfig import ListConfig
+from torch.utils.data import Dataset
+from transformers import PreTrainedTokenizer
+
+from verl.utils import hf_tokenizer
+from verl.utils.fs import copy_to_local
+from verl.utils.model import compute_position_id_with_mask
+
+
+class SFTDataset(Dataset):
+    """
+    This is an in-memory SFTDataset
+
+    Arguments:
+        config (OmegaConf): the data config
+    """
+
+    def __init__(self, parquet_files: str | ListConfig, tokenizer, config):
+        prompt_key = config.get("prompt_key", "prompt")
+        prompt_dict_keys = config.get("prompt_dict_keys", None)
+        response_key = config.get("response_key", "response")
+        response_dict_keys = config.get("response_dict_keys", None)
+        max_length = config.get("max_length", 1024)
+        truncation = config.get("truncation", "error")
+        use_shm = config.get("use_shm", False)
+        self.apply_chat_template_kwargs = config.get("apply_chat_template_kwargs", {})
+
+        assert truncation in ["error", "left", "right"]
+        self.truncation = truncation
+        self.use_shm = use_shm
+
+        if not isinstance(parquet_files, ListConfig):
+            parquet_files = [parquet_files]
+
+        self.parquet_files = parquet_files
+        if isinstance(tokenizer, str):
+            tokenizer = hf_tokenizer(tokenizer)
+        self.tokenizer: PreTrainedTokenizer = tokenizer
+
+        self.prompt_key = prompt_key if isinstance(prompt_key, tuple | list) else [prompt_key]
+        self.response_key = response_key if isinstance(response_key, tuple | list) else [response_key]
+        self.prompt_dict_keys = prompt_dict_keys if prompt_dict_keys else []
+        self.response_dict_keys = response_dict_keys if response_dict_keys else []
+
+        self.max_length = max_length
+
+        self._download()
+        self._read_files_and_tokenize()
+
+    def _download(self):
+        for i, parquet_file in enumerate(self.parquet_files):
+            self.parquet_files[i] = copy_to_local(parquet_file, verbose=True, use_shm=self.use_shm)
+
+    def _read_files_and_tokenize(self):
+        def series_to_item(ls):
+            import numpy
+            import pandas
+
+            while isinstance(ls, pandas.core.series.Series | numpy.ndarray) and len(ls) == 1:
+                ls = ls[0]
+            return ls
+
+        dataframes = []
+        for parquet_file in self.parquet_files:
+            # read parquet files and cache
+            dataframe = pd.read_parquet(parquet_file)
+            dataframes.append(dataframe)
+        self.dataframe = pd.concat(dataframes)
+        self.prompts = self.dataframe[self.prompt_key]
+        for key in self.prompt_dict_keys:
+            # type(x): pandas.core.series.Series
+            # type(x[0]): numpy.ndarray
+            # type(x[0][0]): dict
+            try:
+                self.prompts = self.prompts.apply(lambda x: series_to_item(x)[key], axis=1)  # noqa: B023
+            except Exception:
+                print(f"self.prompts={self.prompts}")
+                raise
+        if isinstance(self.prompts, pd.DataFrame):
+            self.prompts = self.prompts.squeeze()
+        self.prompts = self.prompts.tolist()
+        self.responses = self.dataframe[self.response_key]
+        for key in self.response_dict_keys:
+            try:
+                self.responses = self.responses.apply(lambda x: series_to_item(x)[key], axis=1)  # noqa: B023
+            except Exception:
+                print(f"self.responses={self.responses}")
+                raise
+        if isinstance(self.responses, pd.DataFrame):
+            self.responses = self.responses.squeeze()
+        self.responses = self.responses.tolist()
+
+    def __len__(self):
+        return len(self.prompts)
+
+    def __getitem__(self, item):
+        tokenizer = self.tokenizer
+
+        prompt = self.prompts[item]
+        response = self.responses[item]
+
+        # apply chat template
+        prompt_chat = [{"role": "user", "content": prompt}]
+
+        # string
+        prompt_chat_str = tokenizer.apply_chat_template(
+            prompt_chat, add_generation_prompt=True, tokenize=False, **self.apply_chat_template_kwargs
+        )
+        response_chat_str = response + tokenizer.eos_token
+
+        # tokenize
+        prompt_ids_output = tokenizer(prompt_chat_str, return_tensors="pt", add_special_tokens=False)
+        prompt_ids = prompt_ids_output["input_ids"][0]
+        prompt_attention_mask = prompt_ids_output["attention_mask"][0]
+
+        response_ids_output = tokenizer(response_chat_str, return_tensors="pt", add_special_tokens=False)
+        response_ids = response_ids_output["input_ids"][0]
+        response_attention_mask = response_ids_output["attention_mask"][0]
+
+        prompt_length = prompt_ids.shape[0]
+        response_length = response_ids.shape[0]
+
+        input_ids = torch.cat((prompt_ids, response_ids), dim=-1)
+        attention_mask = torch.cat((prompt_attention_mask, response_attention_mask), dim=-1)
+
+        # padding to max length
+        sequence_length = input_ids.shape[0]
+        if sequence_length < self.max_length:
+            padded_input_ids = (
+                torch.ones(size=(self.max_length - sequence_length,), dtype=input_ids.dtype)
+                * self.tokenizer.pad_token_id
+            )
+            padded_attention_mask = torch.zeros(size=(self.max_length - sequence_length,), dtype=attention_mask.dtype)
+
+            input_ids = torch.cat((input_ids, padded_input_ids))
+            attention_mask = torch.cat((attention_mask, padded_attention_mask))
+        elif sequence_length > self.max_length:
+            if self.truncation == "left":
+                # actually, left truncation may not be reasonable
+                input_ids = input_ids[-self.max_length :]
+                attention_mask = attention_mask[-self.max_length :]
+            elif self.truncation == "right":
+                input_ids = input_ids[: self.max_length]
+                attention_mask = attention_mask[: self.max_length]
+            elif self.truncation == "error":
+                raise NotImplementedError(f"{sequence_length=} is larger than {self.max_length=}")
+            else:
+                raise NotImplementedError(f"Unknown truncation method {self.truncation}")
+
+        position_ids = compute_position_id_with_mask(attention_mask)
+
+        loss_mask = attention_mask.clone()
+        if prompt_length > 1:
+            # mask out prompt for SFT.
+            loss_mask[: min(prompt_length, loss_mask.size(0)) - 1] = 0
+        # mask out the last token in response
+        loss_mask[min(prompt_length + response_length, loss_mask.size(0)) - 1] = 0
+
+        return {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "position_ids": position_ids,
+            "loss_mask": loss_mask,
+        }

verl/verl/utils/dataset/vision_utils.py

@@ -0,0 +1,117 @@
+# 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 io import BytesIO
+from typing import Optional
+
+import torch
+from PIL import Image
+from qwen_vl_utils import fetch_image, fetch_video
+
+
+def process_image(image: dict | Image.Image) -> Image.Image:
+    if isinstance(image, Image.Image):
+        return image.convert("RGB")
+
+    if "bytes" in image:
+        assert "image" not in image, "Cannot have both `bytes` and `image`"
+        image["image"] = Image.open(BytesIO(image["bytes"]))
+
+    return fetch_image(image)
+
+
+VIDEO_FORMAT_HELP = """Currently, we only support the video formats introduced in qwen2-vl.
+Refer to https://github.com/QwenLM/Qwen2.5-VL?tab=readme-ov-file#using---transformers-to-chat.
+
+eg.
+{
+    "type": "video",
+    "video": [
+        "file:///path/to/frame1.jpg",
+        "file:///path/to/frame2.jpg"
+    ]
+}
+
+{
+    "type": "video",
+    "video": "file:///path/to/video.mp4"
+}
+# Defaults to fps=2, min_frames=4, max_frames=768
+
+{
+    "type": "video",
+    "video": "file:///path/to/video.mp4",
+    "fps": 2,
+    "min_frames": 1,
+    "max_frames": 32
+}
+"""
+
+
+def process_video(
+    video: dict,
+    nframes: Optional[int] = None,
+    fps: Optional[float] = None,
+    fps_min_frames: Optional[int] = None,
+    fps_max_frames: Optional[int] = None,
+) -> torch.Tensor:
+    """Converts a video dict into a [n_frames, 3, H, W] tensor
+
+    Add video sample FPS in a future MR
+    """
+
+    if not isinstance(video, dict) or "video" not in video:
+        raise NotImplementedError(VIDEO_FORMAT_HELP)
+    assert nframes is None or fps is None, "Can't use both `nframes` or `fps`"
+
+    # Shallow copy... since we might want to add some keys
+    video = dict(video)
+
+    contains_sampling_rules = "nframes" in video or "fps" in video
+    if not contains_sampling_rules:
+        if nframes is not None:
+            video["nframes"] = nframes
+        elif fps is not None:
+            video["fps"] = fps
+            if fps_min_frames is not None:
+                video["min_frames"] = fps_min_frames
+            if fps_max_frames is not None:
+                video["max_frames"] = fps_max_frames
+
+    return fetch_video(video)
+
+
+def process_multi_modal_inputs_for_minicpmo(input_ids, attention_mask, position_ids, cu_seqlens, multi_modal_inputs):
+    # Adjust image bounds based on left padding and cumulative sequence lengths
+    # This is necessary for MiniCPM-o's vision-language alignment
+    left_padding_length = torch.argmax(attention_mask, dim=1)
+    image_bounds = []
+    for i in range(len(multi_modal_inputs["image_bound"])):
+        image_bound = (
+            multi_modal_inputs["image_bound"][i].to(left_padding_length.device) - left_padding_length[i] + cu_seqlens[i]
+        )
+        image_bounds.append(image_bound)
+
+    # Flatten pixel values list for MiniCPM-o processing
+    pixel_values = []
+    for i in range(len(multi_modal_inputs["pixel_values"])):
+        pixel_values.extend([p for p in multi_modal_inputs["pixel_values"][i]])
+
+    multi_modal_inputs["pixel_values"] = [pixel_values]
+    multi_modal_inputs["image_bound"] = [torch.vstack(image_bounds)]
+    multi_modal_inputs["tgt_sizes"] = [torch.vstack(multi_modal_inputs["tgt_sizes"])]
+    multi_modal_inputs["input_ids"] = input_ids
+    multi_modal_inputs["attention_mask"] = attention_mask
+    multi_modal_inputs["position_ids"] = position_ids
+    return {"data": multi_modal_inputs}

verl/verl/utils/debug/__init__.py

@@ -0,0 +1,17 @@
+# 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.
+
+# APIs kept for backward compatibility purpose
+# For new features please develop in verl/utils/profiler/
+from ..profiler import *  # noqa

verl/verl/utils/debug/metrics.py

@@ -0,0 +1,109 @@
+# Copyright 2025 Individual Contributor: TomQunChaoA
+# 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 logging
+
+import torch
+
+from verl.protocol import DataProto
+
+logger = logging.getLogger(__file__)
+
+
+def calculate_token_list_diff(tensor1: torch.Tensor, tensor2: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+    # verify inputs
+    if tensor1.numel() == 0 or tensor2.numel() == 0:
+        return torch.zeros(tensor1.shape[0], dtype=torch.long, device=tensor1.device)
+    if tensor1.shape != tensor2.shape or mask.shape != tensor1.shape or mask.shape != tensor2.shape:
+        print(
+            f"<WARN> dim of tensor1, tensor2, mask is not equal, {(tensor1.shape)=},{(tensor2.shape)=}, {(mask.shape)=}"
+        )
+        return torch.ones_like(tensor1)
+    # transfer to same device
+    if tensor2.device != tensor1.device:
+        tensor2 = tensor2.to(tensor1.device)
+    if mask.device != tensor1.device:
+        mask = mask.to(tensor1.device)
+
+    # calculate diff
+    diff_mask = tensor1 != tensor2
+
+    valid_diff_mask = diff_mask & (mask == 1)
+
+    diff_counts = valid_diff_mask.sum(dim=1)
+
+    return diff_counts
+
+
+def pearson_correlation_coefficient(tensor1: torch.Tensor, tensor2: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+    # implemention of https://arxiv.org/pdf/2506.13585
+    if tensor1.shape != tensor2.shape or mask.shape != tensor1.shape or mask.shape != tensor2.shape:
+        return 0
+    mt1 = torch.masked_select(tensor1, mask)
+    mt2 = torch.masked_select(tensor2, mask)
+    result = torch.corrcoef(torch.stack([mt1, mt2], dim=0))
+    return result[0][1].detach().item()
+
+
+def calculate_log_prob_diff(log_probs1: torch.Tensor, log_probs2: torch.Tensor, mask: torch.Tensor) -> torch.Tensor:
+    full_diff = torch.abs(log_probs1 - log_probs2)
+    return torch.masked_select(full_diff, mask)
+
+
+def calculate_debug_metrics(data: DataProto) -> dict:
+    """
+    calculate rollout vs actor logprobs diff, for debugging purpose
+
+    Args:
+        data: DataProto
+            the data batch to calculate
+            rollout_log_probs: log_probs record when rollout forward tokens
+            old_log_probs(actor log probs): log_probs record when actor forward tokens
+            loss_mask or attention_mask: to mask unrelated token
+            responses: the response tokens, for calculating size
+    Returns:
+        dict: metrics
+            "training/rollout_probs_diff_valid": 1->input is valid, 0->input is invalid
+            "training/rollout_probs_diff_max": max value of logprob diff of rollout vs. actor
+            "training/rollout_probs_diff_mean": mean value of logprob diff of rollout vs. actor
+            "training/rollout_probs_diff_std": std value of logprob diff of rollout vs. actor
+            "training/rollout_actor_probs_pearson_corr": logprob's pearson corrcoef of rollout vs. actor, reference to https://arxiv.org/pdf/2506.13585
+    """
+
+    rollout_old_log_probs = data.batch["rollout_log_probs"]
+    actor_old_log_probs = data.batch["old_log_probs"]
+    if "response_mask" in data.batch:
+        logger.debug("response mask found, use it to mask log probs")
+        log_prob_mask = data.batch["response_mask"]
+    elif "attention_mask" in data.batch:
+        log_prob_mask = data.batch["attention_mask"]
+    else:
+        logger.warning(f"no mask info found, use all log probs, {(data.batch.keys())=}")
+        log_prob_mask = torch.ones_like(rollout_old_log_probs)
+    responses = data.batch["responses"]
+    response_length = responses.size(1)
+
+    response_mask = log_prob_mask[:, -response_length:]
+    # calculate pearson corrcoef
+    actor_probs = torch.exp(actor_old_log_probs)
+    rollout_probs = torch.exp(rollout_old_log_probs)
+    response_mask_bool = response_mask.bool()
+    pearson_corrcoef = pearson_correlation_coefficient(actor_probs, rollout_probs, response_mask_bool)
+    rollout_probs_diff = calculate_log_prob_diff(actor_probs, rollout_probs, response_mask_bool)
+    return {
+        "training/rollout_probs_diff_valid": 1,
+        "training/rollout_probs_diff_max": torch.max(rollout_probs_diff).detach().item(),
+        "training/rollout_probs_diff_mean": torch.mean(rollout_probs_diff).detach().item(),
+        "training/rollout_probs_diff_std": torch.std(rollout_probs_diff).detach().item(),
+        "training/rollout_actor_probs_pearson_corr": pearson_corrcoef,
+    }

verl/verl/utils/debug/performance.py

@@ -0,0 +1,17 @@
+# 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.
+
+# APIs kept for backward compatibility purpose
+# This file is deprecated, for new features please develop in profiler/performance.py
+from verl.utils.profiler.performance import simple_timer, reduce_timing  # noqa

verl/verl/utils/debug/trajectory_tracker.py

@@ -0,0 +1,109 @@
+# 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.
+"""
+Trajectory tracker can be inserted into code to save the intermediate results.
+The results will be dump to hdfs for offline comparison.
+Each process will have a client that first move all the tensors to CPU
+"""
+
+import io
+import os
+import tempfile
+from collections import deque
+
+import ray
+import torch
+
+from verl.utils.hdfs_io import copy, makedirs
+
+remote_copy = ray.remote(copy)
+
+
+@ray.remote
+def save_to_hdfs(data: io.BytesIO, name, hdfs_dir, verbose):
+    filename = name + ".pth"
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        local_filepath = os.path.join(tmpdirname, filename)
+        with open(local_filepath, "wb") as f:
+            f.write(data.getbuffer())
+        # upload to hdfs
+
+        if verbose:
+            print(f"Saving {local_filepath} to {hdfs_dir}")
+        try:
+            copy(local_filepath, hdfs_dir)
+        except Exception as e:
+            print(e)
+
+
+@ray.remote
+class TrajectoryTracker:
+    def __init__(self, hdfs_dir, verbose) -> None:
+        self.hdfs_dir = hdfs_dir
+        makedirs(hdfs_dir)
+        self.verbose = verbose
+
+        self.handle = deque()
+
+    def dump(self, data: io.BytesIO, name):
+        # get a temp file and write to it
+        self.handle.append(save_to_hdfs.remote(data, name, self.hdfs_dir, self.verbose))
+
+    def wait_for_hdfs(self):
+        while len(self.handle) != 0:
+            future = self.handle.popleft()
+            ray.get(future)
+
+
+def dump_data(data, name):
+    enable = os.getenv("VERL_ENABLE_TRACKER", "0") == "1"
+    if not enable:
+        return
+    buffer = io.BytesIO()
+    torch.save(data, buffer)
+    tracker = get_trajectory_tracker()
+    ray.get(tracker.dump.remote(buffer, name))
+
+
+def get_trajectory_tracker():
+    hdfs_dir = os.getenv("VERL_TRACKER_HDFS_DIR", default=None)
+    verbose = os.getenv("VERL_TRACKER_VERBOSE", default="0") == "1"
+    assert hdfs_dir is not None
+    tracker = TrajectoryTracker.options(name="global_tracker", get_if_exists=True, lifetime="detached").remote(
+        hdfs_dir, verbose
+    )
+    return tracker
+
+
+if __name__ == "__main__":
+    # testing
+    os.environ["VERL_ENABLE_TRACKER"] = "1"
+    os.environ["VERL_TRACKER_HDFS_DIR"] = "~/debug/test"
+
+    @ray.remote
+    def process(iter):
+        data = {"obs": torch.randn(10, 20)}
+        dump_data(data, f"process_{iter}_obs")
+
+    ray.init()
+
+    output_lst = []
+
+    for i in range(10):
+        output_lst.append(process.remote(i))
+
+    out = ray.get(output_lst)
+
+    tracker = get_trajectory_tracker()
+    ray.get(tracker.wait_for_hdfs.remote())

verl/verl/utils/experimental/__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.

verl/verl/utils/experimental/torch_functional.py

@@ -0,0 +1,216 @@
+# 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 typing import Optional
+
+import torch
+
+
+def _fused_linear_for_ppo_fwd(
+    hidden_states: torch.FloatTensor,
+    vocab_weights: torch.FloatTensor,
+    input_ids: torch.LongTensor,
+    temperature: float = 1.0,
+) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+    logits = (hidden_states @ vocab_weights.t()) / temperature
+    orig_dtype = logits.dtype
+    logits = logits.to(torch.float32)
+
+    # Slower but more numerically stable to do log_softmax than probs.log()
+    probs = logits.softmax(dim=-1)
+    log_probs = logits.log_softmax(dim=-1)
+
+    token_log_probs = log_probs.gather(-1, input_ids.unsqueeze(-1)).squeeze(-1)
+    entropy = torch.logsumexp(logits, dim=-1) - torch.sum(probs * logits, dim=-1)
+
+    return token_log_probs.to(orig_dtype), entropy.to(orig_dtype)
+
+
+def _fused_linear_for_ppo_bwd(
+    dlog_probs: Optional[torch.FloatTensor],
+    dentropy: Optional[torch.FloatTensor],
+    hidden_states: torch.FloatTensor,
+    vocab_weights: torch.FloatTensor,
+    input_ids: torch.LongTensor,
+    temperature: float = 1.0,
+) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+    logits = (hidden_states @ vocab_weights.t()) / temperature
+    orig_dtype = logits.dtype
+    logits = logits.to(torch.float32)
+
+    probs = logits.softmax(dim=-1)
+
+    dlogits = 0
+
+    # Gradient from log_probs
+    if dlog_probs is not None:
+        one_hot_input = torch.zeros_like(logits).scatter_(-1, input_ids.unsqueeze(-1), 1)
+        dlogits += dlog_probs.to(torch.float32).unsqueeze(-1) * (one_hot_input - probs)
+
+    # Gradient from entropy
+    if dentropy is not None:
+        log_probs = logits.log_softmax(dim=-1)
+        entropy = torch.logsumexp(logits, dim=-1) - torch.sum(probs * logits, dim=-1)
+        dlogits += probs * (log_probs + entropy.unsqueeze(-1)) * (-dentropy.unsqueeze(-1))
+
+    dlogits = dlogits.to(orig_dtype) / temperature
+
+    dhidden_states = dlogits @ vocab_weights
+    dvocab_weights = dlogits.t() @ hidden_states
+
+    return dhidden_states, dvocab_weights
+
+
+class FusedLinearForPPOFunction(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        hidden_states: torch.FloatTensor,
+        vocab_weights: torch.FloatTensor,
+        input_ids: torch.LongTensor,
+        temperature: float = 1.0,
+        chunk_size: int = 512,
+    ) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+        ctx.set_materialize_grads(False)
+
+        # Cast to a 2D tensor of the shape [T, D] for ease of working
+        orig_ndim = hidden_states.ndim
+        assert orig_ndim in (2, 3), f"Invalid hidden_states shape, received {hidden_states.shape}"
+
+        orig_batch_size = -1
+        if orig_ndim == 3:
+            assert input_ids.ndim == 2, f"input_ids shape doesn't match, {hidden_states.shape} {input_ids.shape}"
+            orig_batch_size = hidden_states.shape[0]
+            hidden_states = hidden_states.flatten(0, 1)
+            input_ids = input_ids.flatten(0, 1)
+
+        T = hidden_states.shape[0]
+
+        # Allocate memory for outputs
+        output_requires_grad = hidden_states.requires_grad or vocab_weights.requires_grad
+        log_probs = hidden_states.new_zeros(T, requires_grad=output_requires_grad)
+        entropy = hidden_states.new_zeros(T, requires_grad=output_requires_grad)
+
+        # Perform forward one chunk at a time
+        for chunk_start in range(0, T, chunk_size):
+            chunk_end = min(chunk_start + chunk_size, T)
+
+            chunk_log_probs, chunk_entropy = _fused_linear_for_ppo_fwd(
+                hidden_states=hidden_states[chunk_start:chunk_end],
+                vocab_weights=vocab_weights,
+                input_ids=input_ids[chunk_start:chunk_end],
+                temperature=temperature,
+            )
+            log_probs[chunk_start:chunk_end] = chunk_log_probs
+            entropy[chunk_start:chunk_end] = chunk_entropy
+
+        # Cast the output back to the original input dimension
+        if orig_ndim == 3:
+            log_probs = log_probs.view(orig_batch_size, -1)
+            entropy = entropy.view(orig_batch_size, -1)
+
+        ctx.save_for_backward(hidden_states, vocab_weights, input_ids)
+        ctx.orig_batch_size = orig_batch_size
+        ctx.orig_ndim = orig_ndim
+        ctx.temperature = temperature
+        ctx.chunk_size = chunk_size
+
+        return log_probs, entropy
+
+    @staticmethod
+    def backward(ctx, dlog_probs: Optional[torch.FloatTensor], dentropy: Optional[torch.FloatTensor]):
+        assert dlog_probs is not None or dentropy is not None
+
+        hidden_states, vocab_weights, input_ids = ctx.saved_tensors
+        orig_batch_size = ctx.orig_batch_size
+        orig_ndim = ctx.orig_ndim
+        temperature = ctx.temperature
+        chunk_size = ctx.chunk_size
+
+        # Here orig_ndim refers to the orig_ndim of hidden_states
+        if orig_ndim == 3:
+            if dlog_probs is not None:
+                dlog_probs = dlog_probs.flatten()
+            if dentropy is not None:
+                dentropy = dentropy.flatten()
+
+        T = hidden_states.shape[0]
+
+        # Allocate memory for outputs
+        dhidden_states = None
+        if hidden_states.requires_grad:
+            dhidden_states = torch.zeros_like(hidden_states)
+        dvocab_weights = None
+        if vocab_weights.requires_grad:
+            dvocab_weights = torch.zeros_like(vocab_weights)
+
+        # Perform backward one chunk at a time
+        for chunk_start in range(0, T, chunk_size):
+            chunk_end = min(chunk_start + chunk_size, T)
+            chunk_dlog_probs = None
+            if dlog_probs is not None:
+                chunk_dlog_probs = dlog_probs[chunk_start:chunk_end]
+            chunk_dentropy = None
+            if dentropy is not None:
+                chunk_dentropy = dentropy[chunk_start:chunk_end]
+
+            h, v = _fused_linear_for_ppo_bwd(
+                dlog_probs=chunk_dlog_probs,
+                dentropy=chunk_dentropy,
+                hidden_states=hidden_states[chunk_start:chunk_end],
+                vocab_weights=vocab_weights,
+                input_ids=input_ids[chunk_start:chunk_end],
+                temperature=temperature,
+            )
+
+            if hidden_states.requires_grad:
+                dhidden_states[chunk_start:chunk_end] += h
+            if vocab_weights.requires_grad:
+                dvocab_weights += v
+
+        # Cast the output back to the original input dimension
+        if orig_ndim == 3 and hidden_states.requires_grad:
+            hidden_size = hidden_states.shape[-1]
+            dhidden_states = dhidden_states.view(orig_batch_size, -1, hidden_size)
+
+        return (
+            dhidden_states,  # hidden_states
+            dvocab_weights,  # vocab_weights
+            None,  # input_ids
+            None,  # temperature
+            None,  # chunk_size
+        )
+
+
+class FusedLinearForPPO(torch.nn.Module):
+    def __init__(self, chunk_size: int = 512):
+        super().__init__()
+
+        self.chunk_size = chunk_size
+
+    def forward(
+        self,
+        hidden_states: torch.FloatTensor,
+        vocab_weights: torch.FloatTensor,
+        input_ids: torch.LongTensor,
+        temperature: float = 1.0,
+    ) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+        input_ids = input_ids.to(torch.int64)
+        return FusedLinearForPPOFunction.apply(
+            hidden_states,
+            vocab_weights,
+            input_ids,
+            temperature,
+            self.chunk_size,
+        )

verl/verl/utils/kernel/__init__.py

@@ -0,0 +1,31 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+
+# 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.
+

verl/verl/utils/kernel/kernels.py

@@ -0,0 +1,1586 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+
+# 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.
+"""
+Implementations of the linear cross entropy with token entropy kernel.
+"""
+
+import typing
+from dataclasses import dataclass
+
+import torch
+import torch.distributed as dist
+
+try:
+    import triton
+    import triton.language as tl
+
+    HAVE_TRITON = True
+except ImportError:
+    HAVE_TRITON = False
+
+from verl.utils.device import get_torch_device
+
+if not HAVE_TRITON:
+    from contextlib import contextmanager
+    from unittest.mock import MagicMock
+
+    @contextmanager
+    def null_decorator(*args, **kwargs):
+        if len(kwargs) == 0 and len(args) == 1 and callable(args[0]):
+            return args[0]
+        else:
+
+            def inner(func):
+                return func
+
+            return inner
+
+    triton = MagicMock()
+    triton.jit = null_decorator
+    triton.autotune = null_decorator
+    tl = MagicMock()
+
+
+@dataclass
+class EntropyReductionEnum:
+    """
+    Enum for the reduction method of cross entropy.
+    """
+
+    _None = 0
+    _Sum = 1
+    _Mean = 2
+
+
+def get_entropy_reduction_enum_number(reduction: str) -> int:
+    """
+    Get the enum number for the reduction method of cross entropy.
+    """
+    _enum = EntropyReductionEnum._None
+    if reduction == "none":
+        _enum = EntropyReductionEnum._None
+    elif reduction == "sum":
+        _enum = EntropyReductionEnum._Sum
+    elif reduction == "mean":
+        _enum = EntropyReductionEnum._Mean
+    else:
+        raise ValueError(f"Invalid reduction: {reduction}")
+    return _enum
+
+
+def get_entropy_reduction_enum(ce_reduction: int) -> EntropyReductionEnum:
+    """
+    Get the enum for the reduction method of cross entropy.
+    """
+    _enum = EntropyReductionEnum._None
+    if ce_reduction == 0:
+        _enum = EntropyReductionEnum._None
+    elif ce_reduction == 1:
+        _enum = EntropyReductionEnum._Sum
+    elif ce_reduction == 2:
+        _enum = EntropyReductionEnum._Mean
+    else:
+        raise ValueError(f"Invalid ce_reduction: {ce_reduction}")
+    return _enum
+
+
+@dataclass
+class BackwardEnum:
+    """
+    Enum for the backward method.
+    """
+
+    _Total_Fuse_MN = (
+        0  # Fuse d_logits & d_hidden & d_weight, no intermediate storage, requires fp32 for d_hidden & d_weight
+    )
+    _Total_Separate = 1  # Store d_logits, no special requirements for d_hidden & d_weight
+    _Split_Dlogits_N = 2  # split d_logits along its N dimension, aka. vocab_size
+    _Split_Dlogits_M = 3  # split d_logits along its M dimension, aka. num_tokens
+
+
+@dataclass
+class Config:
+    """Configuration for efficient entropy kernel operations.
+
+    Args:
+        _backward (BackwardEnum): Backward computation method. Defaults to BackwardEnum._Split_Dlogits_N.
+        _use_triton (bool): Whether to use Triton kernels for computation. Defaults to True.
+    """
+
+    _backward: BackwardEnum = BackwardEnum._Split_Dlogits_N
+    _use_triton: bool = True
+
+
+_config = Config()
+
+
+def set_backward_method(backward_method: BackwardEnum):
+    """
+    Set the backward method.
+    """
+    global _config
+    _config._backward = backward_method
+
+
+@triton.autotune(
+    configs=[triton.Config({"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 256, "BLOCK_SIZE_K": 32}, num_stages=3, num_warps=8)],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_kernel_general_mainloop(
+    rank,
+    hidden_ptr,
+    weight_ptr,
+    labels_ptr,
+    num_tokens,
+    hidden_size,
+    vocab_size,
+    vocab_per_split,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    max_ptr,
+    stride_max_m: tl.int64,
+    stride_max_n: tl.int64,
+    accu_ptr,
+    stride_accu_m: tl.int64,
+    stride_accu_n: tl.int64,
+    entropy_b_ptr,
+    stride_entropy_b_m: tl.int64,
+    stride_entropy_b_n: tl.int64,
+    global_logprobs_ptr,
+    stride_global_logprobs: tl.int64,
+    global_logprobs_scalar_ptr,
+    rcp_temperature: tl.float32,
+    # Meta-parameters
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+):
+    """
+    forward mainloop
+    """
+    pid = tl.program_id(axis=0)
+    num_splits = (vocab_size + vocab_per_split - 1) // vocab_per_split
+    num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    num_pid_n = tl.cdiv(vocab_per_split, BLOCK_SIZE_N)
+    pid_m = pid % num_pid_m
+    pid_n = pid // num_pid_m
+
+    if pid_m == 0 and pid_n == 0:
+        tl.store(global_logprobs_scalar_ptr, 0.0)
+
+    # create pointers for the first blocks of hidden
+    offs_am = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+    hidden_ptrs = hidden_ptr + (offs_am[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+
+    # load labels for this block
+    labels = tl.load(labels_ptr + offs_am, mask=offs_am < num_tokens)
+
+    # traverse over N dimension
+    # _max = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    _max = tl.full((BLOCK_SIZE_M,), -float("inf"), dtype=tl.float32)
+    _accu = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    _entropy_b = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    _logprobs = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    for n in range(0, num_pid_n):
+        offs_bn = pid_n * vocab_per_split + n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+        # weight_ptrs = weight_ptr + (offs_k[:, None] * stride_weight_k + offs_bn[None, :] * stride_weight_n)
+        weight_ptrs = weight_ptr + (offs_bn[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+
+        # iterate over K dimension
+        logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+        for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+            # load the next block of hidden and weight
+            _hidden = tl.load(
+                hidden_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+                other=0.0,
+            )
+            # _weight = tl.load(weight_ptrs,
+            #                   mask=(offs_k[:, None] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[None, :] < (min(
+            #                       (pid_n + 1) * vocab_per_split, vocab_size))),
+            #                   other=0.0)
+
+            _weight = tl.load(
+                weight_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K)
+                & (offs_bn[:, None] < (min((pid_n + 1) * vocab_per_split, vocab_size))),
+                other=0.0,
+            )
+
+            # GEMM
+            logits = tl.dot(_hidden, _weight.trans(), logits)
+
+            # advance the ptrs to the next K block
+            hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+            weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+        # reset hidden_ptrs for next iteration
+        hidden_ptrs -= hidden_size * stride_hidden_k
+
+        # scale logits by temperature
+        logits *= rcp_temperature
+
+        # update global maximum
+        _max_old = _max
+        m_pid_n = tl.max(logits, axis=1)
+        _max = tl.maximum(_max_old, m_pid_n)
+
+        exp_logits = tl.exp(logits - _max[:, None])
+        coeff = tl.exp(_max_old - _max)
+        _accu = coeff * _accu + tl.sum(exp_logits, axis=1)
+
+        _entropy_b = _entropy_b * coeff + tl.sum(logits * exp_logits, axis=1)
+
+        label_mask = (offs_bn + rank * vocab_size)[None, :] == labels[:, None]
+        _logprobs += tl.sum(logits * label_mask, axis=1)
+
+    # store maximum
+    offs_max_m = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_max_n = pid_n
+    maximum_ptrs = max_ptr + offs_max_n * stride_max_n + offs_max_m * stride_max_m
+    tl.store(maximum_ptrs, _max, mask=(offs_max_m < num_tokens) & (offs_max_n < num_splits))
+
+    # store entropy
+    accu_ptrs = accu_ptr + offs_max_n * stride_accu_n + offs_max_m * stride_accu_m
+    tl.store(accu_ptrs, _accu, mask=(offs_max_m < num_tokens) & (offs_max_n[None] < num_splits))
+    entropy_b_ptrs = entropy_b_ptr + offs_max_n * stride_entropy_b_n + offs_max_m * stride_entropy_b_m
+    tl.store(entropy_b_ptrs, _entropy_b, mask=(offs_max_m < num_tokens) & (offs_max_n < num_splits))
+
+    # store logprobs
+    vocab_left_idx = pid_n * vocab_per_split + rank * vocab_size
+    vocab_right_idx = min((pid_n + 1) * vocab_per_split, vocab_size) + rank * vocab_size
+    mask = (labels >= vocab_left_idx) & (labels < vocab_right_idx)
+    mask &= offs_am < num_tokens
+    global_logprobs_ptrs = global_logprobs_ptr + offs_am * stride_global_logprobs
+    # tl.atomic_add(global_logprobs_ptrs, _logprobs, mask=mask)
+    tl.store(global_logprobs_ptrs, _logprobs, mask=mask)
+
+
+@triton.autotune(configs=[triton.Config({"BLOCK_SIZE_M": 16, "BLOCK_SIZE_N": 64})], key=["num_tokens", "num_splits"])
+@triton.jit
+def efficient_entropy_triton_kernel_epilogue(
+    max_ptr,
+    stride_max_m: tl.int64,
+    stride_max_n: tl.int64,
+    num_tokens,
+    num_splits,
+    global_max_ptr,
+    stride_global_max: tl.int64,
+    accu_ptr,
+    stride_accu_m: tl.int64,
+    stride_accu_n: tl.int64,
+    global_accu_ptr,
+    stride_global_accu: tl.int64,
+    entropy_b_ptr,
+    stride_entropy_b_m: tl.int64,
+    stride_entropy_b_n: tl.int64,
+    global_entropy_b_ptr,
+    stride_global_entropy_b: tl.int64,
+    global_entropy_ptr,
+    stride_global_entropy: tl.int64,
+    global_logprobs_ptr,
+    stride_global_logprobs: tl.int64,
+    global_logprobs_scalar_ptr,
+    reduction: int,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+):
+    """
+    foward epilogue
+    """
+    pid_m = tl.program_id(axis=0)
+
+    offs_m = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    global_max = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    global_accu = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    global_entropy_b = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    for pid_n in range(0, tl.cdiv(num_splits, BLOCK_SIZE_N)):
+        offs_n = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+        max_ptrs = max_ptr + offs_m[:, None] * stride_max_m + offs_n[None, :] * stride_max_n
+
+        _max = tl.load(max_ptrs, mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits), other=0.0)
+
+        accu_ptrs = accu_ptr + offs_m[:, None] * stride_accu_m + offs_n[None, :] * stride_accu_n
+        _accu = tl.load(accu_ptrs, mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits), other=0.0)
+
+        entropy_b_ptrs = entropy_b_ptr + offs_m[:, None] * stride_entropy_b_m + offs_n[None, :] * stride_entropy_b_n
+        _entropy_b = tl.load(
+            entropy_b_ptrs, mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits), other=0.0
+        )
+
+        # local reduction
+        _max_old = global_max
+        _local_max = tl.max(_max, axis=1)
+        global_max = tl.maximum(global_max, _local_max)
+
+        _scale = tl.exp(_max - global_max[:, None])
+        _coeff = tl.exp(_max_old - global_max)
+        global_accu = _coeff * global_accu + tl.sum(_scale * _accu, axis=1)
+        global_entropy_b = _coeff * global_entropy_b + tl.sum(_scale * _entropy_b, axis=1)
+
+    # store
+    maximum_ptrs = global_max_ptr + offs_m * stride_global_max
+    tl.store(maximum_ptrs, global_max, mask=offs_m < num_tokens)
+
+    # store entropy_b
+    global_entropy_b = tl.fdiv(global_entropy_b, global_accu)  # entropy_b
+    tl.store(global_entropy_b_ptr + offs_m * stride_global_entropy_b, global_entropy_b, mask=offs_m < num_tokens)
+
+    # store entropy
+    global_accu_ptrs = global_accu_ptr + offs_m * stride_global_accu
+    tl.store(global_accu_ptrs, global_accu, mask=offs_m < num_tokens)
+    global_entropy = tl.log(global_accu) + global_max - global_entropy_b  # entropy_a
+    global_entropy_ptrs = global_entropy_ptr + offs_m * stride_global_entropy
+    tl.store(global_entropy_ptrs, global_entropy, mask=offs_m < num_tokens)
+    # update logprobs
+    global_logprobs_ptrs = global_logprobs_ptr + offs_m * stride_global_logprobs
+    global_logprobs = tl.load(global_logprobs_ptrs, mask=offs_m < num_tokens)
+    global_logprobs = global_max + tl.log(global_accu) - global_logprobs
+
+    global_logprobs = -1 * global_logprobs
+    if reduction == 0:
+        tl.store(global_logprobs_ptrs, global_logprobs, mask=offs_m < num_tokens)
+    elif reduction == 1:
+        global_logprobs_scalar = tl.sum(global_logprobs, axis=0)
+        tl.atomic_add(global_logprobs_scalar_ptr, global_logprobs_scalar)
+    elif reduction == 2:
+        global_logprobs_scalar = tl.sum(global_logprobs, axis=0) / num_tokens.to(tl.float32)
+        tl.atomic_add(global_logprobs_scalar_ptr, global_logprobs_scalar)
+
+
+@triton.autotune(configs=[triton.Config({"BLOCK_SIZE_M": 16, "BLOCK_SIZE_N": 64})], key=["num_tokens", "num_splits"])
+@triton.jit
+def efficient_entropy_triton_kernel_epilogue_tp(
+    num_tokens,
+    num_splits,
+    reduced_max_ptr,
+    stride_reduced_max_m: tl.int64,
+    stride_reduced_max_n: tl.int64,
+    original_max_ptr,
+    stride_original_max_m: tl.int64,
+    stride_original_max_n: tl.int64,
+    accu_ptr,
+    stride_accu_m: tl.int64,
+    stride_accu_n: tl.int64,
+    entropy_b_ptr,
+    stride_entropy_b_m: tl.int64,
+    stride_entropy_b_n: tl.int64,
+    global_max_ptr,
+    stride_global_max: tl.int64,
+    global_accu_ptr,
+    stride_global_accu: tl.int64,
+    global_entropy_b_ptr,
+    stride_global_entropy_b: tl.int64,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+):
+    pid_m = tl.program_id(axis=0)
+
+    offs_m = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+
+    global_max = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    global_accu = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    global_entropy_b = tl.zeros((BLOCK_SIZE_M,), dtype=tl.float32)
+    for pid_n in range(0, tl.cdiv(num_splits, BLOCK_SIZE_N)):
+        offs_n = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+
+        _reduced_max = tl.load(
+            reduced_max_ptr + offs_m[:, None] * stride_reduced_max_m + offs_n[None, :] * stride_reduced_max_n,
+            mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits),
+            other=0.0,
+        )
+        _original_max = tl.load(
+            original_max_ptr + offs_m[:, None] * stride_original_max_m + offs_n[None, :] * stride_original_max_n,
+            mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits),
+            other=0.0,
+        )
+        _accu = tl.load(
+            accu_ptr + offs_m[:, None] * stride_accu_m + offs_n[None, :] * stride_accu_n,
+            mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits),
+            other=0.0,
+        )
+
+        # local reduce-max
+        _max_old = global_max
+        _local_max = tl.max(_reduced_max, axis=1)
+        global_max = tl.maximum(global_max, _local_max)
+
+        # update accumulate
+        _coeff = tl.exp(_max_old - global_max)
+        _scale = tl.exp(_original_max - global_max[:, None])
+        global_accu = _coeff * global_accu + tl.sum(_scale * _accu, axis=1)
+
+        # update entropy_b
+        _entropy_b = tl.load(
+            entropy_b_ptr + offs_m[:, None] * stride_entropy_b_m + offs_n[None, :] * stride_entropy_b_n,
+            mask=(offs_m[:, None] < num_tokens) & (offs_n[None, :] < num_splits),
+            other=0.0,
+        )
+        global_entropy_b = _coeff * global_entropy_b + tl.sum(_scale * _entropy_b, axis=1)
+
+    # store
+    tl.store(global_max_ptr + offs_m * stride_global_max, global_max, mask=offs_m < num_tokens)
+    tl.store(global_accu_ptr + offs_m * stride_global_accu, global_accu, mask=offs_m < num_tokens)
+    tl.store(global_entropy_b_ptr + offs_m * stride_global_entropy_b, global_entropy_b, mask=offs_m < num_tokens)
+
+
+@triton.autotune(configs=[triton.Config({"BLOCK_SIZE_M": 16})], key=["num_tokens"])
+@triton.jit
+def efficient_entropy_triton_epilogue_tp_update(
+    num_tokens,
+    logprobs_ptr,
+    stride_logprobs: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accumulate_ptr,
+    stride_accumulate: tl.int64,
+    entropy_b_ptr,
+    stride_entropy_b: tl.int64,
+    entropy_ptr,
+    stride_entropy: tl.int64,
+    logprobs_scalar_ptr,
+    reduction: int,
+    BLOCK_SIZE_M: tl.constexpr,
+):
+    pid_m = tl.program_id(axis=0)
+
+    offs_m = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+
+    maximum = tl.load(maximum_ptr + offs_m * stride_maximum, mask=offs_m < num_tokens)
+    accumulate = tl.load(accumulate_ptr + offs_m * stride_accumulate, mask=offs_m < num_tokens)
+
+    entropy_b = tl.load(entropy_b_ptr + offs_m * stride_entropy_b, mask=offs_m < num_tokens)
+    entropy_b = tl.fdiv(entropy_b, accumulate)
+    tl.store(entropy_b_ptr + offs_m * stride_entropy_b, entropy_b, mask=offs_m < num_tokens)
+
+    entropy = tl.log(accumulate) + maximum - entropy_b
+    tl.store(entropy_ptr + offs_m * stride_entropy, entropy, mask=offs_m < num_tokens)
+
+    logprobs = tl.load(logprobs_ptr + offs_m * stride_logprobs, mask=offs_m < num_tokens)
+    logprobs = maximum + tl.log(accumulate) - logprobs
+
+    logprobs = -1 * logprobs
+    if reduction == 0:
+        tl.store(logprobs_ptr + offs_m * stride_logprobs, logprobs, mask=offs_m < num_tokens)
+    elif reduction == 1:
+        logprobs_scalar = tl.sum(logprobs, axis=0)
+        tl.atomic_add(logprobs_scalar_ptr, logprobs_scalar)
+    elif reduction == 2:
+        logprobs_scalar = tl.sum(logprobs, axis=0) / num_tokens.to(tl.float32)
+        tl.atomic_add(logprobs_scalar_ptr, logprobs_scalar)
+
+
+_dedicated_stream, _dedicated_events = None, None
+
+
+def efficient_entropy_forward(
+    hidden: torch.Tensor,
+    weight: torch.Tensor,
+    labels: torch.Tensor,
+    reduction: typing.Optional[int] = 2,
+    temperature: typing.Optional[float] = 1.0,
+    dist_process_group: typing.Optional[dist.ProcessGroup] = None,
+) -> list[torch.Tensor]:
+    """
+    forward host function
+    """
+    assert hidden.is_cuda and weight.is_cuda and labels.is_cuda
+    assert weight.device == hidden.device and labels.device == hidden.device
+    assert hidden.dim() == 2 and weight.dim() == 2 and labels.dim() == 1
+    assert hidden.is_contiguous() and weight.is_contiguous() and labels.is_contiguous()
+
+    assert hidden.shape[0] == labels.shape[0] and hidden.shape[1] == weight.shape[1]
+
+    _rank = 0 if dist_process_group is None else dist.get_rank(dist_process_group)
+    _world_size = 1 if dist_process_group is None else dist.get_world_size(dist_process_group)
+
+    if dist_process_group is not None and not hasattr(efficient_entropy_forward, "_initialized"):
+        global _dedicated_stream, _dedicated_events
+        _dedicated_stream = get_torch_device().Stream(hidden.device)
+        _dedicated_events = [get_torch_device().Event() for _ in range(2)]
+        efficient_entropy_forward._initialized = True
+
+    num_tokens, hidden_size = hidden.shape
+    num_tokens = labels.shape[0]
+    vocab_size, hidden_size = weight.shape
+    assert hidden_size % 128 == 0
+
+    REDUCTION = get_entropy_reduction_enum(reduction)
+
+    if REDUCTION == EntropyReductionEnum._None:
+        if dist_process_group is None:
+            logprobs = torch.empty((num_tokens,), device=hidden.device, dtype=torch.float32)
+        else:
+            logprobs = torch.zeros((num_tokens,), device=hidden.device, dtype=torch.float32)
+    elif REDUCTION in (EntropyReductionEnum._Sum, EntropyReductionEnum._Mean):
+        logprobs = torch.empty((), device=hidden.device, dtype=torch.float32)
+    else:
+        raise ValueError(f"Invalid reduction: {reduction}")
+
+    entropy = torch.empty((num_tokens,), device=hidden.device, dtype=torch.float32)
+    assert logprobs.is_contiguous() and entropy.is_contiguous()
+
+    maximum = torch.empty_like(entropy)
+    accumulate_and_entropy_b = torch.empty((num_tokens * 2,), device=hidden.device, dtype=torch.float32)
+    accumulate_and_entropy_b_view = accumulate_and_entropy_b.view(2, num_tokens)
+    accumulate = accumulate_and_entropy_b_view[0, :]
+    entropy_b = accumulate_and_entropy_b_view[1, :]
+    assert maximum.is_contiguous() and accumulate.is_contiguous() and entropy_b.is_contiguous()
+
+    vocab_per_split = 1024
+    assert vocab_per_split % 128 == 0
+    num_splits = (vocab_size + vocab_per_split - 1) // vocab_per_split
+
+    _max = torch.empty((num_tokens, num_splits), device=hidden.device, dtype=torch.float32)
+    _accu = torch.empty((num_tokens, num_splits), device=hidden.device, dtype=torch.float32)
+    _entropy_b = torch.empty((num_tokens, num_splits), device=hidden.device, dtype=torch.float32)
+
+    if REDUCTION == EntropyReductionEnum._None:
+        _logprobs = logprobs
+    else:
+        _logprobs = torch.empty((num_tokens,), device=hidden.device, dtype=torch.float32)
+
+    assert _accu.is_contiguous() and _entropy_b.is_contiguous() and _max.is_contiguous()
+    assert _accu.is_cuda and _entropy_b.is_cuda and _max.is_cuda
+
+    if _config._use_triton:
+        # 1D kernel launch, then split the tile
+        def mainloop_grid(meta):
+            return (triton.cdiv(num_tokens, meta["BLOCK_SIZE_M"]) * num_splits,)
+
+        efficient_entropy_kernel_general_mainloop[mainloop_grid](
+            _rank,
+            hidden,
+            weight,
+            labels,
+            num_tokens,
+            hidden_size,
+            vocab_size,
+            vocab_per_split,
+            hidden.stride(0),
+            hidden.stride(1),
+            weight.stride(0),
+            weight.stride(1),
+            _max,
+            _max.stride(0),
+            _max.stride(1),
+            _accu,
+            _accu.stride(0),
+            _accu.stride(1),
+            _entropy_b,
+            _entropy_b.stride(0),
+            _entropy_b.stride(1),
+            _logprobs,
+            _logprobs.stride(0),
+            logprobs,
+            1.0 / temperature,
+        )
+    else:
+        raise AssertionError("Triton is required for efficient entropy kernel")
+
+    # reduction on maximum and maximum_indices
+    def epilogue_grid(meta):
+        return (triton.cdiv(num_tokens, meta["BLOCK_SIZE_M"]),)
+
+    if dist_process_group is None:
+        efficient_entropy_triton_kernel_epilogue[epilogue_grid](
+            _max,
+            _max.stride(0),
+            _max.stride(1),
+            num_tokens,
+            num_splits,
+            maximum,
+            maximum.stride(0),
+            _accu,
+            _accu.stride(0),
+            _accu.stride(1),
+            accumulate,
+            accumulate.stride(0),
+            _entropy_b,
+            _entropy_b.stride(0),
+            _entropy_b.stride(1),
+            entropy_b,
+            entropy_b.stride(0),
+            entropy,
+            entropy.stride(0),
+            _logprobs,
+            _logprobs.stride(0),
+            logprobs,
+            REDUCTION,
+        )
+    else:
+        # tensor-parallel
+        _max_backup = _max.clone()
+        dist.all_reduce(_max, op=dist.ReduceOp.MAX, group=dist_process_group)
+
+        get_torch_device().current_stream().record_event(_dedicated_events[0])
+        with get_torch_device().stream(_dedicated_stream):
+            _dedicated_stream.wait_event(_dedicated_events[0])
+            dist.all_reduce(_logprobs, op=dist.ReduceOp.SUM, group=dist_process_group)
+            _dedicated_stream.record_event(_dedicated_events[1])
+
+        efficient_entropy_triton_kernel_epilogue_tp[epilogue_grid](
+            num_tokens,
+            num_splits,
+            _max,
+            _max.stride(0),
+            _max.stride(1),
+            _max_backup,
+            _max_backup.stride(0),
+            _max_backup.stride(1),
+            _accu,
+            _accu.stride(0),
+            _accu.stride(1),
+            _entropy_b,
+            _entropy_b.stride(0),
+            _entropy_b.stride(1),
+            maximum,
+            maximum.stride(0),
+            accumulate,
+            accumulate.stride(0),
+            entropy_b,
+            entropy_b.stride(0),
+        )
+        get_torch_device().current_stream().wait_event(_dedicated_events[1])
+
+        dist.all_reduce(accumulate_and_entropy_b, op=dist.ReduceOp.SUM, group=dist_process_group)
+
+        # update logprobs & entropy
+        efficient_entropy_triton_epilogue_tp_update[epilogue_grid](
+            num_tokens,
+            _logprobs,
+            _logprobs.stride(0),
+            maximum,
+            maximum.stride(0),
+            accumulate,
+            accumulate.stride(0),
+            entropy_b,
+            entropy_b.stride(0),
+            entropy,
+            entropy.stride(0),
+            logprobs,
+            REDUCTION,
+        )
+
+    return (logprobs, entropy, maximum, accumulate, entropy_b)
+
+
+# NOTE: merge d_weight & d_hidden here, split along M & N
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 128, "BLOCK_SIZE_K": 32, "GROUP_SIZE_M": 16},
+            num_stages=3,
+            num_warps=8,
+        )
+    ],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_backward_kernel_general_mainloop_MN(
+    num_tokens: int,
+    hidden_size: int,
+    vocab_size: int,
+    rank: int,
+    hidden_ptr,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    weight_ptr,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    labels_ptr,
+    stride_labels: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accu_ptr,
+    stride_accu: tl.int64,
+    d_entropy_ptr,
+    stride_d_entropy: tl.int64,
+    d_logprobs_ptr,
+    stride_d_logprobs: tl.int64,
+    reduction: int,
+    entropy_b_ptr,
+    stride_entropy_b: tl.int64,
+    d_hidden_ptr,
+    stride_d_hidden_m: tl.int64,
+    stride_d_hidden_k: tl.int64,
+    d_weight_ptr,
+    stride_d_weight_n: tl.int64,
+    stride_d_weight_k: tl.int64,
+    rcp_temperature: tl.float32,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+):
+    """
+    backward mainloop, where d_logits & d_hidden & d_weight are fused
+    """
+    # block swizzling
+    # pid = tl.program_id(axis=0)
+    # num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    # pid_m = pid % num_pid_m
+    # pid_n = pid // num_pid_m
+
+    pid = tl.program_id(axis=0)
+    num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    num_pid_n = tl.cdiv(vocab_size, BLOCK_SIZE_N)
+    num_pid_in_group = GROUP_SIZE_M * num_pid_n
+    group_id = pid // num_pid_in_group
+    first_pid_m = group_id * GROUP_SIZE_M
+    group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M)
+    pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m)
+    pid_n = (pid % num_pid_in_group) // group_size_m
+
+    offs_am = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_bn = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+
+    maximum_ptrs = maximum_ptr + offs_am * stride_maximum
+    maximum = tl.load(maximum_ptrs, mask=offs_am < num_tokens, other=0.0)
+    accu_ptrs = accu_ptr + offs_am * stride_accu
+    accu = tl.load(accu_ptrs, mask=offs_am < num_tokens, other=1e-6)  # epsilon to avoid division by zero
+    accu_rcp = tl.fdiv(1.0, accu)
+
+    d_entropy_ptrs = d_entropy_ptr + offs_am * stride_d_entropy
+    d_entropy = tl.load(d_entropy_ptrs, mask=offs_am < num_tokens, other=0.0)
+    if reduction == 0:  # none
+        d_logprobs_ptrs = d_logprobs_ptr + offs_am * stride_d_logprobs
+        d_logprobs = tl.load(d_logprobs_ptrs, mask=offs_am < num_tokens, other=0.0)
+    elif reduction == 1:  # sum
+        d_logprobs = tl.load(d_logprobs_ptr)
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    else:  # mean
+        d_logprobs = tl.fdiv(tl.load(d_logprobs_ptr), num_tokens.to(tl.float32))
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    d_logprobs = -1 * d_logprobs
+
+    entropy_b_ptrs = entropy_b_ptr + offs_am * stride_entropy_b
+    entropy_b = tl.load(entropy_b_ptrs, mask=offs_am < num_tokens, other=0.0)
+
+    hidden_ptrs = hidden_ptr + (offs_am[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+    # weight_ptrs = weight_ptr + (offs_k[:, None] * stride_weight_k + offs_bn[None, :] * stride_weight_n)
+    weight_ptrs = weight_ptr + (offs_bn[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+    labels_ptrs = labels_ptr + offs_am * stride_labels
+    labels = tl.load(labels_ptrs, mask=offs_am < num_tokens, other=0)
+
+    d_hidden_ptrs = d_hidden_ptr + offs_am[:, None] * stride_d_hidden_m + offs_k[None, :] * stride_d_hidden_k
+    # d_weight_ptrs = d_weight_ptr + offs_k[:, None] * stride_d_weight_k + offs_bn[None, :] * stride_d_weight_n
+    d_weight_ptrs = d_weight_ptr + offs_bn[:, None] * stride_d_weight_n + offs_k[None, :] * stride_d_weight_k
+
+    logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+    for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+        _hidden = tl.load(
+            hidden_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+            other=0.0,
+        )
+        # _weight = tl.load(weight_ptrs,
+        #                   mask=(offs_k[:, None] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[None, :] < vocab_size),
+        #                   other=0.0)
+        _weight = tl.load(
+            weight_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[:, None] < vocab_size),
+            other=0.0,
+        )
+
+        logits = tl.dot(_hidden, _weight.trans(), logits)
+
+        hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+        weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+    hidden_ptrs -= hidden_size * stride_hidden_k
+    weight_ptrs -= hidden_size * stride_weight_k
+
+    # scale logits by temperature
+    logits *= rcp_temperature
+
+    exp_logits = tl.exp(logits - maximum[:, None])
+
+    mask = (offs_bn + rank * vocab_size)[None, :] == labels[:, None]
+    d_logits = d_logprobs[:, None] * (exp_logits * accu_rcp[:, None] - mask)
+    d_logits += d_entropy[:, None] * (-exp_logits * accu_rcp[:, None]) * (logits - entropy_b[:, None])
+
+    # scale d_logits by temperature
+    d_logits *= rcp_temperature
+
+    # loop for d_weight & d_hidden
+    for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+        _hidden = tl.load(
+            hidden_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+            other=0.0,
+        )
+        # _d_weight = tl.dot(tl.trans(_hidden).to(tl.float32), d_logits)
+        # tl.atomic_add(d_weight_ptrs,
+        #               _d_weight,
+        #               mask=(offs_k[:, None] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[None, :] < vocab_size))
+        _d_weight = tl.dot(d_logits.trans(), _hidden.to(tl.float32))
+        tl.atomic_add(
+            d_weight_ptrs,
+            _d_weight,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[:, None] < vocab_size),
+        )
+
+        # _weight = tl.load(weight_ptrs,
+        #                   mask=(offs_k[:, None] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[None, :] < vocab_size),
+        #                   other=0.0)
+        # _d_hidden = tl.dot(d_logits, tl.trans(_weight).to(tl.float32))
+        _weight = tl.load(
+            weight_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[:, None] < vocab_size),
+            other=0.0,
+        )
+        _d_hidden = tl.dot(d_logits, _weight.to(tl.float32))
+        tl.atomic_add(
+            d_hidden_ptrs,
+            _d_hidden,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+        )
+
+        hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+        weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+        d_hidden_ptrs += BLOCK_SIZE_K * stride_d_hidden_k
+        d_weight_ptrs += BLOCK_SIZE_K * stride_d_weight_k
+
+
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 128, "BLOCK_SIZE_K": 32, "GROUP_SIZE_M": 16},
+            num_stages=3,
+            num_warps=8,
+        ),
+    ],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_backward_kernel_d_hidden(
+    num_tokens: int,
+    hidden_size: int,
+    vocab_size: int,
+    rank: int,
+    hidden_ptr,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    weight_ptr,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    labels_ptr,
+    stride_labels: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accu_ptr,
+    stride_accu: tl.int64,
+    d_entropy_ptr,
+    stride_d_entropy: tl.int64,
+    d_logprobs_ptr,
+    stride_d_logprobs: tl.int64,
+    reduction: int,
+    entropy_b_ptr,
+    stride_entropy_b: tl.int64,
+    d_hidden_ptr,
+    stride_d_hidden_m: tl.int64,
+    stride_d_hidden_k: tl.int64,
+    rcp_temperature: tl.float32,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+):
+    """
+    backward d_hidden
+    """
+    pid = tl.program_id(axis=0)
+    num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    pid_m = pid % num_pid_m
+    pid_k = pid // num_pid_m
+
+    offs_m = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+    result_offs_k = pid_k * BLOCK_SIZE_K + offs_k
+
+    maximum = tl.load(maximum_ptr + offs_m * stride_maximum, mask=offs_m < num_tokens, other=0.0)
+    accu = tl.load(accu_ptr + offs_m * stride_accu, mask=offs_m < num_tokens, other=1e-6)
+    accu_rcp = tl.fdiv(1.0, accu)
+    d_entropy = tl.load(d_entropy_ptr + offs_m * stride_d_entropy, mask=offs_m < num_tokens, other=0.0)
+    if reduction == 0:
+        d_logprobs = tl.load(d_logprobs_ptr + offs_m * stride_d_logprobs, mask=offs_m < num_tokens, other=0.0)
+    elif reduction == 1:
+        d_logprobs = tl.load(d_logprobs_ptr)
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    else:
+        d_logprobs = tl.fdiv(tl.load(d_logprobs_ptr), num_tokens.to(tl.float32))
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    d_logprobs = -1 * d_logprobs
+
+    entropy_b = tl.load(entropy_b_ptr + offs_m * stride_entropy_b, mask=offs_m < num_tokens, other=0.0)
+    labels = tl.load(labels_ptr + offs_m * stride_labels, mask=offs_m < num_tokens, other=0)
+
+    # iterate over vocab_size
+    d_hidden = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_K), dtype=tl.float32)
+    for n in range(0, tl.cdiv(vocab_size, BLOCK_SIZE_N)):
+        offs_n = n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+
+        hidden_ptrs = hidden_ptr + (offs_m[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+        weight_ptrs = weight_ptr + (offs_n[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+
+        # iterate over hidden_size to get logits
+        logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+        for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+            _hidden = tl.load(
+                hidden_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_m[:, None] < num_tokens),
+                other=0.0,
+            )
+            _weight = tl.load(
+                weight_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_n[:, None] < vocab_size),
+                other=0.0,
+            )
+
+            logits = tl.dot(_hidden, _weight.trans(), logits)
+
+            hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+            weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+
+        # scale logits by temperature
+        logits *= rcp_temperature
+
+        exp_logits = tl.exp(logits - maximum[:, None])
+
+        mask = (offs_n + rank * vocab_size)[None, :] == labels[:, None]
+        d_logits = d_logprobs[:, None] * (exp_logits * accu_rcp[:, None] - mask)
+        d_logits += d_entropy[:, None] * (-exp_logits * accu_rcp[:, None]) * (logits - entropy_b[:, None])
+
+        # scale d_logits
+        d_logits *= rcp_temperature
+
+        # calculate d_hidden
+        weight_ptrs = weight_ptr + (offs_n[:, None] * stride_weight_n + result_offs_k[None, :] * stride_weight_k)
+        _weight = tl.load(
+            weight_ptrs, mask=(result_offs_k[None, :] < hidden_size) & (offs_n[:, None] < vocab_size), other=0.0
+        )
+        d_hidden = tl.dot(d_logits.to(weight_ptr.dtype.element_ty), _weight, d_hidden)
+
+    # write back
+    tl.store(
+        d_hidden_ptr + offs_m[:, None] * stride_d_hidden_m + result_offs_k[None, :] * stride_d_hidden_k,
+        d_hidden,
+        mask=(offs_m[:, None] < num_tokens) & (result_offs_k[None, :] < hidden_size),
+    )
+
+
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 128, "BLOCK_SIZE_K": 32, "GROUP_SIZE_M": 16},
+            num_stages=3,
+            num_warps=8,
+        ),
+    ],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_backward_kernel_d_weight(
+    num_tokens: int,
+    hidden_size: int,
+    vocab_size: int,
+    rank: int,
+    hidden_ptr,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    weight_ptr,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    labels_ptr,
+    stride_labels: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accu_ptr,
+    stride_accu: tl.int64,
+    d_entropy_ptr,
+    stride_d_entropy: tl.int64,
+    d_logprobs_ptr,
+    stride_d_logprobs: tl.int64,
+    reduction: int,
+    entropy_b_ptr,
+    stride_entropy_b: tl.int64,
+    d_weight_ptr,
+    stride_d_weight_n: tl.int64,
+    stride_d_weight_k: tl.int64,
+    rcp_temperature: tl.float32,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+):
+    pid = tl.program_id(axis=0)
+    num_pid_n = tl.cdiv(vocab_size, BLOCK_SIZE_N)
+    pid_n = pid % num_pid_n
+    pid_k = pid // num_pid_n
+
+    offs_n = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+    result_offs_k = pid_k * BLOCK_SIZE_K + offs_k
+
+    d_weight = tl.zeros((BLOCK_SIZE_N, BLOCK_SIZE_K), dtype=tl.float32)
+    for m in range(0, tl.cdiv(num_tokens, BLOCK_SIZE_M)):
+        offs_m = m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+
+        maximum = tl.load(maximum_ptr + offs_m * stride_maximum, mask=offs_m < num_tokens, other=0.0)
+        accu = tl.load(accu_ptr + offs_m * stride_accu, mask=offs_m < num_tokens, other=1e-6)
+        accu_rcp = tl.fdiv(1.0, accu)
+        d_entropy = tl.load(d_entropy_ptr + offs_m * stride_d_entropy, mask=offs_m < num_tokens, other=0.0)
+        if reduction == 0:
+            d_logprobs = tl.load(d_logprobs_ptr + offs_m * stride_d_logprobs, mask=offs_m < num_tokens, other=0.0)
+        elif reduction == 1:
+            d_logprobs = tl.load(d_logprobs_ptr)
+            d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+        else:
+            d_logprobs = tl.fdiv(tl.load(d_logprobs_ptr), num_tokens.to(tl.float32))
+            d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+        d_logprobs = -1 * d_logprobs
+
+        entropy_b = tl.load(entropy_b_ptr + offs_m * stride_entropy_b, mask=offs_m < num_tokens, other=0.0)
+        labels = tl.load(labels_ptr + offs_m * stride_labels, mask=offs_m < num_tokens, other=0)
+
+        hidden_ptrs = hidden_ptr + (offs_m[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+        weight_ptrs = weight_ptr + (offs_n[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+
+        logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+        for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+            _hidden = tl.load(
+                hidden_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_m[:, None] < num_tokens),
+                other=0.0,
+            )
+            _weight = tl.load(
+                weight_ptrs,
+                mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_n[:, None] < vocab_size),
+                other=0.0,
+            )
+
+            logits = tl.dot(_hidden, _weight.trans(), logits)
+
+            hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+            weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+
+        logits *= rcp_temperature
+
+        exp_logits = tl.exp(logits - maximum[:, None])
+
+        mask = (offs_n + rank * vocab_size)[None, :] == labels[:, None]
+        d_logits = d_logprobs[:, None] * (exp_logits * accu_rcp[:, None] - mask)
+        d_logits += d_entropy[:, None] * (-exp_logits * accu_rcp[:, None]) * (logits - entropy_b[:, None])
+
+        d_logits *= rcp_temperature
+
+        hidden_ptrs = hidden_ptr + (offs_m[:, None] * stride_hidden_m + result_offs_k[None, :] * stride_hidden_k)
+        _hidden = tl.load(
+            hidden_ptrs, mask=(result_offs_k[None, :] < hidden_size) & (offs_m[:, None] < num_tokens), other=0.0
+        )
+        d_weight = tl.dot(d_logits.to(d_weight_ptr.dtype.element_ty).trans(), _hidden, d_weight)
+
+    # write back
+    tl.store(
+        d_weight_ptr + offs_n[:, None] * stride_d_weight_n + result_offs_k[None, :] * stride_d_weight_k,
+        d_weight,
+        mask=(offs_n[:, None] < vocab_size) & (result_offs_k[None, :] < hidden_size),
+    )
+
+
+# NOTE: split tile from d_logits' perspective
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 256, "BLOCK_SIZE_K": 32, "GROUP_SIZE_M": 16},
+            num_stages=3,
+            num_warps=8,
+        ),
+    ],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_backward_kernel_general_d_logits(
+    num_tokens: int,
+    hidden_size: int,
+    vocab_size: int,
+    rank: int,
+    hidden_ptr,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    weight_ptr,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    labels_ptr,
+    stride_labels: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accu_ptr,
+    stride_accu: tl.int64,
+    d_entropy_ptr,
+    stride_d_entropy: tl.int64,
+    d_logprobs_ptr,
+    stride_d_logprobs: tl.int64,
+    reduction: int,
+    entropy_b_ptr,
+    stride_entropy_b,
+    d_logits_ptr,
+    stride_d_logits_m: tl.int64,
+    stride_d_logits_n: tl.int64,
+    rcp_temperature: tl.float32,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+):
+    """
+    backward d_logits
+    """
+    # block swizzling
+    # pid = tl.program_id(axis=0)
+    # num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    # pid_m = pid % num_pid_m
+    # pid_n = pid // num_pid_m
+
+    pid = tl.program_id(axis=0)
+    num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    num_pid_n = tl.cdiv(vocab_size, BLOCK_SIZE_N)
+    num_pid_in_group = GROUP_SIZE_M * num_pid_n
+    group_id = pid // num_pid_in_group
+    first_pid_m = group_id * GROUP_SIZE_M
+    group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M)
+    pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m)
+    pid_n = (pid % num_pid_in_group) // group_size_m
+
+    offs_am = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_bn = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+
+    maximum_ptrs = maximum_ptr + offs_am * stride_maximum
+    maximum = tl.load(maximum_ptrs, mask=offs_am < num_tokens, other=0.0)
+    accu_ptrs = accu_ptr + offs_am * stride_accu
+    accu = tl.load(accu_ptrs, mask=offs_am < num_tokens, other=1e-6)  # epsilon to avoid division by zero
+    accu_rcp = tl.fdiv(1.0, accu)
+
+    d_entropy_ptrs = d_entropy_ptr + offs_am * stride_d_entropy
+    d_entropy = tl.load(d_entropy_ptrs, mask=offs_am < num_tokens, other=0.0)
+    if reduction == 0:  # none
+        d_logprobs_ptrs = d_logprobs_ptr + offs_am * stride_d_logprobs
+        d_logprobs = tl.load(d_logprobs_ptrs, mask=offs_am < num_tokens, other=0.0)
+    elif reduction == 1:  # sum
+        d_logprobs = tl.load(d_logprobs_ptr)
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    else:  # mean
+        d_logprobs = tl.fdiv(tl.load(d_logprobs_ptr), num_tokens.to(tl.float32))
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    d_logprobs = -1 * d_logprobs
+
+    entropy_b_ptrs = entropy_b_ptr + offs_am * stride_entropy_b
+    entropy_b = tl.load(entropy_b_ptrs, mask=offs_am < num_tokens, other=0.0)
+
+    hidden_ptrs = hidden_ptr + (offs_am[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+    # weight_ptrs = weight_ptr + (offs_k[:, None] * stride_weight_k + offs_bn[None, :] * stride_weight_n)
+    weight_ptrs = weight_ptr + (offs_bn[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+    labels_ptrs = labels_ptr + offs_am * stride_labels
+    labels = tl.load(labels_ptrs, mask=offs_am < num_tokens, other=0)
+
+    logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+    for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+        _hidden = tl.load(
+            hidden_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+            other=0.0,
+        )
+        # _weight = tl.load(weight_ptrs,
+        #                   mask=(offs_k[:, None] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[None, :] < vocab_size),
+        #                   other=0.0)
+        _weight = tl.load(
+            weight_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[:, None] < vocab_size),
+            other=0.0,
+        )
+
+        logits = tl.dot(_hidden, _weight.trans(), logits)
+
+        hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+        weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+    hidden_ptrs -= hidden_size * stride_hidden_k
+    weight_ptrs -= hidden_size * stride_weight_k
+
+    # scale logits by temperature
+    logits *= rcp_temperature
+
+    exp_logits = tl.exp(logits - maximum[:, None])
+
+    mask = (offs_bn + rank * vocab_size)[None, :] == labels[:, None]
+    d_logits = d_logprobs[:, None] * (exp_logits * accu_rcp[:, None] - mask)
+    d_logits += d_entropy[:, None] * (-exp_logits * accu_rcp[:, None]) * (logits - entropy_b[:, None])
+
+    # scale d_logits by temperature
+    d_logits *= rcp_temperature
+
+    # store d_logits
+    d_logits_ptrs = d_logits_ptr + offs_am[:, None] * stride_d_logits_m + offs_bn[None, :] * stride_d_logits_n
+    tl.store(
+        d_logits_ptrs,
+        d_logits,  # will be implicitly converted to d_logits_ptrs.dtype.element_ty
+        mask=(offs_am[:, None] < num_tokens) & (offs_bn[None, :] < vocab_size),
+    )
+
+
+@triton.autotune(
+    configs=[
+        triton.Config(
+            {"BLOCK_SIZE_M": 128, "BLOCK_SIZE_N": 256, "BLOCK_SIZE_K": 32, "GROUP_SIZE_M": 16},
+            num_stages=3,
+            num_warps=8,
+        ),
+    ],
+    key=["num_tokens", "hidden_size", "vocab_size"],
+)
+@triton.jit
+def efficient_entropy_backward_kernel_general_d_logits_split_N(
+    split_idx: int,
+    num_tokens: int,
+    hidden_size: int,
+    vocab_size: int,
+    vocab_per_split: int,
+    rank: int,
+    hidden_ptr,
+    stride_hidden_m: tl.int64,
+    stride_hidden_k: tl.int64,
+    weight_ptr,
+    stride_weight_n: tl.int64,
+    stride_weight_k: tl.int64,
+    labels_ptr,
+    stride_labels: tl.int64,
+    maximum_ptr,
+    stride_maximum: tl.int64,
+    accu_ptr,
+    stride_accu: tl.int64,
+    d_entropy_ptr,
+    stride_d_entropy: tl.int64,
+    d_logprobs_ptr,
+    stride_d_logprobs: tl.int64,
+    reduction: int,
+    entropy_b_ptr,
+    stride_entropy_b,
+    d_logits_ptr,
+    stride_d_logits_m: tl.int64,
+    stride_d_logits_n: tl.int64,
+    rcp_temperature: tl.float32,
+    BLOCK_SIZE_M: tl.constexpr,
+    BLOCK_SIZE_N: tl.constexpr,
+    BLOCK_SIZE_K: tl.constexpr,
+    GROUP_SIZE_M: tl.constexpr,
+):
+    pid = tl.program_id(axis=0)
+    num_pid_m = tl.cdiv(num_tokens, BLOCK_SIZE_M)
+    num_pid_n = tl.cdiv(vocab_per_split, BLOCK_SIZE_N)
+    num_pid_in_group = GROUP_SIZE_M * num_pid_n
+    group_id = pid // num_pid_in_group
+    first_pid_m = group_id * GROUP_SIZE_M
+    group_size_m = min(num_pid_m - first_pid_m, GROUP_SIZE_M)
+    pid_m = first_pid_m + ((pid % num_pid_in_group) % group_size_m)
+    pid_n = (pid % num_pid_in_group) // group_size_m
+
+    offs_am = pid_m * BLOCK_SIZE_M + tl.arange(0, BLOCK_SIZE_M)
+    offs_bn = split_idx * vocab_per_split + pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    offs_k = tl.arange(0, BLOCK_SIZE_K)
+
+    maximum = tl.load(maximum_ptr + offs_am * stride_maximum, mask=offs_am < num_tokens, other=0.0)
+    accu = tl.load(accu_ptr + offs_am * stride_accu, mask=offs_am < num_tokens, other=1e-6)
+    accu_rcp = tl.fdiv(1.0, accu)
+    d_entropy = tl.load(d_entropy_ptr + offs_am * stride_d_entropy, mask=offs_am < num_tokens, other=0.0)
+    if reduction == 0:
+        d_logprobs = tl.load(d_logprobs_ptr + offs_am * stride_d_logprobs, mask=offs_am < num_tokens, other=0.0)
+    elif reduction == 1:
+        d_logprobs = tl.load(d_logprobs_ptr)
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    else:
+        d_logprobs = tl.fdiv(tl.load(d_logprobs_ptr), num_tokens.to(tl.float32))
+        d_logprobs = tl.broadcast_to(d_logprobs, (BLOCK_SIZE_M,))
+    d_logprobs = -1 * d_logprobs
+    entropy_b = tl.load(entropy_b_ptr + offs_am * stride_entropy_b, mask=offs_am < num_tokens, other=0.0)
+    labels = tl.load(labels_ptr + offs_am * stride_labels, mask=offs_am < num_tokens, other=0)
+
+    hidden_ptrs = hidden_ptr + (offs_am[:, None] * stride_hidden_m + offs_k[None, :] * stride_hidden_k)
+    weight_ptrs = weight_ptr + (offs_bn[:, None] * stride_weight_n + offs_k[None, :] * stride_weight_k)
+
+    vocab_right_bound = min((split_idx + 1) * vocab_per_split, vocab_size)
+    logits = tl.zeros((BLOCK_SIZE_M, BLOCK_SIZE_N), dtype=tl.float32)
+    for k in range(0, tl.cdiv(hidden_size, BLOCK_SIZE_K)):
+        _hidden = tl.load(
+            hidden_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_am[:, None] < num_tokens),
+            other=0.0,
+        )
+        _weight = tl.load(
+            weight_ptrs,
+            mask=(offs_k[None, :] < hidden_size - k * BLOCK_SIZE_K) & (offs_bn[:, None] < vocab_right_bound),
+            other=0.0,
+        )
+        logits = tl.dot(_hidden, _weight.trans(), logits)
+
+        hidden_ptrs += BLOCK_SIZE_K * stride_hidden_k
+        weight_ptrs += BLOCK_SIZE_K * stride_weight_k
+
+    logits *= rcp_temperature
+    exp_logits = tl.exp(logits - maximum[:, None])
+
+    mask = (offs_bn + rank * vocab_size)[None, :] == labels[:, None]
+    d_logits = d_logprobs[:, None] * (exp_logits * accu_rcp[:, None] - mask)
+    d_logits += d_entropy[:, None] * (-exp_logits * accu_rcp[:, None]) * (logits - entropy_b[:, None])
+
+    d_logits *= rcp_temperature
+
+    # filter d_logits with mask
+    result_offs_n = pid_n * BLOCK_SIZE_N + tl.arange(0, BLOCK_SIZE_N)
+    mask = (offs_am[:, None] < num_tokens) & (result_offs_n[None, :] < vocab_per_split)
+
+    tl.store(
+        d_logits_ptr + offs_am[:, None] * stride_d_logits_m + result_offs_n[None, :] * stride_d_logits_n, d_logits, mask
+    )
+
+
+def efficient_entropy_backward(
+    dlogprobs: torch.Tensor,
+    dentropy: torch.Tensor,
+    hidden: torch.Tensor,
+    weight: torch.Tensor,
+    labels: torch.Tensor,
+    maximum: torch.Tensor,
+    acc: torch.Tensor,
+    entropy_b: torch.Tensor,
+    reduction: typing.Optional[int] = 2,
+    should_return_fp32_grad: bool = False,
+    temperature: typing.Optional[float] = 1.0,
+    dist_process_group: typing.Optional[dist.ProcessGroup] = None,
+) -> list[torch.Tensor]:
+    """
+    backward host function
+    """
+    assert hidden.is_cuda and weight.is_cuda and labels.is_cuda
+    assert weight.device == hidden.device and labels.device == hidden.device
+    assert hidden.dim() == 2 and weight.dim() == 2 and labels.dim() == 1
+    assert hidden.is_contiguous() and weight.is_contiguous() and labels.is_contiguous()
+    assert hidden.shape[0] == labels.shape[0] and hidden.shape[1] == weight.shape[1]
+
+    _rank = 0 if dist_process_group is None else dist.get_rank(dist_process_group)
+    _world_size = 1 if dist_process_group is None else dist.get_world_size(dist_process_group)
+
+    num_tokens, hidden_size = hidden.shape
+    num_tokens = labels.shape[0]
+    vocab_size, hidden_size = weight.shape
+    assert hidden_size % 128 == 0
+
+    REDUCTION = get_entropy_reduction_enum(reduction)
+
+    if REDUCTION == EntropyReductionEnum._None:
+        assert dlogprobs.shape == (num_tokens,)
+    else:
+        assert dlogprobs.dim() == 0
+
+    assert dlogprobs.is_contiguous() and dentropy.is_contiguous()
+    assert dlogprobs.is_cuda and dentropy.is_cuda
+    assert dlogprobs.device == hidden.device and dlogprobs.device == dentropy.device
+    assert dentropy.shape == (num_tokens,)
+
+    d_hidden, d_weight = None, None
+    if _config._backward == BackwardEnum._Total_Fuse_MN or should_return_fp32_grad:
+        d_hidden = torch.zeros_like(hidden, dtype=torch.float32, device=hidden.device)
+        d_weight = torch.zeros_like(weight, dtype=torch.float32, device=weight.device)
+    else:
+        d_hidden = torch.empty_like(hidden, dtype=hidden.dtype, device=hidden.device)
+        d_weight = torch.empty_like(weight, dtype=hidden.dtype, device=weight.device)
+    assert d_hidden.is_contiguous() and d_weight.is_contiguous()
+
+    assert maximum.is_contiguous() and acc.is_contiguous()
+    assert maximum.device == hidden.device and acc.device == hidden.device
+    assert maximum.shape == labels.shape == acc.shape
+    assert maximum.is_cuda and acc.is_cuda
+
+    vocab_per_split = 1024
+    assert vocab_per_split % 128 == 0
+    num_splits = (vocab_size + vocab_per_split - 1) // vocab_per_split
+
+    assert entropy_b.is_contiguous() and entropy_b.is_cuda
+    assert entropy_b.shape == (num_tokens,)
+
+    if _config._backward == BackwardEnum._Total_Fuse_MN:
+        # --- Triton doesn't materialize d_logits at all. Split tiles at the perspective of d_logits.
+        def mainloop_grid(meta):
+            return (triton.cdiv(num_tokens, meta["BLOCK_SIZE_M"]) * triton.cdiv(vocab_size, meta["BLOCK_SIZE_N"]),)
+
+        efficient_entropy_backward_kernel_general_mainloop_MN[mainloop_grid](
+            num_tokens,
+            hidden_size,
+            vocab_size,
+            _rank,
+            hidden,
+            hidden.stride(0),
+            hidden.stride(1),
+            weight,
+            weight.stride(0),
+            weight.stride(1),
+            labels,
+            labels.stride(0),
+            maximum,
+            maximum.stride(0),
+            acc,
+            acc.stride(0),
+            dentropy,
+            dentropy.stride(0),
+            dlogprobs,
+            dlogprobs.stride(0) if REDUCTION == EntropyReductionEnum._None else 0,
+            REDUCTION,
+            entropy_b,
+            entropy_b.stride(0),
+            d_hidden,
+            d_hidden.stride(0),
+            d_hidden.stride(1),
+            d_weight,
+            d_weight.stride(0),
+            d_weight.stride(1),
+            1.0 / temperature,
+        )
+
+    elif _config._backward == BackwardEnum._Total_Separate:
+        _d_logits = torch.empty((num_tokens, vocab_size), device=hidden.device, dtype=hidden.dtype).contiguous()
+        assert _d_logits.is_contiguous()
+
+        if _config._use_triton:
+
+            def d_logits_grid(meta):
+                return (triton.cdiv(num_tokens, meta["BLOCK_SIZE_M"]) * triton.cdiv(vocab_size, meta["BLOCK_SIZE_N"]),)
+
+            efficient_entropy_backward_kernel_general_d_logits[d_logits_grid](
+                num_tokens,
+                hidden_size,
+                vocab_size,
+                _rank,
+                hidden,
+                hidden.stride(0),
+                hidden.stride(1),
+                weight,
+                weight.stride(0),
+                weight.stride(1),
+                labels,
+                labels.stride(0),
+                maximum,
+                maximum.stride(0),
+                acc,
+                acc.stride(0),
+                dentropy,
+                dentropy.stride(0),
+                dlogprobs,
+                dlogprobs.stride(0) if REDUCTION == EntropyReductionEnum._None else 0,
+                REDUCTION,
+                entropy_b,
+                entropy_b.stride(0),
+                _d_logits,
+                _d_logits.stride(0),
+                _d_logits.stride(1),
+                1.0 / temperature,
+            )
+
+            torch.matmul(_d_logits, weight, out=d_hidden)
+            torch.matmul(_d_logits.T, hidden, out=d_weight)
+        else:
+            raise AssertionError("Triton is required for efficient entropy kernel")
+
+    elif _config._backward == BackwardEnum._Split_Dlogits_N:
+        vocab_per_split = 9504
+        num_splits = (vocab_size + vocab_per_split - 1) // vocab_per_split
+
+        _d_logits = torch.empty((num_tokens, vocab_per_split), device=hidden.device, dtype=hidden.dtype).contiguous()
+        assert _d_logits.is_contiguous()
+
+        def d_logits_grid(meta):
+            return (triton.cdiv(num_tokens, meta["BLOCK_SIZE_M"]) * triton.cdiv(vocab_per_split, meta["BLOCK_SIZE_N"]),)
+
+        for split_idx in range(num_splits):
+            efficient_entropy_backward_kernel_general_d_logits_split_N[d_logits_grid](
+                split_idx,
+                num_tokens,
+                hidden_size,
+                vocab_size,
+                vocab_per_split,
+                _rank,
+                hidden,
+                hidden.stride(0),
+                hidden.stride(1),
+                weight,
+                weight.stride(0),
+                weight.stride(1),
+                labels,
+                labels.stride(0),
+                maximum,
+                maximum.stride(0),
+                acc,
+                acc.stride(0),
+                dentropy,
+                dentropy.stride(0),
+                dlogprobs,
+                dlogprobs.stride(0) if REDUCTION == EntropyReductionEnum._None else 0,
+                REDUCTION,
+                entropy_b,
+                entropy_b.stride(0),
+                _d_logits,
+                _d_logits.stride(0),
+                _d_logits.stride(1),
+                1.0 / temperature,
+            )
+
+            if split_idx == (num_splits - 1):
+                vocab_right_bound = min((split_idx + 1) * vocab_per_split, vocab_size) - split_idx * vocab_per_split
+                _d_logits = _d_logits[:, :vocab_right_bound].contiguous()
+
+            if split_idx == 0:
+                torch.matmul(
+                    _d_logits, weight[split_idx * vocab_per_split : (split_idx + 1) * vocab_per_split, :], out=d_hidden
+                )
+            else:
+                d_hidden += torch.matmul(
+                    _d_logits, weight[split_idx * vocab_per_split : (split_idx + 1) * vocab_per_split, :]
+                )
+            torch.matmul(
+                _d_logits.T, hidden, out=d_weight[split_idx * vocab_per_split : (split_idx + 1) * vocab_per_split, :]
+            )
+
+    elif _config._backward == BackwardEnum._Split_Dlogits_M:
+        raise NotImplementedError("BackwardEnum._Split_Dlogits_M is not implemented yet")
+
+    return d_hidden, d_weight

verl/verl/utils/kernel/linear_cross_entropy.py

@@ -0,0 +1,119 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+
+# 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 typing
+
+import torch
+import torch.distributed as dist
+
+
+class LinearCrossEntropy(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        hidden: torch.Tensor,
+        weight: torch.Tensor,
+        labels: torch.Tensor,
+        temperature: typing.Optional[float] = 1.0,
+        reduction: typing.Optional[str] = "none",
+        dist_process_group: typing.Optional[dist.ProcessGroup] = None,
+    ) -> list[torch.Tensor]:
+        """_summary_
+
+        Args:
+            ctx (_type_): _description_
+            hidden (torch.Tensor): (batch_size, num_tokens, hidden_size) -> (batch_size * num_tokens, hidden_size)
+            weight (torch.Tensor): (vocab_size, hidden_size)
+            labels (torch.Tensor): (batch_size, num_tokens) -> (batch_size * num_tokens, )
+            temperature (typing.Optional[float], optional): _description_. Defaults to 1.0.
+            reduction (typing.Optional[str], optional): _description_. Defaults to "none".
+            dist_process_group (typing.Optional[dist.ProcessGroup], optional): _description_. Defaults to None.
+
+        Returns:
+            typing.List[torch.Tensor]: _description_
+        """
+
+        assert isinstance(temperature, float), f"temperature must be a float, but got {type(temperature)}"
+        assert isinstance(reduction, str), f"reduction must be a str, but got {type(reduction)}"
+        with torch.cuda.nvtx.range("LinearCrossEntropy-forward"):
+            from . import kernels
+
+            REDUCTION = kernels.get_entropy_reduction_enum_number(reduction.lower())
+
+            original_hidden_shape = hidden.shape
+            if len(hidden.shape) != 2:
+                hidden = hidden.view(-1, hidden.shape[-1])  # (batch_size * num_tokens, hidden_size)
+            if len(labels.shape) != 1:
+                labels = labels.view(-1)
+
+            logprobs, entropy, _maximum, _accumulate, _entropy_b = kernels.efficient_entropy_forward(
+                hidden, weight, labels, REDUCTION, temperature, dist_process_group
+            )
+
+            ctx.save_for_backward(hidden, weight, labels, _maximum, _accumulate, _entropy_b)
+            ctx.original_hidden_shape = original_hidden_shape
+            ctx.REDUCTION = REDUCTION
+            ctx.dist_process_group = dist_process_group
+            ctx.should_return_fp32_grad = False
+            ctx.temperature = temperature
+        return logprobs, entropy
+
+    @staticmethod
+    def backward(ctx, dlogprobs: torch.Tensor, dentropy: torch.Tensor) -> list[torch.Tensor]:
+        from . import kernels
+
+        with torch.cuda.nvtx.range("LinearCrossEntropy-backward"):
+            (hidden, weight, labels, _maximum, _accumulate, _entropy_b) = ctx.saved_tensors
+            REDUCTION = ctx.REDUCTION
+            dist_process_group = ctx.dist_process_group
+            should_return_fp32_grad = ctx.should_return_fp32_grad
+            temperature = ctx.temperature
+
+            d_hidden, d_weight = kernels.efficient_entropy_backward(
+                dlogprobs,
+                dentropy,
+                hidden,
+                weight,
+                labels,
+                _maximum,
+                _accumulate,
+                _entropy_b,
+                REDUCTION,
+                should_return_fp32_grad,
+                temperature,
+                dist_process_group,
+            )
+            d_hidden = d_hidden.view(ctx.original_hidden_shape)
+
+        return (d_hidden, d_weight, None, None, None, None)
+
+
+linear_cross_entropy = LinearCrossEntropy.apply

verl/verl/utils/logger/__init__.py

@@ -0,0 +1,32 @@
+# 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 .aggregate_logger import (
+    DecoratorLoggerBase,
+    LocalLogger,
+    log_with_rank,
+    print_rank_0,
+    print_with_rank,
+    print_with_rank_and_timer,
+)
+
+__all__ = [
+    "LocalLogger",
+    "DecoratorLoggerBase",
+    "print_rank_0",
+    "print_with_rank",
+    "print_with_rank_and_timer",
+    "log_with_rank",
+]

verl/verl/utils/logger/aggregate_logger.py

@@ -0,0 +1,140 @@
+# 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.
+"""
+A Ray logger will receive logging info from different processes.
+"""
+
+import datetime
+import logging
+import numbers
+import pprint
+
+import torch
+
+
+def concat_dict_to_str(dict: dict, step):
+    output = [f"step:{step}"]
+    for k, v in dict.items():
+        if isinstance(v, numbers.Number):
+            output.append(f"{k}:{pprint.pformat(v)}")
+    output_str = " - ".join(output)
+    return output_str
+
+
+class LocalLogger:
+    """
+    A local logger that logs messages to the console.
+
+    Args:
+        print_to_console (bool): Whether to print to the console.
+    """
+
+    def __init__(self, print_to_console=True):
+        self.print_to_console = print_to_console
+
+    def flush(self):
+        pass
+
+    def log(self, data, step):
+        if self.print_to_console:
+            print(concat_dict_to_str(data, step=step), flush=True)
+
+
+class DecoratorLoggerBase:
+    """
+    Base class for all decorators that log messages.
+
+    Args:
+        role (str): The role (the name) of the logger.
+        logger (logging.Logger): The logger instance to use for logging.
+        level (int): The logging level.
+        rank (int): The rank of the process.
+        log_only_rank_0 (bool): If True, only log for rank 0.
+    """
+
+    def __init__(
+        self, role: str, logger: logging.Logger = None, level=logging.DEBUG, rank: int = 0, log_only_rank_0: bool = True
+    ):
+        self.role = role
+        self.logger = logger
+        self.level = level
+        self.rank = rank
+        self.log_only_rank_0 = log_only_rank_0
+        self.logging_function = self.log_by_logging
+        if logger is None:
+            self.logging_function = self.log_by_print
+
+    def log_by_print(self, log_str):
+        if not self.log_only_rank_0 or self.rank == 0:
+            print(f"{self.role} {log_str}", flush=True)
+
+    def log_by_logging(self, log_str):
+        if self.logger is None:
+            raise ValueError("Logger is not initialized")
+        if not self.log_only_rank_0 or self.rank == 0:
+            self.logger.log(self.level, f"{self.role} {log_str}")
+
+
+def print_rank_0(message):
+    """If distributed is initialized, print only on rank 0."""
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            print(message, flush=True)
+    else:
+        print(message, flush=True)
+
+
+def print_with_rank(message: str, rank: int = 0, log_only_rank_0: bool = False):
+    """_summary_
+    Print a message with rank information.
+    This function prints the message only if `log_only_rank_0` is False or if the rank is 0.
+
+    Args:
+        message (str): _description_
+        rank (int, optional): _description_. Defaults to 0.
+        log_only_rank_0 (bool, optional): _description_. Defaults to False.
+    """
+    if not log_only_rank_0 or rank == 0:
+        print(f"[Rank {rank}] {message}", flush=True)
+
+
+def print_with_rank_and_timer(message: str, rank: int = 0, log_only_rank_0: bool = False):
+    """_summary_
+    Print a message with rank information and a timestamp.
+    This function prints the message only if `log_only_rank_0` is False or if the rank is 0.
+
+    Args:
+        message (str): _description_
+        rank (int, optional): _description_. Defaults to 0.
+        log_only_rank_0 (bool, optional): _description_. Defaults to False.
+    """
+    now = datetime.datetime.now()
+    message = f"[{now.strftime('%Y-%m-%d %H:%M:%S')}] [Rank {rank}] {message}"
+    if not log_only_rank_0 or rank == 0:
+        print(message, flush=True)
+
+
+def log_with_rank(message: str, rank, logger: logging.Logger, level=logging.INFO, log_only_rank_0: bool = False):
+    """_summary_
+    Log a message with rank information using a logger.
+    This function logs the message only if `log_only_rank_0` is False or if the rank is 0.
+    Args:
+        message (str): The message to log.
+        rank (int): The rank of the process.
+        logger (logging.Logger): The logger instance to use for logging.
+        level (int, optional): The logging level. Defaults to logging.INFO.
+        log_only_rank_0 (bool, optional): If True, only log for rank 0. Defaults to False.
+    """
+    if not log_only_rank_0 or rank == 0:
+        logger.log(level, f"[Rank {rank}] {message}")

verl/verl/utils/megatron/__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.

verl/verl/utils/megatron/dist_checkpointing.py

@@ -0,0 +1,56 @@
+# 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 megatron.core import dist_checkpointing, mpu
+from megatron.core.dist_checkpointing.serialization import (
+    get_default_load_sharded_strategy,
+    get_default_save_sharded_strategy,
+)
+from megatron.core.dist_checkpointing.strategies.fully_parallel import (
+    FullyParallelLoadStrategyWrapper,
+    FullyParallelSaveStrategyWrapper,
+)
+
+
+def save_dist_checkpointing(sharded_state_dict, ckpt_path, async_save=False):
+    validate_sharding_integrity = True
+    # Get checkpointing strategies
+    save_strategy = get_default_save_sharded_strategy("torch_dist")
+    save_strategy = FullyParallelSaveStrategyWrapper(
+        save_strategy, mpu.get_data_parallel_group(with_context_parallel=True)
+    )
+
+    # Save model sharded state dicts
+    async_save_request = dist_checkpointing.save(
+        sharded_state_dict,
+        ckpt_path,
+        sharded_strategy=save_strategy,
+        async_sharded_save=async_save,
+        validate_access_integrity=validate_sharding_integrity,
+    )
+
+    return async_save_request
+
+
+def load_dist_checkpointing(sharded_state_dict, ckpt_dir):
+    # Get checkpointing strategies
+    load_strategy = get_default_load_sharded_strategy(ckpt_dir)
+    load_strategy = FullyParallelLoadStrategyWrapper(
+        load_strategy, mpu.get_data_parallel_group(with_context_parallel=True)
+    )
+
+    # Load model sharded state dicts
+    state_dict = dist_checkpointing.load(sharded_state_dict, ckpt_dir, sharded_strategy=load_strategy)
+
+    return state_dict

verl/verl/utils/megatron/memory.py

@@ -0,0 +1,38 @@
+# 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 torch
+
+from verl.utils.device import get_device_id
+
+
+class MemoryBuffer:
+    def __init__(self, numel, numel_padded, dtype):
+        self.numel = numel
+        self.numel_padded = numel_padded
+        self.dtype = dtype
+        self.data = torch.zeros(self.numel_padded, dtype=self.dtype, device=get_device_id(), requires_grad=False)
+
+    def zero(self):
+        """Reset the buffer to zero."""
+        self.data.zero_()
+
+    def get(self, shape, start_index):
+        """Return a tensor with the input `shape` as a view into the
+        1-D data starting at `start_index`."""
+        end_index = start_index + shape.numel()
+        assert end_index <= self.numel, "requested tensor is out of the buffer range."
+        buffer_tensor = self.data[start_index:end_index]
+        buffer_tensor = buffer_tensor.view(shape)
+        return buffer_tensor

verl/verl/utils/megatron/optimizer.py

@@ -0,0 +1,108 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# 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 torch
+from megatron.core.optimizer import OptimizerConfig
+from megatron.core.optimizer import get_megatron_optimizer as get_megatron_optimizer_native
+from megatron.core.optimizer_param_scheduler import OptimizerParamScheduler
+
+from verl.utils.logger import print_rank_0
+
+
+def init_megatron_optim_config(optim_config: dict) -> OptimizerConfig:
+    optim_args = {
+        "optimizer": optim_config.optimizer,
+        "lr": optim_config.lr,
+        "min_lr": optim_config.min_lr,
+        "clip_grad": optim_config.clip_grad,
+        "weight_decay": optim_config.weight_decay,
+        "bf16": True,
+        "params_dtype": torch.bfloat16,
+        "use_distributed_optimizer": True,
+    }
+
+    override_config = optim_config.get("override_optimizer_config", {})
+    if override_config:
+        for k, v in override_config.items():
+            optim_args[k] = v
+
+    print_rank_0(f"optimizer config after override: {optim_args}")
+
+    config = OptimizerConfig(**optim_args)
+    return config
+
+
+def get_megatron_optimizer(
+    model,
+    config: OptimizerConfig,
+    no_weight_decay_cond=None,
+    scale_lr_cond=None,
+    lr_mult=1.0,
+):
+    # Base optimizer.
+    return get_megatron_optimizer_native(
+        config=config,
+        model_chunks=model,
+        no_weight_decay_cond=no_weight_decay_cond,
+        scale_lr_cond=scale_lr_cond,
+        lr_mult=lr_mult,
+    )
+
+
+def get_megatron_optimizer_param_scheduler(
+    optimizer,
+    config,
+):
+    """
+    Get the optimizer parameter scheduler for Megatron.
+    """
+    lr_decay_steps = config.lr_decay_steps
+    lr_warmup_steps = config.lr_warmup_steps
+    if config.get("lr_decay_steps", None) is None:
+        lr_decay_steps = config.total_training_steps
+    wsd_decay_steps = None
+    if config.get("lr_wsd_decay_steps", None) is not None:
+        wsd_decay_steps = config.lr_wsd_decay_steps
+    if config.get("lr_warmup_steps_ratio", None) is not None and (
+        config.get("lr_warmup_steps", None) is None or config.lr_warmup_steps <= 0
+    ):
+        lr_warmup_steps = int(config.lr_warmup_steps_ratio * lr_decay_steps)
+
+    opt_param_scheduler = OptimizerParamScheduler(
+        optimizer,
+        init_lr=config.lr_warmup_init,
+        max_lr=config.lr,
+        min_lr=config.min_lr,
+        lr_warmup_steps=lr_warmup_steps,
+        lr_decay_steps=lr_decay_steps,
+        lr_decay_style=config.lr_decay_style,
+        start_wd=config.weight_decay,
+        end_wd=config.weight_decay,
+        wd_incr_steps=config.total_training_steps,
+        wd_incr_style=config.weight_decay_incr_style,
+        use_checkpoint_opt_param_scheduler=config.use_checkpoint_opt_param_scheduler,
+        override_opt_param_scheduler=(not config.use_checkpoint_opt_param_scheduler),
+        wsd_decay_steps=wsd_decay_steps,
+        lr_wsd_decay_style=config.lr_wsd_decay_style,
+    )
+
+    return opt_param_scheduler
+
+
+def get_megatron_last_lr(optimizer):
+    """
+    Get the last learning rate from the optimizer parameter scheduler.
+    """
+    return optimizer.param_groups[0]["lr"]

verl/verl/utils/megatron/pipeline_parallel.py

@@ -0,0 +1,71 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# 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 torch
+from megatron.core import parallel_state as mpu
+
+from .sequence_parallel import pad_to_sequence_parallel
+
+
+def compute_transformers_input_shapes(batches, meta_info):
+    from flash_attn.bert_padding import unpad_input  # flash 2 is a must for Megatron
+
+    # pre-compute input shapes for each micro-batch at each pp stage
+    input_shapes = []
+    for model_inputs in batches:
+        input_ids = model_inputs["input_ids"]
+        attention_mask = model_inputs["attention_mask"]
+        input_ids_rmpad = unpad_input(input_ids.unsqueeze(dim=-1), attention_mask)[0]  # (total_nnz, 1)
+        if meta_info["sequence_parallel"]:
+            input_ids_rmpad = pad_to_sequence_parallel(input_ids_rmpad)
+            # compute shapes for model_inputs
+            input_shapes.append(
+                torch.Size(
+                    [
+                        input_ids_rmpad.shape[0] // mpu.get_tensor_model_parallel_world_size(),
+                        1,
+                        meta_info["hidden_size"],
+                    ]
+                )
+            )
+        else:
+            # compute shapes for model_inputs
+            input_shapes.append(torch.Size([input_ids_rmpad.shape[0], 1, meta_info["hidden_size"]]))
+    return input_shapes
+
+
+def make_batch_generator(batches, vpp_size):
+    """
+    Creates a batch generator suitable for Megatron pipeline parallelism,
+    handling virtual pipeline parallelism (VPP).
+
+    If VPP is used (vpp_size > 1), it duplicates the batch iterator for each
+    virtual pipeline stage. Otherwise, it returns a single iterator.
+
+    Args:
+        batches: An iterable (e.g., list) of micro-batches.
+        vpp_size (int): The virtual pipeline model parallel size.
+
+    Returns:
+        An iterator or a list of iterators over the micro-batches.
+    """
+    if vpp_size > 1:
+        # has vpp
+        batch_generator = [batches] * vpp_size  # number of vpp chunks
+        batch_generator = [iter(b) for b in batch_generator]
+    else:
+        # no vpp
+        batch_generator = iter(batches)
+    return batch_generator

verl/verl/utils/megatron/sequence_parallel.py

@@ -0,0 +1,52 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# 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 torch
+import torch.nn.functional as F
+from megatron.core import parallel_state as mpu
+
+
+def mark_parameter_as_sequence_parallel(parameter):
+    parameter.sequence_parallel = True
+
+
+def is_sequence_parallel_param(param):
+    return hasattr(param, "sequence_parallel") and param.sequence_parallel
+
+
+def pad_to_sequence_parallel(unpad_tokens: torch.Tensor):
+    """pad the tokens such that the total length is a multiple of sp world size
+
+    Args:
+        unpad_tokens: (total_nnz, ...). Tokens after removing padding
+
+    Returns:
+        the padded tokens: (total_nnz + pad_size,...)
+
+    """
+    total_nnz = unpad_tokens.shape[0]
+    sp_world_size = mpu.get_tensor_model_parallel_world_size()
+
+    pad_size = 0 if total_nnz % sp_world_size == 0 else sp_world_size - total_nnz % sp_world_size
+
+    if pad_size > 0:
+        if unpad_tokens.ndim == 1:
+            unpad_tokens = F.pad(unpad_tokens, (0, pad_size))
+        elif unpad_tokens.ndim == 2:
+            unpad_tokens = F.pad(unpad_tokens, (0, 0, 0, pad_size))
+        else:
+            raise NotImplementedError(f"Padding dim {unpad_tokens.ndim()} is not supported")
+
+    return unpad_tokens

verl/verl/utils/megatron/tensor_parallel.py

@@ -0,0 +1,186 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# 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.
+"""
+Utilities for using tensor_parallel in megatron
+"""
+
+from typing import TYPE_CHECKING
+
+import torch
+import torch.distributed as dist
+from megatron.core import parallel_state as mpu
+from torch.nn import init
+
+if TYPE_CHECKING:
+    from megatron.core import ModelParallelConfig
+
+
+def update_kwargs_with_config(dictionary: dict, config: "ModelParallelConfig"):
+    dictionary["config"] = config
+    return dictionary
+
+
+def get_default_kwargs_for_model_parallel_config():
+    model_parallel_config_kwargs = {
+        "params_dtype": torch.float32,
+        "use_cpu_initialization": False,
+        "perform_initialization": True,
+        "gradient_accumulation_fusion": False,
+        "sequence_parallel": False,
+    }
+    return model_parallel_config_kwargs
+
+
+def get_default_model_parallel_config():
+    from megatron.core import ModelParallelConfig
+
+    return ModelParallelConfig(**get_default_kwargs_for_model_parallel_config())
+
+
+def get_common_default_kwargs_for_parallel_linear():
+    default_model_parallel_config = get_default_model_parallel_config()
+    common_default_kwargs = {
+        "init_method": init.xavier_normal_,
+        "stride": 1,
+        "keep_master_weight_for_test": False,
+        "config": default_model_parallel_config,
+    }
+    return common_default_kwargs
+
+
+def get_default_kwargs_for_column_parallel_linear():
+    from megatron.core import ModelParallelConfig
+
+    model_parallel_config_kwargs = get_default_kwargs_for_model_parallel_config()
+    column_parallel_config_kwargs = {
+        "async_tensor_model_parallel_allreduce": False,
+    }
+    model_parallel_config_kwargs.update(column_parallel_config_kwargs)
+    column_default_kwargs = {
+        "config": ModelParallelConfig(**model_parallel_config_kwargs),
+    }
+    common_default_kwargs = get_common_default_kwargs_for_parallel_linear()
+    common_default_kwargs.update(column_default_kwargs)
+    return common_default_kwargs
+
+
+def get_default_kwargs_for_row_parallel_linear():
+    common_default_kwargs = get_common_default_kwargs_for_parallel_linear()
+    return common_default_kwargs
+
+
+def get_default_kwargs_for_parallel_embedding():
+    from megatron.core import ModelParallelConfig
+
+    model_parallel_config_kwargs = get_default_kwargs_for_model_parallel_config()
+    embedding_default_kwargs = {
+        "init_method": init.xavier_normal_,
+        "config": ModelParallelConfig(**model_parallel_config_kwargs),
+    }
+    return embedding_default_kwargs
+
+
+def is_tensor_parallel_param(param):
+    return hasattr(param, "tensor_model_parallel") and param.tensor_model_parallel
+
+
+def get_tensor_parallel_partition_dim(param):
+    assert is_tensor_parallel_param(param)
+    return param.partition_dim
+
+
+def get_tensor_parallel_partition_stride(param):
+    assert is_tensor_parallel_param(param)
+    return param.partition_stride
+
+
+class _VocabParallelEntropy(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, vocab_parallel_logits: torch.Tensor) -> torch.Tensor:
+        @torch.compile(dynamic=True)
+        def mul_reduce(a, b):
+            return (a * b).sum(dim=-1, keepdim=True)
+
+        logits_max = vocab_parallel_logits.max(dim=-1, keepdim=True).values
+        dist.all_reduce(logits_max, op=dist.ReduceOp.MAX, group=mpu.get_tensor_model_parallel_group())
+        normalized_vocab_parallel_logits = vocab_parallel_logits - logits_max
+        normalized_exp_logits = normalized_vocab_parallel_logits.exp_()
+        normalized_sum_exp_logits = normalized_exp_logits.sum(dim=-1, keepdim=True)
+        dist.all_reduce(normalized_sum_exp_logits, group=mpu.get_tensor_model_parallel_group())
+        softmax_logits = normalized_exp_logits.div_(normalized_sum_exp_logits)
+        sum_softmax_times_logits = mul_reduce(softmax_logits, vocab_parallel_logits)
+        dist.all_reduce(sum_softmax_times_logits, group=mpu.get_tensor_model_parallel_group())
+        entropy = logits_max + normalized_sum_exp_logits.log() - sum_softmax_times_logits
+        ctx.save_for_backward(vocab_parallel_logits, softmax_logits, sum_softmax_times_logits)
+        return entropy.squeeze(dim=-1)
+
+    @staticmethod
+    def backward(ctx, grad_output: torch.Tensor) -> torch.Tensor:
+        vocab_parallel_logits, softmax_logits, sum_softmax_times_logits = ctx.saved_tensors
+        # reuse softmax_logits as grad
+        vocab_parallel_logits.sub_(sum_softmax_times_logits)
+        softmax_logits.mul_(vocab_parallel_logits)
+        softmax_logits.mul_(grad_output.unsqueeze(dim=-1))
+        # recover vocab_parallel_logits
+        vocab_parallel_logits.add_(sum_softmax_times_logits)
+        softmax_logits.mul_(-1)
+        return softmax_logits
+
+
+def vocab_parallel_entropy(vocab_parallel_logits: torch.Tensor) -> torch.Tensor:
+    """Compute entropy when the logits are sharded in tp ranks
+
+    Args:
+        vocab_parallel_logits: (total_nnz, vocab_size // tp_size)
+
+    Returns: (total_nnz,)
+
+    """
+    return _VocabParallelEntropy.apply(vocab_parallel_logits)
+
+
+def vocab_parallel_log_probs_from_logits(logits, labels):
+    """TODO(zhangchi.usc1992): We may change the implementation later"""
+    from megatron.core import tensor_parallel
+
+    return -tensor_parallel.vocab_parallel_cross_entropy(vocab_parallel_logits=logits, target=labels)
+
+
+def vocab_parallel_log_probs_from_logits_response_rmpad(input_ids, attention_mask, logits_rmpad, response_length):
+    """Similar to log_probs_from_logits_response_rmpad, but the logits_rmpad is now spliited across tensor parallel
+    region.
+    This will further reduce the peak memory usage during training
+
+    Args:
+        input_ids: [batch_size, seqlen]
+        attention_mask: [batch_size, seqlen]
+        logits_rmpad: [total_nnz, vocab_size // tp_size]
+        response_length: int
+
+    """
+    from flash_attn.bert_padding import pad_input, unpad_input
+
+    batch_size, seqlen = input_ids.shape
+    input_ids_rmpad, indices, *_ = unpad_input(input_ids.unsqueeze(-1), attention_mask=attention_mask)
+    input_ids_rmpad = input_ids_rmpad.squeeze(-1)
+    input_ids_rmpad_rolled = torch.roll(input_ids_rmpad, shifts=-1, dims=0)
+    full_log_probs_rmpad = vocab_parallel_log_probs_from_logits(
+        logits=logits_rmpad, labels=input_ids_rmpad_rolled
+    )  # (total_nnz,)
+    full_output = pad_input(
+        hidden_states=full_log_probs_rmpad.unsqueeze(-1), indices=indices, batch=batch_size, seqlen=seqlen
+    )
+    output = full_output.squeeze(-1)[:, -response_length - 1 : -1]  # [batch_size, response_length]
+    return output

verl/verl/utils/metric/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2025 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 .utils import reduce_metrics
+
+__all__ = ["reduce_metrics"]

verl/verl/utils/metric/utils.py

@@ -0,0 +1,54 @@
+# Copyright 2025 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.
+"""
+Metrics utils.
+"""
+
+from typing import Any
+
+import numpy as np
+
+
+def reduce_metrics(metrics: dict[str, list[Any]]) -> dict[str, Any]:
+    """
+    Reduces a dictionary of metric lists by computing the mean, max, or min of each list.
+    The reduce operation is determined by the key name:
+    - If the key contains "max", np.max is used
+    - If the key contains "min", np.min is used
+    - Otherwise, np.mean is used
+
+    Args:
+        metrics: A dictionary mapping metric names to lists of metric values.
+
+    Returns:
+        A dictionary with the same keys but with each list replaced by its reduced value.
+
+    Example:
+        >>> metrics = {
+        ...     "loss": [1.0, 2.0, 3.0],
+        ...     "accuracy": [0.8, 0.9, 0.7],
+        ...     "max_reward": [5.0, 8.0, 6.0],
+        ...     "min_error": [0.1, 0.05, 0.2]
+        ... }
+        >>> reduce_metrics(metrics)
+        {"loss": 2.0, "accuracy": 0.8, "max_reward": 8.0, "min_error": 0.05}
+    """
+    for key, val in metrics.items():
+        if "max" in key:
+            metrics[key] = np.max(val)
+        elif "min" in key:
+            metrics[key] = np.min(val)
+        else:
+            metrics[key] = np.mean(val)
+    return metrics

verl/verl/utils/profiler/__init__.py

@@ -0,0 +1,40 @@
+# 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 ..device import is_npu_available
+from ..import_utils import is_nvtx_available
+from .performance import GPUMemoryLogger, log_gpu_memory_usage, simple_timer
+from .profile import DistProfiler, DistProfilerExtension, ProfilerConfig
+
+# Select marker implementations by availability, but keep DistProfiler as our dispatcher
+if is_nvtx_available():
+    from .nvtx_profile import mark_annotate, mark_end_range, mark_start_range, marked_timer
+elif is_npu_available:
+    from .mstx_profile import mark_annotate, mark_end_range, mark_start_range, marked_timer
+else:
+    from .performance import marked_timer
+    from .profile import mark_annotate, mark_end_range, mark_start_range
+
+__all__ = [
+    "GPUMemoryLogger",
+    "log_gpu_memory_usage",
+    "mark_start_range",
+    "mark_end_range",
+    "mark_annotate",
+    "DistProfiler",
+    "DistProfilerExtension",
+    "ProfilerConfig",
+    "simple_timer",
+    "marked_timer",
+]

verl/verl/utils/profiler/config.py

@@ -0,0 +1,156 @@
+# 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 warnings
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from omegaconf import MISSING
+
+from verl.base_config import BaseConfig
+
+
+@dataclass
+class NsightToolConfig(BaseConfig):
+    """Nsight tool config."""
+
+    "True for each task has its own database, False for all tasks in one training step share one database."
+    discrete: bool = False
+
+    def __post_init__(self) -> None:
+        pass
+
+
+@dataclass
+class TorchProfilerToolConfig(BaseConfig):
+    """Torch profiler tool config.
+
+    Args:
+        step_start (int): Start step in update_policy.
+        step_end (int): End step.
+    """
+
+    step_start: int = -1
+    step_end: int = -1
+
+    def __post_init__(self) -> None:
+        """config validation logics go here"""
+        warnings.warn("Torch profiler tool config is not fully supported now.", stacklevel=1)
+        assert isinstance(self.step_start, int), f"Profiler step_start must be of type int, got {type(self.step_start)}"
+
+
+@dataclass
+class TorchMemoryToolConfig(BaseConfig):
+    """Torch memory profiler tool config.
+
+    Args:
+        trace_alloc_max_entries (int): Maximum number of memory allocation entries to track.
+        stack_depth (int): Stack trace depth for memory allocations.
+    """
+
+    trace_alloc_max_entries: int = 100_000
+    stack_depth: int = 32
+
+    def __post_init__(self) -> None:
+        """config validation logics go here"""
+        assert isinstance(self.trace_alloc_max_entries, int), (
+            f"trace_alloc_max_entries must be int, got {type(self.trace_alloc_max_entries)}"
+        )
+        assert isinstance(self.stack_depth, int), f"stack_depth must be int, got {type(self.stack_depth)}"
+        assert self.trace_alloc_max_entries > 0, (
+            f"trace_alloc_max_entries must be positive, got {self.trace_alloc_max_entries}"
+        )
+        assert self.stack_depth > 0, f"stack_depth must be positive, got {self.stack_depth}"
+
+
+@dataclass
+class NPUToolConfig(NsightToolConfig):
+    """NPU profiler too; config."""
+
+    # options: npu, cpu, memory, shapes, module, stack
+    contents: list[str] = field(default_factory=list)
+
+    # Collection level, optional values: level_none, level0, level1, level2.
+    level: str = "level1"
+
+    # Whether to automatically parse the data.
+    analysis: bool = False
+
+    def __post_init__(self) -> None:
+        """config validation logics go here"""
+        assert isinstance(self.contents, list), f"Profiler contents must be of type list, got {type(self.contents)}"
+        assert isinstance(self.level, str), f"Profiler level must be of type str, got {type(self.level)}"
+        assert isinstance(self.analysis, bool), f"Profiler analysis must be of type bool, got {type(self.analysis)}"
+        for content in self.contents:
+            assert content in ["npu", "cpu", "memory", "shapes", "module", "stack"], (
+                f"Profiler contents only supports npu, cpu, memory, shapes, module, stack, but gets {content}"
+            )
+        assert self.level in ["level_none", "level0", "level1", "level2"], (
+            f"Profiler level only supports level0, 1, 2, and level_none, but gets {self.level}"
+        )
+
+
+@dataclass
+class ProfilerConfig(BaseConfig):
+    """Worker profiler config.
+
+    The inheritance from BaseConfig provides omegaconf.DictConfig-like interface for a dataclass config.
+
+    Args:
+        discrete (bool): True for each task has its own database, False for all tasks in one training step
+          share one database.
+        all_ranks (bool): Whether to profile all ranks.
+        ranks (list[int]): The ranks that will be profiled. Defaults to [].
+        global_tool_config (Any): Global tool configuration for all profiling tools.
+    """
+
+    tool: Optional[str] = MISSING
+    enable: bool = False
+    all_ranks: bool = False
+    ranks: list[int] = field(default_factory=list)
+    save_path: Optional[str] = MISSING
+    tool_config: Any = MISSING  # Just a placeholder, will use configs above directly
+    global_tool_config: Optional[Any] = None  # Global tool configuration for all profiling tools
+
+    def union(self, other: "ProfilerConfig") -> "ProfilerConfig":
+        assert self.tool == other.tool, f"Cannot union ProfilerConfig with different tools: {self.tool} vs {other.tool}"
+        return ProfilerConfig(
+            tool=self.tool,
+            enable=self.enable or other.enable,
+            all_ranks=self.all_ranks or other.all_ranks,
+            ranks=list(set(self.ranks or []) | set(other.ranks or [])),
+            save_path=self.save_path,
+            tool_config=self.tool_config,
+            global_tool_config=self.global_tool_config or other.global_tool_config,
+        )
+
+    def intersect(self, other: "ProfilerConfig") -> "ProfilerConfig":
+        assert self.tool == other.tool, (
+            f"Cannot intersect ProfilerConfig with different tools: {self.tool} vs {other.tool}"
+        )
+        return ProfilerConfig(
+            tool=self.tool,
+            enable=self.enable and other.enable,
+            all_ranks=self.all_ranks and other.all_ranks,
+            ranks=list(set(self.ranks or []) & set(other.ranks or [])),
+            save_path=self.save_path,
+            tool_config=self.tool_config,
+            global_tool_config=self.global_tool_config if self.global_tool_config else other.global_tool_config,
+        )
+
+    def __post_init__(self) -> None:
+        """config validation logics go here"""
+        assert isinstance(self.ranks, set | list | tuple), (
+            f"Profiler ranks must be of type list, got {type(self.ranks)}"
+        )

verl/verl/utils/profiler/empty_annotations.py

@@ -0,0 +1,40 @@
+# 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 typing import Callable, Optional
+
+
+def mark_start_range(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> None:
+    pass
+
+
+def mark_end_range(range_id: str) -> None:
+    pass
+
+
+def mark_annotate(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> Callable:
+    def decorator(func):
+        return func
+
+    return decorator

verl/verl/utils/profiler/mstx_profile.py

@@ -0,0 +1,271 @@
+# 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.
+
+# Inspired from https://gitee.com/ascend/MindSpeed-RL/blob/master/mindspeed_rl/utils/utils.py
+import functools
+import logging
+import os
+from contextlib import contextmanager
+from typing import Any, Callable, Optional
+
+import torch_npu
+from torch_npu.npu import mstx
+
+from .config import NPUToolConfig
+from .profile import DistProfiler, ProfilerConfig
+
+
+def mark_start_range(message: Optional[str] = None) -> None:
+    """Start a mark range in the profiler.
+
+    Args:
+        message (str, optional):
+            The message to be displayed in the profiler. Defaults to None.
+    """
+    return mstx.range_start(message=message)
+
+
+def mark_end_range(range_id: str) -> None:
+    """End a mark range in the profiler.
+
+    Args:
+        range_id (str):
+            The id of the mark range to end.
+    """
+    return mstx.range_end(range_id)
+
+
+def mark_annotate(message: Optional[str] = None) -> Callable:
+    """Decorate a function to annotate a mark range along with the function life cycle.
+
+    Args:
+        message (str, optional):
+            The message to be displayed in the profiler. Defaults to None.
+    """
+
+    def decorator(func):
+        profile_message = message or func.__name__
+        return mstx.mstx_range(profile_message)(func)
+
+    return decorator
+
+
+@contextmanager
+def marked_timer(name: str, timing_raw: dict[str, float], *args: Any, **kwargs: Any) -> None:
+    """Context manager for timing with MSTX markers.
+
+    This utility function measures the execution time of code within its context,
+    accumulates the timing information, and adds MSTX markers for profiling.
+
+    Args:
+        name (str): The name/identifier for this timing measurement.
+        timing_raw (Dict[str, float]): Dictionary to store timing information.
+
+    Yields:
+        None: This is a context manager that yields control back to the code block.
+    """
+    if args:
+        logging.warning(f"Args are not supported in mstx_profile, but received: {args}")
+    if kwargs:
+        logging.warning(f"Kwargs are not supported in mstx_profile, but received: {kwargs}")
+    mark_range = mark_start_range(message=name)
+    from .performance import _timer
+
+    yield from _timer(name, timing_raw)
+    mark_end_range(mark_range)
+
+
+def get_npu_profiler(
+    contents: list[str],
+    profile_level: str,
+    profile_save_path: str,
+    analysis: bool,
+    role: Optional[str] = None,
+    profile_step: Optional[str] = None,
+):
+    """Generate and return an NPU profiler object.
+
+    Args:
+        contents (list[str]):
+            A list of options to control the collection content,
+            such as npu, cpu, memory, shapes, module, stack.
+        profile_level (str):
+            The collection level, which can be set to level_none,
+            level0, level1 and level2.
+        profile_save_path (str):
+            The path to save the collected data.
+        analysis (bool):
+            Whether to enables automatic data parsing.
+        role (str, optional):
+            The role of the current data collection. Defaults to None.
+        profile_step(str, optional):
+            The current training step. Defaults to None.
+    """
+    if profile_level == "level_none":
+        level = torch_npu.profiler.ProfilerLevel.Level_none
+    elif profile_level == "level0":
+        level = torch_npu.profiler.ProfilerLevel.Level0
+    elif profile_level == "level1":
+        level = torch_npu.profiler.ProfilerLevel.Level1
+    elif profile_level == "level2":
+        level = torch_npu.profiler.ProfilerLevel.Level2
+    else:
+        raise ValueError(f"level only supports level0, 1, 2, and level_none, but gets {profile_level}")
+
+    if profile_step:
+        profile_save_path = os.path.join(profile_save_path, profile_step)
+    if role:
+        profile_save_path = os.path.join(profile_save_path, role)
+
+    experimental_config = torch_npu.profiler._ExperimentalConfig(
+        aic_metrics=torch_npu.profiler.AiCMetrics.PipeUtilization,
+        profiler_level=level,
+        export_type=torch_npu.profiler.ExportType.Text,
+        data_simplification=True,
+        msprof_tx=True,
+    )
+
+    activites = []
+    if contents is None or "npu" in contents:
+        activites.append(torch_npu.profiler.ProfilerActivity.NPU)
+    if contents is None or "cpu" in contents:
+        activites.append(torch_npu.profiler.ProfilerActivity.CPU)
+
+    prof = torch_npu.profiler.profile(
+        with_modules=contents is None or "module" in contents,
+        with_stack=contents is None or "stack" in contents,
+        record_shapes=contents is None or "shapes" in contents,
+        profile_memory=contents is None or "memory" in contents,
+        activities=activites,
+        on_trace_ready=torch_npu.profiler.tensorboard_trace_handler(profile_save_path, analyse_flag=analysis),
+        experimental_config=experimental_config,
+    )
+    return prof
+
+
+class NPUProfiler(DistProfiler):
+    """
+    NPU profiler. Initialized in a worker to control the NPU profiler.
+    """
+
+    _define_count = 0
+
+    def __init__(self, rank: int, config: ProfilerConfig, tool_config: NPUToolConfig, **kwargs):
+        """Initialize the NsightSystemsProfiler.
+
+        Args:
+            rank (int): The rank of the current process.
+            config (Optional[ProfilerConfig]): Configuration for the profiler. If None, a default configuration is used.
+            tool_config (NPUToolConfig): The config to control npu profiler behavior.
+        """
+        if not config:
+            config = ProfilerConfig(ranks=[], enable=False)
+        if not tool_config:
+            assert not config.enable, "tool_config must be set when profiler is enabled"
+        self.enable: bool = config.enable
+        if not config.enable:
+            return
+        self.this_step: bool = False
+        self.discrete: bool = tool_config.discrete
+        self.this_rank: bool = False
+        self.profile_npu = None
+        self.profile_contents = tool_config.contents
+        self.profile_level = tool_config.level
+        self.profile_save_path = config.save_path
+        self.analysis = tool_config.analysis
+        if config.all_ranks:
+            self.this_rank = True
+        elif config.ranks:
+            self.this_rank = rank in config.ranks
+
+    def start(self, **kwargs):
+        role, profile_step = kwargs.get("role", None), kwargs.get("profile_step", None)
+        profile_step = str(profile_step) if profile_step is not None else None
+        if self.enable and self.this_rank:
+            self.this_step = True
+            if not self.discrete and NPUProfiler._define_count == 0:
+                self.profile_npu = get_npu_profiler(
+                    contents=self.profile_contents,
+                    profile_level=self.profile_level,
+                    profile_save_path=self.profile_save_path,
+                    analysis=self.analysis,
+                    role=role,
+                    profile_step=profile_step,
+                )
+                self.profile_npu.start()
+                NPUProfiler._define_count += 1
+
+    def stop(self):
+        if self.enable and self.this_rank:
+            self.this_step = False
+            if not self.discrete and NPUProfiler._define_count == 1:
+                self.profile_npu.step()
+                self.profile_npu.stop()
+                NPUProfiler._define_count -= 1
+
+    def annotate(self, message: Optional[str] = None, role: Optional[str] = None, **kwargs_outer) -> Callable:
+        """Decorate a Worker member function to profile the current rank in the current training step.
+
+        Requires the target function to be a member function of a Worker,
+        which has a member field `profiler` with NPUProfiler type.
+
+        Args:
+            message (str, optional):
+                The message to be displayed in the profiler. Defaults to None.
+            role (str, optional):
+                The role of the current data collection. Defaults to None.
+        """
+
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs_inner):
+                if not self.enable:
+                    return func(*args, **kwargs_inner)
+
+                profile_name = message or func.__name__
+                discrete_mode = self.discrete
+                profile_enable = self.this_step and self.enable
+
+                if not profile_enable:
+                    return func(*args, **kwargs_inner)
+
+                if profile_enable:
+                    if not discrete_mode:
+                        mark_range = mark_start_range(message=profile_name)
+                    else:
+                        profile_npu = get_npu_profiler(
+                            contents=self.profile_contents,
+                            profile_level=self.profile_level,
+                            profile_save_path=self.profile_save_path,
+                            analysis=self.analysis,
+                            role=role,
+                        )
+                        profile_npu.start()
+                        mark_range = mark_start_range(message=profile_name)
+
+                result = func(*args, **kwargs_inner)
+
+                if profile_enable:
+                    if not discrete_mode:
+                        mark_end_range(mark_range)
+                    else:
+                        mark_end_range(mark_range)
+                        profile_npu.step()
+                        profile_npu.stop()
+
+                return result
+
+            return wrapper
+
+        return decorator

verl/verl/utils/profiler/nvtx_profile.py

@@ -0,0 +1,200 @@
+# Copyright 2024 Bytedance Ltd. and/or its affiliates
+# Copyright (c) 2024, NVIDIA CORPORATION. All rights reserved.
+#
+# 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 functools
+from contextlib import contextmanager
+from typing import Callable, Optional
+
+import nvtx
+import torch
+
+from .config import NsightToolConfig
+from .profile import DistProfiler, ProfilerConfig
+
+
+def mark_start_range(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> None:
+    """Start a mark range in the profiler.
+
+    Args:
+        message (str, optional):
+            The message to be displayed in the profiler. Defaults to None.
+        color (str, optional):
+            The color of the range. Defaults to None.
+        domain (str, optional):
+            The domain of the range. Defaults to None.
+        category (str, optional):
+            The category of the range. Defaults to None.
+    """
+    return nvtx.start_range(message=message, color=color, domain=domain, category=category)
+
+
+def mark_end_range(range_id: str) -> None:
+    """End a mark range in the profiler.
+
+    Args:
+        range_id (str):
+            The id of the mark range to end.
+    """
+    return nvtx.end_range(range_id)
+
+
+def mark_annotate(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> Callable:
+    """Decorate a function to annotate a mark range along with the function life cycle.
+
+    Args:
+        message (str, optional):
+            The message to be displayed in the profiler. Defaults to None.
+        color (str, optional):
+            The color of the range. Defaults to None.
+        domain (str, optional):
+            The domain of the range. Defaults to None.
+        category (str, optional):
+            The category of the range. Defaults to None.
+    """
+
+    def decorator(func):
+        profile_message = message or func.__name__
+        return nvtx.annotate(profile_message, color=color, domain=domain, category=category)(func)
+
+    return decorator
+
+
+@contextmanager
+def marked_timer(
+    name: str,
+    timing_raw: dict[str, float],
+    color: str = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+):
+    """Context manager for timing with NVTX markers.
+
+    This utility function measures the execution time of code within its context,
+    accumulates the timing information, and adds NVTX markers for profiling.
+
+    Args:
+        name (str): The name/identifier for this timing measurement.
+        timing_raw (Dict[str, float]): Dictionary to store timing information.
+        color (Optional[str]): Color for the NVTX marker. Defaults to None.
+        domain (Optional[str]): Domain for the NVTX marker. Defaults to None.
+        category (Optional[str]): Category for the NVTX marker. Defaults to None.
+
+    Yields:
+        None: This is a context manager that yields control back to the code block.
+    """
+    mark_range = mark_start_range(message=name, color=color, domain=domain, category=category)
+    from .performance import _timer
+
+    yield from _timer(name, timing_raw)
+    mark_end_range(mark_range)
+
+
+class NsightSystemsProfiler(DistProfiler):
+    """Nsight system profiler. Installed in a worker to control the Nsight system profiler."""
+
+    def __init__(self, rank: int, config: Optional[ProfilerConfig], tool_config: Optional[NsightToolConfig], **kwargs):
+        """Initialize the NsightSystemsProfiler.
+
+        Args:
+            rank (int): The rank of the current process.
+            config (Optional[ProfilerConfig]): Configuration for the profiler. If None, a default configuration is used.
+        """
+        # If no configuration is provided, create a default ProfilerConfig with an empty list of ranks
+        if not config:
+            config = ProfilerConfig(ranks=[])
+        if not tool_config:
+            assert not config.enable, "tool_config must be provided when profiler is enabled"
+        self.enable = config.enable
+        if not config.enable:
+            return
+        self.this_step: bool = False
+        self.discrete: bool = tool_config.discrete
+        self.this_rank: bool = False
+        if config.all_ranks:
+            self.this_rank = True
+        elif config.ranks:
+            self.this_rank = rank in config.ranks
+
+    def start(self, **kwargs):
+        if self.enable and self.this_rank:
+            self.this_step = True
+            if not self.discrete:
+                torch.cuda.profiler.start()
+
+    def stop(self):
+        if self.enable and self.this_rank:
+            self.this_step = False
+            if not self.discrete:
+                torch.cuda.profiler.stop()
+
+    def annotate(
+        self,
+        message: Optional[str] = None,
+        color: Optional[str] = None,
+        domain: Optional[str] = None,
+        category: Optional[str] = None,
+        **kwargs_outer,
+    ) -> Callable:
+        """Decorate a Worker member function to profile the current rank in the current training step.
+
+        Requires the target function to be a member function of a Worker, which has a member field `profiler` with
+        NightSystemsProfiler type.
+
+        Args:
+            message (str, optional):
+                The message to be displayed in the profiler. Defaults to None.
+            color (str, optional):
+                The color of the range. Defaults to None.
+            domain (str, optional):
+                The domain of the range. Defaults to None.
+            category (str, optional):
+                The category of the range. Defaults to None.
+        """
+
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs_inner):
+                if not self.enable:
+                    return func(*args, **kwargs_inner)
+
+                profile_name = message or func.__name__
+
+                if self.this_step:
+                    if self.discrete:
+                        torch.cuda.profiler.start()
+                    mark_range = mark_start_range(message=profile_name, color=color, domain=domain, category=category)
+
+                result = func(*args, **kwargs_inner)
+
+                if self.this_step:
+                    mark_end_range(mark_range)
+                    if self.discrete:
+                        torch.cuda.profiler.stop()
+
+                return result
+
+            return wrapper
+
+        return decorator

verl/verl/utils/profiler/performance.py

@@ -0,0 +1,240 @@
+# 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 datetime
+import inspect
+import logging
+from contextlib import contextmanager
+from typing import Any, Optional
+
+import torch
+import torch.distributed as dist
+from codetiming import Timer
+
+from verl.utils.device import get_device_id, get_torch_device
+from verl.utils.logger import DecoratorLoggerBase
+
+
+def _get_current_mem_info(unit: str = "GB", precision: int = 2) -> tuple[str]:
+    """Get current memory usage.
+
+    Note that CPU device memory info is always 0.
+
+    Args:
+        unit (str, optional): The unit of memory measurement. Defaults to "GB".
+        precision (int, optional): The number of decimal places to round memory values. Defaults to 2.
+
+    Returns:
+        tuple[str]: A tuple containing memory allocated, memory reserved, memory used, and memory total
+        in the specified unit.
+    """
+    assert unit in ["GB", "MB", "KB"]
+    device = get_torch_device()
+    # torch.cpu.memory_allocated() does not exist
+    if device == torch.cpu:
+        return "0.00", "0.00", "0.00", "0.00"
+
+    divisor = 1024**3 if unit == "GB" else 1024**2 if unit == "MB" else 1024
+    mem_allocated = get_torch_device().memory_allocated()
+    mem_reserved = get_torch_device().memory_reserved()
+    # use get_torch_device().mem_get_info to profile device memory
+    # since vllm's sleep mode works below pytorch
+    # see https://github.com/vllm-project/vllm/pull/11743#issuecomment-2754338119
+    mem_free, mem_total = get_torch_device().mem_get_info()
+    mem_used = mem_total - mem_free
+    mem_allocated = f"{mem_allocated / divisor:.{precision}f}"
+    mem_reserved = f"{mem_reserved / divisor:.{precision}f}"
+    mem_used = f"{mem_used / divisor:.{precision}f}"
+    mem_total = f"{mem_total / divisor:.{precision}f}"
+    return mem_allocated, mem_reserved, mem_used, mem_total
+
+
+def log_gpu_memory_usage(head: str, logger: logging.Logger = None, level=logging.DEBUG, rank: int = 0):
+    """Log GPU memory usage information.
+
+    Args:
+        head (str): A descriptive header for the memory usage log message.
+        logger (logging.Logger, optional): Logger instance to use for logging. If None, prints to stdout.
+        level: Logging level to use. Defaults to logging.DEBUG.
+        rank (int): The rank of the process to log memory for. Defaults to 0.
+    """
+    if (not dist.is_initialized()) or (rank is None) or (dist.get_rank() == rank):
+        mem_allocated, mem_reserved, mem_used, mem_total = _get_current_mem_info()
+        message = (
+            f"{head}, memory allocated (GB): {mem_allocated}, memory reserved (GB): {mem_reserved}, "
+            f"device memory used/total (GB): {mem_used}/{mem_total}"
+        )
+
+        if logger is None:
+            print(message)
+        else:
+            logger.log(msg=message, level=level)
+
+
+class GPUMemoryLogger(DecoratorLoggerBase):
+    """A decorator class to log GPU memory usage.
+
+    Example:
+        >>> from verl.utils.profiler.performance import GPUMemoryLogger
+        >>> @GPUMemoryLogger(role="actor")
+        >>> def update_actor(self, batch):
+        ...     # real actor update logics
+        ...     return
+    """
+
+    def __init__(self, role: str, logger: logging.Logger = None, level=logging.DEBUG, log_only_rank_0: bool = True):
+        if dist.is_initialized() and dist.get_world_size() > 1:
+            rank = dist.get_rank()
+        else:
+            rank = 0
+        super().__init__(role, logger, level, rank, log_only_rank_0)
+
+    def __call__(self, decorated_function: callable):
+        def f(*args, **kwargs):
+            return self.log(decorated_function, *args, **kwargs)
+
+        return f
+
+    def log(self, func, *args, **kwargs):
+        name = func.__name__
+        mem_allocated, mem_reserved, mem_used, mem_total = _get_current_mem_info()
+        message = (
+            f"Before {name}, memory allocated (GB): {mem_allocated}, memory reserved (GB): {mem_reserved}, "
+            f"device memory used/total (GB): {mem_used}/{mem_total}"
+        )
+        self.logging_function(message)
+
+        output = func(*args, **kwargs)
+
+        mem_allocated, mem_reserved, mem_used, mem_total = _get_current_mem_info()
+        message = (
+            f"After {name}, memory allocated (GB): {mem_allocated}, memory reserved (GB): {mem_reserved}, "
+            f"device memory used/total (GB): {mem_used}/{mem_total}"
+        )
+
+        self.logging_function(message)
+        return output
+
+
+def log_print(ctn: Any):
+    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    frame = inspect.currentframe().f_back
+    function_name = frame.f_code.co_name
+    line_number = frame.f_lineno
+    file_name = frame.f_code.co_filename.split("/")[-1]
+    print(f"[{current_time}-{file_name}:{line_number}:{function_name}]: {ctn}")
+
+
+def _timer(name: str, timing_raw: dict[str, float]):
+    """Inner function that handles the core timing logic.
+
+    Args:
+        name (str): The name/identifier for this timing measurement.
+        timing_raw (Dict[str, float]): Dictionary to store timing information.
+    """
+    with Timer(name=name, logger=None) as timer:
+        yield
+    if name not in timing_raw:
+        timing_raw[name] = 0
+    timing_raw[name] += timer.last
+
+
+@contextmanager
+def simple_timer(name: str, timing_raw: dict[str, float]):
+    """Context manager for basic timing without NVTX markers.
+
+    This utility function measures the execution time of code within its context
+    and accumulates the timing information in the provided dictionary.
+
+    Args:
+        name (str): The name/identifier for this timing measurement.
+        timing_raw (Dict[str, float]): Dictionary to store timing information.
+
+    Yields:
+        None: This is a context manager that yields control back to the code block.
+    """
+    yield from _timer(name, timing_raw)
+
+
+@contextmanager
+def marked_timer(
+    name: str,
+    timing_raw: dict[str, float],
+    color: str = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+):
+    """Context manager for timing with platform markers.
+
+    This utility function measures the execution time of code within its context,
+    accumulates the timing information, and adds platform markers for profiling.
+    This function is a default implementation when hardware profiler is not available.
+
+    Args:
+        name (str): The name/identifier for this timing measurement.
+        timing_raw (Dict[str, float]): Dictionary to store timing information.
+        color (Optional[str]): Color for the marker. Defaults to None.
+        domain (Optional[str]): Domain for the marker. Defaults to None.
+        category (Optional[str]): Category for the marker. Defaults to None.
+
+    Yields:
+        None: This is a context manager that yields control back to the code block.
+    """
+    yield from _timer(name, timing_raw)
+
+
+def reduce_timing(
+    timing_raw: dict[str, float], reduce_op: torch.distributed.ReduceOp = torch.distributed.ReduceOp.AVG
+) -> dict[str, float]:
+    """Reduce timing information across all processes.
+
+    This function uses distributed communication to gather and sum the timing
+    information from all processes in a distributed environment.
+
+    Args:
+        timing_raw (Dict[str, float]): Dictionary containing timing information.
+
+    Returns:
+        Dict[str, float]: Reduced timing information.
+    """
+    if not dist.is_initialized():
+        return timing_raw
+
+    key_list, timing_list = [], []
+    for key in sorted(timing_raw.keys()):
+        key_list.append(key)
+        timing_list.append(timing_raw[key])
+    timing_list = torch.tensor(timing_list, dtype=torch.float32, device=get_device_id())
+    torch.distributed.all_reduce(timing_list, op=reduce_op)
+    timing_list = [tensor.item() for tensor in timing_list.to("cpu")]
+    timing_generate = {key_list[i]: timing_list[i] for i in range(len(key_list))}
+    return timing_generate
+
+
+def topk_reduce_ratio_min_max(timing: float, k: int = 10) -> tuple[float, float, float]:
+    """Calculate topk items take-up ratio, and min/max timing across all ranks."""
+    if not dist.is_initialized():
+        return -1.0, -1.0, -1.0
+
+    world_size = dist.get_world_size()
+    timing_tensor = torch.tensor(timing, dtype=torch.float32, device=get_device_id())
+    tensor_list = [torch.zeros(1, dtype=torch.float32, device=get_device_id()) for _ in range(world_size)]
+    torch.distributed.all_gather(tensor_list, timing_tensor)
+    tensor_stack = torch.stack(tensor_list)
+    timing_min = tensor_stack.min().cpu().item()
+    timing_max = tensor_stack.max().cpu().item()
+    top_k_percentile = torch.quantile(tensor_stack, 1 - k / 100)
+    tail_ratio = torch.mean((tensor_stack > top_k_percentile).float()).cpu().item()
+    return tail_ratio, timing_min, timing_max

verl/verl/utils/profiler/profile.py

@@ -0,0 +1,371 @@
+# 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 functools
+import os
+from typing import Callable, Optional
+
+import torch
+import torch.distributed
+
+from ..memory_utils import MemorySnapshotSampler, enable_memory_visualize
+from .config import ProfilerConfig, TorchMemoryToolConfig, TorchProfilerToolConfig
+
+
+class Profiler:
+    """A PyTorch profiler wrapper class for collecting performance metrics.
+
+    TODO(haibin.lin): this should implement the DistProfiler interface, and the config should be unified.
+
+    This profiler provides a convenient interface for profiling PyTorch operations,
+    with support for:
+
+    - CPU and CUDA activity profiling
+    - Configurable profiling schedule (wait/warmup/active steps)
+    - Multi-rank profiling support
+    - Chrome trace export
+
+    Args:
+        config: Configuration object containing profiling parameters
+    """
+
+    def __init__(self, config: ProfilerConfig, tool_config: Optional[TorchProfilerToolConfig] = None):
+        # note : if we do not set use_profile, it will be set as None, so that all function will be skip
+        if not config:
+            config = ProfilerConfig(ranks=[], enable=False)
+        if not tool_config:
+            assert not config.enable, "tool_config must be provided when profiler is enabled"
+        self.prof = None
+        self.saved = False
+        self.enable = config.enable
+        if not config.enable:
+            return
+        self.config = config
+        self.tool_config = tool_config
+        self.rank = torch.distributed.get_rank()
+        # we need to validate the config before using the profiler
+        self._validate()
+        if self.rank in self.config.profile_ranks:
+            print(f"[Profiler] Profiler init for rank {self.rank}")
+
+            self.prof = torch.profiler.profile(
+                activities=[
+                    torch.profiler.ProfilerActivity.CPU,
+                    torch.profiler.ProfilerActivity.CUDA,
+                ],
+                schedule=torch.profiler.schedule(
+                    wait=max(self.tool_config.step_start - 1, 0),
+                    warmup=1 if self.tool_config.step_start > 0 else 0,
+                    active=self.tool_config.step_end - self.tool_config.step_start,
+                    repeat=1,
+                ),
+                record_shapes=True,
+                with_stack=True,
+            )
+
+    def _validate(self):
+        if self.enable:
+            if self.config.profile_ranks is None:
+                print("[WARNING] Profile ranks is not set, default to rank 0")
+                self.config.profile_ranks = [0]
+            assert self.tool_config.step_start >= 0, "[ERROR] Profile step start must be greater than 0"
+            assert self.tool_config.step_end >= 0, "[ERROR] Profile step end must be greater than 0"
+            assert self.tool_config.step_start < self.tool_config.step_end, (
+                "[ERROR] Profile step start must be less than step end"
+            )
+
+    def check(self):
+        return self.prof is not None and self.enable
+
+    def start(self):
+        if self.check():
+            print(f"[Profiler] started for rank {self.rank}")
+            self.prof.start()
+
+    def step(self):
+        if self.check():
+            self.prof.step()
+
+    def stop(self):
+        if self.check():
+            print(f"[Profiler] stopped for rank {self.rank}")
+            self.prof.stop()
+
+    def save(self):
+        if self.prof is not None and not self.saved:
+            if not os.path.exists(self.config.save_path):
+                os.makedirs(self.config.save_path)
+            save_file_name = f"/prof_start_{self.config.step_start}_end_{self.config.step_end}_rank_{self.rank}.json"
+            print(f"[Profiler] Saving trace to {self.config.save_path + save_file_name}")
+            self.prof.export_chrome_trace(self.config.save_path + save_file_name)
+            self.enable = False
+            self.saved = True
+
+    def stop_and_save(self):
+        if self.check():
+            self.stop()
+            self.save()
+
+    def stop_trace(self):
+        if self.check():
+            print(f"[Profiler] Trace stopped for rank {self.rank}")
+            self.enable = False
+
+
+def mark_start_range(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> None:
+    """Start a profiling range marker (no-op implementation).
+
+    Args:
+        message (Optional[str]): Message to associate with the range marker.
+        color (Optional[str]): Color for the marker visualization.
+        domain (Optional[str]): Domain for the marker.
+        category (Optional[str]): Category for the marker.
+    """
+    pass
+
+
+def mark_end_range(range_id: str) -> None:
+    """End a profiling range marker (no-op implementation).
+
+    Args:
+        range_id (str): Identifier of the range to end.
+    """
+    pass
+
+
+def mark_annotate(
+    message: Optional[str] = None,
+    color: Optional[str] = None,
+    domain: Optional[str] = None,
+    category: Optional[str] = None,
+) -> Callable:
+    """Decorator to annotate a function with profiling markers (no-op implementation).
+
+    Args:
+        message (Optional[str]): Message to associate with the annotation.
+        color (Optional[str]): Color for the marker visualization.
+        domain (Optional[str]): Domain for the marker.
+        category (Optional[str]): Category for the marker.
+
+    Returns:
+        Callable: Decorator function that returns the original function unchanged.
+    """
+
+    def decorator(func):
+        return func
+
+    return decorator
+
+
+class DistProfiler:
+    """A dispatcher that delegates to specific profilers based on config.tool.
+
+    Supported tools:
+    - nsys: NsightSystemsProfiler
+    - npu: NPUProfiler (Ascend)
+    - torch: PyTorch torch.profiler wrapper
+    - torch_memory: Torch CUDA memory snapshot dump
+    """
+
+    def __init__(
+        self, rank: int, config: Optional[ProfilerConfig] = None, tool_config: Optional[object] = None, **kwargs
+    ):
+        # Default config
+        if not config:
+            config = ProfilerConfig(ranks=[], enable=False)
+
+        self._impl = None
+        self._tool = getattr(config, "tool", None)
+
+        # Normalize rank selection
+        self._this_rank = False
+        if config.all_ranks:
+            self._this_rank = True
+        elif config.ranks:
+            self._this_rank = rank in config.ranks
+        else:
+            # default rank 0 if enabled but ranks unspecified
+            self._this_rank = (rank == 0) if config.enable else False
+
+        # Lazy import to avoid circular deps
+        if self._tool == "nsys":
+            from .nvtx_profile import NsightSystemsProfiler as _Nsight
+
+            self._impl = _Nsight(rank=rank, config=config, tool_config=tool_config, **kwargs)
+        elif self._tool == "npu":
+            from .mstx_profile import NPUProfiler as _Npu
+
+            self._impl = _Npu(rank=rank, config=config, tool_config=tool_config, **kwargs)
+        elif self._tool == "torch":
+            # Use the torch profiler wrapper defined above
+            self._impl = Profiler(config=config, tool_config=tool_config)
+        elif self._tool == "torch_memory":
+            self._impl = TorchMemoryProfiler(rank=rank, config=config, tool_config=tool_config)
+        else:
+            # Fallback to a no-op impl
+            self._impl = _NoOpProfiler()
+
+    def start(self, **kwargs):
+        return getattr(self._impl, "start", lambda **_: None)(**kwargs)
+
+    def stop(self):
+        return getattr(self._impl, "stop", lambda: None)()
+
+    @classmethod
+    def annotate(
+        cls,
+        message: Optional[str] = None,
+        color: Optional[str] = None,
+        domain: Optional[str] = None,
+        category: Optional[str] = None,
+        **kwargs_outer,
+    ) -> Callable:
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(self_instance, *args, **kwargs_inner):
+                profiler = getattr(self_instance, "profiler", None)
+                if not profiler:
+                    return func(self_instance, *args, **kwargs_inner)
+
+                impl = profiler._impl
+                if hasattr(impl, "annotate"):
+                    try:
+                        actual_decorator = impl.annotate(
+                            message=message, color=color, domain=domain, category=category, **kwargs_outer
+                        )
+
+                        return actual_decorator(func)(self_instance, *args, **kwargs_inner)
+                    except Exception:
+                        return func(self_instance, *args, **kwargs_inner)
+                return func(self_instance, *args, **kwargs_inner)
+
+            return wrapper
+
+        return decorator
+
+
+class _NoOpProfiler:
+    def start(self, **kwargs):
+        return
+
+    def stop(self):
+        return
+
+
+class TorchMemoryProfiler:
+    """Profiler that dumps CUDA memory snapshots at step boundaries.
+
+    Behavior:
+    - On first construction (per process), enable memory history recording if CUDA is available
+    - On start(step=X), remember sub_dir for this step
+    - On stop(), dump a memory snapshot into config.save_path under the remembered sub_dir
+    """
+
+    _memory_history_enabled: bool = False
+
+    def __init__(
+        self, rank: int, config: Optional[ProfilerConfig], tool_config: Optional[TorchMemoryToolConfig] = None
+    ):
+        # Always respond to explicit start/stop calls for torch_memory tool,
+        # regardless of per-role enable flag, to align with global step control.
+        self.enable = True
+        if not config:
+            config = ProfilerConfig(ranks=[])
+        self.config = config
+        self.rank = rank
+        self.this_step = False
+        self.sub_dir = None
+        self.sampler = MemorySnapshotSampler()
+
+        # Get parameters from tool_config, with fallback to defaults
+        if tool_config:
+            trace_alloc_max_entries = tool_config.trace_alloc_max_entries
+            stack_depth = tool_config.stack_depth
+        else:
+            trace_alloc_max_entries = 100_000
+            stack_depth = 32
+
+        # Best-effort enable memory history once
+        if not TorchMemoryProfiler._memory_history_enabled:
+            try:
+                enable_memory_visualize(trace_alloc_max_entries=trace_alloc_max_entries, stack_depth=stack_depth)
+            except Exception:
+                # silently ignore if not supported
+                pass
+            TorchMemoryProfiler._memory_history_enabled = True
+
+    def start(self, **kwargs):
+        if not self.enable:
+            return
+        if not self._should_profile_this_rank():
+            return
+        profile_step = kwargs.get("profile_step", None)
+        # Keep ranks aligned under same folder name
+        self.sub_dir = f"step{profile_step}" if profile_step is not None else None
+        self.this_step = True
+
+    def stop(self):
+        if not self.enable or not self.this_step:
+            return
+        self.this_step = False
+        if not self._should_profile_this_rank():
+            return
+        out_dir = self.config.save_path or "outputs/profile"
+        tag = "torch_memory"
+        # Dump snapshot; all ranks write into same sub_dir
+        try:
+            self.sampler.dump_memory_snapshot(out_dir=out_dir, tag=tag, sub_dir=self.sub_dir)
+        except Exception:
+            pass
+
+    def _should_profile_this_rank(self) -> bool:
+        if self.config.all_ranks:
+            return True
+        if self.config.ranks:
+            return self.rank in self.config.ranks
+        # default rank 0
+        return self.rank == 0
+
+
+class DistProfilerExtension:
+    """An extension class for DistProfiler that provides distributed profiling capabilities.
+
+    It is intended for workers in verl that single controller invokes.
+
+    This class wraps a DistProfiler instance and provides methods to start/stop profiling
+    that can be dispatched across multiple ranks in a distributed training environment.
+
+    Args:
+        profiler (DistProfiler): The base distributed profiler instance to extend
+    """
+
+    def __init__(self, profiler: DistProfiler):
+        self.profiler = profiler
+
+    from verl.single_controller.base.decorator import Dispatch, register
+
+    @register(dispatch_mode=Dispatch.ONE_TO_ALL)
+    def start_profile(self, **kwargs) -> None:
+        """Start profiling for the current rank in the current training step."""
+        self.profiler.start(**kwargs)
+
+    @register(dispatch_mode=Dispatch.ONE_TO_ALL)
+    def stop_profile(self) -> None:
+        """Stop profiling for the current rank in the current training step."""
+        self.profiler.stop()

verl/verl/utils/rendezvous/__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.

verl/verl/utils/rendezvous/ray_backend.py

@@ -0,0 +1,73 @@
+# 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 logging
+import time
+
+import ray
+from cupy.cuda.nccl import NcclCommunicator, get_unique_id
+from ray.util import list_named_actors
+
+
+@ray.remote
+class NCCLIDStore:
+    def __init__(self, nccl_id):
+        self._nccl_id = nccl_id
+
+    def get(self):
+        return self._nccl_id
+
+
+def get_nccl_id_store_by_name(name):
+    all_actors = list_named_actors(all_namespaces=True)
+    matched_actors = [actor for actor in all_actors if actor.get("name", None) == name]
+    if len(matched_actors) == 1:
+        actor = matched_actors[0]
+        return ray.get_actor(**actor)
+    elif len(matched_actors) > 1:
+        logging.warning("multiple actors with same name found: %s", matched_actors)
+    elif len(matched_actors) == 0:
+        logging.info("failed to get any actor named %s", name)
+    return None
+
+
+def create_nccl_communicator_in_ray(
+    rank: int, world_size: int, group_name: str, max_retries: int = 100, interval_s: int = 5
+):
+    if rank == 0:
+        nccl_id = get_unique_id()
+        nccl_id_store = NCCLIDStore.options(name=group_name).remote(nccl_id)
+
+        assert ray.get(nccl_id_store.get.remote()) == nccl_id
+        communicator = NcclCommunicator(
+            ndev=world_size,
+            commId=nccl_id,
+            rank=0,
+        )
+        return communicator
+    else:
+        for i in range(max_retries):
+            nccl_id_store = get_nccl_id_store_by_name(group_name)
+            if nccl_id_store is not None:
+                logging.info("nccl_id_store %s got", group_name)
+                nccl_id = ray.get(nccl_id_store.get.remote())
+                logging.info("nccl id for %s got: %s", group_name, nccl_id)
+                communicator = NcclCommunicator(
+                    ndev=world_size,
+                    commId=nccl_id,
+                    rank=rank,
+                )
+                return communicator
+            logging.info("failed to get nccl_id for %d time, sleep for %d seconds", i + 1, interval_s)
+            time.sleep(interval_s)

verl/verl/utils/reward_score/__init__.py

@@ -0,0 +1,134 @@
+# 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 . import gsm8k, math, prime_math, prime_code
+
+from verl.utils.import_utils import deprecated
+
+
+def default_compute_score(
+    data_source,
+    solution_str,
+    ground_truth,
+    extra_info=None,
+    sandbox_fusion_url=None,
+    concurrent_semaphore=None,
+    memory_limit_mb=None,
+):
+    """Compute the score for a given solution based on the data source.
+
+    Args:
+        data_source (str): The source dataset identifier which determines the scoring method.
+        solution_str (str): The solution string to be evaluated.
+        ground_truth (str): The ground truth answer for comparison.
+        extra_info (dict, optional): Additional information that might be needed for scoring. Defaults to None.
+
+    Returns:
+        float: The computed score as a floating point number. If the result is a dictionary,
+               it returns the dictionary instead.
+
+    Raises:
+        NotImplementedError: If the reward function is not implemented for the given data source.
+    """
+    if data_source == "openai/gsm8k":
+        from . import gsm8k
+
+        res = gsm8k.compute_score(solution_str, ground_truth)
+    elif data_source in ["lighteval/MATH", "DigitalLearningGmbH/MATH-lighteval", "HuggingFaceH4/MATH-500"]:
+        from . import math_reward
+
+        res = math_reward.compute_score(solution_str, ground_truth)
+        # [Optional] Math-Verify Integration
+        # For enhanced accuracy, consider utilizing Math-Verify (https://github.com/huggingface/Math-Verify).
+        # Note: Math-Verify needs to be manually installed via pip: `pip install math-verify`.
+        # To use it, override the `compute_score` function with the following implementation:
+
+        # from . import math_verify
+        # res = math_verify.compute_score(solution_str, ground_truth)
+    elif data_source in ["math_dapo", "math", "math_dapo_reasoning"] or data_source.startswith("aime"):
+        from . import math_dapo
+
+        res = math_dapo.compute_score(solution_str, ground_truth)
+    elif data_source in [
+        "numina_aops_forum",
+        "numina_synthetic_math",
+        "numina_amc_aime",
+        "numina_synthetic_amc",
+        "numina_cn_k12",
+        "numina_olympiads",
+    ]:
+        from . import prime_math
+
+        res = prime_math.compute_score(solution_str, ground_truth)
+    elif data_source in ["codecontests", "apps", "codeforces", "taco"]:
+        # Use the passed sandbox_fusion_url if available
+        if sandbox_fusion_url:
+            from . import sandbox_fusion
+
+            # Pass the URL directly, ground_truth likely contains test cases here
+            res = sandbox_fusion.compute_score(
+                sandbox_fusion_url, concurrent_semaphore, memory_limit_mb, solution_str, ground_truth, continuous=True
+            )
+        else:
+            # If no sandbox URL is provided, fall back to prime_code or raise error
+            from . import prime_code
+
+            # Assuming prime_code doesn't need the URL
+            res = prime_code.compute_score(solution_str, ground_truth, continuous=True)
+    elif data_source in ["hiyouga/geometry3k"]:
+        from . import geo3k
+
+        res = geo3k.compute_score(solution_str, ground_truth)
+    elif data_source in [
+        "searchR1_nq",
+        "searchR1_triviaqa",
+        "searchR1_popqa",
+        "searchR1_hotpotqa",
+        "searchR1_2wikimultihopqa",
+        "searchR1_musique",
+        "searchR1_bamboogle",
+    ]:
+        from . import search_r1_like_qa_em
+
+        res = search_r1_like_qa_em.compute_score(solution_str, ground_truth)
+
+    else:
+        raise NotImplementedError(f"Reward function is not implemented for {data_source=}")
+
+    if isinstance(res, dict):
+        return res
+    elif isinstance(res, int | float | bool):
+        return float(res)
+    else:
+        return float(res[0])
+
+
+@deprecated("verl.utils.reward_score.default_compute_score")
+def _default_compute_score(
+    data_source,
+    solution_str,
+    ground_truth,
+    extra_info=None,
+    sandbox_fusion_url=None,
+    concurrent_semaphore=None,
+    memory_limit_mb=None,
+):
+    """
+    Legacy function API to be deprecated. Please use `default_compute_score` instead.
+    """
+    return default_compute_score(
+        data_source, solution_str, ground_truth, extra_info, sandbox_fusion_url, concurrent_semaphore, memory_limit_mb
+    )
+
+
+__all__ = ["default_compute_score"]

verl/verl/utils/reward_score/geo3k.py

@@ -0,0 +1,36 @@
+# 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 mathruler.grader import extract_boxed_content, grade_answer
+
+
+def format_reward(predict_str: str) -> float:
+    pattern = re.compile(r"<think>.*</think>.*\\boxed\{.*\}.*", re.DOTALL)
+    match_result = re.fullmatch(pattern, predict_str)
+    return 1.0 if match_result else 0.0
+
+
+def acc_reward(predict_str: str, ground_truth: str, use_boxed: bool = True) -> float:
+    if use_boxed:
+        answer = extract_boxed_content(predict_str)
+    else:
+        answer = predict_str
+    return 1.0 if grade_answer(answer, ground_truth) else 0.0
+
+
+def compute_score(predict_str: str, ground_truth: str, use_boxed: bool = True, format_score: float = 0.1) -> float:
+    return (1.0 - format_score) * acc_reward(predict_str, ground_truth, use_boxed) + format_score * format_reward(
+        predict_str
+    )