[ English | 中文 | 日本語 ]

OpenRLHF是首个高性能、生产就绪的开源RLHF框架，它将Ray + vLLM分布式架构与统一的基于智能体的设计范式相结合，实现了可扩展且可扩展的人类反馈强化学习。

📚 了解更多: 文档 | 幻灯片 | 技术报告 | 视频

📖 目录

• 🗞️ 新闻
• 🏗️ 架构基础 - Ray + vLLM + DeepSpeed分布式基础设施
• 🎯 设计范式 - 统一的基于智能体的执行流水线
• 🚀 RL算法 - PPO、REINFORCE++、GRPO、RLOO
• 📋 功能概览 - 完整的RLHF流水线功能
• 🎬 快速入门 - 安装与典型工作流程
• 🎓 训练指南 - SFT、奖励模型、RL训练
• 🎯 单轮智能体 - 自定义奖励函数
• 🤖 多轮智能体 - 复杂环境
• 🔧 高级主题 - LoRA、性能调优

新闻

🏗️ 架构基础：Ray + vLLM分布式架构

OpenRLHF是首个基于Ray + vLLM分布式架构构建的RLHF框架，能够高效地协调跨GPU的多个组件：

核心基础设施组件

Ray - 分布式调度器和控制器
OpenRLHF 利用 Ray 实现高效的分布式调度。它将 Actor、奖励模型、参考模型和 Critic 模型分别部署在不同的 GPU 上，从而支持高达 70B+ 参数 的模型进行可扩展训练。

混合引擎调度：所有模型和 vLLM 引擎可以共享 GPU 资源，最大限度地减少空闲时间并提高 GPU 利用率。这使得在有限的硬件上也能运行完整的 RLHF 流水线。

vLLM - 高性能推理引擎
RLHF 训练中，80% 的时间都花在样本生成上。借助 vLLM 的自动张量并行（AutoTP）和流水线并行（PP），OpenRLHF 能够提供高吞吐、内存高效的生成能力。

DeepSpeed - 内存高效训练
基于 DeepSpeed 的 ZeRO-3、deepcompile、AutoTP 以及 RingAttention 架构。无需依赖重量级框架即可实现大模型训练，并直接与 HuggingFace 模型兼容。

Transformers - 模型接口
原生集成 HuggingFace Transformers，实现模型的无缝加载、状态管理和预训练模型的微调。

NCCL / CUDA IPC - 高速通信
用于分布式训练和推理的高效 GPU 间通信机制。

🎯 设计范式：基于智能体的执行

在 Ray 分布式架构之上，OpenRLHF 是 首个实现统一智能体范式的 RLHF 框架。无论是一次性标准 PPO 还是复杂的多轮推理，每一次训练都会遵循一致的智能体执行流水线。

为什么采用基于智能体的执行？

OpenRLHF 通过 “token-in-token-out” 的智能体执行方式 将生成与训练统一起来，确保完美的一致性、易于单轮或多轮扩展，并且完全避免文本级别的不匹配。

智能体架构

                 ┌─────────────────────────────┐
                 │    AgentExecutorBase        │
                 │  (Token-in-Token-out Core)  │
                 └─────────────────────────────┘
                              │
                 ┌────────────┴────────────┐
                 ↓                         ↓
         SingleTurnExecutor        MultiTurnExecutor
                 │                         │
      ┌──────────┴──────────┐   ┌─────────┴──────────┐
      ↓                     ↓   ↓                    ↓
  Standard RLHF      Custom Reward   Multi-Step    External Env
  (One-shot gen)     Function      Reasoning     (OpenAI Agent Server)
      ↓                     ↓           ↓                ↓
      └─────────────────────┴───────────┴────────────────┘
                              │
                    Consistent Token Trajectories
                              │
                    ┌─────────┴─────────┐
                    │  RL Algorithms    │
                    │  (Decoupled)      │
                    │                   │
                    │  PPO, REINFORCE++ │
                    │  GRPO, RLOO, etc. │
                    └───────────────────┘

核心设计原则

两种执行模式（与 RL 算法正交）

智能体的执行模式与您选择的 RL 算法 无关。您可以将 任意算法（PPO、REINFORCE++、GRPO 等）与 任意执行模式 结合使用：

🚀 最先进的 RL 算法

OpenRLHF 实现了 PPO、REINFORCE++、REINFORCE++-baseline、GRPO、RLOO 等算法，并结合实践指南和社区最佳实践中的优化技巧进行了深度优化。

关键设计：RL 算法与智能体执行模式 解耦。所有算法都能无缝对接单轮和多轮智能体执行器，通过统一的 “token-in-token-out” 流水线运行，从而保证行为的一致性。

参考资料：知乎文章 | Notion 最佳实践

📋 全面的功能特性

OpenRLHF 提供了一个基于智能体的灵活完整 RLHF 流水线：

🎯 基于智能体的强化学习训练（核心创新）

🎓 监督式训练与偏好学习

⚡ 高级功能

🎬 快速入门

安装

推荐：使用 Docker 以实现无忧安装

# 1. 启动 Docker 容器
docker run --runtime=nvidia -it --rm --shm-size="10g" --cap-add=SYS_ADMIN \
  -v $PWD:/openrlhf nvcr.io/nvidia/pytorch:25.11-py3 bash

# 2. 清除冲突包
sudo pip uninstall xgboost transformer_engine flash_attn pynvml -y

# 3. 安装 OpenRLHF（任选其一）
pip install openrlhf                    # 基础版
pip install openrlhf[vllm]              # + vLLM 0.19.0（推荐）
pip install openrlhf[vllm_latest]       # + 最新版本 vLLM
pip install openrlhf[vllm,ring,liger]   # + 所有优化功能

替代方案：从源码安装

git clone https://github.com/OpenRLHF/OpenRLHF.git
cd OpenRLHF
pip install -e .

[!TIP] 我们建议使用 vLLM 0.19.0+ 以获得最佳性能。请参阅 Dockerfile 和 Nvidia-Docker 安装脚本。

准备数据集

OpenRLHF 提供灵活的数据处理方法：

关键参数：

• --input_key：指定输入数据的 JSON 键名
• --apply_chat_template：使用 HuggingFace 分词器的 聊天模板
• --input_template：自定义模板字符串（作为聊天模板的替代方案）
• --prompt_data_probs / --dataset_probs：混合多个数据集（例如 0.1,0.4,0.5）
• --eval_dataset：指定评估数据集路径

聊天模板示例：

dataset = [{"input_key": [
  {"role": "user", "content": "你好，最近怎么样？"},
  {"role": "assistant", "content": "我很好，今天有什么可以帮您的吗？"},
  {"role": "user", "content": "我想展示一下聊天模板的功能！"},
]}]

tokenizer.apply_chat_template(dataset[0]["input_key"], tokenize=False)
# 输出："<s>[INST] 你好，最近怎么样？ [/INST]我很好...</s> [INST] 我想展示一下... [/INST]"

[!NOTE] JSON 键选项因数据集类型而异。请参阅 奖励数据集、SFT 数据集 和 提示数据集

有监督微调

OpenRLHF 的模型检查点与 HuggingFace 模型完全兼容。你可以使用 --pretrain {name or path}、--reward_pretrain {name or path} 和 --critic_pretrain {name or path} 来指定模型名称或路径。我们在 HuggingFace OpenRLHF 上提供了一些预训练的检查点和数据集。

然后，你可以使用我们在 examples/scripts 目录中提供的启动脚本，或者使用以下命令开始训练。

deepspeed --module openrlhf.cli.train_sft \
   --max_len 4096 \
   --dataset Open-Orca/OpenOrca \
   --input_key question \
   --output_key response \
   --input_template $'User: {}\nAssistant: ' \
   --train_batch_size 256 \
   --micro_train_batch_size 2 \
   --max_samples 500000 \
   --pretrain meta-llama/Meta-Llama-3-8B \
   --save_path ./checkpoint/llama3-8b-sft \
   --save_steps -1 \
   --logging_steps 1 \
   --eval_steps -1 \
   --zero_stage 2 \
   --max_epochs 1 \
   --packing_samples \
   --param_dtype bf16 \
   --learning_rate 5e-6 \
   --gradient_checkpointing \
   --use_wandb {wandb_token}

# 其他选项：
# --apply_chat_template                # 使用 HF 分词器聊天模板
# --ring_attn_size 2                   # 启用 RingAttention（需先安装 ring_flash_attn）
# --multiturn                          # 多轮微调损失
# --pretrain_mode                      # 继续预训练模式

奖励模型训练

deepspeed --module openrlhf.cli.train_rm \
   --save_path ./checkpoint/llama3-8b-rm \
   --save_steps -1 \
   --logging_steps 1 \
   --eval_steps -1 \
   --train_batch_size 256 \
   --micro_train_batch_size 1 \
   --pretrain OpenRLHF/Llama-3-8b-sft-mixture \
   --param_dtype bf16 \
   --max_epochs 1 \
   --max_len 8192 \
   --zero_stage 3 \
   --learning_rate 9e-6 \
   --dataset OpenRLHF/preference_dataset_mixture2_and_safe_pku \
   --apply_chat_template \
   --chosen_key chosen \
   --rejected_key rejected \
   --packing_samples \
   --gradient_checkpointing \
   --use_wandb {wandb_token}

建议将奖励模型的 --value_prefix_head 选项设置为 score，这样我们就可以使用 AutoModelForSequenceClassification 加载模型：

reward_model = AutoModelForSequenceClassification.from_pretrained(
              reward_model_path,
              num_labels=1,
              torch_dtype=torch.bfloat16,
              attn_implementation="flash_attention_2",
              use_cache=False,
          )
inputs = xxxx (左填充输入标记)
reward = reward_model.model(*inputs).last_hidden_state
reward = reward_model.score(reward)[:, -1]

RL 训练：使用 Ray 和 vLLM 的 PPO/REINFORCE++

OpenRLHF 中的所有 RL 训练都通过 智能体执行流水线 运行。下面的例子展示了使用混合引擎以获得最佳性能的单回合智能体执行（默认模式）：

# 在容器中启动 Ray 主节点
ray start --head --node-ip-address 0.0.0.0 --num-gpus 8

# 如果你想在更多节点上启动 Ray，可以使用
ray start --address {MASTER-NODE-ADDRESS}:6379  --num-gpus 8

ray job submit --address="http://127.0.0.1:8265" \
   --runtime-env-json='{"working_dir": "/openrlhf"}' \
   -- python3 -m openrlhf.cli.train_ppo_ray \
   --ref_num_nodes 1 \
   --ref_num_gpus_per_node 8 \
   --reward_num_nodes 1 \
   --reward_num_gpus_per_node 8 \
   --critic_num_nodes 1 \
   --critic_num_gpus_per_node 8 \
   --actor_num_nodes 1 \
   --actor_num_gpus_per_node 8 \
   --vllm_num_engines 4 \
   --vllm_tensor_parallel_size 2 \
   --colocate_all_models \
   --vllm_gpu_memory_utilization 0.5 \
   --pretrain OpenRLHF/Llama-3-8b-sft-mixture \
   --reward_pretrain OpenRLHF/Llama-3-8b-rm-700k \
   --save_path /openrlhf/examples/test_scripts/final/llama3-8b-rlhf \
   --ckpt_path /openrlhf/examples/test_scripts/ckpt/llama3-8b-rlhf \
   --save_hf_ckpt \
   --train_batch_size 128 \
   --rollout_batch_size 1024 \
   --use_dynamic_batch \
   --n_samples_per_prompt 1 \
   --max_epochs 1 \
   --prompt_max_len 1024 \
   --max_samples 100000 \
   --generate_max_len 1024 \
   --zero_stage 3 \
   --param_dtype bf16 \
   --actor_learning_rate 5e-7 \
   --critic_learning_rate 9e-6 \
   --init_kl_coef 0.01 \
   --prompt_data OpenRLHF/prompt-collection-v0.1 \
   --input_key context_messages \
   --apply_chat_template \
   --normalize_reward \
   --gradient_checkpointing \
   --packing_samples \
   --vllm_sync_backend nccl \
   --enforce_eager \
   --vllm_enable_sleep \
   --deepspeed_enable_sleep \
   --use_wandb {wandb_token}

# 算法变体（均采用单回合智能体执行）：
# --advantage_estimator reinforce        # REINFORCE++
# --advantage_estimator rloo             # RLOO
# --advantage_estimator reinforce_baseline  # REINFORCE++-baseline（最适合 RLVR）
# --advantage_estimator group_norm       # GRPO
# --advantage_estimator dr_grpo          # Dr. GRPO

# 高级选项：
# --init_kl_coef 0                                    # 无参考模型
# --remote_rm_url http://host:5000/get_reward         # HTTP 奖励模型
# --n_samples_per_prompt 4                            # 每个提示生成多个样本
# --vllm_generate_batch_size 2048                     # 生成时超采样（大于 rollout_batch_size）；需要 --async_train
# --enable_vllm_is_correction                         # vLLM 对于离策略回放的重要性采样修正
# --vllm_is_correction_type tis                       # 修正类型：tis（token clamp）| icepop（token filter）| seq-mask-tis（序列级几何平均）
# --vllm_is_truncated_threshold 0.5 5.0               # IS 截断区间：[低, 高]
# --best_metric_key eval_default_pass1                # 根据评估指标保存最佳检查点（空值表示自动检测第一轮 pass1，'none' 表示禁用）
# --policy_loss_type gspo                             # 使用 GSPO 策略损失变体（ vs 默认的 'ppo'）

[!TIP] 对于推理任务（RLVR）：使用 --advantage_estimator reinforce_baseline 作为 REINFORCE++-baseline——它对不同的奖励尺度具有鲁棒性。

[!NOTE] Ray 环境设置：让 Ray 自动部署，使用 --runtime-env-json='{"setup_commands": ["pip install openrlhf[vllm]"]}'

[!NOTE] 解决 GPU 索引错误：如果遇到 DeepSpeed GPU 设备设置问题，可以设置 export RAY_EXPERIMENTAL_NOSET_CUDA_VISIBLE_DEVICES=1。

📚 更多示例：请参阅 examples/scripts 和 文档

🎯 单轮智能体：使用自定义奖励进行强化微调

单轮智能体执行（默认模式）支持自定义奖励函数，非常适合在没有训练好的奖励模型的情况下进行强化微调。您无需使用预训练的奖励模型，而是提供一个 Python 函数来实时计算奖励。

适用场景：

• 基于规则的奖励（长度、格式、代码执行、数学验证）
• 外部 API 奖励（裁判模型、编译器、测试套件）
• 混合奖励（结合多种信号）

示例：自定义奖励函数

# reward_func.py
import torch

def reward_func(queries, prompts, labels):
    """
    为生成的响应计算自定义奖励。
    
    参数：
        queries: List[str] - 完整文本（提示 + 响应）
        prompts: List[str] - 仅原始提示
        labels: List[str] - 真实标签（来自 --label_key）
    
    返回：
        包含以下键的字典：
            - rewards: 用于优势计算的张量
            - scores: 用于动态筛选的张量（0-1 范围）
            - extra_logs: 用于 wandb 日志记录的字典
    """
    batch_size = len(queries)
    
    # 示例：随机奖励（请替换为您自己的逻辑）
    # 实际应用：代码执行、数学验证、格式检查
    reward = torch.randint(0, 2, (batch_size,)).float()

    return {
        "rewards": reward,           # 用于强化学习中的优势计算
        "scores": reward,            # 用于动态筛选 (--dynamic_filtering)
        "extra_logs": {              # 记录到 wandb
            "custom_metric": reward.mean().item(),
        },
    }

使用方法

ray job submit --address="http://127.0.0.1:8265" \
  --runtime-env-json='{"working_dir": "/openrlhf"}' \
  -- python3 -m openrlhf.cli.train_ppo_ray \
  --pretrain meta-llama/Meta-Llama-3-8B \
  --use_dynamic_batch \
  --remote_rm_url /path/to/reward_func.py \
  --label_key answer \
  --prompt_data your_prompt_dataset \
  ... # 其他训练参数

关键参数：--label_key answer 将数据集中的“answer”字段作为 labels 传递给 reward_func。

[!TIP] 应用场景：代码生成（执行测试）、数学（验证解题结果）、格式化（检查结构）、多目标优化（结合多种信号）

📖 完整示例：examples/scripts/train_ppo_with_reward_fn.sh

🤖 多轮智能体：复杂环境交互

对于需要多步交互的任务（推理链、带反馈的编程、游戏对战），OpenRLHF 提供了多轮智能体执行模式。

构建自定义多轮智能体

实现 AgentInstanceBase 类，并定义 reset/step 方法：

# agent_func.py
import random
from typing import Any, Dict

import torch
from openrlhf.utils.agent import AgentInstanceBase, MultiTurnAgentExecutor


# 一个简单的 n 步随机环境
class AgentInstance(AgentInstanceBase):
    async def __init__(self, *args, **kwargs):
        self.step_idx = 0
        self.max_steps = random.randint(1, 3)  # 1-3 步

    async def reset(self, states: dict, **kwargs):
        return {"observation": states["observation"]}  # 返回原始文本观测值

    async def step(self, states: dict, **kwargs) -> Dict[str, Any]:
        print(f"step_idx: {self.step_idx}, max_steps: {self.max_steps}")

        observation_text = states["observation_text"]
        action_text = states["action_text"]
        label = states["label"]

        # 检查是否结束回合
        done = self.step_idx >= self.max_steps
        reward = torch.randint(0, 2, (1,)).float() if done else torch.tensor(0)

        # 根据是否结束回合生成环境反馈
        environment_feedback = (
            "\n\nHuman: [CORRECT]\n</s>"
            if done
            else "\n\nHuman: [INCORRECT]\n请分析问题并重试。\n</s>\n\nAssistant: "
        )

        self.step_idx += 1

        return {
            "rewards": reward,  # 用于优势计算的奖励
            "scores": reward,  # 用于动态筛选的分数（0-1  Beliebt

### OpenAI 兼容代理服务器

对于需要 OpenAI 兼容聊天 API 的多轮对话代理（例如集成外部工具使用框架），[`agent_func_openai_server_executor.py`](./examples/python/agent_func_openai_server_executor.py) 将 vLLM 包装为本地的 `/v1/chat/completions` 服务器，同时收集用于强化学习训练的 token 级别追踪信息。

- 暴露标准的 OpenAI 端点（`/v1/chat/completions`、`/v1/models`、`/tokenize`）
- 自动为每个会话收集 token ID 和 logprobs，用于强化学习训练
- Delta-tokenization 在多轮调用中复用前缀 token
- 可以通过重写 `run_agent()` 来接入您自己的多轮工作流

```bash
python3 -m openrlhf.cli.train_ppo_ray \
  --agent_func_path examples/python/agent_func_openai_server_executor.py \
  ... # 其他训练参数

🔧 高级主题

LoRA：合并适配器

在使用 LoRA/QLoRA 时，OpenRLHF 只保存适配器权重。要部署或继续训练，需将适配器与基础模型合并：

python -m openrlhf.cli.lora_combiner \
    --model_path meta-llama/Meta-Llama-3-8B \
    --lora_path ./checkpoint/llama3-8b-rm \
    --output_path ./checkpoint/llama-3-8b-rm-combined \
    --is_rm \
    --param_dtype bf16

性能调优指南

根据您的硬件和工作负载，使用以下建议优化 OpenRLHF：

🎯 执行模式：吞吐量 vs. 稳定性

根据您的优先级选择执行模式——OpenRLHF 提供了一个清晰的权衡选项：

⚡ 其他速度优化

💾 内存管理

内存充足时：

• ✅ 禁用 --adam_offload
• ✅ 启用 --overlap_comm
• ✅ 使用 --colocate_critic_reward 和 --colocate_actor_ref

遇到 OOM 时：

• ❌ 禁用所有 --colocate_* 选项
• ✅ 减少批次大小
• ✅ 启用梯度检查点

🎮 批次大小调整

1. 生成阶段：最大化 --micro_rollout_batch_size，最小化 vLLM TP 大小
2. 训练阶段：最大化 --micro_train_batch_size，启用 --packing_samples
3. vLLM：始终使用 --vllm_sync_backend nccl

[!TIP] 快速入门模板：对于 8x A100（80GB），可以尝试混合引擎 + --vllm_gpu_memory_utilization 0.5 + --colocate_all_models

📖 更多详情：性能调优文档

使用 OpenRLHF 的公司和组织

• Google
• 字节跳动
• 腾讯
• 阿里巴巴
• 百度
• 中国电信
• 维沃
• Allen AI
• NexusFlow
• Jülich 超级计算中心（JSC）
• 伯克利星雀团队
• M-A-P
• ...

加入我们

如何加入？

1. 发送邮件至 janhu9527@gmail.com 或加入 GitHub 组织。请提供以下信息：
   • 您的姓名
   • 您的 GitHub 用户名
   • 您感兴趣的领域
   • 您在 NLP 和/或 AI 方面的技能和经验
2. 您也可以通过官方 GitHub OpenRLHF ↗ 项目页面加入我们。只需创建一个关于您贡献兴趣的问题，我们会尽快回复您。

您可以做什么？

1. 加入团队，参与 OpenRLHF 项目的开发。
2. 通过提交拉取请求为项目做出贡献。
3. 帮助改进文档、修复 bug 或开发新功能。
4. 分享该项目，帮助我们扩大社区。

赞助我们

您的赞助可以帮助我们维护和改进 OpenRLHF。如果您觉得这个项目很有用，请考虑赞助我们。您可以在 Open Collective ↗ 上进行赞助。

星级图

贡献者

非常感谢所有贡献者！如果您想参与贡献，欢迎随时提交拉取请求或创建问题。

参考文献与致谢

我们衷心感谢以下项目和组织对 AI 和 NLP 领域的贡献：

• Hugging Face Transformers ↗
• OpenAI GPT ↗
• LLaMA ↗
• DeepSpeed ↗
• Ray ↗

我们的项目还要感谢 ColossalChat 和 DeepSpeedChat。在项目早期，我们参考了他们的代码设计。此外，我们还要感谢 Netmind.AI 为环形注意力机制的开发提供的 GPU 支持。

（2024年7月）我们的 GitHub 组织已从 OpenLLMAI 更名为 OpenRLHF。

引用

OpenRLHF

@article{hu2024openrlhf,
  title={OpenRLHF：一个易于使用、可扩展且高性能的RLHF框架},
  author={Jian Hu和Xibin Wu和Zilin Zhu和Xianyu和Weixun Wang和Dehao Zhang和Yu Cao},
  journal={arXiv预印本arXiv:2405.11143},
  year={2024}
}

REINFORCE++-基线

@article{hu2025reinforce++,
  title={Reinforce++：一种简单高效的大型语言模型对齐方法},
  author={Hu, Jian},
  journal={arXiv预印本arXiv:2501.03262},
  year={2025}
}

OpenRLHF © 2025 OpenRLHF。保留所有权利。

OpenRLHF 快速上手指南

OpenRLHF 是首个结合 Ray + vLLM 分布式架构与统一 Agent 执行范式的高性能开源 RLHF 框架。它支持 PPO、REINFORCE++、GRPO 等先进算法，能够高效训练高达 70B+ 参数的大模型。

1. 环境准备

系统要求

• 操作系统: Linux (推荐 Ubuntu 20.04/22.04)
• GPU: NVIDIA GPU (显存建议 24GB+，多卡环境需支持 NVLink 或高速互联)
• CUDA: 12.1 或更高版本
• Python: 3.9 - 3.11

前置依赖

确保已安装以下基础组件：

• NVIDIA Driver
• CUDA Toolkit
• NCCL (用于多卡通信)

国内加速建议： 推荐使用国内镜像源加速 Python 包下载：

export PIP_INDEX_URL=https://pypi.tuna.tsinghua.edu.cn/simple

2. 安装步骤

方式一：通过 pip 安装（推荐）

直接从 PyPI 安装最新稳定版：

pip install openrlhf

若需安装包含最新特性的开发版：

pip install git+https://github.com/OpenRLHF/OpenRLHF.git

方式二：源码安装

克隆仓库并安装依赖：

git clone https://github.com/OpenRLHF/OpenRLHF.git
cd OpenRLHF
pip install -e .

验证安装

检查是否成功安装 openrlhf 命令行工具：

openrlhf --help

3. 基本使用

OpenRLHF 的核心工作流基于 Agent 执行模式，默认采用 Single-Turn（单轮） 模式进行标准 RLHF 训练。以下是一个基于 Ray 和 vLLM 的最小化训练示例。

步骤 1: 准备数据

确保你有一个包含 prompt 字段的 JSONL 格式数据集，例如 prompts.jsonl：

{"prompt": "What is the capital of France?"}
{"prompt": "Explain quantum entanglement."}

步骤 2: 启动训练

使用内置脚本启动基于 REINFORCE++ 算法的训练任务。该命令会自动调度 Ray 集群，利用 vLLM 进行采样，并使用 DeepSpeed 进行模型更新。

bash examples/scripts/train_reinforce_baseline_ray.sh \
    --pretrain OpenRLHF/Llama-3-8b-sft-mixture \
    --reward_pretrain OpenRLHF/Llama-3-8b-rm-mixture \
    --save_path ./checkpoint/llama3-8b-rlhf \
    --micro_train_batch_size 8 \
    --train_batch_size 128 \
    --micro_rollout_batch_size 16 \
    --rollout_batch_size 1024 \
    --max_samples 100000 \
    --max_epochs 1 \
    --prompt_max_len 1024 \
    --generate_max_len 1024 \
    --zero_stage 3 \
    --bf16 \
    --actor_learning_rate 5e-7 \
    --critic_learning_rate 9e-6 \
    --init_kl_coef 0.01 \
    --prompt_data prompts.jsonl \
    --input_key prompt \
    --apply_chat_template \
    --normalize_reward \
    --adam_offload \
    --flash_attn \
    --gradient_checkpointing \
    --use_vllm \
    --vllm_num_engines 2 \
    --vllm_tensor_parallel_size 1 \
    --advantage_estimator reinforce_baseline

关键参数说明

• --pretrain: 初始策略模型（SFT 模型）。
• --reward_pretrain: 奖励模型（Reward Model）。
• --use_vllm: 启用 vLLM 加速采样过程（显著提升吞吐量）。
• --vllm_num_engines: 启动的 vLLM 引擎数量，根据显卡数量调整。
• --advantage_estimator: 选择优势估计算法，如 ppo, reinforce_baseline, grpo 等。
• --prompt_data: 输入提示词数据路径。

自定义奖励函数（可选）

若不使用预训练的奖励模型，可通过 Python 脚本定义自定义奖励逻辑。创建一个继承自 AgentExecutorBase 的类，实现 reward_func 方法，并在启动脚本中通过 --agent_func_path 指定路径。

# custom_reward.py
from openrlhf.trainer.ray import AgentExecutorBase

class CustomRewardAgent(AgentExecutorBase):
    def reward_func(self, prompts, outputs, **kwargs):
        # 在此处编写自定义奖励逻辑
        scores = [1.0 if "Paris" in out else 0.0 for out in outputs]
        return scores

运行命令：

... --agent_func_path custom_reward.py ...

更多高级用法（如多轮对话 Agent、VLM 训练、LoRA 微调）请参考官方文档或 examples/ 目录下的完整脚本。