# Copyright 2024 Bytedance Ltd. and/or its affiliates # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ The main entry point to run the PPO algorithm """ import logging import os import warnings import asyncio asyncio.set_event_loop(asyncio.new_event_loop()) import torch from omegaconf import OmegaConf from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from peft import LoraConfig, TaskType, get_peft_model from verl import DataProto from verl.models.transformers.monkey_patch import apply_monkey_patch from verl.single_controller.base.decorator import ( Dispatch, register, make_nd_compute_dataproto_dispatch_fn, ) from verl.utils import hf_processor, hf_tokenizer from verl.utils.activation_offload import enable_activation_offloading from verl.utils.device import get_device_id from verl.utils.fs import copy_to_local from verl.utils.fsdp_utils import ( CPUOffloadPolicy, MixedPrecisionPolicy, apply_fsdp2, fsdp2_load_full_state_dict, get_fsdp_wrap_policy, get_init_weight_context_manager, init_fn, ) from verl.utils.profiler import DistProfiler, log_gpu_memory_usage, simple_timer from verl.utils.profiler.performance import reduce_timing, topk_reduce_ratio_min_max from verl.utils.py_functional import convert_to_regular_types from verl.workers.fsdp_workers import ( ActorRolloutRefWorker as VerlActorRolloutRefWorker, AsyncActorRolloutRefWorker as VerlAsyncActorRolloutRefWorker, CriticWorker as VerlCriticWorker, RewardModelWorker as VerlRewardModelWorker, get_vl_model_vision_tower, get_sharding_strategy, ) logger = logging.getLogger(__file__) logger.setLevel(os.getenv("VERL_LOGGING_LEVEL", "WARN")) class ActorRolloutRefWorker(VerlActorRolloutRefWorker): """ This worker can be instantiated as a standalone actor or a standalone rollout or a standalone reference policy or a hybrid engine based on the config.rollout """ @register(dispatch_mode=Dispatch.ONE_TO_ALL) def init_model(self): super().init_model() if self._is_actor: from ragen.workers.actor.dp_actor import DataParallelPPOActor as RagenDataParallelPPOActor # Use the local actor implementation so we can do component-wise gradient analysis self.actor = RagenDataParallelPPOActor( config=self.config.actor, actor_module=self.actor_module_fsdp, actor_optimizer=self.actor_optimizer, ) @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="rollout")) @DistProfiler.annotate(color="red", role="rollout_generate") def generate_sequences(self, prompts: DataProto): # Support all hardwares assert self._is_rollout mode = prompts.meta_info.get("mode", "singleturn") skip_generation = prompts.meta_info.get("skip_generation", False) allowed_modes = {"singleturn", "multiturn-start", "multiturn-middle", "multiturn-end"} if mode not in allowed_modes: raise ValueError(f"Unsupported cache control mode: {mode}") if skip_generation and mode != "multiturn-end": raise ValueError("skip_generation is only supported when mode='multiturn-end'") should_empty_cache = mode in {"singleturn", "multiturn-end"} if skip_generation: output = prompts.to("cpu") else: prompts = prompts.to(get_device_id()) meta_info = { "eos_token_id": self.generation_config.eos_token_id if self.generation_config is not None else self.tokenizer.eos_token_id, "pad_token_id": self.generation_config.pad_token_id if self.generation_config is not None else self.tokenizer.pad_token_id, } prompts.meta_info.update(meta_info) timing_generate = {} if self._is_actor and mode in {"singleturn", "multiturn-start"}: # For rollout only, we do not switch context. try: loop = asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(self.rollout_mode()) log_gpu_memory_usage("After switch to rollout mode", logger=logger) with simple_timer("generate_sequences", timing_generate): output = self.rollout.generate_sequences(prompts=prompts) if self._is_actor and mode in {"singleturn", "multiturn-end"}: try: loop = asyncio.get_event_loop() except RuntimeError: loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.run_until_complete(self.trainer_mode()) log_gpu_memory_usage("After switch to trainer mode", logger=logger) # We calculate the average timing across all ranks # to make sure meta_info["timing"] is the same timing_generate_topk_ratio, timing_generate_min, timing_generate_max = topk_reduce_ratio_min_max( timing_generate["generate_sequences"] ) timing_generate = reduce_timing(timing_generate) timing_generate.update( { "generation_timing/max": timing_generate_max, "generation_timing/min": timing_generate_min, "generation_timing/topk_ratio": timing_generate_topk_ratio, } ) output.meta_info["timing"] = timing_generate output = output.to("cpu") if should_empty_cache: torch.cuda.empty_cache() return output @register(dispatch_mode=make_nd_compute_dataproto_dispatch_fn(mesh_name="actor")) @DistProfiler.annotate(color="red", role="actor_update") def update_actor(self, data: DataProto, skip_optimizer_step=False): data = data.to(get_device_id()) if "skip_optimizer_step" in data.meta_info: skip_optimizer_step = bool(data.meta_info["skip_optimizer_step"]) if skip_optimizer_step: data.meta_info["skip_optimizer_step"] = True output = self.actor.update_policy(data) if isinstance(output, DataProto): return output return DataProto(meta_info={"metrics": output}) class AsyncActorRolloutRefWorker(VerlAsyncActorRolloutRefWorker): pass class RewardModelWorker(VerlRewardModelWorker): pass class CriticWorker(VerlCriticWorker): def _build_critic_model_optimizer(self, config): """Only changed the lora config from verl to fix critic lora error""" # the following line is necessary from torch import optim from torch.distributed.fsdp import MixedPrecision from verl.utils.model import load_valuehead_model, print_model_size from verl.utils.torch_dtypes import PrecisionType use_shm = config.model.get("use_shm", False) local_path = copy_to_local(config.model.path, use_shm=use_shm) # note that the tokenizer between actor and critic may be different. So override tokenizer info with actor info # using random initialized model from any architecture. May not be the same as Actor. tokenizer_path = copy_to_local(config.model.tokenizer_path, use_shm=use_shm) self.tokenizer = hf_tokenizer(tokenizer_path, trust_remote_code=config.model.get("trust_remote_code", False)) self.processor = hf_processor(tokenizer_path, trust_remote_code=config.model.get("trust_remote_code", False)) if self.config.model.get("custom_chat_template", None) is not None: if self.processor is not None: self.processor.chat_template = self.config.model.custom_chat_template else: self.tokenizer.chat_template = self.config.model.custom_chat_template override_config = OmegaConf.to_container(OmegaConf.create(self.config.model.get("override_config", {}))) override_config_kwargs = { "bos_token_id": self.tokenizer.bos_token_id, "eos_token_id": self.tokenizer.eos_token_id, "pad_token_id": self.tokenizer.pad_token_id, } override_config_kwargs.update(override_config) if self.rank == 0: print(f"Critic overriding config {override_config_kwargs}") torch_dtype = self.config.model.fsdp_config.get("model_dtype", "fp32") torch_dtype = PrecisionType.to_dtype(torch_dtype) from transformers import AutoConfig critic_model_config = AutoConfig.from_pretrained( local_path, attn_implementation="flash_attention_2", trust_remote_code=config.model.get("trust_remote_code", False), ) # TODO: VL models use VisionAttention, which directly uses flash_attention in transformers>=4.53 # which will be patched by _ulysses_flash_attention_forward, but errorly misses position_ids # Maybe support Ulysses in VisionAttention in the future and remove this patch if self.ulysses_sequence_parallel_size > 1 and hasattr(critic_model_config, "vision_config"): critic_model_config.vision_config._attn_implementation = "eager" critic_model_config.num_labels = 1 # patch for kimi-vl if getattr(critic_model_config, "model_type", None) == "kimi_vl": critic_model_config.text_config.topk_method = "greedy" init_context = get_init_weight_context_manager( use_meta_tensor=not critic_model_config.tie_word_embeddings, mesh=self.device_mesh ) with init_context(), warnings.catch_warnings(): warnings.simplefilter("ignore") critic_model_config.classifier_dropout = 0.0 critic_model_config.hidden_dropout = "0" critic_model_config.summary_dropout_prob = 0.0 critic_module = load_valuehead_model( local_path, torch_dtype, critic_model_config, config.model.get("trust_remote_code", False), ) use_remove_padding = config.model.get("use_remove_padding", False) apply_monkey_patch( model=critic_module, use_remove_padding=use_remove_padding, ulysses_sp_size=self.ulysses_sequence_parallel_size, ) # some parameters may not in torch_dtype critic_module.to(torch_dtype) if config.model.get("enable_gradient_checkpointing", False): critic_module.gradient_checkpointing_enable(gradient_checkpointing_kwargs={"use_reentrant": False}) if self._is_lora: print("Applying LoRA to critic module") critic_module.enable_input_require_grads() # Convert config to regular Python types before creating PEFT model lora_config = { "task_type": TaskType.TOKEN_CLS, "r": self.config.model.lora_rank, "lora_alpha": self.config.model.lora_alpha, "target_modules": convert_to_regular_types(self.config.model.target_modules), "modules_to_save": ["score"], "bias": "none", } critic_module = get_peft_model(critic_module, LoraConfig(**lora_config)) critic_module.print_trainable_parameters() if self.rank == 0: print_model_size(critic_module) self.critic_model_config = critic_model_config fsdp_config = self.config.model.fsdp_config mixed_precision_config = fsdp_config.get("mixed_precision", None) if mixed_precision_config is not None: param_dtype = PrecisionType.to_dtype(mixed_precision_config.get("param_dtype", "bf16")) reduce_dtype = PrecisionType.to_dtype(mixed_precision_config.get("reduce_dtype", "fp32")) buffer_dtype = PrecisionType.to_dtype(mixed_precision_config.get("buffer_dtype", "fp32")) else: param_dtype = torch.bfloat16 reduce_dtype = torch.float32 buffer_dtype = torch.float32 mixed_precision = MixedPrecision(param_dtype=param_dtype, reduce_dtype=reduce_dtype, buffer_dtype=buffer_dtype) auto_wrap_policy = get_fsdp_wrap_policy( module=critic_module, config=self.config.model.fsdp_config.wrap_policy, is_lora=self.config.model.get("lora_rank", 0) > 0, ) log_gpu_memory_usage("Before critic FSDP", logger=None) fsdp_mesh = self.device_mesh sharding_strategy = get_sharding_strategy(fsdp_mesh) self.use_orig_params = fsdp_config.get("use_orig_params", False) if self.config.model.get("freeze_vision_tower", False): vision_tower = get_vl_model_vision_tower(critic_module) if vision_tower is not None: vision_tower.requires_grad_(False) self.use_orig_params = True if self.rank == 0: print("[critic model] Vision tower is set to not trainable.") else: if self.rank == 0: print("[critic model] No vision tower found.") # Note: We force turn off CPUOffload for critic because it causes incorrect results when using grad accumulation if config.strategy == "fsdp": critic_module = FSDP( critic_module, param_init_fn=init_fn, use_orig_params=self.use_orig_params, auto_wrap_policy=auto_wrap_policy, device_id=get_device_id(), sharding_strategy=sharding_strategy, mixed_precision=mixed_precision, sync_module_states=True, forward_prefetch=self.config.model.fsdp_config.forward_prefetch, device_mesh=self.device_mesh, cpu_offload=None, ) elif config.strategy == "fsdp2": assert CPUOffloadPolicy is not None, "PyTorch version >= 2.4 is required for using fully_shard API (FSDP2)" mp_policy = MixedPrecisionPolicy( param_dtype=param_dtype, reduce_dtype=reduce_dtype, cast_forward_inputs=True ) offload_policy = None if fsdp_config.offload_policy: self._is_offload_param = False self._is_offload_optimizer = False offload_policy = CPUOffloadPolicy(pin_memory=True) fsdp_kwargs = { "mesh": fsdp_mesh, "mp_policy": mp_policy, "offload_policy": offload_policy, "reshard_after_forward": fsdp_config.reshard_after_forward, "shard_placement_fn": get_shard_placement_fn(fsdp_size=self.device_mesh.shape[-1]), } full_state = critic_module.state_dict() apply_fsdp2(critic_module, fsdp_kwargs, fsdp_config) fsdp2_load_full_state_dict(critic_module, full_state, fsdp_mesh, offload_policy) else: raise NotImplementedError(f"Unknown strategy {config.strategy}") if config.model.get("enable_activation_offload", False): enable_gradient_checkpointing = config.model.get("enable_gradient_checkpointing", False) enable_activation_offloading(critic_module, config.strategy, enable_gradient_checkpointing) log_gpu_memory_usage("After critic FSDP", logger=None) critic_optimizer = optim.AdamW( critic_module.parameters(), lr=config.optim.lr, betas=config.optim.get("betas", (0.9, 0.999)), weight_decay=config.optim.get("weight_decay", 1e-2), ) total_steps = config.optim.get("total_training_steps", 0) num_warmup_steps = int(config.optim.get("lr_warmup_steps", -1)) warmup_style = config.optim.get("warmup_style") or config.optim.get("lr_scheduler_type", "constant") if num_warmup_steps < 0: num_warmup_steps_ratio = config.optim.get("lr_warmup_steps_ratio", 0.0) num_warmup_steps = int(num_warmup_steps_ratio * total_steps) if self.rank == 0: print(f"Total steps: {total_steps}, num_warmup_steps: {num_warmup_steps}") from verl.utils.torch_functional import get_constant_schedule_with_warmup, get_cosine_schedule_with_warmup if warmup_style == "constant": critic_lr_scheduler = get_constant_schedule_with_warmup( optimizer=critic_optimizer, num_warmup_steps=num_warmup_steps ) elif warmup_style == "cosine": min_lr_ratio = config.optim.get("min_lr_ratio", 0.0) num_cycles = config.optim.get("num_cycles", 0.5) critic_lr_scheduler = get_cosine_schedule_with_warmup( optimizer=critic_optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=total_steps, min_lr_ratio=min_lr_ratio, num_cycles=num_cycles, ) else: raise NotImplementedError(f"Warmup style {warmup_style} is not supported") return critic_module, critic_optimizer, critic_lr_scheduler