main_ppo.py — def create_resource_pool_manager(config, roles):

文件路径: verl/experimental/one_step_off_policy/main_ppo.py

文件概述

一步离策略（One-Step Off-Policy）PPO 训练的主入口文件。这种训练模式介于标准同步训练和全异步训练之间：训练和推理使用不同的 GPU，但推理和训练步骤之间有一定的重叠——当前步的训练和下一步的推理并行执行。

关键代码讲解

1. 资源池创建

def create_resource_pool_manager(config, roles):
    resource_pool_spec = {}
    mapping = {}

    # 训练池（Actor、Critic 等共享）
    trainer_pool = [config.trainer.n_gpus_per_node] * config.trainer.nnodes
    resource_pool_spec["trainer_pool"] = trainer_pool

    # Rollout 池（独立 GPU，由 AgentLoopManager 管理）
    # 注意：这里不需要为 Rollout 创建池，因为 AgentLoop 自己处理
    return ResourcePoolManager(resource_pool_spec=resource_pool_spec, mapping=mapping)

2. Worker 映射

def create_role_worker_mapping(config):
    from verl.experimental.separation.engine_workers import DetachActorWorker
    from verl.workers.engine_workers import TrainingWorker

    role_worker_mapping = {
        Role.Actor: ray.remote(DetachActorWorker),   # 使用 Detach 版本的 Actor
        Role.Critic: ray.remote(TrainingWorker),
    }
    if need_reference_policy(config):
        role_worker_mapping[Role.RefPolicy] = ray.remote(DetachActorWorker)
    return role_worker_mapping, RayWorkerGroup

DetachActorWorker 是"分离"版本的 Actor Worker，支持训练引擎和推理引擎在不同 GPU 上运行。

3. OneStepTaskRunner

@ray.remote(num_cpus=10, max_concurrency=100)
class OneStepTaskRunner:
    def run(self, config):
        # 1. 加载 tokenizer、processor
        tokenizer = hf_tokenizer(local_path, ...)
        processor = hf_processor(local_path, ...)

        # 2. 创建数据集
        train_dataset = create_rl_dataset(config.data.train_files, ...)
        val_dataset = create_rl_dataset(config.data.val_files, ...)

        # 3. 创建 Trainer
        trainer = OneStepOffRayTrainer(
            config=config, tokenizer=tokenizer, processor=processor,
            role_worker_mapping=role_worker_mapping,
            resource_pool_manager=resource_pool_manager,
            train_dataset=train_dataset, val_dataset=val_dataset,
            collate_fn=collate_fn, train_sampler=train_sampler,
        )

        # 4. 初始化 Worker 并开始训练
        trainer.init_workers()
        asyncio.run(trainer.fit())

4. Hydra 入口

@hydra.main(config_path="config", config_name="one_step_off_ppo_trainer", version_base=None)
def main(config):
    auto_set_device(config)
    config.actor_rollout_ref.rollout.nnodes = config.rollout.nnodes
    config.actor_rollout_ref.rollout.n_gpus_per_node = config.rollout.n_gpus_per_node
    run_ppo(config, task_runner_class=OneStepTaskRunner)

一步离策略 vs 标准同步 vs 全异步

标准同步:    [推理] → [训练] → [推理] → [训练] → ...
                                                   (串行，无重叠)

一步离策略:  [推理1] → [训练1 + 推理2] → [训练2 + 推理3] → ...
                                                   (训练和下一步推理重叠)

全异步:      [推理持续运行...] ←→ [训练持续运行...]
                       ↕ MessageQueue ↕
                                                   (完全解耦)

核心类/函数列表

名称	类型	说明
create_resource_pool_manager()	函数	创建 GPU 资源池
create_role_worker_mapping()	函数	创建角色到 Worker 的映射
OneStepTaskRunner	Ray Remote 类	训练任务运行器
main()	函数	Hydra 命令行入口

与其他模块的关系

• 创建 OneStepOffRayTrainer（ray_trainer.py）
• 使用 DetachActorWorker（separation/engine_workers.py）
• 使用 verl 标准的数据集创建和采样器

小结

main_ppo.py 是一步离策略训练的入口。与全异步训练不同，这种模式只需要一个 Trainer 组件（无需 MessageQueue），通过 asyncio 实现训练和推理的流水线重叠。它是从标准同步训练到全异步训练的中间过渡方案。