diff --git "a/train.jsonl" "b/train.jsonl" new file mode 100644--- /dev/null +++ "b/train.jsonl" @@ -0,0 +1,172 @@ +{"file_name": "verl__base_config.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport collections\nfrom dataclasses import FrozenInstanceError, dataclass, fields\nfrom typing import Any\n\n\n# BaseConfig class inherits from collections.abc.Mapping, which means it can act like a dictionary\n@dataclass\nclass BaseConfig(collections.abc.Mapping):\n \"\"\"The BaseConfig provides dict-like interface for a dataclass config.\n\n By default all fields in the config is not mutable, unless specified in\n \"_mutable_fields\". The BaseConfig class implements the Mapping Abstract Base Class.\n This allows instances of this class to be used like dictionaries.\n \"\"\"\n\n _mutable_fields = set()\n _target_: str = \"\"\n\n def __setattr__(self, name: str, value):\n \"\"\"Set the value of an attribute. Check if the attr is mutable before setting the value.\"\"\"\n # If the field already exists, it's considered frozen unless it's in _mutable_fields\n if name in self.__dict__ and name not in getattr(self, \"_mutable_fields\", set()):\n raise FrozenInstanceError(f\"Field '{name}' is frozen and cannot be modified\")\n super().__setattr__(name, value)\n\n def get(self, key: str, default: Any = None) -> Any:\n \"\"\"Get the value associated with the given key. If the key does not exist, return the default value.\n\n Args:\n key (str): The attribute name to retrieve.\n default (Any, optional): The value to return if the attribute does not exist. Defaults to None.\n\n Returns:\n Any: The value of the attribute or the default value.\n \"\"\"\n try:\n return getattr(self, key)\n except AttributeError:\n return default\n\n def __getitem__(self, key: str):\n \"\"\"Implement the [] operator for the class. Allows accessing attributes like dictionary items.\n\n Args:\n key (str): The attribute name to retrieve.\n\n Returns:\n Any: The value of the attribute.\n\n Raises:\n AttributeError: If the attribute does not exist.\n TypeError: If the key type is not string\n \"\"\"\n return getattr(self, key)\n\n def __iter__(self):\n \"\"\"Implement the iterator protocol. Allows iterating over the attribute names of the instance.\n\n Yields:\n str: The name of each field in the dataclass.\n \"\"\"\n for f in fields(self):\n yield f.name\n\n def __len__(self):\n \"\"\"\n Return the number of fields in the dataclass.\n\n Returns:\n int: The number of fields in the dataclass.\n \"\"\"\n return len(fields(self))\n"} +{"file_name": "verl__checkpoint_engine__base.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport asyncio\nfrom abc import ABC, abstractmethod\nfrom typing import Any, Generator, TypedDict\n\nimport ray\nimport torch\n\nfrom verl.single_controller.base import Worker\nfrom verl.single_controller.base.decorator import Dispatch, register\nfrom verl.single_controller.ray import RayClassWithInitArgs, RayWorkerGroup\nfrom verl.utils.distributed import initialize_global_process_group_ray\nfrom verl.utils.ray_utils import auto_await\nfrom verl.workers.config import HFModelConfig, RolloutConfig\nfrom verl.workers.rollout import BaseRollout, RolloutReplica, get_rollout_class\n\n\nclass TensorMeta(TypedDict):\n name: str\n shape: torch.Size\n dtype: torch.dtype\n offset: int\n\n\nclass CheckpointEngineRegistry:\n \"\"\"Checkpoint engine registry.\"\"\"\n\n _registry: dict[str, type[\"CheckpointEngine\"]] = {}\n\n def register(backend: str):\n \"\"\"Register a checkpoint engine.\n\n Args:\n backend: The backend of the checkpoint engine.\n \"\"\"\n\n def wrapper(cls: type[\"CheckpointEngine\"]):\n CheckpointEngineRegistry._registry[backend] = cls\n return cls\n\n return wrapper\n\n @classmethod\n def get(cls, backend: str) -> type[\"CheckpointEngine\"]:\n \"\"\"Get the checkpoint engine class.\n\n Args:\n backend: The backend of the checkpoint engine.\n\n Returns:\n The checkpoint engine class.\n \"\"\"\n return cls._registry[backend]\n\n @classmethod\n def new(cls, backend: str, *args, **kwargs) -> \"CheckpointEngine\":\n \"\"\"Create a new checkpoint engine instance.\n\n Args:\n backend: The backend of the checkpoint engine.\n *args: Variable length argument pass to the checkpoint engine constructor.\n **kwargs: Arbitrary keyword arguments pass to the checkpoint engine constructor.\n\n Returns:\n A new checkpoint engine instance.\n \"\"\"\n if backend not in cls._registry:\n raise ValueError(f\"Checkpoint engine {backend} not registered\")\n return cls._registry[backend](*args, **kwargs)\n\n\nclass CheckpointEngine(ABC):\n \"\"\"CheckpointEngine is an abstraction to transfer weights from trainer to rollout.\n\n In trainer process:\n >>> trainer = EngineRegistry.new(...) # FSDP, Megatron, VeOmini, TorchTitan, ...\n >>> engine = CheckpointEngine.new(...) # NCCLCheckpointEngine, NIXLCheckpointEngine, ...\n >>> await engine.send_weights(trainer.get_per_tensor_param())\n\n In rollout process:\n >>> engine = CheckpointEngine.new(...)\n >>> server_adapter = ServerAdapter()\n >>> await server_adapter.update_weights(engine.get_weights()) # update weights via cuda ipc\n \"\"\"\n\n @abstractmethod\n def prepare(self) -> dict[str, Any]:\n \"\"\"Prepare checkpoint engine before each step send_weights/receive_weights.\n\n 1. Allocate weight bucket.\n 2. [Optional] Register weight bucket for RDMA.\n 3. Return metadata to build communication topology: master ip:port, register RDMA description, etc.\n\n Args:\n worker_group: The worker group that the checkpoint engine will be used.\n\n Returns:\n A dictionary that contains the metadata of the worker group.\n \"\"\"\n raise NotImplementedError\n\n @classmethod\n @abstractmethod\n def build_topology(\n cls, trainer_world_size: int, rollout_world_size: int, metadata: list[dict]\n ) -> tuple[dict[str, list[Any]], dict[str, list[Any]]]:\n \"\"\"Build communication topology between all workers.\n\n Args:\n trainer_world_size: The world size of the trainer worker group.\n rollout_world_size: The world size of the rollout replica.\n metadata: A list of metadata `prepare` from all workers.\n\n Returns:\n A tuple of two dictionaries that contains the communication topology for trainer and rollout worker group.\n Each dict value should be a list argument equal to the world size of the worker group to dispatch to\n `init_process_group`.\n\n ```\n world_size = rollout.world_size + trainer.world_size\n kwargs = {\n \"rank\": list(range(world_size)),\n \"world_size\": [world_size] * world_size,\n \"master_metadata\": [metadata[0]] * world_size,\n }\n ```\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def init_process_group(self, **kwargs):\n \"\"\"Init process group for checkpoint engine.\n\n Args:\n **kwargs: Keyword arguments from `build_topology`.\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def finalize(self):\n \"\"\"Finalize checkpoint engine after each step send_weights/receive_weights.\n\n 1. Free weight bucket.\n 1. [Optional] Deregister weight bucket for RDMA.\n 2. [Optional] Destroy process group.\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n async def send_weights(self, weights: Generator[tuple[str, torch.Tensor], None, None]):\n \"\"\"Send the weights of the model.\n\n Args:\n weights: A generator that yields the name of the weight tensor and the tensor itself.\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n async def receive_weights(self) -> Generator[tuple[str, torch.Tensor], None, None]:\n \"\"\"Receive the weights of the model.\n\n Yields:\n A tuple of the name of the weight tensor and the tensor itself.\n \"\"\"\n raise NotImplementedError\n\n\nclass CheckpointEngineWithCache(CheckpointEngine):\n \"\"\"Checkpoint engine with local cache: shm, disk, etc. This allow to synchronize weights without interrupting\n rollout ongoing requests (partial rollout). After requests exhausted, rollout can get weights from local cache.\n\n Laminar: https://arxiv.org/abs/2510.12633\n \"\"\"\n\n @abstractmethod\n async def get_weights(self) -> Generator[tuple[str, torch.Tensor], None, None]:\n \"\"\"Get the weights of the model from local cache.\n\n Yields:\n A tuple of the name of the weight tensor and the tensor itself.\n \"\"\"\n raise NotImplementedError\n\n\n@CheckpointEngineRegistry.register(\"naive\")\nclass ColocatedCheckpointEngine(CheckpointEngine):\n \"\"\"Checkpoint engine for trainer and rollout colocated on same GPU.\n\n In trainer process:\n >>> engine = ColocatedCheckpointEngine()\n >>> trainer = Trainer()\n >>> server_adapter = ServerAdapter()\n >>> engine.send_weights(trainer.get_per_tensor_param())\n >>> server_adapter.update_weights(engine.receive_weights())\n \"\"\"\n\n def __init__(self, bucket_size: int, is_master: bool = False) -> None:\n self.bucket_size = bucket_size\n self.is_master = is_master\n\n def prepare(self):\n raise NotImplementedError\n\n def init_process_group(self, **kwargs):\n raise NotImplementedError\n\n def finalize(self):\n raise NotImplementedError\n\n @classmethod\n def build_topology(cls, *args, **kwargs):\n raise NotImplementedError\n\n def send_weights(self, weights: Generator[tuple[str, torch.Tensor], None, None]):\n \"\"\"Send the weights of the model.\n\n Args:\n weights: A generator that yields the name of the weight tensor and the tensor itself.\n \"\"\"\n self.weights = weights\n\n def receive_weights(self) -> Generator[tuple[str, torch.Tensor], None, None]:\n \"\"\"Receive the weights of the model.\n\n Yields:\n A tuple of the name of the weight tensor and the tensor itself.\n \"\"\"\n yield from self.weights\n self.weights = None\n\n\nclass CheckpointEngineWorker(Worker):\n \"\"\"CheckpointEngineWorker colocated with inference engine's WorkerProc on same GPU.\n\n Args:\n rollout_config: The rollout configuration.\n model_config: The model configuration.\n server_adapter: The server adapter to update weights.\n \"\"\"\n\n def __init__(\n self,\n rollout_config: RolloutConfig,\n model_config: HFModelConfig,\n server_adapter: BaseRollout = None,\n ) -> None:\n self.rollout_config = rollout_config\n self.model_config = model_config\n\n # sglang and trt-llm need device_mesh for internal communication\n initialize_global_process_group_ray(timeout_second=None, backend=\"cpu:gloo\")\n self.server_adapter: BaseRollout = server_adapter or get_rollout_class(\n rollout_config.name, rollout_config.mode\n )(config=rollout_config, model_config=model_config, device_mesh=None)\n\n backend = rollout_config.checkpoint_engine.backend\n bucket_size = rollout_config.checkpoint_engine.update_weights_bucket_megabytes << 20\n engine_kwargs = rollout_config.checkpoint_engine.engine_kwargs.get(backend, {})\n self.checkpoint_engine = CheckpointEngineRegistry.new(backend, bucket_size=bucket_size, **engine_kwargs)\n\n @register(dispatch_mode=Dispatch.ONE_TO_ALL, blocking=False)\n async def update_weights(self):\n weights = self.checkpoint_engine.receive_weights()\n await self.server_adapter.update_weights(weights)\n\n @register(dispatch_mode=Dispatch.DP_COMPUTE, blocking=False)\n def execute_checkpoint_engine(self, method: str, *args, **kwargs):\n return getattr(self.checkpoint_engine, method)(*args, **kwargs)\n\n\n_worker_cls = ray.remote(CheckpointEngineWorker)\n\n\nclass CheckpointEngineManager:\n \"\"\"Checkpoint engine manager to coordinate weight synchronization between trainer and rollout replicas.\n\n - ME: model engine, FSDP, MCore, VeOmni, export full tensor generator `get_per_tensor_param`\n - CE: checkpoint engine, NCCL, NIXL, etc\n\n In trainer, model engine and checkpoint engine are in same process.\n In rollout, checkpoint engine and rollout worker are in separate process, update weights via cuda ipc.\n\n ```\n ┌────────┬────────┬─────┬────────┐ ┌───────────────────┬───────────────────┐\n │ ┌────┐ │ ┌────┐ │ │ ┌────┐ │ │ Replica 0 │ Replica 1 │\n │ │ ME0│ │ │ ME1│ │ │ │ MEn│ │ ├────┬────┬────┬────┼────┬────┬────┬────┤\n │ └──┬─┘ │ └────┘ │ ... │ └────┘ │ │ 0 │ 1 │ 2 │ 3 │ 0 │ 1 │ 2 │ 3 │\n │ v | | | | └──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┘\n | ┌──┴─┐ │ ┌────┐ │ │ ┌────┐ │ ^ ^ ^ cuda ipc ^ ^ ^\n │ │ CE │ │ │ CE │ │ │ │ CE │ │ ┌──┴─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─┬──┴─┐\n │ └──┬─┘ │ └────┘ │ │ └────┘ │ │ CE │ CE │ CE │ CE │ CE │ CE │ CE │ CE |\n └────┼───┴────────┴─────┴────────┘ └──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┘\n v | | | | | | | |\n └─────────────(nccl/nixl/..)─────────────┴────┴────┴────┴────┴────┴────┴────┘\n ```\n\n Args:\n backend: The checkpoint engine backend.\n trainer: The trainer worker group.\n replicas: The list of rollout replicas.\n \"\"\"\n\n def __init__(\n self,\n backend: str,\n trainer: RayWorkerGroup,\n replicas: list[RolloutReplica],\n ) -> None:\n self.backend = backend\n self.backend_cls = CheckpointEngineRegistry.get(backend)\n self.trainer = trainer\n self.replicas = replicas\n\n def build_process_group(self, rollout: RayWorkerGroup):\n \"\"\"Build process group for trainer and rollout replicas.\"\"\"\n trainer = self.trainer\n\n # 1. prepare all workers\n metadata = ray.get(\n trainer.execute_checkpoint_engine([\"prepare\"] * trainer.world_size)\n + rollout.execute_checkpoint_engine([\"prepare\"] * rollout.world_size)\n )\n\n # 2. build communication topology between all workers\n trainer_kwargs, rollout_kwargs = self.backend_cls.build_topology(\n trainer.world_size, rollout.world_size, metadata\n )\n for k, v in trainer_kwargs.items():\n assert len(v) == trainer.world_size, f\"trainer_kwargs[{k}] must have length of {trainer.world_size}\"\n for k, v in rollout_kwargs.items():\n assert len(v) == rollout.world_size, f\"rollout_kwargs[{k}] must have length of {rollout.world_size}\"\n\n trainer_kwargs[\"method\"] = [\"init_process_group\"] * trainer.world_size\n rollout_kwargs[\"method\"] = [\"init_process_group\"] * rollout.world_size\n\n # 3. init process group between all workers\n ray.get(\n trainer.execute_checkpoint_engine(**trainer_kwargs) + rollout.execute_checkpoint_engine(**rollout_kwargs)\n )\n\n def add_replicas(self, replicas: list[RolloutReplica]):\n \"\"\"Add rollout replicas to the manager for elastic scale up, will rebuild process group.\n\n Args:\n replicas: The list of rollout replicas to add.\n \"\"\"\n self.replicas.extend(replicas)\n\n def remove_replicas(self, replicas: list[RolloutReplica]):\n \"\"\"Remove rollout replicas from the manager for elastic scale down, will rebuild process group.\n\n Args:\n replicas: The list of rollout replicas to remove.\n \"\"\"\n replicas_set = set(replicas)\n self.replicas = [r for r in self.replicas if r not in replicas_set]\n\n @auto_await\n async def sleep_replicas(self):\n \"\"\"Sleep all rollout replicas: free weight and kv_cache device memory.\"\"\"\n # skip sleep replicas for disaggregated rollout\n if self.backend != \"naive\":\n return\n await asyncio.gather(*[r.sleep() for r in self.replicas])\n\n @auto_await\n async def update_weights(self):\n \"\"\"Update weights from trainer to rollout replicas.\"\"\"\n\n # 0. update weights for sync training with colocated trainer and rollout\n if self.backend == \"naive\":\n ray.get(self.trainer.update_weights())\n return\n\n # 1. abort and save all unfinished requests for partial rollout\n await asyncio.gather(*[r.abort_all_requests() for r in self.replicas])\n\n # 2. create a temporay worker group for all replicas\n workers = []\n for replica in self.replicas:\n workers.extend(replica.workers)\n rollout = RayWorkerGroup(worker_handles=workers, ray_cls_with_init=RayClassWithInitArgs(cls=_worker_cls))\n trainer = self.trainer\n\n # 3. build process group\n self.build_process_group(rollout)\n\n # 4. update weights of all workers\n ray.get(trainer.update_weights() + rollout.update_weights())\n\n # 5. finalize all workers\n ray.get(\n trainer.execute_checkpoint_engine([\"finalize\"] * trainer.world_size)\n + rollout.execute_checkpoint_engine([\"finalize\"] * rollout.world_size)\n )\n\n # 6. resume all unfinished requests for partial rollout\n await asyncio.gather(*[r.resume_all_requests() for r in self.replicas])\n"} +{"file_name": "verl__checkpoint_engine__nixl_checkpoint_engine.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport asyncio\nimport logging\nimport os\nimport time\nimport uuid\nfrom collections import defaultdict, deque\nfrom dataclasses import dataclass\nfrom typing import AsyncGenerator, Generator\nfrom unittest.mock import patch\n\nwith patch(\"importlib.metadata.distributions\", return_value=[]):\n import cupy as cp\n\nimport nixl._api as nixl_api\nimport nixl._bindings as nixl_bindings\nimport ray\nimport torch\nimport zmq\nimport zmq.asyncio\n\nfrom verl.checkpoint_engine.base import CheckpointEngine, CheckpointEngineRegistry, TensorMeta\nfrom verl.utils.net_utils import get_free_port, is_valid_ipv6_address\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\n@dataclass\nclass NixlAgentMetadata:\n agent_name: str\n agent_metadata: bytes\n zmq_ip: str\n zmq_port: int\n\n\nclass NixlAgent:\n \"\"\"This is a wrapper class for nixl_agent, the main purpose is to use ZeroMQ instead of\n `nixl_agent.send_notif` to send bucket tensor metadata.\n \"\"\"\n\n def __init__(self):\n self.agent_name = str(uuid.uuid4())\n self.agent = nixl_api.nixl_agent(self.agent_name)\n self.notifications: dict[str, deque[bytes]] = defaultdict(deque)\n\n self.start_zmq_server()\n self.zmq_clients: dict[str, zmq.Socket] = {}\n self.messages: dict[str, deque[bytes]] = defaultdict(deque)\n\n def __getattr__(self, name):\n attr = getattr(self.agent, name)\n\n if callable(attr):\n\n def wrapper(*args, **kwargs):\n return attr(*args, **kwargs)\n\n return wrapper\n else:\n return attr\n\n def get_agent_metadata(self) -> NixlAgentMetadata:\n return NixlAgentMetadata(\n agent_name=self.agent_name,\n agent_metadata=self.agent.get_agent_metadata(),\n zmq_ip=self.ip,\n zmq_port=self.listen_port,\n )\n\n def start_zmq_server(self):\n self.ip = ray.util.get_node_ip_address().strip(\"[]\")\n self.listen_port, self.listen_sock = get_free_port(self.ip)\n\n context = zmq.asyncio.Context()\n self.socket = context.socket(zmq.PULL)\n if is_valid_ipv6_address(self.ip):\n address = f\"tcp://[{self.ip}]:{self.listen_port}\"\n self.socket.setsockopt(zmq.IPV6, 1)\n else:\n address = f\"tcp://{self.ip}:{self.listen_port}\"\n\n self.socket.bind(address)\n\n def add_remote_agent(self, metadata: NixlAgentMetadata) -> str:\n agent_name = self.agent.add_remote_agent(metadata.agent_metadata).decode(\"utf-8\")\n assert agent_name == metadata.agent_name, f\"Agent name {agent_name} not equal to {metadata.agent_name}\"\n\n context = zmq.Context()\n socket = context.socket(zmq.PUSH)\n if is_valid_ipv6_address(metadata.zmq_ip):\n address = f\"tcp://[{metadata.zmq_ip}]:{metadata.zmq_port}\"\n socket.setsockopt(zmq.IPV6, 1)\n else:\n address = f\"tcp://{metadata.zmq_ip}:{metadata.zmq_port}\"\n\n socket.connect(address)\n self.zmq_clients[agent_name] = socket\n return agent_name\n\n def remove_remote_agent(self, agent_name: str):\n self.agent.remove_remote_agent(agent_name)\n socket = self.zmq_clients.pop(agent_name)\n socket.close()\n\n def send_message(self, agent_name, message: dict):\n socket = self.zmq_clients[agent_name]\n socket.send_pyobj((self.agent_name, message), zmq.DONTWAIT)\n\n async def read_message(self, agent_name: str) -> dict:\n while len(self.messages[agent_name]) == 0:\n recv_agent_name, message = await self.socket.recv_pyobj()\n self.messages[recv_agent_name].append(message)\n return self.messages[agent_name].popleft()\n\n async def get_notification(self, remote_name: str) -> bytes:\n while len(self.notifications[remote_name]) == 0:\n notifs = self.agent.get_new_notifs()\n for remote_name, notif in notifs.items():\n self.notifications[remote_name].extend(notif)\n await asyncio.sleep(0)\n return self.notifications[remote_name].popleft()\n\n\nclass ReadableOperation:\n \"\"\"Encapsulates a readable operation to remote agent.\n 1. send metadata to remote agent\n 2. wait until remote agent read complete.\n\n Args:\n agent (NixlAgent): The Nixl agent.\n remote_agent (str): The name of the remote agent.\n local_descs (nixl_bindings.nixlXferDList): The local transfer descriptors.\n metadata (dict): Metadata for the read operation.\n bucket_size (int): The size of the bucket in bytes.\n \"\"\"\n\n def __init__(\n self,\n agent: NixlAgent,\n remote_agent: str,\n local_descs: nixl_bindings.nixlXferDList,\n metadata: dict,\n ):\n self.agent = agent\n self.remote_agent = remote_agent\n self.local_descs = local_descs\n self.notify_key = uuid.uuid4().bytes\n message = {\"notify_key\": self.notify_key, \"remote_descs\": self.local_descs, **metadata}\n self.agent.send_message(self.remote_agent, message)\n\n async def wait_for_complete(self):\n \"\"\"Block until remote agent read complete.\"\"\"\n notification = await self.agent.get_notification(self.remote_agent)\n assert self.notify_key == notification, f\"Notify key {self.notify_key} not equal to {notification}\"\n logger.debug(f\"ReadableOperation to {self.remote_agent} complete\")\n\n\nclass ReadOperation:\n \"\"\"Encapsulates a read operation from remote agent.\n 1. read medata from remote agent\n 2. start read transfer operation\n 3. wait until read complete\n\n Args:\n agent (NixlAgent): The Nixl agent.\n remote_agent (str): The name of the remote agent.\n local_descs (nixl_bindings.nixlXferDList): The local transfer descriptors.\n bucket_size (int): The size of the bucket in bytes.\n \"\"\"\n\n def __init__(self, agent: NixlAgent, remote_agent: str, local_descs: nixl_bindings.nixlXferDList, bucket_size: int):\n self.agent = agent\n self.remote_agent = remote_agent\n self.local_descs = local_descs\n self.remote_descs = None\n self.xfer_handle = None\n self.notify_key = None\n self.bucket_size = bucket_size\n self.start_time = None\n\n async def read_metadata(self) -> dict:\n \"\"\"Block until the remote agent sends the metadata.\n\n Returns:\n dict: Metadata from the remote agent.\n \"\"\"\n metadata = await self.agent.read_message(self.remote_agent)\n self.remote_descs = metadata.pop(\"remote_descs\")\n self.notify_key = metadata.pop(\"notify_key\")\n return metadata\n\n def begin_read(self):\n \"\"\"Start the read operation.\"\"\"\n assert self.remote_descs is not None and self.notify_key is not None\n self.xfer_handle = self.agent.initialize_xfer(\n \"READ\", self.local_descs, self.remote_descs, self.remote_agent, self.notify_key\n )\n state = self.agent.transfer(self.xfer_handle)\n assert state != \"ERR\", f\"Read from {self.remote_agent} got to {state} state.\"\n self.start_time = time.time()\n\n async def wait_for_complete(self):\n \"\"\"Block until the read operation complete.\"\"\"\n while True:\n state = self.agent.check_xfer_state(self.xfer_handle)\n if state == \"ERR\":\n logger.error(f\"Read from {self.remote_agent} got to {state} state.\")\n exit(-1)\n elif state == \"DONE\":\n break\n else:\n await asyncio.sleep(0)\n self.agent.release_xfer_handle(self.xfer_handle)\n end_time = time.time()\n bandwidth = self.bucket_size / (end_time - self.start_time) / (1024 * 1024 * 1024)\n logger.debug(f\"ReadOperation read data from {self.remote_agent} complete, bandwidth: {bandwidth:.2f} GB/s\")\n\n\n@CheckpointEngineRegistry.register(\"nixl\")\nclass NIXLCheckpointEngine(CheckpointEngine):\n \"\"\"NIXL checkpoint engine with p2p communication, support various backends: ucx, uccl, mooncacke, etc.\n\n For UCX backend, some environment variables need to be set: UCX_TLS, UCX_IB_GID_INDEX, UCX_IB_DEVICES, etc.\n Please refer to: https://openucx.readthedocs.io/en/master/faq.html\n\n Args:\n bucket_size (int): Bucket size in bytes to transfer multiple weights at one time. Note that we use\n two buffer to send and recv weights at same time, so the device memory overhead is 2 * bucket_size.\n device (str): The device to use for the checkpoint engine, \"cpu\" or \"cuda\".\n rollout_dtype (torch.dtype): The dtype of the weights received from rollout workers. Defaults to torch.bfloat16.\n \"\"\"\n\n def __init__(\n self,\n bucket_size: int,\n device: str = \"cuda\",\n rollout_dtype: torch.dtype = torch.bfloat16,\n is_master: bool = False,\n ):\n self.bucket_size = bucket_size\n self.device = device\n self.rollout_dtype = rollout_dtype\n self.agent = NixlAgent()\n self.is_master = is_master\n\n def prepare(self) -> NixlAgentMetadata:\n \"\"\"Prepare send and recv bucket.\n\n Returns:\n NixlAgentMetadata: The metadata of the current nixl agent.\n \"\"\"\n # For master process, use cupy instead of torch to avoid memory register error\n # when `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True`.\n if self.device == \"cuda\":\n send_buf = cp.zeros(self.bucket_size, dtype=cp.uint8)\n recv_buf = cp.zeros(self.bucket_size, dtype=cp.uint8)\n self.send_buf = torch.as_tensor(send_buf, dtype=torch.uint8)\n self.recv_buf = torch.as_tensor(recv_buf, dtype=torch.uint8)\n else:\n self.send_buf = torch.zeros(self.bucket_size, dtype=torch.uint8, device=self.device, pin_memory=True)\n self.recv_buf = torch.zeros(self.bucket_size, dtype=torch.uint8, device=self.device, pin_memory=True)\n self.send_reg_descs = self.agent.register_memory(self.send_buf)\n self.recv_reg_descs = self.agent.register_memory(self.recv_buf)\n self.send_descs = self.agent.get_xfer_descs(self.send_buf)\n self.recv_descs = self.agent.get_xfer_descs(self.recv_buf)\n\n return self.agent.get_agent_metadata()\n\n @classmethod\n def build_topology(cls, trainer_world_size: int, rollout_world_size: int, metadata: list[dict]):\n trainer_kwargs = {\n \"method\": [\"init_process_group\"] * trainer_world_size,\n \"rank\": [0] + [-1] * (trainer_world_size - 1),\n \"world_size\": [rollout_world_size + 1] * trainer_world_size,\n \"prev_agent_metadata\": [None] * trainer_world_size,\n \"next_agent_metadata\": [metadata[-rollout_world_size]] + [None] * (trainer_world_size - 1),\n }\n\n rollout_kwargs = {\n \"method\": [\"init_process_group\"] * rollout_world_size,\n \"rank\": list(range(1, rollout_world_size + 1)),\n \"world_size\": [rollout_world_size + 1] * rollout_world_size,\n \"prev_agent_metadata\": [metadata[0]] + metadata[-rollout_world_size:-1],\n \"next_agent_metadata\": metadata[-rollout_world_size + 1 :] + [None],\n }\n return trainer_kwargs, rollout_kwargs\n\n def init_process_group(\n self, rank: int, world_size: int, prev_agent_metadata: NixlAgentMetadata, next_agent_metadata: NixlAgentMetadata\n ):\n \"\"\"Setup the communication with the previous and next agent.\n\n Args:\n rank (int): The rank of the current process.\n world_size (int): The total number of processes.\n prev_agent_metadata (NixlAgentMetadata): The metadata of the previous nixl agent.\n next_agent_metadata (NixlAgentMetadata): The metadata of the next nixl agent.\n \"\"\"\n if rank < 0:\n assert not prev_agent_metadata and not next_agent_metadata, (\n f\"rank {rank} should not have prev_agent_metadata or next_agent_metadata\"\n )\n elif rank == 0:\n assert not prev_agent_metadata and next_agent_metadata, f\"rank {rank} should have next_agent_metadata\"\n elif 0 < rank < world_size - 1:\n assert prev_agent_metadata and next_agent_metadata, (\n f\"rank {rank} should have prev_agent_metadata and next_agent_metadata\"\n )\n elif rank == world_size - 1:\n assert prev_agent_metadata and not next_agent_metadata, (\n f\"rank {rank} should have prev_agent_metadata and not next_agent_metadata\"\n )\n\n self.rank = rank\n self.world_size = world_size\n self.prev_agent = None\n self.next_agent = None\n\n if prev_agent_metadata is not None:\n self.prev_agent = self.agent.add_remote_agent(prev_agent_metadata)\n\n if next_agent_metadata is not None:\n self.next_agent = self.agent.add_remote_agent(next_agent_metadata)\n\n logger.info(\n f\"init_process_group rank: {self.rank}, world_size: {self.world_size}, \"\n f\"prev_agent: {self.prev_agent}, next_agent: {self.next_agent}\"\n )\n\n def finalize(self):\n \"\"\"Cleanup communication with the previous and next agent, and deregister the memory.\"\"\"\n if self.prev_agent:\n self.agent.remove_remote_agent(self.prev_agent)\n if self.next_agent:\n self.agent.remove_remote_agent(self.next_agent)\n\n self.agent.deregister_memory(self.send_reg_descs)\n self.agent.deregister_memory(self.recv_reg_descs)\n self.send_buf = None\n self.recv_buf = None\n self.send_reg_descs = None\n self.recv_reg_descs = None\n self.send_descs = None\n self.recv_descs = None\n\n self.rank = None\n self.world_size = None\n self.prev_agent = None\n self.next_agent = None\n\n @torch.no_grad()\n async def send_weights(self, weights: Generator[tuple[str, torch.Tensor], None, None]):\n \"\"\"Send the weights of the model.\n\n Args:\n weights: A generator that yields the name of the weight tensor and the tensor itself.\n \"\"\"\n assert self.rank <= 0, \"Trainer workers other than rank 0 should not send weights.\"\n\n # For trainer workers other than rank 0, just consume weights and do nothing.\n if self.rank < 0:\n for name, weight in weights:\n pass\n return\n\n assert self.next_agent is not None, \"Next agent is not set.\"\n send_buf, recv_buf = self.send_buf, self.recv_buf\n send_descs, recv_descs = self.send_descs, self.recv_descs\n readable_op = None\n\n start_time = time.time()\n bucket_meta: dict[str, TensorMeta] = {}\n offset = 0\n for name, weight in weights:\n # fill the tensor bucket\n if offset + weight.nbytes > self.bucket_size:\n torch.cuda.synchronize()\n\n # wait previous bucket to be received\n if readable_op is not None:\n await readable_op.wait_for_complete()\n\n # send bucket meta to next agent\n readable_op = ReadableOperation(\n self.agent,\n self.next_agent,\n send_descs,\n {\"bucket_meta\": bucket_meta, \"is_last\": False},\n )\n\n # swap send and recv buf\n send_buf, recv_buf = recv_buf, send_buf\n send_descs, recv_descs = recv_descs, send_descs\n bucket_meta = {}\n offset = 0\n\n assert offset + weight.nbytes <= self.bucket_size, (\n f\"Weight {name}({weight.shape}, {weight.dtype}) is too large to fit in the bucket.\"\n )\n\n bucket_meta[name] = {\n \"name\": name,\n \"shape\": weight.shape,\n \"dtype\": weight.dtype,\n \"offset\": offset,\n }\n send_buf[offset : offset + weight.nbytes].copy_(weight.view(-1).view(torch.uint8), non_blocking=True)\n offset += weight.nbytes\n\n # send last bucket meta to next agent\n torch.cuda.synchronize()\n if readable_op is not None:\n await readable_op.wait_for_complete()\n\n readable_op = ReadableOperation(\n self.agent, self.next_agent, send_descs, {\"bucket_meta\": bucket_meta, \"is_last\": True}\n )\n await readable_op.wait_for_complete()\n logger.info(f\"Rank {self.rank} send weights done, time cost: {time.time() - start_time:.2f}s\")\n\n @torch.no_grad()\n async def receive_weights(self) -> AsyncGenerator[tuple[str, torch.Tensor], None]:\n \"\"\"Receive the weights of the model.\n\n Yields:\n A tuple of the name of the weight tensor and the tensor itself.\n \"\"\"\n assert self.prev_agent is not None, \"Previous agent is not set.\"\n send_buf, recv_buf = self.send_buf, self.recv_buf\n send_descs, recv_descs = self.send_descs, self.recv_descs\n total_bytes, total_params = 0, 0\n\n # receive first bucket from previous agent\n start_time = time.time()\n read_op = ReadOperation(self.agent, self.prev_agent, recv_descs, self.bucket_size)\n metadata = await read_op.read_metadata()\n read_op.begin_read()\n await read_op.wait_for_complete()\n total_bytes += self.bucket_size\n total_params += len(metadata[\"bucket_meta\"])\n\n # swap send and recv buf\n send_buf, recv_buf = recv_buf, send_buf\n send_descs, recv_descs = recv_descs, send_descs\n while not metadata[\"is_last\"]:\n # 1. send bucket to next agent\n readable_op = None\n if self.next_agent is not None:\n readable_op = ReadableOperation(\n self.agent,\n self.next_agent,\n send_descs,\n metadata,\n )\n\n # 2. receive bucket from previous agent\n read_op = ReadOperation(self.agent, self.prev_agent, recv_descs, self.bucket_size)\n next_metadata = await read_op.read_metadata()\n read_op.begin_read()\n\n # 3. yield tensor from send_buf\n for name, meta in metadata[\"bucket_meta\"].items():\n dtype, shape = meta[\"dtype\"], meta[\"shape\"]\n size = dtype.itemsize * shape.numel()\n tensor = send_buf[meta[\"offset\"] : meta[\"offset\"] + size].view(dtype=dtype).view(shape)\n yield name, tensor\n\n # 4. wait for next agent read complete and read from previous agent complete\n if readable_op is not None:\n await readable_op.wait_for_complete()\n await read_op.wait_for_complete()\n total_bytes += self.bucket_size\n total_params += len(next_metadata[\"bucket_meta\"])\n\n # 5. swap send and recv buf\n torch.cuda.synchronize() # sync non-blocking copy\n metadata = next_metadata\n send_buf, recv_buf = recv_buf, send_buf\n send_descs, recv_descs = recv_descs, send_descs\n\n # send last bucket to next agent\n readable_op = None\n if self.next_agent is not None:\n readable_op = ReadableOperation(\n self.agent,\n self.next_agent,\n send_descs,\n metadata,\n )\n\n # yield tensor from send_buf\n for name, meta in metadata[\"bucket_meta\"].items():\n dtype, shape = meta[\"dtype\"], meta[\"shape\"]\n size = dtype.itemsize * shape.numel()\n tensor = send_buf[meta[\"offset\"] : meta[\"offset\"] + size].view(dtype=dtype).view(shape)\n yield name, tensor\n\n # wait for next agent read complete\n if readable_op is not None:\n await readable_op.wait_for_complete()\n time_cost = time.time() - start_time\n bandwidth = total_bytes / time_cost / (1024 * 1024 * 1024)\n logger.info(\n f\"Rank {self.rank} receive weights done, total_params: {total_params}, \"\n f\"time cost: {time_cost:.2f}s, bandwidth: {bandwidth:.2f} GB/s\"\n )\n"} +{"file_name": "verl__interactions__gsm8k_interaction.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2023-2024 SGLang Team\n# Copyright 2025 ModelBest Inc. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport logging\nimport os\nfrom typing import Any, Optional\nfrom uuid import uuid4\n\nfrom verl.utils.reward_score import gsm8k\n\nfrom .base import BaseInteraction\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\nclass Gsm8kInteraction(BaseInteraction):\n \"\"\"A demo interaction for calculating the reward of gsm8k.\n\n - `start_interaction`: start a interaction instance for a trajectory.\n - `generate_response`: generate the response of the assistant.\n - `calculate_score`: calculate the score of the interaction.\n - `finalize_interaction`: finalize the interaction instance.\n \"\"\"\n\n def __init__(self, config: dict):\n super().__init__(config)\n self._instance_dict = {}\n\n async def start_interaction(\n self, instance_id: Optional[str] = None, ground_truth: Optional[str] = None, **kwargs\n ) -> str:\n if instance_id is None:\n instance_id = str(uuid4())\n self._instance_dict[instance_id] = {\n \"response\": \"\",\n \"ground_truth\": ground_truth,\n \"reward\": 0.0,\n }\n return instance_id\n\n async def generate_response(\n self, instance_id: str, messages: list[dict[str, Any]], **kwargs\n ) -> tuple[bool, str, float, dict]:\n content = \"\"\n for i in range(len(messages) - 1, -1, -1):\n item = messages[i]\n if item.get(\"role\") == \"assistant\":\n content = item.get(\"content\")\n break\n\n self._instance_dict[instance_id][\"response\"] = content\n\n reward = await self.calculate_score(instance_id)\n if reward == 1.0:\n response = \"Your response is correct!\"\n should_terminate_sequence = True\n else:\n response = \"Your response is incorrect! You need to reflect on your answer and try again.\"\n should_terminate_sequence = False\n\n return should_terminate_sequence, response, reward, {}\n\n async def calculate_score(self, instance_id: str, **kwargs) -> float:\n return gsm8k.compute_score(\n self._instance_dict[instance_id][\"response\"],\n self._instance_dict[instance_id][\"ground_truth\"],\n method=\"strict\",\n format_score=0.0,\n score=1.0,\n )\n\n async def finalize_interaction(self, instance_id: str, **kwargs) -> None:\n del self._instance_dict[instance_id]\n"} +{"file_name": "verl__interactions__utils__interaction_registry.py", "text": "# Copyright 2023-2024 SGLang Team\n# Copyright 2025 ModelBest Inc. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport importlib.util\nimport logging\nimport os\nimport sys\n\nfrom omegaconf import OmegaConf\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef get_interaction_class(cls_name):\n \"\"\"Dynamically import and return the interaction class.\"\"\"\n module_name, class_name = cls_name.rsplit(\".\", 1)\n if module_name not in sys.modules:\n spec = importlib.util.find_spec(module_name)\n module = importlib.util.module_from_spec(spec)\n sys.modules[module_name] = module\n spec.loader.exec_module(module)\n else:\n module = sys.modules[module_name]\n\n interaction_cls = getattr(module, class_name)\n return interaction_cls\n\n\ndef initialize_interactions_from_config(interaction_config_file):\n \"\"\"Initialize interactions from configuration file.\n\n Args:\n interaction_config_file: Path to the interaction configuration file.\n\n Returns:\n dict: A dictionary mapping interaction names to BaseInteraction instances.\n \"\"\"\n interaction_config = OmegaConf.load(interaction_config_file)\n interaction_map = {}\n\n for interaction_item in interaction_config.interaction:\n cls_name = interaction_item.class_name\n interaction_cls = get_interaction_class(cls_name)\n\n # Extract config and name\n config = OmegaConf.to_container(interaction_item.config, resolve=True)\n\n # Get the interaction name - either from config or derive from class name\n name = interaction_item.get(\"name\", None)\n if name is None:\n # If no name is specified, use the class name as default\n class_simple_name = cls_name.split(\".\")[-1]\n # Remove \"Interaction\" suffix if present, otherwise use full class name\n if class_simple_name.endswith(\"Interaction\"):\n name = class_simple_name[:-11].lower() # Remove \"Interaction\" (11 chars)\n else:\n name = class_simple_name.lower()\n\n # Check for duplicate names\n if name in interaction_map:\n raise ValueError(f\"Duplicate interaction name '{name}' found. Each interaction must have a unique name.\")\n\n # Inject the name into the config\n config[\"name\"] = name\n\n # Create the interaction instance\n interaction = interaction_cls(config=config)\n interaction_map[name] = interaction\n\n logger.info(f\"Initialized interaction '{name}' with class '{cls_name}'\")\n\n return interaction_map\n"} +{"file_name": "verl__interactions__weather_interaction.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport logging\nimport os\nfrom typing import Any, Optional\nfrom uuid import uuid4\n\nfrom .base import BaseInteraction\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\nclass WeatherInteraction(BaseInteraction):\n \"\"\"A demo interaction for handling weather-related queries.\n\n - `start_interaction`: start a interaction instance for a trajectory.\n - `generate_response`: generate the response of the assistant.\n - `calculate_score`: calculate the score of the interaction.\n - `finalize_interaction`: finalize the interaction instance.\n \"\"\"\n\n def __init__(self, config: dict):\n super().__init__(config)\n self._instance_dict = {}\n\n async def start_interaction(\n self, instance_id: Optional[str] = None, ground_truth: Optional[str] = None, **kwargs\n ) -> str:\n if instance_id is None:\n instance_id = str(uuid4())\n self._instance_dict[instance_id] = {\n \"response\": \"\",\n \"ground_truth\": ground_truth,\n \"reward\": 0.0,\n }\n return instance_id\n\n async def generate_response(\n self, instance_id: str, messages: list[dict[str, Any]], **kwargs\n ) -> tuple[bool, str, float, dict]:\n content = \"no tool call\"\n for i in range(len(messages) - 1, -1, -1):\n item = messages[i]\n if item.get(\"role\") == \"tool\":\n content = item.get(\"content\")\n break\n self._instance_dict[instance_id][\"response\"] = content\n\n reward = await self.calculate_score(instance_id)\n if reward == 1.0:\n response = \"Thank you for your weather query!\"\n should_terminate_sequence = True\n else:\n response = \"Please use the weather tool to get the weather information.\"\n should_terminate_sequence = True\n return should_terminate_sequence, response, reward, {}\n\n async def calculate_score(self, instance_id: str, **kwargs) -> float:\n # For weather interaction, we can implement a more complex scoring logic\n # For now, we'll just return a default score of 1.0\n if self._instance_dict[instance_id][\"response\"] == \"no tool call\":\n return 0.0\n return 1.0\n\n async def finalize_interaction(self, instance_id: str, **kwargs) -> None:\n del self._instance_dict[instance_id]\n"} +{"file_name": "verl__model_merger__base_model_merger.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport argparse\nimport os\nfrom abc import ABC, abstractmethod\nfrom dataclasses import dataclass, field\nfrom typing import Optional\n\nimport torch\nfrom accelerate import init_empty_weights\nfrom transformers import (\n AutoConfig,\n AutoModelForCausalLM,\n AutoModelForTokenClassification,\n GenerationConfig,\n)\n\nfrom verl.utils import hf_processor, hf_tokenizer\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description=\"verl model merger\")\n subparsers = parser.add_subparsers(dest=\"operation\", required=True, help=\"Specify 'merge' or 'test' operation.\")\n\n base_op_parser = argparse.ArgumentParser(add_help=False)\n base_op_parser.add_argument(\n \"--backend\", type=str, required=True, choices=[\"fsdp\", \"megatron\"], help=\"The backend of the model\"\n )\n base_op_parser.add_argument(\"--local_dir\", type=str, default=None, help=\"Path to the saved model checkpoints.\")\n base_op_parser.add_argument(\n \"--tie-word-embedding\",\n action=\"store_true\",\n help=\"Whether to tie word embedding weights (currently only Megatron supported)\",\n )\n base_op_parser.add_argument(\"--trust-remote-code\", action=\"store_true\", help=\"Whether to trust remote code\")\n base_op_parser.add_argument(\n \"--is-value-model\",\n action=\"store_true\",\n help=\"Whether the model is a value model (currently only Megatron supported)\",\n )\n base_op_parser.add_argument(\n \"--use_cpu_initialization\",\n action=\"store_true\",\n help=\"Whether to use CPU initialization for the model. This is useful for large models that cannot \"\n \"fit into GPU memory during initialization.\",\n )\n\n merge_parser = subparsers.add_parser(\"merge\", parents=[base_op_parser], help=\"Merge model checkpoints and save.\")\n merge_parser.add_argument(\n \"--target_dir\", default=\"tmp\", type=str, help=\"Directory to save the merged huggingface model\"\n )\n merge_parser.add_argument(\n \"--hf_upload_path\", default=None, type=str, help=\"Hugging Face repository ID to upload the model\"\n )\n merge_parser.add_argument(\n \"--private\", action=\"store_true\", help=\"Whether to upload the model to a private Hugging Face repository\"\n )\n\n test_parser = subparsers.add_parser(\n \"test\", parents=[base_op_parser], help=\"Test merged model against a reference Hugging Face model\"\n )\n test_parser.add_argument(\n \"--test_hf_dir\", type=str, required=True, help=\"Path to the reference Hugging Face model directory for testing\"\n )\n\n args = parser.parse_args()\n return args\n\n\n@dataclass\nclass ModelMergerConfig:\n \"\"\"Configuration for model merger operations.\n\n Args:\n operation (str): Operation type - 'merge' or 'test'.\n backend (str): Backend type for the model ('fsdp' or 'megatron').\n target_dir (Optional[str]): Directory to save the merged huggingface model. Defaults to \"tmp\".\n hf_upload_path (Optional[str]): Hugging Face repository ID to upload the model. Defaults to None.\n private (bool): Whether to upload the model to a private Hugging Face repository. Defaults to False.\n test_hf_dir (Optional[str]): Path to the reference Hugging Face model directory for testing. Defaults to None.\n tie_word_embedding (bool): Whether to tie word embedding weights (currently only Megatron\n supported). Defaults to False.\n trust_remote_code (bool): Whether to trust remote code. Defaults to False.\n is_value_model (bool): Whether the model is a value model (currently only Megatron\n supported). Defaults to False.\n local_dir (Optional[str]): Path to the saved model checkpoints. Defaults to None.\n hf_model_config_path (Optional[str]): Path to HuggingFace model configuration files. Defaults to None.\n hf_upload (bool): Whether to upload to HuggingFace (computed automatically). Not for initialization.\n use_cpu_initialization (bool): Whether to use CPU initialization for large models. Defaults to False.\n \"\"\"\n\n operation: str # 'merge' or 'test'\n backend: str\n target_dir: Optional[str] = \"tmp\"\n hf_upload_path: Optional[str] = None\n private: bool = False\n test_hf_dir: Optional[str] = None\n tie_word_embedding: bool = False\n trust_remote_code: bool = False\n is_value_model: bool = False\n local_dir: Optional[str] = None\n hf_model_config_path: Optional[str] = None\n hf_upload: bool = field(init=False)\n use_cpu_initialization: bool = False\n\n def __post_init__(self):\n self.hf_upload = self.operation == \"merge\" and bool(self.hf_upload_path)\n if self.operation == \"test\":\n self.target_dir = None\n self.hf_upload_path = None\n self.private = False\n\n\ndef generate_config_from_args(args: argparse.Namespace) -> ModelMergerConfig:\n common_config_args = {\n \"operation\": args.operation,\n \"backend\": args.backend,\n \"tie_word_embedding\": args.tie_word_embedding,\n \"trust_remote_code\": args.trust_remote_code,\n \"is_value_model\": args.is_value_model,\n \"local_dir\": args.local_dir,\n \"hf_model_config_path\": os.path.join(args.local_dir, \"huggingface\"),\n \"use_cpu_initialization\": args.use_cpu_initialization,\n }\n\n if args.operation == \"merge\":\n config = ModelMergerConfig(\n **common_config_args,\n target_dir=args.target_dir,\n hf_upload_path=args.hf_upload_path,\n private=args.private,\n test_hf_dir=None,\n )\n os.makedirs(config.target_dir, exist_ok=True)\n elif args.operation == \"test\":\n config = ModelMergerConfig(\n **common_config_args,\n test_hf_dir=args.test_hf_dir,\n # the following args are not used by test operation\n target_dir=None,\n hf_upload_path=None,\n private=False,\n )\n else:\n raise NotImplementedError(f\"Unknown operation: {args.operation}\")\n return config\n\n\nclass BaseModelMerger(ABC):\n \"\"\"\n Abstract base class for merging distributed model checkpoints into HuggingFace format.\n\n This class provides common functionality for converting model checkpoints from different\n distributed training backends (FSDP, Megatron) into standard HuggingFace format that\n can be easily loaded and used for inference or further training.\n\n The merger supports two main operations:\n - merge: Convert and save checkpoints to HuggingFace format\n - test: Validate merged checkpoints against a reference model\n\n Args:\n config (ModelMergerConfig): Configuration object containing paths, backend type,\n and operation parameters.\n\n Attributes:\n config (ModelMergerConfig): The configuration object passed during initialization.\n hf_model_config_path (str): Path to the HuggingFace model configuration files.\n model_config (PretrainedConfig): Loaded HuggingFace model configuration.\n \"\"\"\n\n def __init__(self, config: ModelMergerConfig):\n self.config = config\n self.hf_model_config_path = config.hf_model_config_path\n self.model_config = AutoConfig.from_pretrained(\n self.hf_model_config_path, trust_remote_code=self.config.trust_remote_code\n )\n\n def get_transformers_auto_model_class(self):\n has_remote_code = hasattr(self.model_config, \"auto_map\") and any(\n self.model_config.architectures[0] in val for val in self.model_config.auto_map.values()\n )\n if has_remote_code:\n auto_class = next(\n k for k, v in self.model_config.auto_map.items() if self.model_config.architectures[0] in v\n )\n match auto_class:\n case \"AutoModelForCausalLM\":\n return AutoModelForCausalLM\n case \"AutoModelForTokenClassification\":\n return AutoModelForTokenClassification\n case \"AutoModelForVision2Seq\":\n # Handle different transformers versions for Vision2Seq models\n import transformers\n from packaging import version\n\n if version.parse(transformers.__version__) >= version.parse(\"4.54.0\"):\n # transformers >= 4.54.0 uses AutoModelForImageTextToText\n from transformers import AutoModelForImageTextToText\n\n return AutoModelForImageTextToText\n else:\n # transformers < 4.54.0 uses AutoModelForVision2Seq\n from transformers import AutoModelForVision2Seq\n\n return AutoModelForVision2Seq\n case _:\n raise NotImplementedError(f\"Unknown auto class {auto_class}\")\n else:\n if \"ForTokenClassification\" in self.model_config.architectures[0]:\n return AutoModelForTokenClassification\n elif \"ForCausalLM\" in self.model_config.architectures[0]:\n return AutoModelForCausalLM\n elif \"ForConditionalGeneration\" in self.model_config.architectures[0]:\n return AutoModelForVision2Seq\n\n raise NotImplementedError(f\"Unknown architecture {self.model_config.architectures}\")\n\n def patch_model_generation_config(self, model):\n \"\"\"\n The generation_config created from model config may be different to the pretrained model,\n this may lead to error when generating: https://github.com/volcengine/verl/issues/1246\n\n This function patch the generation_config created from model config to the pretrained model.\n \"\"\"\n if model.can_generate():\n try:\n model.generation_config = GenerationConfig.from_pretrained(self.hf_model_config_path)\n except OSError:\n print(\n f\"Warning: Generation config file not found in {self.hf_model_config_path}, using a \"\n f\"generation config created from the model config.\"\n )\n return model\n\n def save_lora_adapter(self, state_dict: dict[str, torch.Tensor]):\n \"\"\"\n Save lora adapter to safetensors.\n\n Returns:\n lora_path: str, the path to the lora adapter. None if no lora adapter found.\n\n Note:\n This function change the 'state_dict' in place.\n \"\"\"\n lora_params_names = [name for name in state_dict.keys() if \"lora_\" in name]\n\n if len(lora_params_names) == 0:\n return None\n\n import json\n from typing import OrderedDict\n\n import peft\n from safetensors.torch import save_file\n\n lora_params = OrderedDict()\n target_modules = set()\n lora_key = None\n\n for name in lora_params_names:\n lora_key = name.replace(\".default.weight\", \".weight\")\n target_modules.add(lora_key.split(\".\")[-3])\n lora_params[lora_key] = state_dict.pop(name)\n\n lora_rank = min(lora_params[lora_key].shape[0], lora_params[lora_key].shape[1])\n peft_dict = {\n \"r\": lora_rank,\n \"lora_alpha\": 0, # lora_alpha is not set. An error should be raised to inform the user to set it manually.\n \"target_modules\": list(target_modules),\n }\n peft_config = peft.LoraConfig(**peft_dict).to_dict()\n peft_config[\"task_type\"] = peft_config[\"task_type\"].value if peft_config[\"task_type\"] else None\n peft_config[\"peft_type\"] = peft_config[\"peft_type\"].value if peft_config[\"peft_type\"] else None\n peft_config[\"target_modules\"] = list(peft_config[\"target_modules\"])\n\n lora_path = os.path.join(self.config.target_dir, \"lora_adapter\")\n os.makedirs(lora_path, exist_ok=True)\n with open(os.path.join(lora_path, \"adapter_config.json\"), \"w\", encoding=\"utf-8\") as f:\n json.dump(peft_config, f, ensure_ascii=False, indent=4)\n save_file(lora_params, os.path.join(lora_path, \"adapter_model.safetensors\"))\n\n for name in list(state_dict.keys()):\n key = (\n name.replace(\"base_model.model.\", \"\")\n .replace(\".base_layer.weight\", \".weight\")\n .replace(\".base_layer.bias\", \".bias\")\n )\n state_dict[key] = state_dict.pop(name)\n\n return lora_path\n\n def save_hf_model_and_tokenizer(self, state_dict: dict[str, torch.Tensor]):\n auto_model_class = self.get_transformers_auto_model_class()\n with init_empty_weights():\n model = auto_model_class.from_config(\n self.model_config, torch_dtype=torch.bfloat16, trust_remote_code=self.config.trust_remote_code\n )\n model.to_empty(device=\"cpu\")\n model = self.patch_model_generation_config(model)\n\n lora_path = self.save_lora_adapter(state_dict)\n if lora_path:\n print(f\"Saving lora adapter to {lora_path}\")\n\n print(f\"Saving model to {self.config.target_dir}\")\n model.save_pretrained(self.config.target_dir, state_dict=state_dict)\n del state_dict\n del model\n\n processor = hf_processor(self.hf_model_config_path, trust_remote_code=self.config.trust_remote_code)\n tokenizer = hf_tokenizer(self.hf_model_config_path, trust_remote_code=self.config.trust_remote_code)\n if processor is not None:\n print(f\"Saving processor to {self.config.target_dir}\")\n processor.save_pretrained(self.config.target_dir)\n if tokenizer is not None:\n print(f\"Saving tokenizer to {self.config.target_dir}\")\n tokenizer.save_pretrained(self.config.target_dir)\n\n def upload_to_huggingface(self):\n import requests\n from huggingface_hub import HfApi\n from huggingface_hub.utils import HfHubHTTPError, RepositoryNotFoundError\n\n api = HfApi()\n try:\n # Attempt to create repository\n api.create_repo(repo_id=self.config.hf_upload_path, private=self.config.private, exist_ok=True)\n except HfHubHTTPError as e:\n # Handle authentication/API errors\n if e.response.status_code == 401:\n raise PermissionError(\n \"Hugging Face authentication failed. Verify your token is valid and has write permissions.\"\n ) from e\n elif e.response.status_code == 404:\n raise RepositoryNotFoundError(f\"Repository path not found: {self.config.hf_upload_path}\") from e\n else:\n raise ConnectionError(f\"Failed to create repository ({e.response.status_code}): {e}\") from e\n except requests.exceptions.ConnectionError as e:\n raise ConnectionError(\"Network connection failed. Check your internet connection.\") from e\n\n try:\n # Attempt folder upload\n api.upload_folder(folder_path=self.config.target_dir, repo_id=self.config.hf_upload_path, repo_type=\"model\")\n except HfHubHTTPError as e:\n if e.response.status_code == 401:\n raise PermissionError(\"Authentication failed during upload. Token may have expired.\") from e\n else:\n raise RuntimeError(f\"Upload failed ({e.response.status_code}): {e}\") from e\n except requests.exceptions.ConnectionError as e:\n raise ConnectionError(\"Network interruption during upload. Try again with stable connection.\") from e\n except OSError as e:\n raise FileNotFoundError(f\"Local folder error: {self.config.target_dir} - {str(e)}\") from e\n except Exception as e:\n raise RuntimeError(f\"Unexpected error during upload: {str(e)}\") from e\n\n @abstractmethod\n def merge_and_save(self):\n raise NotImplementedError(\"Subclasses should implement this method\")\n\n @abstractmethod\n def cleanup(self):\n raise NotImplementedError(\"Subclasses should implement this method to clean up resources if needed\")\n"} +{"file_name": "verl__model_merger__fsdp_model_merger.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport json\nimport os\nfrom concurrent.futures import ThreadPoolExecutor\nfrom pathlib import Path\n\nimport numpy as np\nimport torch\nfrom torch.distributed._tensor import Placement, Shard\n\ntry:\n # for torch 2.5+\n from torch.distributed.tensor import DTensor\nexcept ImportError:\n from torch.distributed._tensor import DTensor\n\nfrom tqdm import tqdm\n\nfrom .base_model_merger import BaseModelMerger\n\n\nclass FSDPModelMerger(BaseModelMerger):\n \"\"\"\n Model merger for FSDP (Fully Sharded Data Parallel) checkpoints.\n\n This class handles the conversion of FSDP distributed checkpoints into HuggingFace format.\n FSDP shards model parameters across multiple processes, and this merger reconstructs\n the full model by loading and concatenating the sharded parameters from all ranks.\n\n The merger supports various FSDP configurations including:\n - Pure FSDP (single dimension sharding)\n - FSDP + DDP (data parallel + fully sharded data parallel)\n - DTensor-based sharding with custom device meshes\n\n Key features:\n - Automatic detection of world size from checkpoint filenames\n - Support for DTensor and non-DTensor checkpoints\n - Parallel loading of checkpoint shards for efficiency\n - Validation against reference HuggingFace models\n\n Example:\n To merge FSDP checkpoints:\n ```python\n config = ModelMergerConfig(\n operation=\"merge\",\n backend=\"fsdp\",\n local_dir=\"path/to/fsdp/checkpoints\",\n target_dir=\"path/to/output\"\n )\n merger = FSDPModelMerger(config)\n merger.merge_and_save()\n ```\n \"\"\"\n\n def _get_world_size(self) -> int:\n \"\"\"_summary_\n From FSDP json config file, extract the world size.\n\n Returns:\n int: world size\n \"\"\"\n config_path = Path(self.config.local_dir) / \"fsdp_config.json\"\n if not config_path.exists():\n raise FileNotFoundError(f\"Config file {config_path} does not exist.\")\n\n with open(config_path) as f:\n config = json.load(f)\n\n # Extract world size from the config\n world_size = config.get(\"world_size\", None)\n if world_size is None:\n raise ValueError(\"World size not found in the config file.\")\n\n return world_size\n\n def _load_rank_zero_state_dict(self, world_size: int) -> dict:\n return torch.load(\n Path(self.config.local_dir) / f\"model_world_size_{world_size}_rank_0.pt\",\n map_location=\"cpu\",\n weights_only=False,\n )\n\n def _extract_device_mesh_info(self, state_dict: dict, world_size: int) -> tuple[np.ndarray, tuple[str, ...]]:\n \"\"\"\n Retrieves sharding information (device_mesh, mesh_dim_names) from a DTensor in the state_dict.\n If no DTensor is found, infers a simple FSDP mesh based on world_size.\n \"\"\"\n pivot_key = sorted(list(state_dict.keys()))[0]\n weight = state_dict[pivot_key]\n\n if isinstance(weight, DTensor):\n # get sharding info\n device_mesh = weight.device_mesh\n mesh = device_mesh.mesh\n mesh_dim_names = device_mesh.mesh_dim_names\n else:\n # for non-DTensor\n mesh = np.array([world_size], dtype=np.int64)\n mesh_dim_names = (\"fsdp\",)\n\n return mesh, mesh_dim_names\n\n def _calculate_shard_configuration(\n self, mesh: np.ndarray, mesh_dim_names: tuple[str, ...]\n ) -> tuple[int, tuple[int, ...]]:\n \"\"\"Calculates the total number of shards and the shape of the device mesh.\"\"\"\n assert mesh_dim_names in ((\"fsdp\",), (\"ddp\", \"fsdp\")), f\"Unsupported mesh_dim_names {mesh_dim_names}\"\n\n if \"tp\" in mesh_dim_names:\n # TODO: \"tp\" is not supported yet due to the above assert\n total_shards = mesh.shape[-1] * mesh.shape[-2]\n mesh_shape = (mesh.shape[-2], mesh.shape[-1])\n else:\n total_shards = mesh.shape[-1]\n mesh_shape = (mesh.shape[-1],)\n\n return total_shards, mesh_shape\n\n def _merge_by_placement(self, tensors: list[torch.Tensor], placement: Placement) -> torch.Tensor:\n \"\"\"Merges a list of tensors based on their DTensor placement\"\"\"\n if placement.is_replicate():\n return tensors[0]\n elif placement.is_partial():\n raise NotImplementedError(\"Partial placement is not supported yet\")\n elif placement.is_shard():\n return torch.cat(tensors, dim=placement.dim).contiguous()\n\n raise NotImplementedError(f\"Unsupported placement: {placement}\")\n\n def _load_and_merge_state_dicts(\n self, world_size: int, total_shards: int, mesh_shape: tuple[int, ...], mesh_dim_names: tuple[str, ...]\n ) -> dict[str, torch.Tensor]:\n model_state_dict_lst = [None] * total_shards\n\n def process_one_shard(rank: int, model_state_dict_lst: list):\n model_path = Path(self.config.local_dir) / f\"model_world_size_{world_size}_rank_{rank}.pt\"\n state_dict = torch.load(model_path, map_location=\"cpu\", weights_only=False)\n model_state_dict_lst[rank] = state_dict\n return state_dict\n\n with ThreadPoolExecutor(max_workers=min(32, os.cpu_count())) as executor:\n futures = [executor.submit(process_one_shard, rank, model_state_dict_lst) for rank in range(total_shards)]\n for future in tqdm(futures, desc=f\"Loading {total_shards} FSDP shards\", total=total_shards):\n future.result()\n\n # Merge state dicts from all shards\n state_dict = {}\n param_placements: dict[str, list] = {}\n\n for key in set(model_state_dict_lst[0].keys()):\n state_dict[key] = []\n for model_state_shard in model_state_dict_lst:\n # add tensor shard in order of rank to state_dict[key]\n tensor = model_state_shard.pop(key)\n if isinstance(tensor, DTensor):\n state_dict[key].append(tensor._local_tensor.bfloat16())\n\n placements = tuple(tensor.placements)\n # replicated placement at dp dimension can be discarded\n if mesh_dim_names[0] in (\"dp\", \"ddp\"):\n placements = placements[1:]\n\n if key not in param_placements:\n param_placements[key] = placements\n else:\n assert param_placements[key] == placements\n else:\n state_dict[key].append(tensor.bfloat16())\n\n del model_state_dict_lst\n\n # Merge tensors\n for key in sorted(state_dict):\n if not isinstance(state_dict[key], list):\n print(f\"No need to merge key {key}\")\n continue\n if key in param_placements:\n # merge shards\n placements: tuple[Shard] = param_placements[key]\n if len(mesh_shape) == 1:\n # 1-D list, FSDP without TP\n assert len(placements) == 1\n shards = state_dict[key]\n state_dict[key] = self._merge_by_placement(shards, placements[0])\n else:\n # 2-D list, FSDP + TP\n raise NotImplementedError(\"FSDP + TP is not supported yet\")\n else:\n state_dict[key] = torch.cat(state_dict[key], dim=0)\n\n return state_dict\n\n def merge_and_save(self):\n world_size = self._get_world_size()\n rank_zero_state_dict = self._load_rank_zero_state_dict(world_size)\n\n mesh, mesh_dim_names = self._extract_device_mesh_info(rank_zero_state_dict, world_size)\n print(f\"Got device mesh {mesh}, mesh_dim_names {mesh_dim_names}\")\n\n total_shards, mesh_shape = self._calculate_shard_configuration(mesh, mesh_dim_names)\n print(f\"Processing model shards with {total_shards} {mesh_shape} in total\")\n\n merged_state_dict = self._load_and_merge_state_dicts(world_size, total_shards, mesh_shape, mesh_dim_names)\n\n if self.config.operation == \"test\":\n if not self.config.test_hf_dir:\n raise ValueError(\"test_hf_dir must be provided for test operation\")\n self._validate_state_dict(merged_state_dict)\n elif self.config.operation == \"merge\":\n self.save_hf_model_and_tokenizer(merged_state_dict)\n if self.config.hf_upload:\n self.upload_to_huggingface()\n else:\n raise ValueError(f\"Unknown operation: {self.config.operation}\")\n\n def _validate_state_dict(self, state_dict: dict[str, torch.Tensor]):\n auto_model_class = self.get_transformers_auto_model_class()\n\n hf_model = auto_model_class.from_pretrained(self.config.test_hf_dir, torch_dtype=torch.bfloat16)\n hf_state_dict = hf_model.state_dict()\n del hf_model\n\n hf_model_keys = set(hf_state_dict.keys())\n collected_keys = set(state_dict.keys())\n\n missing_keys = hf_model_keys - collected_keys\n assert len(missing_keys) == 0, f\"Missing keys in collected state dict: {list(sorted(missing_keys))}\"\n\n extra_keys = collected_keys - hf_model_keys\n assert len(extra_keys) == 0, f\"Extra keys in collected state dict: {list(sorted(extra_keys))}\"\n\n for key in hf_model_keys:\n hf_shape = hf_state_dict[key].shape\n collected_shape = state_dict[key].shape\n assert hf_shape == collected_shape, (\n f\"Shape mismatch for key '{key}': original {hf_shape} vs collected {collected_shape}\"\n )\n\n hf_dtype = hf_state_dict[key].dtype\n collected_dtype = state_dict[key].dtype\n assert hf_dtype == collected_dtype, (\n f\"Dtype mismatch for key '{key}': original {hf_dtype} vs collected {collected_dtype}\"\n )\n\n torch.testing.assert_close(hf_state_dict[key], state_dict[key], atol=1e-6, rtol=1e-6)\n\n print(\"FSDP checks passed: The merged state_dict matches the hf model saved by FSDPCheckpointManager.\")\n\n def cleanup(self):\n \"\"\"Cleanup temporary files if needed.\"\"\"\n # FSDP merger does not create temporary files, so no cleanup is needed.\n pass\n"} +{"file_name": "verl__model_merger__megatron_model_merger.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport json\nimport os\nimport warnings\nfrom contextlib import contextmanager\nfrom pathlib import Path\nfrom typing import Any, Callable, ContextManager\n\nimport numpy as np\nimport torch\nimport torch.distributed as dist\n\ntry:\n # NPU patch\n import mindspeed.megatron_adaptor # noqa: F401\nexcept ImportError:\n pass\n\nfrom accelerate import init_empty_weights\nfrom megatron.core import mpu\nfrom megatron.core.models.gpt.gpt_model import ModelType\nfrom megatron.core.tensor_parallel.random import model_parallel_cuda_manual_seed\nfrom safetensors.torch import load_file\nfrom transformers import (\n AutoConfig,\n PretrainedConfig,\n)\n\nfrom verl.models.mcore import hf_to_mcore_config\nfrom verl.utils.device import get_device_name, get_nccl_backend, get_torch_device\nfrom verl.utils.distributed import set_numa_affinity\nfrom verl.utils.megatron.dist_checkpointing import load_dist_checkpointing\nfrom verl.utils.megatron_utils import get_model\nfrom verl.utils.tokenizer import hf_processor, hf_tokenizer\n\nfrom .base_model_merger import BaseModelMerger, ModelMergerConfig\n\n\n@contextmanager\ndef noop_context() -> Any:\n yield\n\n\ndef get_dynamic_pipeline_shards(layer_num: int, pp_size: int) -> list[int]:\n \"\"\"Calculate the pipeline sharding configuration for Megatron-LM.\n\n Args:\n layer_num: Total number of layers in the model.\n pp_size: Number of pipeline parallel ranks.\n\n Returns:\n layer number of each pp rank. Make the sharding of the pipeline as uniform as possible.\n \"\"\"\n if layer_num < pp_size:\n raise ValueError(f\"layer_num {layer_num} must be greater than pp_size {pp_size}.\")\n\n if pp_size < 1:\n raise ValueError(f\"pp_size must be at least 1, got {pp_size}.\")\n if pp_size == 1:\n return [layer_num]\n\n if pp_size == 2:\n return [\n layer_num // 2,\n layer_num - layer_num // 2,\n ]\n\n middle_size = pp_size - 2\n shards_strategy = []\n for middle_layer_num in range(layer_num):\n first_last_layer_num = layer_num - middle_layer_num * middle_size\n first_layer_num = first_last_layer_num // 2\n last_layer_num = first_last_layer_num - first_last_layer_num // 2\n if 0 < first_layer_num <= middle_layer_num and 0 < last_layer_num <= middle_layer_num:\n shards_strategy.append(\n (\n [first_layer_num] + [middle_layer_num] * middle_size + [last_layer_num],\n abs(first_layer_num - middle_layer_num),\n )\n )\n\n # sort by diff of layer_num, to make it as uniform as possible\n res = sorted(shards_strategy, key=lambda x: x[1])[0][0]\n assert sum(res) == layer_num, f\"sum(res)={sum(res)} != layer_num={layer_num}, pp_size={pp_size}\"\n return res\n\n\nclass MegatronModelMerger(BaseModelMerger):\n \"\"\"\n Model merger for Megatron-LM distributed checkpoints.\n\n This class handles the conversion of Megatron-LM distributed checkpoints into HuggingFace format.\n Megatron-LM uses tensor parallelism, pipeline parallelism, and data parallelism to distribute\n large language models across multiple GPUs. This merger reconstructs the full model by\n loading distributed checkpoints and applying the necessary transformations.\n\n Key features:\n - Support for tensor parallel, pipeline parallel, and data parallel configurations\n - Automatic parameter name mapping from Megatron to HuggingFace conventions\n - Handling of QKV and gate-up tensor splitting/merging\n - Support for tied word embeddings and value models\n - Integration with Megatron's distributed checkpointing system\n\n The merger handles various model architectures and configurations:\n - Standard transformer models (GPT-style)\n - Models with tied word embeddings\n - Value models for reinforcement learning\n - Multi-layer attention (MLA) architectures\n - Mixture of Experts (MoE) models\n\n Args:\n config (ModelMergerConfig): Configuration object with Megatron-specific settings\n including tie_word_embedding and is_value_model flags.\n\n Example:\n To merge Megatron checkpoints:\n ```python\n config = ModelMergerConfig(\n operation=\"merge\",\n backend=\"megatron\",\n local_dir=\"path/to/megatron/checkpoints\",\n target_dir=\"path/to/output\",\n tie_word_embedding=True\n )\n merger = MegatronModelMerger(config)\n merger.merge_and_save()\n ```\n \"\"\"\n\n def __init__(self, config: ModelMergerConfig):\n super().__init__(config)\n # Currently we use only 1 rank to merge the dist_ckpt, we will move to multi-process save shortly afterwards\n if \"WORLD_SIZE\" not in os.environ:\n os.environ[\"RANK\"] = \"0\"\n os.environ[\"LOCAL_RANK\"] = \"0\"\n os.environ[\"WORLD_SIZE\"] = \"1\"\n os.environ[\"MASTER_ADDR\"] = \"localhost\"\n os.environ[\"MASTER_PORT\"] = \"12355\"\n\n set_numa_affinity()\n torch.distributed.init_process_group(get_nccl_backend())\n\n self.rank = torch.distributed.get_rank()\n self.world_size = torch.distributed.get_world_size()\n local_rank = os.environ.get(\"LOCAL_RANK\", 0)\n get_torch_device().set_device(f\"{get_device_name()}:{local_rank}\")\n\n mpu.initialize_model_parallel(\n tensor_model_parallel_size=1,\n pipeline_model_parallel_size=self.world_size,\n virtual_pipeline_model_parallel_size=None,\n context_parallel_size=1,\n expert_model_parallel_size=1,\n )\n model_parallel_cuda_manual_seed(0)\n self.hf_config = AutoConfig.from_pretrained(\n self.config.hf_model_config_path, trust_remote_code=self.config.trust_remote_code\n )\n print(self.hf_config, flush=True)\n\n self.params_mapping = {\n # megatron core gpt model name, huggingface model name\n # NOTICE: It's a little bit tricky, when 2 keys have the same prefix, we need to make sure the\n # longer key within the containing relationship is processed first.\n \"embedding.word_embeddings\": \"model.embed_tokens\",\n # input layer norm for dpskv3\n \"input_layernorm.weight\": \"input_layernorm.weight\",\n \"input_layernorm.bias\": \"input_layernorm.bias\",\n # attn\n \"self_attention.linear_qkv.layer_norm_weight\": \"input_layernorm.weight\",\n \"self_attention.linear_qkv.layer_norm_bias\": \"input_layernorm.bias\",\n \"self_attention.linear_qkv\": \"self_attn.qkv_proj\",\n \"self_attention.q_layernorm\": \"self_attn.q_norm\",\n \"self_attention.k_layernorm\": \"self_attn.k_norm\",\n \"self_attention.linear_proj\": \"self_attn.o_proj\",\n # mla\n \"self_attention.linear_q_proj\": \"self_attn.q_proj\",\n \"self_attention.linear_q_down_proj\": \"self_attn.q_a_proj\",\n \"self_attention.linear_q_up_proj.layer_norm_weight\": \"self_attn.q_a_layernorm.weight\",\n \"self_attention.linear_q_up_proj\": \"self_attn.q_b_proj\",\n \"self_attention.linear_kv_down_proj\": \"self_attn.kv_a_proj_with_mqa\",\n \"self_attention.linear_kv_up_proj.layer_norm_weight\": \"self_attn.kv_a_layernorm.weight\",\n \"self_attention.linear_kv_up_proj\": \"self_attn.kv_b_proj\",\n # mlp\n \"pre_mlp_layernorm\": \"post_attention_layernorm\",\n \"mlp.linear_fc1.layer_norm_weight\": \"post_attention_layernorm.weight\",\n \"mlp.linear_fc1.layer_norm_bias\": \"post_attention_layernorm.bias\",\n \"mlp.linear_fc1\": \"mlp.gate_up_proj\",\n \"mlp.linear_fc2\": \"mlp.down_proj\",\n # moe\n \"mlp.router.expert_bias\": \"mlp.gate.e_score_correction_bias\",\n \"mlp.router\": \"mlp.gate\",\n \"mlp.shared_experts.linear_fc1\": \"mlp.shared_experts.gate_up_proj\",\n \"mlp.shared_experts.linear_fc2\": \"mlp.shared_experts.down_proj\",\n \"linear_fc1\": \"gate_up_proj\",\n \"linear_fc2\": \"down_proj\",\n # output\n \"final_layernorm\": \"norm\",\n \"output_layer\": \"lm_head\",\n }\n\n if \"Qwen2MoeForCausalLM\" in self.hf_config.architectures:\n self.params_mapping[\"mlp.shared_experts.linear_fc1\"] = \"mlp.shared_expert.gate_up_proj\"\n self.params_mapping[\"mlp.shared_experts.linear_fc2\"] = \"mlp.shared_expert.down_proj\"\n self.params_mapping[\"mlp.shared_experts.gate_weight\"] = \"mlp.shared_expert_gate.weight\"\n\n def _load_state_dicts(self, model_ckpt_path: str) -> dict[str, Any]:\n \"\"\"_summary_\n Use Megatron dist_checkpointing to load the model state dicts from the checkpoint directory.\n\n Args:\n model_ckpt_path (str): Path to the model checkpoint directory.\n\n Returns:\n State dict containing the model parameters.\n \"\"\"\n\n # init hf config\n self.pipeline_shards = get_dynamic_pipeline_shards(self.hf_config.num_hidden_layers, self.world_size)\n print(f\"Pipeline shards: {self.pipeline_shards}, total layers: {sum(self.pipeline_shards)}\")\n\n tf_config = hf_to_mcore_config(\n self.hf_config,\n torch.bfloat16,\n num_layers_in_first_pipeline_stage=self.pipeline_shards[0] if len(self.pipeline_shards) > 1 else None,\n num_layers_in_last_pipeline_stage=self.pipeline_shards[-1] if len(self.pipeline_shards) > 2 else None,\n )\n tf_config.use_cpu_initialization = self.config.use_cpu_initialization\n tie_word_embeddings = getattr(self.hf_config, \"tie_word_embeddings\", False)\n\n # init megatron model\n def megatron_model_provider(pre_process, post_process):\n from verl.models.mcore import init_mcore_model\n\n parallel_model = init_mcore_model(\n tf_config,\n self.hf_config,\n pre_process,\n post_process,\n share_embeddings_and_output_weights=tie_word_embeddings,\n value=False,\n )\n return parallel_model\n\n context: Callable[..., ContextManager] = (\n init_empty_weights if self.config.use_cpu_initialization else noop_context\n )\n with context():\n whole_model = get_model(\n model_provider_func=megatron_model_provider,\n model_type=ModelType.encoder_or_decoder,\n wrap_with_ddp=False,\n transformer_config=tf_config,\n )\n\n if self.config.use_cpu_initialization:\n # convert meta device to empty tensor so it can use `copy_` function\n whole_model[0].module = whole_model[0].module.to_empty(device=\"cpu\")\n\n # load state dicts\n sharded_state_dict = {}\n for vpp_rank, model in enumerate(whole_model):\n key = f\"model{vpp_rank}\" if len(whole_model) > 1 else \"model\"\n mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)\n sharded_state_dict[key] = model.sharded_state_dict()\n model_state_dict = load_dist_checkpointing(sharded_state_dict, model_ckpt_path)\n model_state_dict_list = []\n for vpp_rank, model in enumerate(whole_model):\n key = f\"model{vpp_rank}\" if len(whole_model) > 1 else \"model\"\n mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)\n model_state_dict_list.append(model_state_dict[key])\n\n return model_state_dict_list\n\n def _check_megatron_state_key(self, key: str) -> bool:\n \"\"\"\n Checks if the key is a valid Megatron state key.\n\n Now the model merger only supports keys that start with \"decoder/embedding/output_layer\" in TransformerLayer.\n Shall not use key starts with \"model.\"\n \"\"\"\n if key.startswith(\"model.\"):\n raise ValueError(\n f\"Invalid key {key} in Megatron state_dict. Expected keys to start with \"\n f\"'decoder/embedding/output_layer' in TransformerLayer.\"\n )\n\n skip_checking_keys = [\"embedding.word_embeddings\", \"output_layer\"]\n for skip_key in skip_checking_keys:\n if skip_key in key:\n print(f\"skip checking key {key}\")\n return\n\n # Exclude extra state keys\n if not key.startswith(\"decoder\"):\n raise ValueError(\n f\"Invalid key {key} in Megatron state_dict. Expected keys to start with 'decoder' in TransformerLayer.\"\n )\n\n def _split_tensors(\n self, key: str, tensor: torch.Tensor, config: PretrainedConfig, is_value_model: bool = False\n ) -> list[torch.Tensor]:\n \"\"\"\n Splits a tensor into multiple tensors based on the name.\n This is used to handle qkv and gate_up tensors.\n \"\"\"\n if \"linear_fc1.weight\" in key:\n # if the tensor is gate and proj\n gate_lst = []\n up_lst = []\n gate, up = tensor.chunk(2)\n gate_lst.append(gate)\n up_lst.append(up)\n gate = torch.cat(gate_lst, dim=0)\n up = torch.cat(up_lst, dim=0)\n return [gate, up]\n elif \"self_attention.linear_qkv.\" in key and \"layer_norm\" not in key:\n # if the tensor is qkv, for each param on tp, split into q, k, v\n # concat q, k, v separately.\n q_lst, k_lst, v_lst = [], [], []\n assert config.num_attention_heads % config.num_key_value_heads == 0\n num_q_per_kv = config.num_attention_heads // config.num_key_value_heads\n assert tensor.shape[0] % (num_q_per_kv + 2) == 0, (\n f\"Tensor shape {tensor.shape} is not divisible by {num_q_per_kv + 2}\"\n )\n kv_size = tensor.shape[0] // (num_q_per_kv + 2)\n split_size = [kv_size * num_q_per_kv, kv_size, kv_size]\n\n num_query_groups_per_partition = config.num_key_value_heads\n for chunk in tensor.chunk(num_query_groups_per_partition):\n split_size = [\n kv_size * num_q_per_kv // num_query_groups_per_partition,\n kv_size // num_query_groups_per_partition,\n kv_size // num_query_groups_per_partition,\n ]\n q, k, v = chunk.split(split_size)\n q_lst.append(q)\n k_lst.append(k)\n v_lst.append(v)\n\n return [torch.cat(q_lst, dim=0), torch.cat(k_lst, dim=0), torch.cat(v_lst, dim=0)]\n else:\n return [tensor]\n\n def _merge_state_dicts(self, model_state_dict_list: list[dict[str, Any]]) -> dict[str, torch.Tensor]:\n state_dict = {}\n layers_cum = 0\n if self.world_size > 1:\n pipeline_cumsum = np.cumsum(self.pipeline_shards)\n layers_cum = 0 if self.rank == 0 else pipeline_cumsum[self.rank - 1]\n\n print(f\"{layers_cum=}\")\n for model_state_dict in model_state_dict_list:\n layers_handled = 0\n keys = model_state_dict.keys()\n for key in keys:\n if \"extra_state\" in key:\n continue\n if self.config.tie_word_embedding and (\"output_layer\" in key):\n print(\"skip lm_head and reward_head loading because of tie_word_embeddings\")\n continue\n\n self._check_megatron_state_key(key)\n hf_name = self._replace_name(key, self.params_mapping)\n assert hf_name is not None, f\"Failed to convert layer name [{key}] from megatron to huggingface.\"\n if \"model.layers.\" in hf_name:\n local_layer_no = int(hf_name.split(\".\")[2])\n layers_handled = max(local_layer_no, layers_handled)\n global_layer_no = local_layer_no + layers_cum\n new_key_list = hf_name.split(\".\")\n new_key_list[2] = str(global_layer_no)\n hf_name = \".\".join(new_key_list)\n else:\n warnings.warn(f\"hf_name {hf_name} will not be fixed with layer number\", stacklevel=2)\n\n if \"mlp.experts.\" in hf_name and \".weight\" in hf_name:\n name_prefix, expert_id = hf_name.split(\".weight\")\n for proj in [\"gate_up\", \"down\"]:\n if f\"{proj}_proj\" in hf_name:\n hf_name = hf_name.replace(\n f\"mlp.experts.{proj}_proj.weight{expert_id}\",\n f\"mlp.experts.{expert_id}.{proj}_proj.weight\",\n )\n\n tensor = model_state_dict[key]\n split_tensor = self._split_tensors(\n key, tensor, self.hf_config, is_value_model=self.config.is_value_model\n )\n\n if len(split_tensor) == 1:\n state_dict[hf_name] = split_tensor[0]\n elif len(split_tensor) == 3:\n # split qkv\n for n, d in zip([\"q\", \"k\", \"v\"], split_tensor, strict=True):\n state_dict[hf_name.replace(\"qkv\", n)] = d\n elif len(split_tensor) == 2:\n # split gate up\n state_dict[hf_name.replace(\"gate_up\", \"gate\")] = split_tensor[0]\n state_dict[hf_name.replace(\"gate_up\", \"up\")] = split_tensor[1]\n shape_info = (\n split_tensor.shape if isinstance(split_tensor, torch.Tensor) else [t.shape for t in split_tensor]\n )\n print(f\"converted {key} to {hf_name} with shape {shape_info}\")\n\n layers_cum += layers_handled + 1 # zero based\n\n return state_dict\n\n def save_hf_model_and_tokenizer(self, merged_state_dict):\n if self.world_size == 1:\n return super().save_hf_model_and_tokenizer(merged_state_dict)\n\n from safetensors.torch import save_file\n\n layer_num = self.hf_config.num_hidden_layers\n\n # FIXME: make configurable\n saves_per_layer = 1 if layer_num < 30 else 2\n saves_total = saves_per_layer * layer_num\n saves_indexes = {}\n\n # calculate the layer start index and key chunks\n layer_this_rank = self.pipeline_shards[self.rank]\n pipeline_cumsum = np.cumsum(self.pipeline_shards)\n layer_start = 0 if self.rank == 0 else pipeline_cumsum[self.rank - 1]\n keys = list(merged_state_dict.keys())\n keys_chunk = np.array_split(np.array(keys), layer_this_rank * saves_per_layer)\n numel = 0\n\n assert len(keys_chunk) == layer_this_rank * saves_per_layer, (\n f\"Expected {len(keys_chunk)} chunks, but got {layer_this_rank * saves_per_layer} for rank {self.rank}.\"\n )\n\n # save to model shards manually\n target_dir = Path(self.config.target_dir)\n for i, keys in enumerate(keys_chunk):\n sd_to_save = {k: merged_state_dict[k] for k in keys}\n numel += sum([sd_to_save[i].numel() for i in sd_to_save])\n save_idx = layer_start * saves_per_layer + i\n save_path = target_dir / f\"model-{save_idx + 1:05d}-of-{saves_total:05d}.safetensors\"\n\n save_file(sd_to_save, save_path)\n for k in keys:\n saves_indexes[k] = str(save_path.name)\n\n tensor = torch.tensor([numel]).to(get_device_name())\n dist.all_reduce(tensor, op=dist.ReduceOp.SUM)\n numel = tensor.cpu().item()\n\n all_save_indexes = [{} for _ in range(self.world_size)]\n dist.all_gather_object(all_save_indexes, saves_indexes)\n saves_indexes = {k: v for i in all_save_indexes for k, v in i.items()}\n if self.rank == 0:\n with open(target_dir / \"model.safetensors.index.json\", \"w\") as f:\n json.dump(\n {\n \"metadata\": {\n \"total_size\": numel,\n },\n \"weight_map\": saves_indexes,\n },\n f,\n indent=4,\n )\n print(f\"model saved to {target_dir} with {numel=}\")\n\n self.model_config.save_pretrained(self.config.target_dir)\n\n processor = hf_processor(self.hf_model_config_path, trust_remote_code=self.config.trust_remote_code)\n tokenizer = hf_tokenizer(self.hf_model_config_path, trust_remote_code=self.config.trust_remote_code)\n if processor is not None:\n print(f\"Saving processor to {self.config.target_dir}\")\n processor.save_pretrained(self.config.target_dir)\n if tokenizer is not None:\n print(f\"Saving tokenizer to {self.config.target_dir}\")\n tokenizer.save_pretrained(self.config.target_dir)\n\n def merge_and_save(self):\n from verl.utils.megatron_utils import get_dist_checkpoint_path\n\n model_ckpt_path = get_dist_checkpoint_path(self.config.local_dir)\n\n model_state_dict = self._load_state_dicts(model_ckpt_path)\n merged_state_dict = self._merge_state_dicts(model_state_dict)\n del model_state_dict\n\n if self.config.operation == \"test\":\n if not self.config.test_hf_dir:\n raise ValueError(\"test_hf_dir must be provided for test operation\")\n self._validate_state_dict(merged_state_dict)\n elif self.config.operation == \"merge\":\n self.save_hf_model_and_tokenizer(merged_state_dict)\n if self.config.hf_upload:\n self.upload_to_huggingface()\n else:\n raise ValueError(f\"Unknown operation: {self.config.operation}\")\n\n def _validate_state_dict(self, state_dict: dict[str, torch.Tensor]):\n \"\"\"\n Compares the merged Megatron state_dict against a reference safetensors model.\n Applies necessary name mappings from Megatron to Hugging Face conventions using _replace_name.\n \"\"\"\n ref_state_dict = load_file(Path(self.config.test_hf_dir) / \"model.safetensors\")\n\n for name, loaded_weight in state_dict.items():\n # name = self._replace_name(original_name, self.params_mapping)\n if not name or name.endswith(\".bias\") and name not in ref_state_dict:\n continue\n if \"rotary_emb.inv_freq\" in name:\n continue\n if \"lm_head.weight\" in name:\n if self.config.is_value_model or self.config.tie_word_embedding:\n continue\n if name not in ref_state_dict:\n raise RuntimeError(f\"key: {name} not exist in state_dict\")\n param = ref_state_dict[name]\n assert loaded_weight.dtype == param.dtype\n torch.testing.assert_close(loaded_weight.to(\"cpu\"), param, atol=1e-2, rtol=5e-2)\n\n def _replace_name(self, megatron_name: str, name_mapping: dict[str, str]) -> str:\n for m_name, v_name in name_mapping.items():\n if m_name not in megatron_name:\n continue\n\n megatron_name = megatron_name.replace(\"decoder\", \"model\")\n param_name = megatron_name.replace(m_name, v_name)\n\n return param_name\n\n return None # Return None if no mapping found\n\n def cleanup(self):\n torch.distributed.destroy_process_group()\n"} +{"file_name": "verl__models__llama__megatron__checkpoint_utils__llama_loader.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\n\nfrom verl.utils.device import get_device_id, get_torch_device\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n print(f\"get megatron data parallel size: {mpu.get_data_parallel_world_size()}\")\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef load_state_dict_to_megatron_llama(\n state_dict, wrapped_models, config, params_dtype, is_value_model=False, tie_word_embeddings=False\n):\n \"\"\"Load merged state_dict to sharded Megatron module in training.\"\"\"\n from megatron.core import DistributedDataParallel as LocalDDP\n from megatron.core import mpu\n from megatron.core.transformer.module import Float16Module\n from torch.nn.parallel import DistributedDataParallel as torchDDP\n\n from verl.utils.logger import print_rank_0\n from verl.utils.megatron_utils import unwrap_model\n\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n def fetch_params(module):\n for param in module.parameters():\n torch.distributed.fetch(\n param.data, src=mpu.get_data_parallel_src_rank(), group=mpu.get_data_parallel_group()\n )\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if torch.distributed.get_rank() == 0:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers, (\n f\"num_layers_per_model: {num_layers_per_model} * pp_size: {pp_size} * virtual_pp_size \"\n f\"{virtual_pp_size} != config.num_hidden_layers: {config.num_hidden_layers}\"\n )\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n gpt_model_module = _get_gpt_model(models[i])\n assert len(gpt_model_module.model.layers) == num_layers_per_model\n\n def _fetch_tensor(tensor, name) -> torch.Tensor:\n \"\"\"fetch tensor\"\"\"\n nonlocal state_dict\n if tensor is not None:\n tensor.data.copy_(state_dict[name])\n\n def _fetch_tp_shard_tensor_vocab(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards\"\"\"\n nonlocal state_dict\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n if tensor is not None:\n tensor.data.copy_(tensor_chunk[tp_rank])\n else:\n print(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards\"\"\"\n nonlocal state_dict\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n if tensor is not None:\n tensor.data.copy_(tensor_chunk[tp_rank])\n else:\n print(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor_gate_up(tensor, gate_name, up_name) -> torch.Tensor:\n \"\"\"fetch gate_up tensor in tp shards\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if gate_name in state_dict and up_name in state_dict:\n gate_weight = state_dict[gate_name]\n up_weight = state_dict[up_name]\n new_gate_up_weight = torch.empty(\n config.intermediate_size * 2, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_tp = gate_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n up_weight_tp = up_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n new_gate_up_weight[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)].copy_(\n torch.cat([gate_weight_tp, up_weight_tp], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_gate_up_weight, tp_size, dim=0)\n if tensor is not None:\n tensor.data.copy_(tensor_chunk[tp_rank])\n else:\n print(f\"tp_shard tensor:[{gate_name}, {up_name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n assert q_name in state_dict and k_name in state_dict and v_name in state_dict\n full_weight_q = state_dict[q_name]\n full_weight_k = state_dict[k_name]\n full_weight_v = state_dict[v_name]\n\n hidden_size_per_head = config.hidden_size // config.num_attention_heads\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n k_part = full_weight_k[i * kv_size_tp : (i + 1) * kv_size_tp]\n v_part = full_weight_v[i * kv_size_tp : (i + 1) * kv_size_tp]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(torch.cat([q_part, k_part, v_part], dim=0))\n\n else:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n start_idx = i * config.num_key_value_heads // tp_size * hidden_size_per_head\n end_idx = (i * config.num_key_value_heads // tp_size + 1) * hidden_size_per_head\n k_part = full_weight_k[start_idx:end_idx]\n v_part = full_weight_v[start_idx:end_idx]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(torch.cat([q_part, k_part, v_part], dim=0))\n\n tensor_chunk = torch.chunk(new_weight_qkv, tp_size, dim=0)\n if tensor is not None:\n tensor.data.copy_(tensor_chunk[tp_rank])\n\n # Embeddings\n # -------------------\n print_rank_0(\"loading embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n embed_tokens_weight = None\n if pp_rank == 0:\n embed_tokens_weight = gpt_model_module.model.embed_tokens.weight\n _fetch_tp_shard_tensor_vocab(embed_tokens_weight, \"model.embed_tokens.weight\")\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n num_layer_per_pp = config.num_hidden_layers // pp_size\n vpp_size = mpu.get_virtual_pipeline_model_parallel_world_size()\n\n layer_list = []\n if vpp_size is not None:\n for vpp_rank in range(vpp_size):\n num_layer_vpp_chunk = num_layer_per_pp // vpp_size\n num_layer_this_model = num_layer_vpp_chunk\n offset = vpp_rank * (config.num_hidden_layers // mpu.get_virtual_pipeline_model_parallel_world_size()) + (\n mpu.get_pipeline_model_parallel_rank() * num_layer_vpp_chunk\n )\n layer_list.extend(list(range(offset, offset + num_layer_this_model)))\n else:\n num_layer_this_model = num_layer_per_pp\n offset = pp_rank * num_layer_per_pp\n layer_list.extend(list(range(offset, offset + num_layer_this_model)))\n\n for layer in layer_list:\n print_rank_0(f\"loading layer #{layer}...\")\n layer_name = f\"model.layers.{layer}\"\n dst_pp_rank, dst_virtual_pp_rank, dst_layer_idx = layer_map[layer]\n\n gpt_model_module = _get_gpt_model(models[dst_virtual_pp_rank])\n sync_layer = gpt_model_module.model.layers[dst_layer_idx]\n\n _fetch_tensor(\n sync_layer.input_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.input_layernorm.weight\",\n )\n\n _fetch_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n )\n\n _fetch_tp_shard_tensor(\n sync_layer.self_attn.o_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.o_proj.weight\",\n chunk_dim=1,\n )\n\n _fetch_tensor(\n sync_layer.post_attention_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.post_attention_layernorm.weight\",\n )\n\n _fetch_tp_shard_tensor_gate_up(\n sync_layer.mlp.gate_up_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n )\n\n _fetch_tp_shard_tensor(\n sync_layer.mlp.down_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.down_proj.weight\",\n chunk_dim=1,\n )\n # Final Layernorm\n # -------------------\n print_rank_0(\"loading final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _fetch_tensor(\n getattr(gpt_model_module.model.norm, \"weight\", None),\n \"model.norm.weight\",\n )\n\n print_rank_0(\"loading lm_head...\")\n if pp_rank + 1 == pp_size:\n lm_head_weight = gpt_model_module.lm_head.weight\n\n if is_value_model:\n if \"lm_head.weight\" in state_dict and state_dict[\"lm_head.weight\"].shape[0] == 1:\n _fetch_tensor(lm_head_weight, \"lm_head.weight\")\n print_rank_0(\"load lm_head weight\")\n elif \"reward_head.weight\" in state_dict and state_dict[\"reward_head.weight\"].shape[0] == 1:\n _fetch_tensor(lm_head_weight, \"reward_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n else:\n _fetch_tensor(None, \"lm_head.weight\")\n print_rank_0(\"fail to match lm_head in value_model\")\n else:\n _fetch_tp_shard_tensor(lm_head_weight, \"lm_head.weight\")\n\n dist.barrier()\n get_torch_device().empty_cache()\n print_rank_0(f\"loading megatron ckpt done, time elapsed {time.time() - start_time}s\")\n"} +{"file_name": "verl__models__llama__megatron__checkpoint_utils__llama_saver.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\nfrom megatron.core import mpu\nfrom megatron.core.distributed import DistributedDataParallel as LocalDDP\nfrom megatron.core.transformer.module import Float16Module\nfrom torch.nn.parallel import DistributedDataParallel as torchDDP\n\nfrom verl.utils.device import get_device_id, get_torch_device\nfrom verl.utils.logger import print_rank_0\nfrom verl.utils.megatron_utils import unwrap_model\n\n\ndef _megatron_calc_global_rank(tp_rank: int = 0, dp_rank: int = 0, pp_rank: int = 0):\n \"\"\"given TP,DP,PP rank to get the global rank.\"\"\"\n\n tp_size = mpu.get_tensor_model_parallel_world_size()\n dp_size = mpu.get_data_parallel_world_size()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n assert tp_size * dp_size * pp_size == torch.distributed.get_world_size(), (\n f\"{tp_size} x {dp_size} x {pp_size} != {torch.distributed.get_world_size()}\"\n )\n # We only support TP-DP-PP grouping, for correctness when resharding\n return (pp_rank * dp_size + dp_rank) * tp_size + tp_rank\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef merge_megatron_ckpt_llama(wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False):\n \"\"\"Merge sharded parameters of a Megatron module into a merged checkpoint.\n\n Args:\n wrapped_models (list of megatron.core.distributed.DistributedDataParallel):\n The local DDP wrapped megatron modules.\n config (str or None):\n HF config for model\n dtype: model params type\n is_value_model: if model is value model\n tie_word_embeddings: tie_word_embeddings, not used in llama, only to keep same interface with qwen2\n Returns:\n state_dict (dict):\n The merged state_dict in rank 0, and an empty dictionary in other ranks.\n \"\"\"\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if dist.get_rank() == 0:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n assert len(models[i].model.layers) == num_layers_per_model, (\n \"len model layers {} not equal to num_layers_per_model {}\".format(\n len(models[i].model.layers), num_layers_per_model\n )\n )\n\n state_dict = dict()\n\n def _get_cpu_tensor(tensor: torch.Tensor):\n if tensor is None:\n return None\n if tensor.device == torch.device(\"cpu\"):\n return tensor.detach().clone()\n return tensor.detach().cpu()\n\n def _broadcast_tensor(tensor, name, src_pp_rank) -> torch.Tensor:\n \"\"\"broadcast tensor across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank)\n\n if torch.distributed.get_rank() == src_rank:\n if tensor is None:\n weight = None\n tensor_shape = None\n else:\n weight = tensor\n tensor_shape = weight.shape\n else:\n weight = None\n tensor_shape = None\n\n obj_list = [tensor_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n tensor_shape = obj_list[0]\n\n if tensor_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tensor:[{name}] not exist, skip collect\")\n return\n\n if weight is None:\n weight = torch.empty(\n tensor_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n dist.broadcast(weight, src=src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n state_dict[name] = _get_cpu_tensor(weight)\n\n def _broadcast_tp_shard_tensor(tensor, name, src_pp_rank, concat_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=concat_dim)\n if mutate_func is not None:\n full_tensor = mutate_func(full_tensor)\n state_dict[name] = full_tensor\n\n def _broadcast_tp_shard_tensor_gate_up(tensor, gate_name, up_name, src_pp_rank) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{gate_name, up_name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=0)\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_list = []\n up_weight_list = []\n for i in range(tp_size):\n gate_up_weight_tp = full_tensor[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)]\n gate_weight_tp = gate_up_weight_tp[:intermediate_size_tp]\n up_weight_tp = gate_up_weight_tp[intermediate_size_tp:]\n gate_weight_list.append(gate_weight_tp)\n up_weight_list.append(up_weight_tp)\n\n state_dict[gate_name] = torch.cat(gate_weight_list, dim=0)\n state_dict[up_name] = torch.cat(up_weight_list, dim=0)\n\n def _broadcast_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name, src_pp_rank):\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{q_name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=0)\n q_weight_list = []\n k_weight_list = []\n v_weight_list = []\n hidden_size_per_head = config.hidden_size // config.num_attention_heads\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n for i in range(tp_size):\n qkv_part = full_tensor[i * total_size : (i + 1) * total_size]\n q_part = qkv_part[:q_size_tp]\n k_part = qkv_part[q_size_tp : q_size_tp + kv_size_tp]\n v_part = qkv_part[q_size_tp + kv_size_tp : total_size]\n q_weight_list.append(q_part)\n k_weight_list.append(k_part)\n v_weight_list.append(v_part)\n else:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n for i in range(tp_size):\n qkv_part = full_tensor[i * total_size : (i + 1) * total_size]\n q_part = qkv_part[:q_size_tp]\n k_part = qkv_part[q_size_tp : q_size_tp + kv_size_tp]\n v_part = qkv_part[q_size_tp + kv_size_tp : total_size]\n q_weight_list.append(q_part)\n if i * config.num_key_value_heads % tp_size == 0:\n k_weight_list.append(k_part)\n v_weight_list.append(v_part)\n\n state_dict[q_name] = torch.cat(q_weight_list, dim=0)\n state_dict[k_name] = torch.cat(k_weight_list, dim=0)\n state_dict[v_name] = torch.cat(v_weight_list, dim=0)\n\n # empty cache before collecting weights\n get_torch_device().empty_cache()\n # Embeddings\n # -------------------\n if dp_rank == 0:\n # Embeddings\n # -------------------\n print_rank_0(\"collecting embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n _broadcast_tp_shard_tensor(\n gpt_model_module.model.embed_tokens.weight if pp_rank == 0 else None,\n \"model.embed_tokens.weight\",\n src_pp_rank=0,\n )\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n for layer in range(config.num_hidden_layers):\n print_rank_0(f\"collecting layer #{layer}...\")\n layer_name = f\"model.layers.{layer}\"\n src_pp_rank, src_virtual_pp_rank, src_layer_idx = layer_map[layer]\n\n gpt_model_module = _get_gpt_model(models[src_virtual_pp_rank])\n sync_layer = gpt_model_module.model.layers[src_layer_idx]\n\n _broadcast_tensor(\n sync_layer.input_layernorm.weight,\n f\"{layer_name}.input_layernorm.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.weight,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.self_attn.o_proj.weight,\n f\"{layer_name}.self_attn.o_proj.weight\",\n concat_dim=1,\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tensor(\n sync_layer.post_attention_layernorm.weight,\n f\"{layer_name}.post_attention_layernorm.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor_gate_up(\n sync_layer.mlp.gate_up_proj.weight,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.mlp.down_proj.weight,\n f\"{layer_name}.mlp.down_proj.weight\",\n concat_dim=1,\n src_pp_rank=src_pp_rank,\n )\n\n # Final Layernorm\n # -------------------\n print_rank_0(\"collecting final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _broadcast_tensor(\n getattr(gpt_model_module.model.norm, \"weight\", None),\n \"model.norm.weight\",\n src_pp_rank=pp_size - 1,\n )\n\n print_rank_0(\"collecting lm_head...\")\n\n if is_value_model:\n if pp_rank == pp_size - 1:\n print(f\"gpt_model_module.lm_head.weight: {gpt_model_module.lm_head.weight.shape}\")\n _broadcast_tensor(\n gpt_model_module.lm_head.weight if pp_rank == pp_size - 1 else None,\n \"lm_head.weight\",\n src_pp_rank=pp_size - 1,\n )\n _broadcast_tensor(\n gpt_model_module.reward_head.weight\n if pp_rank == pp_size - 1 and getattr(gpt_model_module, \"reward_weight\", None) is not None\n else None,\n \"reward_head.weight\",\n src_pp_rank=pp_size - 1,\n )\n\n else:\n _broadcast_tp_shard_tensor(\n getattr(gpt_model_module.lm_head, \"weight\", None) if pp_rank == pp_size - 1 else None,\n \"lm_head.weight\",\n src_pp_rank=pp_size - 1,\n )\n\n dist.barrier()\n\n get_torch_device().empty_cache()\n if torch.distributed.get_rank() == 0:\n if dtype not in [torch.float16, torch.bfloat16, torch.float32]:\n print(f'Unknown/unsupported dtype to save: {dtype}\"')\n exit(1)\n for k, v in state_dict.items():\n if dtype != v.dtype:\n state_dict[k] = v.to(dtype)\n\n print_rank_0(f\"merge megatron ckpt done, time elapsed {time.time() - start_time}s\")\n return state_dict\n"} +{"file_name": "verl__models__llama__megatron__layers__parallel_decoder.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Optional\n\nimport torch\nfrom megatron.core import ModelParallelConfig\nfrom torch import nn\nfrom transformers import LlamaConfig\n\nfrom verl.utils.megatron_utils import TransformerConfig, convert_config\n\nfrom .parallel_attention import ParallelLlamaAttention, ParallelLlamaAttentionRmPad\nfrom .parallel_mlp import ParallelLlamaMLP\nfrom .parallel_rmsnorm import ParallelLlamaRMSNorm\n\n\nclass ParallelLlamaDecoderLayer(nn.Module):\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig, layer_idx: int):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.layer_idx = layer_idx\n self.hidden_size = config.hidden_size\n self.self_attn = ParallelLlamaAttention(config=config, megatron_config=megatron_config)\n\n self.mlp = ParallelLlamaMLP(config, megatron_config=megatron_config)\n self.input_layernorm = ParallelLlamaRMSNorm(config, megatron_config)\n self.post_attention_layernorm = ParallelLlamaRMSNorm(config, megatron_config)\n\n def forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple[torch.FloatTensor, Optional[tuple[torch.FloatTensor, torch.FloatTensor]]]:\n \"\"\"\n Args:\n hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)`\n attention_mask (`torch.FloatTensor`, *optional*): attention mask of size\n `(batch, 1, tgt_len, src_len)` where padding elements are indicated by very large negative values.\n output_attentions (`bool`, *optional*):\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under\n returned tensors for more detail.\n use_cache (`bool`, *optional*):\n If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding\n (see `past_key_values`).\n past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states\n \"\"\"\n\n residual = hidden_states\n\n hidden_states = self.input_layernorm(hidden_states)\n\n # Note: sequence parallel is hidden inside ColumnParallelLinear\n # reduce scatter is hidden inside RowParallelLinear\n\n # Self Attention\n hidden_states = self.self_attn(\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n position_ids=position_ids,\n )\n\n # TODO: add sequence parallel operator reduce_scatter here\n\n hidden_states = residual + hidden_states\n\n # Fully Connected\n residual = hidden_states\n hidden_states = self.post_attention_layernorm(hidden_states)\n\n # TODO: add sequence parallel operator all_gather here\n\n hidden_states = self.mlp(hidden_states)\n\n # TODO: add sequence parallel operator reduce_scatter here\n\n hidden_states = residual + hidden_states\n\n outputs = hidden_states\n\n return outputs\n\n\nclass ParallelLlamaDecoderLayerRmPad(nn.Module):\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig, layer_idx: int):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.layer_idx = layer_idx\n self.hidden_size = config.hidden_size\n self.self_attn = ParallelLlamaAttentionRmPad(config=config, megatron_config=megatron_config)\n\n self.mlp = ParallelLlamaMLP(config, megatron_config=megatron_config)\n self.input_layernorm = ParallelLlamaRMSNorm(config, megatron_config)\n self.post_attention_layernorm = ParallelLlamaRMSNorm(config, megatron_config)\n\n def forward(\n self,\n hidden_states: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: int = None,\n max_seqlen_in_batch: int = None,\n ) -> tuple[torch.FloatTensor, Optional[tuple[torch.FloatTensor, torch.FloatTensor]]]:\n residual = hidden_states # (total_nnz // sp, 1, hidden_size)\n\n hidden_states = self.input_layernorm(hidden_states)\n\n # Self Attention\n # (total_nnz // sp, 1, hidden_size) -> all-gather (total_nnz, 1, hidden_size)\n # -> col + row -> reduce-scatter -> (total_nnz // sp, 1, hidden_size)\n hidden_states = self.self_attn(\n hidden_states=hidden_states,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = residual + hidden_states\n\n # Fully Connected\n # shape changes same as attn\n residual = hidden_states\n hidden_states = self.post_attention_layernorm(hidden_states)\n hidden_states = self.mlp(hidden_states)\n hidden_states = residual + hidden_states\n\n outputs = hidden_states\n\n return outputs\n"} +{"file_name": "verl__models__llama__megatron__layers__parallel_linear.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2023 The vLLM team.\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# Adapted from https://github.com/vllm-project/vllm/blob/main/vllm/model_executor/layers/linear.py\n\nimport torch\nfrom megatron.core import tensor_parallel\n\n\nclass QKVParallelLinear(tensor_parallel.ColumnParallelLinear):\n def __init__(\n self,\n input_size,\n num_heads,\n num_key_value_heads,\n head_dim,\n *,\n bias=True,\n gather_output=True,\n skip_bias_add=False,\n **kwargs,\n ):\n # Keep input parameters, and already restrict the head numbers\n self.input_size = input_size\n self.q_output_size = num_heads * head_dim\n self.kv_output_size = num_key_value_heads * head_dim\n self.head_dim = head_dim\n self.gather_output = gather_output\n self.skip_bias_add = skip_bias_add\n\n input_size = self.input_size\n output_size = (num_heads + 2 * num_key_value_heads) * self.head_dim\n\n super().__init__(\n input_size=input_size,\n output_size=output_size,\n bias=bias,\n gather_output=gather_output,\n skip_bias_add=skip_bias_add,\n **kwargs,\n )\n\n\nclass MergedColumnParallelLinear(tensor_parallel.ColumnParallelLinear):\n def __init__(\n self,\n input_size,\n gate_ouput_size,\n up_output_size,\n *,\n bias=True,\n gather_output=True,\n skip_bias_add=False,\n **kwargs,\n ):\n # Keep input parameters, and already restrict the head numbers\n self.input_size = input_size\n self.output_size = gate_ouput_size + up_output_size\n self.gather_output = gather_output\n self.skip_bias_add = skip_bias_add\n\n super().__init__(\n input_size=self.input_size,\n output_size=self.output_size,\n bias=bias,\n gather_output=gather_output,\n skip_bias_add=skip_bias_add,\n **kwargs,\n )\n\n\nclass LinearForLastLayer(torch.nn.Linear):\n def __init__(\n self,\n input_size,\n output_size,\n *,\n config,\n bias=True,\n ):\n super().__init__(in_features=input_size, out_features=output_size, bias=bias)\n self.sequence_parallel = config.sequence_parallel\n if self.sequence_parallel:\n self.weight.sequence_parallel = True\n\n def forward(\n self,\n input_,\n weight=None,\n runtime_gather_output=None,\n ):\n logits = super().forward(input_)\n logits = logits.float()\n if self.sequence_parallel:\n logits = tensor_parallel.gather_from_sequence_parallel_region(logits, tensor_parallel_output_grad=False)\n return logits, None\n"} +{"file_name": "verl__models__llama__megatron__layers__parallel_mlp.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom megatron.core import ModelParallelConfig, tensor_parallel\nfrom megatron.core import parallel_state as mpu\nfrom torch import nn\nfrom transformers.activations import ACT2FN\n\nfrom verl.models.llama.megatron.layers.parallel_linear import MergedColumnParallelLinear\nfrom verl.utils.megatron import tensor_parallel as tp_utils\n\n\nclass ParallelLlamaMLP(nn.Module):\n def __init__(self, config, megatron_config: ModelParallelConfig = None) -> None:\n super().__init__()\n self.config = config\n self.hidden_size = config.hidden_size\n self.intermediate_size = config.intermediate_size\n # The weight is only [hidden_size, intermediate_size // model_parallel_world_size]\n\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n row_kwargs = tp_utils.get_default_kwargs_for_row_parallel_linear()\n\n if megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n assert row_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(row_kwargs, megatron_config)\n tp_utils.update_kwargs_with_config(column_kwargs, megatron_config)\n\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n self.gate_up_proj = MergedColumnParallelLinear(\n input_size=self.hidden_size,\n gate_ouput_size=self.intermediate_size,\n up_output_size=self.intermediate_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n self.gate_size = self.intermediate_size // tp_size\n\n self.down_proj = tensor_parallel.RowParallelLinear(\n input_size=self.intermediate_size,\n output_size=self.hidden_size,\n bias=False,\n input_is_parallel=True,\n skip_bias_add=False,\n **row_kwargs,\n )\n\n self.act_fn = ACT2FN[config.hidden_act]\n\n def forward(self, x):\n gate_up = self.gate_up_proj(x)[0]\n gate, up = gate_up.split(self.gate_size, dim=-1)\n return self.down_proj(self.act_fn(gate) * up)[0]\n"} +{"file_name": "verl__models__llama__megatron__layers__parallel_rmsnorm.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport numbers\n\nimport torch\nfrom megatron.core import ModelParallelConfig\nfrom torch import nn\nfrom transformers import LlamaConfig\n\nfrom verl.utils.megatron import sequence_parallel as sp_utils\n\n\nclass ParallelLlamaRMSNorm(nn.Module):\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig):\n \"\"\"\n LlamaRMSNorm is equivalent to T5LayerNorm\n \"\"\"\n super().__init__()\n if isinstance(config.hidden_size, numbers.Integral):\n normalized_shape = (config.hidden_size,)\n self.normalized_shape = torch.Size(normalized_shape)\n self.weight = nn.Parameter(torch.ones(self.normalized_shape))\n self.variance_epsilon = config.rms_norm_eps\n\n if megatron_config.sequence_parallel:\n sp_utils.mark_parameter_as_sequence_parallel(self.weight)\n\n def forward(self, hidden_states):\n from apex.normalization.fused_layer_norm import fused_rms_norm_affine\n\n return fused_rms_norm_affine(\n input=hidden_states,\n weight=self.weight,\n normalized_shape=self.normalized_shape,\n eps=self.variance_epsilon,\n memory_efficient=True,\n )\n"} +{"file_name": "verl__models__llama__megatron__modeling_llama_megatron.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"PyTorch LLaMA model with Megatron-style acceleration.\"\"\"\n\nfrom typing import Optional\n\nimport torch\nimport torch.utils.checkpoint\nfrom megatron.core import ModelParallelConfig, mpu, tensor_parallel\nfrom torch import nn\nfrom transformers.modeling_outputs import BaseModelOutputWithPast\nfrom transformers.models.llama.configuration_llama import LlamaConfig\nfrom transformers.models.llama.modeling_llama import CausalLMOutputWithPast\n\nfrom verl.utils.megatron import sequence_parallel as sp_utils\nfrom verl.utils.megatron import tensor_parallel as tp_utils\nfrom verl.utils.megatron_utils import TransformerConfig, convert_config\n\nfrom .layers import ParallelLlamaDecoderLayer, ParallelLlamaDecoderLayerRmPad, ParallelLlamaRMSNorm\n\n\"\"\"\nTODO: \n1. Add weight initialization. Here we need to be careful on TP weight init.\n2. Add sequence parallel\n3. Load checkpoint from meta LLama pretrained checkpoint\n\"\"\"\n\n\n# Copied from transformers.models.bart.modeling_bart._make_causal_mask\ndef _make_causal_mask(input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device):\n \"\"\"\n Make causal mask used for bi-directional self-attention.\n \"\"\"\n bsz, tgt_len = input_ids_shape\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\n mask_cond = torch.arange(mask.size(-1), device=device)\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\n mask = mask.to(dtype)\n return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len)\n\n\n# Copied from transformers.models.bart.modeling_bart._expand_mask\ndef _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):\n \"\"\"\n Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.\n \"\"\"\n bsz, src_len = mask.size()\n tgt_len = tgt_len if tgt_len is not None else src_len\n\n expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)\n\n inverted_mask = 1.0 - expanded_mask\n\n return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)\n\n\nclass ParallelLlamaModel(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]\n\n Args:\n config: LlamaConfig\n \"\"\"\n\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, self.megatron_config)\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n\n self.layers = nn.ModuleList(\n [ParallelLlamaDecoderLayer(config, megatron_config) for _ in range(config.num_hidden_layers)]\n )\n self.norm = ParallelLlamaRMSNorm(config, megatron_config)\n\n # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask\n def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds):\n # create causal mask\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n combined_attention_mask = None\n if input_shape[-1] > 1:\n combined_attention_mask = _make_causal_mask(\n input_shape,\n inputs_embeds.dtype,\n device=inputs_embeds.device,\n )\n\n if attention_mask is not None:\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(\n inputs_embeds.device\n )\n combined_attention_mask = (\n expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask\n )\n\n return combined_attention_mask\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (batch_size, seq_length)\n attention_mask: attention_mask. shape (batch_size, seq_length)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n batch_size, seq_length = input_ids.shape\n inputs_embeds = self.embed_tokens(input_ids)\n # embed positions\n\n attention_mask = self._prepare_decoder_attention_mask(attention_mask, (batch_size, seq_length), inputs_embeds)\n\n hidden_states = inputs_embeds\n\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n attention_mask=attention_mask,\n position_ids=position_ids,\n )\n\n hidden_states = layer_outputs\n\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelLlamaForCausalLM(nn.Module):\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.model = ParallelLlamaModel(config, megatron_config=megatron_config)\n self.vocab_size = config.vocab_size\n\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n\n # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\n outputs = self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n )\n\n hidden_states = outputs\n logits = self.lm_head(hidden_states)[0]\n\n logits = tensor_parallel.gather_from_tensor_model_parallel_region(logits)\n\n logits = logits.float()\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n\n\nfrom flash_attn.bert_padding import index_first_axis, pad_input, unpad_input # noqa: F401, E402\n\n\nclass ParallelLlamaModelRmPad(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]\n\n Args:\n config: LlamaConfig\n \"\"\"\n\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n self.megatron_config = megatron_config\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, self.megatron_config)\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n\n self.layers = nn.ModuleList(\n [ParallelLlamaDecoderLayerRmPad(config, megatron_config) for _ in range(config.num_hidden_layers)]\n )\n self.norm = ParallelLlamaRMSNorm(config, megatron_config)\n\n def forward(\n self,\n input_ids: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: int = None,\n max_seqlen_in_batch: int = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (1, totol_nnz)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n inputs_embeds = self.embed_tokens(input_ids) # (1, total_nnz) -> (1, total_nnz, hidden_size)\n\n # (1, total_nnz, hidden_size) -> (total_nnz, 1, hidden_size) -> (total_nnz // sp, 1, hidden_size)\n inputs_embeds = inputs_embeds.transpose(0, 1)\n if self.megatron_config.sequence_parallel:\n inputs_embeds = tensor_parallel.scatter_to_sequence_parallel_region(inputs_embeds)\n\n hidden_states = inputs_embeds\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = layer_outputs\n\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelLlamaForCausalLMRmPad(nn.Module):\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.megatron_config = megatron_config\n self.model = ParallelLlamaModelRmPad(config, megatron_config=megatron_config)\n self.vocab_size = config.vocab_size\n self._init_head(config)\n\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n def _forward_head(self, hidden_states):\n # all_gather from sequence parallel region is performed inside lm_head\n logits = self.lm_head(hidden_states)[0]\n logits = logits.float() # (total_nnz_padded, 1, vocab_size // tp)\n logits = tensor_parallel.gather_from_tensor_model_parallel_region(logits) # (total_nnz_padded, 1, vocab_size)\n return logits\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n batch_size, sequence_length = input_ids.shape\n\n # remove padding here\n input_ids, indices, cu_seqlens, max_seqlen_in_batch, *_ = unpad_input(\n input_ids.unsqueeze(dim=-1), attention_mask\n ) # (total_nnz, 1)\n\n # pad input_ids to multiple of tp for all tp ranks\n # TODO: for better performance, the sp padding should be removed at each layer. Not sure the performance gap\n if self.megatron_config.sequence_parallel:\n input_ids = sp_utils.pad_to_sequence_parallel(input_ids)\n\n input_ids = input_ids.transpose(0, 1) # (1, total_nnz+pad)\n\n outputs = self.model(\n input_ids=input_ids,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = outputs\n\n logits = self._forward_head(hidden_states)\n\n # remove padding from sequence parallel\n if self.megatron_config.sequence_parallel:\n totol_nnz = cu_seqlens[-1]\n logits = logits[:totol_nnz] # (total_nnz_padded)\n\n logits = torch.squeeze(logits, dim=1) # remove the artificial batch dimension\n # add removed padding back\n logits = pad_input(\n logits, indices, batch_size, seqlen=sequence_length\n ) # (batch_size, sequence_length, vocab_size)\n\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n\n\nclass ParallelLlamaForValueRmPad(ParallelLlamaForCausalLMRmPad):\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = nn.Linear(in_features=config.hidden_size, out_features=1, bias=False)\n # lm_head is effectively the same as sequence parallel\n sp_utils.mark_parameter_as_sequence_parallel(self.lm_head.weight)\n\n def _forward_head(self, hidden_states):\n logits = self.lm_head(hidden_states) # (total_nnz_padded // tp, 1, 1)\n logits = logits.float()\n if self.megatron_config.sequence_parallel:\n logits = tensor_parallel.gather_from_sequence_parallel_region(logits, tensor_parallel_output_grad=False)\n return logits\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n output = super().forward(input_ids, attention_mask, position_ids)\n output.logits = torch.squeeze(output.logits, dim=-1)\n return output\n\n\n\"\"\"\nSupport pipeline parallelism\n\"\"\"\n\n\nclass ParallelLlamaModelRmPadPP(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`LlamaDecoderLayer`]\n This model definition supports pipeline parallelism. To support pp and vpp,\n - This model only contains layer in this pp stage and vpp chunk\n - When calling get_model in Megatron, this rank will instantiate all the vpp chunks in this pp.\n Args:\n config: LlamaConfig\n \"\"\"\n\n def __init__(self, config: LlamaConfig, megatron_config: ModelParallelConfig, pre_process, post_process):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n self.pre_process = pre_process\n self.post_process = post_process\n self.megatron_config = megatron_config\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, self.megatron_config)\n if pre_process:\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n else:\n self.embed_tokens = None\n\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = megatron_config.pipeline_model_parallel_size\n self.num_layer_per_pp = config.num_hidden_layers // pp_size\n vpp_size = megatron_config.virtual_pipeline_model_parallel_size\n vpp_rank = mpu.get_virtual_pipeline_model_parallel_rank()\n\n if vpp_size is not None:\n self.layers = nn.ModuleList()\n self.num_layer_vpp_chunk = self.num_layer_per_pp // vpp_size\n self.num_layer_this_model = self.num_layer_vpp_chunk\n offset = vpp_rank * (config.num_hidden_layers // vpp_size) + (pp_rank * self.num_layer_vpp_chunk)\n else:\n self.num_layer_this_model = self.num_layer_per_pp\n offset = pp_rank * self.num_layer_per_pp\n\n self.layers = nn.ModuleList()\n for i in range(self.num_layer_this_model):\n layer = ParallelLlamaDecoderLayerRmPad(config, megatron_config, layer_idx=offset + i)\n self.layers.add_module(f\"{i}\", layer)\n\n if post_process:\n self.norm = ParallelLlamaRMSNorm(config, megatron_config)\n else:\n self.norm = None\n\n def set_input_tensor(self, input_tensor):\n \"\"\"Set input tensor to be used instead of forward()'s input.\n\n When doing pipeline parallelism the input from the previous\n stage comes from communication, not from the input, so the\n model's forward_step_func won't have it. This function is thus\n used by internal code to bypass the input provided by the\n forward_step_func\"\"\"\n self.input_tensor = input_tensor\n\n def forward(\n self,\n input_ids: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: int = None,\n max_seqlen_in_batch: int = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (1, totol_nnz)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n if self.pre_process:\n inputs_embeds = self.embed_tokens(input_ids) # (1, total_nnz) -> (1, total_nnz, hidden_size)\n\n # vocab parallel embedding will not do sequence parallel reduce-scatter in open source megatron\n # so need to deal with it by handle here:\n # (1, total_nnz, hidden_size) -> (total_nnz, 1, hidden_size) -> (total_nnz // sp, 1, hidden_size)\n inputs_embeds = inputs_embeds.transpose(0, 1)\n if self.megatron_config.sequence_parallel:\n inputs_embeds = tensor_parallel.scatter_to_sequence_parallel_region(inputs_embeds)\n\n hidden_states = inputs_embeds\n else:\n # self.hidden_states should be passed by Megatron\n hidden_states = self.input_tensor\n\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = layer_outputs\n\n if self.post_process:\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelLlamaForCausalLMRmPadPP(nn.Module):\n def __init__(\n self,\n config: LlamaConfig,\n megatron_config: ModelParallelConfig,\n pre_process,\n post_process,\n share_embeddings_and_output_weights=False,\n ):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.megatron_config = megatron_config\n self.model = ParallelLlamaModelRmPadPP(\n config, megatron_config=megatron_config, pre_process=pre_process, post_process=post_process\n )\n assert share_embeddings_and_output_weights is False, (\n \"Llama Model not supports sharing embedding and output weights\"\n )\n self.share_embeddings_and_output_weights = share_embeddings_and_output_weights\n self.vocab_size = config.vocab_size\n self.pre_process = pre_process\n self.post_process = post_process\n if post_process:\n self._init_head(config)\n\n def set_input_tensor(self, input_tensor):\n \"\"\"Set input tensor to be used instead of forward()'s input.\n\n When doing pipeline parallelism the input from the previous\n stage comes from communication, not from the input, so the\n model's forward_step_func won't have it. This function is thus\n used by internal code to bypass the input provided by the\n forward_step_func\"\"\"\n assert len(input_tensor) == 1\n self.model.set_input_tensor(input_tensor[0])\n\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n def _forward_head(self, hidden_states):\n # all_gather from sequence parallel region is performed inside lm_head\n # logits shape before forward_head hidden_states.shape: [4, 32, 4096]\n logits = self.lm_head(hidden_states)[0]\n # logits shape after forward_head logits.shape: [8, 32, 8]\n logits = logits.float() # (total_nnz_padded, 1, vocab_size // tp)\n return logits\n\n def forward(\n self,\n # original input\n *,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n\n # Note that input_ids, attention_mask and position_ids should be passed to every pp layer.\n # In the first pp, input_ids will be used, in other pp layers hidden_states will be used inside self.model\n batch_size, sequence_length = input_ids.shape\n # remove padding here\n input_ids_rmpad, indices, cu_seqlens, max_seqlen_in_batch, *_ = unpad_input(\n input_ids.unsqueeze(dim=-1), attention_mask\n ) # (total_nnz, 1)\n\n # pad input_ids to multiple of tp for all tp ranks\n # TODO: for better performance, the sp padding should be removed at each layer. Not sure the performance gap\n if self.megatron_config.sequence_parallel:\n input_ids_rmpad = sp_utils.pad_to_sequence_parallel(input_ids_rmpad)\n\n input_ids_rmpad = input_ids_rmpad.transpose(0, 1) # (1, total_nnz+pad)\n\n outputs = self.model(\n input_ids=input_ids_rmpad,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n if self.post_process:\n hidden_states = outputs\n # print(f'hidden_states.shape = {hidden_states.shape}') # torch.Size([4, 32, 4096])\n logits = self._forward_head(hidden_states)\n logits = torch.squeeze(logits, dim=1) # remove the artificial batch dimension # torch.Size([8, 32, 16])\n\n # remove padding from sequence parallel\n if self.megatron_config.sequence_parallel:\n totol_nnz = cu_seqlens[-1]\n logits = logits[:totol_nnz] # (total_nnz_padded)\n # add removed padding back. If input is already rmpad, we let the caller pad_input\n logits = pad_input(\n logits, indices, batch_size, seqlen=sequence_length\n ) # (batch_size, sequence_length, vocab_size)\n\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n else:\n return outputs\n\n\nclass ParallelLlamaForValueRmPadPP(ParallelLlamaForCausalLMRmPadPP):\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = nn.Linear(in_features=config.hidden_size, out_features=1, bias=False)\n # lm_head is effectively the same as sequence parallel\n sp_utils.mark_parameter_as_sequence_parallel(self.lm_head.weight)\n\n def _forward_head(self, hidden_states):\n logits = self.lm_head(hidden_states) # (total_nnz_padded // tp, 1, 1)\n logits = logits.float()\n if self.megatron_config.sequence_parallel:\n logits = tensor_parallel.gather_from_sequence_parallel_region(logits, tensor_parallel_output_grad=False)\n return logits\n\n def forward(\n self,\n *,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n output = super().forward(input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids)\n if self.post_process:\n output.logits = torch.squeeze(output.logits, dim=-1)\n return output\n else:\n return output\n"} +{"file_name": "verl__models__mcore__config_converter.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# convert huggingface config to mcore transformer config\n\n\nimport warnings\nfrom typing import TypeVar\n\nimport torch\nimport torch.nn.functional as F\nfrom megatron.core import parallel_state as mpu\nfrom megatron.core.transformer import MLATransformerConfig, TransformerConfig\nfrom transformers import PretrainedConfig\n\nT = TypeVar(\"T\", bound=TransformerConfig)\n\n\ndef _get_base_transformer_config(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> dict:\n \"\"\"\n Create a base TransformerConfig with common parameters across different model architectures.\n TODO: (ycl) use dataclass or converter config?\n\n Args:\n hf_config: HuggingFace model configuration\n dtype: Data type for the model\n override_transformer_config_kwargs: Additional parameters to override defaults\n\n Returns:\n TransformerConfig with common parameters\n \"\"\"\n\n # Common parallel state parameters\n overlap_p2p_comm = (\n mpu.get_virtual_pipeline_model_parallel_world_size() is not None\n and mpu.get_virtual_pipeline_model_parallel_world_size() > 1\n )\n batch_p2p_comm = False\n\n # Base configuration with common parameters\n base_config = {\n # Model architecture parameters\n \"num_layers\": hf_config.num_hidden_layers,\n \"hidden_size\": hf_config.hidden_size,\n \"num_attention_heads\": hf_config.num_attention_heads,\n \"num_query_groups\": hf_config.num_key_value_heads,\n \"ffn_hidden_size\": hf_config.intermediate_size,\n \"attention_dropout\": hf_config.attention_dropout,\n \"hidden_dropout\": getattr(hf_config, \"hidden_dropout\", 0.0),\n \"kv_channels\": getattr(hf_config, \"head_dim\", None),\n \"layernorm_epsilon\": hf_config.rms_norm_eps,\n \"add_bias_linear\": True,\n # Activation and normalization\n \"activation_func\": F.silu,\n \"normalization\": \"RMSNorm\",\n \"gated_linear_unit\": True,\n # Data types\n \"pipeline_dtype\": dtype,\n \"params_dtype\": dtype,\n \"bf16\": dtype is torch.bfloat16,\n # Parallel configuration\n \"tensor_model_parallel_size\": mpu.get_tensor_model_parallel_world_size(),\n \"pipeline_model_parallel_size\": mpu.get_pipeline_model_parallel_world_size(),\n \"expert_model_parallel_size\": mpu.get_expert_model_parallel_world_size(),\n \"expert_tensor_parallel_size\": mpu.get_expert_tensor_parallel_world_size(),\n \"virtual_pipeline_model_parallel_size\": mpu.get_virtual_pipeline_model_parallel_world_size(),\n \"context_parallel_size\": mpu.get_context_parallel_world_size(),\n \"overlap_p2p_comm\": overlap_p2p_comm,\n \"batch_p2p_comm\": batch_p2p_comm,\n \"sequence_parallel\": mpu.get_tensor_model_parallel_world_size() > 1,\n # Common settings\n \"variable_seq_lengths\": True,\n \"masked_softmax_fusion\": True,\n \"moe_token_dispatcher_type\": \"alltoall\",\n }\n\n # Update with any provided overrides\n # override_transformer_config_kwargs as kwargs shall never be none\n base_config.update(override_transformer_config_kwargs)\n\n return base_config\n\n\ndef _get_mla_transformer_config(\n hf_config: PretrainedConfig, mla_rope_config: dict, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> dict:\n \"\"\"\n Create a MLATransformerConfig with common parameters across different model architectures.\n This is specifically for MLA models like DeepseekV3.\n\n Args:\n hf_config: HuggingFace model configuration\n mla_rope_config: MLA specific RoPE configuration\n dtype: Data type for the model\n override_transformer_config_kwargs: Additional parameters to override defaults\n\n Returns:\n MLATransformerConfig with common parameters\n \"\"\"\n base_config = _get_base_transformer_config(hf_config=hf_config, dtype=dtype, **override_transformer_config_kwargs)\n mla_config = {\n # MLA specific parameters\n \"q_lora_rank\": hf_config.q_lora_rank,\n \"kv_lora_rank\": hf_config.kv_lora_rank,\n \"qk_head_dim\": hf_config.qk_nope_head_dim,\n \"qk_pos_emb_head_dim\": hf_config.qk_rope_head_dim,\n \"v_head_dim\": hf_config.v_head_dim,\n \"rotary_base\": hf_config.rope_theta,\n \"rotary_scaling_factor\": mla_rope_config[\"factor\"],\n \"rope_type\": mla_rope_config[\"type\"],\n \"max_position_embeddings\": mla_rope_config[\"original_max_position_embeddings\"],\n \"beta_fast\": mla_rope_config[\"beta_fast\"],\n \"beta_slow\": mla_rope_config[\"beta_slow\"],\n \"mscale\": mla_rope_config[\"mscale\"],\n \"mscale_all_dim\": mla_rope_config[\"mscale_all_dim\"],\n }\n\n base_config.update(mla_config)\n return base_config\n\n\ndef check_and_construct_configs(original_config: dict, cls: type[T]) -> T:\n \"\"\"\n Check and disable incompatible configurations for older Megatron version.\n\n Args:\n original_config (dict): The original model configuration.\n\n Returns:\n dict: The updated model configuration with incompatible settings disabled.\n \"\"\"\n removed_keys = []\n for key in original_config.keys():\n if not hasattr(cls, key):\n removed_keys.append(key)\n if removed_keys:\n warnings.warn(\n f\"The following keys are not supported in the current Megatron version and will be removed: {removed_keys}\",\n stacklevel=2,\n )\n for key in removed_keys:\n original_config.pop(key)\n\n original_config = mapping_string_to_attn_backend(original_config)\n if not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0:\n print(f\"Overridden {cls.__name__} init config: {original_config}\")\n return cls(**original_config)\n\n\ndef hf_to_mcore_config_dense(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n # for LlamaForCausalLM or Qwen2ForCausalLM\n qkv_bias = True if \"Qwen2\" in hf_config.architectures[0] else getattr(hf_config, \"attention_bias\", False)\n qk_layernorm = True if \"Qwen3\" in hf_config.architectures[0] else False\n\n args: dict = _get_base_transformer_config(\n hf_config=hf_config,\n dtype=dtype,\n use_cpu_initialization=False,\n add_bias_linear=False,\n add_qkv_bias=qkv_bias,\n qk_layernorm=qk_layernorm,\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n return check_and_construct_configs(args, TransformerConfig)\n\n\ndef hf_to_mcore_config_qwen2moe(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n args: dict = _get_base_transformer_config(\n hf_config=hf_config,\n dtype=dtype,\n use_cpu_initialization=False,\n add_bias_linear=False,\n layernorm_epsilon=hf_config.rms_norm_eps,\n # MoE specific\n moe_ffn_hidden_size=hf_config.moe_intermediate_size,\n moe_router_bias_update_rate=0.001,\n moe_router_topk=hf_config.num_experts_per_tok,\n num_moe_experts=hf_config.num_experts,\n moe_shared_expert_intermediate_size=hf_config.shared_expert_intermediate_size,\n moe_aux_loss_coeff=hf_config.router_aux_loss_coef,\n # moe_aux_loss_coeff=0.0,\n moe_router_load_balancing_type=\"none\", # turn off aux_loss as it hurts perf in RL\n moe_shared_expert_overlap=True,\n moe_grouped_gemm=True,\n moe_router_score_function=\"softmax\",\n # Other optimizations\n persist_layer_norm=True,\n bias_activation_fusion=True,\n bias_dropout_fusion=True,\n # Qwen specific\n moe_router_pre_softmax=True,\n add_qkv_bias=True,\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n return check_and_construct_configs(args, TransformerConfig)\n\n\ndef hf_to_mcore_config_mixtral(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n args: dict = _get_base_transformer_config(\n hf_config=hf_config,\n dtype=dtype,\n use_cpu_initialization=False,\n add_bias_linear=False,\n layernorm_epsilon=hf_config.rms_norm_eps,\n # MoE specific\n num_moe_experts=hf_config.num_local_experts,\n moe_aux_loss_coeff=hf_config.router_aux_loss_coef,\n moe_router_topk=hf_config.num_experts_per_tok,\n moe_router_pre_softmax=True,\n moe_router_load_balancing_type=\"none\", # turn off aux_loss as it hurts perf in RL\n moe_router_score_function=\"softmax\",\n moe_shared_expert_intermediate_size=None, # mixtral has no shared expert\n moe_shared_expert_overlap=False, # mixtral has no shared expert\n moe_ffn_hidden_size=hf_config.intermediate_size,\n moe_router_bias_update_rate=0.001,\n # moe_permute_fusion=True, # need TE 2.1+\n moe_grouped_gemm=True,\n # Other optimizations\n persist_layer_norm=True,\n apply_rope_fusion=True,\n bias_activation_fusion=True,\n bias_dropout_fusion=True,\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n return check_and_construct_configs(args, TransformerConfig)\n\n\ndef hf_to_mcore_config_qwen3moe(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n args: dict = _get_base_transformer_config(\n hf_config=hf_config,\n dtype=dtype,\n use_cpu_initialization=False,\n add_bias_linear=False,\n layernorm_epsilon=hf_config.rms_norm_eps,\n # MoE specific\n moe_ffn_hidden_size=hf_config.moe_intermediate_size,\n moe_router_bias_update_rate=0.001,\n moe_router_topk=hf_config.num_experts_per_tok,\n num_moe_experts=hf_config.num_experts,\n moe_aux_loss_coeff=hf_config.router_aux_loss_coef,\n # moe_aux_loss_coeff=0.0,\n moe_router_load_balancing_type=\"none\", # turn off aux_loss as it hurts perf in RL\n moe_grouped_gemm=True,\n moe_router_score_function=\"softmax\",\n # Other optimizations\n persist_layer_norm=True,\n bias_activation_fusion=True,\n bias_dropout_fusion=True,\n # Qwen specific\n moe_router_pre_softmax=False,\n qk_layernorm=True,\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n return check_and_construct_configs(args, TransformerConfig)\n\n\ndef hf_to_mcore_config_dpskv3(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> MLATransformerConfig:\n # DeepseekV3ForCausalLM\n from megatron.core.config import set_experimental_flag\n from megatron.core.transformer.enums import AttnBackend\n\n set_experimental_flag(True)\n\n from .patch import apply_patch\n\n apply_patch()\n\n mla_rope_config = {\n \"beta_fast\": 32,\n \"beta_slow\": 1,\n \"factor\": 1,\n \"mscale\": 1.0,\n \"mscale_all_dim\": 1.0,\n \"original_max_position_embeddings\": 4096,\n \"type\": \"rope\",\n }\n if \"rope_scaling\" in hf_config and hf_config.rope_scaling is not None:\n mla_rope_config.update(hf_config.rope_scaling)\n moe_layer_freq = [1] * hf_config.num_hidden_layers\n for i in range(min(hf_config.first_k_dense_replace, hf_config.num_hidden_layers)):\n moe_layer_freq[i] = 0\n\n # disable MTP and quantization for now\n if \"num_nextn_predict_layers\" in hf_config:\n assert hf_config.num_nextn_predict_layers == 0, (\n \"MTP is not supported for now, please modify the config.json to set num_nextn_predict_layers to 0\"\n )\n assert \"quantization_config\" not in hf_config or not hf_config.quantization_config, (\n \"quantization is not supported for now, please modify the config.json to remove quantization_config\"\n )\n\n args: dict = _get_mla_transformer_config(\n hf_config=hf_config,\n mla_rope_config=mla_rope_config,\n dtype=dtype,\n # Additional parameters\n use_cpu_initialization=False,\n add_bias_linear=False,\n attention_backend=AttnBackend.fused,\n qk_layernorm=True,\n # Standard MoE parameters\n moe_ffn_hidden_size=hf_config.moe_intermediate_size,\n moe_token_dispatcher_type=\"alltoall\",\n moe_router_bias_update_rate=0.001,\n moe_router_enable_expert_bias=True,\n moe_router_topk=hf_config.num_experts_per_tok,\n num_moe_experts=hf_config.n_routed_experts,\n moe_shared_expert_intermediate_size=hf_config.moe_intermediate_size * hf_config.n_shared_experts,\n moe_aux_loss_coeff=getattr(hf_config, \"aux_loss_alpha\", 0.001),\n moe_router_load_balancing_type=\"seq_aux_loss\",\n moe_shared_expert_overlap=True,\n # moe_permute_fusion=True, # need TE 2.1+\n moe_grouped_gemm=True,\n moe_router_score_function=\"sigmoid\",\n moe_router_pre_softmax=True,\n moe_router_topk_scaling_factor=hf_config.routed_scaling_factor,\n moe_layer_freq=moe_layer_freq,\n # mcore 0.12 moe\n moe_router_dtype=\"fp64\",\n disable_bf16_reduced_precision_matmul=True,\n # Other optimizations\n # deallocate_pipeline_outputs=True,\n # gradient_accumulation_fusion=True,\n persist_layer_norm=True,\n bias_activation_fusion=True,\n bias_dropout_fusion=True,\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n transformer_config = check_and_construct_configs(args, MLATransformerConfig)\n # MTP\n if \"num_nextn_predict_layers\" in hf_config:\n transformer_config.mtp_num_layers = hf_config.num_nextn_predict_layers\n transformer_config.mtp_loss_scaling_factor = 0.1\n\n return transformer_config\n\n\ndef hf_to_mcore_config_qwen2_5_vl(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n # Qwen2_5_VLForConditionalGeneration\n\n args = _get_base_transformer_config(\n hf_config=hf_config,\n dtype=dtype,\n add_bias_linear=False,\n # qwen specific\n add_qkv_bias=True,\n mrope_section=hf_config.rope_scaling[\"mrope_section\"],\n )\n # override_transformer_config_kwargs as kwargs shall never be none\n args.update(override_transformer_config_kwargs)\n args = mapping_string_to_attn_backend(args)\n return TransformerConfig(**args)\n\n\ndef hf_to_mcore_config_llama4(\n hf_config: PretrainedConfig, dtype: torch.dtype, **override_transformer_config_kwargs\n) -> TransformerConfig:\n # Llama4ForConditionalGeneration\n raise NotImplementedError(\"Llama4ForConditionalGeneration is not supported yet\")\n\n\ndef mapping_string_to_attn_backend(args: dict) -> dict:\n if \"attention_backend\" in args and isinstance(args[\"attention_backend\"], str):\n from megatron.core.transformer.enums import AttnBackend\n\n args[\"attention_backend\"] = AttnBackend[args[\"attention_backend\"]]\n return args\n"} +{"file_name": "verl__models__mcore__loader.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\n\nfrom verl.utils.device import get_device_id, get_torch_device\n\nfrom .saver import _megatron_calc_global_rank\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef load_state_dict_to_megatron_gptmodel(state_dict, wrapped_models, config, params_dtype, is_value_model=False):\n \"\"\"Load merged state_dict to sharded Megatron module in training.\"\"\"\n from megatron.core import DistributedDataParallel as LocalDDP\n from megatron.core import mpu\n from megatron.core.transformer.module import Float16Module\n from torch.nn.parallel import DistributedDataParallel as torchDDP\n\n from verl.utils.logger import print_rank_0\n from verl.utils.megatron_utils import unwrap_model\n\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n def broadcast_params(module):\n for param in module.parameters():\n torch.distributed.broadcast(\n param.data, src=mpu.get_data_parallel_src_rank(), group=mpu.get_data_parallel_group()\n )\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n cp_rank = mpu.get_context_parallel_rank()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=0, cp_rank=cp_rank)\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if torch.distributed.get_rank() == src_rank:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n gpt_model_module = _get_gpt_model(models[i])\n assert len(gpt_model_module.decoder.layers) == num_layers_per_model\n\n def _broadcast_tensor(tensor, name) -> torch.Tensor:\n \"\"\"broadcast tensor from rank0 across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n if torch.distributed.get_rank() == src_rank:\n if name in state_dict:\n weight = state_dict[name]\n tensor_shape = weight.shape\n else:\n tensor_shape = None\n else:\n weight = None\n tensor_shape = None\n\n obj_list = [tensor_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n tensor_shape = obj_list[0]\n\n if tensor_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tensor:[{name}] not in state_dict, skip load\")\n return\n\n if tensor is None:\n tensor = torch.empty(\n tensor_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n if torch.distributed.get_rank() == src_rank:\n tensor.data.copy_(weight)\n dist.broadcast(tensor, src=src_rank, group=mp_group)\n\n def _broadcast_tp_shard_tensor_vocab(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == src_rank:\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == src_rank:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=src_rank, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == src_rank:\n if name in state_dict:\n full_weight = state_dict[name]\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == src_rank:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=src_rank, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor_gate_up(tensor, gate_name, up_name) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == src_rank:\n gate_weight = state_dict[gate_name]\n up_weight = state_dict[up_name]\n new_gate_up_weight = torch.empty(\n config.intermediate_size * 2, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_tp = gate_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n up_weight_tp = up_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n new_gate_up_weight[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)].copy_(\n torch.cat([gate_weight_tp, up_weight_tp], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_gate_up_weight, tp_size, dim=0)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{gate_name, up_name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank() == src_rank:} tensor {gate_name, up_name} shape \"\n f\"{tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == src_rank:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=src_rank, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name, bias=False) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == src_rank:\n assert q_name in state_dict and k_name in state_dict and v_name in state_dict\n full_weight_q = state_dict[q_name]\n full_weight_k = state_dict[k_name]\n full_weight_v = state_dict[v_name]\n\n hidden_size_per_head = getattr(config, \"head_dim\", config.hidden_size // config.num_attention_heads)\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = hidden_size_per_head * config.num_attention_heads // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n sizes = [total_size * tp_size]\n if not bias:\n sizes.append(config.hidden_size)\n new_weight_qkv = torch.empty(*sizes, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n k_part = full_weight_k[i * kv_size_tp : (i + 1) * kv_size_tp]\n v_part = full_weight_v[i * kv_size_tp : (i + 1) * kv_size_tp]\n num_query_groups_per_partition = models[0].config.num_query_groups // tp_size\n new_weight_qkv_this_tp = new_weight_qkv[i * total_size : (i + 1) * total_size]\n q_part_per_head = torch.chunk(q_part, num_query_groups_per_partition, dim=0)\n k_part_per_head = torch.chunk(k_part, num_query_groups_per_partition, dim=0)\n v_part_per_head = torch.chunk(v_part, num_query_groups_per_partition, dim=0)\n total_size_per_head = total_size // num_query_groups_per_partition\n for j in range(num_query_groups_per_partition):\n new_weight_qkv_this_tp[j * total_size_per_head : (j + 1) * total_size_per_head].copy_(\n torch.cat([q_part_per_head[j], k_part_per_head[j], v_part_per_head[j]], dim=0)\n )\n\n else:\n q_size_tp = hidden_size_per_head * config.num_attention_heads // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n sizes = [total_size * tp_size]\n if not bias:\n sizes.append(config.hidden_size)\n new_weight_qkv = torch.empty(*sizes, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n start_idx = i * config.num_key_value_heads // tp_size * hidden_size_per_head\n end_idx = (i * config.num_key_value_heads // tp_size + 1) * hidden_size_per_head\n k_part = full_weight_k[start_idx:end_idx]\n v_part = full_weight_v[start_idx:end_idx]\n new_weight_qkv_this_tp = new_weight_qkv[i * total_size : (i + 1) * total_size]\n q_part_per_head = torch.chunk(q_part, config.num_attention_heads, dim=0)\n k_part_per_head = torch.chunk(k_part, config.num_attention_heads, dim=0)\n v_part_per_head = torch.chunk(v_part, config.num_attention_heads, dim=0)\n total_size_per_head = total_size // config.num_attention_heads\n for j in range(config.num_attention_heads):\n new_weight_qkv_this_tp[j * total_size_per_head : (j + 1) * total_size_per_head].copy_(\n torch.cat([q_part_per_head[j], k_part_per_head[j], v_part_per_head[j]], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_weight_qkv, tp_size, dim=0)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{q_name, k_name, v_name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {q_name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == src_rank:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=src_rank, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n if dp_rank == 0:\n # Embeddings\n # -------------------\n print_rank_0(\"loading embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n embed_tokens_weight = None\n if pp_rank == 0:\n embed_tokens_weight = gpt_model_module.embedding.word_embeddings.weight\n _broadcast_tp_shard_tensor_vocab(embed_tokens_weight, \"model.embed_tokens.weight\")\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n\n for layer in range(config.num_hidden_layers):\n layer_name = f\"model.layers.{layer}\"\n print_rank_0(f\"loading layer #{layer}, with layer_name model.layers.{layer}...\")\n dst_pp_rank, dst_virtual_pp_rank, dst_layer_idx = layer_map[layer]\n\n gpt_model_module = _get_gpt_model(models[dst_virtual_pp_rank])\n sync_layer = gpt_model_module.decoder.layers[dst_layer_idx]\n\n _broadcast_tensor(\n sync_layer.self_attention.linear_qkv.layer_norm_weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.input_layernorm.weight\",\n )\n\n if f\"{layer_name}.self_attn.q_norm.weight\" in state_dict:\n _broadcast_tensor(\n sync_layer.self_attention.q_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_norm.weight\",\n )\n _broadcast_tensor(\n sync_layer.self_attention.k_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.k_norm.weight\",\n )\n\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attention.linear_qkv.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n )\n if f\"{layer_name}.self_attn.q_proj.bias\" in state_dict:\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attention.linear_qkv.bias if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.bias\",\n f\"{layer_name}.self_attn.k_proj.bias\",\n f\"{layer_name}.self_attn.v_proj.bias\",\n bias=True,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.self_attention.linear_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.o_proj.weight\",\n chunk_dim=1,\n )\n _broadcast_tensor(\n sync_layer.mlp.linear_fc1.layer_norm_weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.post_attention_layernorm.weight\",\n )\n\n _broadcast_tp_shard_tensor_gate_up(\n sync_layer.mlp.linear_fc1.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.mlp.linear_fc2.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.down_proj.weight\",\n chunk_dim=1,\n )\n # Final Layernorm\n # -------------------\n print_rank_0(\"loading final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _broadcast_tensor(\n getattr(gpt_model_module.decoder.final_layernorm, \"weight\", None),\n \"model.norm.weight\",\n )\n\n print_rank_0(\"loading lm_head...\")\n lm_head_weight = None\n if pp_rank + 1 == pp_size:\n lm_head_weight = gpt_model_module.output_layer.weight\n\n if is_value_model:\n # if torch.distributed.get_rank() == src_rank:\n if \"lm_head.weight\" in state_dict and state_dict[\"lm_head.weight\"].shape[0] == 1:\n _broadcast_tensor(lm_head_weight, \"lm_head.weight\")\n elif \"reward_head.weight\" in state_dict and state_dict[\"reward_head.weight\"].shape[0] == 1:\n _broadcast_tensor(lm_head_weight, \"reward_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n elif \"score.weight\" in state_dict and state_dict[\"score.weight\"].shape[0] == 1:\n _broadcast_tensor(lm_head_weight, \"score.weight\")\n print_rank_0(\"load lm_head from score weight\")\n else:\n _broadcast_tensor(None, \"lm_head.weight\")\n print_rank_0(\"fail to match lm_head in value_model\")\n # else:\n\n # _broadcast_tensor(lm_head_weight, \"lm_head.weight\")\n\n else:\n _broadcast_tp_shard_tensor(lm_head_weight, \"lm_head.weight\")\n dist.barrier()\n # Broadcast weights inside data parallel groups\n for wrapped_model in wrapped_models:\n broadcast_params(wrapped_model)\n pass\n get_torch_device().empty_cache()\n print_rank_0(f\"loading megatron ckpt done, time elapsed {time.time() - start_time}s\")\n"} +{"file_name": "verl__models__mcore__model_forward.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport torch\n\nfrom verl.utils.megatron_utils import unwrap_model\nfrom verl.workers.config import MtpConfig\n\nfrom .util import (\n postprocess_bshd,\n postprocess_bshd_no_padding,\n postprocess_packed_seqs,\n postprocess_thd_no_padding,\n preprocess_bshd,\n preprocess_bshd_no_padding,\n preprocess_packed_seqs,\n preprocess_thd_no_padding,\n)\n\n\ndef model_forward_gen(vision_model: bool = False):\n def model_forward(\n model,\n input_ids,\n attention_mask,\n position_ids,\n multi_modal_inputs: dict,\n logits_processor=None,\n logits_processor_args: dict = None,\n value_model=False,\n data_format: str = \"thd\",\n mtp_config: MtpConfig = None,\n ):\n \"\"\"Forward pass for models with sequence packing.\"\"\"\n assert data_format in [\"thd\", \"bshd\"], \"data_format must be 'thd' or 'bshd'\"\n pre_process = (\n unwrap_model(model).pre_process if not vision_model else False\n ) # vision model does not need pre_process, because we pack the input_ids to thd in the forward function\n post_process = unwrap_model(model).post_process\n sp = unwrap_model(model).config.sequence_parallel\n fp8 = unwrap_model(model).config.fp8\n use_fp8_padding = fp8 in [\"e4m3\", \"hybrid\"]\n\n model_kwargs = {}\n if \"pixel_values\" in multi_modal_inputs:\n model_kwargs[\"pixel_values\"] = multi_modal_inputs[\"pixel_values\"].to(input_ids.device)\n if \"image_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"image_grid_thw\"] = multi_modal_inputs[\"image_grid_thw\"].to(input_ids.device)\n if \"pixel_values_videos\" in multi_modal_inputs:\n model_kwargs[\"pixel_values_videos\"] = multi_modal_inputs[\"pixel_values_videos\"].to(input_ids.device)\n if \"video_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"video_grid_thw\"] = multi_modal_inputs[\"video_grid_thw\"].to(input_ids.device)\n\n batch_size, seq_len = attention_mask.shape[:2]\n if data_format == \"thd\":\n input_ids_rmpad, packed_seq_params = preprocess_packed_seqs(\n input_ids, attention_mask, pre_process=pre_process or post_process, use_fp8_padding=use_fp8_padding\n )\n input_ids_rmpad = input_ids_rmpad.contiguous()\n\n # when pp > 1 and processor is not None, we need to pass the labels and loss_mask to the model\n if mtp_config and mtp_config.enable_train and post_process:\n args = {\n k: preprocess_packed_seqs(v, attention_mask, pre_process=True, use_fp8_padding=use_fp8_padding)[0]\n for k, v in logits_processor_args.items()\n }\n model_kwargs[\"labels\"] = args[\"label\"].contiguous()\n model_kwargs[\"loss_mask\"] = args[\"label_mask\"].contiguous()\n\n input_args = dict(\n input_ids=input_ids_rmpad,\n attention_mask=None,\n position_ids=position_ids if not vision_model else None, # vision models will calculate position_ids\n packed_seq_params=packed_seq_params,\n **model_kwargs,\n )\n\n if vision_model:\n # workaround for supporting sequence packing with context parallelism\n # cp split with sequence packing will make model lose vision token information, so we need to keep\n # the original input_ids and pack them after vision embedding is calculated,\n # cooporate with mbridge\n input_args[\"input_ids\"] = input_ids\n input_args[\"attention_mask\"] = attention_mask\n\n output_orig = model(**input_args)\n\n if post_process and logits_processor is not None:\n args = {\n k: preprocess_packed_seqs(v, attention_mask, pre_process=True, use_fp8_padding=use_fp8_padding)[0]\n for k, v in logits_processor_args.items()\n }\n output_dict = logits_processor(output_orig, **args)\n output = {\n k: postprocess_packed_seqs(\n v, packed_seq_params, attention_mask, batch_size, seq_len, post_process=post_process\n )\n for k, v in output_dict.items()\n }\n else:\n output = postprocess_packed_seqs(\n output_orig, packed_seq_params, attention_mask, batch_size, seq_len, post_process=post_process\n )\n elif data_format == \"bshd\":\n \"\"\"\n data_format: \"thd\" or \"bshd\", default is \"thd\",\n why we need this?\n for some new models, GPT-OSS, the thd format is not supported, so we need to use the bshd format.\n When using the bshd format, we have to add paddings to the input_ids to meet the longest sequence length, \n so it is recommended to disable dynamic batch size and set batch size to 1\n \"\"\"\n assert not vision_model, \"vision model does not support bshd format\"\n assert fp8 is None, \"fp8 is not supported for bshd format yet\"\n\n batch_size, sequence_length = attention_mask.shape[:2]\n new_input_ids, new_attention_mask, new_position_ids = preprocess_bshd(\n input_ids, attention_mask, position_ids, sequence_parallel=sp, pre_process=pre_process\n )\n output_orig = model(\n input_ids=new_input_ids,\n position_ids=new_position_ids,\n attention_mask=new_attention_mask,\n **model_kwargs,\n )\n if post_process and logits_processor is not None:\n args = {\n k: preprocess_bshd(v, attention_mask, position_ids, sequence_parallel=sp, pre_process=True)[0]\n for k, v in logits_processor_args.items()\n }\n output_dict = logits_processor(output_orig, **args)\n output = {\n k: postprocess_bshd(\n v, new_attention_mask, attention_mask, sequence_length, post_process=post_process\n )\n for k, v in output_dict.items()\n }\n else:\n output = postprocess_bshd(\n output_orig, new_attention_mask, attention_mask, sequence_length, post_process=post_process\n )\n if value_model and post_process:\n output = output[..., 0]\n return output\n\n return model_forward\n\n\ndef gptmodel_forward_no_padding(\n model,\n input_ids,\n multi_modal_inputs: dict,\n logits_processor=None,\n logits_processor_args: dict = None,\n value_model=False,\n vision_model=False,\n pad_token_id=None,\n data_format: str = \"thd\",\n enable_mtp: bool = False,\n):\n \"\"\"Default forward pass for GPT models with optional sequence packing.\"\"\"\n\n assert data_format in [\"thd\", \"bshd\"], \"data_format must be 'thd' or 'bshd'\"\n pre_process = unwrap_model(model).pre_process\n post_process = unwrap_model(model).post_process\n\n model_kwargs = {}\n if \"pixel_values\" in multi_modal_inputs:\n model_kwargs[\"pixel_values\"] = multi_modal_inputs[\"pixel_values\"].to(input_ids.device)\n if \"image_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"image_grid_thw\"] = multi_modal_inputs[\"image_grid_thw\"].to(input_ids.device)\n if \"pixel_values_videos\" in multi_modal_inputs:\n model_kwargs[\"pixel_values_videos\"] = multi_modal_inputs[\"pixel_values_videos\"].to(input_ids.device)\n if \"video_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"video_grid_thw\"] = multi_modal_inputs[\"video_grid_thw\"].to(input_ids.device)\n\n batch_size = input_ids.shape[0]\n if data_format == \"thd\":\n input_ids_rmpad, packed_seq_params = preprocess_thd_no_padding(input_ids, pre_process=pre_process)\n input_ids_rmpad = input_ids_rmpad.contiguous()\n\n if enable_mtp and post_process:\n args = {\n k: preprocess_thd_no_padding(v, pre_process=True, need_roll=(k == \"label\" or k == \"loss_mask\"))[0]\n for k, v in logits_processor_args.items()\n }\n model_kwargs[\"labels\"] = args[\"label\"].contiguous()\n model_kwargs[\"loss_mask\"] = args[\"loss_mask\"].contiguous()\n if logits_processor_args and \"loss_mask\" in logits_processor_args:\n logits_processor_args.pop(\"loss_mask\")\n\n # For VLM model, need to pass bshd format `input_ids` and `attention_mask`.\n attention_mask = None\n if vision_model:\n input_ids_rmpad = input_ids.to_padded_tensor(pad_token_id)\n seqlens_in_batch = input_ids.offsets().diff()\n attention_mask = torch.zeros_like(input_ids_rmpad, dtype=torch.bool)\n for i, seqlen in enumerate(seqlens_in_batch):\n attention_mask[i, :seqlen] = True\n\n output_orig = model(\n input_ids=input_ids_rmpad,\n attention_mask=attention_mask,\n position_ids=None,\n packed_seq_params=packed_seq_params,\n **model_kwargs,\n )\n\n if post_process and logits_processor is not None:\n args = {\n k: preprocess_thd_no_padding(v, pre_process=True, need_roll=(k == \"label\"))[0]\n for k, v in logits_processor_args.items()\n }\n output_dict = logits_processor(output_orig, **args)\n output = {\n k: postprocess_thd_no_padding(v, packed_seq_params, input_ids, batch_size, post_process=post_process)\n for k, v in output_dict.items()\n }\n else:\n output = postprocess_thd_no_padding(\n output_orig, packed_seq_params, input_ids, batch_size, post_process=post_process\n )\n else:\n \"\"\"\n data_format: \"thd\" or \"bshd\", default is \"thd\",\n why we need this?\n for some new models, GPT-OSS, the thd format is not supported, so we need to use the bshd format.\n When using the bshd format, we have to add paddings to the input_ids to meet the longest sequence length, \n so it is recommended to disable dynamic batch size and set batch size to 1\n \"\"\"\n\n input_ids_bshd, attention_mask_bshd, position_ids_bshd = preprocess_bshd_no_padding(\n input_ids, pre_process=pre_process\n )\n\n if enable_mtp and post_process:\n args = {\n k: preprocess_bshd_no_padding(v, pre_process=True, need_roll=(k == \"label\" or k == \"loss_mask\"))[0]\n for k, v in logits_processor_args.items()\n }\n model_kwargs[\"labels\"] = args[\"label\"].contiguous()\n model_kwargs[\"loss_mask\"] = args[\"loss_mask\"].contiguous()\n if logits_processor_args and \"loss_mask\" in logits_processor_args:\n logits_processor_args.pop(\"loss_mask\")\n\n output_orig = model(\n input_ids=input_ids_bshd,\n attention_mask=attention_mask_bshd,\n position_ids=position_ids_bshd,\n **model_kwargs,\n )\n if post_process and logits_processor is not None:\n args = {\n k: preprocess_bshd_no_padding(v, pre_process=True, need_roll=(k == \"label\"))[0]\n for k, v in logits_processor_args.items()\n }\n output_dict = logits_processor(output_orig, **args)\n output = {\n k: postprocess_bshd_no_padding(v, attention_mask_bshd, post_process=post_process)\n for k, v in output_dict.items()\n }\n else:\n output = postprocess_bshd_no_padding(output_orig, attention_mask_bshd, post_process=post_process)\n\n if value_model and post_process:\n # output = output[..., 0]\n # while using nested tensor, the advanced indexing operation above will result in an error at backward, i.e.\n # ValueError: NestedTensor _nested_select_backward_default(grad_output: t, self: jt_all, dim: any, index: any)\n # so we use `squeeze` to remove the last dimension\n output = output.squeeze(-1)\n\n return output\n"} +{"file_name": "verl__models__mcore__model_forward_1f1b_overlap.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Callable, Optional\n\nimport torch\nfrom megatron.core.models.common.model_chunk_schedule_plan import TransformerModelChunkSchedulePlan\nfrom megatron.core.models.gpt.gpt_model import GPTModel\nfrom megatron.core.utils import make_viewless_tensor\nfrom torch import Tensor\n\nfrom verl.models.mcore.util import preprocess_packed_seqs\nfrom verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\nfrom verl.utils.megatron_utils import unwrap_model\nfrom verl.utils.model import CausalLMOutputForPPO\n\nfrom .util import postprocess_packed_seqs, postprocess_packed_seqs_for_dict_output\n\n\ndef gptmodel_forward_1f1b_overlap(\n model: GPTModel,\n input_ids: Tensor,\n position_ids: Tensor,\n attention_mask: Tensor,\n labels: Tensor = None,\n labels_mask: Tensor = None,\n multi_modal_inputs: Optional[dict] = None,\n logits_processor: Optional[Callable] = None,\n logits_processor_args: Optional[dict] = None,\n temperature: float = 1.0,\n) -> TransformerModelChunkSchedulePlan:\n pre_process: bool = unwrap_model(model).pre_process\n post_process: bool = unwrap_model(model).post_process\n assert logits_processor is None, \"only support fused kernel\"\n batch_size, seq_len = attention_mask.shape[:2]\n input_ids_rmpad, packed_seq_params = preprocess_packed_seqs(input_ids, attention_mask, pre_process=pre_process)\n input_ids_rmpad = input_ids_rmpad.contiguous()\n\n schedule_plan = model.build_schedule_plan(\n input_ids=input_ids_rmpad,\n attention_mask=attention_mask,\n labels=labels,\n position_ids=position_ids,\n packed_seq_params=packed_seq_params,\n )\n if post_process:\n attention_mask_out = attention_mask\n\n def _postprocess(\n self,\n hidden_states,\n input_ids,\n position_ids,\n labels,\n rotary_pos_emb,\n rotary_pos_cos,\n rotary_pos_sin,\n mtp_in_postprocess=None,\n loss_mask=None,\n decoder_input=None,\n attention_mask=None,\n inference_params=None,\n packed_seq_params=None,\n sequence_len_offset=None,\n runtime_gather_output=None,\n extra_block_kwargs=None,\n inference_context=None,\n ):\n \"\"\"patched from https://github.com/NVIDIA/Megatron-LM/blob/core_r0.14.0/megatron/core/models/gpt/gpt_model.py#L412\"\"\"\n \"\"\"Postprocesses decoder hidden states to generate logits or compute loss.\n\n Applies Multi-Token Prediction if enabled, generates output logits through\n the output layer, and computes language model loss when labels are provided.\n \"\"\"\n from megatron.core import parallel_state\n from megatron.core.tensor_parallel import gather_from_sequence_parallel_region\n\n in_inference_mode = inference_context is not None and not self.training\n if in_inference_mode:\n assert runtime_gather_output, \"Inference must always gather TP logits\"\n\n # logits and loss\n output_weight = None\n if self.share_embeddings_and_output_weights:\n output_weight = self.shared_embedding_or_output_weight()\n\n if mtp_in_postprocess:\n hidden_states = self.mtp(\n input_ids=input_ids,\n position_ids=position_ids,\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n inference_params=inference_params,\n rotary_pos_emb=rotary_pos_emb,\n rotary_pos_cos=rotary_pos_cos,\n rotary_pos_sin=rotary_pos_sin,\n packed_seq_params=packed_seq_params,\n sequence_len_offset=sequence_len_offset,\n embedding=self.embedding,\n **(extra_block_kwargs or {}),\n )\n\n if not self.post_process:\n return hidden_states\n\n if self.mtp_process:\n from megatron.core.transformer.multi_token_prediction import (\n MTPLossAutoScaler,\n MTPLossLoggingHelper,\n roll_tensor,\n )\n\n mtp_labels = labels.clone()\n hidden_states_list = torch.chunk(hidden_states, 1 + self.config.mtp_num_layers, dim=0)\n hidden_states = hidden_states_list[0]\n if loss_mask is None:\n # if loss_mask is not provided, use all ones as loss_mask\n loss_mask = torch.ones_like(mtp_labels)\n for mtp_layer_number in range(self.config.mtp_num_layers):\n # output\n mtp_logits, _ = self.output_layer(\n hidden_states_list[mtp_layer_number + 1],\n weight=output_weight,\n runtime_gather_output=runtime_gather_output,\n )\n # Calc loss for the current Multi-Token Prediction (MTP) layers.\n mtp_labels, _ = roll_tensor(mtp_labels, shifts=-1, dims=-1, cp_group=self.cp_group)\n loss_mask, num_tokens = roll_tensor(loss_mask, shifts=-1, dims=-1, cp_group=self.cp_group)\n mtp_loss = self.compute_language_model_loss(mtp_labels, mtp_logits)\n mtp_loss = loss_mask * mtp_loss\n if self.training:\n # TODO(shifangx): remove the use of parallel_state here\n # after moving loss logging to loss_func in pretrain_gpt.py\n MTPLossLoggingHelper.save_loss_to_tracker(\n torch.sum(mtp_loss) / num_tokens,\n mtp_layer_number,\n self.config.mtp_num_layers,\n avg_group=parallel_state.get_data_parallel_group(with_context_parallel=True),\n )\n mtp_loss_scale = self.config.mtp_loss_scaling_factor / self.config.mtp_num_layers\n if self.config.calculate_per_token_loss:\n hidden_states = MTPLossAutoScaler.apply(hidden_states, mtp_loss_scale * mtp_loss)\n else:\n hidden_states = MTPLossAutoScaler.apply(hidden_states, mtp_loss_scale * mtp_loss / num_tokens)\n\n if logits_processor is not None:\n logits, _ = self.output_layer(\n hidden_states, weight=output_weight, runtime_gather_output=runtime_gather_output\n )\n output_orig = logits.transpose(0, 1).contiguous()\n args = {\n k: preprocess_packed_seqs(v, attention_mask_out, pre_process=True)[0]\n for k, v in logits_processor_args.items()\n }\n output_dict = logits_processor(output_orig, **args)\n output = {\n k: postprocess_packed_seqs(\n v, packed_seq_params, attention_mask_out, batch_size, seq_len, post_process=post_process\n )\n for k, v in output_dict.items()\n }\n else:\n # fused kernel\n\n labels_rmpad, _ = preprocess_packed_seqs(labels, attention_mask, pre_process=True)\n labels_mask_rmpad, _ = preprocess_packed_seqs(labels_mask, attention_mask, pre_process=True)\n labels_rmpad = labels_rmpad.contiguous()\n labels_mask_rmpad = labels_mask_rmpad.contiguous()\n\n output = CausalLMOutputForPPO(\n loss=None,\n logits=None,\n past_key_values=None,\n hidden_states=hidden_states,\n attentions=None,\n )\n if self.config.sequence_parallel:\n hidden_states = gather_from_sequence_parallel_region(hidden_states)\n logprobs, entropy = linear_cross_entropy(\n hidden_states,\n self.output_layer.weight,\n labels_rmpad,\n temperature,\n \"none\",\n parallel_state.get_tensor_model_parallel_group(),\n )\n output.entropy = entropy\n output.log_probs = logprobs\n\n output = postprocess_packed_seqs_for_dict_output(\n labels_mask_rmpad,\n output,\n packed_seq_params,\n attention_mask,\n batch_size,\n seq_len,\n post_process=post_process,\n )\n output_ = [output[\"log_probs\"]]\n # TODO NOW 1f1b overlap only support one tensor output\n # if \"entropy\" in output:\n # output_.append(output[\"entropy\"])\n output_ = tuple(output_)\n return output_\n\n def _custom_post_process_node_forward_impl(self, hidden_states):\n if self.gpt_model.decoder.final_layernorm and not self.gpt_model.mtp_process:\n hidden_states = self.gpt_model.decoder.final_layernorm(hidden_states)\n # TENorm produces a \"viewed\" tensor. This will result in schedule.py's\n # deallocate_output_tensor() throwing an error, so a viewless tensor is\n # created to prevent this.\n hidden_states = make_viewless_tensor(inp=hidden_states, requires_grad=True, keep_graph=True)\n\n # Run GPTModel._postprocess\n output = self.gpt_model._postprocess(\n hidden_states=hidden_states,\n input_ids=self.chunk_state.input_ids,\n position_ids=self.chunk_state.position_ids,\n labels=self.chunk_state.labels,\n decoder_input=self.chunk_state.decoder_input,\n rotary_pos_emb=self.chunk_state.rotary_pos_emb,\n rotary_pos_cos=self.chunk_state.rotary_pos_cos,\n rotary_pos_sin=self.chunk_state.rotary_pos_sin,\n mtp_in_postprocess=False,\n loss_mask=self.chunk_state.loss_mask,\n attention_mask=self.chunk_state.attention_mask,\n packed_seq_params=self.chunk_state.packed_seq_params,\n sequence_len_offset=self.chunk_state.sequence_len_offset,\n runtime_gather_output=self.chunk_state.runtime_gather_output,\n extra_block_kwargs=self.chunk_state.extra_block_kwargs,\n )\n return output\n\n schedule_plan.post_process.forward_impl = _custom_post_process_node_forward_impl.__get__(\n schedule_plan.post_process, schedule_plan.post_process.__class__\n )\n unwrap_model(model)._postprocess = _postprocess.__get__(unwrap_model(model), unwrap_model(model).__class__)\n\n return schedule_plan\n"} +{"file_name": "verl__models__mcore__model_forward_fused.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom collections import OrderedDict\nfrom typing import Optional\n\nimport megatron.core as mcore\nimport torch\nfrom megatron.core import parallel_state\nfrom megatron.core.config_logger import has_config_logger_enabled, log_config_to_disk\nfrom megatron.core.inference.contexts import BaseInferenceContext\nfrom megatron.core.models.gpt.gpt_model import GPTModel\nfrom megatron.core.packed_seq_params import PackedSeqParams\nfrom megatron.core.tensor_parallel.mappings import gather_from_sequence_parallel_region\nfrom megatron.core.utils import deprecate_inference_params\nfrom packaging import version\nfrom torch import Tensor\n\nfrom verl.models.mcore.util import preprocess_packed_seqs, preprocess_thd_no_padding\nfrom verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\nfrom verl.utils.megatron_utils import unwrap_model\nfrom verl.utils.model import CausalLMOutputForPPO\n\nfrom .util import postprocess_packed_seqs_for_dict_output, postprocess_thd_no_padding\n\n\ndef _get_patching_model(model: torch.nn.Module):\n model = unwrap_model(model)\n if isinstance(model, GPTModel):\n return model\n\n if not (hasattr(model, \"language_model\") and isinstance(model.language_model, GPTModel)):\n print(f\"Model {model.__class__.__name__} is not a supported for fused forward\")\n return None\n\n return model.language_model\n\n\ndef patch_fused_forward(model: torch.nn.Module):\n assert version.parse(mcore.__version__) >= version.parse(\"0.13.0\"), (\n \"Fused forward patching requires mecore >= 0.13.0\"\n )\n model = _get_patching_model(model)\n if model is not None:\n model.forward_backup = model.forward\n model.forward = _fused_GPTModel_forward.__get__(model, model.__class__)\n\n\ndef unpatch_fused_forward(model: torch.nn.Module):\n model = _get_patching_model(model)\n if model is not None:\n model.forward = model.forward_backup\n\n\ndef fused_forward_model_gen(vision_model: bool = False):\n def fused_forward_model(\n model,\n input_ids: Tensor,\n position_ids: Tensor,\n attention_mask: Tensor,\n labels: Tensor,\n labels_mask: Tensor,\n temperature: float,\n multi_modal_inputs: dict,\n ):\n pre_process: bool = (\n unwrap_model(model).pre_process if not vision_model else False\n ) # vision model does not need pre_process, because we pack the input_ids to thd in the forward function\n post_process: bool = unwrap_model(model).post_process\n\n model_kwargs = {}\n if \"pixel_values\" in multi_modal_inputs:\n model_kwargs[\"pixel_values\"] = multi_modal_inputs[\"pixel_values\"].to(input_ids.device)\n if \"image_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"image_grid_thw\"] = multi_modal_inputs[\"image_grid_thw\"].to(input_ids.device)\n if \"pixel_values_videos\" in multi_modal_inputs:\n model_kwargs[\"pixel_values_videos\"] = multi_modal_inputs[\"pixel_values_videos\"].to(input_ids.device)\n if \"video_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"video_grid_thw\"] = multi_modal_inputs[\"video_grid_thw\"].to(input_ids.device)\n\n batch_size, seq_len = attention_mask.shape[:2]\n input_ids_rmpad, packed_seq_params = preprocess_packed_seqs(input_ids, attention_mask, pre_process=pre_process)\n input_ids_rmpad = input_ids_rmpad.contiguous()\n labels_rmpad, _ = preprocess_packed_seqs(labels, attention_mask, pre_process=True)\n labels_mask_rmpad, _ = preprocess_packed_seqs(labels_mask, attention_mask, pre_process=True)\n labels_rmpad = labels_rmpad.contiguous()\n labels_mask_rmpad = labels_mask_rmpad.contiguous()\n\n input_args = dict(\n input_ids=input_ids_rmpad,\n attention_mask=None,\n position_ids=position_ids if not vision_model else None, # vision models will calculate position_ids\n packed_seq_params=packed_seq_params,\n labels=labels_rmpad,\n temperature=temperature,\n **model_kwargs,\n )\n\n if vision_model:\n # workaround for supporting sequence packing with context parallelism\n # cp split with sequence packing will make model lose vision token information, so we need to keep\n # the original input_ids and pack them after vision embedding is calculated,\n # cooporate with mbridge\n input_args[\"input_ids\"] = input_ids\n input_args[\"attention_mask\"] = attention_mask\n\n output_orig: CausalLMOutputForPPO = model(**input_args)\n\n if post_process:\n # output_orig is in type of CausalLMOutputForPPO\n output = postprocess_packed_seqs_for_dict_output(\n labels_mask_rmpad,\n output_orig,\n packed_seq_params,\n attention_mask,\n batch_size,\n seq_len,\n post_process=post_process,\n )\n else:\n output = output_orig\n return output\n\n return fused_forward_model\n\n\ndef fused_forward_no_padding_gen(vision_model: bool = False):\n def fused_forward_no_padding(\n model,\n input_ids: Tensor,\n labels: Tensor,\n multi_modal_inputs: dict,\n temperature: float,\n calculate_entropy: bool,\n pad_token_id: int,\n ):\n pre_process = unwrap_model(model).pre_process\n post_process = unwrap_model(model).post_process\n\n input_ids_rmpad, packed_seq_params = preprocess_thd_no_padding(input_ids, pre_process=pre_process)\n input_ids_rmpad = input_ids_rmpad.contiguous()\n\n model_kwargs = {}\n if \"pixel_values\" in multi_modal_inputs:\n model_kwargs[\"pixel_values\"] = multi_modal_inputs[\"pixel_values\"].to(input_ids.device)\n if \"image_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"image_grid_thw\"] = multi_modal_inputs[\"image_grid_thw\"].to(input_ids.device)\n if \"pixel_values_videos\" in multi_modal_inputs:\n model_kwargs[\"pixel_values_videos\"] = multi_modal_inputs[\"pixel_values_videos\"].to(input_ids.device)\n if \"video_grid_thw\" in multi_modal_inputs:\n model_kwargs[\"video_grid_thw\"] = multi_modal_inputs[\"video_grid_thw\"].to(input_ids.device)\n\n attention_mask = None\n if vision_model:\n input_ids_rmpad = input_ids.to_padded_tensor(pad_token_id)\n seqlens_in_batch = input_ids.offsets().diff().to(input_ids.device)\n max_seq_len = input_ids_rmpad.shape[1]\n attention_mask = torch.arange(max_seq_len, device=input_ids.device).unsqueeze(\n 0\n ) < seqlens_in_batch.unsqueeze(1)\n\n labels_rmpad, _ = preprocess_thd_no_padding(labels, pre_process=True, need_roll=True)\n labels_rmpad = labels_rmpad.contiguous()\n output_orig: CausalLMOutputForPPO = model(\n input_ids=input_ids_rmpad,\n attention_mask=attention_mask,\n position_ids=None,\n packed_seq_params=packed_seq_params,\n labels=labels_rmpad,\n temperature=temperature,\n **model_kwargs,\n )\n\n if not post_process:\n return output_orig\n\n log_probs = output_orig.log_probs\n if log_probs.dim() == 1:\n log_probs = log_probs.unsqueeze(0)\n log_probs = postprocess_thd_no_padding(\n log_probs, packed_seq_params, input_ids, input_ids.shape[0], post_process=post_process\n )\n\n output = {\"log_probs\": log_probs}\n\n if calculate_entropy:\n entropy = output_orig.entropy\n if entropy.dim() == 1:\n entropy = entropy.unsqueeze(0)\n entropy = postprocess_thd_no_padding(\n entropy, packed_seq_params, input_ids, input_ids.shape[0], post_process=post_process\n )\n output[\"entropy\"] = entropy\n\n return output\n\n return fused_forward_no_padding\n\n\ndef _fused_GPTModel_forward(\n model,\n input_ids: Tensor,\n position_ids: Tensor,\n attention_mask: Tensor,\n decoder_input: Tensor = None,\n labels: Tensor = None,\n inference_context: BaseInferenceContext = None,\n packed_seq_params: PackedSeqParams = None,\n extra_block_kwargs: dict = None,\n runtime_gather_output: Optional[bool] = None,\n *,\n inference_params: Optional[BaseInferenceContext] = None,\n loss_mask: Optional[Tensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> CausalLMOutputForPPO:\n \"\"\"\n Patch self._postprocess in forward for GPT models to enable fused kernel support.\n https://github.com/NVIDIA/Megatron-LM/blob/core_v0.13.0/megatron/core/models/gpt/gpt_model.py\n\n TODO: Currently we still need to patch `forward` because we need to pass `temperature`\n explicitly to `self._postprocess` when calling, maybe there can be a better way to handle this?\n \"\"\"\n\n inference_context = deprecate_inference_params(inference_context, inference_params)\n\n preproc_output = model._preprocess(\n input_ids=input_ids,\n position_ids=position_ids,\n decoder_input=decoder_input,\n inference_context=inference_context,\n packed_seq_params=packed_seq_params,\n )\n\n (decoder_input, rotary_pos_emb, rotary_pos_cos, rotary_pos_sin, sequence_len_offset) = preproc_output[:5]\n\n # Run decoder.\n hidden_states = model.decoder(\n hidden_states=decoder_input,\n attention_mask=attention_mask,\n inference_context=inference_context,\n rotary_pos_emb=rotary_pos_emb,\n rotary_pos_cos=rotary_pos_cos,\n rotary_pos_sin=rotary_pos_sin,\n packed_seq_params=packed_seq_params,\n sequence_len_offset=sequence_len_offset,\n **(extra_block_kwargs or {}),\n **kwargs,\n )\n\n if not model.post_process:\n return hidden_states\n\n output = CausalLMOutputForPPO(\n loss=None,\n logits=None,\n past_key_values=None,\n hidden_states=hidden_states,\n attentions=None,\n )\n\n if model.config.sequence_parallel:\n hidden_states = gather_from_sequence_parallel_region(hidden_states)\n\n # Get the output weight - use embedding weight if output_layer is None or weight is shared\n if hasattr(model, \"output_layer\") and model.output_layer is not None and model.output_layer.weight is not None:\n output_weight = model.output_layer.weight\n else:\n # When embeddings are tied, use the embedding weight\n output_weight = model.embedding.word_embeddings.weight\n\n logprobs, entropy = linear_cross_entropy(\n hidden_states,\n output_weight,\n labels,\n temperature,\n \"none\",\n parallel_state.get_tensor_model_parallel_group(),\n )\n\n if has_config_logger_enabled(model.config):\n payload = OrderedDict(\n {\n \"input_ids\": input_ids,\n \"position_ids\": position_ids,\n \"attention_mask\": attention_mask,\n \"decoder_input\": decoder_input,\n \"logprobs\": logprobs,\n \"entropy\": entropy,\n }\n )\n log_config_to_disk(model.config, payload, prefix=\"input_and_logits\")\n\n output.entropy = entropy\n output.log_probs = logprobs\n\n return output\n"} +{"file_name": "verl__models__mcore__model_initializer.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# use mcore transformer config to initialize the model\nimport inspect\nfrom abc import ABC, abstractmethod\n\nfrom megatron.core.models.gpt.gpt_layer_specs import get_gpt_decoder_block_spec, get_gpt_mtp_block_spec\nfrom megatron.core.models.gpt.gpt_model import GPTModel\n\nfrom .config_converter import PretrainedConfig, TransformerConfig\n\n\nclass BaseModelInitializer(ABC):\n \"\"\"Base class for model initializers.\"\"\"\n\n def __init__(self, tfconfig: TransformerConfig, hf_config: PretrainedConfig):\n self.tfconfig = tfconfig\n self.hf_config = hf_config\n self.has_vp_stage = inspect.signature(get_gpt_decoder_block_spec).parameters.get(\"vp_stage\", None) is not None\n\n @abstractmethod\n def get_transformer_layer_spec(self, vp_stage=None):\n \"\"\"Get the transformer layer specification.\n https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/models/gpt/gpt_layer_specs.py\"\"\"\n pass\n\n def get_rope_scaling_args(self) -> dict:\n \"\"\"Get rope scaling args.\"\"\"\n rope_scaling_args = {}\n if \"rope_scaling\" in self.hf_config:\n if self.hf_config.rope_scaling is not None:\n # assert self.hf_config.rope_scaling[\"type\"] == \"linear\", \"only linear scaling is supported for now\"\n rope_scaling_args[\"seq_len_interpolation_factor\"] = self.hf_config.rope_scaling[\"factor\"]\n return rope_scaling_args\n\n def initialize(\n self,\n pre_process: bool = True,\n post_process: bool = True,\n share_embeddings_and_output_weights: bool = False,\n value: bool = False,\n **extra_kwargs,\n ) -> GPTModel:\n \"\"\"Initialize a GPT model with the given configuration.\n https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/models/gpt/gpt_model.py\n\n Args:\n pre_process (bool): include embedding layer.\n post_process (bool): including an output layer.\n share_embeddings_and_output_weights (bool): input embeddings and output logit weights are shared.\n value (bool): add an extra linear layer for classification or regression.\n\n Returns:\n GPTModel: An initialized GPT model instance\n \"\"\"\n vp_stage = extra_kwargs.get(\"vp_stage\", None)\n transformer_layer_spec = self.get_transformer_layer_spec(vp_stage=vp_stage)\n rope_scaling_args = self.get_rope_scaling_args()\n mtp_block_spec = extra_kwargs.get(\"mtp_block_spec\", None)\n model = GPTModel(\n config=self.tfconfig,\n transformer_layer_spec=transformer_layer_spec,\n vocab_size=self.hf_config.vocab_size,\n max_sequence_length=self.hf_config.max_position_embeddings,\n pre_process=pre_process,\n post_process=post_process,\n share_embeddings_and_output_weights=share_embeddings_and_output_weights,\n position_embedding_type=\"rope\",\n rotary_base=self.hf_config.rope_theta,\n **rope_scaling_args,\n mtp_block_spec=mtp_block_spec,\n **({} if not self.has_vp_stage else {\"vp_stage\": vp_stage}),\n )\n\n if post_process and value:\n from verl.models.llama.megatron.layers.parallel_linear import LinearForLastLayer\n\n model.output_layer = LinearForLastLayer(\n input_size=self.tfconfig.hidden_size, output_size=1, config=self.tfconfig\n )\n\n return model\n\n\nclass DenseModel(BaseModelInitializer):\n \"\"\"Initializer for dense models like Llama and Qwen2.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n assert self.tfconfig.normalization == \"RMSNorm\", \"only RMSNorm is supported for now\"\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n return get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n\n\nclass Qwen2MoEModel(BaseModelInitializer):\n \"\"\"Initializer for Qwen2 MoE models.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n assert self.tfconfig.normalization == \"RMSNorm\", \"only RMSNorm is supported for now\"\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n transformer_layer_spec = get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n\n # Patch layer spec for shared experts\n for i in range(len(transformer_layer_spec.layer_specs)):\n transformer_layer_spec.layer_specs[i].submodules.mlp.submodules.shared_experts.params[\"gate\"] = True\n\n return transformer_layer_spec\n\n def initialize(self, **kwargs):\n # Qwen default freeze_moe_router: true\n model = super().initialize(**kwargs)\n freeze_moe_router = kwargs.get(\"freeze_moe_router\", True)\n if freeze_moe_router:\n for layer in model.decoder.layers:\n layer.mlp.router.weight.requires_grad = False\n return model\n\n\nclass MixtralModel(BaseModelInitializer):\n \"\"\"Initializer for Mixtral models.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n assert self.tfconfig.normalization == \"RMSNorm\", \"only RMSNorm is supported for now\"\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n transformer_layer_spec = get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n return transformer_layer_spec\n\n def initialize(self, **kwargs):\n model = super().initialize(**kwargs)\n freeze_moe_router = kwargs.get(\"freeze_moe_router\", False)\n if freeze_moe_router:\n for layer in model.decoder.layers:\n layer.mlp.router.weight.requires_grad = False\n return model\n\n\nclass Qwen3MoEModel(BaseModelInitializer):\n \"\"\"Initializer for Qwen3 MoE models.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n assert self.tfconfig.normalization == \"RMSNorm\", \"only RMSNorm is supported for now\"\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n transformer_layer_spec = get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n return transformer_layer_spec\n\n def initialize(self, **kwargs):\n # Qwen default freeze_moe_router: true\n model = super().initialize(**kwargs)\n freeze_moe_router = kwargs.get(\"freeze_moe_router\", True)\n if freeze_moe_router:\n for layer in model.decoder.layers:\n layer.mlp.router.weight.requires_grad = False\n return model\n\n\nclass DeepseekV3Model(BaseModelInitializer):\n \"\"\"Initializer for DeepseekV3 models.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n transformer_layer_spec = get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n return transformer_layer_spec\n\n def get_rope_scaling_args(self) -> dict:\n \"\"\"Get rope scaling args.\"\"\"\n rope_scaling_args = {}\n return rope_scaling_args\n\n def initialize(\n self,\n **kwargs,\n ):\n vp_stage = kwargs.get(\"vp_stage\", None)\n freeze_moe_router = kwargs.get(\"freeze_moe_router\", True)\n if freeze_moe_router:\n self.tfconfig.moe_router_load_balancing_type = \"none\"\n # MTP\n if self.tfconfig.mtp_num_layers is not None and self.tfconfig.mtp_num_layers > 0:\n transformer_layer_spec = self.get_transformer_layer_spec(vp_stage=vp_stage)\n mtp_block_spec = get_gpt_mtp_block_spec(\n self.tfconfig, transformer_layer_spec, use_transformer_engine=True, vp_stage=vp_stage\n )\n kwargs[\"mtp_block_spec\"] = mtp_block_spec\n\n model = super().initialize(**kwargs)\n if freeze_moe_router:\n for layer in model.decoder.layers:\n if hasattr(layer.mlp, \"router\"):\n layer.mlp.router.weight.requires_grad = False\n return model\n\n\nclass Qwen25VLModel(BaseModelInitializer):\n \"\"\"Initializer for Qwen2.5 VL models.\"\"\"\n\n def get_transformer_layer_spec(self, vp_stage=None):\n extra_kwargs = {} if not self.has_vp_stage else {\"vp_stage\": vp_stage}\n transformer_layer_spec = get_gpt_decoder_block_spec(self.tfconfig, use_transformer_engine=True, **extra_kwargs)\n return transformer_layer_spec\n\n def initialize(\n self,\n pre_process=None,\n post_process=None,\n share_embeddings_and_output_weights=False,\n value=False,\n **extra_kwargs,\n ):\n tfconfig = self.tfconfig\n hf_config = self.hf_config\n # Qwen2_5_VLForConditionalGeneration\n from copy import deepcopy\n\n transformer_layer_spec = self.get_transformer_layer_spec()\n\n from megatron.core.extensions.transformer_engine import TEColumnParallelLinear, TERowParallelLinear\n from megatron.core.models.gpt.moe_module_specs import MLPSubmodules\n from megatron.core.models.vision.vit_layer_specs import get_vit_layer_with_transformer_engine_spec\n\n from .qwen2_5_vl import Qwen2_5VLModel, get_vision_model_config, get_vision_projection_config\n\n vision_transformer_config = get_vision_model_config(deepcopy(tfconfig))\n vision_transformer_config.pipeline_model_parallel_size = 1\n vision_transformer_config.first_pipeline_num_layers = None\n\n vision_projection_config = get_vision_projection_config(\n deepcopy(tfconfig),\n vision_transformer_config.hidden_size,\n spatial_merge_size=hf_config.vision_config.spatial_merge_size,\n )\n vision_projection_layer_spec = MLPSubmodules(\n linear_fc1=TEColumnParallelLinear,\n linear_fc2=TERowParallelLinear,\n )\n vision_transformer_layer_spec = get_vit_layer_with_transformer_engine_spec()\n\n qwen25_vl_model = Qwen2_5VLModel(\n language_transformer_config=tfconfig,\n language_transformer_layer_spec=transformer_layer_spec,\n language_vocab_size=hf_config.vocab_size,\n language_max_sequence_length=hf_config.max_position_embeddings,\n vision_transformer_config=vision_transformer_config,\n vision_transformer_layer_spec=vision_transformer_layer_spec,\n vision_projection_config=vision_projection_config,\n vision_projection_layer_spec=vision_projection_layer_spec,\n vision_projection_type=\"mlp\",\n language_rotary_base=hf_config.rope_theta,\n pre_process=pre_process,\n post_process=post_process,\n add_decoder=True,\n add_encoder=True,\n parallel_output=True,\n language_share_embeddings_and_output_weights=share_embeddings_and_output_weights,\n )\n\n if post_process and value:\n from verl.models.llama.megatron.layers.parallel_linear import LinearForLastLayer\n\n qwen25_vl_model.language_model.output_layer = LinearForLastLayer(\n input_size=tfconfig.hidden_size, output_size=1, config=tfconfig\n )\n\n return qwen25_vl_model\n"} +{"file_name": "verl__models__mcore__mtp_patch.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n# Copyright 2025 Meituan Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Callable\n\nimport torch\nfrom megatron.core import parallel_state\nfrom megatron.core.models.gpt.gpt_model import GPTModel\nfrom megatron.core.transformer.multi_token_prediction import (\n MTPLossAutoScaler,\n MTPLossLoggingHelper,\n roll_tensor,\n)\n\ntry:\n from megatron.core.utils import unwrap_model\nexcept ImportError:\n from verl.utils.megatron_utils import unwrap_model\n\n\ndef _get_patching_model(model: torch.nn.Module):\n model = unwrap_model(model)\n if isinstance(model, GPTModel):\n return model\n\n if not (hasattr(model, \"language_model\") and isinstance(model.language_model, GPTModel)):\n print(f\"Model {model.__class__.__name__} is not a supported for fused forward\")\n return None\n\n return model.language_model\n\n\ndef patch_postprocess(model: torch.nn.Module):\n model = _get_patching_model(model)\n if model is not None:\n model._postprocess_backup = model._postprocess\n model._postprocess = _megatron_gptmodel_postprocess.__get__(model, model.__class__)\n\n\ndef unpatch_postprocess(model: torch.nn.Module):\n model = _get_patching_model(model)\n if model is not None:\n model._postprocess = model._postprocess_backup\n\n\n# copy from https://github.com/NVIDIA/Megatron-LM/blob/23e092f41ec8bc659020e401ddac9576c1cfed7e/megatron/core/models/gpt/gpt_model.py\n# patch the postprocess method of GPTModel to support advanced features like MTP, 1f1b overlap, etc.\ndef _megatron_gptmodel_postprocess(\n self,\n hidden_states,\n input_ids,\n position_ids,\n labels,\n rotary_pos_emb,\n rotary_pos_cos,\n rotary_pos_sin,\n mtp_in_postprocess=None,\n loss_mask=None,\n decoder_input=None,\n attention_mask=None,\n inference_params=None,\n packed_seq_params=None,\n sequence_len_offset=None,\n runtime_gather_output=None,\n extra_block_kwargs=None,\n inference_context=None,\n):\n \"\"\"Postprocesses decoder hidden states to generate logits or compute loss.\n\n Applies Multi-Token Prediction if enabled, generates output logits through\n the output layer, and computes language model loss when labels are provided.\n \"\"\"\n\n # logits and loss\n output_weight = None\n if self.share_embeddings_and_output_weights:\n output_weight = self.shared_embedding_or_output_weight()\n\n if mtp_in_postprocess and labels is not None:\n hidden_states = self.mtp(\n input_ids=input_ids,\n position_ids=position_ids,\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n inference_params=inference_params,\n rotary_pos_emb=rotary_pos_emb,\n rotary_pos_cos=rotary_pos_cos,\n rotary_pos_sin=rotary_pos_sin,\n packed_seq_params=packed_seq_params,\n sequence_len_offset=sequence_len_offset,\n embedding=self.embedding,\n **(extra_block_kwargs or {}),\n )\n\n if not self.post_process:\n return hidden_states\n\n # Skip when mtp_num_layers is None or 0\n if self.config.mtp_num_layers and labels is not None:\n mtp_labels = labels.clone()\n\n hidden_states_list = torch.chunk(hidden_states, 1 + self.config.mtp_num_layers, dim=0)\n hidden_states = hidden_states_list[0]\n if loss_mask is None:\n # if loss_mask is not provided, use all ones as loss_mask\n loss_mask = torch.ones_like(mtp_labels)\n for mtp_layer_number in range(self.config.mtp_num_layers):\n # Calc loss for the current Multi-Token Prediction (MTP) layers.\n mtp_labels, _ = roll_tensor(\n mtp_labels,\n shifts=-1,\n dims=-1,\n cp_group=self.cp_group,\n packed_seq_params=packed_seq_params,\n )\n loss_mask, num_tokens = roll_tensor(\n loss_mask,\n shifts=-1,\n dims=-1,\n cp_group=self.cp_group,\n packed_seq_params=packed_seq_params,\n )\n\n # Compute mtp loss without storing logits to save memory.\n mtp_loss = self.compute_output_layer_and_language_model_loss(\n hidden_states_list[mtp_layer_number + 1],\n labels=mtp_labels,\n weight=self.shared_embedding_or_output_weight(),\n sequence_parallel_enabled=self.output_layer.sequence_parallel,\n column_parallel_linear=self.output_layer,\n col_linear_kwargs={\n \"weight\": output_weight,\n \"runtime_gather_output\": runtime_gather_output,\n },\n )\n\n mtp_loss = loss_mask * mtp_loss\n if self.training:\n # TODO(shifangx): remove the use of parallel_state here\n # after moving loss logging to loss_func in pretrain_gpt.py\n MTPLossLoggingHelper.save_loss_to_tracker(\n torch.sum(mtp_loss) / num_tokens,\n mtp_layer_number,\n self.config.mtp_num_layers,\n avg_group=parallel_state.get_data_parallel_group(with_context_parallel=True),\n )\n mtp_loss_scale = self.config.mtp_loss_scaling_factor / self.config.mtp_num_layers\n if self.config.calculate_per_token_loss:\n hidden_states = MTPLossAutoScaler.apply(hidden_states, mtp_loss_scale * mtp_loss)\n else:\n hidden_states = MTPLossAutoScaler.apply(hidden_states, mtp_loss_scale * mtp_loss / num_tokens)\n\n logits, _ = self.output_layer(hidden_states, weight=output_weight, runtime_gather_output=runtime_gather_output)\n # [s b h] => [b s h]\n return logits.transpose(0, 1).contiguous()\n\n\ndef patch_mtp_layer_get_embeddings(model: torch.nn.Module):\n \"\"\"Patch the _get_embeddings method of MultiTokenPredictionLayer\"\"\"\n from megatron.core.models.gpt.gpt_model import GPTModel\n from megatron.core.transformer.multi_token_prediction import MultiTokenPredictionLayer\n\n # Unwrap each model in the actor_module to get the actual GPTModel\n model = _get_patching_model(model)\n # Collect all MultiTokenPredictionLayer instances\n target_layers = []\n\n if isinstance(model, GPTModel):\n # Check if GPTModel has MTP and find the layers\n if hasattr(model, \"mtp\") and hasattr(model.mtp, \"layers\"):\n for layer in model.mtp.layers:\n if isinstance(layer, MultiTokenPredictionLayer):\n target_layers.append(layer)\n elif hasattr(model, \"layers\"):\n # Check if any layer in the model is MultiTokenPredictionLayer\n for layer in model.layers:\n if isinstance(layer, MultiTokenPredictionLayer):\n target_layers.append(layer)\n\n if target_layers:\n for layer in target_layers:\n layer._get_embeddings_backup = layer._get_embeddings\n layer._get_embeddings = _patched_get_embeddings_for_detach.__get__(layer, layer.__class__)\n print(f\"Found and patched {len(target_layers)} MTP layer(s) in any of the actor modules\")\n return True\n else:\n print(\"No MTP layers found to patch in any of the actor modules\")\n return False\n\n\ndef unpatch_mtp_layer_get_embeddings(model: torch.nn.Module):\n \"\"\"Unpatch the _get_embeddings method of MultiTokenPredictionLayer\"\"\"\n from megatron.core.models.gpt.gpt_model import GPTModel\n from megatron.core.transformer.multi_token_prediction import MultiTokenPredictionLayer\n\n # Unwrap each model in the actor_module to get the actual GPTModel\n model = _get_patching_model(model)\n\n # Collect all MultiTokenPredictionLayer instances\n target_layers = []\n\n if isinstance(model, GPTModel):\n # Check if GPTModel has MTP and find the layers\n if hasattr(model, \"mtp\") and hasattr(model.mtp, \"layers\"):\n for layer in model.mtp.layers:\n if isinstance(layer, MultiTokenPredictionLayer):\n target_layers.append(layer)\n elif hasattr(model, \"layers\"):\n # Check if any layer in the model is MultiTokenPredictionLayer\n for layer in model.layers:\n if isinstance(layer, MultiTokenPredictionLayer):\n target_layers.append(layer)\n\n unpatched_count = 0\n for layer in target_layers:\n if hasattr(layer, \"_get_embeddings_backup\"):\n layer._get_embeddings = layer._get_embeddings_backup\n delattr(layer, \"_get_embeddings_backup\")\n unpatched_count += 1\n\n if unpatched_count > 0:\n print(f\"Unpatched {unpatched_count} MTP layer(s)\")\n return True\n return False\n\n\ndef _patched_get_embeddings_for_detach(\n self,\n input_ids: torch.Tensor,\n position_ids: torch.Tensor,\n embedding: Callable,\n hidden_states: torch.Tensor,\n packed_seq_params=None,\n):\n \"\"\"\n Patched version of _get_embeddings method for MultiTokenPredictionLayer.\n\n This is a modified version that you can customize according to your needs.\n The original implementation is preserved below with modifications.\n \"\"\"\n\n # You can modify the logic here as needed\n # For example, you could:\n # - Change the shift amount in roll_tensor\n # - Apply custom transformations to input_ids or position_ids\n # - Add debugging information\n # - Modify the embedding computation\n\n # Original logic with custom modifications\n from megatron.core.transformer.multi_token_prediction import roll_tensor\n from megatron.core.utils import make_viewless_tensor\n\n # Calc logits for the current Multi-Token Prediction (MTP) layers.\n input_ids, _ = roll_tensor(\n input_ids,\n shifts=-1, # You can modify this shift value\n dims=-1,\n cp_group=self.cp_group,\n packed_seq_params=packed_seq_params,\n )\n position_ids, _ = roll_tensor(\n position_ids,\n shifts=-1, # You can modify this shift value\n dims=-1,\n cp_group=self.cp_group,\n packed_seq_params=packed_seq_params,\n )\n\n # embedding computation - you can modify this part\n decoder_input = embedding(input_ids=input_ids, position_ids=position_ids)\n\n # Apply custom transformations if needed\n # For example: decoder_input = some_custom_function(decoder_input)\n\n hidden_states = make_viewless_tensor(inp=hidden_states, requires_grad=True, keep_graph=True)\n\n # detach decoder_input and hidden_states\n decoder_input = decoder_input.detach()\n hidden_states = hidden_states.detach()\n\n return input_ids, position_ids, decoder_input, hidden_states\n"} +{"file_name": "verl__models__mcore__patch.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# there is some bug in mcore 0.12, so we need to patch it\n# 1. `get_query_key_value_tensors` in `multi_latent_attention.py` works wrong when packed_seq_params is not None\n\n\ndef apply_patch():\n import megatron.core\n import torch\n import torch.nn.functional as F\n from megatron.core import parallel_state, tensor_parallel\n from megatron.core.transformer.multi_latent_attention import (\n MLASelfAttention,\n MultiLatentAttention,\n apply_rotary_pos_emb,\n deprecate_inference_params,\n gather_from_sequence_parallel_region,\n gather_from_tensor_model_parallel_region,\n scatter_to_sequence_parallel_region,\n )\n from packaging import version\n\n mcore_ge_013 = version.parse(megatron.core.__version__) >= version.parse(\"0.13.0\")\n\n def patch_get_query_key_value_tensors(\n self,\n hidden_states,\n key_value_states=None,\n position_ids=None,\n packed_seq_params=None,\n inference_context=None,\n *,\n inference_params=None,\n ):\n \"\"\"\n Derives `query`, `key` and `value` tensors from `hidden_states`.\n \"\"\"\n # s = sequence length, b = batch size, h = hidden size, n = num attention heads\n # Attention heads [s, b, n*h]\n assert hidden_states.ndim == 3, f\"hidden_states should be 3D, [s, b, n*h], got {hidden_states.ndim}D\"\n\n inference_context = deprecate_inference_params(inference_context, inference_params)\n\n # =========================================\n # Prepare RoPE and seqlen related params\n # =========================================\n rotary_seq_len = self.rotary_pos_emb.get_rotary_seq_len(\n inference_context, None, hidden_states, self.config, packed_seq_params\n )\n\n # rotary_pos_emb:[s, b, 1, 64]\n mscale = 1.0\n if self.config.rope_type == \"rope\":\n packed_seq = packed_seq_params is not None and packed_seq_params.qkv_format == \"thd\"\n try:\n # In case of TypeError: RotaryEmbedding.forward() got an unexpected keyword argument 'packed_seq'\n rotary_pos_emb = self.rotary_pos_emb(rotary_seq_len, packed_seq=packed_seq)\n except TypeError:\n rotary_pos_emb = self.rotary_pos_emb(rotary_seq_len)\n else:\n rotary_pos_emb, mscale = self.rotary_pos_emb(rotary_seq_len)\n\n # =========================================\n # QKV down projection and layernorm\n # =========================================\n if self.config.q_lora_rank is not None:\n # if linear_q_down_proj is ColumnParallelLinear:\n # q_compressed: [s, b, q_lora_rank / TP]\n # elif linear_q_down_proj is Linear:\n # q_compressed: [s / TP, b, q_lora_rank]\n q_compressed, _ = self.linear_q_down_proj(hidden_states)\n\n # When output is sharded (ColumnParallelLinear), two things are needed to be\n # identical to a normal Linear.\n # 1. Manually gather output to restore output dim q_lora_rank;\n # 2. Scatter sequence back to s / TP if sequence-parallel since it was\n # gathered by ColumnParallelLinear.\n if q_compressed.size(-1) != self.config.q_lora_rank:\n q_compressed = gather_from_tensor_model_parallel_region(q_compressed)\n if self.config.sequence_parallel:\n q_compressed = scatter_to_sequence_parallel_region(q_compressed)\n\n q_compressed = self.q_layernorm(q_compressed)\n else:\n q_compressed = hidden_states\n\n # if linear_kv_down_proj is ColumnParallelLinear:\n # kv_combined: [s, b, (kv_lora_rank + qk_pos_emb_head_dim) / TP]\n # elif linear_kv_down_proj is Linear:\n # kv_combined: [s / TP, b, (kv_lora_rank + qk_pos_emb_head_dim)]\n kv_combined, _ = self.linear_kv_down_proj(hidden_states)\n if kv_combined.size(-1) != self.config.kv_lora_rank + self.config.qk_pos_emb_head_dim:\n # kv_combined: [s, b, (kv_lora_rank + qk_pos_emb_head_dim)]\n kv_combined = gather_from_tensor_model_parallel_region(kv_combined)\n # kv_compressed:[s, b, kv_lora_rank], k_pos_emb: [s, b, qk_pos_emb_head_dim]\n kv_compressed, k_pos_emb = torch.split(\n kv_combined, [self.config.kv_lora_rank, self.config.qk_pos_emb_head_dim], dim=-1\n )\n if self.config.sequence_parallel:\n # kv_compressed:[s / TP, b, kv_lora_rank]\n kv_compressed = scatter_to_sequence_parallel_region(kv_compressed)\n else:\n # kv_compressed:[s / TP, b, kv_lora_rank], k_pos_emb: [s / TP, b, qk_pos_emb_head_dim]\n kv_compressed, k_pos_emb = torch.split(\n kv_combined, [self.config.kv_lora_rank, self.config.qk_pos_emb_head_dim], dim=-1\n )\n if parallel_state.get_tensor_model_parallel_world_size() > 1:\n # k_pos_emb: [s, b, qk_pos_emb_head_dim]\n k_pos_emb = gather_from_sequence_parallel_region(k_pos_emb)\n\n kv_compressed = self.kv_layernorm(kv_compressed)\n\n # =========================================\n # QKV up projection and RoPE apply\n # =========================================\n def qkv_up_proj_and_rope_apply(q_compressed, kv_compressed, k_pos_emb, rotary_pos_emb):\n if self.config.q_lora_rank is not None:\n q, _ = self.linear_q_up_proj(q_compressed)\n else:\n # hidden_states:[s, b, 2048], q: [s, b, n * 192]\n q, _ = self.linear_q_proj(q_compressed)\n\n q_len, bsz, _ = q.size()\n\n # q: [s, b, n, 192]\n q = q.view(q_len, bsz, self.num_attention_heads_per_partition, self.q_head_dim)\n\n # kv: [s, b, 2048]\n kv, _ = self.linear_kv_up_proj(kv_compressed)\n\n # kv: [s, b, n, 256]\n kv = kv.view(\n q_len,\n bsz,\n self.num_attention_heads_per_partition,\n self.config.qk_head_dim + self.config.v_head_dim,\n )\n\n cp_size = parallel_state.get_context_parallel_world_size()\n if inference_context is not None:\n # add offset to the sequence start for inference\n sequence_start = inference_context.sequence_len_offset\n sequence_end = sequence_start + q_len\n rotary_pos_emb = rotary_pos_emb[sequence_start:sequence_end]\n elif packed_seq_params is None or cp_size == 1:\n # Shorten rotary_pos_emb to the sequence length when inference_params\n # is not provided. This makes sure we can run forward directly with\n # any sequence length. During training, the sequence length is always\n # the full rotary_pos_emb length, except for sequence packing + CP.\n # When sequence packing and context parallel are both enabled, the\n # position embedding will not split rotary_pos_emb, so it may exceed\n # the sequence length on this CP rank, but we need the full rotary_pos_emb\n # to cover the full sequence, so we do not shorten it here.\n rotary_pos_emb = rotary_pos_emb[0:q_len]\n\n # [s, b, 64] -> [s, b, 1, 64]\n k_pos_emb = torch.unsqueeze(k_pos_emb, 2)\n\n # q: [s, b, n, 128], q_pos_emb: [s, b, n, 64]\n q_no_pe, q_pos_emb = torch.split(q, [self.config.qk_head_dim, self.config.qk_pos_emb_head_dim], dim=-1)\n\n # k_no_pe: [s, b, n, 128], value: [s, b, n, 128]\n k_no_pe, value = torch.split(kv, [self.config.qk_head_dim, self.config.v_head_dim], dim=-1)\n\n if packed_seq_params is not None:\n cu_seqlens_q = packed_seq_params.cu_seqlens_q\n cu_seqlens_kv = packed_seq_params.cu_seqlens_kv\n q_pos_emb = q_pos_emb.squeeze(1)\n k_pos_emb = k_pos_emb.squeeze(1)\n q_no_pe = q_no_pe.squeeze(1)\n k_no_pe = k_no_pe.squeeze(1)\n value = value.squeeze(1)\n else:\n cu_seqlens_q = cu_seqlens_kv = None\n\n # q_pos_emb: [s, b, n, 64], k_pos_emb:[s, b, 1, 64]\n q_pos_emb = apply_rotary_pos_emb(\n q_pos_emb,\n rotary_pos_emb,\n config=self.config,\n cu_seqlens=cu_seqlens_q,\n mscale=mscale,\n )\n k_pos_emb = apply_rotary_pos_emb(\n k_pos_emb,\n rotary_pos_emb,\n config=self.config,\n cu_seqlens=cu_seqlens_kv,\n mscale=mscale,\n )\n\n # query: [s, b, n, 192]\n query = torch.cat([q_no_pe, q_pos_emb], dim=-1)\n if packed_seq_params is not None:\n k_pos_emb = k_pos_emb.expand(-1, self.num_attention_heads_per_partition, -1)\n key = torch.cat([k_no_pe, k_pos_emb], dim=-1)\n else:\n # key: [s, b, n, 192]\n k_pos_emb = k_pos_emb.expand(-1, -1, self.num_attention_heads_per_partition, -1)\n key = torch.cat([k_no_pe, k_pos_emb], dim=-1)\n\n query = query.contiguous()\n key = key.contiguous()\n value = value.contiguous()\n return query, key, value\n\n if self.recompute_up_proj:\n self.qkv_up_checkpoint = tensor_parallel.CheckpointWithoutOutput()\n query, key, value = self.qkv_up_checkpoint.checkpoint(\n qkv_up_proj_and_rope_apply, q_compressed, kv_compressed, k_pos_emb, rotary_pos_emb\n )\n else:\n query, key, value = qkv_up_proj_and_rope_apply(q_compressed, kv_compressed, k_pos_emb, rotary_pos_emb)\n\n return query, key, value\n\n def patch_forward(\n self,\n hidden_states,\n attention_mask,\n key_value_states=None,\n inference_context=None,\n rotary_pos_emb=None,\n rotary_pos_cos=None,\n rotary_pos_sin=None,\n attention_bias=None,\n packed_seq_params=None,\n position_ids=None,\n sequence_len_offset=None,\n *,\n inference_params=None,\n **kwargs,\n ):\n \"\"\"Forward pass for multi-latent attention\"\"\"\n assert attention_bias is None, \"Attention bias should not be passed into MLA.\"\n assert rotary_pos_cos is None and rotary_pos_sin is None, \"MLA does not support Flash Decoding\"\n\n # hidden_states: [sq, b, h]\n\n inference_context = deprecate_inference_params(inference_context, inference_params)\n\n # =====================\n # Query, Key, and Value\n # =====================\n # Get the query, key and value tensors based on the type of attention -\n # self or cross attn.\n # query: [96, 1, 16, 128], key:[96, 1, 16, 128], value:[96, 1, 16, 128]\n query, key, value = self.get_query_key_value_tensors(\n hidden_states,\n key_value_states,\n position_ids,\n packed_seq_params,\n inference_context=inference_context,\n )\n\n # ===================================================\n # Adjust key, value for inference\n # ===================================================\n # rotary_pos_emb = None\n if mcore_ge_013:\n query, key, value, _, attn_mask_type, _ = self._adjust_key_value_for_inference(\n inference_context, query, key, value, rotary_pos_emb=None\n )\n else:\n query, key, value, _, attn_mask_type = self._adjust_key_value_for_inference(\n inference_context, query, key, value, rotary_pos_emb=None\n )\n\n # TODO: Currently, TE can only accept contiguous tensors for MLA\n query = query.contiguous()\n key = key.contiguous()\n value = value.contiguous()\n\n # ==================================\n # core attention computation\n # ==================================\n # Need corresponding TE change\n thd_qkv_format = packed_seq_params and packed_seq_params.qkv_format == \"thd\"\n v_dim = value.shape[-1]\n if thd_qkv_format and query.shape[-1] != v_dim:\n value = F.pad(value, [0, query.shape[-1] - v_dim])\n self.core_attention.hidden_size_per_attention_head_v = value.shape[-1]\n if self.checkpoint_core_attention and self.training:\n core_attn_out = self._checkpointed_attention_forward(\n query, key, value, attention_mask, packed_seq_params=packed_seq_params\n )\n else:\n core_attn_out = self.core_attention(\n query,\n key,\n value,\n attention_mask,\n packed_seq_params=packed_seq_params,\n attn_mask_type=attn_mask_type,\n )\n if thd_qkv_format:\n if core_attn_out.ndim == 2:\n core_attn_out = core_attn_out.reshape(*core_attn_out.shape[:-1], -1, value.shape[-1])\n if query.shape[-1] != v_dim:\n core_attn_out = core_attn_out[..., :v_dim]\n # reshape to same output shape as unpacked case\n # (t, np, hn) -> (t, b=1, h=np*hn)\n # t is the pack size = sum (sq_i)\n # note that batch is a dummy dimension in the packed case\n core_attn_out = core_attn_out.reshape(core_attn_out.size(0), 1, -1)\n\n if self.recompute_up_proj:\n assert self.qkv_up_checkpoint is not None\n self.qkv_up_checkpoint.discard_output_and_register_recompute(core_attn_out)\n self.qkv_up_checkpoint = None\n\n # =================\n # Output. [sq, b, h]\n # =================\n output, bias = self.linear_proj(core_attn_out)\n\n return output, bias\n\n MLASelfAttention.get_query_key_value_tensors = patch_get_query_key_value_tensors\n\n MultiLatentAttention.forward = patch_forward\n\n\ndef apply_patch_mbridge():\n try:\n from megatron.core.utils import get_tensor_model_parallel_group_if_none\n except ImportError:\n import warnings\n\n import megatron.core.utils\n import torch\n from megatron.core import parallel_state\n\n def get_tensor_model_parallel_group_if_none(tp_group, is_expert=False, check_initialized=True):\n \"\"\"Issue a deprecation warning if tp_group is None and return the default tp group.\"\"\"\n if not torch.distributed.is_initialized():\n return None\n if tp_group is None:\n if torch.distributed.is_initialized() and torch.distributed.get_rank() == 0:\n warnings.warn(\n \"Warning: tp_group is None, using default tp group. Passing tp_group will be mandatory soon\",\n DeprecationWarning,\n stacklevel=2,\n )\n if is_expert:\n tp_group = parallel_state.get_expert_tensor_parallel_group(check_initialized=check_initialized)\n else:\n tp_group = parallel_state.get_tensor_model_parallel_group(check_initialized=check_initialized)\n return tp_group\n\n megatron.core.utils.get_tensor_model_parallel_group_if_none = get_tensor_model_parallel_group_if_none\n"} +{"file_name": "verl__models__mcore__qwen2_5_vl__model.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright (c) 2024 Alibaba PAI Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport logging\n\nimport torch\nfrom megatron.core import InferenceParams, mpu, tensor_parallel\nfrom megatron.core.models.gpt.gpt_model import GPTModel\n\n# from .transformer_config import Qwen2VLTransformerConfig\nfrom megatron.core.packed_seq_params import PackedSeqParams\nfrom megatron.core.transformer import MegatronModule\nfrom megatron.core.transformer.spec_utils import ModuleSpec\nfrom megatron.core.transformer.transformer_config import TransformerConfig\n\nfrom verl.models.mcore.util import preprocess_packed_seqs\n\nfrom .attention import Qwen2_5VLSelfAttention\nfrom .vision_model import Qwen2_5VisionModel\n\n\n# Note: This is under development and may be missing features.\nclass Qwen2_5VLModel(MegatronModule):\n \"\"\"Qwen2.5VL multi-modal model.\n\n Args:\n language_transformer_config (TransformerConfig): Transformer config for the language model.\n language_transformer_layer_spec (ModuleSpec): Specifies module to use for transformer layers of the\n language model.\n language_vocab_size (int): Language model vocabulary size.\n language_max_sequence_length (int): Language model maximum sequence length. This is used for\n positional embedding.\n vision_transformer_config (TransformerConfig): Transformer config for the vision model.\n vision_transformer_layer_spec (ModuleSpec): Specifies module to use for transformer layers of the\n vision model.\n vision_projection_config (TransformerConfig): Config for the projection from vision model outputs to\n language model inputs.\n vision_projection_layer_spec (ModuleSpec): Specifies the module to use for the vision\n projection.\n vision_projection_type (str): Type of the vision projection to use. Default is a 2-layer MLP.\n parallel_output (bool): Do not gather the outputs, keep them split across tensor parallel ranks. This\n is typically True for training and False for inference.\n language_rotary_percent (float): Percent of rotary dimension to use for rotary position embeddings\n in the language model. Defaults to 1.0.\n pre_process (bool): Include the embedding layer in the gpt decoder (used with pipeline parallelism).\n Defaults to True.\n post_process (bool): Include an output layer and a layernorm in the gpt decoder (used with pipeline\n parallelism). Defaults to True.\n add_encoder (bool): Construct the encoder module (used with pipeline parallelism). Defaults to True.\n When we use pipelining, the encoder\n will live on only a subset of the pipeline stages (specifically, only the first stage).\n add_decoder (bool): Construct the decoder module (used with pipeline parallelism). Defaults to True.\n When we use pipelining, the decoder\n will live on only a subset of the pipeline stages (specifically, every stage after the first one).\n img_h (int): The height of each image that the ViT will see.\n img_w (int): The width of each image that the ViT will see.\n patch_dim (int): The size of each patch side.\n img_embedding_idx (int): Index in the language_embeddings tensor where image_embeddings should be\n inserted. Defaults to 0.\n \"\"\"\n\n def __init__(\n self,\n language_transformer_config: TransformerConfig,\n language_transformer_layer_spec: ModuleSpec,\n language_vocab_size: int,\n language_max_sequence_length: int,\n vision_transformer_config: TransformerConfig,\n vision_transformer_layer_spec: ModuleSpec,\n vision_projection_config: TransformerConfig,\n vision_projection_layer_spec: ModuleSpec,\n vision_projection_type: str = \"mlp\",\n parallel_output: bool = True,\n language_rotary_percent: float = 1.0,\n pre_process: bool = True,\n post_process: bool = True,\n add_encoder: bool = True,\n add_decoder: bool = True,\n language_rotary_base: int = 10000,\n fp16_lm_cross_entropy: bool = False,\n language_share_embeddings_and_output_weights: bool = False,\n image_token_id: int = 151655,\n video_token_id: int = 151656,\n ) -> None:\n super().__init__(config=language_transformer_config)\n\n # patch self_attention to use qwen2_5_vl attention\n vision_transformer_layer_spec.submodules.self_attention.module = Qwen2_5VLSelfAttention\n for layer_spec in language_transformer_layer_spec.layer_specs:\n layer_spec.submodules.self_attention.module = Qwen2_5VLSelfAttention\n\n logging.getLogger(__name__).warning(\"Qwen2VL model is under development and may be missing features.\")\n\n self.pre_process = pre_process\n self.post_process = post_process\n self.add_encoder = add_encoder\n self.add_decoder = add_decoder\n\n self.encoder_hidden_state = None\n self.vision_model = None\n self.vision_projection = None\n self.language_model = None\n self.image_token_id = image_token_id\n self.video_token_id = video_token_id\n\n self.square_merge_size = vision_projection_config.ffn_hidden_size // vision_transformer_config.hidden_size\n\n # This attribute is needed to check if an all-reduce is required\n # on the word embeddings inside `finalize_model_grads._allreduce_word_embedding_grads`.\n self.share_embeddings_and_output_weights = False\n if self.pre_process:\n self.vision_model = Qwen2_5VisionModel(\n vision_transformer_config,\n vision_transformer_layer_spec,\n vision_projection_config,\n vision_projection_layer_spec,\n projection_type=vision_projection_type,\n pre_process=True,\n post_process=True,\n )\n\n self.language_model = GPTModel(\n config=language_transformer_config,\n transformer_layer_spec=language_transformer_layer_spec,\n vocab_size=language_vocab_size,\n max_sequence_length=language_max_sequence_length,\n parallel_output=parallel_output,\n position_embedding_type=\"mrope\",\n rotary_percent=language_rotary_percent,\n pre_process=self.pre_process,\n post_process=self.post_process,\n rotary_base=language_rotary_base,\n fp16_lm_cross_entropy=fp16_lm_cross_entropy,\n share_embeddings_and_output_weights=language_share_embeddings_and_output_weights,\n scatter_embedding_sequence_parallel=False,\n )\n assert mpu.get_context_parallel_world_size() <= 1, \"please use mbridge for qwen2_5_vl with context parallelism\"\n self.share_embeddings_and_output_weights = self.language_model.share_embeddings_and_output_weights\n\n def shared_embedding_or_output_weight(self):\n \"\"\"This is a convenience method to surface the language model's word embeddings, which is\n necessary for `finalize_model_grads._allreduce_word_embedding_grads`.\"\"\"\n if self.add_decoder:\n return self.language_model.shared_embedding_or_output_weight()\n return None\n\n def set_input_tensor(self, input_tensor) -> None:\n # This is usually handled in schedules.py but some inference code still\n # gives us non-lists or None\n if not isinstance(input_tensor, list):\n input_tensor = [input_tensor]\n assert len(input_tensor) == 1, \"input_tensor should only be length 1 for Qwen2VL\"\n\n if self.pre_process:\n self.encoder_hidden_state = input_tensor[0]\n else:\n self.language_model.set_input_tensor(input_tensor[0])\n\n def freeze(self, freeze_language_model: bool, freeze_vision_model: bool, freeze_vision_projection: bool):\n \"\"\"Freeze model modules.\n\n Make specific modules non-trainable by setting requires_grad to False for the module's parameters.\n\n Args:\n freeze_language_model (bool): Freeze the language model module.\n freeze_vision_model (bool): Freeze the vision model module.\n freeze_vision_projection (bool): Freeze the vision projection module.\n \"\"\"\n modules = []\n if freeze_language_model and self.language_model is not None:\n modules.append(self.language_model)\n if freeze_vision_model and self.vision_model is not None:\n modules.append(self.vision_model)\n if freeze_vision_projection and self.vision_projection is not None:\n modules.append(self.vision_projection)\n\n for module in modules:\n for param in module.parameters():\n param.requires_grad = False\n\n def forward(\n self,\n input_ids: torch.Tensor,\n position_ids: torch.Tensor,\n attention_mask: torch.Tensor = None,\n labels: torch.Tensor = None,\n inference_params: InferenceParams = None,\n packed_seq_params: PackedSeqParams = None,\n extra_block_kwargs: dict = None,\n pixel_values: torch.Tensor = None,\n pixel_values_videos: torch.Tensor = None,\n image_grid_thw: torch.Tensor = None,\n video_grid_thw: torch.Tensor = None,\n **kwargs,\n ) -> torch.Tensor:\n \"\"\"Forward function of the Qwen2VL model.\n ### there is a workaround for supporting sequence packing with context parallelism\n # cp split with sequence packing will make model lose vision token information, so we need to keep\n # the original input_ids and pack them after vision embedding is calculated,\n # cooporate with verl's models/mcore/model_forward.py\n # pack the combined_embeddings to thd here, we check if packed_seq_params is None to determine if\n # we need to pack the combined_embeddings to thd\n # this function needs the position_ids and attention_mask in BSHD format, no matter use packed_seq or not\n\n Args:\n image_data (torch.Tensor): input image of shape [total_thw_size, n_features].\n input_ids (torch.Tensor): input text ids [batch, text_seq_len].\n position_ids (torch.Tensor): input text position ids [batch, text_seq_len].\n attention_mask (torch.Tensor): attention mask for the language model [batch, 1, combined_seq_len,\n combined_seq_len].\n labels (torch.Tensor): Optional target text labels [batch, combined_seq_len].\n inference_params (InferenceParams): Inference-time parameters including KV cache.\n\n video_start_index:\n 0 -- all video\n len(video_seq) -- all image\n others -- mixture\n *_input_mask: should not be None in the first PP stage\n Returns:\n output (torch.Tensor): Loss of shape [b, s] if labels are provided, otherwise logits of shape\n [b, s, vocab_size].\n \"\"\"\n video_start_index = 0\n vision_grid_thw = None\n vision_data = None\n if image_grid_thw is not None:\n image_mask = input_ids == self.image_token_id\n vision_grid_thw = image_grid_thw\n vision_data = pixel_values\n video_start_index = image_mask.sum().item()\n if video_grid_thw is not None:\n video_mask = input_ids == self.video_token_id\n if vision_grid_thw is not None:\n vision_grid_thw = torch.cat([vision_grid_thw, video_grid_thw], dim=0)\n vision_data = torch.cat([vision_data, pixel_values_videos], dim=0)\n else:\n vision_grid_thw = video_grid_thw\n vision_data = pixel_values_videos\n use_inference_kv_cache = (\n inference_params is not None and \"image_tokens_count\" in inference_params.key_value_memory_dict\n )\n if use_inference_kv_cache:\n raise NotImplementedError()\n\n if self.pre_process:\n vision_embeds = None\n if vision_grid_thw is not None and vision_grid_thw.shape[0] > 0:\n vision_embeds = self.vision_model(\n vision_data=vision_data, # If None, vision model should use intermediate outputs (EPP > 1)\n grid_thw=vision_grid_thw, # should provided in each EPP stage\n )\n\n # If running inference, the language model KV cache will be updated for image token positions.\n # Here we store the image tokens sequence length, which can be used as an offset to the KV cache later.\n if inference_params is not None:\n raise NotImplementedError()\n # inference_params.key_value_memory_dict[\"image_tokens_count\"] = (\n # vision_embeddings.shape[0]\n # )\n\n # If running inference, we can skip image token computation if they were computed already earlier\n # for this sample.\n if use_inference_kv_cache:\n language_embeddings: torch.Tensor = self.language_model.embedding(\n input_ids=input_ids,\n position_ids=None, # NOTE: disable\n ) # [text_seq_len, b, h_language]\n # NOTE: why not cat here? is it the combined embeddings useless?\n combined_embeddings = language_embeddings\n elif vision_embeds is not None:\n if video_start_index == 0:\n image_embeds = None\n video_embeds = vision_embeds\n elif video_start_index == vision_embeds.shape[0]:\n image_embeds = vision_embeds\n video_embeds = None\n elif 0 < video_start_index < vision_embeds.shape[0]:\n image_embeds = vision_embeds[:video_start_index]\n video_embeds = vision_embeds[video_start_index:]\n else:\n raise ValueError(\n f\"Expect video token start index in range [0, {vision_embeds.shape[0]}], but got \"\n f\"{video_start_index}\"\n )\n\n combined_embeddings = self.language_model.embedding(\n input_ids=input_ids,\n position_ids=None, # NOTE: disable\n ) # [text_seq_len, b, h_language]\n\n if image_embeds is not None or video_embeds is not None:\n combined_embeddings = combined_embeddings.transpose(0, 1).contiguous()\n if image_embeds is not None:\n image_mask = (input_ids == self.image_token_id).contiguous()\n if image_mask.sum() > 0:\n combined_embeddings = combined_embeddings.clone()\n combined_embeddings[image_mask] = image_embeds.to(\n dtype=combined_embeddings.dtype, device=combined_embeddings.device\n )\n if video_embeds is not None:\n video_mask = (input_ids == self.video_token_id).contiguous()\n if video_mask.sum() > 0:\n combined_embeddings = combined_embeddings.clone()\n combined_embeddings[video_mask] = video_embeds.to(\n dtype=combined_embeddings.dtype, device=combined_embeddings.device\n )\n combined_embeddings = combined_embeddings.transpose(0, 1).contiguous()\n\n else:\n combined_embeddings = self.language_model.embedding(\n input_ids=input_ids,\n position_ids=None, # NOTE: disable\n ) # [text_seq_len, b, h_language]\n\n if packed_seq_params is not None:\n combined_embeddings = (\n preprocess_packed_seqs(\n combined_embeddings.transpose(0, 1).contiguous(), attention_mask, pre_process=True\n )[0]\n .transpose(0, 1)\n .contiguous()\n )\n if self.config.sequence_parallel:\n combined_embeddings = tensor_parallel.scatter_to_sequence_parallel_region(combined_embeddings)\n combined_embeddings = combined_embeddings.contiguous()\n else:\n combined_embeddings = None\n from .rope_utils import get_rope_index\n\n # BSHD\n position_ids, _ = get_rope_index(\n input_ids,\n image_grid_thw=image_grid_thw,\n video_grid_thw=video_grid_thw,\n attention_mask=attention_mask,\n )\n # THD\n if packed_seq_params is not None:\n position_ids = (\n preprocess_packed_seqs(position_ids.permute(1, 2, 0), attention_mask, pre_process=True)[0]\n .permute(2, 0, 1)\n .contiguous()\n )\n attention_mask = None\n\n output = self.language_model(\n input_ids=None,\n position_ids=position_ids, # None in encoder\n attention_mask=attention_mask, # None in encoder\n decoder_input=combined_embeddings, # only not None in the first decoder PP stage\n labels=labels, # only not None in the last decoder PP stage\n # inference_params=inference_params, # currently always None\n packed_seq_params=packed_seq_params, # currently always None\n **(extra_block_kwargs or {}),\n **kwargs,\n )\n\n return output\n"} +{"file_name": "verl__models__mcore__qwen2_5_vl__rope_utils.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright (c) 2024 Alibaba PAI Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nfrom __future__ import annotations\n\nimport logging\nfrom typing import Optional\n\nimport torch\nfrom megatron.core.models.common.embeddings.rope_utils import *\nfrom megatron.core.models.common.embeddings.rope_utils import _apply_rotary_pos_emb_bshd\nfrom torch import Tensor\n\nlogger = logging.getLogger(__name__)\n\n\n# Slightly modified from Qwen2VLForConditionalGeneration.get_rope_index\ndef get_rope_index(\n input_ids: Optional[torch.LongTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n second_per_grid_ts: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n):\n \"\"\"\n Calculate the 3D rope index based on image and video's temporal, height and width in LLM.\n\n Explanation:\n\n Each embedding sequence contains vision embedding and text embedding or just contains text embedding.\n\n For pure text embedding sequence, the rotary position embedding has no difference with modern LLMs.\n\n Examples:\n\n input_ids: [T T T T T], here T is for text.\n temporal position_ids: [0, 1, 2, 3, 4]\n height position_ids: [0, 1, 2, 3, 4]\n width position_ids: [0, 1, 2, 3, 4]\n\n For vision and text embedding sequence, we calculate 3D rotary position embedding for vision part\n and 1D rotary position embedding for text part.\n\n Examples:\n\n Temporal (Time): 3 patches, representing different segments of the video in time.\n Height: 2 patches, dividing each frame vertically.\n Width: 2 patches, dividing each frame horizontally.\n We also have some important parameters:\n fps (Frames Per Second): The video's frame rate, set to 1. This means one frame is processed each\n second.\n tokens_per_second: This is a crucial parameter. It dictates how many \"time-steps\" or \"temporal\n tokens\" are conceptually packed into a one-second interval of the video.\n In this case, we have 25 tokens per second. So each second of the video will be\n represented with 25 separate time points. It essentially defines the temporal\n granularity.\n temporal_patch_size: The number of frames that compose one temporal patch. Here, it's 2 frames.\n interval: The step size for the temporal position IDs, calculated as tokens_per_second *\n temporal_patch_size / fps. In this case, 25 * 2 / 1 = 50. This means that each temporal patch will be\n have a difference of 50 in the temporal position IDs.\n input_ids: [V V V V V V V V V V V V T T T T T], here V is for vision.\n vision temporal position_ids: [0, 0, 0, 0, 50, 50, 50, 50, 100, 100, 100, 100]\n vision height position_ids: [0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]\n vision width position_ids: [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]\n text temporal position_ids: [101, 102, 103, 104, 105]\n text height position_ids: [101, 102, 103, 104, 105]\n text width position_ids: [101, 102, 103, 104, 105]\n Here we calculate the text start position_ids as the max vision position_ids plus 1.\n\n Args:\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\n Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide\n it.\n image_grid_thw (`torch.LongTensor` of shape `(num_images, 3)`, *optional*):\n The temporal, height and width of feature shape of each image in LLM.\n video_grid_thw (`torch.LongTensor` of shape `(num_videos, 3)`, *optional*):\n The temporal, height and width of feature shape of each video in LLM.\n second_per_grid_ts (`torch.Tensor` of shape `(num_videos)`, *optional*):\n The time interval (in seconds) for each grid along the temporal dimension in the 3D position IDs.\n attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*):\n Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:\n\n - 1 for tokens that are **not masked**,\n - 0 for tokens that are **masked**.\n\n Returns:\n position_ids (`torch.LongTensor` of shape `(3, batch_size, sequence_length)`)\n mrope_position_deltas (`torch.Tensor` of shape `(batch_size)`)\n \"\"\"\n spatial_merge_size = 2\n tokens_per_second = 2\n image_token_id = 151655\n video_token_id = 151656\n vision_start_token_id = 151652\n mrope_position_deltas = []\n if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):\n total_input_ids = input_ids\n if attention_mask is None:\n attention_mask = torch.ones_like(total_input_ids)\n position_ids = torch.ones(\n 3,\n input_ids.shape[0],\n input_ids.shape[1],\n dtype=input_ids.dtype,\n device=input_ids.device,\n )\n image_index, video_index = 0, 0\n attention_mask = attention_mask.to(total_input_ids.device)\n for i, input_ids in enumerate(total_input_ids):\n input_ids = input_ids[attention_mask[i] == 1]\n image_nums, video_nums = 0, 0\n vision_start_indices = torch.argwhere(input_ids == vision_start_token_id).squeeze(1)\n vision_tokens = input_ids[vision_start_indices + 1]\n image_nums = (vision_tokens == image_token_id).sum()\n video_nums = (vision_tokens == video_token_id).sum()\n input_tokens = input_ids.tolist()\n llm_pos_ids_list: list = []\n st = 0\n remain_images, remain_videos = image_nums, video_nums\n for _ in range(image_nums + video_nums):\n if image_token_id in input_tokens and remain_images > 0:\n ed_image = input_tokens.index(image_token_id, st)\n else:\n ed_image = len(input_tokens) + 1\n if video_token_id in input_tokens and remain_videos > 0:\n ed_video = input_tokens.index(video_token_id, st)\n else:\n ed_video = len(input_tokens) + 1\n if ed_image < ed_video:\n t, h, w = (\n image_grid_thw[image_index][0],\n image_grid_thw[image_index][1],\n image_grid_thw[image_index][2],\n )\n second_per_grid_t = 0\n image_index += 1\n remain_images -= 1\n ed = ed_image\n\n else:\n t, h, w = (\n video_grid_thw[video_index][0],\n video_grid_thw[video_index][1],\n video_grid_thw[video_index][2],\n )\n if second_per_grid_ts is not None:\n second_per_grid_t = second_per_grid_ts[video_index]\n else:\n second_per_grid_t = 1.0\n video_index += 1\n remain_videos -= 1\n ed = ed_video\n llm_grid_t, llm_grid_h, llm_grid_w = (\n t.item(),\n h.item() // spatial_merge_size,\n w.item() // spatial_merge_size,\n )\n text_len = ed - st\n\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n range_tensor = torch.arange(llm_grid_t).view(-1, 1)\n expanded_range = range_tensor.expand(-1, llm_grid_h * llm_grid_w)\n\n time_tensor = expanded_range * second_per_grid_t * tokens_per_second\n\n time_tensor_long = time_tensor.long()\n t_index = time_tensor_long.flatten()\n\n h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()\n w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()\n llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + text_len + st_idx)\n st = ed + llm_grid_t * llm_grid_h * llm_grid_w\n\n if st < len(input_tokens):\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n text_len = len(input_tokens) - st\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)\n position_ids[..., i, attention_mask[i] == 1] = llm_positions.to(position_ids.device)\n mrope_position_deltas.append(llm_positions.max() + 1 - len(total_input_ids[i]))\n mrope_position_deltas = torch.tensor(mrope_position_deltas, device=input_ids.device).unsqueeze(1)\n return position_ids, mrope_position_deltas\n else:\n if attention_mask is not None:\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n position_ids = position_ids.unsqueeze(0).expand(3, -1, -1).to(attention_mask.device)\n max_position_ids = position_ids.max(0, keepdim=False)[0].max(-1, keepdim=True)[0]\n mrope_position_deltas = max_position_ids + 1 - attention_mask.shape[-1]\n else:\n position_ids = (\n torch.arange(input_ids.shape[1], device=input_ids.device)\n .view(1, 1, -1)\n .expand(3, input_ids.shape[0], -1)\n )\n mrope_position_deltas = torch.zeros(\n [input_ids.shape[0], 1],\n device=input_ids.device,\n dtype=input_ids.dtype,\n )\n\n return position_ids, mrope_position_deltas\n\n\ndef apply_rotary_pos_emb_thd_absolute(\n t: Tensor, cu_seqlens: Tensor, freqs: Tensor, rotary_interleaved: bool = False\n) -> Tensor:\n \"\"\"A baseline implementation of applying RoPE for `thd` format.\n\n Args:\n t (Tensor): Input tensor T is of shape [t, h, d]\n cu_seqlens(Tensor): Cumulative sum of sequence lengths in a batch for `t`,\n with shape [b + 1] and dtype torch.int32.\n freqs (Tensor): Rotary Positional embedding tensor freq is of shape [max_s, 1, 1, d]\n\n Returns:\n Tensor: Shape [t, h, d]. The input tensor after applying RoPE.\n \"\"\"\n return _apply_rotary_pos_emb_bshd(t[:, None], freqs, rotary_interleaved=rotary_interleaved).squeeze(1)\n\n\ndef apply_rotary_pos_emb_absolute(\n t: Tensor,\n freqs: Tensor,\n config: TransformerConfig,\n cu_seqlens: Optional[Tensor] = None,\n):\n \"\"\"\n Reroute to the appropriate apply_rotary_pos_emb function depending on\n bshd (conventional) / thd (packed seq) format\n\n In Qwen2-VL, the shape of freqs is (seq_length, bs, 1, 2 * dim) instead of [max_seqlen, 1, 1, 2 * dim]\n \"\"\"\n\n if config.apply_rope_fusion:\n if cu_seqlens is None:\n # NOTE: TE backends do not support mRoPE in bshd format when bs > 1\n if freqs.shape[1] > 1:\n return _apply_rotary_pos_emb_bshd(t, freqs, rotary_interleaved=config.rotary_interleaved)\n else:\n return fused_apply_rotary_pos_emb(t, freqs)\n else:\n # NOTE: as expected, thd format can use bshd\n return fused_apply_rotary_pos_emb(t[:, None], freqs).squeeze(1)\n else:\n if cu_seqlens is None:\n return _apply_rotary_pos_emb_bshd(t, freqs, rotary_interleaved=config.rotary_interleaved)\n else:\n return apply_rotary_pos_emb_thd_absolute(t, cu_seqlens, freqs, rotary_interleaved=config.rotary_interleaved)\n"} +{"file_name": "verl__models__mcore__qwen2_5_vl__vision_config.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright (c) 2024 Alibaba PAI Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport torch\nfrom megatron.core import parallel_state\nfrom megatron.core.transformer import TransformerConfig\n\n\ndef get_vision_model_config(config: TransformerConfig) -> TransformerConfig:\n # Given a Transformer Config from decoder, build vision encoder config\n # diff: out_hidden_size & intermediate_size\n\n # mlp: hidden_size -> intermediate_size -> embed_dim, silu\n # NOTE: here we provide a workaround to solve the wrong layer amount when VPP of decoder is on\n if config.num_layers in [28, 36]:\n config.ffn_hidden_size = 3420\n else:\n config.ffn_hidden_size = 3456\n\n if parallel_state.get_virtual_pipeline_model_parallel_world_size() is not None:\n config.num_layers = 32 * parallel_state.get_virtual_pipeline_model_parallel_world_size() # depth\n else:\n config.num_layers = 32 # depth\n config.num_attention_heads = 16 # num_heads\n config.add_bias_linear = True # all nn.Linear has bias (MLP, attn)\n config.add_qkv_bias = True # qkv_proj in attn has bias\n config.hidden_size = 1280 # hidden_size\n config.hidden_dropout = 0.0\n config.attention_dropout = 0.0\n\n # config.gated_linear_unit = False # no gated\n # config.activation_func = quick_gelu # hidden_act\n config.kv_channels = config.hidden_size // config.num_attention_heads\n config.num_query_groups = config.num_attention_heads # no GQA\n config.layernorm_zero_centered_gamma = False # False\n config.apply_query_key_layer_scaling = False # factor=math.sqrt(head_dim)\n config.bias_activation_fusion = False # no swiglu, set false\n config.bias_dropout_fusion = False # no dropout, set false\n config.attention_softmax_in_fp32 = True # use True\n # config.normalization = 'LayerNorm' # use RMSNorm\n config.seq_length = 1\n\n config.tp_comm_overlap = False\n config.sequence_parallel = False\n config.temporal_patch_size = 2\n config.patch_size = 14\n config.in_channels = 3\n config.spatial_merge_size = 2\n\n config.fullatt_block_indexes = [7, 15, 23, 31]\n config._qwen2_5_vl_window_size = 112\n return config\n\n\ndef get_vision_projection_config(\n config: TransformerConfig, embed_dim: int, spatial_merge_size: int\n) -> TransformerConfig:\n # merger:\n # context_dim = hidden_size * merge_size**2\n # out_hidden_size = hidden_size\n # context_dim -> context_dim -> out_hidden_size\n # MLP:\n # input_size -> ffn_hidden_size -> hidden_size\n # spec: LN -> Linear(bias=True) -> GELU -> Linear(bias=True)\n config.gated_linear_unit = False\n config.bias_activation_fusion = False\n config.add_bias_linear = True\n config.ffn_hidden_size = embed_dim * (spatial_merge_size**2)\n config.activation_func = torch.nn.functional.gelu\n config.tp_comm_overlap = False\n config.sequence_parallel = False\n return config\n"} +{"file_name": "verl__models__mcore__qwen2_5_vl__vision_model.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright (c) 2024 Alibaba PAI Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Optional\n\nimport torch\nfrom megatron.core import InferenceParams\nfrom megatron.core.models.common.vision_module.vision_module import VisionModule\nfrom megatron.core.models.vision.multimodal_projector import MultimodalProjector\nfrom megatron.core.packed_seq_params import PackedSeqParams\nfrom megatron.core.transformer.enums import ModelType\nfrom megatron.core.transformer.spec_utils import ModuleSpec\nfrom megatron.core.transformer.transformer_config import TransformerConfig\nfrom torch import nn\nfrom torch.nn import functional as F\n\nfrom .vision_transformer_block import Qwen2_5VisionTransformerBlock as TransformerBlock\n\n\n# copied from https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_vl/modeling_qwen2_vl.py\nclass PatchEmbed(nn.Module):\n def __init__(\n self,\n patch_size: int = 14,\n temporal_patch_size: int = 2,\n in_channels: int = 3,\n embed_dim: int = 1152,\n ) -> None:\n super().__init__()\n self.patch_size = patch_size\n self.temporal_patch_size = temporal_patch_size\n self.in_channels = in_channels\n self.embed_dim = embed_dim\n\n kernel_size = [temporal_patch_size, patch_size, patch_size]\n self.proj = nn.Conv3d(in_channels, embed_dim, kernel_size=kernel_size, stride=kernel_size, bias=False)\n\n def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:\n target_dtype = self.proj.weight.dtype\n hidden_states = hidden_states.view(\n -1, self.in_channels, self.temporal_patch_size, self.patch_size, self.patch_size\n )\n hidden_states = self.proj(hidden_states.to(dtype=target_dtype)).view(-1, self.embed_dim)\n return hidden_states\n\n\n# copied from https://github.com/huggingface/transformers/blob/main/src/transformers/models/qwen2_vl/modeling_qwen2_vl.py\nclass VisionRotaryEmbedding(nn.Module):\n def __init__(self, dim: int, theta: float = 10000.0) -> None:\n super().__init__()\n inv_freq = 1.0 / (theta ** (torch.arange(0, dim, 2, dtype=torch.float) / dim))\n self.register_buffer(\"inv_freq\", inv_freq, persistent=False)\n\n def forward(self, seqlen: int) -> torch.Tensor:\n seq = torch.arange(seqlen, device=self.inv_freq.device, dtype=self.inv_freq.dtype)\n freqs = torch.outer(seq, self.inv_freq)\n return freqs.float()\n\n\nclass Qwen2_5VisionModel(VisionModule):\n \"\"\"Qwen2.5 ViT vision model.\n\n Args:\n transformer_config (TransformerConfig): Transformer config.\n transformer_layer_spec (ModuleSpec): Specifies module to use for transformer layers.\n ln_pre_impl (ModuleSpec or type): Specifies the layer norm type to use for ln_pre.\n add_class_token (bool, optional): Include a class token. Defaults to True.\n class_token_len (int): Class token length. Defaults to 1 but 8 may be faster.\n patch_dim (int): Image patch size.\n img_h (int): Input image height.\n img_w (int): Input image width.\n \"\"\"\n\n def __init__(\n self,\n transformer_config: TransformerConfig,\n transformer_layer_spec: ModuleSpec,\n projection_config: TransformerConfig,\n projection_layer_spec: ModuleSpec,\n projection_type: str = \"mlp\",\n pre_process: bool = True,\n post_process: bool = False,\n ) -> None:\n super().__init__(config=transformer_config)\n\n self.spatial_merge_size = transformer_config.spatial_merge_size\n\n embed_dim = transformer_config.hidden_size\n num_heads = transformer_config.num_attention_heads\n temporal_patch_size = transformer_config.temporal_patch_size\n patch_size = transformer_config.patch_size\n in_channels = transformer_config.in_channels\n\n self.patch_size = transformer_config.patch_size\n self.fullatt_block_indexes = transformer_config.fullatt_block_indexes\n self.window_size = transformer_config._qwen2_5_vl_window_size\n self.spatial_merge_unit = self.spatial_merge_size * self.spatial_merge_size\n\n self.max_sequence_length = transformer_config.seq_length\n self.patch_embed = PatchEmbed(\n patch_size=patch_size,\n temporal_patch_size=temporal_patch_size,\n in_channels=in_channels,\n embed_dim=embed_dim,\n )\n\n head_dim = embed_dim // num_heads\n self.rotary_pos_emb = VisionRotaryEmbedding(head_dim // 2)\n\n self.model_type = ModelType.encoder_or_decoder\n self.pre_process = pre_process\n self.post_process = post_process\n\n # Transformer layers.\n # TODO: Follow-up changes will make pre and post_process configurable. They are needed for supporting\n # pipeline parallelism.\n # NOTE: a final layer norm and/or linear layer present in some implementations are omitted here.\n self.decoder = TransformerBlock(\n config=transformer_config,\n spec=transformer_layer_spec,\n pre_process=self.pre_process,\n post_process=self.post_process,\n post_layer_norm=True,\n )\n\n self.merge_hidden_size = projection_config.ffn_hidden_size\n self.square_merge_size = self.merge_hidden_size // embed_dim\n\n if self.post_process:\n self.projection = MultimodalProjector(\n projection_config, projection_layer_spec, projection_type, projection_config.ffn_hidden_size\n )\n else:\n self.projection = None\n\n self.input_tensor = None\n\n def set_input_tensor(self, input_tensor: torch.Tensor) -> None:\n \"\"\"Sets input tensor to the model.\n\n Args:\n input_tensor (Tensor): Sets the input tensor for the model.\n \"\"\"\n if self.pre_process: # always True\n self.input_tensor = input_tensor\n else:\n raise NotImplementedError()\n\n def rot_pos_emb(self, grid_thw):\n pos_ids = []\n for t, h, w in grid_thw:\n hpos_ids = torch.arange(h).unsqueeze(1).expand(-1, w)\n hpos_ids = hpos_ids.reshape(\n h // self.spatial_merge_size,\n self.spatial_merge_size,\n w // self.spatial_merge_size,\n self.spatial_merge_size,\n )\n hpos_ids = hpos_ids.permute(0, 2, 1, 3)\n hpos_ids = hpos_ids.flatten()\n\n wpos_ids = torch.arange(w).unsqueeze(0).expand(h, -1)\n wpos_ids = wpos_ids.reshape(\n h // self.spatial_merge_size,\n self.spatial_merge_size,\n w // self.spatial_merge_size,\n self.spatial_merge_size,\n )\n wpos_ids = wpos_ids.permute(0, 2, 1, 3)\n wpos_ids = wpos_ids.flatten()\n pos_ids.append(torch.stack([hpos_ids, wpos_ids], dim=-1).repeat(t, 1))\n pos_ids = torch.cat(pos_ids, dim=0).to(grid_thw.device)\n max_grid_size = grid_thw[:, 1:].max()\n rotary_pos_emb_full = self.rotary_pos_emb(max_grid_size).to(grid_thw.device)\n rotary_pos_emb = rotary_pos_emb_full[pos_ids].flatten(1)\n return rotary_pos_emb\n\n def get_window_index(self, grid_thw):\n window_index: list = []\n cu_window_seqlens: list = [0]\n window_index_id = 0\n vit_merger_window_size = self.window_size // self.spatial_merge_size // self.patch_size\n\n for grid_t, grid_h, grid_w in grid_thw:\n llm_grid_h, llm_grid_w = (\n grid_h // self.spatial_merge_size,\n grid_w // self.spatial_merge_size,\n )\n index = torch.arange(grid_t * llm_grid_h * llm_grid_w).reshape(grid_t, llm_grid_h, llm_grid_w)\n pad_h = vit_merger_window_size - llm_grid_h % vit_merger_window_size\n pad_w = vit_merger_window_size - llm_grid_w % vit_merger_window_size\n num_windows_h = (llm_grid_h + pad_h) // vit_merger_window_size\n num_windows_w = (llm_grid_w + pad_w) // vit_merger_window_size\n index_padded = F.pad(index, (0, pad_w, 0, pad_h), \"constant\", -100)\n index_padded = index_padded.reshape(\n grid_t,\n num_windows_h,\n vit_merger_window_size,\n num_windows_w,\n vit_merger_window_size,\n )\n index_padded = index_padded.permute(0, 1, 3, 2, 4).reshape(\n grid_t,\n num_windows_h * num_windows_w,\n vit_merger_window_size,\n vit_merger_window_size,\n )\n seqlens = (index_padded != -100).sum([2, 3]).reshape(-1)\n index_padded = index_padded.reshape(-1)\n index_new = index_padded[index_padded != -100]\n window_index.append(index_new + window_index_id)\n cu_seqlens_tmp = seqlens.cumsum(0) * self.spatial_merge_unit + cu_window_seqlens[-1]\n cu_window_seqlens.extend(cu_seqlens_tmp.tolist())\n window_index_id += (grid_t * llm_grid_h * llm_grid_w).item()\n window_index = torch.cat(window_index, dim=0)\n\n return window_index, cu_window_seqlens\n\n def forward(\n self,\n vision_data: Optional[torch.Tensor],\n grid_thw: torch.Tensor,\n inference_params: Optional[InferenceParams] = None,\n extra_block_kwargs: dict = None,\n ) -> torch.Tensor:\n \"\"\"Forward function of the Qwen2 Vision Model. This function passes the input tensors\n through the embedding layer and then the transformer.\n\n Args:\n x (torch.Tensor): input image/video data of shape [n_tokens, n_dims]\n grid_thw (torch.Tensor): the size tensor indicates grid size of each image/frame\n packed_seq_params (PackedSeqParams): parameters to build attention mask in the backend\n\n Returns:\n x (torch.Tensor): output after final transformer block of shape [b, s, h].\n \"\"\"\n assert grid_thw is not None\n assert self.input_tensor is None\n assert inference_params is None\n\n # Rotary positional embeddings (embedding is None for PP intermediate devices)\n vision_data = self.patch_embed(vision_data)\n window_index, cu_window_seqlens = self.get_window_index(grid_thw)\n cu_window_seqlens = torch.tensor(\n cu_window_seqlens,\n device=vision_data.device,\n dtype=torch.int32,\n )\n cu_window_seqlens = torch.unique_consecutive(cu_window_seqlens)\n\n seq_len, _ = vision_data.size()\n vision_data = vision_data.reshape(seq_len // self.spatial_merge_unit, self.spatial_merge_unit, -1)\n vision_data = vision_data[window_index, :, :]\n vision_data = vision_data.reshape(seq_len, 1, -1)\n\n rotary_pos_emb = self.rot_pos_emb(grid_thw)\n rotary_pos_emb = rotary_pos_emb.reshape(seq_len // self.spatial_merge_unit, self.spatial_merge_unit, -1)\n rotary_pos_emb = rotary_pos_emb[window_index, :, :]\n rotary_pos_emb = rotary_pos_emb.reshape(seq_len, 1, 1, -1).repeat(1, 1, 1, 2)\n\n hidden_states = self.decoder(\n hidden_states=vision_data,\n attention_mask=None,\n inference_params=inference_params,\n rotary_pos_emb=rotary_pos_emb,\n packed_seq_params=self.build_packed_seq_params(None, cu_window_seqlens),\n packed_seq_params_full=self.build_packed_seq_params(grid_thw),\n fullatt_block_indexes=self.fullatt_block_indexes,\n **(extra_block_kwargs or {}),\n )\n\n hidden_states = self.projection(hidden_states.view(-1, self.merge_hidden_size))\n reverse_indices = torch.argsort(window_index)\n return hidden_states[reverse_indices, :]\n\n def build_packed_seq_params(\n self,\n grid_thw: Optional[torch.Tensor],\n cu_seqlens: Optional[torch.Tensor] = None,\n ) -> PackedSeqParams:\n # NOTE: each frame is a sequence (rather than each grid)\n if grid_thw is not None:\n seqlens = torch.repeat_interleave(grid_thw[:, 1] * grid_thw[:, 2], grid_thw[:, 0])\n cu_seqlens = seqlens.cumsum(dim=0)\n cu_seqlens = F.pad(cu_seqlens, (1, 0), value=0).int()\n else:\n seqlens = cu_seqlens[1:] - cu_seqlens[:-1]\n\n max_seqlen_q = seqlens.max()\n return PackedSeqParams(\n cu_seqlens_q=cu_seqlens,\n cu_seqlens_kv=cu_seqlens,\n qkv_format=\"thd\",\n max_seqlen_q=max_seqlen_q,\n max_seqlen_kv=max_seqlen_q,\n )\n"} +{"file_name": "verl__models__mcore__qwen2_5_vl__vision_transformer_block.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright (c) 2024 Alibaba PAI Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nfrom megatron.core.transformer.transformer_block import *\n\n\nclass Qwen2_5VisionTransformerBlock(TransformerBlock):\n def _checkpointed_forward(\n self,\n hidden_states: Tensor,\n attention_mask: Tensor,\n context: Tensor,\n context_mask: Tensor,\n rotary_pos_emb: Tensor,\n attention_bias: Tensor,\n packed_seq_params: PackedSeqParams,\n packed_seq_params_full: PackedSeqParams,\n fullatt_block_indexes,\n ):\n \"\"\"Forward method with activation checkpointing.\"\"\"\n\n def custom(start: int, end: int):\n def custom_forward(hidden_states, attention_mask, context, context_mask, rotary_pos_emb):\n for index in range(start, end):\n if index in fullatt_block_indexes:\n packed_seq_params_now = packed_seq_params_full\n else:\n packed_seq_params_now = packed_seq_params\n layer = self._get_layer(index)\n hidden_states, context = layer(\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n context=context,\n context_mask=context_mask,\n rotary_pos_emb=rotary_pos_emb,\n attention_bias=attention_bias,\n inference_context=None,\n packed_seq_params=packed_seq_params_now,\n )\n return hidden_states, context\n\n return custom_forward\n\n def checkpoint_handler(forward_func):\n \"\"\"Determines whether to use the `te_checkpoint` or `tensor_parallel.checkpoint`\"\"\"\n if self.config.fp8:\n return te_checkpoint(\n forward_func,\n self.config.distribute_saved_activations,\n tensor_parallel.random.get_cuda_rng_tracker,\n parallel_state.get_tensor_model_parallel_group(),\n hidden_states,\n attention_mask,\n context,\n context_mask,\n rotary_pos_emb,\n )\n else:\n return tensor_parallel.checkpoint(\n forward_func,\n self.config.distribute_saved_activations,\n hidden_states,\n attention_mask,\n context,\n context_mask,\n rotary_pos_emb,\n )\n\n if self.config.recompute_method == \"uniform\":\n # Uniformly divide the total number of Transformer layers and checkpoint\n # the input activation of each divided chunk.\n # A method to further reduce memory usage reducing checkpoints.\n layer_idx = 0\n while layer_idx < self.num_layers_per_pipeline_rank:\n hidden_states, context = checkpoint_handler(\n custom(layer_idx, layer_idx + self.config.recompute_num_layers)\n )\n\n layer_idx += self.config.recompute_num_layers\n\n elif self.config.recompute_method == \"block\":\n # Checkpoint the input activation of only a set number of individual\n # Transformer layers and skip the rest.\n # A method fully use the device memory removing redundant re-computation.\n recompute_skip_num_layers = 0\n for layer_idx in range(self.num_layers_per_pipeline_rank):\n # Skip recomputation when input grad computation is not needed.\n # Need to have at least one input tensor with gradient computation\n # for re-enterant autograd engine.\n if self.config.fp8 and not hidden_states.requires_grad:\n recompute_skip_num_layers += 1\n if (\n layer_idx >= recompute_skip_num_layers\n and layer_idx < self.config.recompute_num_layers + recompute_skip_num_layers\n ):\n hidden_states, context = checkpoint_handler(custom(layer_idx, layer_idx + 1))\n else:\n hidden_states, context = custom(layer_idx, layer_idx + 1)(\n hidden_states, attention_mask, context, context_mask, rotary_pos_emb\n )\n else:\n raise ValueError(\"Invalid activation recompute method.\")\n\n return hidden_states\n\n def forward(\n self,\n hidden_states: Union[Tensor, WrappedTensor],\n attention_mask: Optional[Tensor],\n context: Optional[Tensor] = None,\n context_mask: Optional[Tensor] = None,\n rotary_pos_emb: Optional[Tensor] = None,\n rotary_pos_cos: Optional[Tensor] = None,\n rotary_pos_sin: Optional[Tensor] = None,\n attention_bias: Optional[Tensor] = None,\n inference_context: Optional[BaseInferenceContext] = None,\n packed_seq_params: Optional[PackedSeqParams] = None,\n sequence_len_offset: Optional[Tensor] = None,\n packed_seq_params_full: PackedSeqParams = None,\n fullatt_block_indexes=None,\n *,\n inference_params: Optional[BaseInferenceContext] = None,\n ):\n \"\"\"\n Perform the forward pass through the transformer block.\n\n This method handles the core computation of the transformer, including\n self-attention, optional cross-attention, and feed-forward operations.\n\n Args:\n hidden_states (Union[Tensor, WrappedTensor]): Input tensor of shape [s, b, h]\n where s is the sequence length, b is the batch size, and h is the hidden size.\n Can be passed as a WrappedTensor during inference to avoid an obsolete\n reference in the calling function.\n attention_mask (Tensor): Boolean tensor of shape [1, 1, s, s] for masking\n self-attention.\n context (Tensor, optional): Context tensor for cross-attention.\n context_mask (Tensor, optional): Mask for cross-attention context\n rotary_pos_emb (Tensor, optional): Rotary positional embeddings.\n attention_bias (Tensor): Bias tensor for Q * K.T of shape in shape broadcastable\n to [b, num_head, sq, skv], e.g. [1, 1, sq, skv].\n Used as an alternative to apply attention mask for TE cuDNN attention.\n inference_context (BaseInferenceContext, optional): Parameters for inference-time\n optimizations.\n packed_seq_params (PackedSeqParams, optional): Parameters for packed sequence\n processing.\n\n Returns:\n Union[Tensor, Tuple[Tensor, Tensor]]: The output hidden states tensor of shape\n [s, b, h], and optionally the updated context tensor if cross-attention is used.\n \"\"\"\n\n inference_context = deprecate_inference_params(inference_context, inference_params)\n\n # Delete the obsolete reference to the initial input tensor if necessary\n if isinstance(hidden_states, WrappedTensor):\n hidden_states = hidden_states.unwrap()\n\n if not self.pre_process:\n # See set_input_tensor()\n hidden_states = self.input_tensor\n\n # Update the inference parameters with the current batch size in case it is variable\n if inference_context and not self.training:\n inference_context.current_batch_size = hidden_states.size(1)\n\n # Viewless tensor.\n # - We only need to create a viewless tensor in the case of micro batch\n # size (mbs) == 1, since in this case, 'hidden_states.transpose()'\n # above creates a view tensor, and '.contiguous()' is a pass-through.\n # For mbs >= 2, '.contiguous()' creates a new tensor, eliminating\n # the need to make it viewless.\n #\n # However, we don't explicitly check mbs == 1 here because\n # make_viewless_tensor() has negligible overhead when its input\n # is already viewless.\n #\n # - For the 'else' case above, calling make_viewless_tensor() here is\n # likely redundant, since p2p_communication.py (likely originator)\n # already creates viewless tensors. That said, make_viewless_tensor()\n # is called here to be future-proof and corner-case-proof.\n hidden_states = make_viewless_tensor(inp=hidden_states, requires_grad=True, keep_graph=True)\n\n if self.config.sequence_parallel:\n rng_context = tensor_parallel.get_cuda_rng_tracker().fork()\n else:\n rng_context = nullcontext()\n\n # If fp8_recipe is delayed, wrap the entire pass with get_fp8_context(),\n # otherwise do nothing extra at the outer level\n # if we are using other fp8 recipes, then the context manager enter&exit are free\n # we can wrap fp8_context within the for loop over layers, so that we can fine-grained\n # control which layer will be fp8 or bf16\n use_outer_fp8_context = self.config.fp8 and self.config.fp8_recipe == Fp8Recipe.delayed\n use_inner_fp8_context = self.config.fp8 and self.config.fp8_recipe != Fp8Recipe.delayed\n outer_fp8_context = get_fp8_context(self.config) if use_outer_fp8_context else nullcontext()\n\n with rng_context, outer_fp8_context:\n # Forward pass.\n if self.config.recompute_granularity == \"full\" and self.training:\n hidden_states = self._checkpointed_forward(\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n context=context,\n context_mask=context_mask,\n rotary_pos_emb=rotary_pos_emb,\n attention_bias=attention_bias,\n packed_seq_params=packed_seq_params,\n packed_seq_params_full=packed_seq_params_full,\n fullatt_block_indexes=fullatt_block_indexes,\n )\n else:\n for l_no, layer in enumerate(self.layers):\n inner_fp8_context = (\n get_fp8_context(self.config, layer.layer_number - 1) if use_inner_fp8_context else nullcontext()\n )\n if l_no in fullatt_block_indexes:\n packed_seq_params_now = packed_seq_params_full\n else:\n packed_seq_params_now = packed_seq_params\n with self.offload_context, inner_fp8_context:\n hidden_states, context = layer(\n hidden_states=hidden_states,\n attention_mask=attention_mask,\n context=context,\n context_mask=context_mask,\n rotary_pos_emb=rotary_pos_emb,\n rotary_pos_cos=rotary_pos_cos,\n rotary_pos_sin=rotary_pos_sin,\n attention_bias=attention_bias,\n inference_context=inference_context,\n packed_seq_params=packed_seq_params_now,\n sequence_len_offset=sequence_len_offset,\n )\n\n if (\n torch.is_grad_enabled()\n and self.config.cpu_offloading\n and self.group_prefetch_offload_commit_async is not None\n ):\n hidden_states = self.group_prefetch_offload_commit_async(hidden_states)\n\n # Final layer norm.\n if self.final_layernorm is not None:\n hidden_states = self.final_layernorm(hidden_states)\n # TENorm produces a \"viewed\" tensor. This will result in schedule.py's\n # deallocate_output_tensor() throwing an error, so a viewless tensor is\n # created to prevent this.\n hidden_states = make_viewless_tensor(inp=hidden_states, requires_grad=True, keep_graph=True)\n\n return hidden_states\n"} +{"file_name": "verl__models__mcore__saver.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\nfrom megatron.core import mpu\nfrom megatron.core.distributed import DistributedDataParallel as LocalDDP\nfrom megatron.core.transformer.module import Float16Module\nfrom torch.nn.parallel import DistributedDataParallel as torchDDP\n\nfrom verl.utils.device import get_device_id, get_torch_device\nfrom verl.utils.logger import print_rank_0\nfrom verl.utils.megatron_utils import unwrap_model\n\n\ndef _megatron_calc_global_rank(\n tp_rank: int = 0, dp_rank: int = 0, pp_rank: int = 0, cp_rank: int = 0, ep_rank: int = 0\n):\n \"\"\"Calculate global rank with support for CP/EP parallelism\"\"\"\n\n # Get parallel sizes for each dimension\n tp_size = mpu.get_tensor_model_parallel_world_size()\n dp_size = mpu.get_data_parallel_world_size()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n cp_size = mpu.get_context_parallel_world_size()\n # ep_size = mpu.get_expert_model_parallel_world_size()\n\n # Verify total GPU count matches (must be consistent with parallel_state.py)\n total_size = tp_size * dp_size * pp_size * cp_size\n assert total_size == torch.distributed.get_world_size(), (\n f\"{tp_size}x{dp_size}x{pp_size}x{cp_size} != {torch.distributed.get_world_size()}\"\n )\n\n # Core calculation logic (corresponds to RankGenerator order parameter)\n # Assumes default order is \"tp-cp-ep-dp-pp\"\n return ((pp_rank * dp_size + dp_rank) * cp_size + cp_rank) * tp_size + tp_rank\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef merge_megatron_ckpt_gptmodel(wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False):\n \"\"\"Merge sharded parameters of a Megatron module into a merged checkpoint.\n\n Args:\n wrapped_models (list of megatron.core.distributed.DistributedDataParallel):\n The local DDP wrapped megatron modules.\n config (str or None):\n HF config for model\n dtype: model params type\n is_value_model: if model is value model\n tie_word_embeddings: tie_word_embeddings\n Returns:\n state_dict (dict):\n The merged state_dict in rank 0, and an empty dictionary in other ranks.\n \"\"\"\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n cp_rank = mpu.get_context_parallel_rank()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if dist.get_rank() == 0:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n assert len(models[i].decoder.layers) == num_layers_per_model, (\n \"len model layers {} not equal to num_layers_per_model {}\".format(\n len(models[i].decoder.layers), num_layers_per_model\n )\n )\n\n state_dict = dict()\n\n def _get_cpu_tensor(tensor: torch.Tensor):\n if tensor is None:\n return None\n if tensor.device == torch.device(\"cpu\"):\n return tensor.detach().clone()\n return tensor.detach().cpu()\n\n def _broadcast_tensor(tensor, name, src_pp_rank) -> torch.Tensor:\n \"\"\"broadcast tensor across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n\n if torch.distributed.get_rank() == src_rank:\n if tensor is None:\n weight = None\n tensor_shape = None\n else:\n weight = tensor\n tensor_shape = weight.shape\n else:\n weight = None\n tensor_shape = None\n\n obj_list = [tensor_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n tensor_shape = obj_list[0]\n\n if tensor_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tensor:[{name}] not exist, skip collect\")\n return\n\n if weight is None:\n weight = torch.empty(\n tensor_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n dist.broadcast(weight, src=src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n state_dict[name] = _get_cpu_tensor(weight)\n\n def _broadcast_tp_shard_tensor(tensor, name, src_pp_rank, concat_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n # tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=concat_dim)\n if mutate_func is not None:\n full_tensor = mutate_func(full_tensor)\n state_dict[name] = full_tensor\n\n def _broadcast_tp_shard_tensor_gate_up(tensor, gate_name, up_name, src_pp_rank) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n # tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{gate_name, up_name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=0)\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_list = []\n up_weight_list = []\n for i in range(tp_size):\n gate_up_weight_tp = full_tensor[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)]\n gate_weight_tp = gate_up_weight_tp[:intermediate_size_tp]\n up_weight_tp = gate_up_weight_tp[intermediate_size_tp:]\n gate_weight_list.append(gate_weight_tp)\n up_weight_list.append(up_weight_tp)\n\n state_dict[gate_name] = torch.cat(gate_weight_list, dim=0)\n state_dict[up_name] = torch.cat(up_weight_list, dim=0)\n\n def _broadcast_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name, src_pp_rank):\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n # tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n src_rank = _megatron_calc_global_rank(tp_rank=0, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n\n chunk_shape = tensor.shape if torch.distributed.get_rank() == src_rank else None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=src_rank, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{q_name}] not exist, skip collecting\")\n return\n\n buffer_tensor = torch.empty(\n chunk_shape,\n dtype=dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n\n chunk_tensors = [None] * tp_size\n\n for i in range(tp_size):\n cur_src_rank = _megatron_calc_global_rank(tp_rank=i, dp_rank=0, pp_rank=src_pp_rank, cp_rank=cp_rank)\n sync_tensor = tensor if torch.distributed.get_rank() == cur_src_rank else buffer_tensor\n dist.broadcast(sync_tensor, src=cur_src_rank, group=mp_group)\n\n if torch.distributed.get_rank() == 0:\n chunk_tensors[i] = _get_cpu_tensor(sync_tensor)\n\n if torch.distributed.get_rank() == 0:\n full_tensor = torch.concat(chunk_tensors, dim=0)\n q_weight_list = []\n k_weight_list = []\n v_weight_list = []\n hidden_size_per_head = getattr(config, \"head_dim\", config.hidden_size // config.num_attention_heads)\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = hidden_size_per_head * config.num_attention_heads // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n for i in range(tp_size):\n num_query_groups_per_partition = wrapped_models[0].config.num_query_groups // tp_size\n qkv_part = full_tensor[i * total_size : (i + 1) * total_size]\n q_size_chunk = q_size_tp // num_query_groups_per_partition\n kv_size_chunk = kv_size_tp // num_query_groups_per_partition\n for qkv_part_chunk in qkv_part.chunk(num_query_groups_per_partition):\n q_part = qkv_part_chunk[:q_size_chunk]\n k_part = qkv_part_chunk[q_size_chunk : q_size_chunk + kv_size_chunk]\n v_part = qkv_part_chunk[q_size_chunk + kv_size_chunk :]\n q_weight_list.append(q_part)\n k_weight_list.append(k_part)\n v_weight_list.append(v_part)\n else:\n q_size_tp = hidden_size_per_head * config.num_attention_heads // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n for i in range(tp_size):\n num_query_groups_per_partition = wrapped_models[0].config.num_query_groups // tp_size\n qkv_part = full_tensor[i * total_size : (i + 1) * total_size]\n q_size_chunk = q_size_tp // num_query_groups_per_partition\n kv_size_chunk = kv_size_tp // num_query_groups_per_partition\n for qkv_part_chunk in qkv_part.chunk(num_query_groups_per_partition):\n q_part = qkv_part_chunk[:q_size_chunk]\n k_part = qkv_part_chunk[q_size_chunk : q_size_chunk + kv_size_chunk]\n v_part = qkv_part_chunk[q_size_chunk + kv_size_chunk :]\n q_weight_list.append(q_part)\n if i * config.num_key_value_heads % tp_size == 0:\n k_weight_list.append(k_part)\n v_weight_list.append(v_part)\n\n state_dict[q_name] = torch.cat(q_weight_list, dim=0)\n state_dict[k_name] = torch.cat(k_weight_list, dim=0)\n state_dict[v_name] = torch.cat(v_weight_list, dim=0)\n\n # empty cache before collecting weights\n get_torch_device().empty_cache()\n # Embeddings\n # -------------------\n if dp_rank == 0 and cp_rank == 0: # models are identical across cp ranks\n # Embeddings\n # -------------------\n print_rank_0(\"collecting embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n _broadcast_tp_shard_tensor(\n gpt_model_module.embedding.word_embeddings.weight if pp_rank == 0 else None,\n \"model.embed_tokens.weight\",\n src_pp_rank=0,\n )\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n for layer in range(config.num_hidden_layers):\n print_rank_0(f\"collecting layer #{layer}...\")\n layer_name = f\"model.layers.{layer}\"\n src_pp_rank, src_virtual_pp_rank, src_layer_idx = layer_map[layer]\n\n gpt_model_module = _get_gpt_model(models[src_virtual_pp_rank])\n sync_layer = gpt_model_module.decoder.layers[src_layer_idx]\n\n _broadcast_tensor(\n sync_layer.self_attention.linear_qkv.layer_norm_weight,\n f\"{layer_name}.input_layernorm.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n if gpt_model_module.config.qk_layernorm:\n _broadcast_tensor(\n sync_layer.self_attention.q_layernorm.weight,\n f\"{layer_name}.self_attn.q_norm.weight\",\n src_pp_rank=src_pp_rank,\n )\n _broadcast_tensor(\n sync_layer.self_attention.k_layernorm.weight,\n f\"{layer_name}.self_attn.k_norm.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attention.linear_qkv.weight,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n if gpt_model_module.config.add_qkv_bias:\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attention.linear_qkv.bias,\n f\"{layer_name}.self_attn.q_proj.bias\",\n f\"{layer_name}.self_attn.k_proj.bias\",\n f\"{layer_name}.self_attn.v_proj.bias\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.self_attention.linear_proj.weight,\n f\"{layer_name}.self_attn.o_proj.weight\",\n concat_dim=1,\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tensor(\n sync_layer.mlp.linear_fc1.layer_norm_weight,\n f\"{layer_name}.post_attention_layernorm.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor_gate_up(\n sync_layer.mlp.linear_fc1.weight,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n src_pp_rank=src_pp_rank,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.mlp.linear_fc2.weight,\n f\"{layer_name}.mlp.down_proj.weight\",\n concat_dim=1,\n src_pp_rank=src_pp_rank,\n )\n\n # Final Layernorm\n # -------------------\n print_rank_0(\"collecting final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _broadcast_tensor(\n getattr(gpt_model_module.decoder.final_layernorm, \"weight\", None),\n \"model.norm.weight\",\n src_pp_rank=pp_size - 1,\n )\n\n if tie_word_embeddings:\n print_rank_0(\"tie word embedding skip load lm_head...\")\n else:\n print_rank_0(\"collecting lm_head...\")\n\n if is_value_model:\n lm_head_weight = None\n if pp_rank == pp_size - 1:\n lm_head_weight = getattr(gpt_model_module.output_layer, \"weight\", None)\n _broadcast_tensor(lm_head_weight, \"lm_head.weight\", src_pp_rank=pp_size - 1)\n\n else:\n _broadcast_tp_shard_tensor(\n getattr(gpt_model_module.output_layer, \"weight\", None) if pp_rank == pp_size - 1 else None,\n \"lm_head.weight\",\n src_pp_rank=pp_size - 1,\n )\n\n dist.barrier()\n get_torch_device().empty_cache()\n if torch.distributed.get_rank() == 0:\n for k, v in state_dict.items():\n if dtype != v.dtype:\n state_dict[k] = v.to(dtype)\n\n print_rank_0(f\"merge megatron ckpt done, time elapsed {time.time() - start_time}s\")\n return state_dict\n\n\ndef merge_megatron_ckpt_gptmodel_qwen_moe(\n wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False\n):\n raise NotImplementedError(\"merge_megatron_ckpt_gptmodel_qwen_moe is not implemented\")\n\n\ndef merge_megatron_ckpt_gptmodel_qwen2_5_vl(\n wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False\n):\n raise NotImplementedError(\"merge_megatron_ckpt_gptmodel_qwen2_5_vl is not implemented\")\n\n\ndef merge_megatron_ckpt_gptmodel_dpskv3(wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False):\n raise NotImplementedError(\"merge_megatron_ckpt_gptmodel_dpskv3 is not implemented\")\n\n\ndef merge_megatron_ckpt_gptmodel_mixtral(\n wrapped_models, config, dtype, is_value_model=False, tie_word_embeddings=False\n):\n raise NotImplementedError(\"merge_megatron_ckpt_gptmodel_mixtral is not implemented\")\n"} +{"file_name": "verl__models__mcore__util.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport math\n\nimport torch\nfrom megatron.core import parallel_state as mpu\nfrom megatron.core.packed_seq_params import PackedSeqParams\n\nfrom verl.utils.model import CausalLMOutputForPPO\n\n\ndef preprocess_packed_seqs(\n input_ids: torch.Tensor, attention_mask: torch.Tensor, pre_process: bool = True, use_fp8_padding=False\n) -> tuple[torch.Tensor, PackedSeqParams]:\n \"\"\"\n Preprocess packed sequences\n CP splits sequence into CP*2 chunks, and each GPU gets 2 chunks (GPU0 gets first and last chunks, GPU1\n gets second and second last chunks, and so on), this is for load balancing with causal masking.\n See https://github.com/NVIDIA/TransformerEngine/issues/1368\n \"\"\"\n batch_size = input_ids.shape[0]\n\n seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32)\n tp_size = mpu.get_tensor_model_parallel_world_size()\n cp_size = mpu.get_context_parallel_world_size()\n cp_rank = mpu.get_context_parallel_rank()\n align_size = tp_size * cp_size * 2 if cp_size > 1 else tp_size\n if use_fp8_padding:\n # if fp8 is enabled, ensure the sequence is padded to multiples of 16 for better performance\n original_align_size = align_size\n align_size = math.lcm(16, align_size)\n\n pad_size = (align_size - seqlens_in_batch % align_size) % align_size\n seqlens_in_batch_padded = seqlens_in_batch + pad_size\n\n cu_seqlens = torch.zeros(batch_size + 1, dtype=torch.int32, device=input_ids.device)\n cu_seqlens[1:] = torch.cumsum(seqlens_in_batch, dim=0)\n cu_seqlens_padded = torch.zeros(batch_size + 1, dtype=torch.int32, device=input_ids.device)\n cu_seqlens_padded[1:] = torch.cumsum(seqlens_in_batch_padded, dim=0)\n\n if use_fp8_padding:\n # make sure all the sequences are padded to multiples of 128 for TE compatibility\n align_size_last = original_align_size * 128\n pad_size_last = (align_size_last - cu_seqlens_padded[-1] % align_size_last) % align_size_last\n cu_seqlens_padded[-1] += pad_size_last\n seqlens_in_batch_padded[-1] += pad_size_last\n\n # ----------------------------------------------------------------------------\n # Move the index information needed in the subsequent loop to the CPU at once,\n # to avoid frequent .item() calls in the loop that cause D2H synchronization\n # ----------------------------------------------------------------------------\n seqlens_in_batch_cpu: list[int] = seqlens_in_batch.tolist() # original valid lengths\n seqlens_in_batch_padded_cpu: list[int] = seqlens_in_batch_padded.tolist() # lengths after padding\n cu_seqlens_padded_cpu: list[int] = cu_seqlens_padded.tolist() # start positions (after padding)\n\n # Pure Python int calculation to avoid further synchronization\n max_seqlen_in_batch = max(seqlens_in_batch_padded_cpu)\n\n shape = list(input_ids.shape[1:])\n shape[0] = sum(seqlens_in_batch_padded_cpu) // cp_size\n if pre_process:\n input_ids_rmpad = torch.zeros(shape, dtype=input_ids.dtype, device=input_ids.device)\n for i in range(batch_size):\n # Use Python int, so no GPU→CPU sync in the loop\n if cp_size <= 1:\n seqlen = seqlens_in_batch_cpu[i]\n start_idx = cu_seqlens_padded_cpu[i]\n input_ids_rmpad[start_idx : start_idx + seqlen] = input_ids[i, attention_mask[i]]\n continue\n\n seqlen_padded_i = seqlens_in_batch_padded_cpu[i]\n seqlen = seqlen_padded_i // cp_size\n half_seqlen = seqlen // 2\n start_idx = cu_seqlens_padded_cpu[i] // cp_size\n # split to 2 chunks\n d = input_ids[i, attention_mask[i]]\n input_ids_rmpad[start_idx : start_idx + half_seqlen] = d[\n half_seqlen * cp_rank : half_seqlen * (cp_rank + 1)\n ]\n\n remain_start = seqlen_padded_i - half_seqlen * (cp_rank + 1)\n remain_end = seqlen_padded_i - half_seqlen * cp_rank\n remain_end = min(remain_end, d.shape[0])\n remain_len = remain_end - remain_start\n if remain_len > 0:\n input_ids_rmpad[start_idx + half_seqlen : start_idx + half_seqlen + remain_len] = d[\n remain_start:remain_end\n ]\n\n packed_seq_params = PackedSeqParams(\n qkv_format=\"thd\",\n cu_seqlens_q=cu_seqlens_padded,\n max_seqlen_q=max_seqlen_in_batch,\n cu_seqlens_kv=cu_seqlens_padded,\n max_seqlen_kv=max_seqlen_in_batch,\n cu_seqlens_q_padded=cu_seqlens_padded,\n cu_seqlens_kv_padded=cu_seqlens_padded,\n )\n if pre_process:\n return input_ids_rmpad.unsqueeze(0), packed_seq_params\n else:\n return input_ids, packed_seq_params\n\n\ndef postprocess_packed_seqs(\n output: torch.Tensor,\n packed_seq_params: PackedSeqParams,\n attention_mask: torch.Tensor,\n batch_size: int,\n seq_len: int,\n post_process: bool = True,\n) -> torch.Tensor:\n \"\"\"\n Postprocess packed sequences\n \"\"\"\n if not post_process:\n return output\n\n # -------------------------------------------------------------------------\n # Move the lengths and offsets needed for subsequent Python-level indexing to the CPU in advance,\n # to avoid a large number of .item() calls in the loop\n # -------------------------------------------------------------------------\n cu_padded_cpu: list[int] = packed_seq_params.cu_seqlens_q_padded.tolist()\n seq_lens_cpu: list[int] = attention_mask.sum(dim=1, dtype=torch.int32).cpu().tolist()\n\n shape = [batch_size, seq_len] + list(output.shape[2:]) # 1,packed, dim -> batch_size, seq_len, dim\n output_new = torch.zeros(shape, dtype=output.dtype, device=output.device)\n\n cp_size = mpu.get_context_parallel_world_size()\n # all gather output across context parallel group\n if cp_size > 1:\n # output shape: [1, packed_len, hidden_dim]\n # need to gather across cp group and concatenate in sequence dimension\n output_list = [torch.empty_like(output, dtype=output.dtype) for _ in range(cp_size)]\n torch.distributed.all_gather(output_list, output.detach(), group=mpu.get_context_parallel_group())\n output_list[mpu.get_context_parallel_rank()] = output\n else:\n output_list = [output]\n for i in range(batch_size):\n if cp_size <= 1:\n s = seq_lens_cpu[i]\n start_idx = cu_padded_cpu[i]\n output_new[i, attention_mask[i]] = output[0][start_idx : start_idx + s]\n continue\n s_len_padded_chunk = (cu_padded_cpu[i + 1] - cu_padded_cpu[i]) // cp_size\n half_seqlen = s_len_padded_chunk // 2\n s_len = seq_lens_cpu[i]\n s_len_padded = s_len_padded_chunk * cp_size\n tmp = torch.empty(s_len_padded, *output.shape[2:], device=output.device, dtype=output.dtype)\n for j in range(cp_size):\n o = output_list[j][0]\n # split to 2 chunks\n packed_start_idx = cu_padded_cpu[i] // cp_size\n o0, o1 = (\n o[packed_start_idx : packed_start_idx + half_seqlen],\n o[packed_start_idx + half_seqlen : packed_start_idx + s_len_padded_chunk],\n )\n tmp[j * half_seqlen : (j + 1) * half_seqlen] = o0\n tmp[s_len_padded - (j + 1) * half_seqlen : s_len_padded - j * half_seqlen] = o1\n output_new[i, attention_mask[i]] = tmp[:s_len]\n\n return output_new\n\n\ndef preprocess_bshd(\n input_ids: torch.Tensor,\n attention_mask: torch.Tensor,\n position_ids: torch.Tensor,\n sequence_parallel: bool = False,\n pre_process: bool = True,\n):\n \"\"\"\n Remove left padding from input_ids, attention_mask and position_ids\n return new_input_ids, new_attention_mask, new_position_ids\n \"\"\"\n assert attention_mask.ndim == 2\n assert position_ids.ndim == 2\n cp_size = mpu.get_context_parallel_world_size()\n assert cp_size == 1, \"Context parallel size without seq_pack is not supported\"\n batch_size = input_ids.shape[0]\n shape = list(input_ids.shape) # batch_size, seq_len,...\n seq_lens = attention_mask.sum(dim=1)\n seq_len = seq_lens.max().item()\n if sequence_parallel:\n sp_world_size = mpu.get_tensor_model_parallel_world_size()\n pad_size = (sp_world_size - seq_len % sp_world_size) % sp_world_size\n seq_len = seq_len + pad_size\n shape[1] = seq_len\n if pre_process:\n new_input_ids = torch.zeros(dtype=input_ids.dtype, device=input_ids.device, size=shape)\n new_attention_mask = torch.zeros(\n dtype=attention_mask.dtype, device=attention_mask.device, size=(batch_size, seq_len)\n )\n new_position_ids = torch.zeros(dtype=position_ids.dtype, device=position_ids.device, size=(batch_size, seq_len))\n for i in range(batch_size):\n if pre_process:\n new_input_ids[i, : seq_lens[i]] = input_ids[i, attention_mask[i]]\n new_attention_mask[i, : seq_lens[i]] = attention_mask[i, attention_mask[i]]\n new_position_ids[i, : seq_lens[i]] = position_ids[i, attention_mask[i]]\n if pre_process:\n return new_input_ids, new_attention_mask, new_position_ids\n else:\n return input_ids, new_attention_mask, new_position_ids\n\n\ndef postprocess_bshd(\n result,\n attention_mask: torch.Tensor,\n original_attention_mask: torch.Tensor,\n origin_seqlen: int,\n post_process: bool = True,\n):\n \"\"\"\n Recover left padding from result\n return result\n \"\"\"\n if not post_process:\n return result\n shape = list(result.shape)\n batch_size = shape[0]\n shape[1] = origin_seqlen\n new_result = torch.zeros(dtype=result.dtype, device=result.device, size=shape)\n for i in range(batch_size):\n new_result[i, original_attention_mask[i]] = result[i, attention_mask[i]]\n return new_result\n\n\ndef postprocess_packed_seqs_for_dict_output(\n labels_mask: torch.Tensor,\n output: CausalLMOutputForPPO,\n packed_seq_params: PackedSeqParams,\n attention_mask: torch.Tensor,\n batch_size: int,\n seq_len: int,\n post_process: bool = True,\n) -> dict[str, torch.Tensor]:\n \"\"\"_summary_\n For fused kernels, the output is a dictionary with keys like 'log_probs', 'entropy', etc.\n This function post-processes each tensor in the output dictionary.\n Args:\n output (CausalLMOutputForPPO): _description_\n packed_seq_params (PackedSeqParams): _description_\n attention_mask (torch.Tensor): _description_\n batch_size (int): _description_\n seq_len (int): _description_\n post_process (bool, optional): _description_. Defaults to True.\n Returns:\n CausalLMOutputForPPO: _description_\n \"\"\"\n ret = {}\n output.entropy = output.entropy.view(1, -1)\n output.log_probs = output.log_probs.view(1, -1)\n output.log_probs = output.log_probs.masked_fill(~labels_mask, 0.0)\n ret[\"entropy\"] = postprocess_packed_seqs(\n output.entropy, packed_seq_params, attention_mask, batch_size, seq_len, post_process=post_process\n )\n ret[\"log_probs\"] = postprocess_packed_seqs(\n output.log_probs, packed_seq_params, attention_mask, batch_size, seq_len, post_process=post_process\n )\n return ret\n\n\n### No padding versions for model engine\n### inputs are nested tensors\n\n\ndef preprocess_thd_no_padding(\n input_ids: torch.Tensor, pre_process: bool = True, need_roll: bool = False\n) -> tuple[torch.Tensor, PackedSeqParams]:\n \"\"\"\n Preprocess packed sequences\n CP splits sequence into CP*2 chunks, and each GPU gets 2 chunks (GPU0 gets first and last chunks, GPU1\n gets second and second last chunks, and so on), this is for load balancing with causal masking.\n See https://github.com/NVIDIA/TransformerEngine/issues/1368\n \"\"\"\n batch_size = input_ids.shape[0]\n\n tp_size = mpu.get_tensor_model_parallel_world_size()\n cp_size = mpu.get_context_parallel_world_size()\n cp_rank = mpu.get_context_parallel_rank()\n align_size = tp_size * cp_size * 2 if cp_size > 1 else tp_size\n seqlens_in_batch = input_ids.offsets().diff()\n\n pad_size = (align_size - seqlens_in_batch % align_size) % align_size\n seqlens_in_batch_padded = seqlens_in_batch + pad_size\n\n cu_seqlens = torch.zeros(batch_size + 1, dtype=torch.int32, device=input_ids.device)\n cu_seqlens[1:] = torch.cumsum(seqlens_in_batch, dim=0)\n cu_seqlens_padded = torch.zeros(batch_size + 1, dtype=torch.int32, device=input_ids.device)\n cu_seqlens_padded[1:] = torch.cumsum(seqlens_in_batch_padded, dim=0)\n\n # ----------------------------------------------------------------------------\n # Move the index information needed in the subsequent loop to the CPU at once,\n # to avoid frequent .item() calls in the loop that cause D2H synchronization\n # ----------------------------------------------------------------------------\n seqlens_in_batch_cpu: list[int] = seqlens_in_batch.tolist() # original valid lengths\n seqlens_in_batch_padded_cpu: list[int] = seqlens_in_batch_padded.tolist() # lengths after padding\n cu_seqlens_padded_cpu: list[int] = cu_seqlens_padded.tolist() # start positions (after padding)\n\n # Pure Python int calculation to avoid further synchronization\n max_seqlen_in_batch = max(seqlens_in_batch_padded_cpu)\n\n shape = list(input_ids.shape[1:])\n shape[0] = sum(seqlens_in_batch_padded_cpu) // cp_size\n if pre_process:\n input_ids_rmpad = torch.zeros(shape, dtype=input_ids.dtype, device=input_ids.device)\n if need_roll:\n saved_roll_dict = {}\n for i in range(batch_size):\n # Use Python int, so no GPU→CPU sync in the loop\n if cp_size <= 1:\n seqlen = seqlens_in_batch_cpu[i]\n start_idx = cu_seqlens_padded_cpu[i]\n input_ids_rmpad[start_idx : start_idx + seqlen] = input_ids[i]\n continue\n\n seqlen_padded_i = seqlens_in_batch_padded_cpu[i]\n seqlen = seqlen_padded_i // cp_size\n half_seqlen = seqlen // 2\n start_idx = cu_seqlens_padded_cpu[i] // cp_size\n # split to 2 chunks\n d = input_ids[i]\n input_ids_rmpad[start_idx : start_idx + half_seqlen] = d[\n half_seqlen * cp_rank : half_seqlen * (cp_rank + 1)\n ]\n\n remain_start = seqlen_padded_i - half_seqlen * (cp_rank + 1)\n remain_end = seqlen_padded_i - half_seqlen * cp_rank\n remain_end = min(remain_end, d.shape[0])\n remain_len = remain_end - remain_start\n if remain_len > 0:\n input_ids_rmpad[start_idx + half_seqlen : start_idx + half_seqlen + remain_len] = d[\n remain_start:remain_end\n ]\n\n if need_roll:\n # Handle roll for cp_size > 1 case\n saved_roll_dict[start_idx + half_seqlen - 1] = d[(cp_rank + 1) * half_seqlen]\n if remain_len > 0:\n if remain_end == d.shape[0]:\n saved_roll_dict[start_idx + half_seqlen + remain_len - 1] = d[0]\n else:\n saved_roll_dict[start_idx + half_seqlen + remain_len - 1] = d[remain_end]\n\n if need_roll:\n input_ids_rmpad = torch.roll(input_ids_rmpad, shifts=-1, dims=0)\n if len(saved_roll_dict) > 0:\n for k, v in saved_roll_dict.items():\n input_ids_rmpad[k] = v\n\n packed_seq_params = PackedSeqParams(\n qkv_format=\"thd\",\n cu_seqlens_q=cu_seqlens_padded,\n max_seqlen_q=max_seqlen_in_batch,\n cu_seqlens_kv=cu_seqlens_padded,\n max_seqlen_kv=max_seqlen_in_batch,\n cu_seqlens_q_padded=cu_seqlens_padded,\n cu_seqlens_kv_padded=cu_seqlens_padded,\n )\n if pre_process:\n return input_ids_rmpad.unsqueeze(0), packed_seq_params\n else:\n return input_ids, packed_seq_params\n\n\ndef postprocess_thd_no_padding(\n output: torch.Tensor,\n packed_seq_params: PackedSeqParams,\n input_ids: torch.Tensor,\n batch_size: int,\n post_process: bool = True,\n) -> torch.Tensor:\n \"\"\"\n Postprocess packed sequences\n \"\"\"\n if not post_process:\n return output\n\n # -------------------------------------------------------------------------\n # Move the lengths and offsets needed for subsequent Python-level indexing to the CPU in advance,\n # to avoid a large number of .item() calls in the loop\n # -------------------------------------------------------------------------\n cu_padded_cpu: list[int] = packed_seq_params.cu_seqlens_q_padded.tolist()\n # The reason why we use input_ids.offsets() instead of packed_seq_params.cu_seqlens_q.diff()\n # is that the latter one is the padded length, while the former one is the original length.\n cu_seqlens = input_ids.offsets()\n seq_lens_cpu: list[int] = cu_seqlens.diff().tolist()\n\n output_new = []\n\n cp_size = mpu.get_context_parallel_world_size()\n # all gather output across context parallel group\n if cp_size > 1:\n # output shape: [1, packed_len, hidden_dim]\n # need to gather across cp group and concatenate in sequence dimension\n output_list = [torch.empty_like(output) for _ in range(cp_size)]\n torch.distributed.all_gather(output_list, output.detach(), group=mpu.get_context_parallel_group())\n output_list[mpu.get_context_parallel_rank()] = output\n else:\n output_list = [output]\n\n for i in range(batch_size):\n if cp_size <= 1:\n s = seq_lens_cpu[i]\n start_idx = cu_padded_cpu[i]\n output_new.append(output[0][start_idx : start_idx + s])\n continue\n s_len_padded_chunk = (cu_padded_cpu[i + 1] - cu_padded_cpu[i]) // cp_size\n half_seqlen = s_len_padded_chunk // 2\n s_len = seq_lens_cpu[i]\n s_len_padded = s_len_padded_chunk * cp_size\n tmp = torch.empty(s_len_padded, *output.shape[2:], device=output.device)\n for j in range(cp_size):\n o = output_list[j][0]\n # split to 2 chunks\n packed_start_idx = cu_padded_cpu[i] // cp_size\n o0, o1 = (\n o[packed_start_idx : packed_start_idx + half_seqlen],\n o[packed_start_idx + half_seqlen : packed_start_idx + s_len_padded_chunk],\n )\n tmp[j * half_seqlen : (j + 1) * half_seqlen] = o0\n tmp[s_len_padded - (j + 1) * half_seqlen : s_len_padded - j * half_seqlen] = o1\n output_new.append(tmp[:s_len])\n\n output_new_tensor = torch.nested.as_nested_tensor(output_new, layout=torch.jagged)\n\n return output_new_tensor\n\n\ndef preprocess_bshd_no_padding(input_ids: torch.Tensor, pre_process: bool = True, need_roll: bool = False):\n \"\"\"\n Preprocess bshd sequences\n return \"input_ids, attention_mask, position_ids\"\n \"\"\"\n cp_size = mpu.get_context_parallel_world_size()\n # TODO: support context parallel size > 1\n assert cp_size == 1, \"Context parallel size without bshd is not supported yet\"\n\n batch_size = input_ids.shape[0]\n seqlens_in_batch = input_ids.offsets().diff()\n max_seqlen = seqlens_in_batch.max().item()\n if mpu.get_tensor_model_parallel_world_size() > 1:\n sp_world_size = mpu.get_tensor_model_parallel_world_size()\n pad_size = (sp_world_size - max_seqlen % sp_world_size) % sp_world_size\n max_seqlen = max_seqlen + pad_size\n\n attention_mask = torch.zeros(batch_size, max_seqlen, dtype=torch.bool, device=input_ids.device)\n input_ids_bshd = torch.zeros(batch_size, max_seqlen, dtype=input_ids.dtype, device=input_ids.device)\n for i in range(batch_size):\n attention_mask[i, : seqlens_in_batch[i]] = True\n input_ids_bshd[i, : seqlens_in_batch[i]] = input_ids[i]\n position_ids = torch.arange(max_seqlen, dtype=torch.long, device=input_ids.device)\n position_ids = position_ids.unsqueeze(0).expand_as(input_ids_bshd)\n if need_roll:\n input_ids_bshd = torch.roll(input_ids_bshd, shifts=-1, dims=1)\n\n return input_ids_bshd, attention_mask, position_ids\n\n\ndef postprocess_bshd_no_padding(\n output: torch.Tensor,\n attention_mask: torch.Tensor,\n post_process: bool = True,\n) -> torch.Tensor:\n \"\"\"\n Postprocess bshd sequences\n \"\"\"\n if not post_process:\n return output\n\n batch_size = output.shape[0]\n output_new = []\n\n for i in range(batch_size):\n mask = attention_mask[i].bool()\n output_new.append(output[i][mask])\n\n output_new_tensor = torch.nested.as_nested_tensor(output_new, layout=torch.jagged)\n\n return output_new_tensor\n"} +{"file_name": "verl__models__mcore__weight_converter.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.\n# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# online convert mcore weight to pure huggingface weight, no any fusion\n# including format conversion and name mapping\n# not including resharding\nimport torch\nfrom megatron.core.transformer import TransformerConfig\nfrom transformers import PretrainedConfig\n\n\nclass McoreToHFWeightConverterBase:\n def __init__(self, hf_config: PretrainedConfig, mcore_config: TransformerConfig):\n self.hf_config = hf_config\n self.mcore_config = mcore_config\n\n def convert_param(self, name: str, params_one_group: list[torch.Tensor]) -> torch.Tensor:\n raise NotImplementedError\n\n\nclass McoreToHFWeightConverterDense(McoreToHFWeightConverterBase):\n def _convert_attention_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # 'decoder.layers.0.self_attention.linear_proj.weight'\n # 'decoder.layers.0.self_attention.linear_qkv.layer_norm_weight'\n # 'decoder.layers.0.self_attention.linear_qkv.weight'\n # 'decoder.layers.0.self_attention.linear_qkv.bias'\n layer_number = name.split(\".\")[2]\n convert_names = []\n if \"self_attention.linear_qkv.bias\" in name or \"self_attention.linear_qkv.weight\" in name:\n param_type = name.split(\".\")[-1]\n assert param_type == \"bias\" or param_type == \"weight\"\n convert_names.append(f\"model.layers.{layer_number}.self_attn.q_proj.{param_type}\")\n convert_names.append(f\"model.layers.{layer_number}.self_attn.k_proj.{param_type}\")\n convert_names.append(f\"model.layers.{layer_number}.self_attn.v_proj.{param_type}\")\n assert len(params) == 3\n elif \"self_attention.linear_proj.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.self_attn.o_proj.weight\")\n assert len(params) == 1\n elif \"self_attention.linear_qkv.layer_norm_weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.input_layernorm.weight\")\n assert len(params) == 1\n elif \"self_attention.q_layernorm.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.self_attn.q_norm.weight\")\n assert len(params) == 1\n elif \"self_attention.k_layernorm.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.self_attn.k_norm.weight\")\n assert len(params) == 1\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # 'decoder.layers.0.mlp.linear_fc1.layer_norm_weight'\n # 'decoder.layers.0.mlp.linear_fc1.weight'\n # 'decoder.layers.0.mlp.linear_fc2.weight'\n layer_number = name.split(\".\")[2]\n convert_names = []\n if \"mlp.linear_fc1.weight\" in name:\n # split gate_proj and up_proj\n convert_names.append(f\"model.layers.{layer_number}.mlp.gate_proj.weight\")\n convert_names.append(f\"model.layers.{layer_number}.mlp.up_proj.weight\")\n assert len(params) == 2\n elif \"mlp.linear_fc1.layer_norm_weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.post_attention_layernorm.weight\")\n assert len(params) == 1\n elif \"mlp.linear_fc2.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.mlp.down_proj.weight\")\n assert len(params) == 1\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n\n def convert_param(self, name: str, params_one_group: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n direct_name_mapping = {\n \"embedding.word_embeddings.weight\": \"model.embed_tokens.weight\",\n \"decoder.final_layernorm.weight\": \"model.norm.weight\",\n \"output_layer.weight\": \"lm_head.weight\",\n }\n if name in direct_name_mapping:\n return [direct_name_mapping[name]], [params_one_group[0]]\n\n if \"self_attention\" in name:\n return self._convert_attention_param(name, params_one_group)\n elif \"mlp\" in name:\n return self._convert_mlp_param(name, params_one_group)\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n\n\nclass McoreToHFWeightConverterQwen2Moe(McoreToHFWeightConverterDense):\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # 'decoder.layers.0.pre_mlp_layernorm.weight',\n # 'decoder.layers.0.mlp.router.weight',\n # 'decoder.layers.0.mlp.shared_experts.gate_weight',\n # 'decoder.layers.0.mlp.shared_experts.linear_fc1.weight',\n # 'decoder.layers.0.mlp.shared_experts.linear_fc2.weight'\n # moe1\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight0',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight1',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight2',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight3',\n # moe2\n # 'decoder.layers.0.mlp.experts.linear_fc2.weight0',\n # 'decoder.layers.0.mlp.experts.linear_fc2.weight1',\n layer_number = name.split(\".\")[2]\n convert_names = []\n if \"pre_mlp_layernorm\" in name:\n convert_names.append(f\"model.layers.{layer_number}.post_attention_layernorm.weight\")\n assert len(params) == 1\n elif \"mlp.router.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.mlp.gate.weight\")\n assert len(params) == 1\n elif \"shared_experts.gate_weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.mlp.shared_expert_gate.weight\")\n assert len(params) == 1\n elif \"shared_experts.linear_fc1.weight\" in name: # split gate_proj and up_proj\n convert_names.append(f\"model.layers.{layer_number}.mlp.shared_expert.gate_proj.weight\")\n convert_names.append(f\"model.layers.{layer_number}.mlp.shared_expert.up_proj.weight\")\n assert len(params) == 2\n elif \"shared_experts.linear_fc2.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.mlp.shared_expert.down_proj.weight\")\n assert len(params) == 1\n elif \"mlp.experts.linear_fc1\" in name: # split gate_proj and up_proj\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.gate_proj.weight\")\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.up_proj.weight\")\n assert len(params) == 2\n elif \"mlp.experts.linear_fc2\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.down_proj.weight\")\n assert len(params) == 1\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n\n\nclass McoreToHFWeightConverterQwen2_5_VL(McoreToHFWeightConverterDense):\n def convert_param(self, name: str, params_one_group: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n direct_name_mapping = {\n \"language_model.embedding.word_embeddings.weight\": \"model.embed_tokens.weight\",\n \"language_model.decoder.final_layernorm.weight\": \"model.norm.weight\",\n \"language_model.output_layer.weight\": \"lm_head.weight\",\n \"vision_model.patch_embed.proj.weight\": \"visual.patch_embed.proj.weight\",\n \"vision_model.decoder.final_layernorm.weight\": \"visual.merger.ln_q.weight\",\n \"vision_model.projection.encoder.linear_fc1.weight\": \"visual.merger.mlp.0.weight\",\n \"vision_model.projection.encoder.linear_fc1.bias\": \"visual.merger.mlp.0.bias\",\n \"vision_model.projection.encoder.linear_fc2.weight\": \"visual.merger.mlp.2.weight\",\n \"vision_model.projection.encoder.linear_fc2.bias\": \"visual.merger.mlp.2.bias\",\n }\n if name in direct_name_mapping:\n return [direct_name_mapping[name]], [params_one_group[0]]\n\n if \"self_attention\" in name:\n return self._convert_attention_param(name, params_one_group)\n elif \"mlp\" in name:\n return self._convert_mlp_param(name, params_one_group)\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n\n def _convert_attention_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n model_type, _, _, layer_number = name.split(\".\")[:4]\n\n convert_names = []\n if model_type == \"language_model\":\n name_map_after_layer = {\n \"self_attention.linear_qkv.bias\": [\n \"self_attn.q_proj.bias\",\n \"self_attn.k_proj.bias\",\n \"self_attn.v_proj.bias\",\n ],\n \"self_attention.linear_qkv.weight\": [\n \"self_attn.q_proj.weight\",\n \"self_attn.k_proj.weight\",\n \"self_attn.v_proj.weight\",\n ],\n \"self_attention.linear_proj.weight\": \"self_attn.o_proj.weight\",\n \"self_attention.linear_qkv.layer_norm_weight\": \"input_layernorm.weight\",\n }\n name_after_layer = \".\".join(name.split(\".\")[-3:])\n mapped_name = name_map_after_layer.get(name_after_layer)\n if isinstance(mapped_name, list):\n assert len(params) == len(mapped_name)\n for one in mapped_name:\n convert_names.append(f\"model.layers.{layer_number}.{one}\")\n else:\n assert len(params) == 1\n convert_names.append(f\"model.layers.{layer_number}.{mapped_name}\")\n elif model_type == \"vision_model\":\n name_map_after_layer = {\n \"self_attention.linear_proj.weight\": \"attn.proj.weight\",\n \"self_attention.linear_proj.bias\": \"attn.proj.bias\",\n \"self_attention.linear_qkv.layer_norm_weight\": \"norm1.weight\",\n }\n name_after_layer = \".\".join(name.split(\".\")[-3:])\n mapped_name = name_map_after_layer.get(name_after_layer, None)\n if mapped_name is None:\n assert \"linear_qkv\" in name_after_layer\n assert len(params) == 3\n new_param = torch.cat(params, dim=0)\n params = [new_param]\n if \"bias\" in name_after_layer:\n convert_names.append(f\"visual.blocks.{layer_number}.attn.qkv.bias\")\n else:\n convert_names.append(f\"visual.blocks.{layer_number}.attn.qkv.weight\")\n else:\n assert len(params) == 1\n convert_names.append(f\"visual.blocks.{layer_number}.{mapped_name}\")\n else:\n raise NotImplementedError(f\"Unsupported model type: {model_type}\")\n return convert_names, params\n\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n model_type, _, _, layer_number = name.split(\".\")[:4]\n\n convert_names = []\n if model_type == \"language_model\":\n name_map_after_layer = {\n \"mlp.linear_fc1.weight\": [\"mlp.gate_proj.weight\", \"mlp.up_proj.weight\"],\n \"mlp.linear_fc1.bias\": [\"mlp.gate_proj.bias\", \"mlp.up_proj.bias\"],\n \"mlp.linear_fc2.weight\": \"mlp.down_proj.weight\",\n \"mlp.linear_fc2.bias\": \"mlp.down_proj.bias\",\n \"mlp.linear_fc1.layer_norm_weight\": \"post_attention_layernorm.weight\",\n }\n name_after_layer = \".\".join(name.split(\".\")[-3:])\n mapped_name = name_map_after_layer.get(name_after_layer)\n if isinstance(mapped_name, list):\n assert len(params) == len(mapped_name)\n for one in mapped_name:\n convert_names.append(f\"model.layers.{layer_number}.{one}\")\n else:\n assert len(params) == 1\n convert_names.append(f\"model.layers.{layer_number}.{mapped_name}\")\n\n elif model_type == \"vision_model\":\n name_map_after_layer = {\n \"mlp.linear_fc1.weight\": [\"mlp.gate_proj.weight\", \"mlp.up_proj.weight\"],\n \"mlp.linear_fc1.bias\": [\"mlp.gate_proj.bias\", \"mlp.up_proj.bias\"],\n \"mlp.linear_fc2.weight\": \"mlp.down_proj.weight\",\n \"mlp.linear_fc2.bias\": \"mlp.down_proj.bias\",\n \"mlp.linear_fc1.layer_norm_weight\": \"norm2.weight\",\n }\n name_after_layer = \".\".join(name.split(\".\")[-3:])\n mapped_name = name_map_after_layer.get(name_after_layer)\n if isinstance(mapped_name, list):\n assert len(params) == len(mapped_name)\n for one in mapped_name:\n convert_names.append(f\"visual.blocks.{layer_number}.{one}\")\n else:\n assert len(params) == 1\n convert_names.append(f\"visual.blocks.{layer_number}.{mapped_name}\")\n else:\n raise NotImplementedError(f\"Unsupported model type: {model_type}\")\n return convert_names, params\n\n\nclass McoreToHFWeightConverterDpskv3(McoreToHFWeightConverterBase):\n def _convert_attention_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # mcore\n # 'decoder.layers.0.input_layernorm.weight'\n # 'decoder.layers.0.self_attention.linear_proj.weight'\n # 'decoder.layers.0.self_attention.linear_q_proj.weight'\n # 'decoder.layers.0.self_attention.linear_kv_down_proj.weight'\n # 'decoder.layers.0.self_attention.linear_kv_up_proj.layer_norm_weight'\n # 'decoder.layers.0.self_attention.linear_kv_up_proj.weight'\n # 'decoder.layers.0.self_attention.linear_q_down_proj.weight'\n # 'decoder.layers.0.self_attention.linear_q_up_proj.weight'\n # 'decoder.layers.0.self_attention.linear_q_up_proj.layer_norm_weight'\n # hf\n # 'model.layers.0.input_layernorm.weight'\n # 'model.layers.0.self_attn.o_proj.weight'\n # 'model.layers.0.self_attn.q_proj.weight'\n # 'model.layers.0.self_attn.kv_a_proj_with_mqa.weight'\n # 'model.layers.0.self_attn.kv_a_layernorm.weight'\n # 'model.layers.0.self_attn.kv_b_proj.weight'\n # 'model.layers.0.self_attn.q_a_proj.weight'\n # 'model.layers.0.self_attn.q_b_proj.weight'\n # 'model.layers.0.self_attn.q_a_layernorm.weight'\n name_map_after_layer = {\n \"input_layernorm.weight\": \"input_layernorm.weight\",\n \"self_attention.linear_proj.weight\": \"self_attn.o_proj.weight\",\n \"self_attention.linear_q_proj.weight\": \"self_attn.q_proj.weight\",\n \"self_attention.linear_kv_down_proj.weight\": \"self_attn.kv_a_proj_with_mqa.weight\",\n \"self_attention.linear_kv_up_proj.layer_norm_weight\": \"self_attn.kv_a_layernorm.weight\",\n \"self_attention.linear_kv_up_proj.weight\": \"self_attn.kv_b_proj.weight\",\n \"self_attention.linear_q_down_proj.weight\": \"self_attn.q_a_proj.weight\",\n \"self_attention.linear_q_up_proj.weight\": \"self_attn.q_b_proj.weight\",\n \"self_attention.linear_q_up_proj.layer_norm_weight\": \"self_attn.q_a_layernorm.weight\",\n }\n assert len(params) == 1\n convert_names = []\n layer_number = name.split(\".\")[2]\n name_after_layer = name.split(f\".{layer_number}.\")[1]\n convert_names.append(f\"model.layers.{layer_number}.{name_map_after_layer[name_after_layer]}\")\n return convert_names, params\n\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # mcore dense\n # 'decoder.layers.0.mlp.linear_fc1.layer_norm_weight'\n # 'decoder.layers.0.mlp.linear_fc2.weight'\n # 'decoder.layers.0.mlp.linear_fc1.weight'\n # ---\n # 'decoder.layers.1.mlp.shared_experts.linear_fc1.weight'\n # ---\n # 'decoder.layers.1.mlp.shared_experts.linear_fc2.weight'\n # hf dense\n # 'model.layers.0.post_attention_layernorm.weight'\n # 'model.layers.0.mlp.down_proj.weight'\n # 'model.layers.0.mlp.gate_proj.weight'\n # 'model.layers.0.mlp.up_proj.weight'\n # 'model.layers.1.mlp.shared_experts.gate_proj.weight'\n # 'model.layers.1.mlp.shared_experts.up_proj.weight'\n # 'model.layers.1.mlp.shared_experts.down_proj.weight'\n\n # mcore moe\n # 'decoder.layers.1.pre_mlp_layernorm.weight'\n # 'decoder.layers.1.mlp.router.weight'\n # 'decoder.layers.1.mlp.router.expert_bias'\n # 'decoder.layers.1.mlp.experts.linear_fc1.weight0'\n # ---\n # 'decoder.layers.1.mlp.experts.linear_fc2.weight0'\n # hf moe\n # 'model.layers.1.post_attention_layernorm.weight'\n # 'model.layers.1.mlp.gate.weight'\n # 'model.layers.1.mlp.gate.e_score_correction_bias'\n # 'model.layers.1.mlp.experts.0.gate_proj.weight'\n # 'model.layers.1.mlp.experts.0.up_proj.weight'\n # 'model.layers.1.mlp.experts.0.down_proj.weight'\n\n name_map_after_layer = {\n \"mlp.linear_fc1.layer_norm_weight\": \"post_attention_layernorm.weight\",\n \"mlp.linear_fc2.weight\": \"mlp.down_proj.weight\",\n \"mlp.shared_experts.linear_fc2.weight\": \"mlp.shared_experts.down_proj.weight\",\n \"mlp.linear_fc1.weight\": [\"mlp.gate_proj.weight\", \"mlp.up_proj.weight\"],\n \"mlp.shared_experts.linear_fc1.weight\": [\n \"mlp.shared_experts.gate_proj.weight\",\n \"mlp.shared_experts.up_proj.weight\",\n ],\n \"pre_mlp_layernorm.weight\": \"post_attention_layernorm.weight\",\n \"mlp.router.weight\": \"mlp.gate.weight\",\n \"mlp.router.expert_bias\": \"mlp.gate.e_score_correction_bias\",\n }\n convert_names = []\n layer_number = name.split(\".\")[2]\n name_after_layer = name.split(f\".{layer_number}.\")[1]\n if name_after_layer in name_map_after_layer:\n mapped_name = name_map_after_layer[name_after_layer]\n if isinstance(mapped_name, list):\n assert len(params) == len(mapped_name)\n for one in mapped_name:\n convert_names.append(f\"model.layers.{layer_number}.{one}\")\n else:\n assert len(params) == 1\n convert_names.append(f\"model.layers.{layer_number}.{mapped_name}\")\n else:\n if \"mlp.experts.linear_fc1.weight\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.gate_proj.weight\")\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.up_proj.weight\")\n assert len(params) == 2\n elif \"mlp.experts.linear_fc2.weight\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.down_proj.weight\")\n assert len(params) == 1\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n\n return convert_names, params\n\n def _convert_mtp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n assert self.mcore_config.mtp_num_layers == 1, \"only support one mtp layer for now\"\n assert self.mcore_config.num_layers == 61, \"only support 61 layers for now\"\n direct_name_mapping = {\n \"mtp.layers.0.enorm.weight\": \"model.layers.61.enorm.weight\",\n \"mtp.layers.0.hnorm.weight\": \"model.layers.61.hnorm.weight\",\n \"mtp.layers.0.eh_proj.weight\": \"model.layers.61.eh_proj.weight\",\n \"mtp.layers.0.final_layernorm.weight\": \"model.layers.61.shared_head.norm.weight\",\n }\n if name in direct_name_mapping:\n return [direct_name_mapping[name]], [params[0]]\n assert \"mtp.layers.0.transformer_layer\" in name, \"only support transformer layer for now\"\n # use proxy name to convert\n proxy_name = name.replace(\"mtp.layers.0.transformer_layer\", \"decoder.layers.61\")\n if \"self_attention\" in proxy_name or \"input_layernorm.weight\" in proxy_name:\n convert_names, params = self._convert_attention_param(proxy_name, params)\n elif \"mlp\" in proxy_name:\n convert_names, params = self._convert_mlp_param(proxy_name, params)\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n\n def convert_param(self, name: str, params_one_group: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n direct_name_mapping = {\n \"embedding.word_embeddings.weight\": \"model.embed_tokens.weight\",\n \"decoder.final_layernorm.weight\": \"model.norm.weight\",\n \"output_layer.weight\": \"lm_head.weight\",\n }\n if name in direct_name_mapping:\n return [direct_name_mapping[name]], [params_one_group[0]]\n if \"mtp\" in name:\n return self._convert_mtp_param(name, params_one_group)\n elif \"self_attention\" in name or \"input_layernorm.weight\" in name:\n return self._convert_attention_param(name, params_one_group)\n elif \"mlp\" in name:\n return self._convert_mlp_param(name, params_one_group)\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n\n\nclass McoreToHFWeightConverterMixtral(McoreToHFWeightConverterDense):\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # decoder.layers.0.mlp.router.weight\n # decoder.layers.0.mlp.experts.linear_fc1.weight0 - weight7\n # decoder.layers.0.mlp.experts.linear_fc2.weight0 - weight7\n\n layer_number = name.split(\".\")[2]\n convert_names = []\n if \"pre_mlp_layernorm\" in name:\n convert_names.append(f\"model.layers.{layer_number}.post_attention_layernorm.weight\")\n elif \"mlp.router.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.block_sparse_moe.gate.weight\")\n elif \"mlp.experts.linear_fc1.weight\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.block_sparse_moe.experts.{expert_id}.w1.weight\")\n convert_names.append(f\"model.layers.{layer_number}.block_sparse_moe.experts.{expert_id}.w3.weight\")\n elif \"mlp.experts.linear_fc2.weight\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.block_sparse_moe.experts.{expert_id}.w2.weight\")\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n\n\nclass McoreToHFWeightConverterQwen3Moe(McoreToHFWeightConverterDense):\n def _convert_mlp_param(self, name: str, params: list[torch.Tensor]) -> tuple[list[str], list[torch.Tensor]]:\n # qwen3 moe no share expert\n\n # 'decoder.layers.0.pre_mlp_layernorm.weight',\n # 'decoder.layers.0.mlp.router.weight',\n # moe1\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight0',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight1',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight2',\n # 'decoder.layers.0.mlp.experts.linear_fc1.weight3',\n # moe2\n # 'decoder.layers.0.mlp.experts.linear_fc2.weight0',\n # 'decoder.layers.0.mlp.experts.linear_fc2.weight1',\n layer_number = name.split(\".\")[2]\n convert_names = []\n if \"pre_mlp_layernorm\" in name:\n convert_names.append(f\"model.layers.{layer_number}.post_attention_layernorm.weight\")\n assert len(params) == 1\n elif \"mlp.router.weight\" in name:\n convert_names.append(f\"model.layers.{layer_number}.mlp.gate.weight\")\n assert len(params) == 1\n elif \"mlp.experts.linear_fc1\" in name: # split gate_proj and up_proj\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.gate_proj.weight\")\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.up_proj.weight\")\n assert len(params) == 2\n elif \"mlp.experts.linear_fc2\" in name:\n expert_id = name.split(\"weight\")[-1]\n convert_names.append(f\"model.layers.{layer_number}.mlp.experts.{expert_id}.down_proj.weight\")\n assert len(params) == 1\n else:\n raise NotImplementedError(f\"Unsupported parameter name: {name}\")\n return convert_names, params\n"} +{"file_name": "verl__models__qwen2__megatron__checkpoint_utils__qwen2_loader.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\n\nfrom verl.utils.device import get_device_id, get_torch_device\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef load_state_dict_to_megatron_qwen2(\n state_dict, wrapped_models, config, params_dtype, is_value_model=False, tie_word_embeddings=False\n):\n \"\"\"Load merged state_dict to sharded Megatron module in training.\"\"\"\n from megatron.core import DistributedDataParallel as LocalDDP\n from megatron.core import mpu\n from megatron.core.transformer.module import Float16Module\n from torch.nn.parallel import DistributedDataParallel as torchDDP\n\n from verl.utils.logger import print_rank_0\n from verl.utils.megatron_utils import unwrap_model\n\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n def fetch_params(module):\n for param in module.parameters():\n torch.distributed.fetch(\n param.data, src=mpu.get_data_parallel_src_rank(), group=mpu.get_data_parallel_group()\n )\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if torch.distributed.get_rank() == 0:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers, (\n f\"num_layers_per_model: {num_layers_per_model} * pp_size: {pp_size} * virtual_pp_size: \"\n f\"{virtual_pp_size} != config.num_hidden_layers: {config.num_hidden_layers}\"\n )\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n gpt_model_module = _get_gpt_model(models[i])\n assert len(gpt_model_module.model.layers) == num_layers_per_model\n\n def _fetch_tensor(tensor, name) -> torch.Tensor:\n \"\"\"fetch tensor\"\"\"\n nonlocal state_dict\n if tensor is not None:\n tensor = tensor.data.copy_(state_dict[name], non_blocking=True)\n\n def _fetch_tp_shard_tensor_vocab(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards\"\"\"\n nonlocal state_dict\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n if tensor is not None:\n tensor = tensor.data.copy_(tensor_chunk[tp_rank], non_blocking=True)\n else:\n print(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards\"\"\"\n nonlocal state_dict\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n if tensor is not None:\n tensor = tensor.data.copy_(tensor_chunk[tp_rank], non_blocking=True)\n else:\n print(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor_gate_up(tensor, gate_name, up_name) -> torch.Tensor:\n \"\"\"fetch gate_up tensor in tp shards\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n if gate_name in state_dict and up_name in state_dict:\n gate_weight = state_dict[gate_name]\n up_weight = state_dict[up_name]\n new_gate_up_weight = torch.empty(\n config.intermediate_size * 2, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_tp = gate_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n up_weight_tp = up_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n new_gate_up_weight[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)].copy_(\n torch.cat([gate_weight_tp, up_weight_tp], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_gate_up_weight, tp_size, dim=0)\n if tensor is not None:\n tensor = tensor.data.copy_(tensor_chunk[tp_rank], non_blocking=True)\n else:\n print(f\"tp_shard tensor:[{gate_name}, {up_name}] not in state_dict, skip loading\")\n\n def _fetch_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name, bias=False) -> torch.Tensor:\n \"\"\"fetch tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n assert q_name in state_dict and k_name in state_dict and v_name in state_dict\n full_weight_q = state_dict[q_name]\n full_weight_k = state_dict[k_name]\n full_weight_v = state_dict[v_name]\n\n hidden_size_per_head = config.hidden_size // config.num_attention_heads\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n if not bias:\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n else:\n new_weight_qkv = torch.empty(total_size * tp_size, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n k_part = full_weight_k[i * kv_size_tp : (i + 1) * kv_size_tp]\n v_part = full_weight_v[i * kv_size_tp : (i + 1) * kv_size_tp]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(torch.cat([q_part, k_part, v_part], dim=0))\n\n else:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n if not bias:\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n else:\n new_weight_qkv = torch.empty(total_size * tp_size, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n start_idx = i * config.num_key_value_heads // tp_size * hidden_size_per_head\n end_idx = (i * config.num_key_value_heads // tp_size + 1) * hidden_size_per_head\n k_part = full_weight_k[start_idx:end_idx]\n v_part = full_weight_v[start_idx:end_idx]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(torch.cat([q_part, k_part, v_part], dim=0))\n\n tensor_chunk = torch.chunk(new_weight_qkv, tp_size, dim=0)\n if tensor is not None:\n tensor = tensor.data.copy_(tensor_chunk[tp_rank], non_blocking=True)\n\n # Embeddings\n # -------------------\n print_rank_0(\"loading embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n if pp_rank == 0:\n embed_tokens_weight = gpt_model_module.model.embed_tokens.weight\n _fetch_tp_shard_tensor_vocab(embed_tokens_weight, \"model.embed_tokens.weight\")\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n num_layer_per_pp = config.num_hidden_layers // pp_size\n vpp_size = mpu.get_virtual_pipeline_model_parallel_world_size()\n\n layer_list = []\n if vpp_size is not None:\n for vpp_rank in range(vpp_size):\n num_layer_vpp_chunk = num_layer_per_pp // vpp_size\n num_layer_this_model = num_layer_vpp_chunk\n offset = vpp_rank * (config.num_hidden_layers // mpu.get_virtual_pipeline_model_parallel_world_size()) + (\n mpu.get_pipeline_model_parallel_rank() * num_layer_vpp_chunk\n )\n layer_list.extend(list(range(offset, offset + num_layer_this_model)))\n else:\n num_layer_this_model = num_layer_per_pp\n offset = pp_rank * num_layer_per_pp\n layer_list.extend(list(range(offset, offset + num_layer_this_model)))\n\n for layer in layer_list:\n print(f\"{torch.distributed.get_rank()} loading layer #{layer}...\")\n layer_name = f\"model.layers.{layer}\"\n dst_pp_rank, dst_virtual_pp_rank, dst_layer_idx = layer_map[layer]\n\n print(\n f\"{torch.distributed.get_rank()} offset: {offset}, num_layer_this_model: {num_layer_this_model}, \"\n f\"layer_name: {layer_name}, layer_map[layer]: {layer_map[layer]}\"\n )\n\n gpt_model_module = _get_gpt_model(models[dst_virtual_pp_rank])\n sync_layer = gpt_model_module.model.layers[dst_layer_idx]\n\n _fetch_tensor(\n sync_layer.input_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.input_layernorm.weight\",\n )\n\n _fetch_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n )\n\n _fetch_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.bias if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.bias\",\n f\"{layer_name}.self_attn.k_proj.bias\",\n f\"{layer_name}.self_attn.v_proj.bias\",\n bias=True,\n )\n\n _fetch_tp_shard_tensor(\n sync_layer.self_attn.o_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.o_proj.weight\",\n chunk_dim=1,\n )\n\n _fetch_tensor(\n sync_layer.post_attention_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.post_attention_layernorm.weight\",\n )\n\n _fetch_tp_shard_tensor_gate_up(\n sync_layer.mlp.gate_up_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n )\n\n _fetch_tp_shard_tensor(\n sync_layer.mlp.down_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.down_proj.weight\",\n chunk_dim=1,\n )\n # Final Layernorm\n # -------------------\n print_rank_0(\"loading final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _fetch_tensor(\n getattr(gpt_model_module.model.norm, \"weight\", None),\n \"model.norm.weight\",\n )\n\n if tie_word_embeddings:\n print_rank_0(\"tie_word_embeddings skip load lm_head\")\n else:\n print_rank_0(\"loading lm_head...\")\n if pp_rank + 1 == pp_size:\n lm_head_weight = gpt_model_module.lm_head.weight\n\n if is_value_model:\n if \"lm_head.weight\" in state_dict and state_dict[\"lm_head.weight\"].shape[0] == 1:\n _fetch_tensor(lm_head_weight, \"lm_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n elif \"reward_head.weight\" in state_dict and state_dict[\"reward_head.weight\"].shape[0] == 1:\n _fetch_tensor(lm_head_weight, \"reward_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n else:\n _fetch_tensor(None, \"lm_head.weight\")\n print_rank_0(\"fail to match lm_head in value_model\")\n\n else:\n _fetch_tp_shard_tensor(lm_head_weight, \"lm_head.weight\")\n\n dist.barrier()\n get_torch_device().empty_cache()\n print_rank_0(f\"loading megatron ckpt done, time elapsed {time.time() - start_time}s\")\n"} +{"file_name": "verl__models__qwen2__megatron__checkpoint_utils__qwen2_loader_depracated.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport time\n\nimport torch\nimport torch.distributed as dist\n\nfrom verl.utils.device import get_device_id, get_torch_device\n\n\ndef _megatron_calc_layer_map(config):\n \"\"\"Calculate the mapping of global layer_idx to local layer_idx\n Returns:\n layer_map (Dict: int -> tuple(int, int, int)):\n mapping from the global layer index to\n a tuple of (pp_rank, virtual_pp_rank, layer_idx inside model)\n \"\"\"\n from megatron.core import mpu\n\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n\n layer_map = dict()\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers\n\n for pp_rank_idx in range(pp_size):\n for virtual_pp_rank_idx in range(virtual_pp_size):\n layer_offset = (\n virtual_pp_rank_idx * (config.num_hidden_layers // virtual_pp_size) + pp_rank_idx * num_layers_per_model\n )\n for layer_idx in range(num_layers_per_model):\n layer_map[layer_offset + layer_idx] = (\n pp_rank_idx,\n virtual_pp_rank_idx,\n layer_idx,\n )\n return layer_map\n\n\ndef load_state_dict_to_megatron_qwen2(\n state_dict, wrapped_models, config, params_dtype, is_value_model=False, tie_word_embeddings=False\n):\n \"\"\"Load merged state_dict to sharded Megatron module in training.\"\"\"\n from megatron.core import DistributedDataParallel as LocalDDP\n from megatron.core import mpu\n from megatron.core.transformer.module import Float16Module\n from torch.nn.parallel import DistributedDataParallel as torchDDP\n\n from verl.utils.logger import print_rank_0\n from verl.utils.megatron_utils import unwrap_model\n\n start_time = time.time()\n\n def _get_gpt_model(model):\n return model\n\n def broadcast_params(module):\n for param in module.parameters():\n torch.distributed.broadcast(\n param.data, src=mpu.get_data_parallel_src_rank(), group=mpu.get_data_parallel_group()\n )\n\n dp_rank = mpu.get_data_parallel_rank()\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n virtual_pp_size = mpu.get_virtual_pipeline_model_parallel_world_size() or 1\n mp_group = mpu.get_model_parallel_group()\n\n if torch.distributed.get_rank() == 0:\n assert mp_group.rank() == 0, f\"mp_rank:[{mp_group.rank}] != 0 on rank #0\"\n assert pp_rank == 0, f\"pp_rank:[{pp_rank}] != 0 on rank #0\"\n assert dp_rank == 0, f\"dp_rank:[{dp_rank}] != 0 on rank #0\"\n\n if not isinstance(wrapped_models, list | tuple):\n wrapped_models = list(wrapped_models)\n\n assert len(wrapped_models) == virtual_pp_size\n num_layers_per_model = config.num_hidden_layers // pp_size // virtual_pp_size\n assert num_layers_per_model * pp_size * virtual_pp_size == config.num_hidden_layers, (\n f\"num_layers_per_model: {num_layers_per_model} * pp_size: {pp_size} * virtual_pp_size: \"\n f\"{virtual_pp_size} != config.num_hidden_layers: {config.num_hidden_layers}\"\n )\n\n models = [None] * len(wrapped_models)\n\n for i, wrapped_model in enumerate(wrapped_models):\n models[i] = unwrap_model(wrapped_model, (torchDDP, LocalDDP, Float16Module))\n gpt_model_module = _get_gpt_model(models[i])\n assert len(gpt_model_module.model.layers) == num_layers_per_model\n\n def _broadcast_tensor(tensor, name) -> torch.Tensor:\n \"\"\"broadcast tensor from rank0 across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n if torch.distributed.get_rank() == 0:\n if name in state_dict:\n weight = state_dict[name]\n tensor_shape = weight.shape\n else:\n tensor_shape = None\n else:\n weight = None\n tensor_shape = None\n\n obj_list = [tensor_shape]\n dist.broadcast_object_list(obj_list, src=0, group=mp_group)\n tensor_shape = obj_list[0]\n\n if tensor_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tensor:[{name}] not in state_dict, skip load\")\n return\n\n if tensor is None:\n tensor = torch.empty(\n tensor_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n if torch.distributed.get_rank() == 0:\n tensor.data.copy_(weight)\n dist.broadcast(tensor, src=0, group=mp_group)\n\n def _broadcast_tp_shard_tensor_vocab(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == 0:\n if name in state_dict:\n full_weight = state_dict[name]\n\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=0, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == 0:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=0, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor(tensor, name, chunk_dim=0, mutate_func=None) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == 0:\n if name in state_dict:\n full_weight = state_dict[name]\n if mutate_func is not None:\n full_weight = mutate_func(full_weight)\n tensor_chunk = torch.chunk(full_weight, tp_size, dim=chunk_dim)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=0, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == 0:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=0, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor_gate_up(tensor, gate_name, up_name) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == 0:\n gate_weight = state_dict[gate_name]\n up_weight = state_dict[up_name]\n new_gate_up_weight = torch.empty(\n config.intermediate_size * 2, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n for i in range(tp_size):\n intermediate_size_tp = config.intermediate_size // tp_size\n gate_weight_tp = gate_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n up_weight_tp = up_weight[i * intermediate_size_tp : (i + 1) * intermediate_size_tp]\n new_gate_up_weight[intermediate_size_tp * 2 * i : intermediate_size_tp * 2 * (i + 1)].copy_(\n torch.cat([gate_weight_tp, up_weight_tp], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_gate_up_weight, tp_size, dim=0)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=0, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{gate_name, up_name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank() == 0:} tensor {gate_name, up_name} shape \"\n f\"{tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == 0:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=0, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n def _broadcast_tp_shard_tensor_qkv(tensor, q_name, k_name, v_name, bias=False) -> torch.Tensor:\n \"\"\"broadcast tensor in tp shards across mp_group\"\"\"\n nonlocal state_dict\n nonlocal mp_group\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n if torch.distributed.get_rank() == 0:\n assert q_name in state_dict and k_name in state_dict and v_name in state_dict\n full_weight_q = state_dict[q_name]\n full_weight_k = state_dict[k_name]\n full_weight_v = state_dict[v_name]\n\n hidden_size_per_head = config.hidden_size // config.num_attention_heads\n\n if config.num_key_value_heads >= tp_size:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head * config.num_key_value_heads // tp_size\n total_size = q_size_tp + 2 * kv_size_tp\n if not bias:\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n else:\n new_weight_qkv = torch.empty(total_size * tp_size, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n k_part = full_weight_k[i * kv_size_tp : (i + 1) * kv_size_tp]\n v_part = full_weight_v[i * kv_size_tp : (i + 1) * kv_size_tp]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(\n torch.cat([q_part, k_part, v_part], dim=0)\n )\n\n else:\n q_size_tp = config.hidden_size // tp_size\n kv_size_tp = hidden_size_per_head\n total_size = q_size_tp + 2 * kv_size_tp\n if not bias:\n new_weight_qkv = torch.empty(\n total_size * tp_size, config.hidden_size, dtype=params_dtype, device=get_device_id()\n )\n else:\n new_weight_qkv = torch.empty(total_size * tp_size, dtype=params_dtype, device=get_device_id())\n for i in range(tp_size):\n q_part = full_weight_q[i * q_size_tp : (i + 1) * q_size_tp]\n start_idx = i * config.num_key_value_heads // tp_size * hidden_size_per_head\n end_idx = (i * config.num_key_value_heads // tp_size + 1) * hidden_size_per_head\n k_part = full_weight_k[start_idx:end_idx]\n v_part = full_weight_v[start_idx:end_idx]\n new_weight_qkv[i * total_size : (i + 1) * total_size].copy_(\n torch.cat([q_part, k_part, v_part], dim=0)\n )\n\n tensor_chunk = torch.chunk(new_weight_qkv, tp_size, dim=0)\n chunk_shape = tensor_chunk[0].shape\n else:\n chunk_shape = None\n\n obj_list = [chunk_shape]\n dist.broadcast_object_list(obj_list, src=0, group=mp_group)\n chunk_shape = obj_list[0]\n if chunk_shape is None:\n # all or none ranks in the mp_group should reach here\n print_rank_0(f\"tp_shard tensor:[{q_name, k_name, v_name}] not in state_dict, skip loading\")\n return\n\n if tensor is None:\n sync_tensor = torch.empty(\n chunk_shape,\n dtype=params_dtype,\n device=get_device_id(),\n requires_grad=False,\n )\n else:\n assert tensor.shape == chunk_shape, (\n f\"rank #{torch.distributed.get_rank()} tensor {q_name} shape {tensor.shape} != {chunk_shape}\"\n )\n sync_tensor = torch.empty_like(tensor, device=get_device_id(), requires_grad=False)\n\n for i in range(tp_size):\n if torch.distributed.get_rank() == 0:\n sync_tensor.data.copy_(tensor_chunk[i])\n dist.broadcast(sync_tensor, src=0, group=mp_group)\n if (i == tp_rank) and (tensor is not None):\n tensor.data.copy_(sync_tensor)\n\n if dp_rank == 0:\n # Embeddings\n # -------------------\n print_rank_0(\"loading embeddings...\")\n gpt_model_module = _get_gpt_model(models[0])\n embed_tokens_weight = None\n if pp_rank == 0:\n embed_tokens_weight = gpt_model_module.model.embed_tokens.weight\n _broadcast_tp_shard_tensor_vocab(embed_tokens_weight, \"model.embed_tokens.weight\")\n\n # Transformer layers\n # -------------------\n layer_map = _megatron_calc_layer_map(config)\n\n for layer in range(config.num_hidden_layers):\n print_rank_0(f\"loading layer #{layer}...\")\n layer_name = f\"model.layers.{layer}\"\n dst_pp_rank, dst_virtual_pp_rank, dst_layer_idx = layer_map[layer]\n\n gpt_model_module = _get_gpt_model(models[dst_virtual_pp_rank])\n sync_layer = gpt_model_module.model.layers[dst_layer_idx]\n\n _broadcast_tensor(\n sync_layer.input_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.input_layernorm.weight\",\n )\n\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.weight\",\n f\"{layer_name}.self_attn.k_proj.weight\",\n f\"{layer_name}.self_attn.v_proj.weight\",\n )\n\n _broadcast_tp_shard_tensor_qkv(\n sync_layer.self_attn.qkv_proj.bias if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.q_proj.bias\",\n f\"{layer_name}.self_attn.k_proj.bias\",\n f\"{layer_name}.self_attn.v_proj.bias\",\n bias=True,\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.self_attn.o_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.self_attn.o_proj.weight\",\n chunk_dim=1,\n )\n\n _broadcast_tensor(\n sync_layer.post_attention_layernorm.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.post_attention_layernorm.weight\",\n )\n\n _broadcast_tp_shard_tensor_gate_up(\n sync_layer.mlp.gate_up_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.gate_proj.weight\",\n f\"{layer_name}.mlp.up_proj.weight\",\n )\n\n _broadcast_tp_shard_tensor(\n sync_layer.mlp.down_proj.weight if dst_pp_rank == pp_rank else None,\n f\"{layer_name}.mlp.down_proj.weight\",\n chunk_dim=1,\n )\n # Final Layernorm\n # -------------------\n print_rank_0(\"loading final layernorm...\")\n gpt_model_module = _get_gpt_model(models[-1])\n _broadcast_tensor(\n getattr(gpt_model_module.model.norm, \"weight\", None),\n \"model.norm.weight\",\n )\n\n if tie_word_embeddings:\n print_rank_0(\"tie_word_embeddings skip load lm_head\")\n else:\n print_rank_0(\"loading lm_head...\")\n lm_head_weight = None\n if pp_rank + 1 == pp_size:\n lm_head_weight = gpt_model_module.lm_head.weight\n\n if is_value_model:\n if \"lm_head.weight\" in state_dict and state_dict[\"lm_head.weight\"].shape[0] == 1:\n _broadcast_tensor(lm_head_weight, \"lm_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n elif \"reward_head.weight\" in state_dict and state_dict[\"reward_head.weight\"].shape[0] == 1:\n _broadcast_tensor(lm_head_weight, \"reward_head.weight\")\n print_rank_0(\"load lm_head from value_head weight\")\n else:\n _broadcast_tensor(None, \"lm_head.weight\")\n print_rank_0(\"fail to match lm_head in value_model\")\n\n else:\n _broadcast_tp_shard_tensor(lm_head_weight, \"lm_head.weight\")\n\n dist.barrier()\n # Broadcast weights inside data parallel groups\n for wrapped_model in wrapped_models:\n broadcast_params(wrapped_model)\n\n get_torch_device().empty_cache()\n print_rank_0(f\"loading megatron ckpt done, time elapsed {time.time() - start_time}s\")\n"} +{"file_name": "verl__models__qwen2__megatron__layers__parallel_attention.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport math\nfrom typing import Optional\n\nimport torch.nn.functional as F\nfrom einops import rearrange\nfrom transformers.utils import is_flash_attn_2_available\n\nif is_flash_attn_2_available():\n from flash_attn import flash_attn_varlen_func\n from flash_attn.bert_padding import index_first_axis, pad_input, unpad_input # noqa: F401\n\nimport torch\nfrom flash_attn.layers.rotary import apply_rotary_emb\nfrom megatron.core import ModelParallelConfig, tensor_parallel\nfrom megatron.core import parallel_state as mpu\nfrom torch import nn\nfrom transformers import Qwen2Config\n\nfrom verl.models.qwen2.megatron.layers.parallel_linear import QKVParallelLinear\nfrom verl.utils.megatron import tensor_parallel as tp_utils\n\n\nclass Qwen2RotaryEmbedding(nn.Module):\n def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None):\n super().__init__()\n\n self.dim = dim\n self.max_position_embeddings = max_position_embeddings\n self.base = base\n inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))\n self.register_buffer(\"inv_freq\", inv_freq, persistent=False)\n\n # Build here to make `torch.jit.trace` work.\n self._set_cos_sin_cache(\n seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype()\n )\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\"cos_cached\", emb.cos().to(dtype), persistent=False)\n self.register_buffer(\"sin_cached\", emb.sin().to(dtype), persistent=False)\n\n def forward(self, x, seq_len=None):\n # x: [bs, num_attention_heads, seq_len, head_size]\n if seq_len > self.max_seq_len_cached:\n self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype)\n\n return (\n self.cos_cached[:seq_len].to(dtype=x.dtype),\n self.sin_cached[:seq_len].to(dtype=x.dtype),\n )\n\n\nclass Qwen2LinearScalingRotaryEmbedding(Qwen2RotaryEmbedding):\n \"\"\"Qwen2RotaryEmbedding extended with linear scaling. Credits to the Reddit user /u/kaiokendev\"\"\"\n\n def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):\n self.scaling_factor = scaling_factor\n super().__init__(dim, max_position_embeddings, base, device)\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)\n t = t / self.scaling_factor\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\"cos_cached\", emb.cos().to(dtype), persistent=False)\n self.register_buffer(\"sin_cached\", emb.sin().to(dtype), persistent=False)\n\n\nclass Qwen2DynamicNTKScalingRotaryEmbedding(Qwen2RotaryEmbedding):\n \"\"\"Qwen2RotaryEmbedding extended with Dynamic NTK scaling. Credits to the Reddit users /u/bloc97 and /u/emozilla\"\"\"\n\n def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None, scaling_factor=1.0):\n self.scaling_factor = scaling_factor\n super().__init__(dim, max_position_embeddings, base, device)\n\n def _set_cos_sin_cache(self, seq_len, device, dtype):\n self.max_seq_len_cached = seq_len\n\n if seq_len > self.max_position_embeddings:\n base = self.base * (\n (self.scaling_factor * seq_len / self.max_position_embeddings) - (self.scaling_factor - 1)\n ) ** (self.dim / (self.dim - 2))\n inv_freq = 1.0 / (base ** (torch.arange(0, self.dim, 2).float().to(device) / self.dim))\n self.register_buffer(\"inv_freq\", inv_freq, persistent=False)\n\n t = torch.arange(self.max_seq_len_cached, device=device, dtype=self.inv_freq.dtype)\n\n freqs = torch.einsum(\"i,j->ij\", t, self.inv_freq)\n # Different from paper, but it uses a different permutation in order to obtain the same calculation\n emb = torch.cat((freqs, freqs), dim=-1)\n self.register_buffer(\"cos_cached\", emb.cos().to(dtype), persistent=False)\n self.register_buffer(\"sin_cached\", emb.sin().to(dtype), persistent=False)\n\n\ndef rotate_half(x):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\ndef apply_rotary_pos_emb(q, k, cos, sin, position_ids):\n cos = cos[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\n sin = sin[position_ids].unsqueeze(1) # [bs, 1, seq_len, dim]\n q_embed = (q * cos) + (rotate_half(q) * sin)\n k_embed = (k * cos) + (rotate_half(k) * sin)\n return q_embed, k_embed\n\n\ndef repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:\n \"\"\"\n This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,\n num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)\n \"\"\"\n batch, num_key_value_heads, slen, head_dim = hidden_states.shape\n if n_rep == 1:\n return hidden_states\n hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)\n return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)\n\n\nclass ParallelQwen2Attention(nn.Module):\n \"\"\"Multi-headed attention from 'Attention Is All You Need' paper\"\"\"\n\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config = config\n self.megatron_config = megatron_config\n self.hidden_size = config.hidden_size\n self.num_heads = config.num_attention_heads\n self.head_dim = self.hidden_size // self.num_heads\n self.num_key_value_heads = config.num_key_value_heads\n self.num_key_value_groups = self.num_heads // self.num_key_value_heads\n self.max_position_embeddings = config.max_position_embeddings\n self.rope_theta = config.rope_theta\n\n # assign values after tp\n tp_size = mpu.get_tensor_model_parallel_world_size()\n assert self.num_heads % tp_size == 0, (\n f\"num_head must be divisible by tp_size. Got num_head={self.num_heads}, tp_size={tp_size}\"\n )\n assert self.num_key_value_heads % tp_size == 0, (\n f\"num_key_value_heads must be divisible by tp_size. Got num_key_value_heads=\"\n f\"{self.num_key_value_heads}, tp_size={tp_size}\"\n )\n\n self.num_heads_per_tp = self.num_heads // tp_size\n self.num_key_value_heads_per_tp = self.num_key_value_heads // tp_size\n self.hidden_size_per_tp = self.hidden_size // tp_size\n\n if (self.head_dim * self.num_heads) != self.hidden_size:\n raise ValueError(\n f\"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size} and \"\n f\"`num_heads`: {self.num_heads}).\"\n )\n\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n row_kwargs = tp_utils.get_default_kwargs_for_row_parallel_linear()\n\n if megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n assert row_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, megatron_config)\n tp_utils.update_kwargs_with_config(row_kwargs, megatron_config)\n\n # [self.q_size, self.k_size, self.v_size]\n self.qkv_proj = QKVParallelLinear(\n input_size=self.hidden_size,\n num_heads=self.num_heads,\n num_key_value_heads=self.num_key_value_heads,\n head_dim=self.head_dim,\n # bias=config.attention_bias,\n bias=True,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n self.q_size = self.num_heads_per_tp * self.head_dim\n self.k_size = self.num_key_value_heads_per_tp * self.head_dim\n self.v_size = self.num_key_value_heads_per_tp * self.head_dim\n\n self.o_proj = tensor_parallel.RowParallelLinear(\n input_size=self.num_heads * self.head_dim,\n output_size=self.hidden_size,\n # bias=config.attention_bias,\n bias=False,\n input_is_parallel=True,\n skip_bias_add=False,\n **row_kwargs,\n )\n\n self._init_rope()\n\n def _init_rope(self):\n self.rotary_emb = Qwen2RotaryEmbedding(\n self.head_dim,\n max_position_embeddings=self.max_position_embeddings,\n base=self.rope_theta,\n )\n\n def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):\n return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous()\n\n def forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:\n bsz, q_len, _ = hidden_states.size()\n qkv = self.qkv_proj(hidden_states)[0]\n query_states, key_states, value_states = qkv.split([self.q_size, self.k_size, self.v_size], dim=-1)\n\n query_states = query_states.view(bsz, q_len, self.num_heads_per_tp, self.head_dim).transpose(1, 2)\n key_states = key_states.view(bsz, q_len, self.num_key_value_heads_per_tp, self.head_dim).transpose(1, 2)\n value_states = value_states.view(bsz, q_len, self.num_key_value_heads_per_tp, self.head_dim).transpose(1, 2)\n\n kv_seq_len = key_states.shape[-2]\n cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len)\n query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids)\n\n key_states = repeat_kv(key_states, self.num_key_value_groups)\n value_states = repeat_kv(value_states, self.num_key_value_groups)\n\n attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim)\n\n if attn_weights.size() != (bsz, self.num_heads_per_tp, q_len, kv_seq_len):\n raise ValueError(\n f\"Attention weights should be of size {(bsz, self.num_heads_per_tp, q_len, kv_seq_len)}, \"\n f\"but is {attn_weights.size()}\"\n )\n\n if attention_mask is not None:\n if attention_mask.size() != (bsz, 1, q_len, kv_seq_len):\n raise ValueError(\n f\"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}\"\n )\n attn_weights = attn_weights + attention_mask\n\n # upcast attention to fp32\n attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype)\n attn_output = torch.matmul(attn_weights, value_states)\n\n if attn_output.size() != (bsz, self.num_heads_per_tp, q_len, self.head_dim):\n raise ValueError(\n f\"`attn_output` should be of size {(bsz, self.num_heads_per_tp, q_len, self.head_dim)}, \"\n f\"but is {attn_output.size()}\"\n )\n\n attn_output = attn_output.transpose(1, 2).contiguous()\n attn_output = attn_output.reshape(bsz, q_len, self.hidden_size_per_tp)\n attn_output = self.o_proj(attn_output)[0]\n return attn_output\n\n\n\"\"\"\nRemove padding Attention\n- Using Flash-attn 2\n- Compatible with sequence parallel\n\"\"\"\n\n\ndef apply_rotary_pos_emb_rmpad(q, k, cos, sin, position_ids, indices, sequence_length):\n batch_size = position_ids.shape[0]\n\n q = pad_input(q, indices, batch_size, sequence_length) # (batch_size, seqlen, num_head, head_dim)\n k = pad_input(k, indices, batch_size, sequence_length)\n cos = cos[position_ids].unsqueeze(2) # [bs, seq_len, 1, dim]\n sin = sin[position_ids].unsqueeze(2) # [bs, seq_len, 1, dim]\n q_embed = (q * cos) + (rotate_half(q) * sin)\n k_embed = (k * cos) + (rotate_half(k) * sin)\n\n q_embed = index_first_axis(rearrange(q_embed, \"b s ... -> (b s) ...\"), indices)\n k_embed = index_first_axis(rearrange(k_embed, \"b s ... -> (b s) ...\"), indices)\n\n return q_embed, k_embed\n\n\n# use flash-attn rotary embeddings with rmpad\n# cos/sin shoudl be: (seq_length, rotary_dim / 2)\ndef apply_rotary_pos_emb_rmpad_flash(q, k, cos, sin, cu_seqlens, max_seqlen):\n q_embed = apply_rotary_emb(\n q, cos, sin, interleaved=False, inplace=False, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen\n )\n k_embed = apply_rotary_emb(\n k, cos, sin, interleaved=False, inplace=False, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen\n )\n return q_embed, k_embed\n\n\nclass ParallelQwen2AttentionRmPad(ParallelQwen2Attention):\n def forward(\n self,\n hidden_states: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: torch.Tensor = None,\n max_seqlen_in_batch: int = None,\n ):\n total_nnz, _, _ = hidden_states.size() # This is the total_nnz padded after sequence parallel\n\n if self.megatron_config.sequence_parallel:\n total_nnz = total_nnz * mpu.get_tensor_model_parallel_world_size()\n\n qkv = self.qkv_proj(hidden_states)[0]\n query_states, key_states, value_states = qkv.split(\n [self.q_size, self.k_size, self.v_size], dim=-1\n ) # (total_nnz, 1, hidden_size)\n\n if self.megatron_config.sequence_parallel:\n sequence_parallel_pad = total_nnz - cu_seqlens[-1]\n total_nnz = cu_seqlens[-1] # total_nnz before sp padding\n query_states = query_states[:total_nnz]\n key_states = key_states[:total_nnz]\n value_states = value_states[:total_nnz]\n\n # Flash attention requires the input to have the shape\n # batch_size x seq_length x head_dime x hidden_dim\n # therefore we just need to keep the original shape\n query_states = query_states.view(total_nnz, self.num_heads_per_tp, self.head_dim)\n key_states = key_states.view(total_nnz, self.num_key_value_heads_per_tp, self.head_dim)\n value_states = value_states.view(total_nnz, self.num_key_value_heads_per_tp, self.head_dim)\n\n cos, sin = self.rotary_emb(value_states, seq_len=sequence_length)\n cos, sin = cos[:, : cos.shape[1] // 2], sin[:, : sin.shape[1] // 2] # flash attn only needs half\n query_states, key_states = apply_rotary_pos_emb_rmpad_flash(\n query_states, key_states, cos, sin, cu_seqlens=cu_seqlens, max_seqlen=max_seqlen_in_batch\n )\n # query_states, key_states = apply_rotary_pos_emb_rmpad(query_states, key_states, cos, sin,\n # position_ids, indices,\n\n # It is recommended to use dropout with FA according to the docs\n # when training.\n dropout_rate = 0.0 # if not self.training else self.attn_dropout\n\n # In PEFT, usually we cast the layer norms in float32 for training stability reasons\n # therefore the input hidden states gets silently casted in float32. Hence, we need\n # cast them back in float16 just to be sure everything works as expected.\n # This might slowdown training & inference so it is recommended to not cast the LayerNorms\n # in fp32. (Qwen2RMSNorm handles it correctly)\n input_dtype = query_states.dtype\n if input_dtype == torch.float32:\n query_states = query_states.to(torch.float16)\n key_states = key_states.to(torch.float16)\n value_states = value_states.to(torch.float16)\n\n attn_output_unpad = flash_attn_varlen_func(\n query_states,\n key_states,\n value_states,\n cu_seqlens_q=cu_seqlens,\n cu_seqlens_k=cu_seqlens,\n max_seqlen_q=max_seqlen_in_batch,\n max_seqlen_k=max_seqlen_in_batch,\n dropout_p=dropout_rate,\n softmax_scale=None,\n causal=True,\n )\n\n attn_output_unpad = attn_output_unpad.to(input_dtype)\n attn_output_unpad = attn_output_unpad.reshape(total_nnz, 1, self.hidden_size_per_tp).contiguous()\n\n # sequence parallel reduce_scatter is performed inside RowColumnParallel if enabled\n # Here we need to repad\n if self.megatron_config.sequence_parallel:\n attn_output_unpad = F.pad(attn_output_unpad, pad=(0, 0, 0, 0, 0, sequence_parallel_pad))\n\n attn_output_unpad = self.o_proj(attn_output_unpad)[0]\n return attn_output_unpad\n"} +{"file_name": "verl__models__qwen2__megatron__layers__parallel_mlp.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom megatron.core import ModelParallelConfig, tensor_parallel\nfrom megatron.core import parallel_state as mpu\nfrom torch import nn\nfrom transformers.activations import ACT2FN\n\nfrom verl.models.qwen2.megatron.layers.parallel_linear import MergedColumnParallelLinear\nfrom verl.utils.megatron import tensor_parallel as tp_utils\n\n\nclass ParallelQwen2MLP(nn.Module):\n def __init__(self, config, megatron_config: ModelParallelConfig = None) -> None:\n super().__init__()\n self.config = config\n self.hidden_size = config.hidden_size\n self.intermediate_size = config.intermediate_size\n # The weight is only [hidden_size, intermediate_size // model_parallel_world_size]\n\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n row_kwargs = tp_utils.get_default_kwargs_for_row_parallel_linear()\n\n if megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n assert row_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(row_kwargs, megatron_config)\n tp_utils.update_kwargs_with_config(column_kwargs, megatron_config)\n\n tp_size = mpu.get_tensor_model_parallel_world_size()\n\n self.gate_up_proj = MergedColumnParallelLinear(\n input_size=self.hidden_size,\n gate_ouput_size=self.intermediate_size,\n up_output_size=self.intermediate_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n self.gate_size = self.intermediate_size // tp_size\n\n self.down_proj = tensor_parallel.RowParallelLinear(\n input_size=self.intermediate_size,\n output_size=self.hidden_size,\n bias=False,\n input_is_parallel=True,\n skip_bias_add=False,\n **row_kwargs,\n )\n\n self.act_fn = ACT2FN[config.hidden_act]\n\n def forward(self, x):\n gate_up = self.gate_up_proj(x)[0]\n gate, up = gate_up.split(self.gate_size, dim=-1)\n return self.down_proj(self.act_fn(gate) * up)[0]\n"} +{"file_name": "verl__models__qwen2__megatron__modeling_qwen2_megatron.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.\n#\n# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX\n# and OPT implementations in this library. It has been modified from its\n# original forms to accommodate minor architectural differences compared\n# to GPT-NeoX and OPT used by the Meta AI team that trained the model.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"PyTorch Qwen2 model.\"\"\"\n\nfrom typing import Optional\n\nimport torch\nimport torch.utils.checkpoint\nfrom megatron.core import ModelParallelConfig, mpu, parallel_state, tensor_parallel\nfrom torch import nn\nfrom transformers.modeling_outputs import BaseModelOutputWithPast\nfrom transformers.models.qwen2.configuration_qwen2 import Qwen2Config\nfrom transformers.models.qwen2.modeling_qwen2 import CausalLMOutputWithPast\n\nfrom verl.utils.device import get_device_name\nfrom verl.utils.megatron import sequence_parallel as sp_utils\nfrom verl.utils.megatron import tensor_parallel as tp_utils\nfrom verl.utils.megatron_utils import TransformerConfig, convert_config\n\nfrom .layers import ParallelQwen2DecoderLayer, ParallelQwen2DecoderLayerRmPad, ParallelQwen2RMSNorm\n\n\"\"\"\nTODO: \n1. Add weight initialization. Here we need to be careful on TP weight init.\n2. Add sequence parallel\n3. Load checkpoint from Qwen2 pretrained checkpoint\n\"\"\"\n\n\n# Copied from transformers.models.bart.modeling_bart._make_causal_mask\ndef _make_causal_mask(input_ids_shape: torch.Size, dtype: torch.dtype, device: torch.device):\n \"\"\"\n Make causal mask used for bi-directional self-attention.\n \"\"\"\n bsz, tgt_len = input_ids_shape\n mask = torch.full((tgt_len, tgt_len), torch.finfo(dtype).min, device=device)\n mask_cond = torch.arange(mask.size(-1), device=device)\n mask.masked_fill_(mask_cond < (mask_cond + 1).view(mask.size(-1), 1), 0)\n mask = mask.to(dtype)\n return mask[None, None, :, :].expand(bsz, 1, tgt_len, tgt_len)\n\n\n# Copied from transformers.models.bart.modeling_bart._expand_mask\ndef _expand_mask(mask: torch.Tensor, dtype: torch.dtype, tgt_len: Optional[int] = None):\n \"\"\"\n Expands attention_mask from `[bsz, seq_len]` to `[bsz, 1, tgt_seq_len, src_seq_len]`.\n \"\"\"\n bsz, src_len = mask.size()\n tgt_len = tgt_len if tgt_len is not None else src_len\n\n expanded_mask = mask[:, None, None, :].expand(bsz, 1, tgt_len, src_len).to(dtype)\n\n inverted_mask = 1.0 - expanded_mask\n\n return inverted_mask.masked_fill(inverted_mask.to(torch.bool), torch.finfo(dtype).min)\n\n\nclass ParallelQwen2Model(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`Qwen2DecoderLayer`]\n\n Args:\n config: Qwen2Config\n \"\"\"\n\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, megatron_config)\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n\n self.layers = nn.ModuleList(\n [ParallelQwen2DecoderLayer(config, megatron_config) for _ in range(config.num_hidden_layers)]\n )\n self.norm = ParallelQwen2RMSNorm(config, megatron_config)\n\n # Copied from transformers.models.bart.modeling_bart.BartDecoder._prepare_decoder_attention_mask\n def _prepare_decoder_attention_mask(self, attention_mask, input_shape, inputs_embeds):\n # create causal mask\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n combined_attention_mask = None\n if input_shape[-1] > 1:\n combined_attention_mask = _make_causal_mask(\n input_shape,\n inputs_embeds.dtype,\n device=inputs_embeds.device,\n )\n\n if attention_mask is not None:\n # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]\n expanded_attn_mask = _expand_mask(attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1]).to(\n inputs_embeds.device\n )\n combined_attention_mask = (\n expanded_attn_mask if combined_attention_mask is None else expanded_attn_mask + combined_attention_mask\n )\n\n return combined_attention_mask\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (batch_size, seq_length)\n attention_mask: attention_mask. shape (batch_size, seq_length)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n batch_size, seq_length = input_ids.shape\n inputs_embeds = self.embed_tokens(input_ids)\n # embed positions\n\n attention_mask = self._prepare_decoder_attention_mask(attention_mask, (batch_size, seq_length), inputs_embeds)\n\n hidden_states = inputs_embeds\n\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n attention_mask=attention_mask,\n position_ids=position_ids,\n )\n\n hidden_states = layer_outputs\n\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelQwen2ForCausalLM(nn.Module):\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.model = ParallelQwen2Model(config, megatron_config=megatron_config)\n self.vocab_size = config.vocab_size\n\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n\n # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\n outputs = self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n )\n\n hidden_states = outputs\n logits = self.lm_head(hidden_states)[0]\n\n logits = tensor_parallel.gather_from_tensor_model_parallel_region(logits)\n\n logits = logits.float()\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n\n\nfrom flash_attn.bert_padding import index_first_axis, pad_input, unpad_input # noqa: F401, E402\n\n\nclass ParallelQwen2ModelRmPad(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`Qwen2DecoderLayer`]\n\n Args:\n config: Qwen2Config\n \"\"\"\n\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n self.megatron_config = megatron_config\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, self.megatron_config)\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n\n self.layers = nn.ModuleList(\n [ParallelQwen2DecoderLayerRmPad(config, megatron_config) for _ in range(config.num_hidden_layers)]\n )\n self.norm = ParallelQwen2RMSNorm(config, megatron_config)\n\n def forward(\n self,\n input_ids: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: int = None,\n max_seqlen_in_batch: int = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (1, totol_nnz)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n inputs_embeds = self.embed_tokens(input_ids) # (1, total_nnz) -> (1, total_nnz, hidden_size)\n\n # (1, total_nnz, hidden_size) -> (total_nnz, 1, hidden_size) -> (total_nnz // sp, 1, hidden_size)\n inputs_embeds = inputs_embeds.transpose(0, 1)\n if self.megatron_config.sequence_parallel:\n inputs_embeds = tensor_parallel.scatter_to_sequence_parallel_region(inputs_embeds)\n\n hidden_states = inputs_embeds\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = layer_outputs\n\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelQwen2ForCausalLMRmPad(nn.Module):\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.megatron_config = megatron_config\n self.model = ParallelQwen2ModelRmPad(config, megatron_config=megatron_config)\n self.vocab_size = config.vocab_size\n self._init_head(config)\n\n def _init_head(self, config: Qwen2Config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n **column_kwargs,\n )\n\n def _forward_head(self, hidden_states):\n # all_gather from sequence parallel region is performed inside lm_head\n logits = self.lm_head(hidden_states)[0]\n logits = logits.float() # (total_nnz_padded, 1, vocab_size // tp)\n logits = tensor_parallel.gather_from_tensor_model_parallel_region(logits) # (total_nnz_padded, 1, vocab_size)\n return logits\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n batch_size, sequence_length = input_ids.shape\n\n # remove padding here\n input_ids, indices, cu_seqlens, max_seqlen_in_batch, *_ = unpad_input(\n input_ids.unsqueeze(dim=-1), attention_mask\n ) # (total_nnz, 1)\n\n # pad input_ids to multiple of tp for all tp ranks\n # TODO: for better performance, the sp padding should be removed at each layer. Not sure the performance gap\n if self.megatron_config.sequence_parallel:\n input_ids = sp_utils.pad_to_sequence_parallel(input_ids)\n\n input_ids = input_ids.transpose(0, 1) # (1, total_nnz+pad)\n\n outputs = self.model(\n input_ids=input_ids,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = outputs\n\n logits = self._forward_head(hidden_states)\n\n # remove padding from sequence parallel\n if self.megatron_config.sequence_parallel:\n totol_nnz = cu_seqlens[-1]\n logits = logits[:totol_nnz] # (total_nnz_padded)\n\n logits = torch.squeeze(logits, dim=1) # remove the artificial batch dimension\n # add removed padding back\n logits = pad_input(\n logits, indices, batch_size, seqlen=sequence_length\n ) # (batch_size, sequence_length, vocab_size)\n\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n\n\nclass ParallelQwen2ForValueRmPad(ParallelQwen2ForCausalLMRmPad):\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = nn.Linear(in_features=config.hidden_size, out_features=1, bias=False)\n # lm_head is effectively the same as sequence parallel\n sp_utils.mark_parameter_as_sequence_parallel(self.lm_head.weight)\n\n def _forward_head(self, hidden_states):\n logits = self.lm_head(hidden_states) # (total_nnz_padded // tp, 1, 1)\n logits = logits.float()\n if self.megatron_config.sequence_parallel:\n logits = tensor_parallel.gather_from_sequence_parallel_region(logits, tensor_parallel_output_grad=False)\n return logits\n\n def forward(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n output = super().forward(input_ids, attention_mask, position_ids)\n output.logits = torch.squeeze(output.logits, dim=-1)\n return output\n\n\n\"\"\"\nSupport pipeline parallelism\n\"\"\"\n\n\nclass ParallelQwen2ModelRmPadPP(nn.Module):\n \"\"\"\n Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`Qwen2DecoderLayer`]\n This model definition supports pipeline parallelism. To support pp and vpp,\n - This model only contains layer in this pp stage and vpp chunk\n - When calling get_model in Megatron, this rank will instantiate all the vpp chunks in this pp.\n Args:\n config: Qwen2Config\n \"\"\"\n\n def __init__(self, config: Qwen2Config, megatron_config: ModelParallelConfig, pre_process, post_process):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.padding_idx = config.pad_token_id\n self.vocab_size = config.vocab_size\n self.pre_process = pre_process\n self.post_process = post_process\n self.megatron_config = megatron_config\n embedding_kwargs = tp_utils.get_default_kwargs_for_parallel_embedding()\n if megatron_config is not None:\n assert embedding_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(embedding_kwargs, self.megatron_config)\n if pre_process:\n self.embed_tokens = tensor_parallel.VocabParallelEmbedding(\n num_embeddings=config.vocab_size, embedding_dim=config.hidden_size, **embedding_kwargs\n )\n else:\n self.embed_tokens = None\n\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = megatron_config.pipeline_model_parallel_size\n self.num_layer_per_pp = config.num_hidden_layers // pp_size\n vpp_size = megatron_config.virtual_pipeline_model_parallel_size\n vpp_rank = mpu.get_virtual_pipeline_model_parallel_rank()\n\n if vpp_size is not None:\n self.num_layer_vpp_chunk = self.num_layer_per_pp // vpp_size\n self.num_layer_this_model = self.num_layer_vpp_chunk\n offset = vpp_rank * (config.num_hidden_layers // vpp_size) + (pp_rank * self.num_layer_vpp_chunk)\n else:\n self.num_layer_this_model = self.num_layer_per_pp\n offset = pp_rank * self.num_layer_per_pp\n\n self.layers = nn.ModuleList()\n for i in range(self.num_layer_this_model):\n layer = ParallelQwen2DecoderLayerRmPad(config, megatron_config, layer_idx=i + offset)\n self.layers.add_module(f\"{i}\", layer)\n\n if post_process:\n self.norm = ParallelQwen2RMSNorm(config, megatron_config)\n else:\n self.norm = None\n\n def set_input_tensor(self, input_tensor):\n \"\"\"Set input tensor to be used instead of forward()'s input.\n\n When doing pipeline parallelism the input from the previous\n stage comes from communication, not from the input, so the\n model's forward_step_func won't have it. This function is thus\n used by internal code to bypass the input provided by the\n forward_step_func\"\"\"\n self.input_tensor = input_tensor\n\n def forward(\n self,\n input_ids: torch.Tensor,\n position_ids: Optional[torch.LongTensor] = None,\n sequence_length: int = None,\n indices: torch.Tensor = None,\n cu_seqlens: int = None,\n max_seqlen_in_batch: int = None,\n ) -> tuple | BaseModelOutputWithPast:\n \"\"\"\n\n Args:\n input_ids: input ids. shape (1, totol_nnz)\n position_ids: position ids. shape (batch_size, seq_length)\n\n Returns:\n\n \"\"\"\n if self.pre_process:\n inputs_embeds = self.embed_tokens(input_ids) # (1, total_nnz) -> (1, total_nnz, hidden_size)\n\n # vocab parallel embedding will not do sequence parallel reduce-scatter in open source megatron\n # so need to deal with it by handle here:\n # (1, total_nnz, hidden_size) -> (total_nnz, 1, hidden_size) -> (total_nnz // sp, 1, hidden_size)\n inputs_embeds = inputs_embeds.transpose(0, 1)\n if self.megatron_config.sequence_parallel:\n inputs_embeds = tensor_parallel.scatter_to_sequence_parallel_region(inputs_embeds)\n\n hidden_states = inputs_embeds\n else:\n # self.hidden_states should be passed by Megatron\n hidden_states = self.input_tensor\n\n for idx, decoder_layer in enumerate(self.layers):\n layer_outputs = decoder_layer(\n hidden_states,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n hidden_states = layer_outputs\n\n if self.post_process:\n hidden_states = self.norm(hidden_states)\n\n return hidden_states\n\n\nclass ParallelQwen2ForCausalLMRmPadPP(nn.Module):\n def __init__(\n self,\n config: Qwen2Config,\n megatron_config: ModelParallelConfig,\n pre_process,\n post_process,\n share_embeddings_and_output_weights,\n ):\n super().__init__()\n self.config: TransformerConfig = convert_config(config, megatron_config)\n self.megatron_config = megatron_config\n self.model = ParallelQwen2ModelRmPadPP(\n config, megatron_config=megatron_config, pre_process=pre_process, post_process=post_process\n )\n self.share_embeddings_and_output_weights = share_embeddings_and_output_weights\n self.vocab_size = config.vocab_size\n self.pre_process = pre_process\n self.post_process = post_process\n if post_process:\n self._init_head(config)\n if pre_process or post_process:\n self.setup_embeddings_and_output_layer()\n\n def set_input_tensor(self, input_tensor):\n \"\"\"Set input tensor to be used instead of forward()'s input.\n\n When doing pipeline parallelism the input from the previous\n stage comes from communication, not from the input, so the\n model's forward_step_func won't have it. This function is thus\n used by internal code to bypass the input provided by the\n forward_step_func\"\"\"\n assert len(input_tensor) == 1\n self.model.set_input_tensor(input_tensor[0])\n\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = tensor_parallel.ColumnParallelLinear(\n input_size=config.hidden_size,\n output_size=config.vocab_size,\n bias=False,\n gather_output=False,\n skip_bias_add=False,\n skip_weight_param_allocation=self.pre_process and self.share_embeddings_and_output_weights,\n **column_kwargs,\n )\n\n def setup_embeddings_and_output_layer(self) -> None:\n \"\"\"Sets up embedding layer in first stage and output layer in last stage.\n\n This function initializes word embeddings in the final stage when we are\n using pipeline parallelism and sharing word embeddings, and sets up param\n attributes on the embedding and output layers.\n \"\"\"\n # Set `is_embedding_or_output_parameter` attribute.\n if self.pre_process:\n self.model.embed_tokens.weight.is_embedding_or_output_parameter = True\n if self.post_process and self.lm_head.weight is not None:\n self.lm_head.weight.is_embedding_or_output_parameter = True\n\n if not self.share_embeddings_and_output_weights:\n return\n\n if parallel_state.get_pipeline_model_parallel_world_size() == 1:\n # Zero out wgrad if sharing embeddings between two layers on same\n # pipeline stage to make sure grad accumulation into main_grad is\n # correct and does not include garbage values (e.g., from torch.empty).\n self.shared_embedding_or_output_weight().zero_out_wgrad = True\n return\n\n if parallel_state.is_pipeline_first_stage() and self.pre_process and not self.post_process:\n self.shared_embedding_or_output_weight().shared_embedding = True\n\n if self.post_process and not self.pre_process:\n assert not parallel_state.is_pipeline_first_stage()\n # set word_embeddings weights to 0 here, then copy first\n # stage's weights using all_reduce below.\n self.lm_head.weight.data.fill_(0)\n self.lm_head.weight.shared = True\n self.lm_head.weight.shared_embedding = True\n\n if torch.distributed.is_initialized() and parallel_state.is_rank_in_embedding_group():\n weight = self.shared_embedding_or_output_weight()\n weight.data = weight.data.to(get_device_name())\n torch.distributed.all_reduce(weight.data, group=parallel_state.get_embedding_group())\n\n def shared_embedding_or_output_weight(self) -> torch.Tensor:\n if self.pre_process:\n return self.model.embed_tokens.weight\n elif self.post_process:\n return self.lm_head.weight\n return None\n\n def _forward_head(self, hidden_states):\n # all_gather from sequence parallel region is performed inside lm_head\n # print(f'logits shape before forward_head: {hidden_states.shape}, vocab_size = '\n # f'{self.config.vocab_size}') # [4, 32, 4096]\n output_weight = None\n if self.share_embeddings_and_output_weights:\n output_weight = self.shared_embedding_or_output_weight()\n logits = self.lm_head(hidden_states, weight=output_weight)[0]\n # print(f'logits shape after forward_head: {logits.shape}') # [8, 32, 8]\n logits = logits.float() # (total_nnz_padded, 1, vocab_size // tp)\n return logits\n\n def forward(\n self,\n # original input\n *,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n r\"\"\"\n Args:\n labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):\n Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,\n config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored\n (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.\n\n Returns:\n ```\"\"\"\n\n # Note that input_ids, attention_mask and position_ids should be passed to every pp layer.\n # In the first pp, input_ids will be used, in other pp layers hidden_states will be used inside self.model\n batch_size, sequence_length = input_ids.shape\n # remove padding here\n input_ids_rmpad, indices, cu_seqlens, max_seqlen_in_batch, *_ = unpad_input(\n input_ids.unsqueeze(dim=-1), attention_mask\n ) # (total_nnz, 1)\n\n # pad input_ids to multiple of tp for all tp ranks\n # TODO: for better performance, the sp padding should be removed at each layer. Not sure the performance gap\n if self.megatron_config.sequence_parallel:\n input_ids_rmpad = sp_utils.pad_to_sequence_parallel(input_ids_rmpad)\n\n input_ids_rmpad = input_ids_rmpad.transpose(0, 1) # (1, total_nnz+pad)\n\n outputs = self.model(\n input_ids=input_ids_rmpad,\n position_ids=position_ids,\n sequence_length=sequence_length,\n indices=indices,\n cu_seqlens=cu_seqlens,\n max_seqlen_in_batch=max_seqlen_in_batch,\n )\n\n if self.post_process:\n hidden_states = outputs\n logits = self._forward_head(hidden_states)\n logits = torch.squeeze(logits, dim=1) # remove the artificial batch dimension # torch.Size([8, 32, 16])\n\n # remove padding from sequence parallel\n if self.megatron_config.sequence_parallel:\n totol_nnz = cu_seqlens[-1]\n logits = logits[:totol_nnz] # (total_nnz_padded)\n # add removed padding back. If input is already rmpad, we let the caller pad_input\n logits = pad_input(\n logits, indices, batch_size, seqlen=sequence_length\n ) # (batch_size, sequence_length, vocab_size)\n\n return CausalLMOutputWithPast(\n loss=None,\n logits=logits,\n past_key_values=None,\n hidden_states=None,\n attentions=None,\n )\n else:\n return outputs\n\n\nclass ParallelQwen2ForValueRmPadPP(ParallelQwen2ForCausalLMRmPadPP):\n def _init_head(self, config):\n column_kwargs = tp_utils.get_default_kwargs_for_column_parallel_linear()\n if self.megatron_config is not None:\n assert column_kwargs.get(\"config\", False), \"must have ModelParallelConfig\"\n tp_utils.update_kwargs_with_config(column_kwargs, self.megatron_config)\n self.lm_head = nn.Linear(in_features=config.hidden_size, out_features=1, bias=False)\n # lm_head is effectively the same as sequence parallel\n sp_utils.mark_parameter_as_sequence_parallel(self.lm_head.weight)\n\n def _forward_head(self, hidden_states):\n logits = self.lm_head(hidden_states) # (total_nnz_padded // tp, 1, 1)\n logits = logits.float()\n if self.megatron_config.sequence_parallel:\n logits = tensor_parallel.gather_from_sequence_parallel_region(logits, tensor_parallel_output_grad=False)\n return logits\n\n def forward(\n self,\n *,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n ) -> tuple | CausalLMOutputWithPast:\n output = super().forward(input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids)\n if self.post_process:\n output.logits = torch.squeeze(output.logits, dim=-1)\n return output\n else:\n return output\n"} +{"file_name": "verl__models__registry.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport importlib\nfrom typing import Optional\n\nimport torch.nn as nn\n\n# Supported models in Megatron-LM\n# Architecture -> (module, class).\n_MODELS = {\n \"LlamaForCausalLM\": (\n \"llama\",\n (\"ParallelLlamaForCausalLMRmPadPP\", \"ParallelLlamaForValueRmPadPP\", \"ParallelLlamaForCausalLMRmPad\"),\n ),\n \"Qwen2ForCausalLM\": (\n \"qwen2\",\n (\"ParallelQwen2ForCausalLMRmPadPP\", \"ParallelQwen2ForValueRmPadPP\", \"ParallelQwen2ForCausalLMRmPad\"),\n ),\n \"MistralForCausalLM\": (\n \"mistral\",\n (\"ParallelMistralForCausalLMRmPadPP\", \"ParallelMistralForValueRmPadPP\", \"ParallelMistralForCausalLMRmPad\"),\n ),\n \"ApertusForCausalLM\": (\n \"apertus\",\n (\"ParallelApertusForCausalLMRmPadPP\", \"ParallelApertusForValueRmPadPP\", \"ParallelApertusForCausalLMRmPad\"),\n ),\n}\n\n\n# return model class\nclass ModelRegistry:\n @staticmethod\n def load_model_cls(model_arch: str, value=False) -> Optional[type[nn.Module]]:\n if model_arch not in _MODELS:\n return None\n\n megatron = \"megatron\"\n\n module_name, model_cls_name = _MODELS[model_arch]\n if not value: # actor/ref\n model_cls_name = model_cls_name[0]\n elif value: # critic/rm\n model_cls_name = model_cls_name[1]\n\n module = importlib.import_module(f\"verl.models.{module_name}.{megatron}.modeling_{module_name}_megatron\")\n return getattr(module, model_cls_name, None)\n\n @staticmethod\n def get_supported_archs() -> list[str]:\n return list(_MODELS.keys())\n"} +{"file_name": "verl__models__transformers__dense_common.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom dataclasses import dataclass\nfrom typing import Optional, Union\n\nimport torch\nfrom transformers.cache_utils import Cache\nfrom transformers.modeling_outputs import CausalLMOutputWithPast\n\n\n@dataclass\nclass CausalLMOutputForPPO(CausalLMOutputWithPast):\n log_probs: Optional[torch.FloatTensor] = None\n entropy: Optional[torch.FloatTensor] = None\n\n\ndef forward_base_model(\n self,\n input_ids: Optional[torch.LongTensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Cache] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n cache_position: Optional[torch.LongTensor] = None,\n) -> CausalLMOutputWithPast:\n r\"\"\"\n Copy paste LLaMa's forward\n https://github.com/linkedin/Liger-Kernel/blob/main/src/liger_kernel/transformers/model/llama.py\n\n This function should be generic enough for all pure text models.\n ```\"\"\"\n\n output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions\n output_hidden_states = (\n output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states\n )\n\n # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\n outputs = self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_values=past_key_values,\n inputs_embeds=inputs_embeds,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n cache_position=cache_position,\n )\n\n return outputs\n\n\ndef forward_with_torch_backend(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Union[\"Cache\", list[torch.FloatTensor]]] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n labels: Optional[torch.LongTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n cache_position: Optional[torch.LongTensor] = None,\n logits_to_keep: int | torch.Tensor = 0,\n temperature: float = 1.0,\n **loss_kwargs,\n) -> tuple | CausalLMOutputForPPO:\n from verl.utils.experimental.torch_functional import FusedLinearForPPO\n\n outputs = forward_base_model(\n self,\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_values=past_key_values,\n inputs_embeds=inputs_embeds,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n cache_position=cache_position,\n )\n\n hidden_states = outputs[0]\n\n if not return_dict:\n raise NotImplementedError(\"forward_with_torch_backend has to return_dict\")\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_torch_backend, either labels or input_ids must be provided.\")\n\n fused_linear_for_ppo = FusedLinearForPPO()\n log_probs, entropy = fused_linear_for_ppo.forward(\n hidden_states=hidden_states,\n vocab_weights=self.lm_head.weight,\n input_ids=rolled_labels,\n temperature=temperature,\n )\n\n return CausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n past_key_values=outputs.past_key_values,\n hidden_states=outputs.hidden_states,\n attentions=outputs.attentions,\n )\n\n\ndef forward_with_triton_backend(\n self,\n input_ids: torch.LongTensor = None,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Union[\"Cache\", list[torch.FloatTensor]]] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n labels: Optional[torch.LongTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n cache_position: Optional[torch.LongTensor] = None,\n logits_to_keep: int | torch.Tensor = 0,\n temperature: float = 1.0,\n **loss_kwargs,\n) -> tuple | CausalLMOutputForPPO:\n from verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\n\n outputs = forward_base_model(\n self,\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n past_key_values=past_key_values,\n inputs_embeds=inputs_embeds,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n cache_position=cache_position,\n )\n\n hidden_states = outputs[0]\n\n if not return_dict:\n raise NotImplementedError(\"forward_with_triton_backend has to return_dict\")\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_triton_backend, either labels or input_ids must be provided.\")\n\n log_probs, entropy = linear_cross_entropy(\n hidden_states,\n self.lm_head.weight,\n rolled_labels,\n temperature,\n \"none\",\n )\n\n return CausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n past_key_values=outputs.past_key_values,\n hidden_states=outputs.hidden_states,\n attentions=outputs.attentions,\n )\n"} +{"file_name": "verl__models__transformers__glm4v.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport inspect\nimport itertools\nimport logging\nimport os\nfrom dataclasses import dataclass\nfrom typing import Optional\n\nimport torch\nimport torch.distributed as dist\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward, fa_peft_integration_check\nfrom transformers.models.glm4v.modeling_glm4v import (\n Glm4vCausalLMOutputWithPast,\n Glm4vForConditionalGeneration,\n Glm4vTextAttention,\n)\nfrom transformers.utils import is_flash_attn_2_available, is_flash_attn_greater_or_equal_2_10\n\nfrom verl.utils.device import is_npu_available\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_group,\n get_ulysses_sequence_parallel_world_size,\n validate_ulysses_config,\n)\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\nif is_flash_attn_2_available():\n from flash_attn import flash_attn_func, flash_attn_varlen_func\n\n _flash_supports_window_size = \"window_size\" in inspect.signature(flash_attn_func).parameters\n _flash_supports_deterministic = \"deterministic\" in inspect.signature(flash_attn_func).parameters\n _flash_use_top_left_mask = not is_flash_attn_greater_or_equal_2_10()\n\nif is_npu_available:\n from transformers.integrations.npu_flash_attention import npu_flash_attn_func as flash_attn_func\n from transformers.integrations.npu_flash_attention import npu_flash_attn_varlen_func as flash_attn_varlen_func\n from transformers.modeling_flash_attention_utils import flash_attn_supports_top_left_mask\n\n _flash_supports_window_size = \"window_size\" in inspect.signature(flash_attn_func).parameters\n _flash_supports_deterministic = \"deterministic\" in inspect.signature(flash_attn_func).parameters\n _flash_use_top_left_mask = flash_attn_supports_top_left_mask()\n\n_flash_deterministic_enabled = os.getenv(\"FLASH_ATTENTION_DETERMINISTIC\", \"0\") == \"1\"\n\n\ndef get_rope_index(\n processor,\n input_ids: torch.Tensor,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n) -> torch.Tensor:\n \"\"\"\n Gets the position ids for GLM4V in padding-free format.\n The batch dim has been removed and the input_ids should be a 1D tensor representing a single example.\n \"\"\"\n spatial_merge_size = processor.image_processor.merge_size\n image_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|image|>\")\n video_start_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|begin_of_video|>\")\n video_end_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|end_of_video|>\")\n\n if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):\n if attention_mask is None:\n attention_mask = torch.ones_like(input_ids)\n\n position_ids = torch.ones(3, input_ids.size(0), dtype=input_ids.dtype, device=input_ids.device) # (3, seqlen)\n image_index, video_index = 0, 0\n video_group_index = 0\n\n input_ids_filtered = input_ids[attention_mask == 1]\n input_tokens = input_ids_filtered.tolist()\n\n input_token_type = []\n video_check_flg = False\n for token in input_tokens:\n if token == video_start_token_id:\n video_check_flg = True\n elif token == video_end_token_id:\n video_check_flg = False\n\n if token == image_token_id and not video_check_flg:\n input_token_type.append(\"image\")\n elif token == image_token_id and video_check_flg:\n input_token_type.append(\"video\")\n else:\n input_token_type.append(\"text\")\n\n input_type_group = []\n for key, group in itertools.groupby(enumerate(input_token_type), lambda x: x[1]):\n group = list(group)\n start_index = group[0][0]\n end_index = group[-1][0] + 1\n input_type_group.append((key, start_index, end_index))\n\n llm_pos_ids_list = []\n video_frame_num = 1\n\n for modality_type, start_idx, end_idx in input_type_group:\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n\n if modality_type == \"image\":\n t, h, w = (\n image_grid_thw[image_index][0],\n image_grid_thw[image_index][1],\n image_grid_thw[image_index][2],\n )\n llm_grid_t, llm_grid_h, llm_grid_w = (\n t.item(),\n h.item() // spatial_merge_size,\n w.item() // spatial_merge_size,\n )\n\n t_index = torch.arange(llm_grid_t).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w).flatten()\n h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()\n w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()\n llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + st_idx)\n\n image_index += 1\n video_frame_num = 1\n\n elif modality_type == \"video\":\n t, h, w = (\n video_frame_num,\n video_grid_thw[video_index][1],\n video_grid_thw[video_index][2],\n )\n\n llm_grid_t, llm_grid_h, llm_grid_w = (\n t,\n h.item() // spatial_merge_size,\n w.item() // spatial_merge_size,\n )\n\n for t_idx in range(llm_grid_t):\n t_index = torch.tensor(t_idx).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w).flatten()\n h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(1, -1, llm_grid_w).flatten()\n w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(1, llm_grid_h, -1).flatten()\n llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + st_idx)\n\n video_group_index += 1\n\n if video_group_index >= video_grid_thw[video_index][0]:\n video_index += 1\n video_group_index = 0\n\n video_frame_num += 1\n\n else:\n text_len = end_idx - start_idx\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n video_frame_num = 1\n\n llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)\n position_ids[..., attention_mask == 1] = llm_positions.to(position_ids.device)\n else:\n if attention_mask is not None:\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n position_ids = position_ids.unsqueeze(0).expand(3, -1).to(input_ids.device)\n else:\n position_ids = torch.arange(input_ids.shape[0], device=input_ids.device).view(1, -1).expand(3, -1)\n\n return position_ids\n\n\ndef prepare_fa2_from_position_ids(\n query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, position_ids: torch.Tensor\n):\n assert position_ids.ndim == 2 # (batch_size, seq_length)\n query = query.contiguous().view(-1, query.size(-2), query.size(-1))\n key = key.contiguous().view(-1, key.size(-2), key.size(-1))\n value = value.contiguous().view(-1, value.size(-2), value.size(-1))\n position_ids = position_ids.view(-1)\n cu_seqlens = torch.cat(\n (\n (position_ids == 0).nonzero().view(-1).to(torch.int32),\n torch.tensor(position_ids.size(), device=position_ids.device, dtype=torch.int32),\n )\n )\n max_length = cu_seqlens.diff().max() # use cu_seqlens to infer max_length for qwen2vl mrope\n return (query, key, value, (cu_seqlens, cu_seqlens), (max_length, max_length))\n\n\ndef _custom_flash_attention_forward(\n query_states: torch.Tensor,\n key_states: torch.Tensor,\n value_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor],\n query_length: int,\n is_causal: bool = True,\n position_ids: Optional[torch.Tensor] = None,\n use_top_left_mask: bool = False,\n deterministic: Optional[bool] = None,\n **kwargs,\n):\n \"\"\"\n Patches flash attention forward to handle 3D position ids in mrope. (3, batch_size, seq_length)\n \"\"\"\n # Assuming 4D tensors, key_states.shape[1] is the key/value sequence length (source length).\n flash_kwargs = {}\n\n if _flash_supports_deterministic:\n flash_kwargs[\"deterministic\"] = deterministic if deterministic is not None else _flash_deterministic_enabled\n\n if kwargs.get(\"softcap\") is not None:\n flash_kwargs[\"softcap\"] = kwargs.pop(\"softcap\")\n\n query_states, key_states, value_states = fa_peft_integration_check(\n query_states, key_states, value_states, target_dtype=torch.bfloat16\n )\n\n if position_ids is not None:\n assert position_ids.ndim == 2 # (batch_size, seq_length / sp_size)\n\n sp_size = get_ulysses_sequence_parallel_world_size()\n if sp_size > 1:\n # qkv: (batch_size, seq_length / sp_size, num_head, head_size)\n validate_ulysses_config(query_states.size(2), sp_size)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=1, head_dim=2)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=1, head_dim=2)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=1, head_dim=2)\n position_ids_lst = [torch.empty_like(position_ids) for _ in range(sp_size)]\n position_ids = dist.all_gather(position_ids_lst, position_ids, group=get_ulysses_sequence_parallel_group())\n position_ids = torch.cat(position_ids_lst, dim=-1) # (batch_size, seq_length)\n\n if position_ids is not None and query_length != 1 and not (torch.diff(position_ids, dim=-1) >= 0).all():\n batch_size = query_states.size(0)\n q, k, v, (cu_seqlens_q, cu_seqlens_k), (max_seqlen_q, max_seqlen_k) = prepare_fa2_from_position_ids(\n query_states, key_states, value_states, position_ids\n )\n attn_output = flash_attn_varlen_func(\n q=q,\n k=k,\n v=v,\n cu_seqlens_q=cu_seqlens_q,\n cu_seqlens_k=cu_seqlens_k,\n max_seqlen_q=max_seqlen_q,\n max_seqlen_k=max_seqlen_k,\n dropout_p=kwargs.pop(\"dropout\", 0.0),\n softmax_scale=kwargs.pop(\"softmax_scale\", None),\n causal=is_causal,\n **flash_kwargs,\n )\n attn_output = attn_output.view(batch_size, -1, attn_output.size(-2), attn_output.size(-1))\n else:\n attn_output = _flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n query_length,\n is_causal=is_causal,\n use_top_left_mask=use_top_left_mask,\n deterministic=deterministic,\n **kwargs,\n ) # do not pass position_ids to old flash_attention_forward\n\n if sp_size > 1:\n # (batch_size, seq_length, num_head, head_size)\n attn_output = gather_heads_scatter_seq(attn_output, head_dim=2, seq_dim=1)\n\n return attn_output\n\n\ndef glm4v_attn_forward(\n self: \"Glm4vTextAttention\",\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n position_embeddings: Optional[tuple[torch.Tensor, torch.Tensor]] = None, # will become mandatory in v4.46\n **kwargs,\n) -> tuple[torch.Tensor, None, None]:\n from transformers.models.glm4v.modeling_glm4v import apply_multimodal_rotary_pos_emb, repeat_kv\n\n bsz, q_len, _ = hidden_states.size() # q_len = seq_length / sp_size\n query_states = self.q_proj(hidden_states) # (batch_size, seq_length / sp_size, num_heads * head_size)\n key_states = self.k_proj(hidden_states)\n value_states = self.v_proj(hidden_states)\n\n query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)\n key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n\n # Because the input can be padded, the absolute sequence length depends on the max position id.\n cos, sin = position_embeddings\n query_states, key_states = apply_multimodal_rotary_pos_emb(\n query_states, key_states, cos, sin, self.rope_scaling[\"mrope_section\"]\n )\n key_states = repeat_kv(key_states, self.num_key_value_groups)\n value_states = repeat_kv(value_states, self.num_key_value_groups)\n dropout_rate = 0.0 if not self.training else self.attention_dropout\n\n # This is before the transpose\n q_len = query_states.shape[2]\n\n # FA2 uses non-transposed inputs\n query_states = query_states.transpose(1, 2)\n key_states = key_states.transpose(1, 2)\n value_states = value_states.transpose(1, 2)\n\n attn_output = _custom_flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n query_length=q_len,\n is_causal=getattr(self, \"is_causal\", True),\n dropout=dropout_rate,\n use_top_left_mask=_flash_use_top_left_mask,\n position_ids=position_ids, # important: pass position ids\n ) # (batch_size, seq_length / sp_size, num_head, head_size)\n attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous()\n attn_output = self.o_proj(attn_output)\n return attn_output, None\n\n\ndef _get_input_embeds(\n model: \"Glm4vForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n):\n inputs_embeds = model.get_input_embeddings()(input_ids)\n if pixel_values is not None:\n pixel_values = pixel_values.type(model.visual.dtype)\n image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n n_image_tokens = (input_ids == model.config.image_token_id).sum().item()\n n_image_features = image_embeds.shape[0]\n if n_image_tokens != n_image_features:\n raise ValueError(\n f\"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}\"\n )\n\n mask = input_ids == model.config.image_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n image_mask = mask_expanded.to(inputs_embeds.device)\n\n image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)\n\n if pixel_values_videos is not None:\n pixel_values_videos = pixel_values_videos.type(model.visual.dtype)\n video_embeds = model.visual(pixel_values_videos, grid_thw=video_grid_thw)\n n_video_tokens = (input_ids == model.config.video_token_id).sum().item()\n n_video_features = video_embeds.shape[0]\n if n_video_tokens != n_video_features:\n raise ValueError(\n f\"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}\"\n )\n\n mask = input_ids == model.config.video_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n video_mask = mask_expanded.to(inputs_embeds.device)\n\n video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)\n\n if pixel_values is None and pixel_values_videos is None: # handle mixed text-image data\n pixel_values = torch.zeros((16, 1176), dtype=inputs_embeds.dtype, device=inputs_embeds.device)\n image_grid_thw = torch.tensor([[1, 4, 4]], dtype=torch.long, device=inputs_embeds.device)\n image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n inputs_embeds += 0.0 * image_embeds.mean()\n\n if attention_mask is not None:\n attention_mask = attention_mask.to(inputs_embeds.device)\n\n return inputs_embeds, attention_mask\n\n\ndef process_position_ids(position_ids: torch.Tensor) -> torch.Tensor:\n if position_ids.ndim != 3 or position_ids.size(0) != 4:\n # we concat the text position ids with the 3D vision position ids by default\n # see https://github.com/huggingface/transformers/pull/39447\n raise ValueError(\"position_ids should be a 3D tensor of shape (4, batch_size, seq_length).\")\n\n return position_ids\n\n\n@dataclass\nclass Glm4vCausalLMOutputForPPO(Glm4vCausalLMOutputWithPast):\n log_probs: Optional[torch.FloatTensor] = None\n entropy: Optional[torch.FloatTensor] = None\n\n\ndef glm4v_base_forward(\n self: \"Glm4vForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n labels: Optional[torch.LongTensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n **kwargs,\n):\n kwargs[\"inputs_embeds\"], kwargs[\"attention_mask\"] = _get_input_embeds(\n self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw\n ) # avoid lora module having multiple keyword arguments\n return self.language_model(\n input_ids=None,\n **kwargs,\n )\n\n\ndef glm4v_forward(\n self: \"Glm4vForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n **kwargs,\n):\n return self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=process_position_ids(position_ids),\n pixel_values=pixel_values,\n pixel_values_videos=pixel_values_videos,\n image_grid_thw=image_grid_thw,\n video_grid_thw=video_grid_thw,\n **kwargs,\n )\n\n\ndef forward_with_normal_backend(\n self: Glm4vForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> \"Glm4vCausalLMOutputWithPast\":\n outputs = glm4v_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n logits = self.lm_head(hidden_states)\n\n return Glm4vCausalLMOutputWithPast(\n logits=logits,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_torch_backend(\n self: Glm4vForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> tuple | Glm4vCausalLMOutputForPPO:\n from verl.utils.experimental.torch_functional import FusedLinearForPPO\n\n outputs = glm4v_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_torch_backend, either labels or input_ids must be provided.\")\n\n fused_linear_for_ppo = FusedLinearForPPO()\n log_probs, entropy = fused_linear_for_ppo.forward(\n hidden_states=hidden_states,\n vocab_weights=self.lm_head.weight,\n input_ids=rolled_labels,\n temperature=temperature,\n )\n return Glm4vCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_triton_backend(\n self: Glm4vForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> tuple | Glm4vCausalLMOutputForPPO:\n from verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\n\n outputs = glm4v_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_triton_backend, either labels or input_ids must be provided.\")\n\n log_probs, entropy = linear_cross_entropy(\n hidden_states,\n self.lm_head.weight,\n rolled_labels,\n temperature,\n \"none\",\n )\n return Glm4vCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n"} +{"file_name": "verl__models__transformers__kimi_vl.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Optional\n\nimport torch\nimport torch.nn.functional as F\nfrom transformers.cache_utils import Cache\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward\n\nfrom verl.models.transformers.monkey_patch import is_transformers_version_in_range\n\n# Import compatibility wrapper for flash_attn_supports_top_left_mask\nfrom verl.utils.transformers_compat import flash_attn_supports_top_left_mask\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_world_size,\n validate_ulysses_config,\n)\n\n\n# Copied from transformers.models.llama.modeling_llama.rotate_half\ndef rotate_half(x):\n \"\"\"Rotates half the hidden dims of the input.\"\"\"\n x1 = x[..., : x.shape[-1] // 2]\n x2 = x[..., x.shape[-1] // 2 :]\n return torch.cat((-x2, x1), dim=-1)\n\n\n# Copied from transformers.models.llama.modeling_llama.apply_rotary_pos_emb\ndef apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1):\n \"\"\"Applies Rotary Position Embedding to the query and key tensors.\n\n Args:\n q (`torch.Tensor`): The query tensor.\n k (`torch.Tensor`): The key tensor.\n cos (`torch.Tensor`): The cosine part of the rotary embedding.\n sin (`torch.Tensor`): The sine part of the rotary embedding.\n position_ids (`torch.Tensor`):\n The position indices of the tokens corresponding to the query and key tensors. For example, this can be\n used to pass offsetted position ids when working with a KV-cache.\n unsqueeze_dim (`int`, *optional*, defaults to 1):\n The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and\n sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note\n that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and\n k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes\n cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have\n the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2.\n Returns:\n `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding.\n \"\"\"\n cos = cos[position_ids].unsqueeze(unsqueeze_dim)\n sin = sin[position_ids].unsqueeze(unsqueeze_dim)\n\n b, h, s, d = q.shape\n q = q.view(b, h, s, d // 2, 2).transpose(4, 3).reshape(b, h, s, d)\n\n b, h, s, d = k.shape\n k = k.view(b, h, s, d // 2, 2).transpose(4, 3).reshape(b, h, s, d)\n\n q_embed = (q * cos) + (rotate_half(q) * sin)\n k_embed = (k * cos) + (rotate_half(k) * sin)\n return q_embed, k_embed\n\n\n# Copied from transformers.models.llama.modeling_llama.repeat_kv\ndef repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:\n \"\"\"\n This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch,\n num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim)\n \"\"\"\n batch, num_key_value_heads, slen, head_dim = hidden_states.shape\n if n_rep == 1:\n return hidden_states\n hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim)\n return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim)\n\n\ndef _ulysses_flash_attn_forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.LongTensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_value: Optional[Cache] = None,\n output_attentions: bool = False,\n use_cache: bool = False,\n **kwargs,\n) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:\n bsz, q_len, _ = hidden_states.size()\n\n if self.q_lora_rank is None:\n q = self.q_proj(hidden_states)\n else:\n q = self.q_b_proj(self.q_a_layernorm(self.q_a_proj(hidden_states)))\n q = q.view(bsz, q_len, self.num_heads, self.q_head_dim).transpose(1, 2)\n\n # Flash attention requires the input to have the shape\n # batch_size x seq_length x head_dim x hidden_dim\n # therefore we just need to keep the original shape\n compressed_kv = self.kv_a_proj_with_mqa(hidden_states)\n compressed_kv, k_pe = torch.split(compressed_kv, [self.kv_lora_rank, self.qk_rope_head_dim], dim=-1)\n k_pe = k_pe.view(bsz, q_len, 1, self.qk_rope_head_dim).transpose(1, 2)\n kv = (\n self.kv_b_proj(self.kv_a_layernorm(compressed_kv))\n .view(bsz, q_len, self.num_heads, self.qk_nope_head_dim + self.v_head_dim)\n .transpose(1, 2)\n )\n\n k_nope, value_states = torch.split(kv, [self.qk_nope_head_dim, self.v_head_dim], dim=-1)\n\n # patch\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n if ulysses_sp_size > 1:\n validate_ulysses_config(self.num_heads, ulysses_sp_size)\n\n num_key_value_groups = self.config.num_attention_heads // self.config.num_key_value_heads\n k_pe = repeat_kv(k_pe, ulysses_sp_size) # to keep heads=1 after a2a\n k_nope = repeat_kv(k_nope, num_key_value_groups)\n value_states = repeat_kv(value_states, num_key_value_groups)\n q = gather_seq_scatter_heads(q, seq_dim=2, head_dim=1)\n k_pe = gather_seq_scatter_heads(k_pe, seq_dim=2, head_dim=1)\n k_nope = gather_seq_scatter_heads(k_nope, seq_dim=2, head_dim=1)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=2, head_dim=1)\n # (batch_size, num_head / sp_size, seq_length, head_size)\n full_q_len = q.size(2) # full_q_len = seq_length\n\n else:\n full_q_len = q_len\n\n q_nope, q_pe = torch.split(q, [self.qk_nope_head_dim, self.qk_rope_head_dim], dim=-1)\n cos, sin = self.rotary_emb(value_states, seq_len=full_q_len)\n q_pe, k_pe = apply_rotary_pos_emb(q_pe, k_pe, cos, sin, position_ids)\n\n query_states = k_pe.new_empty(bsz, self.num_heads // ulysses_sp_size, full_q_len, self.q_head_dim)\n query_states[:, :, :, : self.qk_nope_head_dim] = q_nope\n query_states[:, :, :, self.qk_nope_head_dim :] = q_pe\n\n key_states = k_pe.new_empty(bsz, self.num_heads // ulysses_sp_size, full_q_len, self.q_head_dim)\n key_states[:, :, :, : self.qk_nope_head_dim] = k_nope\n key_states[:, :, :, self.qk_nope_head_dim :] = k_pe\n\n if self.q_head_dim != self.v_head_dim:\n value_states = F.pad(value_states, [0, self.q_head_dim - self.v_head_dim])\n\n # TODO: These transpose are quite inefficient but Flash Attention requires the layout\n # [batch_size, sequence_length, num_heads, head_dim]. We would need to refactor the KV cache\n # to be able to avoid many of these transpose/reshape/view.\n query_states = query_states.transpose(1, 2)\n key_states = key_states.transpose(1, 2)\n value_states = value_states.transpose(1, 2)\n\n dropout_rate = self.attention_dropout if self.training else 0.0\n\n attn_output = _flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n full_q_len,\n dropout=dropout_rate,\n sliding_window=None,\n is_causal=self.is_causal,\n use_top_left_mask=flash_attn_supports_top_left_mask(),\n position_ids=position_ids, # important: pass position ids\n softmax_scale=self.softmax_scale,\n )\n\n if ulysses_sp_size > 1:\n attn_output = gather_heads_scatter_seq(attn_output, head_dim=2, seq_dim=1)\n\n if self.q_head_dim != self.v_head_dim:\n attn_output = attn_output[:, :, :, : self.v_head_dim]\n\n attn_output = attn_output.reshape(bsz, q_len, self.num_heads * self.v_head_dim).contiguous()\n attn_output = self.o_proj(attn_output)\n\n if is_transformers_version_in_range(min_version=\"4.53.0\"):\n return attn_output, None\n else:\n return attn_output, None, None\n"} +{"file_name": "verl__models__transformers__llama.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nfrom typing import Callable, Optional\n\nimport torch\n\nif sys.version_info >= (3, 11):\n pass\nelse:\n pass\n\nfrom transformers.cache_utils import Cache\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward\nfrom transformers.models.llama.modeling_llama import apply_rotary_pos_emb\nfrom transformers.utils import logging\n\n# Import compatibility wrapper for flash_attn_supports_top_left_mask\nfrom verl.utils.transformers_compat import flash_attn_supports_top_left_mask\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_world_size,\n validate_ulysses_config,\n)\n\nlogger = logging.get_logger(__name__)\n\n\ndef llama_flash_attn_forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.LongTensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_value: Optional[Cache] = None,\n output_attentions: bool = False,\n use_cache: bool = False,\n cache_position: Optional[torch.LongTensor] = None,\n position_embeddings: Optional[tuple[torch.Tensor, torch.Tensor]] = None, # will become mandatory in v4.46\n **kwargs,\n) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:\n \"\"\"\n Adapted from transformers 4.47.1 to support Ulysses sequence parallelism.\n\n NOTE: This function is used for transformers versions in the range [4.45.0, 4.47.1].\n \"\"\"\n output_attentions = False\n\n bsz, q_len, _ = hidden_states.size()\n\n query_states = self.q_proj(hidden_states)\n key_states = self.k_proj(hidden_states)\n value_states = self.v_proj(hidden_states)\n\n # Flash attention requires the input to have the shape\n # batch_size x seq_length x head_dim x hidden_dim\n # therefore we just need to keep the original shape\n query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)\n key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n\n # trade off: repeat first and then all to all\n # key_states = repeat_kv(key_states, self.num_key_value_groups)\n # value_states = repeat_kv(value_states, self.num_key_value_groups)\n\n ########## AlltoAll for Ulysses ##########\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n if ulysses_sp_size > 1:\n validate_ulysses_config(self.num_heads, ulysses_sp_size)\n\n # (bsz, n_head, seq_len/n, head_dim) -> (bsz, n_head/n, seq_len, head_dim)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=2, head_dim=1)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=2, head_dim=1)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=2, head_dim=1)\n\n full_q_len = query_states.size(2) # full seq length\n\n if position_embeddings is None:\n logger.warning_once(\n \"The attention layers in this model are transitioning from computing the RoPE embeddings internally \"\n \"through `position_ids` (2D tensor with the indexes of the tokens), to using externally computed \"\n \"`position_embeddings` (Tuple of tensors, containing cos and sin). In v4.46 `position_ids` will be \"\n \"removed and `position_embeddings` will be mandatory.\"\n )\n cos, sin = self.rotary_emb(value_states, position_ids)\n else:\n cos, sin = position_embeddings\n query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)\n\n if past_key_value is not None:\n # sin and cos are specific to RoPE models; cache_position needed for the static cache\n cache_kwargs = {\"sin\": sin, \"cos\": cos, \"cache_position\": cache_position}\n key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)\n\n # TODO: These transpose are quite inefficient but Flash Attention requires the layout\n # [batch_size, sequence_length, num_heads, head_dim]. We would need to refactor the KV cache\n # to be able to avoid many of these transpose/reshape/view.\n query_states = query_states.transpose(1, 2)\n key_states = key_states.transpose(1, 2)\n value_states = value_states.transpose(1, 2)\n\n dropout_rate = self.attention_dropout if self.training else 0.0\n\n # In PEFT, usually we cast the layer norms in float32 for training stability reasons\n # therefore the input hidden states gets silently casted in float32. Hence, we need\n # cast them back in the correct dtype just to be sure everything works as expected.\n # This might slowdown training & inference so it is recommended to not cast the LayerNorms\n # in fp32. (LlamaRMSNorm handles it correctly)\n\n input_dtype = query_states.dtype\n if input_dtype == torch.float32:\n if torch.is_autocast_enabled():\n target_dtype = torch.get_autocast_gpu_dtype()\n # Handle the case where the model is quantized\n elif hasattr(self.config, \"_pre_quantization_dtype\"):\n target_dtype = self.config._pre_quantization_dtype\n else:\n target_dtype = self.q_proj.weight.dtype\n\n logger.warning_once(\n f\"The input hidden states seems to be silently casted in float32, this might be related to \"\n f\"the fact you have upcasted embedding or layer norm layers in float32. We will cast back the \"\n f\"input in {target_dtype}.\"\n )\n\n query_states = query_states.to(target_dtype)\n key_states = key_states.to(target_dtype)\n value_states = value_states.to(target_dtype)\n\n attn_output = _flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n full_q_len,\n position_ids=position_ids,\n dropout=dropout_rate,\n sliding_window=getattr(self, \"sliding_window\", None),\n use_top_left_mask=flash_attn_supports_top_left_mask(),\n is_causal=self.is_causal,\n **kwargs,\n )\n\n attn_output = attn_output.reshape(bsz, full_q_len, -1, self.head_dim).contiguous()\n ########## AlltoAll for Ulysses ##########\n if ulysses_sp_size > 1:\n attn_output = gather_heads_scatter_seq(attn_output, seq_dim=1, head_dim=2)\n attn_output = attn_output.reshape(bsz, q_len, -1).contiguous()\n attn_output = self.o_proj(attn_output)\n\n if not output_attentions:\n attn_weights = None\n\n return attn_output, attn_weights, past_key_value\n\n\ndef llama_attn_forward(\n self,\n hidden_states: torch.Tensor,\n position_embeddings: tuple[torch.Tensor, torch.Tensor],\n attention_mask: Optional[torch.Tensor],\n past_key_value: Optional[Cache] = None,\n cache_position: Optional[torch.LongTensor] = None,\n **kwargs,\n) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:\n \"\"\"\n Adapted from transformers 4.49.0 to support Ulysses sequence parallelism for transformers >= 4.48.0.\n\n NOTE: This function has been tested only on transformers versions between 4.48.0 and 4.50.0.\n \"\"\"\n from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS\n from transformers.models.llama.modeling_llama import eager_attention_forward\n\n bsz, q_len, _ = hidden_states.shape\n\n query_states = self.q_proj(hidden_states).view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n key_states = self.k_proj(hidden_states).view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n value_states = self.v_proj(hidden_states).view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n\n ########## AlltoAll for Ulysses ##########\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n if ulysses_sp_size > 1:\n validate_ulysses_config(self.config.num_attention_heads, ulysses_sp_size)\n\n query_states = gather_seq_scatter_heads(query_states, seq_dim=2, head_dim=1)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=2, head_dim=1)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=2, head_dim=1)\n\n full_q_len = query_states.size(2)\n\n cos, sin = position_embeddings\n query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)\n\n if past_key_value is not None:\n # sin and cos are specific to RoPE models; cache_position needed for the static cache\n cache_kwargs = {\"sin\": sin, \"cos\": cos, \"cache_position\": cache_position}\n key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)\n\n attention_interface: Callable = eager_attention_forward\n if self.config._attn_implementation != \"eager\":\n if self.config._attn_implementation == \"sdpa\" and kwargs.get(\"output_attentions\", False):\n logger.warning_once(\n \"`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. \"\n \"Falling back to eager attention. This warning can be removed using the argument \"\n '`attn_implementation=\"eager\"` when loading the model.'\n )\n else:\n attention_interface = ALL_ATTENTION_FUNCTIONS[self.config._attn_implementation]\n\n attn_output, attn_weights = attention_interface(\n self,\n query_states,\n key_states,\n value_states,\n attention_mask,\n dropout=0.0 if not self.training else self.attention_dropout,\n scaling=self.scaling,\n **kwargs,\n )\n\n attn_output = attn_output.reshape(bsz, full_q_len, -1, self.head_dim).contiguous()\n ########## AlltoAll for Ulysses ##########\n if ulysses_sp_size > 1:\n attn_output = gather_heads_scatter_seq(attn_output, seq_dim=1, head_dim=2)\n attn_output = attn_output.reshape(bsz, q_len, -1).contiguous()\n attn_output = self.o_proj(attn_output)\n return attn_output, attn_weights\n"} +{"file_name": "verl__models__transformers__monkey_patch.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nApply monkey-patch function to models\n\"\"\"\n\nimport sys\nfrom types import SimpleNamespace\nfrom typing import Optional\n\nimport torch\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward\nfrom transformers.modeling_utils import PreTrainedModel\n\nfrom verl.utils.import_utils import is_trl_available\nfrom verl.utils.transformers_compat import is_transformers_version_in_range\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_group,\n get_ulysses_sequence_parallel_world_size,\n slice_input_tensor,\n)\n\n_PREFIX_GROUPER_PATCHED = False\n_PREFIX_GROUPER_SUPPORTED_ATTENTIONS = {\"flash_attention_2\", \"flash_attention_3\", \"sdpa\", \"flex_attention\", \"eager\"}\n\n\ndef _create_prefix_grouper_wrapper(original_fn):\n \"\"\"Wrap attention function to support prefix_grouper in kwargs.\"\"\"\n\n def wrapped(module, query, key, value, attention_mask, *args, **kwargs):\n prefix_grouper = kwargs.pop(\"prefix_grouper\", None)\n if prefix_grouper is None:\n return original_fn(module, query, key, value, attention_mask, *args, **kwargs)\n\n def attn_func(q, k, v, attn_mask, *inner_args, **inner_kwargs):\n out, _ = original_fn(module, q, k, v, attn_mask, *inner_args, **inner_kwargs)\n return out\n\n return prefix_grouper.forward(attn_func, query, key, value, *args, **kwargs), None\n\n return wrapped\n\n\ndef apply_prefix_grouper_patch():\n \"\"\"Patch ALL_ATTENTION_FUNCTIONS to support prefix_grouper parameter.\"\"\"\n global _PREFIX_GROUPER_PATCHED\n if _PREFIX_GROUPER_PATCHED:\n return\n\n from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS\n\n patched = []\n for name in list(ALL_ATTENTION_FUNCTIONS.keys()):\n if name in _PREFIX_GROUPER_SUPPORTED_ATTENTIONS:\n ALL_ATTENTION_FUNCTIONS[name] = _create_prefix_grouper_wrapper(ALL_ATTENTION_FUNCTIONS[name])\n patched.append(name)\n\n _PREFIX_GROUPER_PATCHED = True\n print(f\"[PrefixGrouper] Patched: {patched}\")\n\n\ndef repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor:\n \"\"\"\n This is the equivalent of torch.repeat_interleave(x, dim=2, repeats=n_rep). The hidden states go from (batch,\n seqlen, num_key_value_heads, head_dim) to (batch, seqlen, num_attention_heads, head_dim)\n \"\"\"\n batch, slen, num_key_value_heads, head_dim = hidden_states.shape\n if n_rep == 1:\n return hidden_states\n hidden_states = hidden_states[:, :, :, None, :].expand(batch, slen, num_key_value_heads, n_rep, head_dim)\n return hidden_states.reshape(batch, slen, num_key_value_heads * n_rep, head_dim)\n\n\ndef _ulysses_flash_attention_forward(\n query_states: torch.Tensor,\n key_states: torch.Tensor,\n value_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor],\n query_length: int,\n *args,\n position_ids: Optional[torch.Tensor] = None,\n **kwargs,\n):\n \"\"\"Insert all-to-all before and after flash attention.\n DeepSpeed-Ulysses: https://arxiv.org/pdf/2309.14509\n\n For transformers>=4.55, the flash attention api has changed,\n we need to pass the query_length after doing ulysses all2all.\n See https://github.com/huggingface/transformers/issues/40399\n\n Args:\n query_states (torch.Tensor): (batch_size, seqlen/sp_size, nheads, head_dim)\n key_states (torch.Tensor): (batch_size, seqlen/sp_size, nheads_k, head_dim)\n value_states (torch.Tensor): (batch_size, seqlen/sp_size, nheads_k, head_dim)\n position_ids (torch.Tensor, optional): (batch_size, seqlen/sp_size)\n\n Returns:\n torch.Tensor: (batch_size, seqlen/sp_size, nheads, head_dim)\n\n \"\"\"\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n ########## AlltoAll for Ulysses ##########\n # TODO: Disable sp for ViT, there's no elegent way to determine whether it's ViT or not.\n # Use `position_ids` as condition since ViT doesn't pass it to flash attention.\n if ulysses_sp_size > 1 and position_ids is not None:\n # NOTE: repeat kv heads to be divided by sequence parallel. Instead of repeating nheads_q//nheads_k,\n # we choose to repeat sp_size//nheads_k, since flash_attention supports MQA/GQA.\n # For example:\n # - nheads_k=4, sp=8, repeats=2\n # - nheads_k=8, sp=8, repeats=1\n # - nheads_k=16, sp=8, repeats=1\n repeats = max(ulysses_sp_size // key_states.size(2), 1)\n key_states = repeat_kv(key_states, repeats)\n value_states = repeat_kv(value_states, repeats)\n\n # (bsz, seq_len/n, n_head, head_dim) -> (bsz, seq_len, n_head/n, head_dim)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=1, head_dim=2)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=1, head_dim=2)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=1, head_dim=2)\n\n # TODO: all_gather position_ids because `prepare_fa2_from_position_ids` needs it, we can eliminate\n # this all_gather by passing cu_seq_lens_q, cu_seq_lens_k, max_length_k, max_length_q explicitly.\n # https://github.com/huggingface/transformers/pull/33932\n\n # (bsz, seq_len/n) -> (bsz, seq_len)\n position_ids_list = [torch.empty_like(position_ids) for _ in range(ulysses_sp_size)]\n torch.distributed.all_gather(position_ids_list, position_ids, group=get_ulysses_sequence_parallel_group())\n position_ids = torch.concat(position_ids_list, dim=-1)\n\n # (bsz, seq_len, n_head/n, head_dim)\n query_length = query_states.size(1)\n attn_output = _flash_attention_forward(\n query_states, key_states, value_states, attention_mask, query_length, *args, position_ids=position_ids, **kwargs\n )\n\n ########## AlltoAll for Ulysses ##########\n if ulysses_sp_size > 1 and position_ids is not None:\n # (bsz, seq_len, n_head/n, head_dim) -> (bsz, seq_len/n, n_head, head_dim)\n attn_output = gather_heads_scatter_seq(attn_output, seq_dim=1, head_dim=2)\n\n return attn_output\n\n\ndef patch_vlm_for_ulysses_input_slicing(model_class: type):\n \"\"\"\n Applies a monkey patch to the forward method of a given model class\n to enable Ulysses sequence parallelism input slicing.\n \"\"\"\n\n def _create_ulysses_wrapped_decoder_forward(original_forward):\n def ulysses_wrapped_decoder_forward(self, *args, **kwargs):\n inputs_embeds = kwargs.get(\"inputs_embeds\")\n position_ids = kwargs.get(\"position_ids\")\n visual_pos_masks = kwargs.get(\"visual_pos_masks\")\n deepstack_visual_embeds = kwargs.get(\"deepstack_visual_embeds\")\n call_kwargs = kwargs.copy()\n\n current_ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n slice_now = (\n inputs_embeds is not None\n and current_ulysses_sp_size > 1\n and getattr(self, \"_needs_initial_slice\", True)\n )\n if slice_now:\n call_kwargs[\"inputs_embeds\"] = slice_input_tensor(inputs_embeds, dim=1, padding=False)\n call_kwargs[\"position_ids\"] = slice_input_tensor(position_ids, dim=-1, padding=False)\n # Also slice visual_pos_masks and deepstack_visual_embeds for Qwen3 VL models\n if visual_pos_masks is not None:\n original_visual_mask = visual_pos_masks\n sliced_visual_mask = slice_input_tensor(visual_pos_masks, dim=1, padding=False)\n call_kwargs[\"visual_pos_masks\"] = sliced_visual_mask\n\n if deepstack_visual_embeds is not None:\n sliced_embeds = []\n\n num_visual_before = original_visual_mask.sum().item()\n num_visual_in_shard = sliced_visual_mask.sum().item()\n\n if num_visual_in_shard > 0 and num_visual_before > 0:\n # Calculate which visual embeddings belong to this shard\n # We need to find the offset of visual tokens in this shard\n from verl.utils.ulysses import get_ulysses_sequence_parallel_rank\n\n rank = get_ulysses_sequence_parallel_rank()\n seq_len = original_visual_mask.shape[1]\n local_seq_len = seq_len // current_ulysses_sp_size\n start_idx = rank * local_seq_len\n end_idx = start_idx + local_seq_len\n\n # Get total visual tokens before and up to the end of the shard's sequence slice\n # This correctly handles batches by summing across all samples\n visual_start = original_visual_mask[:, :start_idx].sum().item() if start_idx > 0 else 0\n visual_end = original_visual_mask[:, :end_idx].sum().item()\n\n # Slice each tensor in deepstack_visual_embeds\n for embed in deepstack_visual_embeds:\n sliced_embeds.append(embed[visual_start:visual_end])\n else:\n # No visual tokens in this shard, create empty tensors to maintain gradient flow\n for embed in deepstack_visual_embeds:\n sliced_embeds.append(embed[:0])\n call_kwargs[\"deepstack_visual_embeds\"] = sliced_embeds\n\n self._needs_initial_slice = False\n try:\n return original_forward(self, *args, **call_kwargs)\n finally:\n if slice_now:\n self._needs_initial_slice = True\n\n return ulysses_wrapped_decoder_forward\n\n original_forward = model_class.forward\n wrapped_forward = _create_ulysses_wrapped_decoder_forward(original_forward)\n model_class.forward = wrapped_forward\n print(f\"Monkey patch {model_class.__name__}.forward for Ulysses SP input slicing.\")\n\n\ndef patch_forward_with_backends(\n model: PreTrainedModel,\n use_fused_kernels: bool = False,\n fused_kernels_backend: str = None,\n):\n \"\"\"\n Choose the forward function based on the model and backend.\n Args:\n model (PreTrainedModel): The model to apply the monkey patch.\n use_fused_kernels (bool): Whether to use fused kernels.\n fused_kernels_backend (str): The backend to use for fused kernels.\n \"\"\"\n if not use_fused_kernels or fused_kernels_backend not in [\"triton\", \"torch\"]:\n print(\n f\"Skipping monkey patch for {model.__class__.__name__} as use_fused_kernels is \"\n f\"{use_fused_kernels} or fused_kernels_backend is {fused_kernels_backend}\"\n )\n return\n\n forward_with_torch_backend_function = model.__class__.forward\n forward_with_triton_backend_function = model.__class__.forward\n if model.config.model_type in [\"qwen2_5_vl\", \"qwen2_vl\"]:\n from verl.models.transformers.qwen2_vl import forward_with_torch_backend, forward_with_triton_backend\n\n forward_with_torch_backend_function = forward_with_torch_backend\n forward_with_triton_backend_function = forward_with_triton_backend\n elif model.config.model_type in [\"qwen3_vl\", \"qwen3_vl_moe\"]:\n from verl.models.transformers.qwen3_vl import forward_with_torch_backend, forward_with_triton_backend\n\n forward_with_torch_backend_function = forward_with_torch_backend\n forward_with_triton_backend_function = forward_with_triton_backend\n elif model.config.model_type == \"glm4v\":\n from verl.models.transformers.glm4v import forward_with_torch_backend, forward_with_triton_backend\n\n forward_with_torch_backend_function = forward_with_torch_backend\n forward_with_triton_backend_function = forward_with_triton_backend\n else:\n from verl.models.transformers.dense_common import forward_with_torch_backend, forward_with_triton_backend\n\n forward_with_torch_backend_function = forward_with_torch_backend\n forward_with_triton_backend_function = forward_with_triton_backend\n\n if fused_kernels_backend == \"triton\":\n model.__class__.forward = forward_with_triton_backend_function\n print(f\"Using Triton backend for fused kernels in {model.__class__.__name__}\")\n elif fused_kernels_backend == \"torch\":\n model.__class__.forward = forward_with_torch_backend_function\n print(f\"Using Torch backend for fused kernels in {model.__class__.__name__}\")\n else:\n raise ValueError(f\"Unsupported fused_kernels_backend: {fused_kernels_backend}. Choose 'triton' or 'torch'.\")\n\n\ndef apply_monkey_patch(\n model: PreTrainedModel,\n ulysses_sp_size: int = 1,\n use_remove_padding: bool = True,\n use_fused_kernels: bool = False,\n fused_kernels_backend: str = None,\n use_prefix_grouper: bool = False,\n use_tiled_mlp: bool = False,\n tiled_mlp_shards: int = 4,\n):\n \"\"\"\n Apply monkey patch to the models for ulysses sequence parallel, fused kernel, tiled MLP and prefix grouper.\n\n In the end of this function forward function of the model is patched for fused kernel.\n If the model is not supported with fused kernel, please return after patch.\n\n Args:\n model: The model to apply the monkey patch.\n ulysses_sp_size: The size of ulysses sequence parallel.\n use_remove_padding: Whether to use remove padding.\n use_fused_kernels: Whether to use fused kernels.\n fused_kernels_backend: The backend to use for fused kernels.\n use_tiled_mlp: Whether to use TiledMLP for memory-efficient MLP computation.\n tiled_mlp_shards: Number of shards for TiledMLP (higher = lower memory, slightly slower).\n \"\"\"\n\n # Apply TiledMLP monkey patch for memory-efficient MLP computation\n if use_tiled_mlp:\n from verl.models.transformers.tiled_mlp import apply_tiled_mlp_monkey_patch\n\n model_type = getattr(model.config, \"model_type\", None)\n apply_tiled_mlp_monkey_patch(num_shards=tiled_mlp_shards, model_type=model_type)\n # Apply PrefixGrouper patch if enabled\n if use_prefix_grouper:\n apply_prefix_grouper_patch()\n\n \"\"\"Replace _flash_attention_forward to _ulysses_flash_attention_forward\"\"\"\n module = sys.modules[model.__module__]\n\n try:\n num_attention_heads, num_key_value_heads = model.config.num_attention_heads, model.config.num_key_value_heads\n except AttributeError:\n num_attention_heads, num_key_value_heads = (\n model.config.text_config.num_attention_heads,\n model.config.text_config.num_key_value_heads,\n )\n\n assert num_attention_heads % ulysses_sp_size == 0, (\n f\"num_attention_heads {num_attention_heads} must be divisible by ulysses_sp_size {ulysses_sp_size}\"\n )\n assert num_key_value_heads % ulysses_sp_size == 0 or ulysses_sp_size % num_key_value_heads == 0, (\n f\"num_key_value_heads {num_key_value_heads} must be divisible by ulysses_sp_size \"\n f\"{ulysses_sp_size}or vise versa. Upon ulysses_sp_size % num_key_value_heads == 0,\"\n f\"kv heads are repeated to ensure correctness.\"\n )\n\n if is_trl_available():\n from trl import AutoModelForCausalLMWithValueHead # type: ignore\n\n def state_dict(self, *args, **kwargs):\n return torch.nn.Module.state_dict(self, *args, **kwargs)\n\n AutoModelForCausalLMWithValueHead.state_dict = state_dict\n print(\"Monkey patch state_dict in AutoModelForCausalLMWithValueHead. \")\n\n # TODO: VLM models only, unify monkey patch to LLM models.\n if model.config.model_type in [\"qwen2_5_vl\", \"qwen2_vl\"]:\n # Step 1: patch model to support image-text mixed data\n if is_transformers_version_in_range(min_version=\"4.52.0\"):\n from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import (\n Qwen2_5_VLForConditionalGeneration,\n Qwen2_5_VLModel,\n Qwen2_5_VLTextModel,\n )\n from transformers.models.qwen2_vl.modeling_qwen2_vl import (\n Qwen2VLForConditionalGeneration,\n Qwen2VLModel,\n Qwen2VLTextModel,\n )\n else:\n from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLForConditionalGeneration\n from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLModel as Qwen2_5_VLTextModel\n from transformers.models.qwen2_vl.modeling_qwen2_vl import Qwen2VLForConditionalGeneration\n from transformers.models.qwen2_vl.modeling_qwen2_vl import Qwen2VLModel as Qwen2VLTextModel\n\n Qwen2_5_VLModel = SimpleNamespace(forward=None)\n Qwen2VLModel = SimpleNamespace(forward=None)\n\n from verl.models.transformers.qwen2_vl import forward_with_normal_backend, qwen2_vl_base_forward\n\n Qwen2_5_VLModel.forward = qwen2_vl_base_forward\n Qwen2VLModel.forward = qwen2_vl_base_forward\n Qwen2_5_VLForConditionalGeneration.forward = forward_with_normal_backend\n Qwen2VLForConditionalGeneration.forward = forward_with_normal_backend\n print(f\"Monkey patch {model.__class__.__name__} model forward\")\n\n # Step 2: patch attention to support ulysses parallelism\n if is_transformers_version_in_range(min_version=\"4.54.0\"):\n from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import Qwen2_5_VLAttention\n from transformers.models.qwen2_vl.modeling_qwen2_vl import Qwen2VLAttention\n elif is_transformers_version_in_range(min_version=\"4.53.0\"):\n raise RuntimeError(\"Transformers 4.53.* is bugged. Use transformers 4.54.0 or later.\")\n else:\n from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import (\n Qwen2_5_VLFlashAttention2 as Qwen2_5_VLAttention,\n )\n from transformers.models.qwen2_vl.modeling_qwen2_vl import Qwen2VLFlashAttention2 as Qwen2VLAttention\n\n if use_remove_padding or ulysses_sp_size > 1:\n from verl.models.transformers.qwen2_vl import qwen2_vl_attn_forward\n\n Qwen2_5_VLAttention.forward = qwen2_vl_attn_forward\n Qwen2VLAttention.forward = qwen2_vl_attn_forward\n print(f\"Monkey patch {model.__class__.__name__} attention layer\")\n\n # Step 3: patch input for multimodal sequence parallelism\n if ulysses_sp_size > 1:\n patch_vlm_for_ulysses_input_slicing(Qwen2_5_VLTextModel)\n patch_vlm_for_ulysses_input_slicing(Qwen2VLTextModel)\n\n elif model.config.model_type in [\"qwen3_vl\", \"qwen3_vl_moe\"]:\n # Step 1: patch model to support image-text mixed data\n from transformers.models.qwen3_vl.modeling_qwen3_vl import (\n Qwen3VLForConditionalGeneration,\n Qwen3VLModel,\n Qwen3VLTextModel,\n )\n from transformers.models.qwen3_vl_moe.modeling_qwen3_vl_moe import (\n Qwen3VLMoeForConditionalGeneration,\n Qwen3VLMoeModel,\n Qwen3VLMoeTextModel,\n )\n\n from verl.models.transformers.qwen3_vl import (\n forward_with_normal_backend,\n patch_qwen3_vl_moe_sparse_moe_block_forward,\n qwen3_vl_base_forward,\n )\n\n Qwen3VLModel.forward = qwen3_vl_base_forward\n Qwen3VLMoeModel.forward = qwen3_vl_base_forward\n Qwen3VLForConditionalGeneration.forward = forward_with_normal_backend\n Qwen3VLMoeForConditionalGeneration.forward = forward_with_normal_backend\n print(f\"Monkey patch {model.__class__.__name__} model forward\")\n\n # Step 1.5: patch Qwen3VLMoeTextSparseMoeBlock to fix transformers 4.57.3 bug\n if model.config.model_type == \"qwen3_vl_moe\" and is_transformers_version_in_range(max_version=\"4.57.3\"):\n patch_qwen3_vl_moe_sparse_moe_block_forward()\n\n # Step 2: patch input for multimodal sequence parallelism\n if ulysses_sp_size > 1:\n patch_vlm_for_ulysses_input_slicing(Qwen3VLTextModel)\n patch_vlm_for_ulysses_input_slicing(Qwen3VLMoeTextModel)\n\n elif model.config.model_type == \"glm4v\":\n # Step 1: patch model to support image-text mixed data\n\n from transformers.models.glm4v.modeling_glm4v import (\n Glm4vForConditionalGeneration,\n Glm4vModel,\n Glm4vTextAttention,\n Glm4vTextModel,\n )\n\n from verl.models.transformers.glm4v import forward_with_normal_backend, glm4v_base_forward\n\n Glm4vModel.forward = glm4v_base_forward\n Glm4vForConditionalGeneration.forward = forward_with_normal_backend\n print(f\"Monkey patch {model.__class__.__name__} model forward\")\n\n # Step 2: patch attention to support ulysses parallelism\n if use_remove_padding or ulysses_sp_size > 1:\n from verl.models.transformers.glm4v import glm4v_attn_forward\n\n Glm4vTextAttention.forward = glm4v_attn_forward\n print(f\"Monkey patch {model.__class__.__name__} attention layer\")\n\n # Step 3: patch input for multimodal sequence parallelism\n if ulysses_sp_size > 1:\n patch_vlm_for_ulysses_input_slicing(Glm4vTextModel)\n\n elif model.config.model_type == \"kimi_vl\":\n if use_remove_padding or ulysses_sp_size > 1:\n # TODO: Changes need to be made when transformers are adapted.\n from verl.models.transformers.kimi_vl import _ulysses_flash_attn_forward\n\n module.DeepseekV3FlashAttention2.forward = _ulysses_flash_attn_forward\n print(\"Monkey patch FlashAttention2.forward in KimiVL\")\n\n if ulysses_sp_size > 1:\n patch_vlm_for_ulysses_input_slicing(module.DeepseekV3ForCausalLM)\n\n if use_fused_kernels:\n print(\"Not support fused kernels for KimiVL\")\n\n return\n\n if use_remove_padding or ulysses_sp_size > 1:\n if hasattr(module, \"_flash_attention_forward\"): # transformers <= 4.47.1 or legacy models\n module._flash_attention_forward = _ulysses_flash_attention_forward\n print(f\"Monkey patch _flash_attention_forward in {model.__module__}\")\n else:\n from transformers.integrations import flash_attention\n\n flash_attention._flash_attention_forward = _ulysses_flash_attention_forward\n print(f\"Monkey patch _flash_attention_forward in {flash_attention.__name__}\")\n\n patch_forward_with_backends(model, use_fused_kernels=use_fused_kernels, fused_kernels_backend=fused_kernels_backend)\n"} +{"file_name": "verl__models__transformers__npu_patch.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n#\n# Copyright 2025 The Qwen Team and The HuggingFace Inc. team\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport torch\nimport torch.nn.functional as F\nimport torch_npu\nfrom torch import nn\nfrom transformers.activations import ACT2FN\nfrom transformers.models.qwen2 import modeling_qwen2\nfrom transformers.models.qwen2_5_vl import modeling_qwen2_5_vl\nfrom transformers.models.qwen3 import modeling_qwen3\nfrom transformers.models.qwen3_moe import modeling_qwen3_moe\nfrom transformers.models.qwen3_next import modeling_qwen3_next\nfrom transformers.models.qwen3_vl import modeling_qwen3_vl\nfrom transformers.models.qwen3_vl_moe import modeling_qwen3_vl_moe\nfrom transformers.utils import logging\n\nlogger = logging.get_logger(__name__)\n\n\ndef rms_norm_forward_npu(self, x):\n \"\"\"NPU optimized implementation for RMSNorm.\"\"\"\n if x.dtype != self.weight.dtype:\n x = x.to(self.weight.dtype)\n return torch_npu.npu_rms_norm(x, self.weight, epsilon=self.variance_epsilon)[0]\n\n\ndef silu_forward_npu(self, hidden_state):\n \"\"\"NPU optimized implementation for SiLU in `forward` func in MLP layer.\"\"\"\n gate_up = torch.cat((self.gate_proj(hidden_state), self.up_proj(hidden_state)), dim=-1)\n return self.down_proj(torch_npu.npu_swiglu(gate_up, dim=-1))\n\n\ndef apply_rotary_pos_emb_npu(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):\n \"\"\"NPU optimized implementation for RoPE.\"\"\"\n cos = cos.unsqueeze(unsqueeze_dim)\n sin = sin.unsqueeze(unsqueeze_dim)\n q_embed = torch_npu.npu_rotary_mul(q, cos, sin)\n k_embed = torch_npu.npu_rotary_mul(k, cos, sin)\n return q_embed.to(q.dtype), k_embed.to(k.dtype)\n\n\ndef qwen3_next_rms_norm_forward_npu(self, x):\n return torch_npu.npu_rms_norm(x.float(), 1.0 + self.weight.float(), epsilon=self.eps)[0].type_as(x)\n\n\ndef qwen3_next_rms_norm_forward_gated_npu(self, hidden_states, gate=None):\n input_dtype = hidden_states.dtype\n hidden_states = hidden_states.to(torch.float32)\n hidden_states = torch_npu.npu_rms_norm(hidden_states, self.weight.float(), epsilon=self.variance_epsilon)[0]\n hidden_states = hidden_states * F.silu(gate.to(torch.float32))\n return hidden_states.to(input_dtype)\n\n\ndef qwen3_next_apply_rotary_pos_emb_npu(q, k, cos, sin, position_ids=None, unsqueeze_dim=1):\n cos = cos.unsqueeze(unsqueeze_dim)\n sin = sin.unsqueeze(unsqueeze_dim)\n\n # Keep half or full tensor for later concatenation\n rotary_dim = cos.shape[-1]\n q_rot, q_pass = q[..., :rotary_dim], q[..., rotary_dim:]\n k_rot, k_pass = k[..., :rotary_dim], k[..., rotary_dim:]\n\n q_embed = torch_npu.npu_rotary_mul(q_rot, cos, sin).to(q.dtype)\n k_embed = torch_npu.npu_rotary_mul(k_rot, cos, sin).to(k.dtype)\n q_embed = torch.cat([q_embed, q_pass], dim=-1)\n k_embed = torch.cat([k_embed, k_pass], dim=-1)\n return q_embed, k_embed\n\n\nclass NPUGmmFunction(torch.autograd.Function):\n @staticmethod\n def forward(ctx, x, weight, group_list, group_list_type=1):\n \"\"\"\n Grouped Matmul(GMM) for Ascend NPU.\n\n Args:\n x (torch.Tensor): Input tensor, shape (tokens_num * top_k, hidden_size)\n weight (torch.Tensor): Expert weights, shape (n_experts, hidden_size, intermediate_size)\n group_list (torch.Tensor): Expert token counts, shape (n_experts,)\n - type 0: cumsum of tokens per expert\n - type 1: direct tokens per expert (default)\n \"\"\"\n ctx.save_for_backward(x, weight)\n ctx.group_list = group_list\n ctx.group_list_type = group_list_type\n\n output = torch_npu.npu_grouped_matmul(\n [x], [weight], bias=None, group_list=group_list, split_item=2, group_type=0, group_list_type=group_list_type\n )[0]\n\n return output\n\n @staticmethod\n def backward(ctx, grad_output):\n x, weight = ctx.saved_tensors\n group_list = ctx.group_list\n group_list_type = ctx.group_list_type\n\n dx = torch_npu.npu_grouped_matmul(\n [grad_output],\n [weight.transpose(1, 2)],\n bias=None,\n group_list=group_list,\n split_item=2,\n group_type=0,\n group_list_type=group_list_type,\n )[0]\n\n dw = torch_npu.npu_grouped_matmul(\n [x.transpose(0, 1)],\n [grad_output],\n bias=None,\n group_list=group_list,\n split_item=3,\n group_type=2,\n group_list_type=group_list_type,\n )[0]\n\n return dx, dw, None, None\n\n\ndef _qwen3_sparse_moe_routed_forward_npu(self, hidden_states: torch.Tensor):\n \"\"\"\n Shared NPU routed-expert path for Qwen3Moe/Qwen3Next sparse MoE blocks.\n\n Returns:\n tuple: (flattened_input, routed_hidden_states, router_logits)\n \"\"\"\n hidden_dim = hidden_states.shape[-1]\n hidden_states = hidden_states.view(-1, hidden_dim)\n # router_logits: (batch * sequence_length, n_experts)\n router_logits = self.gate(hidden_states)\n\n routing_weights = F.softmax(router_logits, dim=1, dtype=torch.float)\n routing_weights, selected_experts = torch.topk(routing_weights, self.top_k, dim=-1)\n if self.norm_topk_prob: # only diff with mixtral sparse moe block!\n routing_weights /= routing_weights.sum(dim=-1, keepdim=True)\n # we cast back to the input dtype\n routing_weights = routing_weights.to(hidden_states.dtype)\n\n # Loop over all available experts in the model and perform the computation on each expert\n # Concat all weights\n input_dtype = hidden_states.dtype\n up_weight_list = [e.up_proj.weight for e in self.experts]\n gate_weight_list = [e.gate_proj.weight for e in self.experts]\n down_weight_list = [e.down_proj.weight for e in self.experts]\n w1 = torch.stack(up_weight_list).transpose(1, 2).to(input_dtype)\n w2 = torch.stack(gate_weight_list).transpose(1, 2).to(input_dtype)\n w3 = torch.stack(down_weight_list).transpose(1, 2).to(input_dtype)\n\n permuted_tokens, row_ids_map = torch_npu.npu_moe_token_permute(hidden_states, selected_experts.to(torch.int32))\n tokens_per_expert = torch.histc(selected_experts, bins=self.num_experts, min=0, max=self.num_experts)\n\n up_res = NPUGmmFunction.apply(permuted_tokens, w1, tokens_per_expert)\n gate_res = NPUGmmFunction.apply(permuted_tokens, w2, tokens_per_expert)\n act_res = torch_npu.npu_swiglu(torch.cat([gate_res, up_res], dim=-1))\n down_res = NPUGmmFunction.apply(act_res, w3, tokens_per_expert)\n\n routed_hidden_states = torch_npu.npu_moe_token_unpermute(down_res, row_ids_map, probs=routing_weights)\n\n return hidden_states, routed_hidden_states, router_logits\n\n\ndef qwen3_moe_sparse_moe_block_forward_npu(self, hidden_states: torch.Tensor) -> torch.Tensor:\n \"\"\"NPU optimized implementation for `forward` in Qwen3MoeSparseMoeBlock.\"\"\"\n output_shape = hidden_states.shape\n _, routed_hidden_states, router_logits = _qwen3_sparse_moe_routed_forward_npu(self, hidden_states)\n final_hidden_states = routed_hidden_states.reshape(output_shape)\n return final_hidden_states, router_logits\n\n\ndef qwen3_next_sparse_moe_block_forward_npu(self, hidden_states: torch.Tensor) -> torch.Tensor:\n \"\"\"NPU optimized implementation for `forward` in Qwen3NextSparseMoeBlock.\"\"\"\n output_shape = hidden_states.shape\n hidden_states, routed_hidden_states, router_logits = _qwen3_sparse_moe_routed_forward_npu(self, hidden_states)\n\n shared_expert_output = self.shared_expert(hidden_states)\n shared_expert_output = torch.sigmoid(self.shared_expert_gate(hidden_states)) * shared_expert_output\n\n final_hidden_states = (routed_hidden_states + shared_expert_output).reshape(output_shape)\n return final_hidden_states, router_logits\n\n\nclass NPUQwen3VLMoeTextExperts(nn.Module):\n \"\"\"NPU optimized implementation for Qwen3VLMoeTextExperts.\"\"\"\n\n def __init__(self, config):\n super().__init__()\n self.num_experts = config.num_experts\n self.intermediate_size = config.moe_intermediate_size\n self.hidden_size = config.hidden_size\n self.expert_dim = self.intermediate_size\n self.gate_up_proj = nn.Parameter(torch.empty(self.num_experts, self.hidden_size, 2 * self.expert_dim))\n self.down_proj = nn.Parameter(torch.empty((self.num_experts, self.expert_dim, self.hidden_size)))\n self.act_fn = ACT2FN[config.hidden_act]\n\n def forward(\n self, hidden_states: torch.Tensor, routing_weights: torch.Tensor, router_indices: torch.Tensor\n ) -> torch.Tensor:\n \"\"\"\n When training it is more efficient to just loop over the experts and compute the output for each expert\n as otherwise the memory would explode.\n\n For inference we can sacrifice some memory and compute the output for all experts at once.\n By repeating the inputs.\n\n Args:\n hidden_states (torch.Tensor): (batch_size * token_num, hidden_size)\n routing_weights (torch.Tensor): (batch_size * token_num, num_experts)\n router_indices (torch.Tensor): (batch_size * token_num, top_k)\n Returns:\n torch.Tensor\n \"\"\"\n batch_size = hidden_states.shape[0]\n hidden_states = hidden_states.reshape(-1, self.hidden_size) # (num_tokens, hidden_size)\n if self.training:\n permuted_hidden_states, row_ids_map = torch_npu.npu_moe_token_permute(\n hidden_states, router_indices.to(torch.int32)\n )\n tokens_per_expert = torch.histc(router_indices, bins=self.num_experts, min=0, max=self.num_experts)\n intermediate_hidden_states = NPUGmmFunction.apply(\n permuted_hidden_states, self.gate_up_proj, tokens_per_expert\n )\n intermediate_activations = torch_npu.npu_swiglu(intermediate_hidden_states, dim=-1)\n output = NPUGmmFunction.apply(intermediate_activations, self.down_proj, tokens_per_expert)\n num_tokens = hidden_states.shape[0]\n top_k = router_indices.shape[1]\n batch_idx = torch.arange(num_tokens, device=routing_weights.device)\n batch_idx = batch_idx.unsqueeze(1).expand(-1, top_k)\n selected_probs = routing_weights[batch_idx, router_indices]\n next_states = torch_npu.npu_moe_token_unpermute(output, row_ids_map, probs=selected_probs)\n next_states = next_states.view(batch_size, -1, self.hidden_size)\n else:\n hidden_states = hidden_states.repeat(self.num_experts, 1)\n hidden_states = hidden_states.view(self.num_experts, -1, self.hidden_size)\n gate_up = torch.bmm(hidden_states, self.gate_up_proj)\n gate, up = gate_up.chunk(2, dim=-1) # not supported for DTensors\n next_states = torch.bmm((up * self.act_fn(gate)), self.down_proj)\n next_states = next_states.reshape(self.num_experts, batch_size, -1, self.hidden_size)\n next_states = (\n next_states * routing_weights.transpose(0, 1).view(self.num_experts, batch_size, -1)[..., None]\n )\n next_states = next_states.sum(dim=0)\n return next_states\n\n\nclass NPUQwen3VLMoeTextSparseMoeBlock(nn.Module):\n \"\"\"NPU optimized implementation for Qwen3VLMoeTextSparseMoeBlock.\"\"\"\n\n def __init__(self, config):\n super().__init__()\n self.hidden_size = config.hidden_size\n self.num_experts = config.num_experts\n self.top_k = config.num_experts_per_tok\n self.gate = nn.Linear(config.hidden_size, config.num_experts, bias=False)\n self.experts = NPUQwen3VLMoeTextExperts(config)\n\n def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:\n batch_size = hidden_states.shape[0]\n hidden_states = hidden_states.reshape(-1, self.hidden_size)\n router_logits = self.gate(hidden_states)\n routing_weights = torch.nn.functional.softmax(router_logits, dim=-1, dtype=torch.float)\n routing_weights, router_indices = torch.topk(routing_weights, self.top_k, dim=-1)\n routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True)\n routing_weights = routing_weights.to(router_logits.dtype)\n hidden_states = hidden_states.reshape(batch_size, -1, self.hidden_size)\n if not self.training:\n routing_weights = torch.zeros_like(router_logits).scatter_(1, router_indices, routing_weights)\n routed_out = self.experts(hidden_states, routing_weights, router_indices)\n return routed_out\n\n\n# Patches for Qwen2 Model\nmodeling_qwen2.Qwen2RMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen2.Qwen2MLP.forward = silu_forward_npu\nmodeling_qwen2.apply_rotary_pos_emb = apply_rotary_pos_emb_npu\n\n# Patches for Qwen2.5-VL Model\nmodeling_qwen2_5_vl.Qwen2RMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen2_5_vl.Qwen2_5_VLMLP.forward = silu_forward_npu\n\n# Patches for Qwen3 Model\nmodeling_qwen3.Qwen3RMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen3.Qwen3MLP.forward = silu_forward_npu\nmodeling_qwen3.apply_rotary_pos_emb = apply_rotary_pos_emb_npu\n\n# Patches for Qwen3 MoE Model\nmodeling_qwen3_moe.Qwen3MoeRMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen3_moe.Qwen3MoeSparseMoeBlock.forward = qwen3_moe_sparse_moe_block_forward_npu\nmodeling_qwen3_moe.apply_rotary_pos_emb = apply_rotary_pos_emb_npu\n\n# Patches for Qwen3 VL Model\nmodeling_qwen3_vl.Qwen3VLTextRMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen3_vl.Qwen3VLTextMLP.forward = silu_forward_npu\n\n# Patches for Qwen3-VL MoE Model\nmodeling_qwen3_vl_moe.Qwen3VLMoeTextSparseMoeBlock = NPUQwen3VLMoeTextSparseMoeBlock\nmodeling_qwen3_vl_moe.Qwen3VLMoeTextRMSNorm.forward = rms_norm_forward_npu\nmodeling_qwen3_vl_moe.apply_rotary_pos_emb = apply_rotary_pos_emb_npu\n\n# Patches for Qwen3 Next Model\nmodeling_qwen3_next.Qwen3NextSparseMoeBlock.forward = qwen3_next_sparse_moe_block_forward_npu\nmodeling_qwen3_next.Qwen3NextRMSNormGated.forward = qwen3_next_rms_norm_forward_gated_npu\nmodeling_qwen3_next.Qwen3NextRMSNorm.forward = qwen3_next_rms_norm_forward_npu\nmodeling_qwen3_next.apply_rotary_pos_emb = qwen3_next_apply_rotary_pos_emb_npu\n"} +{"file_name": "verl__models__transformers__qwen2.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Callable, Optional\n\nimport torch\nfrom transformers.cache_utils import Cache\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward\nfrom transformers.models.llama.modeling_llama import apply_rotary_pos_emb, repeat_kv\nfrom transformers.utils import logging\n\n# Import compatibility wrapper for flash_attn_supports_top_left_mask\nfrom verl.utils.transformers_compat import flash_attn_supports_top_left_mask\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_world_size,\n validate_ulysses_config,\n)\n\nlogger = logging.get_logger(__name__)\n\n\ndef qwen2_flash_attn_forward(\n self,\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n past_key_value: Optional[Cache] = None,\n output_attentions: bool = False,\n use_cache: bool = False,\n cache_position: Optional[torch.LongTensor] = None,\n position_embeddings: Optional[tuple[torch.Tensor, torch.Tensor]] = None, # will become mandatory in v4.46\n):\n \"\"\"\n Adapted from transformers 4.47.1 to support Ulysses sequence parallelism.\n\n NOTE: This function is only tested on transformers versions between 4.45.0 and 4.47.1.\n \"\"\"\n bsz, q_len, _ = hidden_states.size()\n\n query_states = self.q_proj(hidden_states)\n key_states = self.k_proj(hidden_states)\n value_states = self.v_proj(hidden_states)\n\n query_states = query_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n key_states = key_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n value_states = value_states.view(bsz, q_len, -1, self.head_dim).transpose(1, 2)\n\n ########## AlltoAll for Ulysses ##########\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n if ulysses_sp_size > 1:\n validate_ulysses_config(self.num_heads, ulysses_sp_size)\n\n # (bsz, n_head, seq_len/n, head_dim) -> (bsz, n_head/n, seq_len, head_dim)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=2, head_dim=1)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=2, head_dim=1)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=2, head_dim=1)\n\n full_q_len = query_states.size(2) # full seq length\n\n if position_embeddings is None:\n logger.warning_once(\n \"The attention layers in this model are transitioning from computing the RoPE embeddings internally \"\n \"through `position_ids` (2D tensor with the indexes of the tokens), to using externally computed \"\n \"`position_embeddings` (Tuple of tensors, containing cos and sin). In v4.46 `position_ids` will be \"\n \"removed and `position_embeddings` will be mandatory.\"\n )\n cos, sin = self.rotary_emb(value_states, position_ids)\n else:\n cos, sin = position_embeddings\n query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)\n\n if past_key_value is not None:\n cache_kwargs = {\"sin\": sin, \"cos\": cos, \"cache_position\": cache_position} # Specific to RoPE models\n key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)\n\n # repeat k/v heads if n_kv_heads < n_heads\n key_states = repeat_kv(key_states, self.num_key_value_groups)\n value_states = repeat_kv(value_states, self.num_key_value_groups)\n dropout_rate = 0.0 if not self.training else self.attention_dropout\n\n # In PEFT, usually we cast the layer norms in float32 for training stability reasons\n # therefore the input hidden states gets silently casted in float32. Hence, we need\n # cast them back in float16 just to be sure everything works as expected.\n input_dtype = query_states.dtype\n if input_dtype == torch.float32:\n if torch.is_autocast_enabled():\n target_dtype = torch.get_autocast_gpu_dtype()\n # Handle the case where the model is quantized\n elif hasattr(self.config, \"_pre_quantization_dtype\"):\n target_dtype = self.config._pre_quantization_dtype\n else:\n target_dtype = self.q_proj.weight.dtype\n\n logger.warning_once(\n f\"The input hidden states seems to be silently casted in float32, this might be related to \"\n f\"the fact you have upcasted embedding or layer norm layers in float32. We will cast back the \"\n f\"input in {target_dtype}.\"\n )\n\n query_states = query_states.to(target_dtype)\n key_states = key_states.to(target_dtype)\n value_states = value_states.to(target_dtype)\n\n # Reashape to the expected shape for Flash Attention\n query_states = query_states.transpose(1, 2)\n key_states = key_states.transpose(1, 2)\n value_states = value_states.transpose(1, 2)\n\n if (\n self.config.use_sliding_window\n and getattr(self.config, \"sliding_window\", None) is not None\n and self.layer_idx >= self.config.max_window_layers\n ):\n sliding_window = self.config.sliding_window\n else:\n sliding_window = None\n\n attn_output = _flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n full_q_len,\n position_ids=position_ids,\n dropout=dropout_rate,\n sliding_window=sliding_window,\n is_causal=self.is_causal,\n use_top_left_mask=flash_attn_supports_top_left_mask(),\n )\n\n # use full_q_len to reshape\n attn_output = attn_output.reshape(bsz, full_q_len, -1, self.head_dim).contiguous()\n ########## AlltoAll for Ulysses ##########\n if ulysses_sp_size > 1:\n attn_output = gather_heads_scatter_seq(attn_output, seq_dim=1, head_dim=2)\n attn_output = attn_output.reshape(bsz, q_len, -1).contiguous()\n attn_output = self.o_proj(attn_output)\n\n if not output_attentions:\n attn_weights = None\n\n return attn_output, attn_weights, past_key_value\n\n\ndef qwen2_attn_forward(\n self,\n hidden_states: torch.Tensor,\n position_embeddings: tuple[torch.Tensor, torch.Tensor],\n attention_mask: Optional[torch.Tensor],\n past_key_value: Optional[Cache] = None,\n cache_position: Optional[torch.LongTensor] = None,\n **kwargs,\n) -> tuple[torch.Tensor, Optional[torch.Tensor], Optional[tuple[torch.Tensor]]]:\n \"\"\"\n Adapted from transformers 4.49.0 to support Ulysses sequence parallelism for transformers >= 4.48.0.\n\n NOTE: This function has been tested only on transformers versions between 4.48.0 and 4.50.0.\n \"\"\"\n from transformers.modeling_utils import ALL_ATTENTION_FUNCTIONS\n\n bsz, q_len, _ = hidden_states.shape\n hidden_shape = (bsz, q_len, -1, self.head_dim)\n\n query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)\n key_states = self.k_proj(hidden_states).view(hidden_shape).transpose(1, 2)\n value_states = self.v_proj(hidden_states).view(hidden_shape).transpose(1, 2)\n\n ########## AlltoAll for Ulysses ##########\n ulysses_sp_size = get_ulysses_sequence_parallel_world_size()\n\n if ulysses_sp_size > 1:\n validate_ulysses_config(self.config.num_attention_heads, ulysses_sp_size)\n\n # (bsz, n_head, seq_len/n, head_dim) -> (bsz, n_head/n, seq_len, head_dim)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=2, head_dim=1)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=2, head_dim=1)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=2, head_dim=1)\n\n full_q_len = query_states.size(2)\n\n cos, sin = position_embeddings\n query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin)\n\n if past_key_value is not None:\n # sin and cos are specific to RoPE models; cache_position needed for the static cache\n cache_kwargs = {\"sin\": sin, \"cos\": cos, \"cache_position\": cache_position}\n key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs)\n\n sliding_window = None\n if (\n self.config.use_sliding_window\n and getattr(self.config, \"sliding_window\", None) is not None\n and self.layer_idx >= self.config.max_window_layers\n ):\n sliding_window = self.config.sliding_window\n\n from transformers.models.qwen2.modeling_qwen2 import eager_attention_forward\n\n attention_interface: Callable = eager_attention_forward\n if self.config._attn_implementation != \"eager\":\n if self.config._attn_implementation == \"sdpa\" and kwargs.get(\"output_attentions\", False):\n logger.warning_once(\n \"`torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. \"\n \"Falling back to eager attention. This warning can be removed using the argument \"\n '`attn_implementation=\"eager\"` when loading the model.'\n )\n else:\n attention_interface = ALL_ATTENTION_FUNCTIONS[self.config._attn_implementation]\n\n attn_output, attn_weights = attention_interface(\n self,\n query_states,\n key_states,\n value_states,\n attention_mask,\n dropout=0.0 if not self.training else self.attention_dropout,\n scaling=self.scaling,\n sliding_window=sliding_window, # main diff with Llama\n **kwargs,\n )\n\n attn_output = attn_output.reshape(bsz, full_q_len, -1, self.head_dim).contiguous()\n ########## AlltoAll for Ulysses ##########\n if ulysses_sp_size > 1:\n # (bsz, seq_len, n_head/n, head_dim) -> (bsz, seq_len/n, n_head, head_dim)\n attn_output = gather_heads_scatter_seq(attn_output, seq_dim=1, head_dim=2)\n attn_output = attn_output.reshape(bsz, q_len, -1).contiguous()\n attn_output = self.o_proj(attn_output)\n return attn_output, attn_weights\n"} +{"file_name": "verl__models__transformers__qwen2_vl.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport inspect\nimport logging\nimport os\nfrom dataclasses import dataclass\nfrom typing import Optional\n\nimport torch\nimport torch.distributed as dist\nfrom transformers.modeling_flash_attention_utils import _flash_attention_forward, fa_peft_integration_check\nfrom transformers.models.qwen2_vl.modeling_qwen2_vl import (\n Qwen2VLAttention,\n Qwen2VLCausalLMOutputWithPast,\n Qwen2VLForConditionalGeneration,\n)\nfrom transformers.utils import is_flash_attn_2_available, is_flash_attn_greater_or_equal_2_10\n\nfrom verl.utils.device import is_npu_available\nfrom verl.utils.transformers_compat import is_transformers_version_in_range\nfrom verl.utils.ulysses import (\n gather_heads_scatter_seq,\n gather_seq_scatter_heads,\n get_ulysses_sequence_parallel_group,\n get_ulysses_sequence_parallel_world_size,\n validate_ulysses_config,\n)\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\nif is_flash_attn_2_available():\n from flash_attn import flash_attn_func, flash_attn_varlen_func\n\n _flash_supports_window_size = \"window_size\" in inspect.signature(flash_attn_func).parameters\n _flash_supports_deterministic = \"deterministic\" in inspect.signature(flash_attn_func).parameters\n _flash_use_top_left_mask = not is_flash_attn_greater_or_equal_2_10()\n\nif is_npu_available:\n from transformers.integrations.npu_flash_attention import npu_flash_attn_func as flash_attn_func\n from transformers.integrations.npu_flash_attention import npu_flash_attn_varlen_func as flash_attn_varlen_func\n from transformers.modeling_flash_attention_utils import flash_attn_supports_top_left_mask\n\n _flash_supports_window_size = \"window_size\" in inspect.signature(flash_attn_func).parameters\n _flash_supports_deterministic = \"deterministic\" in inspect.signature(flash_attn_func).parameters\n _flash_use_top_left_mask = flash_attn_supports_top_left_mask()\n\n_flash_deterministic_enabled = os.getenv(\"FLASH_ATTENTION_DETERMINISTIC\", \"0\") == \"1\"\n\n\ndef get_rope_index(\n processor,\n input_ids: torch.Tensor,\n image_grid_thw: Optional[torch.Tensor] = None,\n video_grid_thw: Optional[torch.Tensor] = None,\n second_per_grid_ts: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n) -> torch.Tensor:\n \"\"\"\n Gets the position ids for Qwen2-VL, it should be generated before sharding the sequence.\n The batch dim has been removed and the input_ids should be a 1D tensor representing a single example.\n https://github.com/huggingface/transformers/blob/v4.52.4/src/transformers/models/qwen2_5_vl/modeling_qwen2_5_vl.py#L1405\n \"\"\"\n spatial_merge_size = processor.image_processor.merge_size\n tokens_per_second = 2\n image_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|image_pad|>\")\n video_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|video_pad|>\")\n vision_start_token_id = processor.tokenizer.convert_tokens_to_ids(\"<|vision_start|>\")\n if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):\n if attention_mask is None:\n attention_mask = torch.ones_like(input_ids)\n\n position_ids = torch.ones(3, input_ids.size(0), dtype=input_ids.dtype, device=input_ids.device) # (3, seqlen)\n image_index, video_index = 0, 0\n input_ids = input_ids[attention_mask == 1]\n image_nums, video_nums = 0, 0\n vision_start_indices = torch.argwhere(input_ids == vision_start_token_id)\n vision_tokens = input_ids[vision_start_indices + 1]\n image_nums = (vision_tokens == image_token_id).sum()\n video_nums = (vision_tokens == video_token_id).sum()\n input_tokens = input_ids.tolist()\n llm_pos_ids_list: list = []\n st = 0\n remain_images, remain_videos = image_nums, video_nums\n for _ in range(image_nums + video_nums):\n if image_token_id in input_tokens and remain_images > 0:\n ed_image = input_tokens.index(image_token_id, st)\n else:\n ed_image = len(input_tokens) + 1\n if video_token_id in input_tokens and remain_videos > 0:\n ed_video = input_tokens.index(video_token_id, st)\n else:\n ed_video = len(input_tokens) + 1\n if ed_image < ed_video:\n t, h, w = (\n image_grid_thw[image_index][0],\n image_grid_thw[image_index][1],\n image_grid_thw[image_index][2],\n )\n second_per_grid_t = 0\n image_index += 1\n remain_images -= 1\n ed = ed_image\n else:\n t, h, w = (\n video_grid_thw[video_index][0],\n video_grid_thw[video_index][1],\n video_grid_thw[video_index][2],\n )\n second_per_grid_t = second_per_grid_ts[video_index] if second_per_grid_ts is not None else 1.0\n\n video_index += 1\n remain_videos -= 1\n ed = ed_video\n\n llm_grid_t, llm_grid_h, llm_grid_w = (\n t.item(),\n h.item() // spatial_merge_size,\n w.item() // spatial_merge_size,\n )\n text_len = ed - st\n\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n t_index = torch.arange(llm_grid_t).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w)\n t_index = (t_index * second_per_grid_t * tokens_per_second).long().flatten()\n h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()\n w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()\n llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + text_len + st_idx)\n st = ed + llm_grid_t * llm_grid_h * llm_grid_w\n\n if st < len(input_tokens):\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n text_len = len(input_tokens) - st\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)\n position_ids[..., attention_mask == 1] = llm_positions.to(position_ids.device)\n else:\n if attention_mask is not None:\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n position_ids = position_ids.unsqueeze(0).expand(3, -1).to(input_ids.device)\n else:\n position_ids = torch.arange(input_ids.shape[1], device=input_ids.device).view(1, -1).expand(3, -1)\n\n return position_ids\n\n\ndef prepare_fa2_from_position_ids(\n query: torch.Tensor, key: torch.Tensor, value: torch.Tensor, position_ids: torch.Tensor\n):\n assert position_ids.ndim == 2 # (batch_size, seq_length)\n query = query.contiguous().view(-1, query.size(-2), query.size(-1))\n key = key.contiguous().view(-1, key.size(-2), key.size(-1))\n value = value.contiguous().view(-1, value.size(-2), value.size(-1))\n position_ids = position_ids.view(-1)\n cu_seqlens = torch.cat(\n (\n (position_ids == 0).nonzero().view(-1).to(torch.int32),\n torch.tensor(position_ids.size(), device=position_ids.device, dtype=torch.int32),\n )\n )\n max_length = cu_seqlens.diff().max() # use cu_seqlens to infer max_length for qwen2vl mrope\n return (query, key, value, (cu_seqlens, cu_seqlens), (max_length, max_length))\n\n\ndef _custom_flash_attention_forward(\n query_states: torch.Tensor,\n key_states: torch.Tensor,\n value_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor],\n query_length: int,\n is_causal: bool = True,\n position_ids: Optional[torch.Tensor] = None,\n sliding_window: Optional[int] = None,\n use_top_left_mask: bool = False,\n deterministic: Optional[bool] = None,\n **kwargs,\n):\n \"\"\"\n Patches flash attention forward to handle 3D position ids in mrope. (3, batch_size, seq_length)\n \"\"\"\n # Assuming 4D tensors, key_states.shape[1] is the key/value sequence length (source length).\n use_sliding_windows = (\n _flash_supports_window_size and sliding_window is not None and key_states.shape[1] > sliding_window\n )\n flash_kwargs = {\"window_size\": (sliding_window, sliding_window)} if use_sliding_windows else {}\n\n if _flash_supports_deterministic:\n flash_kwargs[\"deterministic\"] = deterministic if deterministic is not None else _flash_deterministic_enabled\n\n if kwargs.get(\"softcap\") is not None:\n flash_kwargs[\"softcap\"] = kwargs.pop(\"softcap\")\n\n query_states, key_states, value_states = fa_peft_integration_check(\n query_states, key_states, value_states, target_dtype=torch.bfloat16\n )\n\n if position_ids is not None:\n assert position_ids.ndim == 2 # (batch_size, seq_length / sp_size)\n\n sp_size = get_ulysses_sequence_parallel_world_size()\n if sp_size > 1:\n # qkv: (batch_size, seq_length / sp_size, num_head, head_size)\n validate_ulysses_config(query_states.size(2), sp_size)\n query_states = gather_seq_scatter_heads(query_states, seq_dim=1, head_dim=2)\n key_states = gather_seq_scatter_heads(key_states, seq_dim=1, head_dim=2)\n value_states = gather_seq_scatter_heads(value_states, seq_dim=1, head_dim=2)\n position_ids_lst = [torch.empty_like(position_ids) for _ in range(sp_size)]\n position_ids = dist.all_gather(position_ids_lst, position_ids, group=get_ulysses_sequence_parallel_group())\n position_ids = torch.cat(position_ids_lst, dim=-1) # (batch_size, seq_length)\n\n if position_ids is not None and query_length != 1 and not (torch.diff(position_ids, dim=-1) >= 0).all():\n batch_size = query_states.size(0)\n q, k, v, (cu_seqlens_q, cu_seqlens_k), (max_seqlen_q, max_seqlen_k) = prepare_fa2_from_position_ids(\n query_states, key_states, value_states, position_ids\n )\n attn_output = flash_attn_varlen_func(\n q=q,\n k=k,\n v=v,\n cu_seqlens_q=cu_seqlens_q,\n cu_seqlens_k=cu_seqlens_k,\n max_seqlen_q=max_seqlen_q,\n max_seqlen_k=max_seqlen_k,\n dropout_p=kwargs.pop(\"dropout\", 0.0),\n softmax_scale=kwargs.pop(\"softmax_scale\", None),\n causal=is_causal,\n **flash_kwargs,\n )\n attn_output = attn_output.view(batch_size, -1, attn_output.size(-2), attn_output.size(-1))\n else:\n attn_output = _flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n query_length,\n is_causal=is_causal,\n sliding_window=sliding_window,\n use_top_left_mask=use_top_left_mask,\n deterministic=deterministic,\n **kwargs,\n ) # do not pass position_ids to old flash_attention_forward\n\n if sp_size > 1:\n # (batch_size, seq_length, num_head, head_size)\n attn_output = gather_heads_scatter_seq(attn_output, head_dim=2, seq_dim=1)\n\n return attn_output\n\n\ndef qwen2_vl_attn_forward(\n self: \"Qwen2VLAttention\",\n hidden_states: torch.Tensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n position_embeddings: Optional[tuple[torch.Tensor, torch.Tensor]] = None, # will become mandatory in v4.46\n **kwargs,\n) -> tuple[torch.Tensor, None, None]:\n from transformers.models.qwen2_vl.modeling_qwen2_vl import apply_multimodal_rotary_pos_emb, repeat_kv\n\n bsz, q_len, _ = hidden_states.size() # q_len = seq_length / sp_size\n query_states = self.q_proj(hidden_states) # (batch_size, seq_length / sp_size, num_heads * head_size)\n key_states = self.k_proj(hidden_states)\n value_states = self.v_proj(hidden_states)\n\n query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2)\n key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2)\n\n # Because the input can be padded, the absolute sequence length depends on the max position id.\n cos, sin = position_embeddings\n query_states, key_states = apply_multimodal_rotary_pos_emb(\n query_states, key_states, cos, sin, self.rope_scaling[\"mrope_section\"]\n )\n key_states = repeat_kv(key_states, self.num_key_value_groups)\n value_states = repeat_kv(value_states, self.num_key_value_groups)\n dropout_rate = 0.0 if not self.training else self.attention_dropout\n\n sliding_window = None\n if (\n self.config.use_sliding_window\n and getattr(self.config, \"sliding_window\", None) is not None\n and self.layer_idx >= self.config.max_window_layers\n ):\n sliding_window = self.config.sliding_window\n\n # This is before the transpose\n q_len = query_states.shape[2]\n\n # FA2 uses non-transposed inputs\n query_states = query_states.transpose(1, 2)\n key_states = key_states.transpose(1, 2)\n value_states = value_states.transpose(1, 2)\n\n if position_ids.ndim == 3:\n position_ids = position_ids[0]\n\n attn_output = _custom_flash_attention_forward(\n query_states,\n key_states,\n value_states,\n attention_mask,\n query_length=q_len,\n is_causal=getattr(self, \"is_causal\", True),\n dropout=dropout_rate,\n sliding_window=sliding_window,\n use_top_left_mask=_flash_use_top_left_mask,\n position_ids=position_ids, # important: pass position ids\n ) # (batch_size, seq_length / sp_size, num_head, head_size)\n attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous()\n attn_output = self.o_proj(attn_output)\n if is_transformers_version_in_range(min_version=\"4.54.0\"):\n return attn_output, None\n else:\n return attn_output, None, None\n\n\ndef _get_input_embeds(\n model: \"Qwen2VLForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n):\n inputs_embeds = model.get_input_embeddings()(input_ids)\n if pixel_values is not None:\n pixel_values = pixel_values.type(model.visual.dtype)\n image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n n_image_tokens = (input_ids == model.config.image_token_id).sum().item()\n n_image_features = image_embeds.shape[0]\n if n_image_tokens != n_image_features:\n raise ValueError(\n f\"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}\"\n )\n\n mask = input_ids == model.config.image_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n image_mask = mask_expanded.to(inputs_embeds.device)\n\n image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)\n\n if pixel_values_videos is not None:\n pixel_values_videos = pixel_values_videos.type(model.visual.dtype)\n video_embeds = model.visual(pixel_values_videos, grid_thw=video_grid_thw)\n n_video_tokens = (input_ids == model.config.video_token_id).sum().item()\n n_video_features = video_embeds.shape[0]\n if n_video_tokens != n_video_features:\n raise ValueError(\n f\"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}\"\n )\n\n mask = input_ids == model.config.video_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n video_mask = mask_expanded.to(inputs_embeds.device)\n\n video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)\n\n if pixel_values is None and pixel_values_videos is None: # handle mixed text-image data\n config = model.config.vision_config\n patch_dim = config.in_channels * config.temporal_patch_size * config.patch_size**2\n pixel_values = torch.zeros((16, patch_dim), dtype=inputs_embeds.dtype, device=inputs_embeds.device)\n image_grid_thw = torch.tensor([[1, 4, 4]], dtype=torch.long, device=inputs_embeds.device)\n image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n inputs_embeds += 0.0 * image_embeds.mean()\n\n if attention_mask is not None:\n attention_mask = attention_mask.to(inputs_embeds.device)\n\n return inputs_embeds, attention_mask\n\n\ndef process_position_ids(position_ids: torch.Tensor) -> torch.Tensor:\n if position_ids.ndim != 3 or position_ids.size(0) != 4:\n # we concat the text position ids with the 3D vision position ids by default\n # see https://github.com/huggingface/transformers/pull/39447\n raise ValueError(\"position_ids should be a 3D tensor of shape (4, batch_size, seq_length).\")\n\n if is_transformers_version_in_range(max_version=\"4.53.3\"):\n # transformers < 4.54.0 only accepts vision position ids, so we discard the text position ids here\n position_ids = position_ids[1:]\n\n return position_ids\n\n\n@dataclass\nclass Qwen2VLCausalLMOutputForPPO(Qwen2VLCausalLMOutputWithPast):\n log_probs: Optional[torch.FloatTensor] = None\n entropy: Optional[torch.FloatTensor] = None\n\n\ndef qwen2_vl_base_forward(\n self: \"Qwen2VLForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n labels: Optional[torch.LongTensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n **kwargs,\n):\n kwargs[\"inputs_embeds\"], kwargs[\"attention_mask\"] = _get_input_embeds(\n self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw\n ) # avoid lora module having multiple keyword arguments\n return self.language_model(input_ids=None, **kwargs)\n\n\ndef qwen2_vl_forward(\n self: \"Qwen2VLForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n **kwargs,\n):\n if is_transformers_version_in_range(min_version=\"4.52.0\"):\n return self.model(\n input_ids=input_ids,\n attention_mask=attention_mask,\n position_ids=process_position_ids(position_ids),\n pixel_values=pixel_values,\n pixel_values_videos=pixel_values_videos,\n image_grid_thw=image_grid_thw,\n video_grid_thw=video_grid_thw,\n **kwargs,\n )\n else:\n inputs_embeds, attention_mask = _get_input_embeds(\n self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw\n )\n return self.model(\n input_ids=None,\n attention_mask=attention_mask,\n position_ids=process_position_ids(position_ids),\n inputs_embeds=inputs_embeds,\n **kwargs,\n )\n\n\ndef forward_with_normal_backend(\n self: Qwen2VLForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> \"Qwen2VLCausalLMOutputWithPast\":\n outputs = qwen2_vl_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n logits = self.lm_head(hidden_states)\n\n return Qwen2VLCausalLMOutputWithPast(\n logits=logits,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_torch_backend(\n self: Qwen2VLForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> tuple | Qwen2VLCausalLMOutputForPPO:\n from verl.utils.experimental.torch_functional import FusedLinearForPPO\n\n outputs = qwen2_vl_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_torch_backend, either labels or input_ids must be provided.\")\n\n fused_linear_for_ppo = FusedLinearForPPO()\n log_probs, entropy = fused_linear_for_ppo.forward(\n hidden_states=hidden_states,\n vocab_weights=self.lm_head.weight,\n input_ids=rolled_labels,\n temperature=temperature,\n )\n return Qwen2VLCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_triton_backend(\n self: Qwen2VLForConditionalGeneration,\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> tuple | Qwen2VLCausalLMOutputForPPO:\n from verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\n\n outputs = qwen2_vl_forward(self, input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_triton_backend, either labels or input_ids must be provided.\")\n\n log_probs, entropy = linear_cross_entropy(\n hidden_states,\n self.lm_head.weight,\n rolled_labels,\n temperature,\n \"none\",\n )\n return Qwen2VLCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n"} +{"file_name": "verl__models__transformers__qwen3_vl.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport functools\nimport logging\nimport os\nfrom dataclasses import dataclass\nfrom typing import Optional\n\nimport torch\nfrom transformers.models.qwen3_vl.modeling_qwen3_vl import (\n Qwen3VLCausalLMOutputWithPast,\n Qwen3VLForConditionalGeneration,\n)\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef get_rope_index(\n processor,\n input_ids: torch.Tensor,\n image_grid_thw: Optional[torch.Tensor] = None,\n video_grid_thw: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n **kwargs,\n) -> torch.Tensor:\n \"\"\"\n Gets the position ids for Qwen3-VL, it should be generated before sharding the sequence.\n The batch dim has been removed and the input_ids should be a 1D tensor representing a single example.\n https://github.com/huggingface/transformers/blob/v4.57.0/src/transformers/models/qwen3_vl/modeling_qwen3_vl.py#L916\n \"\"\"\n spatial_merge_size = processor.image_processor.merge_size\n image_token_id = processor.image_token_id\n video_token_id = processor.video_token_id\n vision_start_token_id = processor.vision_start_token_id\n\n # Since we use timestamps to separate videos,\n # like ,\n # the video_grid_thw should also be split\n if video_grid_thw is not None:\n video_grid_thw = torch.repeat_interleave(video_grid_thw, video_grid_thw[:, 0], dim=0)\n video_grid_thw[:, 0] = 1\n\n if input_ids is not None and (image_grid_thw is not None or video_grid_thw is not None):\n if attention_mask is None:\n attention_mask = torch.ones_like(input_ids)\n\n position_ids = torch.ones(3, input_ids.shape[0], dtype=input_ids.dtype, device=input_ids.device)\n image_index, video_index = 0, 0\n attention_mask = attention_mask.to(input_ids.device)\n input_ids = input_ids[attention_mask == 1]\n image_nums, video_nums = 0, 0\n vision_start_indices = torch.argwhere(input_ids == vision_start_token_id)\n vision_tokens = input_ids[vision_start_indices + 1]\n image_nums = (vision_tokens == image_token_id).sum()\n video_nums = (vision_tokens == video_token_id).sum()\n input_tokens = input_ids.tolist()\n llm_pos_ids_list: list = []\n st = 0\n remain_images, remain_videos = image_nums, video_nums\n for _ in range(image_nums + video_nums):\n if image_token_id in input_tokens and remain_images > 0:\n ed_image = input_tokens.index(image_token_id, st)\n else:\n ed_image = len(input_tokens) + 1\n if video_token_id in input_tokens and remain_videos > 0:\n ed_video = input_tokens.index(video_token_id, st)\n else:\n ed_video = len(input_tokens) + 1\n if ed_image < ed_video:\n t, h, w = (\n image_grid_thw[image_index][0],\n image_grid_thw[image_index][1],\n image_grid_thw[image_index][2],\n )\n image_index += 1\n remain_images -= 1\n ed = ed_image\n else:\n t, h, w = (\n video_grid_thw[video_index][0],\n video_grid_thw[video_index][1],\n video_grid_thw[video_index][2],\n )\n video_index += 1\n remain_videos -= 1\n ed = ed_video\n\n llm_grid_t, llm_grid_h, llm_grid_w = (\n t.item(),\n h.item() // spatial_merge_size,\n w.item() // spatial_merge_size,\n )\n text_len = ed - st\n\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n # t_index is always 0 because llm_grid_t is always 1\n # (we use timestamps to encode the temporal information for videos)\n t_index = torch.arange(llm_grid_t).view(-1, 1).expand(-1, llm_grid_h * llm_grid_w).flatten()\n h_index = torch.arange(llm_grid_h).view(1, -1, 1).expand(llm_grid_t, -1, llm_grid_w).flatten()\n w_index = torch.arange(llm_grid_w).view(1, 1, -1).expand(llm_grid_t, llm_grid_h, -1).flatten()\n llm_pos_ids_list.append(torch.stack([t_index, h_index, w_index]) + text_len + st_idx)\n st = ed + llm_grid_t * llm_grid_h * llm_grid_w\n\n if st < len(input_tokens):\n st_idx = llm_pos_ids_list[-1].max() + 1 if len(llm_pos_ids_list) > 0 else 0\n text_len = len(input_tokens) - st\n llm_pos_ids_list.append(torch.arange(text_len).view(1, -1).expand(3, -1) + st_idx)\n\n llm_positions = torch.cat(llm_pos_ids_list, dim=1).reshape(3, -1)\n position_ids[..., attention_mask == 1] = llm_positions.to(position_ids.device)\n else:\n if attention_mask is not None:\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n position_ids = position_ids.unsqueeze(0).expand(3, -1).to(attention_mask.device)\n else:\n position_ids = torch.arange(input_ids.shape[1], device=input_ids.device).view(1, -1).expand(3, -1)\n\n return position_ids\n\n\ndef _get_input_embeds(\n model: \"Qwen3VLForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n):\n inputs_embeds = model.get_input_embeddings()(input_ids)\n image_mask, video_mask = None, None\n if pixel_values is not None:\n pixel_values = pixel_values.type(model.visual.dtype)\n image_embeds, deepstack_image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n n_image_tokens = (input_ids == model.config.image_token_id).sum().item()\n n_image_features = image_embeds.shape[0]\n if n_image_tokens != n_image_features:\n raise ValueError(\n f\"Image features and image tokens do not match: tokens: {n_image_tokens}, features {n_image_features}\"\n )\n\n mask = input_ids == model.config.image_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n image_mask = mask_expanded.to(inputs_embeds.device)\n\n image_embeds = image_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(image_mask, image_embeds)\n\n if pixel_values_videos is not None:\n pixel_values_videos = pixel_values_videos.type(model.visual.dtype)\n video_embeds, deepstack_video_embeds = model.visual(pixel_values_videos, grid_thw=video_grid_thw)\n n_video_tokens = (input_ids == model.config.video_token_id).sum().item()\n n_video_features = video_embeds.shape[0]\n if n_video_tokens != n_video_features:\n raise ValueError(\n f\"Video features and video tokens do not match: tokens: {n_video_tokens}, features {n_video_features}\"\n )\n\n mask = input_ids == model.config.video_token_id\n mask_unsqueezed = mask.unsqueeze(-1)\n mask_expanded = mask_unsqueezed.expand_as(inputs_embeds)\n video_mask = mask_expanded.to(inputs_embeds.device)\n\n video_embeds = video_embeds.to(inputs_embeds.device, inputs_embeds.dtype)\n inputs_embeds = inputs_embeds.masked_scatter(video_mask, video_embeds)\n\n visual_pos_masks = None\n deepstack_visual_embeds = None\n if image_mask is not None and video_mask is not None:\n # aggregate visual_pos_masks and deepstack_visual_embeds\n image_mask = image_mask[..., 0]\n video_mask = video_mask[..., 0]\n visual_pos_masks = image_mask | video_mask\n deepstack_visual_embeds = []\n image_mask_joint = image_mask[visual_pos_masks]\n video_mask_joint = video_mask[visual_pos_masks]\n for img_embed, vid_embed in zip(deepstack_image_embeds, deepstack_video_embeds, strict=False):\n embed_joint = img_embed.new_zeros(visual_pos_masks.sum(), img_embed.shape[-1]).to(img_embed.device)\n embed_joint[image_mask_joint, :] = img_embed\n embed_joint[video_mask_joint, :] = vid_embed\n deepstack_visual_embeds.append(embed_joint)\n elif image_mask is not None:\n image_mask = image_mask[..., 0]\n visual_pos_masks = image_mask\n deepstack_visual_embeds = deepstack_image_embeds\n elif video_mask is not None:\n video_mask = video_mask[..., 0]\n visual_pos_masks = video_mask\n deepstack_visual_embeds = deepstack_video_embeds\n\n if pixel_values is None and pixel_values_videos is None:\n config = model.config.vision_config\n patch_dim = config.in_channels * config.temporal_patch_size * config.patch_size**2\n pixel_values = torch.zeros((16, patch_dim), dtype=inputs_embeds.dtype, device=inputs_embeds.device)\n image_grid_thw = torch.tensor([[1, 4, 4]], dtype=torch.long, device=inputs_embeds.device)\n image_embeds, dummy_deepstack_image_embeds = model.visual(pixel_values, grid_thw=image_grid_thw)\n inputs_embeds += 0.0 * image_embeds.mean()\n for emb in dummy_deepstack_image_embeds or []:\n inputs_embeds += 0.0 * emb.mean()\n\n if attention_mask is not None:\n attention_mask = attention_mask.to(inputs_embeds.device)\n\n return {\n \"inputs_embeds\": inputs_embeds,\n \"attention_mask\": attention_mask,\n \"visual_pos_masks\": visual_pos_masks,\n \"deepstack_visual_embeds\": deepstack_visual_embeds,\n }\n\n\n@dataclass\nclass Qwen3VLCausalLMOutputForPPO(Qwen3VLCausalLMOutputWithPast):\n log_probs: Optional[torch.FloatTensor] = None\n entropy: Optional[torch.FloatTensor] = None\n\n\ndef qwen3_vl_base_forward(\n self: \"Qwen3VLForConditionalGeneration\",\n input_ids: torch.LongTensor,\n attention_mask: Optional[torch.Tensor] = None,\n pixel_values: Optional[torch.FloatTensor] = None,\n pixel_values_videos: Optional[torch.FloatTensor] = None,\n image_grid_thw: Optional[torch.LongTensor] = None,\n video_grid_thw: Optional[torch.LongTensor] = None,\n **kwargs,\n):\n input_kwargs = _get_input_embeds(\n self, input_ids, attention_mask, pixel_values, pixel_values_videos, image_grid_thw, video_grid_thw\n ) # avoid lora module having multiple keyword arguments\n kwargs.update(input_kwargs)\n return self.language_model(\n input_ids=None,\n **kwargs,\n )\n\n\ndef forward_with_normal_backend(\n self: \"Qwen3VLForConditionalGeneration\",\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> \"Qwen3VLCausalLMOutputForPPO\":\n outputs = self.model(input_ids, **kwargs)\n hidden_states = outputs[0]\n logits = self.lm_head(hidden_states)\n\n return Qwen3VLCausalLMOutputForPPO(\n logits=logits,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_torch_backend(\n self: \"Qwen3VLForConditionalGeneration\",\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> \"Qwen3VLCausalLMOutputForPPO\":\n from verl.utils.experimental.torch_functional import FusedLinearForPPO\n\n outputs = self.model(input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_torch_backend, either labels or input_ids must be provided.\")\n\n fused_linear_for_ppo = FusedLinearForPPO()\n log_probs, entropy = fused_linear_for_ppo.forward(\n hidden_states=hidden_states,\n vocab_weights=self.lm_head.weight,\n input_ids=rolled_labels,\n temperature=temperature,\n )\n return Qwen3VLCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef forward_with_triton_backend(\n self: \"Qwen3VLForConditionalGeneration\",\n input_ids: torch.LongTensor = None,\n labels: Optional[torch.LongTensor] = None,\n temperature: float = 1.0,\n **kwargs,\n) -> \"Qwen3VLCausalLMOutputForPPO\":\n from verl.utils.kernel.linear_cross_entropy import linear_cross_entropy\n\n outputs = self.model(input_ids, **kwargs)\n hidden_states = outputs[0]\n\n # Loss calculations\n if labels is not None:\n rolled_labels = torch.roll(labels, shifts=-1, dims=-1)\n elif input_ids is not None:\n rolled_labels = torch.roll(input_ids, shifts=-1, dims=-1)\n else:\n raise RuntimeError(\"To use forward_with_triton_backend, either labels or input_ids must be provided.\")\n\n log_probs, entropy = linear_cross_entropy(\n hidden_states,\n self.lm_head.weight,\n rolled_labels,\n temperature,\n \"none\",\n )\n return Qwen3VLCausalLMOutputForPPO(\n log_probs=log_probs,\n entropy=entropy,\n hidden_states=outputs.hidden_states,\n )\n\n\ndef patch_qwen3_vl_moe_sparse_moe_block_forward():\n \"\"\"\n Monkey patch to fix a bug in transformers 4.57.3 where Qwen3VLMoeTextSparseMoeBlock.forward\n incorrectly uses torch.zeros_like(hidden_states) instead of torch.zeros_like(router_logits)\n when creating router_weights (line 148 in modeling_qwen3_vl_moe.py).\n\n This is a minimal fix that only changes the problematic line while keeping the rest of the\n original implementation intact.\n \"\"\"\n try:\n from transformers.models.qwen3_vl_moe.modeling_qwen3_vl_moe import Qwen3VLMoeTextSparseMoeBlock\n except ImportError:\n # Model not available, skip patching\n return\n\n # Store the original forward method for reference\n original_forward = Qwen3VLMoeTextSparseMoeBlock.forward\n\n @functools.wraps(original_forward)\n def patched_forward(self, hidden_states: torch.Tensor) -> torch.Tensor:\n batch_size = hidden_states.shape[0]\n hidden_states = hidden_states.reshape(-1, self.hidden_size)\n router_logits = self.gate(hidden_states)\n routing_weights = torch.nn.functional.softmax(router_logits, dim=-1, dtype=torch.float)\n routing_weights, router_indices = torch.topk(routing_weights, self.top_k, dim=-1)\n routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True)\n # BUG FIX: Original code incorrectly uses hidden_states here, should use router_logits\n routing_weights = routing_weights.to(router_logits.dtype)\n router_weights = torch.zeros_like(router_logits).scatter_(1, router_indices, routing_weights)\n hidden_states = hidden_states.reshape(batch_size, -1, self.hidden_size)\n routed_out = self.experts(hidden_states, router_weights, router_indices)\n return routed_out\n\n # Apply the patch\n Qwen3VLMoeTextSparseMoeBlock.forward = patched_forward\n logger.info(\"Monkey patched Qwen3VLMoeTextSparseMoeBlock.forward to fix router_weights bug\")\n"} +{"file_name": "verl__models__transformers__tiled_mlp.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nFSDP2-compatible TiledMLP implementation for memory-efficient MLP computation.\n\nThis module provides a tiled MLP implementation that reduces peak memory usage\nby processing the MLP forward/backward pass in chunks (tiles). This is particularly\nuseful for large models with FSDP2 training.\n\"\"\"\n\nimport threading\nfrom typing import Optional\n\nimport torch\nimport torch.nn as nn\n\n\nclass GradientAccumulator:\n \"\"\"Gradient accumulator for TiledMLP (FSDP compatible).\n\n This class manages gradient accumulation across multiple shards during\n the backward pass of TiledMLP. It ensures correct gradient computation\n when processing input in chunks.\n \"\"\"\n\n def __init__(self, params: list[torch.nn.Parameter], total_shards: int, dtype: torch.dtype = None):\n self.params = params\n self.total_shards = total_shards\n self.grad_accumulation_dtype = dtype or torch.float32\n self.accumulated_grads = {}\n self.hooks = []\n self.lock = threading.Lock()\n\n for param in self.params:\n if param.grad is not None:\n self.accumulated_grads[param] = param.grad.to(self.grad_accumulation_dtype)\n param.grad = None\n else:\n self.accumulated_grads[param] = torch.zeros_like(param, dtype=self.grad_accumulation_dtype)\n\n def install_hooks(self, is_last_shard: bool):\n \"\"\"Install gradient hooks for the current shard.\"\"\"\n self._remove_hooks()\n\n def create_hook(param):\n def hook(grad):\n with self.lock:\n grad_to_accum_dtype = grad.to(self.grad_accumulation_dtype)\n self.accumulated_grads[param] += grad_to_accum_dtype\n\n if is_last_shard:\n param.grad = None # Critical: prevent double accumulation\n final_grad = self.accumulated_grads[param].to(param.dtype)\n return final_grad\n return None\n\n return hook\n\n for param in self.params:\n if param.requires_grad:\n hook = param.register_hook(create_hook(param))\n self.hooks.append(hook)\n\n def _remove_hooks(self):\n \"\"\"Remove all registered hooks.\"\"\"\n for hook in self.hooks:\n hook.remove()\n self.hooks.clear()\n\n def cleanup(self):\n \"\"\"Cleanup hooks and resources.\"\"\"\n self._remove_hooks()\n\n\nclass TiledMLP(torch.autograd.Function):\n \"\"\"TiledMLP implementation for memory-efficient MLP computation.\n\n This autograd function processes MLP forward/backward in tiles (chunks)\n to reduce peak memory usage. Compatible with FSDP2.\n \"\"\"\n\n @staticmethod\n def forward(ctx, fn, module, x, shards, compute_params):\n ctx.fn = fn\n ctx.module = module\n ctx.shards = shards\n ctx.compute_params = [p for p in compute_params if p.requires_grad]\n ctx.save_for_backward(x)\n\n # Split on dim=-2 (seqlen dimension) following Liger Kernel style\n x_shards = list(torch.chunk(x, chunks=shards, dim=-2))\n with torch.no_grad():\n output_shards = [fn(module, x_shard) for x_shard in x_shards]\n output_unsharded = torch.cat(output_shards, dim=-2)\n return output_unsharded\n\n @staticmethod\n def backward(ctx, *grads):\n fn = ctx.fn\n (x,) = ctx.saved_tensors\n module = ctx.module\n shards = ctx.shards\n compute_params = ctx.compute_params\n\n x_requires_grad = x.requires_grad\n x = x.detach()\n x.requires_grad_(x_requires_grad)\n\n # Flatten to [bs*seqlen, hidden_size]\n hidden_size = x.shape[-1]\n x_shape_orig = x.shape\n x = x.view(-1, hidden_size)\n incoming_grad = grads[0].view(-1, hidden_size)\n\n # Pre-allocate input gradient\n x_grad = torch.zeros_like(x)\n\n # Split on dim=0\n x_shards = list(torch.chunk(x, chunks=shards, dim=0))\n\n grad_accumulator = GradientAccumulator(compute_params, shards, dtype=x.dtype)\n\n for i, x_shard in enumerate(x_shards):\n x_shard.requires_grad_(x_requires_grad)\n\n shard_step = x_shards[i].shape[0]\n shard_offset = i * x_shards[0].shape[0]\n\n # narrow(0, ...) creates a contiguous view that can receive gradients\n x_shard.grad = x_grad.narrow(0, shard_offset, shard_step)\n incoming_grad_shard = incoming_grad.narrow(0, shard_offset, shard_step)\n\n is_last_shard = i + 1 == shards\n grad_accumulator.install_hooks(is_last_shard)\n\n with torch.enable_grad():\n output = fn(module, x_shard)\n torch.autograd.backward(output, incoming_grad_shard)\n\n grad_accumulator.cleanup()\n del grad_accumulator\n\n # Restore original shape\n x_grad = x_grad.view(x_shape_orig) if x_requires_grad else None\n return (None, None, x_grad, None, None)\n\n\ndef _mlp_forward_fn(module, x):\n \"\"\"Forward function for LlamaMLP / Qwen2MLP / Qwen3MLP style.\"\"\"\n return module.down_proj(module.act_fn(module.gate_proj(x)) * module.up_proj(x))\n\n\n# ============================================================================\n# Monkey Patch Functions\n# ============================================================================\n\n# Model type to MLP class mapping\n_MODEL_TYPE_TO_MLP_CLASS = {\n \"llama\": (\"transformers.models.llama.modeling_llama\", \"LlamaMLP\"),\n \"qwen2\": (\"transformers.models.qwen2.modeling_qwen2\", \"Qwen2MLP\"),\n \"qwen2_5\": (\"transformers.models.qwen2.modeling_qwen2\", \"Qwen2MLP\"), # Qwen2.5 uses Qwen2 MLP\n \"qwen3\": (\"transformers.models.qwen3.modeling_qwen3\", \"Qwen3MLP\"),\n}\n\n\ndef apply_tiled_mlp_monkey_patch(\n num_shards: int = 4,\n model_type: Optional[str] = None,\n):\n \"\"\"Apply TiledMLP monkey patch based on model_type.\n\n This function MUST be called BEFORE model instantiation to take effect.\n It patches the MLP classes in transformers library to use TiledMLP for\n memory-efficient computation during training.\n\n Args:\n num_shards: Number of shards to split the input into. Higher values\n reduce peak memory but may slightly impact performance.\n model_type: The model type string (e.g., \"llama\", \"qwen2\", \"qwen3\").\n If None, patches all supported model types.\n\n Returns:\n List of patched class names.\n \"\"\"\n if model_type is None:\n types_to_patch = list(_MODEL_TYPE_TO_MLP_CLASS.keys())\n elif model_type in _MODEL_TYPE_TO_MLP_CLASS:\n types_to_patch = [model_type]\n else:\n raise ValueError(\n f\"TiledMLP does not support model_type='{model_type}'. \"\n f\"Supported types: {list(_MODEL_TYPE_TO_MLP_CLASS.keys())}. \"\n f\"For SwiGLU-style MLPs, you can add support by extending _MODEL_TYPE_TO_MLP_CLASS \"\n f\"in verl/models/transformers/tiled_mlp.py\"\n )\n\n patched_classes = []\n\n for mtype in types_to_patch:\n module_path, class_name = _MODEL_TYPE_TO_MLP_CLASS[mtype]\n try:\n import importlib\n\n module = importlib.import_module(module_path)\n mlp_class = getattr(module, class_name)\n _patch_mlp_class(mlp_class, _mlp_forward_fn, num_shards)\n if class_name not in patched_classes:\n patched_classes.append(class_name)\n except (ImportError, AttributeError) as e:\n print(f\"Warning: Could not patch {mtype} MLP: {e}\")\n\n if patched_classes:\n print(f\"TiledMLP monkey patch applied to: {', '.join(patched_classes)} (shards={num_shards})\")\n\n return patched_classes\n\n\ndef _patch_mlp_class(mlp_class: type[nn.Module], forward_fn, num_shards: int):\n \"\"\"Patch a single MLP class to use TiledMLP.\"\"\"\n\n def tiled_forward(self, x):\n compute_params = [p for p in self.parameters() if p.requires_grad]\n return TiledMLP.apply(forward_fn, self, x, num_shards, compute_params)\n\n mlp_class.forward = tiled_forward\n"} +{"file_name": "verl__single_controller__base__decorator.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport inspect\nfrom functools import partial, wraps\nfrom types import FunctionType\n\nfrom tensordict import TensorDict\n\nfrom verl.protocol import DataProtoFuture, _padding_size_key\nfrom verl.utils.py_functional import DynamicEnum\nfrom verl.utils.tensordict_utils import chunk_tensordict, concat_tensordict, contiguous\nfrom verl.utils.transferqueue_utils import BatchMeta\n\n# here we add a magic number of avoid user-defined function already have this attribute\nMAGIC_ATTR = \"attrs_3141562937\"\n\n\nclass Dispatch(DynamicEnum):\n \"\"\"Enum class defining different dispatch modes for distributed computation.\n\n Each mode represents a specific strategy for distributing data across\n different ranks in a distributed system. The modes are used to control\n how data is partitioned and processed across different worker groups.\n \"\"\"\n\n _registry = {}\n _next_value = 0\n\n\ndef init_predefined_dispatch_mode():\n Dispatch.register(\"RANK_ZERO\")\n Dispatch.register(\"ONE_TO_ALL\")\n Dispatch.register(\"ALL_TO_ALL\")\n Dispatch.register(\"DP_COMPUTE\")\n Dispatch.register(\"DP_COMPUTE_PROTO\")\n Dispatch.register(\"DP_COMPUTE_PROTO_WITH_FUNC\")\n Dispatch.register(\"DP_COMPUTE_METRIC\")\n # This is a special dispatch mode for vllm ExternalRayDistributedExecutor\n Dispatch.register(\"DIRECT_ROLLOUT_METHOD\")\n\n\nclass Execute(DynamicEnum):\n \"\"\"Enum class defining different execution modes for distributed computation.\n\n These modes control how a function should be executed across different ranks\n in a distributed system.\n \"\"\"\n\n _registry = {}\n _next_value = 0\n\n\ndef init_predefined_execute_mode():\n Execute.register(\"ALL\")\n Execute.register(\"RANK_ZERO\")\n\n\n# Initialize the two Dynamic Enum Classes\ninit_predefined_dispatch_mode()\ninit_predefined_execute_mode()\n\n\ndef _consolidate_tuple_td(chunked_arg):\n return tuple(contiguous(val).consolidate() for val in chunked_arg)\n\n\ndef _split_args_kwargs_data_proto(chunks, *args, **kwargs):\n from verl.protocol import DataProto, DataProtoFuture\n\n splitted_args = []\n for arg in args:\n assert isinstance(arg, DataProto | DataProtoFuture | BatchMeta | TensorDict)\n if isinstance(arg, TensorDict):\n chunked_arg = chunk_tensordict(arg, chunks)\n chunked_arg = _consolidate_tuple_td(chunked_arg)\n else:\n chunked_arg = arg.chunk(chunks=chunks)\n assert len(chunked_arg) == chunks\n splitted_args.append(chunked_arg)\n\n splitted_kwargs = {}\n for key, val in kwargs.items():\n assert isinstance(val, DataProto | DataProtoFuture | BatchMeta | TensorDict)\n if isinstance(val, TensorDict):\n chunked_kwarg = chunk_tensordict(val, chunks)\n chunked_kwarg = _consolidate_tuple_td(chunked_kwarg)\n else:\n chunked_kwarg = val.chunk(chunks=chunks)\n assert len(chunked_kwarg) == chunks\n splitted_kwargs[key] = chunked_kwarg\n\n return splitted_args, splitted_kwargs\n\n\ndef _split_args_kwargs_data_proto_with_auto_padding(chunks, *args, **kwargs):\n from verl.protocol import DataProto, DataProtoFuture\n\n data_proto_len = None\n padding_size = None\n\n def _padding_and_split_data(obj, chunks):\n nonlocal data_proto_len, padding_size\n assert isinstance(obj, DataProto | DataProtoFuture)\n if isinstance(obj, DataProto) and obj.is_padding_enabled():\n # for padding, we only support DataProto with same length\n if data_proto_len is None:\n data_proto_len = len(obj)\n padding_size = (chunks - (data_proto_len % chunks)) if (data_proto_len % chunks > 0) else 0\n else:\n assert data_proto_len == len(obj), (\n f\"expecting all arg share same length of {data_proto_len}, but got {len(obj)}\"\n )\n obj.padding(padding_size=padding_size)\n return obj.chunk(chunks=chunks)\n\n splitted_args = [_padding_and_split_data(arg, chunks) for arg in args]\n splitted_kwargs = {key: _padding_and_split_data(val, chunks) for key, val in kwargs.items()}\n if padding_size is not None:\n splitted_kwargs[_padding_size_key] = padding_size\n\n return splitted_args, splitted_kwargs\n\n\ndef dispatch_one_to_all(worker_group, *args, **kwargs):\n args = tuple([arg] * worker_group.world_size for arg in args)\n kwargs = {k: [v] * worker_group.world_size for k, v in kwargs.items()}\n return args, kwargs\n\n\ndef dummy_direct_rollout_call(worker_group, *args, **kwargs):\n raise NotImplementedError(\"Direct rollout call is forbidden.\")\n\n\ndef dispatch_all_to_all(worker_group, *args, **kwargs):\n return args, kwargs\n\n\ndef collect_all_to_all(worker_group, output):\n return output\n\n\ndef _concat_data_proto_or_future(output: list):\n import ray\n\n from verl.protocol import DataProto, DataProtoFuture\n\n # make sure all the elements in output has the same type\n for o in output:\n assert type(o) is type(output[0])\n\n o = output[0]\n\n if isinstance(o, DataProto):\n return DataProto.concat(output)\n elif isinstance(o, ray.ObjectRef):\n return DataProtoFuture.concat(output)\n elif isinstance(o, BatchMeta):\n return BatchMeta.concat(output)\n elif isinstance(o, TensorDict):\n return concat_tensordict(output)\n else:\n raise NotImplementedError\n\n\ndef dispatch_dp_compute(worker_group, *args, **kwargs):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n for arg in args:\n assert isinstance(arg, tuple | list) and len(arg) == worker_group.world_size\n for k, v in kwargs.items():\n assert isinstance(v, tuple | list) and len(v) == worker_group.world_size\n return args, kwargs\n\n\ndef collect_dp_compute(worker_group, output):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n assert len(output) == worker_group.world_size\n return output\n\n\ndef dispatch_dp_compute_data_proto(worker_group, *args, **kwargs):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n # Note: enable auto padding for dp compute DatapProto\n splitted_args, splitted_kwargs = _split_args_kwargs_data_proto_with_auto_padding(\n worker_group.world_size,\n *args,\n **kwargs,\n )\n return splitted_args, splitted_kwargs\n\n\ndef dispatch_dp_compute_data_proto_with_func(worker_group, *args, **kwargs):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n assert isinstance(args[0], FunctionType) # NOTE: The first one args is a function!\n\n splitted_args, splitted_kwargs = _split_args_kwargs_data_proto(worker_group.world_size, *args[1:], **kwargs)\n splitted_args_with_func = [[args[0]] * worker_group.world_size] + splitted_args\n return splitted_args_with_func, splitted_kwargs\n\n\ndef collect_dp_compute_data_proto(worker_group, output):\n import ray\n\n from verl.protocol import DataProto\n\n for o in output:\n assert isinstance(o, DataProto | ray.ObjectRef), f\"expecting {o} to be DataProto, but got {type(o)}\"\n\n output = collect_dp_compute(worker_group, output)\n return _concat_data_proto_or_future(output)\n\n\ndef dispatch_nd_compute(dp_rank_mapping: list[int], dp_size, worker_group, *args, **kwargs):\n import os\n\n from verl.single_controller.base.worker_group import WorkerGroup\n from verl.utils.ray_utils import parallel_put\n\n assert isinstance(worker_group, WorkerGroup)\n\n max_workers = max(1, min(len(args[0]), os.cpu_count()))\n\n args = [parallel_put(arg, max_workers=max_workers) for arg in args]\n kwargs = {k: parallel_put(v, max_workers=max_workers) for k, v in kwargs.items()}\n\n all_args = []\n for arg in args:\n assert isinstance(arg, tuple | list) and len(arg) == dp_size\n transformed_args = []\n for i in range(worker_group.world_size):\n local_dp_rank = dp_rank_mapping[i]\n transformed_args.append(arg[local_dp_rank])\n all_args.append(transformed_args)\n all_args = tuple(all_args)\n\n all_kwargs = {}\n for k, v in kwargs.items():\n assert isinstance(v, tuple | list) and len(v) == dp_size\n transformed_v = []\n for i in range(worker_group.world_size):\n local_dp_rank = dp_rank_mapping[i]\n transformed_v.append(v[local_dp_rank])\n all_kwargs[k] = transformed_v\n return all_args, all_kwargs\n\n\ndef collect_nd_compute(collect_mask: list[bool], worker_group, output):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n assert len(output) == worker_group.world_size\n\n output_in_dp = []\n for global_rank in range(worker_group.world_size):\n collect_dp_rank = collect_mask[global_rank]\n if collect_dp_rank:\n output_in_dp.append(output[global_rank])\n return output_in_dp\n\n\ndef dispatch_nd_compute_dataproto(dp_rank_mapping: list[int], dp_size, worker_group, *args, **kwargs):\n splitted_args, splitted_kwargs = _split_args_kwargs_data_proto(dp_size, *args, **kwargs)\n return dispatch_nd_compute(dp_rank_mapping, dp_size, worker_group, *splitted_args, **splitted_kwargs)\n\n\ndef collect_nd_compute_dataproto(collect_mask: list[bool], worker_group, output):\n output = collect_nd_compute(collect_mask, worker_group, output)\n import ray\n\n from verl.protocol import DataProto\n\n for o in output:\n assert isinstance(o, DataProto | ray.ObjectRef | BatchMeta | TensorDict), (\n f\"expecting {o} to be DataProto | ray.ObjectRef | BatchMeta | TensorDict, but got {type(o)}\"\n )\n return _concat_data_proto_or_future(output)\n\n\ndef dispatch_lazy_compute_data_proto(mesh_name, worker_group, *args, **kwargs):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n\n # query dispatch info of the worker group\n if mesh_name not in worker_group._dispatch_info:\n worker_group._dispatch_info[mesh_name] = worker_group._query_dispatch_info(mesh_name)\n assert len(worker_group._dispatch_info[mesh_name]) == worker_group.world_size\n\n dp_rank_mapping = worker_group._dispatch_info[mesh_name]\n # perform dispatch\n dp_size = max(dp_rank_mapping) + 1\n return dispatch_nd_compute_dataproto(dp_rank_mapping, dp_size, worker_group, *args, **kwargs)\n\n\ndef collect_lazy_compute_data_proto(mesh_name, worker_group, *args, **kwargs):\n from verl.single_controller.base.worker_group import WorkerGroup\n\n assert isinstance(worker_group, WorkerGroup)\n\n # the dispatch info is stored in the worker group\n assert mesh_name in worker_group._dispatch_info\n\n if mesh_name not in worker_group._collect_info:\n worker_group._collect_info[mesh_name] = worker_group._query_collect_info(mesh_name)\n assert len(worker_group._collect_info[mesh_name]) == worker_group.world_size\n\n # a boolean of whether the dp_rank is used for collect\n collect_mask = worker_group._collect_info[mesh_name]\n # perform dispatch\n return collect_nd_compute_dataproto(collect_mask, worker_group, *args, **kwargs)\n\n\ndef make_nd_compute_dataproto_dispatch_fn(mesh_name):\n return {\n \"dispatch_fn\": partial(dispatch_lazy_compute_data_proto, mesh_name),\n \"collect_fn\": partial(collect_lazy_compute_data_proto, mesh_name),\n }\n\n\n# Global registry for dispatch mode.\nDISPATCH_MODE_FN_REGISTRY = {\n Dispatch.ONE_TO_ALL: {\n \"dispatch_fn\": dispatch_one_to_all,\n \"collect_fn\": collect_all_to_all,\n },\n Dispatch.ALL_TO_ALL: {\n \"dispatch_fn\": dispatch_all_to_all,\n \"collect_fn\": collect_all_to_all,\n },\n Dispatch.DP_COMPUTE: {\"dispatch_fn\": dispatch_dp_compute, \"collect_fn\": collect_dp_compute},\n Dispatch.DP_COMPUTE_PROTO: {\n \"dispatch_fn\": dispatch_dp_compute_data_proto,\n \"collect_fn\": collect_dp_compute_data_proto,\n },\n Dispatch.DP_COMPUTE_PROTO_WITH_FUNC: {\n \"dispatch_fn\": dispatch_dp_compute_data_proto_with_func,\n \"collect_fn\": collect_dp_compute_data_proto,\n },\n Dispatch.DP_COMPUTE_METRIC: {\"dispatch_fn\": dispatch_dp_compute_data_proto, \"collect_fn\": collect_dp_compute},\n Dispatch.DIRECT_ROLLOUT_METHOD: {\n \"dispatch_fn\": dummy_direct_rollout_call,\n \"collect_fn\": dummy_direct_rollout_call,\n },\n}\n\n\ndef get_predefined_dispatch_fn(dispatch_mode):\n return DISPATCH_MODE_FN_REGISTRY[dispatch_mode]\n\n\ndef register_dispatch_mode(dispatch_mode_name, dispatch_fn, collect_fn):\n \"\"\"\n Register a new dispatch mode.\n \"\"\"\n dispatch_mode = Dispatch.register(dispatch_mode_name)\n _check_dispatch_mode(dispatch_mode)\n assert dispatch_mode not in DISPATCH_MODE_FN_REGISTRY, f\"dispatch_mode_name {dispatch_mode_name} already exists\"\n DISPATCH_MODE_FN_REGISTRY[dispatch_mode] = {\"dispatch_fn\": dispatch_fn, \"collect_fn\": collect_fn}\n\n\ndef update_dispatch_mode(dispatch_mode, dispatch_fn, collect_fn):\n \"\"\"\n Update the dispatch mode.\n \"\"\"\n _check_dispatch_mode(dispatch_mode)\n assert dispatch_mode in DISPATCH_MODE_FN_REGISTRY, f\"dispatch_mode {dispatch_mode} not found\"\n DISPATCH_MODE_FN_REGISTRY[dispatch_mode] = {\"dispatch_fn\": dispatch_fn, \"collect_fn\": collect_fn}\n\n\ndef get_predefined_execute_fn(execute_mode):\n \"\"\"\n Note that here we only asks execute_all and execute_rank_zero to be implemented\n Leave the choice of how these two functions handle argument 'blocking' to users\n \"\"\"\n predefined_execute_mode_fn = {\n Execute.ALL: {\"execute_fn_name\": \"execute_all\"},\n Execute.RANK_ZERO: {\"execute_fn_name\": \"execute_rank_zero\"},\n }\n return predefined_execute_mode_fn[execute_mode]\n\n\ndef _check_dispatch_mode(dispatch_mode):\n assert isinstance(dispatch_mode, Dispatch | dict), (\n f\"dispatch_mode must be a Dispatch or a Dict. Got {dispatch_mode}\"\n )\n if isinstance(dispatch_mode, dict):\n necessary_keys = [\"dispatch_fn\", \"collect_fn\"]\n for key in necessary_keys:\n assert key in dispatch_mode, f\"key {key} should be in dispatch_mode if it is a dictionary\"\n\n\ndef _check_execute_mode(execute_mode):\n assert isinstance(execute_mode, Execute), f\"execute_mode must be a Execute. Got {execute_mode}\"\n\n\ndef _materialize_futures(*args, **kwargs):\n new_args = []\n for arg in args:\n if isinstance(arg, DataProtoFuture):\n arg = arg.get()\n # add more type to materialize\n new_args.append(arg)\n for k, v in kwargs.items():\n if isinstance(v, DataProtoFuture):\n kwargs[k] = v.get()\n\n new_args = tuple(new_args)\n return new_args, kwargs\n\n\ndef register(dispatch_mode=Dispatch.ALL_TO_ALL, execute_mode=Execute.ALL, blocking=True, materialize_futures=True):\n \"\"\"Register a function with distributed execution configuration.\n\n This decorator registers a function with specific dispatch and execution modes\n for distributed computation. It handles both synchronous and asynchronous\n functions, and optionally materializes futures before execution.\n\n Args:\n dispatch_mode:\n Dispatch mode for computation distribution. Default: Dispatch.ALL_TO_ALL.\n execute_mode:\n Execute mode for computation distribution. Default: Execute.ALL.\n blocking:\n Whether the execution should be blocking. Defaults to True.\n materialize_futures:\n Whether to materialize the data before dispatching. Defaults to True.\n\n Returns:\n A decorator that wraps the original function with distributed execution\n configuration.\n \"\"\"\n from verl.utils.transferqueue_utils import tqbridge\n\n _check_dispatch_mode(dispatch_mode=dispatch_mode)\n _check_execute_mode(execute_mode=execute_mode)\n\n def decorator(func):\n func = tqbridge(dispatch_mode=dispatch_mode)(func)\n\n @wraps(func)\n def inner(*args, **kwargs):\n if materialize_futures:\n args, kwargs = _materialize_futures(*args, **kwargs)\n return func(*args, **kwargs)\n\n @wraps(func)\n async def async_inner(*args, **kwargs):\n if materialize_futures:\n args, kwargs = _materialize_futures(*args, **kwargs)\n return await func(*args, **kwargs)\n\n wrapper = async_inner if inspect.iscoroutinefunction(func) else inner\n attrs = {\"dispatch_mode\": dispatch_mode, \"execute_mode\": execute_mode, \"blocking\": blocking}\n setattr(wrapper, MAGIC_ATTR, attrs)\n return wrapper\n\n return decorator\n"} +{"file_name": "verl__single_controller__base__worker.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nthe class for Worker\n\"\"\"\n\nimport os\nimport socket\nimport warnings\nfrom dataclasses import dataclass\n\nimport ray\n\nfrom verl.utils.device import (\n get_torch_device,\n get_visible_devices_keyword,\n is_npu_available,\n)\n\nfrom .decorator import Dispatch, Execute, register\n\n\n@dataclass\nclass DistRankInfo:\n tp_rank: int\n dp_rank: int\n pp_rank: int\n cp_rank: int\n\n\n@dataclass\nclass DistGlobalInfo:\n tp_size: int\n dp_size: int\n pp_size: int\n cp_size: int\n\n\nclass WorkerHelper:\n @staticmethod\n def _get_node_ip():\n if os.getenv(\"WG_BACKEND\", None) == \"ray\":\n return ray.util.get_node_ip_address()\n else:\n raise NotImplementedError(\"WG_BACKEND now just support ray mode.\")\n\n @staticmethod\n def _get_free_port():\n with socket.socket() as sock:\n sock.bind((\"\", 0))\n return sock.getsockname()[1]\n\n def get_availale_master_addr_port(self):\n warnings.warn(\n \"This function is deprecated due to typo in name; Please use `get_available_master_addr_port` instead\",\n stacklevel=2,\n )\n return self.get_available_master_addr_port()\n\n def get_available_master_addr_port(self):\n return self._get_node_ip().strip(\"[]\"), str(self._get_free_port())\n\n\n# we assume that in each WorkerGroup, there is a Master Worker\nclass Worker(WorkerHelper):\n \"\"\"A distributed worker that handles initialization and configuration for distributed training.\n\n This class manages worker initialization, configuration, and provides methods for executing\n distributed operations. It handles communication settings, device configuration, and worker\n metadata management.\n \"\"\"\n\n fused_worker_attr_name = \"fused_worker_dict\"\n\n def _register_dispatch_collect_info(self, mesh_name: str, dp_rank: int, is_collect: bool):\n \"\"\"Register the dp_rank for a given mesh name. This function is meant to be called by the worker\n\n Args:\n mesh_name (str):\n Name of the mesh to register dp_rank for.\n dp_rank (int):\n dp_rank to register for the given mesh name.\n is_collect (bool):\n Whether the dp_rank is used for collect.\n \"\"\"\n if mesh_name in self.__dispatch_dp_rank or mesh_name in self.__collect_dp_rank:\n raise ValueError(f\"mesh_name {mesh_name} has been registered\")\n self.__dispatch_dp_rank[mesh_name] = dp_rank\n self.__collect_dp_rank[mesh_name] = is_collect\n\n @register(dispatch_mode=Dispatch.ONE_TO_ALL)\n def _query_dispatch_info(self, mesh_name: str):\n \"\"\"Query the dispatch info for a given mesh name.\n\n Args:\n mesh_name (str):\n Name of the mesh to query dispatch info for.\n\n Returns:\n int:\n The dp_rank for the given mesh name.\n \"\"\"\n assert mesh_name in self.__dispatch_dp_rank, f\"{mesh_name} is not registered in {self.__class__.__name__}\"\n # note that each rank store its own dp_rank\n return self.__dispatch_dp_rank[mesh_name]\n\n @register(dispatch_mode=Dispatch.ONE_TO_ALL)\n def _query_collect_info(self, mesh_name: str):\n return self.query_collect_info(mesh_name)\n\n def query_collect_info(self, mesh_name: str):\n \"\"\"Query the collect info for a given mesh name.\n\n Args:\n mesh_name (str):\n Name of the mesh to query collect info for.\n\n Returns:\n bool:\n Whether the dp_rank is used for collect.\n \"\"\"\n assert mesh_name in self.__collect_dp_rank, f\"{mesh_name} is not registered in {self.__class__.__name__}\"\n return self.__collect_dp_rank[mesh_name]\n\n def get_dispatch_collect(self):\n \"\"\"Get all registered dispatch and collect dp_ranks.\n\n Returns:\n dict[str, int]:\n A dictionary mapping mesh names to their dispatch dp_ranks.\n dict[str, bool]:\n A dictionary mapping mesh names to whether they are used for collect.\n \"\"\"\n return {\"dispatch_dp_rank\": self.__dispatch_dp_rank, \"collect_dp_rank\": self.__collect_dp_rank}\n\n def set_dispatch_collect(self, mesh_name: str, dispatch_dp_rank: dict[str, int], collect_dp_rank: dict[str, bool]):\n \"\"\"Set the dispatch and collect dp_ranks for all registered meshes.\n\n Args:\n mesh_name (str): Mesh name to set dispatch and collect dp_ranks for.\n dispatch_dp_rank (dict[str, int]):\n A dictionary mapping mesh names to their dispatch dp_ranks.\n collect_dp_rank (dict[str, bool]):\n A dictionary mapping mesh names to whether they are used for collect.\n \"\"\"\n assert mesh_name not in self.__dispatch_dp_rank, (\n f\"{mesh_name} is already registered, {self.__dispatch_dp_rank.keys()}\"\n )\n assert mesh_name not in self.__collect_dp_rank, (\n f\"{mesh_name} is already registered, {self.__collect_dp_rank.keys()}\"\n )\n for dp_rank in dispatch_dp_rank.values():\n self.__dispatch_dp_rank[mesh_name] = dp_rank\n for is_collect in collect_dp_rank.values():\n self.__collect_dp_rank[mesh_name] = is_collect\n\n @register(dispatch_mode=Dispatch.ONE_TO_ALL, blocking=True)\n def create_transferqueue_client(self, config):\n from verl.utils.transferqueue_utils import create_transferqueue_client\n\n create_transferqueue_client(\n client_id=f\"worker_{self.rank}\",\n config=config.transfer_queue,\n )\n\n @classmethod\n def env_keys(cls):\n \"\"\"The keys of the environment variables that are used to configure the Worker.\"\"\"\n return [\n \"WORLD_SIZE\",\n \"RANK\",\n \"LOCAL_WORLD_SIZE\",\n \"LOCAL_RANK\",\n \"MASTER_ADDR\",\n \"MASTER_PORT\",\n get_visible_devices_keyword().upper(),\n ]\n\n def __init__(self, cuda_visible_devices=None) -> None:\n \"\"\"Initialize the worker with environment settings and device configuration.\n\n Args:\n cuda_visible_devices (str, optional):\n CUDA visible devices configuration. Defaults to None.\n \"\"\"\n # construct a meta from environment variable. Note that the import must be inside the class because\n # it is executed remotely\n import os\n\n self._setup_env_cuda_visible_devices()\n\n world_size = int(os.environ[\"WORLD_SIZE\"])\n rank = int(os.environ[\"RANK\"])\n self._rank = rank\n self._world_size = world_size\n\n master_addr = os.environ[\"MASTER_ADDR\"]\n master_port = os.environ[\"MASTER_PORT\"]\n\n local_world_size = int(os.getenv(\"LOCAL_WORLD_SIZE\", \"1\"))\n local_rank = int(os.getenv(\"LOCAL_RANK\", \"0\"))\n\n store = {\n \"_world_size\": world_size,\n \"_rank\": rank,\n \"_local_world_size\": local_world_size,\n \"_local_rank\": local_rank,\n \"_master_addr\": master_addr,\n \"_master_port\": master_port,\n }\n if cuda_visible_devices is not None:\n store[f\"_{get_visible_devices_keyword()}\".lower()] = cuda_visible_devices\n\n self._configure_with_store(store=store)\n\n self.fused_worker_dict = {}\n self.__dispatch_dp_rank = {}\n self.__collect_dp_rank = {}\n\n def get_fused_worker_by_name(self, worker_name: str):\n \"\"\"Get a fused worker by its name.\n\n Args:\n worker_name (str):\n Name of the worker to retrieve\n \"\"\"\n return self.fused_worker_dict.get(worker_name, None)\n\n def _setup_env_cuda_visible_devices(self):\n from verl.utils.ray_utils import ray_noset_visible_devices\n\n is_ray_noset_visible_devices = ray_noset_visible_devices()\n\n # Prevent use of clashing `{CUDA/HIP/ROCR}_VISIBLE_DEVICES``\n rocr_val = os.environ.get(\"ROCR_VISIBLE_DEVICES\", None)\n hip_val = os.environ.get(\"HIP_VISIBLE_DEVICES\", None)\n cuda_val = os.environ.get(\"CUDA_VISIBLE_DEVICES\", None)\n if hip_val:\n # Switch the use of HIP_VISIBLE_DEVICES to CUDA_VISIBLE_DEVICES for consistency.\n # Make sure that the HIP_VISIBLE_DEVICES is set to the same value as CUDA_VISIBLE_DEVICES\n # at this point.\n val = os.environ.pop(\"HIP_VISIBLE_DEVICES\")\n hip_val = None\n if cuda_val:\n assert val == cuda_val, (\n f\"Please use the same HIP_VISIBLE_DEVICES or CUDA_VISIBLE_DEVICES, inconsistant values \"\n f\"found: {val} and {cuda_val}.\"\n )\n else:\n cuda_val = val\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = val\n # os.environ[\"HIP_VISIBLE_DEVICES\"] = val\n\n if rocr_val:\n # You must take care if both HIP/CUDA and ROCR env vars are set as they have\n # different meanings. Both env vars accept either a list of ints or a\n # list of UUIDs. The ROCR env var is processed first which then reduces\n # the number of GPUs that HIP can select from.\n # https://github.com/pytorch/pytorch/pull/144026\n # To avoid the complexity of this, we simply gives out error if both are set\n # (Also to keep consistency with ray's practice with 2.45.0).\n # Otherwise, we will set ROCR_VISIBLE_DEVICES to CUDA_VISIBLE_DEVICES\n # and remove ROCR_VISIBLE_DEVICES.\n if cuda_val:\n raise ValueError(\"Please don't set ROCR_VISIBLE_DEVICES when HIP/CUDA_VISIBLE_DEVICES is set.\")\n\n cuda_val = os.environ.pop(\"ROCR_VISIBLE_DEVICES\")\n os.environ[\"CUDA_VISIBLE_DEVICES\"] = cuda_val\n rocr_val = None\n\n if is_ray_noset_visible_devices:\n # NOTE: Ray will automatically set the *_VISIBLE_DEVICES\n # environment variable for each actor, unless\n # RAY_EXPERIMENTAL_NOSET_*_VISIBLE_DEVICES is set,\n # so we need to set local rank when the flag is set.\n device_name = \"NPU\" if is_npu_available else \"GPU\"\n local_rank = ray.get_runtime_context().get_accelerator_ids()[device_name][0]\n os.environ[\"LOCAL_RANK\"] = local_rank\n get_torch_device().set_device(int(local_rank))\n\n def _configure_with_store(self, store: dict):\n \"\"\"\n This function should only be called inside by WorkerGroup\n \"\"\"\n store_env_dict = {f\"_{key.lower()}\": store.get(f\"_{key.lower()}\", None) for key in type(self).env_keys()}\n self.__dict__.update(store_env_dict) # this is hacky\n # print(f\"__dict__: {self.__dict__}\")\n for key in type(self).env_keys():\n val = self.__dict__.get(f\"_{key.lower()}\", None)\n if val is not None:\n # print(f\"set {key} to {val}\")\n os.environ[key] = str(val)\n os.environ[\"REDIS_STORE_SERVER_HOST\"] = (\n str(self._master_addr).replace(\"[\", \"\").replace(\"]\", \"\") if self._master_addr else \"\"\n )\n\n def get_master_addr_port(self):\n \"\"\"Get the master address and port for distributed communication.\"\"\"\n return self._master_addr, self._master_port\n\n def get_cuda_visible_devices(self):\n \"\"\"Get the CUDA visible devices configuration.\"\"\"\n import os\n\n visible_devices = os.environ.get(get_visible_devices_keyword().upper(), \"not set\")\n return visible_devices\n\n @property\n def world_size(self):\n \"\"\"Get the total number of workers in the distributed setup.\"\"\"\n return self._world_size\n\n @property\n def rank(self):\n \"\"\"Get the rank of this worker in the distributed setup.\"\"\"\n return self._rank\n\n @register(dispatch_mode=Dispatch.DP_COMPUTE_PROTO_WITH_FUNC)\n def execute_with_func_generator(self, func, *args, **kwargs):\n \"\"\"Execute a function with function generator dispatch mode.\n\n Args:\n func:\n Function to execute\n *args:\n Positional arguments for the function\n **kwargs:\n Keyword arguments for the function\n \"\"\"\n ret_proto = func(self, *args, **kwargs)\n return ret_proto\n\n @register(dispatch_mode=Dispatch.ALL_TO_ALL, execute_mode=Execute.RANK_ZERO)\n def execute_func_rank_zero(self, func, *args, **kwargs):\n \"\"\"Execute a function in rank zero execution mode.\n\n Args:\n func:\n Function to execute\n *args:\n Positional arguments for the function\n **kwargs:\n Keyword arguments for the function\n \"\"\"\n result = func(*args, **kwargs)\n return result\n"} +{"file_name": "verl__single_controller__ray__base.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nimport inspect\nimport logging\nimport os\nimport socket\nfrom copy import deepcopy\nfrom dataclasses import dataclass, field\nfrom typing import Any, Optional\n\nimport numpy as np\nimport ray\nfrom ray.experimental.state.api import get_actor\nfrom ray.util.placement_group import PlacementGroup, placement_group\nfrom ray.util.scheduling_strategies import NodeAffinitySchedulingStrategy, PlacementGroupSchedulingStrategy\n\nfrom verl.protocol import DataProto, _padding_size_key\nfrom verl.single_controller.base import ClassWithInitArgs, ResourcePool, Worker, WorkerGroup\nfrom verl.single_controller.base.decorator import MAGIC_ATTR, Dispatch\nfrom verl.utils.device import get_device_name\nfrom verl.utils.py_functional import temp_env_var\n\n__all__ = [\"Worker\"]\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef get_random_string(length: int) -> str:\n import random\n import string\n\n letters_digits = string.ascii_letters + string.digits\n return \"\".join(random.choice(letters_digits) for _ in range(length))\n\n\ndef func_generator(self, method_name, dispatch_fn, collect_fn, execute_fn, blocking):\n class Functor:\n def __call__(this, *args, **kwargs):\n args, kwargs = dispatch_fn(self, *args, **kwargs)\n padding_count = kwargs.pop(_padding_size_key, 0)\n output = execute_fn(method_name, *args, **kwargs)\n if blocking:\n output = ray.get(output)\n output = collect_fn(self, output)\n if padding_count > 0:\n if isinstance(output, DataProto):\n indices = [i for i in range(len(output))][:-padding_count]\n output = output.select_idxs(indices)\n elif isinstance(output, list):\n output = output[:-padding_count]\n return output\n\n # use class type to pass the method_name to get a better observability\n return type(method_name, (Functor,), {})()\n\n\ndef sort_placement_group_by_node_ip(pgs: list[PlacementGroup]) -> list[PlacementGroup]:\n \"\"\"\n Sort the placement groups by node ip, all bundles in a single placement group should be on the same node.\n\n FSDPCheckpointManager saves sharded model states and optimizer states in local storage, which requires RANK\n to be consistent across nodes when resume from checkpoint.\n\n With this function, if there's only one resource pool and there's no node change, RANK should be consistent\n across nodes in multiple ray jobs, even if the whole ray cluster is restarted.\n \"\"\"\n node_ip = {node[\"NodeID\"]: node[\"NodeManagerAddress\"] for node in ray.nodes()}\n pg_ip = {}\n for pg in pgs:\n specs = ray._private.state.state.placement_group_table(pg.id)\n # all bunles should be on the same node\n node_id = specs[\"bundles_to_node_id\"][0]\n pg_ip[pg.id] = node_ip[node_id]\n return sorted(pgs, key=lambda pg: pg_ip[pg.id])\n\n\n@ray.remote\ndef get_master_addr_port(master_port_range: Optional[list[int]] = None) -> tuple[str, str]:\n addr = ray.util.get_node_ip_address().strip(\"[]\")\n\n if master_port_range is None:\n with socket.socket() as s:\n s.bind((\"\", 0))\n port = s.getsockname()[1]\n else:\n port = master_port_range[0]\n while port < master_port_range[1]:\n try:\n with socket.socket() as s:\n s.bind((\"\", port))\n break\n except OSError:\n port += 1 # Increment port number if already in use\n logger.info(\"Port %d is already in use, trying port %d\", port - 1, port)\n else:\n raise RuntimeError(f\"Could not find a free port in range {master_port_range}\")\n return addr, str(port)\n\n\nclass RayResourcePool(ResourcePool):\n def __init__(\n self,\n process_on_nodes: Optional[list[int]] = None,\n use_gpu: bool = True,\n name_prefix: str = None,\n max_colocate_count: int = 10,\n detached=False,\n accelerator_type: Optional[str] = None,\n ) -> None:\n super().__init__(process_on_nodes, max_colocate_count)\n self.use_gpu = use_gpu\n # print(f\"in RayProcessDispatchConfiguration: name_prefix = {name_prefix}\")\n self.name_prefix = get_random_string(length=6) if name_prefix is None else name_prefix\n self.pgs = None\n self.detached = detached\n self.accelerator_type = accelerator_type\n\n def get_placement_groups(self, strategy=\"STRICT_PACK\", name=None, device_name=\"cuda\"):\n if self.pgs is not None:\n return self.pgs\n\n pg_name_prefix = (\n name if name else f\"{self.name_prefix}verl_group_{'_'.join([str(count) for count in self._store])}:\"\n )\n # print(f\"pg_name_prefix = {pg_name_prefix}\")\n if device_name == \"npu\":\n device_name = \"NPU\"\n elif device_name == \"cuda\":\n device_name = \"GPU\"\n\n bundle = {\"CPU\": self.max_colocate_count}\n if self.use_gpu:\n bundle[device_name] = 1\n if self.accelerator_type is not None:\n bundle[self.accelerator_type] = 1e-4\n pg_scheme = [[bundle.copy() for _ in range(process_count)] for process_count in self._store]\n\n lifetime = \"detached\" if self.detached else None\n\n pgs = [\n placement_group(bundles=bundles, strategy=strategy, name=pg_name_prefix + str(idx), lifetime=lifetime)\n for idx, bundles in enumerate(pg_scheme)\n ]\n\n ray.get([pg.ready() for pg in pgs])\n\n self.pgs = sort_placement_group_by_node_ip(pgs)\n return pgs\n\n\nclass SubRayResourcePool(RayResourcePool):\n def __init__(\n self,\n placement_groups: list[PlacementGroup],\n start_bundle_index: int,\n subgroup_world_size: int,\n **kwargs,\n ) -> None:\n super().__init__(**kwargs)\n self.pgs = placement_groups\n self.start_bundle_index = start_bundle_index\n self.subgroup_world_size = subgroup_world_size\n\n @property\n def world_size(self):\n return self.subgroup_world_size\n\n\n@dataclass\nclass ResourcePoolManager:\n \"\"\"\n Define a resource pool specification. Resource pool will be initialized first.\n \"\"\"\n\n resource_pool_spec: dict[str, list[int]]\n mapping: dict[int, str]\n resource_pool_dict: dict[str, RayResourcePool] = field(default_factory=dict)\n\n def create_resource_pool(self):\n \"\"\"Create Ray resource pools for distributed training.\n\n Initializes resource pools based on the resource pool specification,\n with each pool managing GPU resources across multiple nodes.\n For FSDP backend, uses max_colocate_count=1 to merge WorkerGroups.\n For Megatron backend, uses max_colocate_count>1 for different models.\n \"\"\"\n for resource_pool_name, process_on_nodes in self.resource_pool_spec.items():\n # max_colocate_count means the number of WorkerGroups (i.e. processes) in each RayResourcePool\n # For FSDP backend, using max_colocate_count=3: actor_critic_ref, rollout, reward model (optional)\n # For Megatron backend, we recommend using max_colocate_count>1\n # that can utilize different WorkerGroup for differnt models\n resource_pool = RayResourcePool(\n process_on_nodes=process_on_nodes, use_gpu=True, max_colocate_count=3, name_prefix=resource_pool_name\n )\n self.resource_pool_dict[resource_pool_name] = resource_pool\n\n self._check_resource_available()\n\n def get_resource_pool(self, role) -> RayResourcePool:\n \"\"\"Get the resource pool of the worker_cls\"\"\"\n return self.resource_pool_dict[self.mapping[role]]\n\n def get_n_gpus(self) -> int:\n \"\"\"Get the number of gpus in this cluster.\"\"\"\n return sum([n_gpus for process_on_nodes in self.resource_pool_spec.values() for n_gpus in process_on_nodes])\n\n def _check_resource_available(self):\n \"\"\"Check if the resource pool can be satisfied in this ray cluster.\"\"\"\n node_available_resources = ray._private.state.available_resources_per_node()\n node_available_gpus = {\n node: node_info.get(\"GPU\", 0) if \"GPU\" in node_info else node_info.get(\"NPU\", 0)\n for node, node_info in node_available_resources.items()\n }\n\n # check total required gpus can be satisfied\n total_available_gpus = sum(node_available_gpus.values())\n total_required_gpus = sum(\n [n_gpus for process_on_nodes in self.resource_pool_spec.values() for n_gpus in process_on_nodes]\n )\n if total_available_gpus < total_required_gpus:\n raise ValueError(\n f\"Total available GPUs {total_available_gpus} is less than total desired GPUs {total_required_gpus}\"\n )\n\n\ndef extract_pg_from_exist(\n resource_pools: dict[str, RayResourcePool], src_role_names: list[str], resource_pool: RayResourcePool\n) -> list:\n src_pgs = [\n pg\n for role_name, resource_pool in resource_pools.items()\n for pg in resource_pool.get_placement_groups()\n if role_name in src_role_names\n ]\n\n sorted_src_pgs = sorted(src_pgs, key=lambda pg: pg.bundle_count, reverse=True)\n sorted_process_on_nodes = sorted([(val, idx) for idx, val in enumerate(resource_pool.store)], reverse=True)\n\n unsorted_pgs: list[tuple[int, PlacementGroup]] = []\n searching_idx = 0\n for request_process, original_idx in sorted_process_on_nodes:\n assert searching_idx < len(sorted_src_pgs), f\"no enough nodes for request: searching {searching_idx} th node\"\n assert request_process <= sorted_src_pgs[searching_idx].bundle_count, (\n f\"requesting {request_process} processes, bundle count cannot satisfy\"\n )\n unsorted_pgs.append((original_idx, sorted_src_pgs[searching_idx]))\n searching_idx += 1\n\n return [pg for _, pg in sorted(unsorted_pgs)]\n\n\n# split a RayResourcePool or SubRayResourcePool into multiple SubRayResourcePool\ndef split_resource_pool(\n resource_pool: RayResourcePool | SubRayResourcePool, split_size: int | list[int]\n) -> list[SubRayResourcePool]:\n \"\"\"\n Split a RayResourcePool into multiple SubRayResourcePool.\n resouce_pool can also be a SubRayResourcePool (have been splited) for multiple-time spliting.\n\n Args:\n resource_pool (RayResourcePool | SubRayResourcePool): The resource pool to split.\n split_size (int | list[int]): The size of each split. If int, all splits will have the same size.\n If list[int], each element in the list represents the size of a split.\n\n Returns:\n list[SubRayResourcePool]: A list of SubRayResourcePool after splitting.\n \"\"\"\n # convert split_size to list[int]\n if isinstance(split_size, int):\n assert resource_pool.world_size % split_size == 0, \"split_size must be a divisor of world_size\"\n num_replica = resource_pool.world_size // split_size\n split_size_list = [split_size] * num_replica\n else:\n split_size_list = split_size\n\n assert sum(split_size_list) == resource_pool.world_size, \"split_size must sum up to world_size\"\n\n # judge if this resource pool has been splited\n if isinstance(resource_pool, SubRayResourcePool):\n start_bundle_idx_list = np.cumsum([resource_pool.start_bundle_index] + split_size_list[:-1])\n else:\n start_bundle_idx_list = np.cumsum([0] + split_size_list[:-1])\n\n # ensure resource_pool.pgs has been initialized\n placement_groups = resource_pool.get_placement_groups()\n split_resource_pools = [\n SubRayResourcePool(\n process_on_nodes=resource_pool.store,\n use_gpu=resource_pool.use_gpu,\n name_prefix=f\"{resource_pool.name_prefix}_split_{split_idx}\",\n max_colocate_count=resource_pool.max_colocate_count,\n placement_groups=placement_groups,\n start_bundle_index=start_bundle_idx_list[split_idx],\n subgroup_world_size=split_size_list[split_idx],\n )\n for split_idx in range(len(split_size_list))\n ]\n return split_resource_pools\n\n\ndef merge_resource_pool(rp1: RayResourcePool, rp2: RayResourcePool) -> RayResourcePool:\n assert rp1.use_gpu == rp2.use_gpu, \"Both RayResourcePool must either use_gpu or not\"\n assert rp1.max_colocate_count == rp2.max_colocate_count, \"Both RayResourcePool must has the same max_colocate_count\"\n assert rp1.n_gpus_per_node == rp2.n_gpus_per_node, \"Both RayResourcePool must has the same n_gpus_per_node\"\n assert rp1.detached == rp2.detached, \"Detached ResourcePool cannot be merged with non-detached ResourcePool\"\n\n new_store = rp1.store + rp2.store\n\n merged = type(rp1)(\n new_store, rp1.use_gpu, f\"{rp1.name_prefix}_{rp2.name_prefix}\", rp1.max_colocate_count, rp1.detached\n )\n merged.pgs = rp1.get_placement_groups(device_name=get_device_name()) + rp2.get_placement_groups(\n device_name=get_device_name()\n )\n\n return merged\n\n\nclass RayClassWithInitArgs(ClassWithInitArgs):\n \"\"\"A wrapper class for Ray actors with initialization arguments.\n\n This class extends ClassWithInitArgs to provide additional functionality for\n configuring and creating Ray actors with specific resource requirements and\n scheduling strategies.\n \"\"\"\n\n def __init__(self, cls, *args, **kwargs) -> None:\n # self._options = kwargs.pop('options', dict())\n super().__init__(cls, *args, **kwargs)\n self._options = {}\n self._additional_resource = {}\n\n def set_additional_resource(self, additional_resource):\n \"\"\"Set additional resource requirements for the actor.\n\n Args:\n additional_resource: Dictionary specifying additional resource requirements\n \"\"\"\n self._additional_resource = additional_resource\n\n def update_options(self, options: dict):\n \"\"\"Update the Ray actor creation options.\n\n Args:\n options: Dictionary of options to update\n \"\"\"\n self._options.update(options)\n\n def __call__(\n self,\n placement_group,\n placement_group_bundle_idx,\n use_gpu: bool = True,\n num_gpus=1,\n sharing_with=None,\n device_name=\"cuda\",\n ) -> Any:\n \"\"\"Create and return a Ray actor with the configured options.\n\n Args:\n placement_group: Ray placement group for scheduling\n placement_group_bundle_idx: Index of the bundle in the placement group\n use_gpu: Whether to use GPU resources\n num_gpus: Number of GPUs to allocate\n sharing_with: Actor to share resources with\n device_name: Device for training\n\n Returns:\n A Ray actor handle with the configured options\n \"\"\"\n if sharing_with is not None:\n target_node_id = ray.get(sharing_with.get_node_id.remote())\n visible_devices = ray.get(sharing_with.get_cuda_visible_devices.remote())\n options = {\"scheduling_strategy\": NodeAffinitySchedulingStrategy(node_id=target_node_id, soft=False)}\n return self.cls.options(**options).remote(*self.args, cuda_visible_devices=visible_devices, **self.kwargs)\n\n options = {\n \"scheduling_strategy\": PlacementGroupSchedulingStrategy(\n placement_group=placement_group, placement_group_bundle_index=placement_group_bundle_idx\n )\n }\n options.update(self._options)\n\n if use_gpu and device_name == \"cuda\":\n options[\"num_gpus\"] = num_gpus\n if use_gpu and device_name == \"npu\":\n options[\"resources\"] = {\"NPU\": num_gpus}\n\n if len(self._additional_resource) > 1:\n for k, v in self._additional_resource.items():\n options[k] = v\n\n # print(\"cls:\", self.cls)\n # print(\"args: \", self.args)\n # print(\"kwargs: \", self.kwargs)\n return self.cls.options(**options).remote(*self.args, **self.kwargs)\n\n\nclass RayWorkerGroup(WorkerGroup):\n \"\"\"A group of Ray workers that can be managed collectively.\n\n This class extends WorkerGroup to provide Ray-specific functionality for\n creating and managing groups of Ray actors with specific resource requirements\n and scheduling strategies.\n \"\"\"\n\n def __init__(\n self,\n resource_pool: RayResourcePool = None,\n ray_cls_with_init: RayClassWithInitArgs = None,\n bin_pack: bool = True,\n name_prefix: str = None,\n detached=False,\n worker_names=None,\n worker_handles: list[ray.actor.ActorHandle] = None,\n ray_wait_register_center_timeout: int = 300,\n **kwargs,\n ) -> None:\n \"\"\"Initialize a RayWorkerGroup.\n\n Args:\n resource_pool: Resource pool for worker allocation\n ray_cls_with_init: Class with initialization arguments for workers\n bin_pack: Whether to use strict bin packing for resource allocation\n name_prefix: Prefix for worker names\n detached: Whether workers should be detached\n worker_names: Names of existing workers to attach to\n ray_wait_register_center_timeout: Timeout for waiting on register center\n **kwargs: Additional keyword arguments\n \"\"\"\n self._master_addr = kwargs.pop(\"master_addr\", None)\n self._master_port = kwargs.pop(\"master_port\", None)\n self.use_gpu = kwargs.pop(\"use_gpu\", resource_pool.use_gpu if resource_pool is not None else True)\n self._ray_master_port_range = kwargs.pop(\"master_port_range\", None)\n super().__init__(resource_pool=resource_pool, **kwargs)\n self.ray_cls_with_init = ray_cls_with_init\n self.name_prefix = get_random_string(length=6) if name_prefix is None else name_prefix\n self._ray_wait_register_center_timeout = ray_wait_register_center_timeout\n # Whether the WorkerGroup is a Colocate WorkerGroup created by FusedWorker.\n self.fused_worker_used = False if ray_cls_with_init is None else ray_cls_with_init.fused_worker_used\n # if a WorkerGroup is spawned from Colocate WorkerGroup, this indicates which sub-class is binded to\n # this WorkerGroup.\n self.sub_cls_name = \"\"\n self.device_name = kwargs.get(\"device_name\", \"cuda\")\n self.profile_steps = kwargs.get(\"profile_steps\", None)\n self.worker_nsight_options = kwargs.get(\"worker_nsight_options\", None)\n self.customized_worker_env = kwargs.get(\"worker_env\", {})\n if self.worker_nsight_options is not None and self.worker_nsight_options[\"capture-range-end\"] is None:\n self.worker_nsight_options[\"capture-range-end\"] = f\"repeat-shutdown:{6 * len(self.profile_steps)}\"\n\n if worker_names is not None and (not self.fused_worker_used):\n assert self._is_init_with_detached_workers\n self._worker_names = worker_names\n\n if self._is_init_with_detached_workers:\n self._init_with_detached_workers(worker_names=worker_names, worker_handles=worker_handles)\n elif isinstance(resource_pool, SubRayResourcePool):\n self._init_with_subresource_pool(\n resource_pool=resource_pool,\n ray_cls_with_init=ray_cls_with_init,\n bin_pack=bin_pack,\n detached=detached,\n worker_env=self.customized_worker_env,\n )\n else:\n self._init_with_resource_pool(\n resource_pool=resource_pool,\n ray_cls_with_init=ray_cls_with_init,\n bin_pack=bin_pack,\n detached=detached,\n worker_env=self.customized_worker_env,\n )\n\n if ray_cls_with_init is not None:\n self._bind_worker_method(self.ray_cls_with_init.cls, func_generator)\n\n self.wg_dict = None\n self.method_names = []\n\n def _is_worker_alive(self, worker: ray.actor.ActorHandle):\n \"\"\"Check if a worker actor is still alive.\n\n Args:\n worker: Ray actor handle to check\n\n Returns:\n bool: True if the worker is alive, False otherwise\n \"\"\"\n worker_state_dict = get_actor(worker._actor_id.hex())\n return worker_state_dict.get(\"state\", \"undefined\") == \"ALIVE\" if worker_state_dict is not None else False\n\n def _init_with_detached_workers(self, worker_names, worker_handles):\n # ray.get_actor holds a weak reference to the actor, which causes actors garbage collected unexpectedly\n # if we only hold spawn RayWorkerGroup. By passing actor handle explicitly, spawn RayWorkerGroup have\n # strong reference to these actors.\n # https://github.com/ray-project/ray/pull/45699\n workers = worker_handles if worker_handles else [ray.get_actor(name=name) for name in worker_names]\n self._workers = workers\n self._world_size = len(workers)\n\n def _get_master_addr_port(self, pg, bundle_index=0, master_port_range=None):\n \"\"\"Get master addr and port for this worker group\"\"\"\n if self._master_addr is None and self._master_port is None:\n self._master_addr, self._master_port = ray.get(\n get_master_addr_port.options(\n scheduling_strategy=PlacementGroupSchedulingStrategy(\n placement_group=pg, placement_group_bundle_index=bundle_index\n ),\n ).remote(master_port_range=master_port_range)\n )\n elif self._master_addr is not None and self._master_port is not None:\n logger.debug(f\"{self._master_addr=} {self._master_port=}\")\n else:\n raise ValueError(\n \"Both 'master_addr' and 'master_port' must be provided if you intend to manually specify them, \"\n \"or neither should be provided to use Ray's default assignment.\"\n )\n\n def _init_with_resource_pool(\n self,\n resource_pool,\n ray_cls_with_init,\n bin_pack,\n detached,\n worker_env=None,\n ):\n \"\"\"Initialize the worker group by creating new workers from a resource pool.\n\n Args:\n resource_pool: Resource pool for worker allocation\n ray_cls_with_init: Class with initialization arguments for workers\n bin_pack: Whether to use strict bin packing for resource allocation\n detached: Whether workers should be detached\n \"\"\"\n self.resource_pool = resource_pool\n strategy = \"PACK\"\n if bin_pack:\n strategy = \"STRICT_PACK\"\n pgs = resource_pool.get_placement_groups(strategy=strategy, device_name=self.device_name)\n world_size = resource_pool.world_size\n self._world_size = world_size\n # cia.add_kwarg(\"_world_size\", world_size)\n\n rank = -1\n local_world_size = resource_pool.store[0]\n for pg_idx, pg in enumerate(sort_placement_group_by_node_ip(pgs)):\n assert local_world_size <= pg.bundle_count, f\"when generating for {self.name_prefix}, for the \"\n if pg_idx == 0:\n self._get_master_addr_port(pg, bundle_index=0, master_port_range=self._ray_master_port_range)\n\n for local_rank in range(local_world_size):\n rank += 1\n self._create_worker(\n rank=rank,\n pg_idx=pg_idx,\n pg=pg,\n local_rank=local_rank,\n resource_pool=resource_pool,\n ray_cls_with_init=ray_cls_with_init,\n worker_env=worker_env,\n detached=detached,\n )\n\n def _init_with_subresource_pool(self, resource_pool, ray_cls_with_init, bin_pack, detached, worker_env=None):\n \"\"\"Initialize the worker group by creating new workers from a resource pool or sub resource pool.\n Args:\n resource_pool: Resource pool for worker allocation\n ray_cls_with_init: Class with initialization arguments for workers\n bin_pack: Whether to use strict bin packing for resource allocation\n detached: Whether workers should be detached\n \"\"\"\n strategy = \"PACK\"\n if bin_pack:\n strategy = \"STRICT_PACK\"\n pgs = resource_pool.get_placement_groups(strategy=strategy, device_name=self.device_name)\n world_size = resource_pool.world_size\n self._world_size = world_size\n\n rank = -1\n local_world_size = resource_pool.store[0]\n self._get_master_addr_port(\n pgs[resource_pool.start_bundle_index // local_world_size],\n bundle_index=resource_pool.start_bundle_index % local_world_size,\n master_port_range=self._ray_master_port_range,\n )\n for curr_rank in range(resource_pool.start_bundle_index, resource_pool.start_bundle_index + world_size):\n pg_idx = curr_rank // local_world_size\n pg = pgs[pg_idx]\n local_rank = curr_rank % local_world_size\n assert local_world_size <= pg.bundle_count, f\"when generating for {self.name_prefix}, for the \"\n\n rank += 1\n self._create_worker(\n rank=rank,\n pg_idx=pg_idx,\n pg=pg,\n local_rank=local_rank,\n resource_pool=resource_pool,\n ray_cls_with_init=ray_cls_with_init,\n worker_env=worker_env,\n detached=detached,\n )\n\n def _create_worker(self, rank, pg_idx, pg, local_rank, resource_pool, ray_cls_with_init, worker_env, detached):\n world_size = resource_pool.world_size\n use_gpu = resource_pool.use_gpu\n if self.use_gpu and not use_gpu:\n raise ValueError(\"use_gpu is True but resource_pool.use_gpu is False\")\n local_world_size = resource_pool.store[0]\n num_gpus = 1 / resource_pool.max_colocate_count\n\n # we pass in environment variable at option so that Worker can use environment variable to set\n env_vars = {\n \"WORLD_SIZE\": str(world_size),\n \"RANK\": str(rank),\n \"WG_PREFIX\": self.name_prefix,\n \"WG_BACKEND\": \"ray\",\n \"RAY_LOCAL_WORLD_SIZE\": str(local_world_size),\n \"MASTER_ADDR\": self._master_addr,\n \"MASTER_PORT\": self._master_port,\n }\n if worker_env is not None:\n logging.debug(f\"Appending ray class env, origin: {env_vars}, customized env: {worker_env}\")\n conflict_env_vars = set(env_vars.keys()) & set(worker_env.keys())\n if len(conflict_env_vars) > 0:\n logging.error(\n f\"User customized env vars conflict with system env: {conflict_env_vars} \"\n f\"Overriding may cause unexpected behavior.\"\n )\n raise ValueError(f\"Cannot override protected system env: {conflict_env_vars}\")\n env_vars.update(worker_env)\n import re\n\n cia_name = type(ray_cls_with_init.cls).__name__\n match = re.search(r\"ActorClass\\(([^)]+)\\)\", cia_name) # ray.remote(Obj) -> \"ActorClass(Obj)\"\n cia_name = match.group(1) if match else cia_name # \"ActorClass(Obj)\" -> \"Obj\"\n name = f\"{self.name_prefix}{cia_name}_{pg_idx}:{local_rank}\" # e.g. Worker_2:5\n\n if self.profile_steps and self.device_name == \"cuda\":\n ray_cls_with_init.update_options(\n {\n \"runtime_env\": {\n \"env_vars\": env_vars,\n \"nsight\": self.worker_nsight_options,\n },\n \"name\": name,\n }\n )\n else:\n ray_cls_with_init.update_options({\"runtime_env\": {\"env_vars\": env_vars}, \"name\": name})\n\n if detached:\n ray_cls_with_init.update_options({\"lifetime\": \"detached\"})\n\n # create a worker\n worker = ray_cls_with_init(\n placement_group=pg,\n placement_group_bundle_idx=local_rank,\n use_gpu=self.use_gpu,\n num_gpus=num_gpus,\n device_name=self.device_name,\n )\n self._workers.append(worker)\n self._worker_names.append(name)\n\n @property\n def worker_names(self):\n return self._worker_names\n\n @classmethod\n def from_detached(\n cls,\n name_prefix=None,\n worker_names=None,\n worker_handles=None,\n ray_cls_with_init=None,\n **kwargs,\n ):\n \"\"\"Create a worker group from existing detached workers.\n\n Args:\n name_prefix: Prefix for worker names\n worker_names: Names of existing workers to attach to\n ray_cls_with_init: Class with initialization arguments for workers\n\n Returns:\n A new RayWorkerGroup instance\n \"\"\"\n worker_group = cls(\n resource_pool=None,\n ray_cls_with_init=ray_cls_with_init,\n name_prefix=name_prefix,\n worker_names=worker_names,\n worker_handles=worker_handles,\n **kwargs,\n )\n return worker_group\n\n def spawn(self, prefix_set):\n \"\"\"Spawn to a dictionary of worker groups, each with a subset of method with prefix.\n\n Args:\n prefix_set: Set of prefixes to create worker groups for\n\n Returns:\n Dictionary of worker groups keyed by prefix\n \"\"\"\n if self.fused_worker_used:\n return self.spawn_fused(prefix_set)\n\n def _rebind_actor_methods(worker_group, actor_name):\n prefix: str = actor_name + \"_\"\n for method_name in dir(worker_group):\n if method_name.startswith(prefix):\n original_method_name = method_name.removeprefix(prefix)\n method = getattr(worker_group, method_name)\n setattr(worker_group, original_method_name, method)\n\n new_worker_group_dict = {}\n for prefix in prefix_set:\n new_worker_group = self.from_detached(\n name_prefix=self.name_prefix,\n worker_names=self._worker_names,\n worker_handles=self._workers,\n ray_cls_with_init=self.ray_cls_with_init,\n profile_steps=self.profile_steps,\n worker_nsight_options=self.worker_nsight_options,\n )\n\n _rebind_actor_methods(new_worker_group, prefix)\n new_worker_group_dict[prefix] = new_worker_group\n return new_worker_group_dict\n\n def spawn_fused(self, prefix_set):\n \"\"\"Create a dictionary of worker groups for fused workers.\n\n Args:\n prefix_set: Set of prefixes to create worker groups for\n\n Returns:\n Dictionary of worker groups keyed by prefix\n \"\"\"\n wg_dict = dict()\n for key in prefix_set:\n new_wg = deepcopy(self)\n new_wg._bind_worker_method(self.ray_cls_with_init.cls.raw_cls_dict[key], func_generator)\n new_wg.sub_cls_name = key\n wg_dict[key] = new_wg\n return wg_dict\n\n def fuse(self, prefix_set):\n \"\"\"Fuse multiple worker groups into the current worker group.\n\n Args:\n prefix_set: Set of prefixes to fuse into the worker group\n \"\"\"\n if self.wg_dict is None:\n self.wg_dict = self.spawn(prefix_set)\n for role_name, role_wg in self.wg_dict.items():\n setattr(self, role_name, role_wg)\n self.method_names = self._bind_worker_method(self.ray_cls_with_init.cls, func_generator)\n\n def _execute_remote_single_worker(self, worker, method_name: str, *args, **kwargs):\n \"\"\"Execute a method on a single worker remotely.\n\n Args:\n worker: The worker actor handle\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n Remote object reference to the method execution\n \"\"\"\n if self.fused_worker_used and method_name not in self.method_names:\n remote_call = getattr(worker, self.fused_worker_execute_fn_name)\n return remote_call.remote(f\"{self.sub_cls_name}_fwmn_{method_name}\", *args, **kwargs)\n # fused worker not used\n remote_call = getattr(worker, method_name)\n return remote_call.remote(*args, **kwargs)\n\n def execute_rank_zero_sync(self, method_name: str, *args, **kwargs):\n \"\"\"Execute a method on rank zero worker synchronously.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n Result of the method execution\n \"\"\"\n return ray.get(self.execute_rank_zero_async(method_name, *args, **kwargs))\n\n def execute_rank_zero_async(self, method_name: str, *args, **kwargs):\n \"\"\"Execute a method on rank zero worker asynchronously.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n Remote object reference to the method execution\n \"\"\"\n return self._execute_remote_single_worker(self._workers[0], method_name, *args, **kwargs)\n\n def execute_rank_zero(self, method_name: str, *args, **kwargs):\n \"\"\"Alias for execute_rank_zero_async.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n Remote object reference to the method execution\n \"\"\"\n return self.execute_rank_zero_async(method_name, *args, **kwargs)\n\n def execute_all(self, method_name: str, *args, **kwargs):\n \"\"\"Alias for execute_all_async.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n List of remote object references to the method executions\n \"\"\"\n return self.execute_all_async(method_name, *args, **kwargs)\n\n def execute_all_sync(self, method_name: str, *args, **kwargs):\n \"\"\"Execute a method on all workers synchronously.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n List of results from all workers\n \"\"\"\n return ray.get(self.execute_all_async(method_name, *args, **kwargs))\n\n def execute_all_async(self, method_name: str, *args, **kwargs):\n \"\"\"Execute a method on all workers asynchronously.\n\n Args:\n method_name: Name of the method to execute\n *args: Positional arguments for the method\n **kwargs: Keyword arguments for the method\n\n Returns:\n List of remote object references to the method executions\n \"\"\"\n # Here, we assume that if all arguments in args and kwargs are lists,\n # and their lengths match len(self._workers), we'll distribute each\n # element in these lists to the corresponding worker\n # print(f\"execute_all_async: method {method_name}({args}, {kwargs})\")\n length = len(self._workers)\n if all(isinstance(arg, list) for arg in args) and all(isinstance(kwarg, list) for kwarg in kwargs.values()):\n if all(len(arg) == length for arg in args) and all(len(kwarg) == length for kwarg in kwargs.values()):\n # print(f\"splitting args and kwargs into {length} shards\")\n result = []\n for i in range(length):\n sliced_args = tuple(arg[i] for arg in args)\n sliced_kwargs = {k: v[i] for k, v in kwargs.items()}\n result.append(\n self._execute_remote_single_worker(self._workers[i], method_name, *sliced_args, **sliced_kwargs)\n )\n return result\n\n return [self._execute_remote_single_worker(worker, method_name, *args, **kwargs) for worker in self._workers]\n\n @property\n def master_address(self):\n return self._master_addr\n\n @property\n def master_port(self):\n return self._master_port\n\n @property\n def workers(self):\n return self._workers\n\n @property\n def world_size(self):\n return self._world_size\n\n\n\"\"\"\nUtilities that enables creating workers inside the same ray.Actor,\nwith code written in separate ray.Actors.\n\"\"\"\n\n\n# deprecated, switching to FusedWorker\ndef _bind_workers_method_to_parent(cls, key, user_defined_cls):\n \"\"\"\n Binds the methods of each worker to the WorkerDict.\n Note that we only bind public methods that are decorated by register\n \"\"\"\n\n for method_name in dir(user_defined_cls):\n try:\n method = getattr(user_defined_cls, method_name)\n assert callable(method), f\"{method_name} in {user_defined_cls} is not callable\"\n except Exception:\n # if it is a property, it will fail because Class doesn't have instance property\n continue\n\n if hasattr(method, MAGIC_ATTR):\n\n def generate_function(name, key=key):\n def func(self, *args, **kwargs):\n # dispatch to the actual worker\n return getattr(self.worker_dict[key], name)(*args, **kwargs)\n\n async def async_func(self, *args, **kwargs):\n # dispatch to the actual worker\n return await getattr(self.worker_dict[key], name)(*args, **kwargs)\n\n wrapper = async_func if inspect.iscoroutinefunction(method) else func # noqa: B023\n\n return wrapper\n\n func = generate_function(method_name)\n # pass MAGIC_ATTR for outer worker group\n attrs = getattr(method, MAGIC_ATTR)\n setattr(func, MAGIC_ATTR, attrs)\n try:\n # bind direct rollout method to class without prefix\n if attrs[\"dispatch_mode\"] == Dispatch.DIRECT_ROLLOUT_METHOD and \"rollout\" in key:\n assert not hasattr(cls, method_name), (\n f\"conflict direct rollout method {method_name} with role {key}\"\n )\n setattr(cls, method_name, func)\n print(f\"bind role {key} method {method_name} to class {cls}\")\n else:\n method_name_with_prefix = key + \"_\" + method_name\n setattr(cls, method_name_with_prefix, func)\n except Exception as e:\n raise ValueError(f\"Fail to set method_name {method_name}\") from e\n\n\ndef _unwrap_ray_remote(cls):\n if hasattr(cls, \"__ray_actor_class__\"):\n cls = cls.__ray_actor_class__\n return cls\n\n\ndef _determine_fsdp_megatron_base_class(mros: list):\n \"\"\"\n - megatron: base class should be MegatronWorker\n - fsdp: base class should be Worker\n \"\"\"\n for cls in mros[0]:\n if cls.__name__ == \"MegatronWorker\":\n return cls\n if cls.__name__ == \"Worker\":\n return cls\n raise ValueError(f\"Cannot determine base class for {mros}\")\n\n\n# deprecated, switching to FusedWorker\ndef create_colocated_worker_cls(class_dict: dict[str, RayClassWithInitArgs]):\n \"\"\"\n This function should return a class instance that delegates the calls to every\n cls in cls_dict\n \"\"\"\n cls_dict = {}\n init_args_dict = {}\n worker_cls = _determine_fsdp_megatron_base_class(\n [cls.cls.__ray_actor_class__.__mro__ for cls in class_dict.values()]\n )\n assert issubclass(worker_cls, Worker), f\"worker_cls {worker_cls} should be a subclass of Worker\"\n print(f\"colocated worker base class {worker_cls}\")\n\n for key, cls in class_dict.items():\n cls_dict[key] = cls.cls\n init_args_dict[key] = {\"args\": cls.args, \"kwargs\": cls.kwargs}\n\n assert cls_dict.keys() == init_args_dict.keys()\n\n # TODO: create a class with customizable name\n class WorkerDict(worker_cls):\n def __init__(self):\n super().__init__()\n self.worker_dict = {}\n for key, user_defined_cls in cls_dict.items():\n user_defined_cls = _unwrap_ray_remote(user_defined_cls)\n # directly instantiate the class without remote\n # in worker class, e.g. \n # when DISABLE_WORKER_INIT == 1 it will return immediately\n with temp_env_var(\"DISABLE_WORKER_INIT\", \"1\"):\n self.worker_dict[key] = user_defined_cls(\n *init_args_dict[key].get(\"args\", ()), **init_args_dict[key].get(\"kwargs\", {})\n )\n\n # now monkey-patch the methods from inner class to WorkerDict\n for key, user_defined_cls in cls_dict.items():\n user_defined_cls = _unwrap_ray_remote(user_defined_cls)\n _bind_workers_method_to_parent(WorkerDict, key, user_defined_cls)\n\n remote_cls = ray.remote(WorkerDict)\n remote_cls = RayClassWithInitArgs(cls=remote_cls)\n return remote_cls\n\n\nFusedWorkerCLSName = \"FusedWorker\"\n\n\ndef create_colocated_worker_raw_cls(class_dict: dict[str, RayClassWithInitArgs]):\n \"\"\"\n This function returns a FusedWorker class.\n\n `FusedWorker.{class_name}` -> FusedClass\n Use `class_name` as a param to directly access the underlying class.\n\n `FusedWorker._fuw_execute(\"{class_name}_fwmn_{method_name}\", *args, **kwargs)`\n First param must be \"{class_name}_fwmn_{method_name}\" in order to access `method_name`\n of underlying class `{class_name}`.\n\n `FusedWorker.fused_worker_dict` -> {\"class_name\": FusedClass}\n Stores all underlying classes.\n\n `FusedClass.fused_worker_dict` -> {\"class_name\": FusedClass}\n The same as `FusedWorker.fused_worker_dict`, enables underlying class to access other\n underlying classes.\n \"\"\"\n raw_cls_dict = {cls_name: _unwrap_ray_remote(cia.cls) for cls_name, cia in class_dict.items()}\n init_args_dict = {cls_name: cia.args for cls_name, cia in class_dict.items()}\n init_kwargs_dict = {cls_name: cia.kwargs for cls_name, cia in class_dict.items()}\n cls_names = list(class_dict.keys())\n\n # FusedWorker_Actor_Critic\n class_name_renamed = \"_\".join([FusedWorkerCLSName] + cls_names)\n\n class FusedWorker(Worker):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.cls_names = cls_names\n self.raw_cls_dict = raw_cls_dict\n self.init_args_dict = init_args_dict\n self.init_kwargs_dict = init_kwargs_dict\n\n for cls_name, udc, ud_args, ud_kwargs in zip(\n self.cls_names,\n self.raw_cls_dict.values(),\n self.init_args_dict.values(),\n self.init_kwargs_dict.values(),\n strict=True,\n ):\n with temp_env_var(\"DISABLE_WORKER_INIT\", \"1\"):\n udc._get_ray_actor_cls_name = lambda x, name_renamed=class_name_renamed: name_renamed\n udc._get_ray_method_prefix = lambda x, name_prefixed=cls_name: f\"{name_prefixed}_\"\n # cls_name = \"actor\", \"critic\", udc = ActorWorker, CriticWorker\n self.fused_worker_dict[cls_name] = udc(*ud_args, **ud_kwargs)\n setattr(self, cls_name, self.fused_worker_dict[cls_name])\n\n # injecting fused_worker to each sub worker so they can be aware of existence of each other\n for _, worker in self.fused_worker_dict.items():\n setattr(worker, Worker.fused_worker_attr_name, self.fused_worker_dict)\n\n def _fuw_execute(self, method_name: str, *args, **kwargs):\n # for fused_worker, method_name is in a form of \"{cls_name}_fwmn_{method_name}\"\n # where fwmn stands \"fused worker method name\"\n names = method_name.split(\"_fwmn_\")\n cls_name = names[0]\n method_name = names[1]\n\n assert cls_name in self.fused_worker_dict, (\n f\"calling {cls_name}'s {method_name}, but {cls_name} not in fused_worker_dict\"\n )\n udc_method = getattr(self.fused_worker_dict[cls_name], method_name)\n return udc_method(*args, **kwargs)\n\n renamed_fused_worker_cls = type(class_name_renamed, (FusedWorker,), {})\n renamed_fused_worker_cls.is_fused_worker = True\n renamed_fused_worker_cls.raw_cls_dict = raw_cls_dict\n\n return renamed_fused_worker_cls\n\n\ndef create_colocated_worker_cls_fused(class_dict: dict[str, RayClassWithInitArgs]):\n \"\"\"\n This function returns a RayClassWithInitArgs instance of FusedWorker, which is an replacement\n of `create_colocated_worker_cls`. WorkerGroup constructed using this class will be a colocated\n WorkerGroup, which will be referenced as `ColocateWorkerGroup` below.\n\n `ColocateWorkerGroup.spawn(prefix_set)`\n returns a dict of WorkerGroup {\"class_name\": WorkerGroup}, WorkerGroup in this dict will\n have methods of underlying class `class_name` attached.\n\n `ColocateWorkerGroup.fuse(prefix_set)`\n After executing this function, `ColocateWorkerGroup.{class_name}` will return WorkerGroup\n with methods of underlying class `class_name` attached.\n \"\"\"\n raw_colocated_worker_cls = create_colocated_worker_raw_cls(class_dict)\n\n remote_cls = ray.remote(raw_colocated_worker_cls)\n cia = RayClassWithInitArgs(cls=remote_cls)\n cia.fused_worker_used = True\n\n return cia\n"} +{"file_name": "verl__trainer__config__config.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom dataclasses import dataclass, field\nfrom typing import Any, Optional\n\nfrom verl.base_config import BaseConfig\n\n__all__ = [\"CheckpointConfig\", \"ProfileConfig\", \"BaseModelConfig\"]\n\n\n@dataclass\nclass CheckpointConfig(BaseConfig):\n \"\"\"Configuration for model checkpointing.\n\n The inheritance from BaseConfig provides omegaconf.DictConfig-like interface for a dataclass config.\n\n Args:\n save_contents (list[str]): What to include in saved checkpoints.\n Options: 'model', 'optimizer', 'extra', 'hf_model'.\n load_contents (list[str]): Contents to load from checkpoint. Defaults to same as save_contents.\n async_save (bool): Whether to save checkpoints asynchronously. Only implemented for Megatron as of now.\n \"\"\"\n\n save_contents: list[str] = field(default_factory=lambda: [\"model\", \"optimizer\", \"extra\"])\n load_contents: list[str] = field(default_factory=lambda: [\"model\", \"optimizer\", \"extra\"])\n async_save: bool = False\n mbridge_config: dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ProfileConfig(BaseConfig):\n \"\"\"Configuration for profiling.\n\n The inheritance from BaseConfig provides omegaconf.DictConfig-like interface for a dataclass config.\n\n Args:\n profile_ranks (Optional[list[int]]): List of ranks to profile. None means all ranks.\n step_start (int): Starting step for profiling.\n step_end (int): Ending step for profiling.\n save_path (Optional[str]): Path to save profiling results.\n \"\"\"\n\n profile_ranks: Optional[list[int]] = None\n step_start: int = -1\n step_end: int = -1\n save_path: Optional[str] = None\n\n\n@dataclass\nclass BaseModelConfig(BaseConfig):\n \"\"\"Base configuration for a model.\n Contains core settings for loading and initializing a pretrained model checkpoint.\n\n Args:\n path (str): Path to pretrained model weights.\n tokenizer_path (Optional[str]): Tokenizer path (defaults to actor's model path if not set).\n override_config (dict): Hugging Face config override.\n external_lib (Optional[str]): External model implementation (optional).\n trust_remote_code (bool): Whether to trust remote code from Hugging Face models.\n lora (dict[str, Any]): LoRA configuration dictionary.\n \"\"\"\n\n path: str = \"~/models/deepseek-llm-7b-chat\"\n tokenizer_path: Optional[str] = None\n override_config: dict[str, Any] = field(default_factory=dict)\n external_lib: Optional[str] = None\n trust_remote_code: bool = False\n lora: dict[str, Any] = field(default_factory=dict)\n\n\n@dataclass\nclass ModuleConfig(BaseConfig):\n \"\"\"Configuration for external Python module, which can be loaded, executed (and optionally, ``import``ed).\n\n Args:\n path (str, optional): Path to the module file to load and execute.\n name (str, optional): Name of the module to ``import``. Format: ``\"import.path.to.module\"``.\n If ``None``, the module will be loaded with a hased name and\n will not be added to ``sys.modules``, thus can not be ``import``ed as ``name``.\n \"\"\"\n\n path: Optional[str] = None\n name: Optional[str] = None\n"} +{"file_name": "verl__trainer__fsdp_sft_trainer.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nA lightweight one-file FSDP SFT Trainer\nTODO(zhangchi.usc1992)\n- Add calculation of mfu\n- Add validation\n\"\"\"\n\nimport os\n\nos.environ[\"NCCL_DEBUG\"] = \"WARN\"\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\n\nimport logging\nimport re\nimport time\nfrom contextlib import nullcontext\n\nimport hydra\nimport torch\nimport torch.distributed\nfrom omegaconf import DictConfig, OmegaConf\nfrom peft import LoraConfig, TaskType, get_peft_model\nfrom tensordict import TensorDict\nfrom torch import nn\nfrom torch.distributed.device_mesh import DeviceMesh, init_device_mesh\nfrom torch.distributed.fsdp import CPUOffload, MixedPrecision, ShardingStrategy\nfrom torch.distributed.fsdp import FullyShardedDataParallel as FSDP\nfrom torch.utils.data import Dataset, DistributedSampler\nfrom torchdata.stateful_dataloader import StatefulDataLoader\nfrom tqdm import tqdm\nfrom transformers import AutoConfig, AutoModelForCausalLM, PreTrainedModel\n\nimport verl.utils.hdfs_io as hdfs_io\nfrom verl.utils.attention_utils import index_first_axis, pad_input, rearrange, unpad_input\nfrom verl.utils.checkpoint.checkpoint_manager import find_latest_ckpt_path, get_checkpoint_tracker_filename\nfrom verl.utils.checkpoint.fsdp_checkpoint_manager import FSDPCheckpointManager\nfrom verl.utils.dataset import SFTDataset\nfrom verl.utils.dataset.multiturn_sft_dataset import MultiTurnSFTDataset\nfrom verl.utils.device import (\n auto_set_device,\n get_device_id,\n get_device_name,\n is_cuda_available,\n is_npu_available,\n)\nfrom verl.utils.distributed import destroy_global_process_group, initialize_global_process_group\nfrom verl.utils.fs import copy_to_local\nfrom verl.utils.fsdp_utils import (\n CPUOffloadPolicy,\n MixedPrecisionPolicy,\n apply_fsdp2,\n fsdp2_clip_grad_norm_,\n fsdp2_load_full_state_dict,\n get_fsdp_wrap_policy,\n get_init_weight_context_manager,\n init_fn,\n)\nfrom verl.utils.logger import log_with_rank\nfrom verl.utils.profiler import log_gpu_memory_usage\nfrom verl.utils.py_functional import convert_to_regular_types\nfrom verl.utils.torch_dtypes import PrecisionType\nfrom verl.utils.torch_functional import get_cosine_schedule_with_warmup, get_wsd_schedule_with_warmup\nfrom verl.utils.tracking import Tracking\nfrom verl.utils.ulysses import (\n gather_outputs_and_unpad,\n get_ulysses_sequence_parallel_world_size,\n ulysses_pad_and_slice_inputs,\n)\nfrom verl.workers.config.optimizer import build_optimizer\nfrom verl.workers.sharding_manager.fsdp_ulysses import FSDPUlyssesShardingManager\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_SFT_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef extract_step(path):\n match = re.search(r\"global_step_(\\d+)\", path)\n if match:\n return int(match.group(1))\n return None\n\n\nclass FSDPSFTTrainer:\n def __init__(\n self,\n config,\n device_mesh: DeviceMesh,\n ulysses_device_mesh: DeviceMesh,\n tokenizer,\n train_dataset: Dataset,\n val_dataset: Dataset,\n ):\n self.config = config\n self.device_mesh = device_mesh\n self.ulysses_device_mesh = ulysses_device_mesh\n self.sharding_manager = FSDPUlyssesShardingManager(self.ulysses_device_mesh)\n self.tokenizer = tokenizer\n if self.config.data.chat_template is not None:\n raise ValueError(\"Apply Chat template from config is not supported yet.\")\n\n # normalize dp size\n self._normalize_config_bsz()\n\n # Set sequence parallel size\n self.config.ulysses_sequence_parallel_size = getattr(self.config, \"ulysses_sequence_parallel_size\", 1)\n self.use_remove_padding = getattr(self.config, \"use_remove_padding\", False)\n if self.device_mesh.get_rank() == 0:\n print(f\"Using sequence parallel size: {self.config.ulysses_sequence_parallel_size}\")\n print(f\"Using remove padding: {self.use_remove_padding}\")\n\n self._build_dataloader(train_dataset, val_dataset)\n\n self.lora = self.config.model.get(\"lora_adapter_path\") is not None or self.config.model.lora_rank > 0\n\n # Initialize resume-related variables\n self.resume_global_step = 0\n\n # build model\n self._build_model_optimizer()\n\n # Initialize checkpoint manager\n self._init_checkpoint_manager()\n\n self.load_checkpoint()\n\n if self.device_mesh.get_rank() == 0:\n print(self.config)\n\n self.device_name = self.config.trainer.device\n\n def _normalize_config_bsz(self):\n dp_size = self.device_mesh.size(0) if not self.ulysses_device_mesh else self.ulysses_device_mesh.size(0)\n if self.device_mesh.get_rank() == 0:\n print(f\"Normalize batch size by dp {dp_size}\")\n\n assert self.config.data.train_batch_size % dp_size == 0, (\n f\"Global batch size {self.config.data.train_batch_size} is not divisible by dp size {dp_size}\"\n )\n\n self.config.data.train_batch_size //= dp_size\n\n assert self.config.data.train_batch_size % self.config.data.micro_batch_size_per_gpu == 0\n\n def _build_dataloader(self, train_dataset, val_dataset):\n # build dataset\n config = self.config\n self.train_dataset, self.val_dataset = train_dataset, val_dataset\n\n # build dataloader\n # Use data parallel rank and size instead of global rank and world size\n\n # If doing SP, we need to use the local rank and size\n if self.config.ulysses_sequence_parallel_size > 1:\n rank = self.ulysses_device_mesh.get_local_rank(\"dp\")\n world_size = self.ulysses_device_mesh.size(0)\n if self.ulysses_device_mesh.get_rank() == 0:\n print(f\"Using SP rank {rank} and size {world_size} for data distribution\")\n print(\"Each SP rank gets different data, but the same data WITHIN the same rank\")\n else:\n rank = self.device_mesh.get_rank()\n world_size = self.device_mesh.size()\n if self.device_mesh.get_rank() == 0:\n print(f\"Using FSDP rank {rank} and size {world_size} for data distribution\")\n\n # Set pin_memory_device when pin_memory is enabled.\n device_name = get_device_name()\n\n self.train_sampler = DistributedSampler(\n self.train_dataset, shuffle=True, num_replicas=world_size, rank=rank, drop_last=True\n )\n self.train_dataloader = StatefulDataLoader(\n dataset=self.train_dataset,\n batch_size=config.data.train_batch_size,\n sampler=self.train_sampler,\n num_workers=8,\n pin_memory=True,\n drop_last=True,\n pin_memory_device=device_name,\n )\n\n self.val_sampler = DistributedSampler(\n self.val_dataset, shuffle=False, num_replicas=world_size, rank=rank, drop_last=True\n )\n self.val_dataloader = StatefulDataLoader(\n dataset=self.val_dataset,\n batch_size=config.data.micro_batch_size_per_gpu,\n sampler=self.val_sampler,\n num_workers=8,\n pin_memory=True,\n drop_last=True,\n pin_memory_device=device_name,\n )\n\n def _build_model_optimizer(self):\n # TODO (zhangchi.usc1992):\n # 1. support pretrain from random weights\n # 2. support init directly from sharded weights\n local_model_path = copy_to_local(src=self.config.model.partial_pretrain, verbose=True)\n\n if self.config.model.get(\"external_lib\", None) is not None:\n # This is used to import external_lib into the huggingface systems\n import importlib\n\n importlib.import_module(self.config.model.external_lib)\n\n log_gpu_memory_usage(\"Before model allocation\", logger=logger)\n\n trust_remote_code = self.config.model.trust_remote_code\n torch_dtype = self.config.model.fsdp_config.get(\"model_dtype\", \"fp32\")\n torch_dtype = PrecisionType.to_dtype(torch_dtype)\n # load config first\n config = AutoConfig.from_pretrained(local_model_path, trust_remote_code=trust_remote_code)\n self.model_config = config\n if hasattr(self.model_config, \"max_position_embeddings\"):\n self.model_config.max_position_embeddings = max(\n self.model_config.max_position_embeddings, self.config.data.max_length\n )\n if self.config.ulysses_sequence_parallel_size > 1:\n assert self.use_remove_padding, \"Sequence parallel is only supported when remove_padding is enabled\"\n\n # This may be very large\n init_context = get_init_weight_context_manager(\n use_meta_tensor=not config.tie_word_embeddings, mesh=self.device_mesh\n )\n\n with init_context():\n self.model: PreTrainedModel = AutoModelForCausalLM.from_pretrained(\n local_model_path,\n config=config,\n torch_dtype=torch_dtype,\n attn_implementation=\"flash_attention_2\",\n trust_remote_code=trust_remote_code,\n )\n\n if self.use_remove_padding or self.config.ulysses_sequence_parallel_size > 1:\n from verl.models.transformers.monkey_patch import apply_monkey_patch\n\n apply_monkey_patch(model=self.model, ulysses_sp_size=self.config.ulysses_sequence_parallel_size)\n\n # Apply Liger kernel if use_liger is enabled\n if self.config.model.get(\"use_liger\", False):\n from liger_kernel.transformers.monkey_patch import _apply_liger_kernel_to_instance\n\n _apply_liger_kernel_to_instance(model=self.model)\n\n if self.lora:\n self.model.enable_input_require_grads()\n\n lora_adapter_path = self.config.model.get(\"lora_adapter_path\")\n if lora_adapter_path is not None:\n from peft import PeftModel\n\n print(f\"Loading pre-trained LoRA adapter for sft from: {lora_adapter_path}\")\n\n local_adapter_path = copy_to_local(lora_adapter_path, use_shm=self.config.model.use_shm)\n\n self.model = PeftModel.from_pretrained(self.model, local_adapter_path, is_trainable=True)\n peft_config = self.model.peft_config[\"default\"]\n # Ensure task_type is TaskType enum, not string\n if isinstance(peft_config.task_type, str):\n peft_config.task_type = TaskType.CAUSAL_LM\n else:\n # Convert config to regular Python types before creating PEFT model\n lora_config = {\n \"task_type\": TaskType.CAUSAL_LM,\n \"r\": self.config.model.lora_rank,\n \"lora_alpha\": self.config.model.lora_alpha,\n \"target_modules\": convert_to_regular_types(self.config.model.target_modules),\n \"bias\": \"none\",\n }\n self.model = get_peft_model(self.model, LoraConfig(**lora_config))\n self.model = self.model.to(torch_dtype)\n\n if self.config.model.enable_gradient_checkpointing:\n self.model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={\"use_reentrant\": False})\n\n log_gpu_memory_usage(\"After model allocation\", logger=logger)\n\n mixed_precision = MixedPrecision(\n param_dtype=torch.bfloat16, reduce_dtype=torch.float32, buffer_dtype=torch.float32\n )\n\n auto_wrap_policy = get_fsdp_wrap_policy(\n self.model,\n config=self.config.model.fsdp_config.wrap_policy,\n is_lora=self.lora,\n )\n\n if self.device_mesh.get_rank() == 0:\n print(auto_wrap_policy)\n\n if not self.config.model.fsdp_config.cpu_offload:\n cpu_offload = None\n else:\n cpu_offload = CPUOffload(offload_params=self.config.model.fsdp_config.offload_params)\n\n fsdp_strategy = self.config.model.strategy\n if fsdp_strategy == \"fsdp\":\n self.fsdp_model = FSDP(\n self.model,\n cpu_offload=cpu_offload,\n param_init_fn=init_fn,\n use_orig_params=False,\n auto_wrap_policy=auto_wrap_policy,\n device_id=get_device_id(),\n sharding_strategy=ShardingStrategy.FULL_SHARD,\n mixed_precision=mixed_precision,\n sync_module_states=True,\n device_mesh=self.device_mesh,\n forward_prefetch=False,\n )\n elif fsdp_strategy == \"fsdp2\":\n assert CPUOffloadPolicy is not None, \"PyTorch version >= 2.4 is required for using fully_shard API (FSDP2)\"\n mp_policy = MixedPrecisionPolicy(\n param_dtype=torch.bfloat16, reduce_dtype=torch.float32, cast_forward_inputs=True\n )\n\n fsdp_kwargs = {\n \"mesh\": self.device_mesh,\n \"mp_policy\": mp_policy,\n \"offload_policy\": cpu_offload,\n \"reshard_after_forward\": True,\n }\n full_state = self.model.state_dict()\n apply_fsdp2(self.model, fsdp_kwargs, self.config.model.fsdp_config)\n fsdp2_load_full_state_dict(self.model, full_state, self.device_mesh, cpu_offload)\n self.fsdp_model = self.model\n else:\n raise NotImplementedError(f\"not implement {fsdp_strategy}\")\n\n log_gpu_memory_usage(\"After FSDP wrapping\", logger=logger)\n\n self.optimizer = build_optimizer(self.fsdp_model.parameters(), self.config.optim)\n\n log_gpu_memory_usage(\"After initialize optimizer\", logger=logger)\n\n self.steps_per_epoch = len(self.train_dataloader)\n self.total_steps = self.steps_per_epoch * self.config.trainer.total_epochs\n\n if self.device_mesh.get_rank() == 0:\n print(\n f\"Number of steps/epoch {self.steps_per_epoch}, number of epochs \"\n f\"{self.config.trainer.total_epochs}, total number of steps {self.total_steps}\"\n )\n\n num_warmup_steps = int(self.total_steps * self.config.optim.lr_warmup_steps_ratio)\n\n if not hasattr(self.config.optim, \"lr_scheduler\") or self.config.optim.lr_scheduler == \"cosine\":\n self.lr_scheduler = get_cosine_schedule_with_warmup(\n optimizer=self.optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=self.total_steps\n )\n elif self.config.optim.lr_scheduler == \"wsd\":\n self.lr_scheduler = get_wsd_schedule_with_warmup(\n optimizer=self.optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=self.total_steps\n )\n else:\n raise ValueError(f\"Unknown lr scheduler: {self.config.optim.lr_scheduler}\")\n\n def _compute_loss_and_backward(self, batch, do_backward=True, n_micro_batches=1):\n \"\"\"Compute loss with optional sequence parallelism and remove padding features\"\"\"\n use_sp = self.use_remove_padding and self.config.ulysses_sequence_parallel_size > 1\n\n # Move inputs to GPU and prepare loss mask\n input_ids = batch[\"input_ids\"].to(self.device_name)\n attention_mask = batch[\"attention_mask\"].to(self.device_name)\n position_ids = batch[\"position_ids\"].to(self.device_name)\n loss_mask = batch.pop(\"loss_mask\")[:, 1:].reshape(-1).to(self.device_name)\n loss_fct = nn.CrossEntropyLoss(reduction=\"none\")\n\n # Context manager for sequence parallel if needed\n context = self.sharding_manager if use_sp else nullcontext()\n with context, torch.autocast(device_type=self.device_name, dtype=torch.bfloat16):\n if not use_sp:\n # Standard forward pass without sequence parallel\n labels = input_ids[:, 1:].contiguous()\n output = self.fsdp_model(\n input_ids=input_ids, attention_mask=attention_mask, position_ids=position_ids, use_cache=False\n )\n logits = output.logits\n\n shift_logits = logits[..., :-1, :].contiguous()\n shift_labels = labels.contiguous()\n # Flatten the tokens\n shift_logits = shift_logits.view(-1, self.model.config.vocab_size)\n shift_labels = shift_labels.view(-1)\n # Enable model parallelism\n shift_labels = shift_labels.to(shift_logits.device)\n loss = loss_fct(shift_logits, shift_labels)\n loss = loss * loss_mask.to(loss.device)\n else:\n # IMPORTANT: We have a big assumption here, so we can shard the SAME sequence across SP ranks\n # i.e., each GPU has <1 sequence, and each SP group has 1 sequence\n # 1. All SP ranks will receive the *SAME* batch\n # 2. Different SP groups will receive *DIFFERENT* batches\n # This is implemented by the DistributedSampler\n\n batch_size, seqlen = input_ids.shape\n # Remove padding\n input_ids_rmpad, indices, *_ = unpad_input(\n input_ids.unsqueeze(-1), attention_mask\n ) # input_ids_rmpad (total_nnz, ...)\n input_ids_rmpad = input_ids_rmpad.transpose(0, 1) # (1, total_nnz)\n\n # Unpad position_ids to align rotary\n position_ids_rmpad = index_first_axis(\n rearrange(position_ids.unsqueeze(-1), \"b s ... -> (b s) ...\"), indices\n ).transpose(0, 1)\n\n # Pad and slice inputs for sequence parallelism\n input_ids_rmpad_sliced, position_ids_rmpad_padded, pad_size = ulysses_pad_and_slice_inputs(\n input_ids_rmpad, position_ids_rmpad, sp_size=get_ulysses_sequence_parallel_world_size()\n )\n # For computing loss\n input_ids_rmpad_rolled = torch.roll(input_ids_rmpad, shifts=-1, dims=1) # (1, total_nnz)\n input_ids_rmpad_rolled, _, _ = ulysses_pad_and_slice_inputs(\n input_ids_rmpad_rolled, None, get_ulysses_sequence_parallel_world_size()\n )\n input_ids_rmpad_rolled = input_ids_rmpad_rolled.squeeze(0) # ((total_nnz / sp) + pad)\n\n # Forward pass\n output = self.fsdp_model(\n input_ids=input_ids_rmpad_sliced,\n attention_mask=None, # Not needed with flash attention varlen\n position_ids=position_ids_rmpad_padded,\n use_cache=False,\n )\n\n # Compute loss locally then aggregate\n logits_rmpad = output.logits.squeeze(0)\n input_ids_rmpad_rolled = input_ids_rmpad_rolled.to(logits_rmpad.device)\n loss = loss_fct(logits_rmpad, input_ids_rmpad_rolled)\n # Gather and unpad for sequence parallelism\n loss = gather_outputs_and_unpad(loss, gather_dim=0, unpad_dim=0, padding_size=pad_size)\n\n # This is the loss collected from all ulysses ranks\n full_loss = pad_input(\n hidden_states=loss.unsqueeze(-1), indices=indices, batch=batch_size, seqlen=seqlen\n )\n full_loss = full_loss.squeeze(-1)[:, :-1] # Remove last token's loss\n full_loss = full_loss.reshape(-1)\n loss_mask = loss_mask.to(full_loss.device)\n loss = full_loss * loss_mask\n\n valid_token_this_rank = torch.sum(loss_mask)\n\n if self.config.data.balance_dp_token:\n torch.distributed.all_reduce(valid_token_this_rank)\n dp_size = self.ulysses_device_mesh.size(\"dp\") if use_sp else torch.distributed.get_world_size()\n else:\n dp_size = 1\n\n loss = torch.sum(loss) / (valid_token_this_rank + 1e-8) * dp_size\n\n loss = loss / n_micro_batches # normalize loss\n\n if do_backward:\n loss.backward()\n return loss\n\n def training_step(self, batch: TensorDict):\n start_time = time.time()\n\n self.fsdp_model.train()\n\n log_gpu_memory_usage(\"Before optimizer zero_grad\", logger=logger)\n\n self.optimizer.zero_grad()\n\n log_gpu_memory_usage(\"After optimizer zero_grad\", logger=logger)\n\n micro_batches = batch.split(self.config.data.micro_batch_size_per_gpu)\n n_micro_batches = len(micro_batches)\n step_loss = 0\n for micro_batch in micro_batches:\n loss = self._compute_loss_and_backward(batch=micro_batch, n_micro_batches=n_micro_batches)\n step_loss += loss.item()\n\n if self.config.model.strategy == \"fsdp\":\n grad_norm = self.fsdp_model.clip_grad_norm_(max_norm=self.config.optim.clip_grad)\n elif self.config.model.strategy == \"fsdp2\":\n grad_norm = fsdp2_clip_grad_norm_(self.fsdp_model.parameters(), max_norm=self.config.optim.clip_grad)\n else:\n raise NotImplementedError(f\"not implement {self.config.model.strategy}\")\n\n log_gpu_memory_usage(\"Before optimizer step\", logger=logger)\n\n # if grad_norm is not finite, skip the update\n if not torch.isfinite(grad_norm):\n print(f\"WARN: grad_norm is not finite: {grad_norm}\")\n self.optimizer.zero_grad()\n else:\n self.optimizer.step()\n\n log_gpu_memory_usage(\"After optimizer step\", logger=logger)\n\n self.lr_scheduler.step()\n\n # reduce loss across dp ranks\n lr = self.lr_scheduler.get_last_lr()[0]\n\n log_gpu_memory_usage(\"After offload weights\", logger=logger)\n\n step_loss = torch.tensor(step_loss).to(self.device_name)\n\n # compute time spent per step\n end_time = time.time()\n spend_time_per_step = end_time - start_time\n\n if is_cuda_available:\n torch.distributed.all_reduce(step_loss, op=torch.distributed.ReduceOp.AVG)\n elif is_npu_available:\n torch.distributed.all_reduce(step_loss)\n step_loss /= self.device_mesh.size(0)\n return {\n \"train/loss\": step_loss.detach().item(),\n \"train/lr(1e-3)\": lr * 1e3,\n \"train/time(s)\": spend_time_per_step,\n }\n\n def validation_step(self, batch: TensorDict):\n self.fsdp_model.eval()\n with torch.no_grad():\n loss = self._compute_loss_and_backward(batch, do_backward=False)\n if is_cuda_available:\n torch.distributed.all_reduce(loss, op=torch.distributed.ReduceOp.AVG)\n elif is_npu_available:\n torch.distributed.all_reduce(loss)\n loss /= self.device_mesh.size(0)\n return loss\n\n def save_checkpoint(self, step):\n \"\"\"Save checkpoint using FSDPCheckpointManager with improved tracking\"\"\"\n from verl.utils.fs import local_mkdir_safe\n\n # Determine checkpoint path\n local_global_step_folder = os.path.join(self.config.trainer.default_local_dir, f\"global_step_{step}\")\n\n if self.device_mesh.get_rank() == 0:\n print(f\"Saving checkpoint to: {local_global_step_folder}\")\n\n # Get max checkpoints to keep\n max_ckpt_to_keep = getattr(self.config.trainer, \"max_ckpt_to_keep\", None)\n\n # Use checkpoint manager to save\n self.checkpoint_manager.save_checkpoint(\n local_path=local_global_step_folder, global_step=step, max_ckpt_to_keep=max_ckpt_to_keep\n )\n\n # Save dataloader state\n if self.device_mesh.get_rank() == 0:\n local_mkdir_safe(local_global_step_folder)\n dataloader_local_path = os.path.join(local_global_step_folder, \"data.pt\")\n\n # Use StatefulDataLoader's built-in state dict functionality\n dataloader_state_dict = self.train_dataloader.state_dict()\n torch.save(dataloader_state_dict, dataloader_local_path)\n print(f\"Saved dataloader state to: {dataloader_local_path}\")\n\n # Update latest checkpoint tracker (atomic write)\n tracker_file = get_checkpoint_tracker_filename(self.config.trainer.default_local_dir)\n temp_tracker_file = tracker_file + \".tmp\"\n with open(temp_tracker_file, \"w\") as f:\n f.write(str(step))\n os.rename(temp_tracker_file, tracker_file)\n print(f\"Updated checkpoint tracker: {tracker_file}\")\n\n # Copy to HDFS if configured\n if self.device_mesh.get_rank() == 0 and getattr(self.config.trainer, \"default_hdfs_dir\", None):\n hdfs_io.makedirs(self.config.trainer.default_hdfs_dir, exist_ok=True)\n hdfs_io.copy(src=local_global_step_folder, dst=self.config.trainer.default_hdfs_dir, dirs_exist_ok=True)\n\n torch.distributed.barrier()\n\n def _init_checkpoint_manager(self):\n \"\"\"Initialize checkpoint manager with proper configuration\"\"\"\n # Get checkpoint configuration from config, with defaults\n checkpoint_config = getattr(self.config.trainer, \"checkpoint\", {})\n\n # Set default values if not specified\n save_contents = checkpoint_config.get(\"save_contents\", [\"model\", \"optimizer\", \"extra\"])\n load_contents = checkpoint_config.get(\"load_contents\", save_contents)\n\n # Create checkpoint config dict\n checkpoint_config_dict = {\n \"load_contents\": load_contents,\n \"save_contents\": save_contents,\n }\n\n # Convert to DictConfig for compatibility\n checkpoint_config_dict = DictConfig(checkpoint_config_dict)\n\n # Initialize checkpoint manager\n self.checkpoint_manager = FSDPCheckpointManager(\n model=self.fsdp_model,\n optimizer=self.optimizer,\n lr_scheduler=self.lr_scheduler,\n processing_class=self.tokenizer,\n checkpoint_config=checkpoint_config_dict,\n trust_remote_code=self.config.model.trust_remote_code,\n )\n\n def load_checkpoint(self):\n # Determine resume path based on configuration\n checkpoint_path = self._determine_resume_path()\n\n if checkpoint_path is None:\n return 0\n\n # extract resume step from checkpoint path\n resume_step = extract_step(checkpoint_path)\n if resume_step is None:\n log_with_rank(\n f\"Warning: Could not extract step number from {checkpoint_path}, starting from step 0\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n level=logging.WARNING,\n log_only_rank_0=True,\n )\n return 0\n self.resume_global_step = resume_step\n\n # Use checkpoint manager to load model state\n self.checkpoint_manager.load_checkpoint(checkpoint_path)\n log_with_rank(\n f\"Successfully loaded model checkpoint from {checkpoint_path} (step {resume_step})\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n log_only_rank_0=True,\n )\n\n # Always load dataloader state for StatefulDataLoader\n self._load_dataloader_state(checkpoint_path)\n\n return resume_step\n\n def _load_dataloader_state(self, checkpoint_path: str):\n \"\"\"Load dataloader state from checkpoint\"\"\"\n dataloader_path = os.path.join(checkpoint_path, \"data.pt\")\n\n if os.path.exists(dataloader_path):\n # Use StatefulDataLoader's built-in state dict functionality\n dataloader_state_dict = torch.load(dataloader_path, map_location=\"cpu\", weights_only=False)\n self.train_dataloader.load_state_dict(dataloader_state_dict)\n\n log_with_rank(\n f\"Successfully loaded dataloader state from {dataloader_path}\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n log_only_rank_0=True,\n )\n\n else:\n log_with_rank(\n f\"Warning: No dataloader state found at {dataloader_path}, will start from scratch\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n level=logging.WARNING,\n log_only_rank_0=True,\n )\n\n def _determine_resume_path(self):\n \"\"\"Determine the path to resume from based on resume_mode configuration\"\"\"\n resume_mode = getattr(self.config.trainer, \"resume_mode\", \"auto\")\n resume_from_path = getattr(self.config.trainer, \"resume_from_path\", None)\n\n if resume_mode == \"disable\":\n return None\n elif resume_mode == \"auto\":\n if resume_from_path is not None:\n assert os.path.exists(resume_from_path), (\n \"resume_from_path must be null or an existing path when resume_mode is 'auto'\"\n )\n assert \"global_step_\" in resume_from_path, \"resume_from_path must specify the global_steps\"\n return resume_from_path\n # Try to find the latest checkpoint in the default directory\n return self._find_latest_checkpoint()\n elif resume_mode == \"resume_path\":\n assert os.path.exists(resume_from_path), (\n \"resume_from_path must be an existing path when resume_mode is 'resume_path'\"\n )\n assert \"global_step_\" in resume_from_path, \"resume_from_path must specify the global_steps\"\n return resume_from_path\n else:\n raise ValueError(f\"Invalid resume_mode: {resume_mode}. Must be 'auto', 'disable', or 'resume_path'\")\n\n def _find_latest_checkpoint(self):\n \"\"\"Find the latest checkpoint in the default local directory\"\"\"\n checkpoint_dir = self.config.trainer.default_local_dir\n\n if not os.path.exists(checkpoint_dir):\n return None\n\n latest_checkpoint = find_latest_ckpt_path(checkpoint_dir)\n\n if latest_checkpoint and self.device_mesh.get_rank() == 0:\n step_num = extract_step(latest_checkpoint)\n print(f\"Found latest checkpoint: {latest_checkpoint} (step {step_num})\")\n\n return latest_checkpoint\n\n def fit(self):\n rank = self.device_mesh.get_rank()\n\n # TODO: add a unified tracking\n if rank == 0:\n tracking = Tracking(\n project_name=self.config.trainer.project_name,\n experiment_name=self.config.trainer.experiment_name,\n default_backend=self.config.trainer.logger,\n config=OmegaConf.to_container(self.config, resolve=True),\n )\n\n global_step = self.resume_global_step # Start from resumed step\n last_valid_metric = None\n # compute the total training steps.\n # the total training steps in SFT is mainly for early exit\n total_training_steps = len(self.train_dataloader) * self.config.trainer.total_epochs\n\n if self.config.trainer.total_training_steps is not None:\n total_training_steps = self.config.trainer.total_training_steps\n\n self.total_training_steps = total_training_steps\n log_with_rank(\n f\"Total training steps: {self.total_training_steps},\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n log_only_rank_0=True,\n )\n\n # With StatefulDataLoader, we don't need to manually calculate epochs and steps\n # The dataloader will automatically resume from where it left off\n if global_step > 0:\n log_with_rank(\n f\"StatefulDataLoader will automatically resume from global step: {global_step}\",\n logger=logger,\n rank=self.device_mesh.get_rank(),\n log_only_rank_0=True,\n )\n\n # Calculate which epoch we're starting from for sampler.set_epoch()\n start_epoch = global_step // self.steps_per_epoch\n\n train_time = 0\n for epoch in range(start_epoch, self.config.trainer.total_epochs):\n self.train_sampler.set_epoch(epoch=epoch)\n\n for step_in_epoch, data in enumerate(\n tqdm(\n self.train_dataloader,\n initial=global_step % self.steps_per_epoch if epoch == start_epoch else 0,\n total=self.steps_per_epoch,\n desc=f\"Epoch {epoch + 1}/{self.config.trainer.total_epochs}\",\n disable=rank != 0,\n )\n ):\n global_step += 1\n data = TensorDict(data, batch_size=self.config.data.train_batch_size).to(self.device_name)\n metric = self.training_step(data)\n train_time += metric[\"train/time(s)\"]\n if rank == 0:\n tracking.log(data=metric, step=global_step)\n\n is_last_step = global_step >= self.total_training_steps\n is_valid_step = global_step % self.config.trainer.test_freq == 0\n is_save_step = global_step % self.config.trainer.save_freq == 0\n\n # early exit or validation step\n if is_last_step or (self.config.trainer.test_freq > 0 and is_valid_step):\n # Perform validation\n val_losses = []\n for val_data in self.val_dataloader:\n val_data = TensorDict(val_data, batch_size=self.config.data.micro_batch_size_per_gpu).to(\n self.device_name\n )\n val_loss = self.validation_step(val_data)\n val_losses.append(val_loss)\n if rank == 0:\n val_loss = torch.mean(torch.stack(val_losses))\n metric = {\"val/loss\": val_loss.detach().item()}\n tracking.log(data=metric, step=global_step)\n last_valid_metric = metric\n torch.distributed.barrier()\n\n if is_last_step or (self.config.trainer.save_freq > 0 and is_save_step):\n self.save_checkpoint(step=global_step)\n\n if is_last_step:\n if rank == 0:\n print(f\"Total time for train steps: {train_time:.2f}s\")\n print(f\"Final validation metrics: {last_valid_metric}\")\n return\n\n\ndef run_sft(config):\n device_name = get_device_name()\n local_rank, rank, world_size = initialize_global_process_group()\n\n device_mesh = init_device_mesh(device_type=device_name, mesh_shape=(world_size,), mesh_dim_names=(\"fsdp\",))\n dp_size = world_size // config.ulysses_sequence_parallel_size\n ulysses_device_mesh = init_device_mesh(\n device_type=device_name,\n mesh_shape=(dp_size, config.ulysses_sequence_parallel_size),\n mesh_dim_names=(\"dp\", \"sp\"),\n )\n # build tokenizer and datasets first\n from verl.utils import hf_tokenizer\n\n local_model_path = copy_to_local(src=config.model.partial_pretrain, verbose=True)\n tokenizer = hf_tokenizer(local_model_path, trust_remote_code=config.model.trust_remote_code)\n train_dataset = create_sft_dataset(\n config.data.train_files, config.data, tokenizer, max_samples=config.data.get(\"train_max_samples\", -1)\n )\n val_dataset = create_sft_dataset(\n config.data.val_files, config.data, tokenizer, max_samples=config.data.get(\"val_max_samples\", -1)\n )\n\n trainer = FSDPSFTTrainer(\n config=config,\n device_mesh=device_mesh,\n ulysses_device_mesh=ulysses_device_mesh,\n tokenizer=tokenizer,\n train_dataset=train_dataset,\n val_dataset=val_dataset,\n )\n\n trainer.fit()\n\n destroy_global_process_group()\n\n\n@hydra.main(config_path=\"config\", config_name=\"sft_trainer\", version_base=None)\ndef main(config):\n # Automatically set `config.trainer.device = npu` when running on Ascend NPU.\n auto_set_device(config)\n\n run_sft(config)\n\n\ndef create_sft_dataset(data_paths, data_config, tokenizer, max_samples=-1):\n \"\"\"Create a dataset.\"\"\"\n # build dataset\n # First check if a custom dataset class is specified\n if data_config.custom_cls.get(\"path\", None):\n from verl.utils.import_utils import load_extern_object\n\n dataset_cls = load_extern_object(data_config.custom_cls.path, data_config.custom_cls.name)\n # Then check if multi-turn dataset should be used\n elif data_config.get(\"multiturn\", {}).get(\"enable\", False):\n dataset_cls = MultiTurnSFTDataset\n # Default to single-turn dataset\n else:\n dataset_cls = SFTDataset\n\n # Create datasets based on the selected class\n dataset = dataset_cls(parquet_files=data_paths, tokenizer=tokenizer, config=data_config, max_samples=max_samples)\n return dataset\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__trainer__main_eval.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nOffline evaluate the performance of a generated file using reward model and ground truth verifier.\nThe input is a parquet file that contains N generated sequences and (optional) the ground truth.\n\n\"\"\"\n\nfrom collections import defaultdict\n\nimport hydra\nimport numpy as np\nimport pandas as pd\nimport ray\nfrom omegaconf import OmegaConf\nfrom tqdm import tqdm\n\nfrom verl.trainer.ppo.reward import get_custom_reward_fn\nfrom verl.utils.fs import copy_to_local\n\n\n@ray.remote\ndef process_item(config, data_source, response_lst, reward_data):\n reward_fn = get_custom_reward_fn(config)\n ground_truth = reward_data[\"ground_truth\"]\n score_lst = [reward_fn(data_source, r, ground_truth) for r in response_lst]\n return data_source, np.mean(score_lst)\n\n\n@hydra.main(config_path=\"config\", config_name=\"evaluation\", version_base=None)\ndef main(config):\n local_path = copy_to_local(config.data.path, use_shm=config.data.get(\"use_shm\", False))\n dataset = pd.read_parquet(local_path)\n responses = dataset[config.data.response_key]\n data_sources = dataset[config.data.data_source_key]\n reward_model_data = dataset[config.data.reward_model_key]\n\n total = len(dataset)\n\n # Initialize Ray\n if not ray.is_initialized():\n ray.init(**OmegaConf.to_container(config.ray_kwargs.get(\"ray_init\", {})))\n\n # evaluate test_score based on data source\n data_source_reward = defaultdict(list)\n # Create remote tasks\n remote_tasks = [\n process_item.remote(config, data_sources[i], responses[i], reward_model_data[i]) for i in range(total)\n ]\n\n # Process results as they come in\n with tqdm(total=total) as pbar:\n while len(remote_tasks) > 0:\n # Use ray.wait to get completed tasks\n done_ids, remote_tasks = ray.wait(remote_tasks)\n for result_id in done_ids:\n data_source, score = ray.get(result_id)\n data_source_reward[data_source].append(score)\n pbar.update(1)\n\n metric_dict = {}\n for data_source, rewards in data_source_reward.items():\n metric_dict[f\"test_score/{data_source}\"] = np.mean(rewards)\n\n print(metric_dict)\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__trainer__main_generation.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nGenerate responses given a dataset of prompts\n\"\"\"\n\nimport os\n\nimport hydra\nimport numpy as np\nimport ray\n\nos.environ[\"NCCL_DEBUG\"] = \"WARN\"\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\n# os.environ['TORCH_COMPILE_DISABLE'] = '1'\n\nfrom pprint import pprint\n\nimport pandas as pd\nfrom omegaconf import OmegaConf\n\nfrom verl import DataProto\nfrom verl.protocol import pad_dataproto_to_divisor, unpad_dataproto\nfrom verl.single_controller.ray import RayClassWithInitArgs, RayResourcePool, RayWorkerGroup\nfrom verl.utils import hf_tokenizer\nfrom verl.utils.fs import copy_to_local\nfrom verl.utils.hdfs_io import makedirs\nfrom verl.utils.model import compute_position_id_with_mask\nfrom verl.workers.fsdp_workers import ActorRolloutRefWorker\n\n\n@hydra.main(config_path=\"config\", config_name=\"generation\", version_base=None)\ndef main(config):\n run_generation(config)\n\n\ndef run_generation(config) -> None:\n if not ray.is_initialized():\n # this is for local ray cluster\n default_runtime_env = {\"env_vars\": {\"TOKENIZERS_PARALLELISM\": \"true\", \"NCCL_DEBUG\": \"WARN\"}}\n ray_init_kwargs = config.ray_kwargs.get(\"ray_init\", {})\n runtime_env_kwargs = ray_init_kwargs.get(\"runtime_env\", {})\n runtime_env = OmegaConf.merge(default_runtime_env, runtime_env_kwargs)\n ray_init_kwargs = OmegaConf.create({**ray_init_kwargs, \"runtime_env\": runtime_env})\n print(f\"ray init kwargs: {ray_init_kwargs}\")\n ray.init(**OmegaConf.to_container(ray_init_kwargs))\n\n ray.get(main_task.remote(config))\n\n\n@ray.remote(num_cpus=1)\ndef main_task(config):\n pprint(OmegaConf.to_container(config, resolve=True)) # resolve=True will eval symbol values\n OmegaConf.resolve(config)\n\n local_path = copy_to_local(config.model.path)\n trust_remote_code = config.data.get(\"trust_remote_code\", False)\n tokenizer = hf_tokenizer(local_path, trust_remote_code=trust_remote_code)\n\n if config.rollout.temperature == 0.0:\n assert config.data.n_samples == 1, \"When temperature=0, n_samples must be 1.\"\n assert config.data.n_samples >= 1, \"n_samples should always >= 1\"\n\n # read dataset. Note that the dataset should directly contain chat template format (e.g., a list of dictionary)\n dataset = pd.read_parquet(config.data.path)\n chat_lst = dataset[config.data.prompt_key].tolist()\n\n chat_lst = [chat.tolist() for chat in chat_lst]\n\n tokenizer.padding_side = \"left\"\n if tokenizer.pad_token is None:\n tokenizer.pad_token = tokenizer.eos_token\n\n ray_cls_with_init = RayClassWithInitArgs(cls=ray.remote(ActorRolloutRefWorker), config=config, role=\"rollout\")\n resource_pool = RayResourcePool(process_on_nodes=[config.trainer.n_gpus_per_node] * config.trainer.nnodes)\n\n wg = RayWorkerGroup(\n resource_pool=resource_pool,\n ray_cls_with_init=ray_cls_with_init,\n device_name=config.trainer.device,\n )\n wg.init_model()\n\n total_samples = len(dataset)\n config_batch_size = config.data.batch_size\n apply_chat_template_kwargs = config.data.get(\"apply_chat_template_kwargs\", {})\n num_batch = -(-total_samples // config_batch_size)\n output_lst = [[] for _ in range(config.data.n_samples)]\n\n for batch_idx in range(num_batch):\n print(f\"[{batch_idx + 1}/{num_batch}] Start to process.\")\n batch_chat_lst = chat_lst[batch_idx * config_batch_size : (batch_idx + 1) * config_batch_size]\n inputs = tokenizer.apply_chat_template(\n batch_chat_lst,\n add_generation_prompt=True,\n padding=True,\n truncation=True,\n max_length=config.rollout.prompt_length,\n return_tensors=\"pt\",\n return_dict=True,\n tokenize=True,\n **apply_chat_template_kwargs,\n )\n input_ids = inputs[\"input_ids\"]\n attention_mask = inputs[\"attention_mask\"]\n position_ids = compute_position_id_with_mask(attention_mask)\n batch_dict = {\"input_ids\": input_ids, \"attention_mask\": attention_mask, \"position_ids\": position_ids}\n\n data = DataProto.from_dict(batch_dict)\n data_padded, pad_size = pad_dataproto_to_divisor(data, wg.world_size)\n\n # START TO GENERATE FOR n_samples TIMES\n print(f\"[{batch_idx + 1}/{num_batch}] Start to generate.\")\n for n_sample in range(config.data.n_samples):\n output_padded = wg.generate_sequences(data_padded)\n output = unpad_dataproto(output_padded, pad_size=pad_size)\n\n output_texts = []\n for i in range(len(output)):\n data_item = output[i]\n prompt_length = data_item.batch[\"prompts\"].shape[-1]\n valid_response_length = data_item.batch[\"attention_mask\"][prompt_length:].sum()\n valid_response_ids = data_item.batch[\"responses\"][:valid_response_length]\n response_str = tokenizer.decode(valid_response_ids, skip_special_tokens=True)\n output_texts.append(response_str)\n\n output_lst[n_sample].extend(output_texts)\n\n # convert output_lst from (n_samples, n_data) to (n_data, n_sampels)\n output_lst = np.array(output_lst, dtype=object)\n output_lst = np.transpose(output_lst, axes=(1, 0)).tolist()\n\n # add to the data frame\n dataset[\"responses\"] = output_lst\n\n # write to a new parquet\n output_dir = os.path.dirname(config.data.output_path)\n makedirs(output_dir, exist_ok=True)\n dataset.to_parquet(config.data.output_path)\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__trainer__main_generation_server.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nGenerate responses given a dataset of prompts\n\"\"\"\n\nimport os\n\nimport aiohttp\nimport hydra\nimport numpy as np\nimport ray\n\nos.environ[\"NCCL_DEBUG\"] = \"WARN\"\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\n# os.environ['TORCH_COMPILE_DISABLE'] = '1'\n\nimport asyncio\nfrom pprint import pprint\n\nimport pandas as pd\nfrom omegaconf import OmegaConf\nfrom openai.types.chat import ChatCompletion\n\nfrom verl.utils.hdfs_io import makedirs\nfrom verl.workers.rollout.replica import get_rollout_replica_class\n\n\nasync def start_server(config):\n tp_size = config.actor_rollout_ref.rollout.tensor_model_parallel_size\n num_replicas = (config.trainer.n_gpus_per_node * config.trainer.nnodes) // tp_size\n rollout_config = config.actor_rollout_ref.rollout\n model_config = config.actor_rollout_ref.model\n # create standalone rollout server\n rollout_server_class = get_rollout_replica_class(config.actor_rollout_ref.rollout.name)\n rollout_servers = [\n rollout_server_class(\n replica_rank=replica_rank,\n config=rollout_config,\n model_config=model_config,\n gpus_per_node=config.trainer.n_gpus_per_node,\n )\n for replica_rank in range(num_replicas)\n ]\n await asyncio.gather(*[server.init_standalone() for server in rollout_servers])\n\n server_handles = [server._server_handle for server in rollout_servers]\n server_addresses = [server._server_address for server in rollout_servers]\n assert len(server_handles) == num_replicas\n assert len(server_addresses) == num_replicas\n\n return server_handles, server_addresses\n\n\nasync def submit_request(server_address, **chat_complete_request):\n try:\n extra_headers = chat_complete_request.pop(\"extra_headers\", {})\n timeout = aiohttp.ClientTimeout(total=None)\n session = aiohttp.ClientSession(timeout=timeout)\n async with session.post(\n url=f\"http://{server_address}/v1/chat/completions\",\n headers={\"Authorization\": \"Bearer token-abc123\", **extra_headers},\n json=chat_complete_request,\n ) as resp:\n data = await resp.json()\n return ChatCompletion(**data)\n finally:\n await session.close()\n\n\nasync def generate_per_replica(server_address, model_path: str, n_samples: int, sampling_params: dict, chat_lst: list):\n # here we should sample n_samples for each chat_lst.\n # we use aiohttp to avoid hang in AsyncOpenAI when the number of requests is large.\n\n # client = AsyncOpenAI(\n # api_key=\"123-abc\",\n # base_url=f\"http://{server_address}/v1\",\n # )\n\n chat_complete_request = [\n {\n \"model\": model_path,\n \"messages\": messages,\n **sampling_params,\n }\n for messages in chat_lst\n for _ in range(n_samples)\n ]\n\n tasks = [submit_request(server_address, **req) for req in chat_complete_request]\n results = await asyncio.gather(*tasks)\n return results\n\n\nasync def generate(\n server_addresses: list, model_path: str, n_samples: int, sampling_params: dict, chat_numpy: np.ndarray\n):\n num_replicas = len(server_addresses)\n chat_sub_array = np.array_split(chat_numpy, num_replicas)\n chat_sub_array = [chat.tolist() for chat in chat_sub_array]\n assert len(server_addresses) == len(chat_sub_array)\n results = await asyncio.gather(\n *[\n generate_per_replica(server_addresses[i], model_path, n_samples, sampling_params, chat_sub_array[i])\n for i in range(num_replicas)\n ]\n )\n return results\n\n\n@hydra.main(config_path=\"config\", config_name=\"ppo_trainer\", version_base=None)\ndef main(config):\n ray.init(runtime_env={\"env_vars\": {\"TOKENIZERS_PARALLELISM\": \"true\", \"NCCL_DEBUG\": \"WARN\", \"VLLM_USE_V1\": \"1\"}})\n\n pprint(OmegaConf.to_container(config, resolve=True)) # resolve=True will eval symbol values\n OmegaConf.resolve(config)\n\n n_samples = config.actor_rollout_ref.rollout.n\n\n if config.actor_rollout_ref.rollout.temperature == 0.0:\n assert n_samples == 1, \"When temperature=0, n_samples must be 1.\"\n assert n_samples >= 1, \"n_samples should always >= 1\"\n\n sampling_params = {\n \"temperature\": config.actor_rollout_ref.rollout.temperature,\n \"top_p\": config.actor_rollout_ref.rollout.top_p,\n # \"top_k\": config.actor_rollout_ref.rollout.top_k,\n \"max_tokens\": config.actor_rollout_ref.rollout.response_length,\n }\n\n from omegaconf import ListConfig\n\n train_files = config.data.train_files\n if not isinstance(train_files, list | ListConfig):\n train_files = [train_files]\n\n # read dataset. Note that the dataset should directly contain chat template format (e.g., a list of dictionary)\n\n datasets = []\n for train_file in train_files:\n dataset = pd.read_parquet(train_file)\n datasets.append(dataset)\n\n # concat dataset\n dataset = pd.concat(datasets, axis=0, ignore_index=True)\n chat_lst = dataset[config.data.prompt_key].tolist()\n chat_lst = [chat.tolist() for chat in chat_lst]\n chat_numpy = np.array(chat_lst)\n\n # start native server\n server_handles, server_addresses = asyncio.run(start_server(config))\n\n # run generate\n gen_results = asyncio.run(\n generate(server_addresses, config.actor_rollout_ref.model.path, n_samples, sampling_params, chat_numpy)\n )\n\n # reshape results into a numpy array\n import itertools\n\n results = list(itertools.chain.from_iterable(gen_results))\n\n # extract content from results\n results = np.array([result.choices[0].message.content for result in results])\n results = np.reshape(results, (-1, n_samples))\n\n assert results.shape == (len(chat_lst), n_samples)\n\n results = results.tolist()\n\n # add to the data frame\n dataset[\"responses\"] = results\n\n # write to a new parquet\n output_dir = os.path.dirname(config.data.output_path)\n makedirs(output_dir, exist_ok=True)\n print(f\"Saving results to {config.data.output_path}\")\n dataset.to_parquet(config.data.output_path)\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__trainer__main_ppo.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nNote that we don't combine the main with ray_trainer as ray_trainer is used by other mpain.\n\"\"\"\n\nimport os\nimport socket\n\nimport hydra\nimport ray\nfrom omegaconf import OmegaConf\n\nfrom verl.experimental.dataset.sampler import AbstractSampler\nfrom verl.experimental.reward_loop import migrate_legacy_reward_impl\nfrom verl.trainer.constants_ppo import get_ppo_ray_runtime_env\nfrom verl.trainer.ppo.ray_trainer import RayPPOTrainer\nfrom verl.trainer.ppo.utils import need_critic, need_reference_policy\nfrom verl.utils.config import validate_config\nfrom verl.utils.device import auto_set_device, is_cuda_available\nfrom verl.utils.import_utils import load_extern_object\n\n\n@hydra.main(config_path=\"config\", config_name=\"ppo_trainer\", version_base=None)\ndef main(config):\n \"\"\"Main entry point for PPO training with Hydra configuration management.\n\n Args:\n config: Hydra configuration dictionary containing training parameters.\n \"\"\"\n # Automatically set `config.trainer.device = npu` when running on Ascend NPU.\n auto_set_device(config)\n config = migrate_legacy_reward_impl(config)\n run_ppo(config)\n\n\n# Define a function to run the PPO-like training process\ndef run_ppo(config, task_runner_class=None) -> None:\n \"\"\"Initialize Ray cluster and run distributed PPO training process.\n\n Args:\n config: Training configuration object containing all necessary parameters\n for distributed PPO training including Ray initialization settings,\n model paths, and training hyperparameters.\n task_runner_class: For recipe to change TaskRunner.\n \"\"\"\n # Check if Ray is not initialized\n if not ray.is_initialized():\n # Initialize Ray with a local cluster configuration\n # Set environment variables in the runtime environment to control tokenizer parallelism,\n # NCCL debug level, VLLM logging level, and allow runtime LoRA updating\n # `num_cpus` specifies the number of CPU cores Ray can use, obtained from the configuration\n default_runtime_env = get_ppo_ray_runtime_env()\n ray_init_kwargs = config.ray_kwargs.get(\"ray_init\", {})\n runtime_env_kwargs = ray_init_kwargs.get(\"runtime_env\", {})\n\n if config.transfer_queue.enable:\n # Add runtime environment variables for transfer queue\n runtime_env_vars = runtime_env_kwargs.get(\"env_vars\", {})\n runtime_env_vars[\"TRANSFER_QUEUE_ENABLE\"] = \"1\"\n runtime_env_kwargs[\"env_vars\"] = runtime_env_vars\n\n runtime_env = OmegaConf.merge(default_runtime_env, runtime_env_kwargs)\n ray_init_kwargs = OmegaConf.create({**ray_init_kwargs, \"runtime_env\": runtime_env})\n print(f\"ray init kwargs: {ray_init_kwargs}\")\n ray.init(**OmegaConf.to_container(ray_init_kwargs))\n\n if task_runner_class is None:\n task_runner_class = ray.remote(num_cpus=1)(TaskRunner) # please make sure main_task is not scheduled on head\n\n # Create a remote instance of the TaskRunner class, and\n # Execute the `run` method of the TaskRunner instance remotely and wait for it to complete\n if (\n is_cuda_available\n and config.global_profiler.tool == \"nsys\"\n and config.global_profiler.get(\"steps\") is not None\n and len(config.global_profiler.get(\"steps\", [])) > 0\n ):\n from verl.utils.import_utils import is_nvtx_available\n\n assert is_nvtx_available(), \"nvtx is not available in CUDA platform. Please 'pip3 install nvtx'\"\n nsight_options = OmegaConf.to_container(\n config.global_profiler.global_tool_config.nsys.controller_nsight_options\n )\n runner = task_runner_class.options(runtime_env={\"nsight\": nsight_options}).remote()\n else:\n runner = task_runner_class.remote()\n ray.get(runner.run.remote(config))\n\n # [Optional] get the path of the timeline trace file from the configuration, default to None\n # This file is used for performance analysis\n timeline_json_file = config.ray_kwargs.get(\"timeline_json_file\", None)\n if timeline_json_file:\n ray.timeline(filename=timeline_json_file)\n\n\nclass TaskRunner:\n \"\"\"Ray remote class for executing distributed PPO training tasks.\n\n This class encapsulates the main training logic and runs as a Ray remote actor\n to enable distributed execution across multiple nodes and GPUs.\n\n Attributes:\n role_worker_mapping: Dictionary mapping Role enums to Ray remote worker classes\n mapping: Dictionary mapping Role enums to resource pool IDs for GPU allocation\n \"\"\"\n\n def __init__(self):\n self.role_worker_mapping = {}\n self.mapping = {}\n\n def add_actor_rollout_worker(self, config):\n \"\"\"Add actor rollout worker based on the actor strategy.\"\"\"\n from verl.single_controller.ray import RayWorkerGroup\n from verl.trainer.ppo.ray_trainer import Role\n\n use_legacy_worker_impl = config.trainer.get(\"use_legacy_worker_impl\", \"auto\")\n\n # use new model engine implementation\n if use_legacy_worker_impl == \"disable\":\n from verl.workers.engine_workers import ActorRolloutRefWorker\n\n actor_rollout_cls = ActorRolloutRefWorker\n ray_worker_group_cls = RayWorkerGroup\n\n lora_rank = config.actor_rollout_ref.model.get(\"lora\", {}).get(\"rank\", 0)\n if lora_rank <= 0:\n lora_rank = config.actor_rollout_ref.model.get(\"lora_rank\", 0)\n ref_in_actor = lora_rank > 0 or config.actor_rollout_ref.model.get(\"lora_adapter_path\") is not None\n # NOTE: In new model engine, ref policy and actor rollout are in same ActorRolloutRefWorker,\n # while in legacy model engine, ref policy is in a separate ActorRolloutRefWorker.\n if need_reference_policy(config) and not ref_in_actor:\n role = Role.ActorRolloutRef\n else:\n role = Role.ActorRollout\n self.role_worker_mapping[role] = ray.remote(actor_rollout_cls)\n self.mapping[role] = \"global_pool\"\n return actor_rollout_cls, ray_worker_group_cls\n\n # Note: sync mode validation is now handled in RolloutConfig.__post_init__\n # Always use async worker since sync mode is deprecated and rejected\n if config.actor_rollout_ref.actor.strategy in {\"fsdp\", \"fsdp2\"}:\n from verl.workers.fsdp_workers import AsyncActorRolloutRefWorker\n\n actor_rollout_cls = AsyncActorRolloutRefWorker\n ray_worker_group_cls = RayWorkerGroup\n\n elif config.actor_rollout_ref.actor.strategy == \"megatron\":\n from verl.workers.megatron_workers import AsyncActorRolloutRefWorker\n\n actor_rollout_cls = AsyncActorRolloutRefWorker\n ray_worker_group_cls = RayWorkerGroup\n\n elif config.actor_rollout_ref.actor.strategy == \"veomni\":\n raise NotImplementedError(\"VeOmni does not support legacy worker implementation\")\n\n else:\n raise NotImplementedError\n\n self.role_worker_mapping[Role.ActorRollout] = ray.remote(actor_rollout_cls)\n self.mapping[Role.ActorRollout] = \"global_pool\"\n return actor_rollout_cls, ray_worker_group_cls\n\n def add_critic_worker(self, config):\n \"\"\"Add critic worker to role mapping.\"\"\"\n use_legacy_worker_impl = config.trainer.get(\"use_legacy_worker_impl\", \"auto\")\n if config.critic.strategy in {\"fsdp\", \"fsdp2\"}:\n if use_legacy_worker_impl in [\"auto\", \"enable\"]:\n from verl.workers.fsdp_workers import CriticWorker\n elif use_legacy_worker_impl == \"disable\":\n # we don't need to specialize critic worker. Just use TrainingWorker\n from verl.workers.engine_workers import TrainingWorker\n\n CriticWorker = TrainingWorker\n print(\"Using new worker implementation\")\n else:\n raise ValueError(f\"Invalid use_legacy_worker_impl: {use_legacy_worker_impl}\")\n\n elif config.critic.strategy == \"megatron\":\n # TODO: switch this to TrainingWorker as well\n from verl.workers.megatron_workers import CriticWorker\n\n elif config.critic.strategy == \"veomni\":\n if use_legacy_worker_impl == \"disable\":\n from verl.workers.engine_workers import TrainingWorker\n\n CriticWorker = TrainingWorker\n print(\"Using new worker implementation\")\n else:\n raise ValueError(f\"Invalid use_legacy_worker_impl: {use_legacy_worker_impl}\")\n\n else:\n raise NotImplementedError\n\n from verl.trainer.ppo.ray_trainer import Role\n\n self.role_worker_mapping[Role.Critic] = ray.remote(CriticWorker)\n self.mapping[Role.Critic] = \"global_pool\"\n\n def init_resource_pool_mgr(self, config):\n \"\"\"Initialize resource pool manager.\"\"\"\n\n global_pool_id = \"global_pool\"\n resource_pool_spec = {\n global_pool_id: [config.trainer.n_gpus_per_node] * config.trainer.nnodes,\n }\n\n if config.reward.reward_model.enable_resource_pool:\n if config.reward.reward_model.n_gpus_per_node <= 0:\n raise ValueError(\"config.reward.reward_model.n_gpus_per_node must be greater than 0\")\n if config.reward.reward_model.nnodes <= 0:\n raise ValueError(\"config.reward.reward_model.nnodes must be greater than 0\")\n\n reward_pool = [config.reward.reward_model.n_gpus_per_node] * config.reward.reward_model.nnodes\n resource_pool_spec[\"reward_pool\"] = reward_pool\n else:\n config.reward.reward_model.nnodes = config.trainer.nnodes\n config.reward.reward_model.n_gpus_per_node = config.trainer.n_gpus_per_node\n\n from verl.trainer.ppo.ray_trainer import ResourcePoolManager\n\n resource_pool_manager = ResourcePoolManager(resource_pool_spec=resource_pool_spec, mapping=self.mapping)\n return resource_pool_manager\n\n def add_reward_model_resource_pool(self, config):\n \"\"\"Add reward model worker if enabled.\"\"\"\n from verl.trainer.ppo.ray_trainer import Role\n\n if config.reward.reward_model.enable:\n # we do not use reward model workers, so we only register reward model in resource pool\n # without continue to register reward model worker in role mapping\n if config.reward.reward_model.enable_resource_pool:\n self.mapping[Role.RewardModel] = \"reward_pool\"\n else:\n self.mapping[Role.RewardModel] = \"global_pool\"\n\n def add_ref_policy_worker(self, config, ref_policy_cls):\n \"\"\"Add reference policy worker if KL loss or KL reward is used.\"\"\"\n from verl.trainer.ppo.ray_trainer import Role\n\n # Ref policy has been fused into ActorRolloutRefWorker in new model engine,\n # we don't need to add a separate ref policy worker group.\n use_legacy_worker_impl = config.trainer.get(\"use_legacy_worker_impl\", \"auto\")\n if use_legacy_worker_impl == \"disable\":\n return\n\n if need_reference_policy(config):\n self.role_worker_mapping[Role.RefPolicy] = ray.remote(ref_policy_cls)\n self.mapping[Role.RefPolicy] = \"global_pool\"\n\n def run(self, config):\n \"\"\"Execute the main PPO training workflow.\n\n This method sets up the distributed training environment, initializes\n workers, datasets, and reward functions, then starts the training process.\n\n Args:\n config: Training configuration object containing all parameters needed\n for setting up and running the PPO training process.\n \"\"\"\n # Print the initial configuration. `resolve=True` will evaluate symbolic values.\n from pprint import pprint\n\n from omegaconf import OmegaConf\n\n from verl.utils.fs import copy_to_local\n\n print(f\"TaskRunner hostname: {socket.gethostname()}, PID: {os.getpid()}\")\n pprint(OmegaConf.to_container(config, resolve=True))\n OmegaConf.resolve(config)\n\n actor_rollout_cls, ray_worker_group_cls = self.add_actor_rollout_worker(config)\n self.add_critic_worker(config)\n\n self.add_reward_model_resource_pool(config)\n\n # Add a reference policy worker if KL loss or KL reward is used.\n self.add_ref_policy_worker(config, actor_rollout_cls)\n\n # validate config\n validate_config(\n config=config,\n use_reference_policy=need_reference_policy(config),\n use_critic=need_critic(config),\n )\n\n # Download the checkpoint from HDFS to the local machine.\n # `use_shm` determines whether to use shared memory, which could lead to faster model loading if turned on\n local_path = copy_to_local(\n config.actor_rollout_ref.model.path, use_shm=config.actor_rollout_ref.model.get(\"use_shm\", False)\n )\n\n # Instantiate the tokenizer and processor.\n from verl.utils import hf_processor, hf_tokenizer\n\n trust_remote_code = config.data.get(\"trust_remote_code\", False)\n tokenizer = hf_tokenizer(local_path, trust_remote_code=trust_remote_code)\n # Used for multimodal LLM, could be None\n processor = hf_processor(local_path, trust_remote_code=trust_remote_code, use_fast=True)\n\n resource_pool_manager = self.init_resource_pool_mgr(config)\n\n from verl.utils.dataset.rl_dataset import collate_fn\n\n # Create training and validation datasets.\n train_dataset = create_rl_dataset(\n config.data.train_files,\n config.data,\n tokenizer,\n processor,\n is_train=True,\n max_samples=config.data.get(\"train_max_samples\", -1),\n )\n val_dataset = create_rl_dataset(\n config.data.val_files,\n config.data,\n tokenizer,\n processor,\n is_train=False,\n max_samples=config.data.get(\"val_max_samples\", -1),\n )\n train_sampler = create_rl_sampler(config.data, train_dataset)\n\n # Initialize the PPO trainer.\n trainer = RayPPOTrainer(\n config=config,\n tokenizer=tokenizer,\n processor=processor,\n role_worker_mapping=self.role_worker_mapping,\n resource_pool_manager=resource_pool_manager,\n ray_worker_group_cls=ray_worker_group_cls,\n train_dataset=train_dataset,\n val_dataset=val_dataset,\n collate_fn=collate_fn,\n train_sampler=train_sampler,\n )\n # Initialize the workers of the trainer.\n trainer.init_workers()\n\n # Start the training process.\n trainer.fit()\n\n\ndef create_rl_dataset(data_paths, data_config, tokenizer, processor, is_train=True, max_samples: int = -1):\n \"\"\"Create a dataset.\n\n Arguments:\n data_paths: List of paths to data files.\n data_config: The data config.\n tokenizer (Tokenizer): The tokenizer.\n processor (Processor): The processor.\n\n Returns:\n dataset (Dataset): The dataset.\n \"\"\"\n\n from verl.utils.dataset.rl_dataset import get_dataset_class\n\n # Get the dataset class\n dataset_cls = get_dataset_class(data_config)\n\n # Instantiate the dataset using the determined dataset class\n dataset = dataset_cls(\n data_files=data_paths,\n tokenizer=tokenizer,\n processor=processor,\n config=data_config,\n max_samples=max_samples,\n )\n\n return dataset\n\n\ndef create_rl_sampler(data_config, dataset):\n \"\"\"Create a sampler for the dataset.\n\n Arguments:\n data_config: The data config.\n dataset (Dataset): The dataset.\n\n Returns:\n sampler (Sampler): The sampler.\n \"\"\"\n import torch\n from torch.utils.data import SequentialSampler\n\n # torch.utils.data.RandomSampler could not recover properly\n from torchdata.stateful_dataloader.sampler import RandomSampler\n\n if data_config.sampler is not None and data_config.sampler.get(\"class_path\", None) is not None:\n curriculum_class = load_extern_object(\n data_config.sampler.class_path,\n data_config.sampler.class_name,\n )\n sampler = curriculum_class(\n data_source=dataset,\n data_config=data_config,\n )\n assert isinstance(sampler, AbstractSampler)\n assert data_config.get(\"dataloader_num_workers\", 8) == 0, (\n \"If using curriculum, num_workers must be 0 to prevent data caching. \"\n \"If the dataloader caches data before the batch is done the \"\n \"curriculum sampler won't have the opportunity to reorder it. \"\n )\n\n # Use a sampler to facilitate checkpoint resumption.\n # If shuffling is enabled in the data configuration, create a random sampler.\n elif data_config.shuffle:\n train_dataloader_generator = torch.Generator()\n seed = data_config.get(\"seed\")\n if seed is not None:\n train_dataloader_generator.manual_seed(seed)\n sampler = RandomSampler(data_source=dataset, generator=train_dataloader_generator)\n else:\n # If shuffling is disabled, use a sequential sampler to iterate through the dataset in order.\n sampler = SequentialSampler(data_source=dataset)\n\n return sampler\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__trainer__ppo__metric_utils.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nMetrics related to the PPO trainer.\n\"\"\"\n\nfrom collections import defaultdict\nfrom functools import partial\nfrom typing import Any, Callable\n\nimport numpy as np\nimport torch\n\nimport verl.utils.torch_functional as verl_F\nfrom verl import DataProto\nfrom verl.utils.import_utils import deprecated\n\n\n@deprecated(\"verl.utils.metric.reduce_metrics\")\ndef reduce_metrics(metrics: dict[str, list[Any]]) -> dict[str, Any]:\n \"\"\"\n Reduces a dictionary of metric lists by computing the mean of each list.\n\n Args:\n metrics: A dictionary mapping metric names to lists of metric values.\n\n Returns:\n A dictionary with the same keys but with each list replaced by its mean value.\n\n Example:\n >>> metrics = {\"loss\": [1.0, 2.0, 3.0], \"accuracy\": [0.8, 0.9, 0.7]}\n >>> reduce_metrics(metrics)\n {\"loss\": 2.0, \"accuracy\": 0.8}\n \"\"\"\n from verl.utils.metric import reduce_metrics\n\n return reduce_metrics(metrics)\n\n\ndef _compute_response_info(batch: DataProto) -> dict[str, Any]:\n \"\"\"\n Computes information about prompts and responses from a batch.\n\n This is an internal helper function that extracts masks and lengths for prompts and responses.\n\n Args:\n batch: A DataProto object containing batch data with responses and attention masks.\n\n Returns:\n A dictionary containing:\n - response_mask: Attention mask for the response tokens\n - prompt_length: Tensor of prompt lengths for each item in the batch\n - response_length: Tensor of response lengths for each item in the batch\n \"\"\"\n response_length = batch.batch[\"responses\"].shape[-1]\n\n prompt_mask = batch.batch[\"attention_mask\"][:, :-response_length]\n response_mask = batch.batch[\"attention_mask\"][:, -response_length:]\n\n prompt_length = prompt_mask.sum(-1).float()\n response_length = response_mask.sum(-1).float() # (batch_size,)\n\n return dict(\n response_mask=response_mask,\n prompt_length=prompt_length,\n response_length=response_length,\n )\n\n\ndef compute_data_metrics(batch: DataProto, use_critic: bool = True) -> dict[str, Any]:\n \"\"\"\n Computes various metrics from a batch of data for PPO training.\n\n This function calculates metrics related to scores, rewards, advantages, returns, values,\n and sequence lengths from a batch of data. It provides statistical information (mean, max, min)\n for each metric category.\n\n Args:\n batch: A DataProto object containing batch data with token-level scores, rewards, advantages, etc.\n use_critic: Whether to include critic-specific metrics. Defaults to True.\n\n Returns:\n A dictionary of metrics including:\n - critic/score/mean, max, min: Statistics about sequence scores\n - critic/rewards/mean, max, min: Statistics about sequence rewards\n - critic/advantages/mean, max, min: Statistics about advantages\n - critic/returns/mean, max, min: Statistics about returns\n - critic/values/mean, max, min: Statistics about critic values (if use_critic=True)\n - critic/vf_explained_var: Explained variance of the value function (if use_critic=True)\n - response_length/mean, max, min, clip_ratio: Statistics about response lengths\n - prompt_length/mean, max, min, clip_ratio: Statistics about prompt lengths\n - num_turns/mean, max, min: Statistics about the number of multi-turn conversations\n \"\"\"\n sequence_score = batch.batch[\"token_level_scores\"].sum(-1)\n sequence_reward = batch.batch[\"token_level_rewards\"].sum(-1)\n\n advantages = batch.batch[\"advantages\"]\n returns = batch.batch[\"returns\"]\n\n max_response_length = batch.batch[\"responses\"].shape[-1]\n\n prompt_mask = batch.batch[\"attention_mask\"][:, :-max_response_length].bool()\n response_mask = batch.batch[\"response_mask\"].bool()\n\n max_prompt_length = prompt_mask.size(-1)\n\n response_info = _compute_response_info(batch)\n prompt_length = response_info[\"prompt_length\"]\n response_length = response_info[\"response_length\"]\n\n aborted_mask = (response_length == 0).bool()\n non_aborted_mask = ~aborted_mask\n\n non_aborted_sequence_score = sequence_score[non_aborted_mask]\n non_aborted_sequence_reward = sequence_reward[non_aborted_mask]\n\n score_mean = torch.mean(non_aborted_sequence_score).detach().item()\n score_max = torch.max(non_aborted_sequence_score).detach().item()\n score_min = torch.min(non_aborted_sequence_score).detach().item()\n\n reward_mean = torch.mean(non_aborted_sequence_reward).detach().item()\n reward_max = torch.max(non_aborted_sequence_reward).detach().item()\n reward_min = torch.min(non_aborted_sequence_reward).detach().item()\n\n valid_adv = torch.masked_select(advantages, response_mask)\n valid_returns = torch.masked_select(returns, response_mask)\n\n if use_critic:\n values = batch.batch[\"values\"]\n valid_values = torch.masked_select(values, response_mask)\n return_diff_var = torch.var(valid_returns - valid_values)\n return_var = torch.var(valid_returns)\n\n # Aborted samples and non-aborted response length statistics\n # response_length_non_aborted/*: statistics computed on non-aborted samples only\n aborted_ratio = torch.mean(aborted_mask.float()).detach().item()\n\n non_aborted_response_length = response_length[non_aborted_mask]\n if non_aborted_response_length.numel() > 0:\n non_aborted_response_length_mean = torch.mean(non_aborted_response_length).detach().item()\n non_aborted_response_length_max = torch.max(non_aborted_response_length).detach().item()\n non_aborted_response_length_min = torch.min(non_aborted_response_length).detach().item()\n non_aborted_response_length_clip_ratio = (\n torch.mean(torch.eq(non_aborted_response_length, max_response_length).float()).detach().item()\n )\n else:\n raise ValueError(\"All samples are aborted, this should not happen.\")\n\n metrics = {\n # score\n \"critic/score/mean\": score_mean,\n \"critic/score/max\": score_max,\n \"critic/score/min\": score_min,\n # reward\n \"critic/rewards/mean\": reward_mean,\n \"critic/rewards/max\": reward_max,\n \"critic/rewards/min\": reward_min,\n # adv\n \"critic/advantages/mean\": torch.mean(valid_adv).detach().item(),\n \"critic/advantages/max\": torch.max(valid_adv).detach().item(),\n \"critic/advantages/min\": torch.min(valid_adv).detach().item(),\n # returns\n \"critic/returns/mean\": torch.mean(valid_returns).detach().item(),\n \"critic/returns/max\": torch.max(valid_returns).detach().item(),\n \"critic/returns/min\": torch.min(valid_returns).detach().item(),\n **(\n {\n # values\n \"critic/values/mean\": torch.mean(valid_values).detach().item(),\n \"critic/values/max\": torch.max(valid_values).detach().item(),\n \"critic/values/min\": torch.min(valid_values).detach().item(),\n # vf explained var\n \"critic/vf_explained_var\": (1.0 - return_diff_var / (return_var + 1e-5)).detach().item(),\n }\n if use_critic\n else {}\n ),\n # response length\n \"response_length/mean\": torch.mean(response_length).detach().item(),\n \"response_length/max\": torch.max(response_length).detach().item(),\n \"response_length/min\": torch.min(response_length).detach().item(),\n \"response_length/clip_ratio\": torch.mean(torch.eq(response_length, max_response_length).float())\n .detach()\n .item(),\n # response length (non-aborted only)\n # These statistics exclude aborted samples to avoid skew from zeros\n \"response_length_non_aborted/mean\": non_aborted_response_length_mean,\n \"response_length_non_aborted/max\": non_aborted_response_length_max,\n \"response_length_non_aborted/min\": non_aborted_response_length_min,\n \"response_length_non_aborted/clip_ratio\": non_aborted_response_length_clip_ratio,\n # aborted ratio\n # Fraction of samples whose response length is zero\n \"response/aborted_ratio\": aborted_ratio,\n # prompt length\n \"prompt_length/mean\": torch.mean(prompt_length).detach().item(),\n \"prompt_length/max\": torch.max(prompt_length).detach().item(),\n \"prompt_length/min\": torch.min(prompt_length).detach().item(),\n \"prompt_length/clip_ratio\": torch.mean(torch.eq(prompt_length, max_prompt_length).float()).detach().item(),\n }\n\n # multi-turn conversation\n if \"__num_turns__\" in batch.non_tensor_batch:\n num_turns = batch.non_tensor_batch[\"__num_turns__\"]\n metrics[\"num_turns/min\"] = num_turns.min()\n metrics[\"num_turns/max\"] = num_turns.max()\n metrics[\"num_turns/mean\"] = num_turns.mean()\n\n if \"tool_call_counts\" in batch.non_tensor_batch:\n tool_call_counts = batch.non_tensor_batch[\"tool_call_counts\"]\n metrics[\"tool_call_counts/min\"] = tool_call_counts.min()\n metrics[\"tool_call_counts/max\"] = tool_call_counts.max()\n metrics[\"tool_call_counts/mean\"] = tool_call_counts.mean()\n\n return metrics\n\n\ndef compute_timing_metrics(batch: DataProto, timing_raw: dict[str, float]) -> dict[str, Any]:\n \"\"\"\n Computes timing metrics for different processing stages in PPO training.\n\n This function calculates both raw timing metrics (in seconds) and per-token timing metrics\n (in milliseconds) for various processing stages like generation, reference computation,\n value computation, advantage computation, and model updates.\n\n Args:\n batch: A DataProto object containing batch data with responses and attention masks.\n timing_raw: A dictionary mapping stage names to their execution times in seconds.\n\n Returns:\n A dictionary containing:\n - timing_s/{name}: Raw timing in seconds for each stage\n - timing_per_token_ms/{name}: Per-token timing in milliseconds for each stage\n\n Note:\n Different stages use different token counts for normalization:\n - \"gen\" uses only response tokens\n - Other stages (\"ref\", \"values\", \"adv\", \"update_critic\", \"update_actor\") use all tokens\n (prompt + response)\n \"\"\"\n response_info = _compute_response_info(batch)\n num_prompt_tokens = torch.sum(response_info[\"prompt_length\"]).item()\n num_response_tokens = torch.sum(response_info[\"response_length\"]).item()\n num_overall_tokens = num_prompt_tokens + num_response_tokens\n\n num_tokens_of_section = {\n \"gen\": num_response_tokens,\n **{name: num_overall_tokens for name in [\"ref\", \"values\", \"adv\", \"update_critic\", \"update_actor\"]},\n }\n\n return {\n **{f\"timing_s/{name}\": value for name, value in timing_raw.items()},\n **{\n f\"timing_per_token_ms/{name}\": timing_raw[name] * 1000 / num_tokens_of_section[name]\n for name in set(num_tokens_of_section.keys()) & set(timing_raw.keys())\n },\n }\n\n\ndef compute_throughout_metrics(batch: DataProto, timing_raw: dict[str, float], n_gpus: int) -> dict[str, Any]:\n \"\"\"\n Computes throughput metrics for PPO training.\n\n This function calculates performance metrics related to token processing speed,\n including the total number of tokens processed, time per step, and throughput\n (tokens per second per GPU).\n\n Args:\n batch: A DataProto object containing batch data with meta information about token counts.\n timing_raw: A dictionary mapping stage names to their execution times in seconds.\n Must contain a \"step\" key with the total step time.\n n_gpus: Number of GPUs used for training.\n\n Returns:\n A dictionary containing:\n - perf/total_num_tokens: Total number of tokens processed in the batch\n - perf/time_per_step: Time taken for the step in seconds\n - perf/throughput: Tokens processed per second per GPU\n\n Note:\n The throughput is calculated as total_tokens / (time * n_gpus) to normalize\n across different GPU counts.\n \"\"\"\n total_num_tokens = sum(batch.meta_info[\"global_token_num\"])\n time = timing_raw[\"step\"]\n # estimated_flops, promised_flops = flops_function.estimate_flops(num_tokens, time)\n # f'Actual TFLOPs/s/GPU​': estimated_flops/(n_gpus),\n # f'Theoretical TFLOPs/s/GPU​': promised_flops,\n return {\n \"perf/total_num_tokens\": total_num_tokens,\n \"perf/time_per_step\": time,\n \"perf/throughput\": total_num_tokens / (time * n_gpus),\n }\n\n\ndef compute_variance_proxy_metrics(batch: DataProto, gradient_norm: float = None) -> dict[str, float]:\n \"\"\"\n Compute variance proxy metrics using the simplified expected squared norm approach.\n\n This metric provides a computationally efficient way to monitor gradient variance\n during training. It works for any advantage estimator as long as sum_pi_squared\n is available from the actor.\n\n Theory:\n - Full variance: Var(g̃) = E[||g̃||²] - ||g_true||²\n - Simplified proxy (when ||g_true||² ≈ 0): Var(g̃) ≈ E[||g̃||²]\n - Using W-score approximation: E[||g̃||²] ≈ E[A² × W(τ)]\n\n Where W(τ) = Σ_t[1 - 2π_t(y_t) + Σπ²] is the score-norm proxy.\n \"\"\"\n metrics = {}\n\n # Check if we have the necessary data (sum_pi_squared is required for W-score)\n if \"sum_pi_squared\" not in batch.batch or \"old_log_probs\" not in batch.batch or \"advantages\" not in batch.batch:\n return metrics\n\n # Compute W(τ) = Σ_t[1 - 2π_t(y_t) + Σπ²]\n pi_t = torch.exp(batch.batch[\"old_log_probs\"])\n w_per_timestep = 1 - 2 * pi_t + batch.batch[\"sum_pi_squared\"]\n\n # Get response mask to only consider valid tokens\n response_mask = batch.batch[\"response_mask\"]\n\n # Use pre-computed rollout IS weights from batch (for variance proxy consistency with training loss)\n # IS weights are computed centrally in ray_trainer.py to avoid duplication\n rollout_is_weights = None\n if \"rollout_is_weights\" in batch.batch:\n # Extract pre-computed IS weights from batch (already computed in trainer)\n rollout_is_weights = batch.batch[\"rollout_is_weights\"]\n\n # Scale W by (rollout IS weight)² for optimal baseline under biased estimation\n w_per_timestep = w_per_timestep * (rollout_is_weights**2).detach()\n\n # Note: IS weight statistics and mismatch metrics are logged in ray_trainer.py\n\n # Get scalar advantages (mean over timesteps)\n advantages = batch.batch[\"advantages\"]\n # Compute mean advantage per trajectory using masked_mean\n advantages_scalar = verl_F.masked_mean(advantages, response_mask, axis=-1)\n\n # Compute W values (sum over timesteps)\n w_values = verl_F.masked_sum(w_per_timestep, response_mask, axis=-1)\n\n # ====== COMPUTE VARIANCE PROXIES ======\n # Variance proxy should match the actual gradient computation:\n # - If IS weights were computed/applied: use them in variance proxy calculation\n # - Otherwise: compute on-policy variance proxy\n\n # ====== PROXY 1: Signal Strength ||ḡ||² ======\n # The squared norm of the mean gradient (provided from training loop)\n proxy1_signal_strength = gradient_norm**2 if gradient_norm is not None else None\n\n # ====== PROXY 2: Total Power E[||ĝ_τ||²] ======\n # Measures the average of squared gradient norms (Signal + Noise)\n if rollout_is_weights is not None:\n # Off-policy with IS correction applied: use clamped weights consistently with actual gradient computation\n rollout_is_weights_scalar = verl_F.masked_mean(rollout_is_weights, response_mask, axis=-1)\n # Recover original W (before IS correction was applied in line 657)\n # Clamp to avoid division by zero when IS weights are zero\n w_original = verl_F.masked_sum(\n w_per_timestep / torch.clamp((rollout_is_weights**2).detach(), min=1e-10), response_mask, axis=-1\n )\n # Clamp W to avoid negative values (which would cause NaN in sqrt)\n w_original = torch.clamp(w_original, min=0.0)\n # Proxy 2 for off-policy: E[ρ̄² × A² × W]\n proxy2_total_power = ((rollout_is_weights_scalar**2) * (advantages_scalar**2) * w_original).mean()\n\n else:\n # On-policy Proxy 2: E[A² × W]\n # Clamp W to avoid negative values (which would cause NaN in sqrt)\n w_values_clamped = torch.clamp(w_values, min=0.0)\n proxy2_total_power = (advantages_scalar**2 * w_values_clamped).mean()\n\n # ====== PROXY 3: Pure Noise - Variance of Mean Vector ======\n # Requires ||ḡ||² from actual batch gradient\n # Formula: (1/(N-1)) × (Proxy2 - Proxy1)\n proxy3_pure_noise = None\n if proxy1_signal_strength is not None:\n batch_size = advantages_scalar.shape[0]\n if batch_size > 1:\n proxy3_pure_noise = (1.0 / (batch_size - 1)) * (proxy2_total_power - proxy1_signal_strength)\n # Ensure non-negative (can be negative due to numerical errors)\n proxy3_pure_noise = max(\n 0.0, proxy3_pure_noise.item() if torch.is_tensor(proxy3_pure_noise) else proxy3_pure_noise\n )\n\n # Decompose into components for analysis\n expected_a_squared = (advantages_scalar**2).mean()\n expected_w = w_values.mean()\n\n metrics.update(\n {\n # Proxy 1: Signal Strength ||ḡ||²\n \"variance_proxy/proxy1_signal_strength\": (\n proxy1_signal_strength if proxy1_signal_strength is not None else 0.0\n ),\n # Proxy 2: Total Power E[||ĝ_τ||²]\n \"variance_proxy/proxy2_total_power\": proxy2_total_power.detach().item(),\n # Proxy 3: Pure Noise - Variance of Mean Vector\n \"variance_proxy/proxy3_pure_noise\": proxy3_pure_noise if proxy3_pure_noise is not None else 0.0,\n # Component metrics for debugging\n \"variance_proxy/expected_a_squared\": expected_a_squared.detach().item(),\n \"variance_proxy/expected_w\": expected_w.detach().item(),\n }\n )\n\n return metrics\n\n\ndef bootstrap_metric(\n data: list[Any],\n subset_size: int,\n reduce_fns: list[Callable[[np.ndarray], float]],\n n_bootstrap: int = 1000,\n seed: int = 42,\n) -> list[tuple[float, float]]:\n \"\"\"\n Performs bootstrap resampling to estimate statistics of metrics.\n\n This function uses bootstrap resampling to estimate the mean and standard deviation\n of metrics computed by the provided reduction functions on random subsets of the data.\n\n Args:\n data: List of data points to bootstrap from.\n subset_size: Size of each bootstrap sample.\n reduce_fns: List of functions that compute a metric from a subset of data.\n n_bootstrap: Number of bootstrap iterations. Defaults to 1000.\n seed: Random seed for reproducibility. Defaults to 42.\n\n Returns:\n A list of tuples, where each tuple contains (mean, std) for a metric\n corresponding to each reduction function in reduce_fns.\n\n Example:\n >>> data = [1, 2, 3, 4, 5]\n >>> reduce_fns = [np.mean, np.max]\n >>> bootstrap_metric(data, 3, reduce_fns)\n [(3.0, 0.5), (4.5, 0.3)] # Example values\n \"\"\"\n np.random.seed(seed)\n data_np = np.array(data, dtype=object)\n n_data = len(data_np)\n\n # generate bootstrap indices, shape: (n_bootstrap, subset_size)\n bootstrap_idxs = np.random.choice(n_data, size=(n_bootstrap, subset_size), replace=True)\n\n # pre-allocate result array, shape: (n_fns, n_bootstrap)\n n_fns = len(reduce_fns)\n metric_results = np.empty((n_fns, n_bootstrap), dtype=np.float64)\n\n # compute metric results for each bootstrap sample\n for fn_idx, reduce_fn in enumerate(reduce_fns):\n # bootstrap sample and compute metric\n for boot_idx in range(n_bootstrap):\n sample = data_np[bootstrap_idxs[boot_idx]]\n metric_results[fn_idx, boot_idx] = reduce_fn(sample)\n\n # compute mean and std for each metric function\n result = [\n (float(np.mean(metric_results[fn_idx])), float(np.std(metric_results[fn_idx]))) for fn_idx in range(n_fns)\n ]\n return result\n\n\ndef calc_maj_val(data: list[dict[str, Any]], vote_key: str, val_key: str) -> float:\n \"\"\"\n Calculate a value based on majority voting.\n\n This function identifies the most common value for a specified vote key\n in the data, then returns the corresponding value for that majority vote.\n\n Args:\n data: List of dictionaries, where each dictionary contains both vote_key and val_key.\n vote_key: The key in each dictionary used for voting/counting.\n val_key: The key in each dictionary whose value will be returned for the majority vote.\n\n Returns:\n The value associated with the most common vote.\n\n Example:\n >>> data = [\n ... {\"pred\": \"A\", \"val\": 0.9},\n ... {\"pred\": \"B\", \"val\": 0.8},\n ... {\"pred\": \"A\", \"val\": 0.7}\n ... ]\n >>> calc_maj_val(data, vote_key=\"pred\", val_key=\"val\")\n 0.9 # Returns the first \"val\" for the majority vote \"A\"\n \"\"\"\n vote2vals = defaultdict(list)\n for d in data:\n vote2vals[d[vote_key]].append(d[val_key])\n\n vote2cnt = {k: len(v) for k, v in vote2vals.items()}\n maj_vote = max(vote2cnt, key=vote2cnt.get)\n\n maj_val = vote2vals[maj_vote][0]\n\n return maj_val\n\n\ndef process_validation_metrics(\n data_sources: list[str], sample_uids: list[str], infos_dict: dict[str, list[Any]], seed: int = 42\n) -> dict[str, dict[str, dict[str, float]]]:\n \"\"\"\n Process validation metrics into a structured format with statistical analysis.\n\n This function organizes validation metrics by data source and prompt, then computes\n various statistical measures including means, standard deviations, best/worst values,\n and majority voting results. It also performs bootstrap sampling to estimate statistics\n for different sample sizes.\n\n Args:\n data_sources: List of data source identifiers for each sample.\n sample_uids: List of sample uids corresponding to each sample.\n infos_dict: Dictionary mapping variable names to lists of values for each sample.\n seed: Random seed for bootstrap sampling. Defaults to 42.\n\n Returns:\n A nested dictionary with the structure:\n {\n data_source: {\n variable_name: {\n metric_name: value\n }\n }\n }\n\n Where metric_name includes:\n - \"mean@N\": Mean value across N samples\n - \"std@N\": Standard deviation across N samples\n - \"best@N/mean\": Mean of the best values in bootstrap samples of size N\n - \"best@N/std\": Standard deviation of the best values in bootstrap samples\n - \"worst@N/mean\": Mean of the worst values in bootstrap samples\n - \"worst@N/std\": Standard deviation of the worst values in bootstrap samples\n - \"maj@N/mean\": Mean of majority voting results in bootstrap samples (if \"pred\" exists)\n - \"maj@N/std\": Standard deviation of majority voting results (if \"pred\" exists)\n\n Example:\n >>> data_sources = [\"source1\", \"source1\", \"source2\"]\n >>> sample_uids = [\"uid1\", \"uid1\", \"uid2\"]\n >>> infos_dict = {\"score\": [0.8, 0.9, 0.7], \"pred\": [\"A\", \"A\", \"B\"]}\n >>> result = process_validation_metrics(data_sources, sample_uids, infos_dict)\n >>> # result will contain statistics for each data source and variable\n \"\"\"\n # Group metrics by data source, prompt and variable\n data_src2uid2var2vals = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\n for sample_idx, data_source in enumerate(data_sources):\n uid = sample_uids[sample_idx]\n var2vals = data_src2uid2var2vals[data_source][uid]\n for var_name, var_vals in infos_dict.items():\n var2vals[var_name].append(var_vals[sample_idx])\n\n np_mean = np.mean\n np_std = np.std\n reduce_fns_best_worst = [np.max, np.min]\n n_bootstrap = 1000\n\n # 2. cache ns list\n def gen_ns(n_resps: int) -> list[int]:\n if n_resps <= 1:\n return []\n ns = []\n n = 2\n while n < n_resps:\n ns.append(n)\n n *= 2\n ns.append(n_resps)\n return ns\n\n ns_cache = {}\n\n # 3. cache metric results\n data_src2uid2var2metric = {}\n\n # 4. flatten loop\n for data_source, uid2var2vals in data_src2uid2var2vals.items():\n # create uid dict\n uid_dict = data_src2uid2var2metric.setdefault(data_source, {})\n\n for uid, var2vals in uid2var2vals.items():\n pred_vals = var2vals.get(\"pred\")\n has_pred = pred_vals is not None\n var_dict = uid_dict.setdefault(uid, {})\n\n for var_name, var_vals in var2vals.items():\n # skip empty or string values\n if not var_vals or isinstance(var_vals[0], str):\n continue\n\n # compute mean and std\n n_resps = len(var_vals)\n metric = {f\"mean@{n_resps}\": float(np_mean(var_vals))}\n\n if n_resps > 1:\n metric[f\"std@{n_resps}\"] = float(np_std(var_vals))\n\n # cache ns list\n if n_resps not in ns_cache:\n ns_cache[n_resps] = gen_ns(n_resps)\n ns = ns_cache[n_resps]\n\n # compute best/worst metrics\n for n in ns:\n # compute best/worst metrics\n (bon_mean, bon_std), (won_mean, won_std) = bootstrap_metric(\n data=var_vals,\n subset_size=n,\n reduce_fns=reduce_fns_best_worst,\n n_bootstrap=n_bootstrap,\n seed=seed,\n )\n metric[f\"best@{n}/mean\"] = bon_mean\n metric[f\"best@{n}/std\"] = bon_std\n metric[f\"worst@{n}/mean\"] = won_mean\n metric[f\"worst@{n}/std\"] = won_std\n\n # compute maj metrics\n if has_pred:\n # create vote_data\n vote_data = [\n {\"val\": val, \"pred\": pred} for val, pred in zip(var_vals, pred_vals, strict=True)\n ]\n # compute maj metrics\n [(maj_n_mean, maj_n_std)] = bootstrap_metric(\n data=vote_data,\n subset_size=n,\n reduce_fns=[partial(calc_maj_val, vote_key=\"pred\", val_key=\"val\")],\n n_bootstrap=n_bootstrap,\n seed=seed,\n )\n metric[f\"maj@{n}/mean\"] = maj_n_mean\n metric[f\"maj@{n}/std\"] = maj_n_std\n\n var_dict[var_name] = metric\n\n # Aggregate metrics across uids\n data_src2var2metric2uid_vals = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))\n for data_source, uid2var2metric in data_src2uid2var2metric.items():\n for uid, var2metric in uid2var2metric.items():\n for var_name, metric in var2metric.items():\n for metric_name, metric_val in metric.items():\n data_src2var2metric2uid_vals[data_source][var_name][metric_name].append(metric_val)\n\n data_src2var2metric2val = defaultdict(lambda: defaultdict(lambda: defaultdict(float)))\n for data_source, var2metric2uid_vals in data_src2var2metric2uid_vals.items():\n for var_name, metric2uid_vals in var2metric2uid_vals.items():\n for metric_name, uid_vals in metric2uid_vals.items():\n data_src2var2metric2val[data_source][var_name][metric_name] = np.mean(uid_vals)\n return data_src2var2metric2val\n"} +{"file_name": "verl__trainer__ppo__prefix_grouper_utils.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import annotations\n\nimport torch\nfrom prefix_grouper import PrefixGrouper\n\nfrom verl.utils.torch_functional import logprobs_from_logits\n\n\ndef build_position_ids_for_prefix_grouper(prefix_grouper: PrefixGrouper) -> torch.Tensor:\n \"\"\"Build position_ids for PrefixGrouper where each response restarts from prefix_len.\"\"\"\n num_samples = len(prefix_grouper.group_info)\n max_len = prefix_grouper.padding_mask.size(1)\n device = prefix_grouper.padding_mask.device\n\n position_ids = torch.zeros(num_samples, max_len, dtype=torch.long, device=device)\n\n for i, group in enumerate(prefix_grouper.group_info):\n prefix_len = group.prefix_len\n\n position_ids[i, :prefix_len] = torch.arange(prefix_len, device=device)\n cur_pos = prefix_len\n for suffix_len in group.suffix_lens:\n if suffix_len > 0:\n position_ids[i, cur_pos : cur_pos + suffix_len] = torch.arange(\n prefix_len, prefix_len + suffix_len, device=device\n )\n cur_pos += suffix_len\n\n return position_ids\n\n\ndef build_pg_from_micro_batch(\n micro_batch: dict,\n pad_token_id: int,\n padding_mode: str = \"right\",\n):\n \"\"\"Build PrefixGrouper from micro_batch dict containing prompts, responses, response_mask, uid.\"\"\"\n prompts = micro_batch[\"prompts\"]\n responses = micro_batch[\"responses\"]\n response_mask = micro_batch[\"response_mask\"]\n uids = micro_batch[\"uid\"]\n\n bs = responses.size(0)\n\n group_sizes = []\n cur = 1\n for i in range(1, bs):\n if uids[i] == uids[i - 1]:\n cur += 1\n else:\n group_sizes.append(cur)\n cur = 1\n group_sizes.append(cur)\n\n prefix_indices = []\n cursor = 0\n for gs in group_sizes:\n prefix_indices.append(cursor)\n cursor += gs\n prefix_indices = torch.tensor(prefix_indices, device=prompts.device)\n\n prefix_ids = prompts.index_select(0, prefix_indices)\n prefix_mask = prefix_ids.ne(pad_token_id)\n\n prefix_grouper = PrefixGrouper.from_ungrouped_masks(\n prefix_mask=prefix_mask,\n suffix_mask=response_mask,\n group_sizes=group_sizes,\n padding_mode=padding_mode,\n device=prompts.device,\n )\n\n concat_input_ids = prefix_grouper.concat_input(prefix_ids, prefix_mask, responses, response_mask)\n\n attention_mask = prefix_grouper.padding_mask\n\n position_ids = build_position_ids_for_prefix_grouper(prefix_grouper)\n\n return (\n prefix_grouper,\n concat_input_ids,\n attention_mask,\n position_ids,\n responses,\n response_mask,\n )\n\n\ndef pg_forward(\n model,\n prefix_grouper,\n concat_input_ids,\n attention_mask,\n position_ids,\n completion_ids,\n completion_mask,\n *,\n temperature=1.0,\n padding_mode=\"right\",\n include_prefix_last=1,\n calculate_entropy=False,\n entropy_fn=None,\n):\n logits = model(\n input_ids=concat_input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n use_cache=False,\n prefix_grouper=prefix_grouper,\n ).logits\n\n prefix_out, prefix_mask, suffix_out_raw, suffix_mask_raw = prefix_grouper.split_output(\n logits, include_prefix_last=include_prefix_last\n )\n\n completion_ids_right = prefix_grouper.convert_padding(\n completion_ids,\n completion_mask,\n padding_mode=padding_mode,\n )\n\n suffix_out = suffix_out_raw[:, :-1].float()\n suffix_mask = suffix_mask_raw[:, 1:]\n\n suffix_out /= temperature\n\n log_probs = logprobs_from_logits(suffix_out, completion_ids_right)\n\n entropy = None\n if calculate_entropy and entropy_fn is not None:\n entropy = entropy_fn(suffix_out)\n\n return log_probs, entropy, suffix_mask\n\n\ndef forward_micro_batch_with_prefix_grouper(\n micro_batch: dict,\n model,\n temperature: float,\n calculate_entropy: bool,\n device_name: str,\n param_dtype,\n use_chunking_entropy: bool = False,\n):\n \"\"\"\n Forward pass using PrefixGrouper for shared-prefix optimization.\n\n Args:\n micro_batch: Dict containing prompts, responses, response_mask, uid, etc.\n model: The actor module.\n temperature: Temperature for logits scaling.\n calculate_entropy: Whether to compute entropy.\n device_name: Device name for autocast.\n param_dtype: Parameter dtype for autocast.\n use_chunking_entropy: Whether to use chunking entropy function.\n\n Returns:\n tuple: (entropy, log_probs) where entropy may be None if not calculated.\n \"\"\"\n import verl.utils.torch_functional as verl_F\n\n entropy_fn = None\n if calculate_entropy:\n if use_chunking_entropy:\n entropy_fn = verl_F.entropy_from_logits_with_chunking\n else:\n entropy_fn = verl_F.entropy_from_logits\n\n pad_token_id = micro_batch.get(\"pad_token_id\", 0)\n\n (\n prefix_grouper,\n concat_input_ids,\n attention_mask,\n position_ids,\n responses,\n response_mask,\n ) = build_pg_from_micro_batch(\n micro_batch,\n pad_token_id=pad_token_id,\n padding_mode=\"right\",\n )\n\n with torch.autocast(device_type=device_name, dtype=param_dtype):\n log_probs, entropy, suffix_mask_from_pg = pg_forward(\n model=model,\n prefix_grouper=prefix_grouper,\n concat_input_ids=concat_input_ids,\n attention_mask=attention_mask,\n position_ids=position_ids,\n completion_ids=responses,\n completion_mask=response_mask,\n temperature=temperature,\n padding_mode=\"right\",\n include_prefix_last=1,\n calculate_entropy=calculate_entropy,\n entropy_fn=entropy_fn,\n )\n\n # Zero out padding positions\n padding_mask = suffix_mask_from_pg == 0\n log_probs = log_probs.masked_fill(padding_mask, 0.0)\n if entropy is not None:\n entropy = entropy.masked_fill(padding_mask, 0.0)\n\n # Pad to target response length if needed\n target_response_length = responses.size(1)\n if log_probs.size(1) != target_response_length:\n batch_size = log_probs.size(0)\n current_len = log_probs.size(1)\n\n full_log_probs = log_probs.new_zeros(batch_size, target_response_length)\n full_log_probs[:, :current_len] = log_probs\n log_probs = full_log_probs\n\n if entropy is not None:\n full_entropy = entropy.new_zeros(batch_size, target_response_length)\n full_entropy[:, :current_len] = entropy\n entropy = full_entropy\n\n return entropy, log_probs\n"} +{"file_name": "verl__trainer__ppo__ray_trainer.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2023-2024 SGLang Team\n# Copyright 2025 ModelBest Inc. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nPPO Trainer with Ray-based single controller.\nThis trainer supports model-agonistic model initialization with huggingface\n\"\"\"\n\nimport json\nimport os\nimport uuid\nfrom collections import defaultdict\nfrom copy import deepcopy\nfrom pprint import pprint\nfrom typing import Any, Optional\n\nimport numpy as np\nimport torch\nfrom omegaconf import OmegaConf, open_dict\nfrom torch.utils.data import Dataset, Sampler\nfrom torchdata.stateful_dataloader import StatefulDataLoader\nfrom tqdm import tqdm\n\nfrom verl import DataProto\nfrom verl.checkpoint_engine import CheckpointEngineManager\nfrom verl.experimental.dataset.sampler import AbstractCurriculumSampler\nfrom verl.protocol import pad_dataproto_to_divisor, unpad_dataproto\nfrom verl.single_controller.ray import RayClassWithInitArgs, RayWorkerGroup, ResourcePoolManager\nfrom verl.single_controller.ray.base import create_colocated_worker_cls\nfrom verl.trainer.config import AlgoConfig\nfrom verl.trainer.ppo import core_algos\nfrom verl.trainer.ppo.core_algos import AdvantageEstimator, agg_loss\nfrom verl.trainer.ppo.metric_utils import (\n compute_data_metrics,\n compute_throughout_metrics,\n compute_timing_metrics,\n compute_variance_proxy_metrics,\n process_validation_metrics,\n)\nfrom verl.trainer.ppo.reward import extract_reward\nfrom verl.trainer.ppo.utils import Role, WorkerType, need_critic, need_reference_policy, need_reward_model\nfrom verl.utils import tensordict_utils as tu\nfrom verl.utils.checkpoint.checkpoint_manager import find_latest_ckpt_path, should_save_ckpt_esi\nfrom verl.utils.config import omega_conf_to_dataclass\nfrom verl.utils.debug import marked_timer\nfrom verl.utils.import_utils import load_class_from_fqn\nfrom verl.utils.metric import reduce_metrics\nfrom verl.utils.py_functional import rename_dict\nfrom verl.utils.rollout_skip import RolloutSkip\nfrom verl.utils.seqlen_balancing import calculate_workload, get_seqlen_balanced_partitions, log_seqlen_unbalance\nfrom verl.utils.torch_functional import masked_mean\nfrom verl.utils.tracking import ValidationGenerationsLogger\nfrom verl.workers.config import FSDPEngineConfig\nfrom verl.workers.utils.padding import left_right_2_no_padding, no_padding_2_padding\n\n\ndef apply_kl_penalty(data: DataProto, kl_ctrl: core_algos.AdaptiveKLController, kl_penalty=\"kl\"):\n \"\"\"Apply KL penalty to the token-level rewards.\n\n This function computes the KL divergence between the reference policy and current policy,\n then applies a penalty to the token-level rewards based on this divergence.\n\n Args:\n data (DataProto): The data containing batched model outputs and inputs.\n kl_ctrl (core_algos.AdaptiveKLController): Controller for adaptive KL penalty.\n kl_penalty (str, optional): Type of KL penalty to apply. Defaults to \"kl\".\n\n Returns:\n tuple: A tuple containing:\n - The updated data with token-level rewards adjusted by KL penalty\n - A dictionary of metrics related to the KL penalty\n \"\"\"\n response_mask = data.batch[\"response_mask\"]\n token_level_scores = data.batch[\"token_level_scores\"]\n batch_size = data.batch.batch_size[0]\n\n # compute kl between ref_policy and current policy\n # When apply_kl_penalty, algorithm.use_kl_in_reward=True, so the reference model has been enabled.\n kld = core_algos.kl_penalty(\n data.batch[\"old_log_probs\"], data.batch[\"ref_log_prob\"], kl_penalty=kl_penalty\n ) # (batch_size, response_length)\n kld = kld * response_mask\n beta = kl_ctrl.value\n\n token_level_rewards = token_level_scores - beta * kld\n\n current_kl = masked_mean(kld, mask=response_mask, axis=-1) # average over sequence\n current_kl = torch.mean(current_kl, dim=0).item()\n\n # according to https://github.com/huggingface/trl/blob/951ca1841f29114b969b57b26c7d3e80a39f75a0/trl/trainer/ppo_trainer.py#L837\n kl_ctrl.update(current_kl=current_kl, n_steps=batch_size)\n data.batch[\"token_level_rewards\"] = token_level_rewards\n\n metrics = {\"actor/reward_kl_penalty\": current_kl, \"actor/reward_kl_penalty_coeff\": beta}\n\n return data, metrics\n\n\ndef compute_response_mask(data: DataProto):\n \"\"\"Compute the attention mask for the response part of the sequence.\n\n This function extracts the portion of the attention mask that corresponds to the model's response,\n which is used for masking computations that should only apply to response tokens.\n\n Args:\n data (DataProto): The data containing batched model outputs and inputs.\n\n Returns:\n torch.Tensor: The attention mask for the response tokens.\n \"\"\"\n responses = data.batch[\"responses\"]\n response_length = responses.size(1)\n attention_mask = data.batch[\"attention_mask\"]\n return attention_mask[:, -response_length:]\n\n\ndef compute_advantage(\n data: DataProto,\n adv_estimator: AdvantageEstimator,\n gamma: float = 1.0,\n lam: float = 1.0,\n num_repeat: int = 1,\n norm_adv_by_std_in_grpo: bool = True,\n config: Optional[AlgoConfig] = None,\n) -> DataProto:\n \"\"\"Compute advantage estimates for policy optimization.\n\n This function computes advantage estimates using various estimators like GAE, GRPO, REINFORCE++, etc.\n The advantage estimates are used to guide policy optimization in RL algorithms.\n\n Args:\n data (DataProto): The data containing batched model outputs and inputs.\n adv_estimator (AdvantageEstimator): The advantage estimator to use (e.g., GAE, GRPO, REINFORCE++).\n gamma (float, optional): Discount factor for future rewards. Defaults to 1.0.\n lam (float, optional): Lambda parameter for GAE. Defaults to 1.0.\n num_repeat (int, optional): Number of times to repeat the computation. Defaults to 1.\n norm_adv_by_std_in_grpo (bool, optional): Whether to normalize advantages by standard deviation in\n GRPO. Defaults to True.\n config (dict, optional): Configuration dictionary for algorithm settings. Defaults to None.\n\n Returns:\n DataProto: The updated data with computed advantages and returns.\n \"\"\"\n # Back-compatible with trainers that do not compute response mask in fit\n if \"response_mask\" not in data.batch.keys():\n data.batch[\"response_mask\"] = compute_response_mask(data)\n # prepare response group\n if adv_estimator == AdvantageEstimator.GAE:\n # Compute advantages and returns using Generalized Advantage Estimation (GAE)\n advantages, returns = core_algos.compute_gae_advantage_return(\n token_level_rewards=data.batch[\"token_level_rewards\"],\n values=data.batch[\"values\"],\n response_mask=data.batch[\"response_mask\"],\n gamma=gamma,\n lam=lam,\n )\n data.batch[\"advantages\"] = advantages\n data.batch[\"returns\"] = returns\n if config.get(\"use_pf_ppo\", False):\n data = core_algos.compute_pf_ppo_reweight_data(\n data,\n config.pf_ppo.get(\"reweight_method\"),\n config.pf_ppo.get(\"weight_pow\"),\n )\n elif adv_estimator == AdvantageEstimator.GRPO:\n # Initialize the mask for GRPO calculation\n grpo_calculation_mask = data.batch[\"response_mask\"]\n\n # Call compute_grpo_outcome_advantage with parameters matching its definition\n advantages, returns = core_algos.compute_grpo_outcome_advantage(\n token_level_rewards=data.batch[\"token_level_rewards\"],\n response_mask=grpo_calculation_mask,\n index=data.non_tensor_batch[\"uid\"],\n norm_adv_by_std_in_grpo=norm_adv_by_std_in_grpo,\n )\n data.batch[\"advantages\"] = advantages\n data.batch[\"returns\"] = returns\n else:\n # handle all other adv estimator type other than GAE and GRPO\n adv_estimator_fn = core_algos.get_adv_estimator_fn(adv_estimator)\n adv_kwargs = {\n \"token_level_rewards\": data.batch[\"token_level_rewards\"],\n \"response_mask\": data.batch[\"response_mask\"],\n \"config\": config,\n }\n if \"uid\" in data.non_tensor_batch: # optional\n adv_kwargs[\"index\"] = data.non_tensor_batch[\"uid\"]\n if \"reward_baselines\" in data.batch: # optional\n adv_kwargs[\"reward_baselines\"] = data.batch[\"reward_baselines\"]\n # Add sum_pi_squared for Optimal Token Baseline\n if adv_estimator in (AdvantageEstimator.OPTIMAL_TOKEN_BASELINE, AdvantageEstimator.TIR_OPTIMAL_TOKEN_BASELINE):\n # Check if sum_pi_squared is available\n assert \"sum_pi_squared\" in data.batch, (\n \"Step-dependent optimal baseline requires sum_pi_squared from actor. \"\n \"Please set actor.calculate_sum_pi_squared=True in config.\"\n )\n adv_kwargs[\"sum_pi_squared\"] = data.batch[\"sum_pi_squared\"]\n # Get pre-computed rollout IS weights if available\n rollout_is_weights = data.batch.get(\"rollout_is_weights\", None)\n adv_kwargs[\"rollout_is_weights\"] = rollout_is_weights\n\n # calculate advantage estimator\n advantages, returns = adv_estimator_fn(**adv_kwargs)\n data.batch[\"advantages\"] = advantages\n data.batch[\"returns\"] = returns\n return data\n\n\nclass RayPPOTrainer:\n \"\"\"Distributed PPO trainer using Ray for scalable reinforcement learning.\n\n This trainer orchestrates distributed PPO training across multiple nodes and GPUs,\n managing actor rollouts, critic training, and reward computation with Ray backend.\n Supports various model architectures including FSDP, Megatron, vLLM, and SGLang integration.\n \"\"\"\n\n # TODO: support each role have individual ray_worker_group_cls,\n # i.e., support different backend of different role\n def __init__(\n self,\n config,\n tokenizer,\n role_worker_mapping: dict[Role, WorkerType],\n resource_pool_manager: ResourcePoolManager,\n ray_worker_group_cls: type[RayWorkerGroup] = RayWorkerGroup,\n processor=None,\n train_dataset: Optional[Dataset] = None,\n val_dataset: Optional[Dataset] = None,\n collate_fn=None,\n train_sampler: Optional[Sampler] = None,\n device_name=None,\n ):\n \"\"\"\n Initialize distributed PPO trainer with Ray backend.\n Note that this trainer runs on the driver process on a single CPU/GPU node.\n\n Args:\n config: Configuration object containing training parameters.\n tokenizer: Tokenizer used for encoding and decoding text.\n role_worker_mapping (dict[Role, WorkerType]): Mapping from roles to worker classes.\n resource_pool_manager (ResourcePoolManager): Manager for Ray resource pools.\n ray_worker_group_cls (RayWorkerGroup, optional): Class for Ray worker groups. Defaults to RayWorkerGroup.\n processor: Optional data processor, used for multimodal data\n train_dataset (Optional[Dataset], optional): Training dataset. Defaults to None.\n val_dataset (Optional[Dataset], optional): Validation dataset. Defaults to None.\n collate_fn: Function to collate data samples into batches.\n train_sampler (Optional[Sampler], optional): Sampler for the training dataset. Defaults to None.\n device_name (str, optional): Device name for training (e.g., \"cuda\", \"cpu\"). Defaults to None.\n \"\"\"\n\n # Store the tokenizer for text processing\n self.tokenizer = tokenizer\n self.processor = processor\n self.config = config\n\n self.hybrid_engine = config.actor_rollout_ref.hybrid_engine\n assert self.hybrid_engine, \"Currently, only support hybrid engine\"\n\n if self.hybrid_engine:\n assert Role.ActorRollout in role_worker_mapping or Role.ActorRolloutRef in role_worker_mapping, (\n f\"{role_worker_mapping.keys()=}\"\n )\n\n self.role_worker_mapping = role_worker_mapping\n self.resource_pool_manager = resource_pool_manager\n self.use_reference_policy = need_reference_policy(self.config)\n\n self.use_rm = need_reward_model(self.config)\n\n self.use_critic = need_critic(self.config)\n self.ray_worker_group_cls = ray_worker_group_cls\n self.device_name = device_name if device_name else self.config.trainer.device\n self.validation_generations_logger = ValidationGenerationsLogger(\n project_name=self.config.trainer.project_name,\n experiment_name=self.config.trainer.experiment_name,\n )\n\n # if ref_in_actor is True, the reference policy will be actor without lora applied\n lora_rank = config.actor_rollout_ref.model.get(\"lora\", {}).get(\"rank\", 0)\n if lora_rank <= 0:\n lora_rank = config.actor_rollout_ref.model.get(\"lora_rank\", 0)\n self.ref_in_actor = lora_rank > 0 or config.actor_rollout_ref.model.get(\"lora_adapter_path\") is not None\n\n # define in-reward KL control\n # kl loss control currently not suppoorted\n if self.config.algorithm.use_kl_in_reward:\n self.kl_ctrl_in_reward = core_algos.get_kl_controller(self.config.algorithm.kl_ctrl)\n\n self.use_prefix_grouper = self.config.actor_rollout_ref.actor.get(\"use_prefix_grouper\", False)\n self.use_legacy_worker_impl = config.trainer.get(\"use_legacy_worker_impl\", \"auto\")\n\n self._create_dataloader(train_dataset, val_dataset, collate_fn, train_sampler)\n\n def _create_dataloader(self, train_dataset, val_dataset, collate_fn, train_sampler: Optional[Sampler]):\n \"\"\"\n Creates the train and validation dataloaders.\n \"\"\"\n # TODO: we have to make sure the batch size is divisible by the dp size\n from verl.trainer.main_ppo import create_rl_dataset, create_rl_sampler\n\n if train_dataset is None:\n train_dataset = create_rl_dataset(\n self.config.data.train_files,\n self.config.data,\n self.tokenizer,\n self.processor,\n max_samples=self.config.data.get(\"train_max_samples\", -1),\n )\n if val_dataset is None:\n val_dataset = create_rl_dataset(\n self.config.data.val_files,\n self.config.data,\n self.tokenizer,\n self.processor,\n max_samples=self.config.data.get(\"val_max_samples\", -1),\n )\n self.train_dataset, self.val_dataset = train_dataset, val_dataset\n\n if train_sampler is None:\n train_sampler = create_rl_sampler(self.config.data, self.train_dataset)\n if collate_fn is None:\n from verl.utils.dataset.rl_dataset import collate_fn as default_collate_fn\n\n collate_fn = default_collate_fn\n\n num_workers = self.config.data[\"dataloader_num_workers\"]\n\n self.train_dataloader = StatefulDataLoader(\n dataset=self.train_dataset,\n batch_size=self.config.data.get(\"gen_batch_size\", self.config.data.train_batch_size),\n num_workers=num_workers,\n drop_last=True,\n collate_fn=collate_fn,\n sampler=train_sampler,\n )\n\n val_batch_size = self.config.data.val_batch_size # Prefer config value if set\n if val_batch_size is None:\n val_batch_size = len(self.val_dataset)\n\n self.val_dataloader = StatefulDataLoader(\n dataset=self.val_dataset,\n batch_size=val_batch_size,\n num_workers=num_workers,\n shuffle=self.config.data.get(\"validation_shuffle\", True),\n drop_last=False,\n collate_fn=collate_fn,\n )\n\n assert len(self.train_dataloader) >= 1, \"Train dataloader is empty!\"\n assert len(self.val_dataloader) >= 1, \"Validation dataloader is empty!\"\n\n print(\n f\"Size of train dataloader: {len(self.train_dataloader)}, Size of val dataloader: \"\n f\"{len(self.val_dataloader)}\"\n )\n\n total_training_steps = len(self.train_dataloader) * self.config.trainer.total_epochs\n\n if self.config.trainer.total_training_steps is not None:\n total_training_steps = self.config.trainer.total_training_steps\n\n self.total_training_steps = total_training_steps\n print(f\"Total training steps: {self.total_training_steps}\")\n\n try:\n OmegaConf.set_struct(self.config, True)\n with open_dict(self.config):\n if OmegaConf.select(self.config, \"actor_rollout_ref.actor.optim\"):\n self.config.actor_rollout_ref.actor.optim.total_training_steps = total_training_steps\n if OmegaConf.select(self.config, \"critic.optim\"):\n self.config.critic.optim.total_training_steps = total_training_steps\n except Exception as e:\n print(f\"Warning: Could not set total_training_steps in config. Structure missing? Error: {e}\")\n\n def _dump_generations(self, inputs, outputs, gts, scores, reward_extra_infos_dict, dump_path):\n \"\"\"Dump rollout/validation samples as JSONL.\"\"\"\n os.makedirs(dump_path, exist_ok=True)\n filename = os.path.join(dump_path, f\"{self.global_steps}.jsonl\")\n\n n = len(inputs)\n base_data = {\n \"input\": inputs,\n \"output\": outputs,\n \"gts\": gts,\n \"score\": scores,\n \"step\": [self.global_steps] * n,\n }\n\n for k, v in reward_extra_infos_dict.items():\n if len(v) == n:\n base_data[k] = v\n\n lines = []\n for i in range(n):\n entry = {k: v[i] for k, v in base_data.items()}\n lines.append(json.dumps(entry, ensure_ascii=False))\n\n with open(filename, \"w\") as f:\n f.write(\"\\n\".join(lines) + \"\\n\")\n\n print(f\"Dumped generations to {filename}\")\n\n def _log_rollout_data(\n self, batch: DataProto, reward_extra_infos_dict: dict, timing_raw: dict, rollout_data_dir: str\n ):\n \"\"\"Log rollout data to disk.\n Args:\n batch (DataProto): The batch containing rollout data\n reward_extra_infos_dict (dict): Additional reward information to log\n timing_raw (dict): Timing information for profiling\n rollout_data_dir (str): Directory path to save the rollout data\n \"\"\"\n with marked_timer(\"dump_rollout_generations\", timing_raw, color=\"green\"):\n inputs = self.tokenizer.batch_decode(batch.batch[\"prompts\"], skip_special_tokens=True)\n outputs = self.tokenizer.batch_decode(batch.batch[\"responses\"], skip_special_tokens=True)\n scores = batch.batch[\"token_level_scores\"].sum(-1).cpu().tolist()\n sample_gts = [item.non_tensor_batch.get(\"reward_model\", {}).get(\"ground_truth\", None) for item in batch]\n\n reward_extra_infos_to_dump = reward_extra_infos_dict.copy()\n if \"request_id\" in batch.non_tensor_batch:\n reward_extra_infos_dict.setdefault(\n \"request_id\",\n batch.non_tensor_batch[\"request_id\"].tolist(),\n )\n\n self._dump_generations(\n inputs=inputs,\n outputs=outputs,\n gts=sample_gts,\n scores=scores,\n reward_extra_infos_dict=reward_extra_infos_to_dump,\n dump_path=rollout_data_dir,\n )\n\n def _maybe_log_val_generations(self, inputs, outputs, scores):\n \"\"\"Log a table of validation samples to the configured logger (wandb or swanlab)\"\"\"\n\n generations_to_log = self.config.trainer.log_val_generations\n\n if generations_to_log == 0:\n return\n\n import numpy as np\n\n # Create tuples of (input, output, score) and sort by input text\n samples = list(zip(inputs, outputs, scores, strict=True))\n samples.sort(key=lambda x: x[0]) # Sort by input text\n\n # Use fixed random seed for deterministic shuffling\n rng = np.random.RandomState(42)\n rng.shuffle(samples)\n\n # Take first N samples after shuffling\n samples = samples[:generations_to_log]\n\n # Log to each configured logger\n self.validation_generations_logger.log(self.config.trainer.logger, samples, self.global_steps)\n\n def _get_gen_batch(self, batch: DataProto) -> DataProto:\n reward_keys = set({\"data_source\", \"reward_model\", \"extra_info\", \"uid\"}) & batch.non_tensor_batch.keys()\n\n # pop those keys for generation\n batch_keys_to_pop = []\n non_tensor_batch_keys_to_pop = set(batch.non_tensor_batch.keys()) - reward_keys\n gen_batch = batch.pop(\n batch_keys=batch_keys_to_pop,\n non_tensor_batch_keys=list(non_tensor_batch_keys_to_pop),\n )\n\n # For agent loop, we need reward model keys to compute score.\n gen_batch.non_tensor_batch.update(batch.non_tensor_batch)\n\n return gen_batch\n\n def _compute_reward_colocate(self, batch: DataProto) -> tuple[torch.Tensor, dict[str, Any]] | torch.Tensor:\n \"\"\"\n compute reward use colocate reward model\n \"\"\"\n assert self.reward_loop_manager is not None, \"RewardLoopManager is None\"\n batch_reward = self.reward_loop_manager.compute_rm_score(batch)\n return batch_reward\n\n def _validate(self, merged: bool = False):\n data_source_lst = []\n reward_extra_infos_dict: dict[str, list] = defaultdict(list)\n\n # Lists to collect samples for the table\n sample_inputs = []\n sample_outputs = []\n sample_gts = []\n sample_scores = []\n sample_turns = []\n sample_uids = []\n\n for test_data in self.val_dataloader:\n test_batch = DataProto.from_single_dict(test_data)\n\n if \"uid\" not in test_batch.non_tensor_batch:\n test_batch.non_tensor_batch[\"uid\"] = np.array(\n [str(uuid.uuid4()) for _ in range(len(test_batch.batch))], dtype=object\n )\n\n # repeat test batch\n test_batch = test_batch.repeat(\n repeat_times=self.config.actor_rollout_ref.rollout.val_kwargs.n, interleave=True\n )\n\n ground_truths = [\n item.non_tensor_batch.get(\"reward_model\", {}).get(\"ground_truth\", None) for item in test_batch\n ]\n sample_gts.extend(ground_truths)\n\n test_gen_batch = self._get_gen_batch(test_batch)\n test_gen_batch.meta_info = {\n \"eos_token_id\": self.tokenizer.eos_token_id,\n \"pad_token_id\": self.tokenizer.pad_token_id,\n \"recompute_log_prob\": False,\n \"do_sample\": self.config.actor_rollout_ref.rollout.val_kwargs.do_sample,\n \"validate\": True,\n \"global_steps\": self.global_steps,\n }\n print(f\"test_gen_batch meta info: {test_gen_batch.meta_info}\")\n\n # pad to be divisible by dp_size\n size_divisor = self.config.actor_rollout_ref.rollout.agent.num_workers\n test_gen_batch_padded, pad_size = pad_dataproto_to_divisor(test_gen_batch, size_divisor)\n test_output_gen_batch_padded = self.async_rollout_manager.generate_sequences(test_gen_batch_padded)\n\n if self.use_rm and \"rm_scores\" not in test_output_gen_batch_padded.batch.keys():\n # for colocate reward models, we need to sleep rollout model\n # to spare GPU memory for reward model\n self.checkpoint_manager.sleep_replicas()\n batch_reward = self._compute_reward_colocate(test_output_gen_batch_padded)\n test_output_gen_batch_padded = test_output_gen_batch_padded.union(batch_reward)\n # wake up rollout model\n # replace with wake_up method once supported\n self.checkpoint_manager.update_weights()\n\n # unpad\n test_output_gen_batch = unpad_dataproto(test_output_gen_batch_padded, pad_size=pad_size)\n\n print(\"validation generation end\")\n\n # Store generated outputs\n output_ids = test_output_gen_batch.batch[\"responses\"]\n output_texts = [self.tokenizer.decode(ids, skip_special_tokens=True) for ids in output_ids]\n sample_outputs.extend(output_texts)\n\n test_batch = test_batch.union(test_output_gen_batch)\n test_batch.meta_info[\"validate\"] = True\n\n # Store original inputs\n input_ids = test_batch.batch[\"prompts\"]\n # TODO: Can we keep special tokens except for padding tokens?\n input_texts = [self.tokenizer.decode(ids, skip_special_tokens=True) for ids in input_ids]\n sample_inputs.extend(input_texts)\n sample_uids.extend(test_batch.non_tensor_batch[\"uid\"])\n\n # evaluate using reward_function\n reward_tensor, reward_extra_info = extract_reward(test_batch)\n\n scores = reward_tensor.sum(-1).cpu().tolist()\n sample_scores.extend(scores)\n\n reward_extra_infos_dict[\"reward\"].extend(scores)\n for key, values in reward_extra_info.items():\n if key not in reward_extra_infos_dict:\n reward_extra_infos_dict[key] = []\n if isinstance(values, np.ndarray):\n reward_extra_infos_dict[key].extend(values.tolist())\n else:\n reward_extra_infos_dict[key].extend(values if isinstance(values, list) else [values])\n\n # collect num_turns of each prompt\n if \"__num_turns__\" in test_batch.non_tensor_batch:\n sample_turns.append(test_batch.non_tensor_batch[\"__num_turns__\"])\n\n data_source_lst.append(test_batch.non_tensor_batch.get(\"data_source\", [\"unknown\"] * reward_tensor.shape[0]))\n\n self._maybe_log_val_generations(inputs=sample_inputs, outputs=sample_outputs, scores=sample_scores)\n\n # dump generations\n val_data_dir = self.config.trainer.get(\"validation_data_dir\", None)\n if val_data_dir:\n self._dump_generations(\n inputs=sample_inputs,\n outputs=sample_outputs,\n gts=sample_gts,\n scores=sample_scores,\n reward_extra_infos_dict=reward_extra_infos_dict,\n dump_path=val_data_dir,\n )\n\n for key_info, lst in reward_extra_infos_dict.items():\n assert len(lst) == 0 or len(lst) == len(sample_scores), f\"{key_info}: {len(lst)=}, {len(sample_scores)=}\"\n\n if merged:\n print(\"_merge_validation_results validate result will be merged\")\n return {\n \"data_sources\": data_source_lst,\n \"sample_uids\": sample_uids,\n \"sample_turns\": sample_turns,\n \"reward_extra_infos_dict\": reward_extra_infos_dict,\n }\n data_sources = np.concatenate(data_source_lst, axis=0)\n return self._val_metrics_update(data_sources, sample_uids, reward_extra_infos_dict, sample_turns)\n\n def _val_metrics_update(self, data_sources, sample_uids, reward_extra_infos_dict, sample_turns):\n data_src2var2metric2val = process_validation_metrics(data_sources, sample_uids, reward_extra_infos_dict)\n metric_dict = {}\n for data_source, var2metric2val in data_src2var2metric2val.items():\n core_var = \"acc\" if \"acc\" in var2metric2val else \"reward\"\n for var_name, metric2val in var2metric2val.items():\n n_max = max([int(name.split(\"@\")[-1].split(\"/\")[0]) for name in metric2val.keys()])\n for metric_name, metric_val in metric2val.items():\n if (\n (var_name == core_var)\n and any(metric_name.startswith(pfx) for pfx in [\"mean\", \"maj\", \"best\"])\n and (f\"@{n_max}\" in metric_name)\n ):\n metric_sec = \"val-core\"\n else:\n metric_sec = \"val-aux\"\n pfx = f\"{metric_sec}/{data_source}/{var_name}/{metric_name}\"\n metric_dict[pfx] = metric_val\n\n if len(sample_turns) > 0:\n sample_turns = np.concatenate(sample_turns)\n metric_dict[\"val-aux/num_turns/min\"] = sample_turns.min()\n metric_dict[\"val-aux/num_turns/max\"] = sample_turns.max()\n metric_dict[\"val-aux/num_turns/mean\"] = sample_turns.mean()\n\n return metric_dict\n\n def _merge_validation_results(self, result_a, result_b):\n if result_a is None and result_b is None:\n return {}\n if result_a is None:\n result_a = {\"data_sources\": [], \"sample_uids\": [], \"sample_turns\": [], \"reward_extra_infos_dict\": {}}\n if result_b is None:\n result_b = {\"data_sources\": [], \"sample_uids\": [], \"sample_turns\": [], \"reward_extra_infos_dict\": {}}\n\n if not result_a.get(\"data_sources\") and not result_b.get(\"data_sources\"):\n return {}\n\n data_sources = np.concatenate(result_a[\"data_sources\"] + result_b[\"data_sources\"], axis=0)\n sample_uids = result_a[\"sample_uids\"] + result_b[\"sample_uids\"]\n sample_turns = result_a[\"sample_turns\"] + result_b[\"sample_turns\"]\n\n reward_extra_infos_dict = {}\n all_keys = set(result_a[\"reward_extra_infos_dict\"].keys()) | set(result_b[\"reward_extra_infos_dict\"].keys())\n for key in all_keys:\n list_a = result_a[\"reward_extra_infos_dict\"].get(key, [])\n list_b = result_b[\"reward_extra_infos_dict\"].get(key, [])\n reward_extra_infos_dict[key] = list_a + list_b\n\n return self._val_metrics_update(data_sources, sample_uids, reward_extra_infos_dict, sample_turns)\n\n def init_workers(self):\n \"\"\"Initialize distributed training workers using Ray backend.\n\n Creates:\n 1. Ray resource pools from configuration\n 2. Worker groups for each role (actor, critic, etc.)\n \"\"\"\n self.resource_pool_manager.create_resource_pool()\n\n self.resource_pool_to_cls = {pool: {} for pool in self.resource_pool_manager.resource_pool_dict.values()}\n\n # create actor and rollout\n actor_role = Role.ActorRolloutRef if Role.ActorRolloutRef in self.role_worker_mapping else Role.ActorRollout\n if self.hybrid_engine:\n actor_rollout_resource_pool = self.resource_pool_manager.get_resource_pool(actor_role)\n actor_rollout_cls = RayClassWithInitArgs(\n cls=self.role_worker_mapping[actor_role],\n config=self.config.actor_rollout_ref,\n role=str(actor_role),\n )\n self.resource_pool_to_cls[actor_rollout_resource_pool][str(actor_role)] = actor_rollout_cls\n else:\n raise NotImplementedError\n\n # create critic\n if self.use_critic:\n resource_pool = self.resource_pool_manager.get_resource_pool(Role.Critic)\n\n from verl.workers.config import CriticConfig\n\n critic_cfg: CriticConfig = omega_conf_to_dataclass(self.config.critic)\n\n if self.use_legacy_worker_impl == \"disable\":\n # convert critic_cfg into TrainingWorkerConfig\n from verl.workers.engine_workers import TrainingWorkerConfig\n\n orig_critic_cfg = critic_cfg\n if orig_critic_cfg.strategy == \"fsdp\":\n engine_config: FSDPEngineConfig = orig_critic_cfg.model.fsdp_config\n engine_config.infer_max_token_len_per_gpu = critic_cfg.ppo_infer_max_token_len_per_gpu\n engine_config.max_token_len_per_gpu = critic_cfg.ppo_max_token_len_per_gpu\n else:\n raise NotImplementedError(f\"Unknown strategy {orig_critic_cfg.strategy=}\")\n\n critic_cfg = TrainingWorkerConfig(\n model_type=\"value_model\",\n model_config=orig_critic_cfg.model_config,\n engine_config=engine_config,\n optimizer_config=orig_critic_cfg.optim,\n checkpoint_config=orig_critic_cfg.checkpoint,\n )\n\n critic_cls = RayClassWithInitArgs(cls=self.role_worker_mapping[Role.Critic], config=critic_cfg)\n self.resource_pool_to_cls[resource_pool][str(Role.Critic)] = critic_cls\n\n # create reference policy if needed\n if self.use_reference_policy and Role.RefPolicy in self.role_worker_mapping:\n resource_pool = self.resource_pool_manager.get_resource_pool(Role.RefPolicy)\n ref_policy_cls = RayClassWithInitArgs(\n self.role_worker_mapping[Role.RefPolicy],\n config=self.config.actor_rollout_ref,\n role=str(Role.RefPolicy),\n )\n self.resource_pool_to_cls[resource_pool][str(Role.RefPolicy)] = ref_policy_cls\n\n # initialize WorkerGroup\n # NOTE: if you want to use a different resource pool for each role, which can support different parallel size,\n # you should not use `create_colocated_worker_cls`.\n # Instead, directly pass different resource pool to different worker groups.\n # See https://github.com/volcengine/verl/blob/master/examples/ray/tutorial.ipynb for more information.\n all_wg = {}\n wg_kwargs = {} # Setting up kwargs for RayWorkerGroup\n if OmegaConf.select(self.config.trainer, \"ray_wait_register_center_timeout\") is not None:\n wg_kwargs[\"ray_wait_register_center_timeout\"] = self.config.trainer.ray_wait_register_center_timeout\n if OmegaConf.select(self.config.global_profiler, \"steps\") is not None:\n wg_kwargs[\"profile_steps\"] = OmegaConf.select(self.config.global_profiler, \"steps\")\n # Only require nsight worker options when tool is nsys\n if OmegaConf.select(self.config.global_profiler, \"tool\") == \"nsys\":\n assert (\n OmegaConf.select(self.config.global_profiler.global_tool_config.nsys, \"worker_nsight_options\")\n is not None\n ), \"worker_nsight_options must be set when using nsys with profile_steps\"\n wg_kwargs[\"worker_nsight_options\"] = OmegaConf.to_container(\n OmegaConf.select(self.config.global_profiler.global_tool_config.nsys, \"worker_nsight_options\")\n )\n wg_kwargs[\"device_name\"] = self.device_name\n\n for resource_pool, class_dict in self.resource_pool_to_cls.items():\n worker_dict_cls = create_colocated_worker_cls(class_dict=class_dict)\n wg_dict = self.ray_worker_group_cls(\n resource_pool=resource_pool,\n ray_cls_with_init=worker_dict_cls,\n **wg_kwargs,\n )\n spawn_wg = wg_dict.spawn(prefix_set=class_dict.keys())\n all_wg.update(spawn_wg)\n\n if self.use_critic:\n self.critic_wg = all_wg[str(Role.Critic)]\n if self.use_legacy_worker_impl == \"disable\":\n self.critic_wg.reset()\n # assign critic loss\n from functools import partial\n\n from verl.workers.utils.losses import value_loss\n\n value_loss_ = partial(value_loss, config=orig_critic_cfg)\n self.critic_wg.set_loss_fn(value_loss_)\n else:\n self.critic_wg.init_model()\n\n if self.use_reference_policy and not self.ref_in_actor:\n if str(Role.RefPolicy) in all_wg:\n self.ref_policy_wg = all_wg[str(Role.RefPolicy)]\n self.ref_policy_wg.init_model()\n else:\n # Model engine: ActorRolloutRefWorker\n assert str(Role.ActorRolloutRef) in all_wg, f\"{all_wg.keys()=}\"\n self.ref_policy_wg = all_wg[str(Role.ActorRolloutRef)]\n\n # we should create rollout at the end so that vllm can have a better estimation of kv cache memory\n self.actor_rollout_wg = all_wg[str(actor_role)]\n self.actor_rollout_wg.init_model()\n\n if self.ref_in_actor:\n self.ref_policy_wg = self.actor_rollout_wg\n\n # create reward loop manager\n from verl.experimental.reward_loop import RewardLoopManager\n\n # initalize reward loop manager\n # reward model (colocate or standalone): get resource_pool\n # no reward model: resource_pool = None\n resource_pool = self.resource_pool_manager.get_resource_pool(Role.RewardModel) if self.use_rm else None\n self.reward_loop_manager = RewardLoopManager(\n config=self.config,\n rm_resource_pool=resource_pool,\n )\n\n # create async rollout manager and request scheduler\n # Note: mode is always \"async\" since sync mode is deprecated\n self.async_rollout_mode = True\n\n # Support custom AgentLoopManager via config\n manager_class_fqn = self.config.actor_rollout_ref.rollout.get(\"agent\", {}).get(\"agent_loop_manager_class\")\n if manager_class_fqn:\n AgentLoopManager = load_class_from_fqn(manager_class_fqn, \"AgentLoopManager\")\n else:\n from verl.experimental.agent_loop import AgentLoopManager\n\n # infrastructure overview: https://verl.readthedocs.io/en/latest/advance/reward_loop.html#architecture-design\n # agent_reward_loop: streaming reward computation with actor rollout\n # two conditions satisfied: (1) no reward model, or (2) reward model with extra resource pool\n enable_agent_reward_loop = not self.use_rm or self.config.reward.reward_model.enable_resource_pool\n\n # if enable_agent_reward_loop, we directly pass reward_loop_workers to agent loop manager\n # to stream reward computation with actor rollout\n reward_loop_worker_handles = self.reward_loop_manager.reward_loop_workers if enable_agent_reward_loop else None\n self.async_rollout_manager = AgentLoopManager(\n config=self.config,\n worker_group=self.actor_rollout_wg,\n rollout_resource_pool=actor_rollout_resource_pool,\n reward_loop_worker_handles=reward_loop_worker_handles,\n )\n\n self.checkpoint_manager = CheckpointEngineManager(\n backend=self.config.actor_rollout_ref.rollout.checkpoint_engine.backend,\n trainer=self.actor_rollout_wg,\n replicas=self.async_rollout_manager.rollout_replicas,\n )\n\n # sleep all replicas to load checkpoint\n self.checkpoint_manager.sleep_replicas()\n\n def _save_checkpoint(self):\n from verl.utils.fs import local_mkdir_safe\n\n # path: given_path + `/global_step_{global_steps}` + `/actor`\n local_global_step_folder = os.path.join(\n self.config.trainer.default_local_dir, f\"global_step_{self.global_steps}\"\n )\n\n print(f\"local_global_step_folder: {local_global_step_folder}\")\n actor_local_path = os.path.join(local_global_step_folder, \"actor\")\n\n actor_remote_path = (\n None\n if self.config.trainer.default_hdfs_dir is None\n else os.path.join(self.config.trainer.default_hdfs_dir, f\"global_step_{self.global_steps}\", \"actor\")\n )\n\n remove_previous_ckpt_in_save = self.config.trainer.get(\"remove_previous_ckpt_in_save\", False)\n if remove_previous_ckpt_in_save:\n print(\n \"Warning: remove_previous_ckpt_in_save is deprecated,\"\n + \" set max_actor_ckpt_to_keep=1 and max_critic_ckpt_to_keep=1 instead\"\n )\n max_actor_ckpt_to_keep = (\n self.config.trainer.get(\"max_actor_ckpt_to_keep\", None) if not remove_previous_ckpt_in_save else 1\n )\n max_critic_ckpt_to_keep = (\n self.config.trainer.get(\"max_critic_ckpt_to_keep\", None) if not remove_previous_ckpt_in_save else 1\n )\n\n self.actor_rollout_wg.save_checkpoint(\n actor_local_path, actor_remote_path, self.global_steps, max_ckpt_to_keep=max_actor_ckpt_to_keep\n )\n\n if self.use_critic:\n critic_local_path = os.path.join(local_global_step_folder, str(Role.Critic))\n critic_remote_path = (\n None\n if self.config.trainer.default_hdfs_dir is None\n else os.path.join(\n self.config.trainer.default_hdfs_dir, f\"global_step_{self.global_steps}\", str(Role.Critic)\n )\n )\n self.critic_wg.save_checkpoint(\n critic_local_path, critic_remote_path, self.global_steps, max_ckpt_to_keep=max_critic_ckpt_to_keep\n )\n\n # save dataloader\n local_mkdir_safe(local_global_step_folder)\n dataloader_local_path = os.path.join(local_global_step_folder, \"data.pt\")\n dataloader_state_dict = self.train_dataloader.state_dict()\n torch.save(dataloader_state_dict, dataloader_local_path)\n\n # latest checkpointed iteration tracker (for atomic usage)\n if (\n hasattr(self.config.actor_rollout_ref.actor.checkpoint, \"async_save\")\n and self.config.actor_rollout_ref.actor.checkpoint.async_save\n ) or (\n \"async_save\" in self.config.actor_rollout_ref.actor.checkpoint\n and self.config.actor_rollout_ref.actor.checkpoint[\"async_save\"]\n ):\n print(\"skip write latest_checkpointed_iteration.txt when async_save is True\")\n return\n local_latest_checkpointed_iteration = os.path.join(\n self.config.trainer.default_local_dir, \"latest_checkpointed_iteration.txt\"\n )\n with open(local_latest_checkpointed_iteration, \"w\") as f:\n f.write(str(self.global_steps))\n\n def _load_checkpoint(self):\n if self.config.trainer.resume_mode == \"disable\":\n return 0\n\n # load from hdfs\n if self.config.trainer.default_hdfs_dir is not None:\n raise NotImplementedError(\"load from hdfs is not implemented yet\")\n else:\n checkpoint_folder = self.config.trainer.default_local_dir # TODO: check path\n if not os.path.isabs(checkpoint_folder):\n working_dir = os.getcwd()\n checkpoint_folder = os.path.join(working_dir, checkpoint_folder)\n global_step_folder = find_latest_ckpt_path(checkpoint_folder) # None if no latest\n\n # find global_step_folder\n if self.config.trainer.resume_mode == \"auto\":\n if global_step_folder is None:\n print(\"Training from scratch\")\n return 0\n else:\n if self.config.trainer.resume_mode == \"resume_path\":\n assert isinstance(self.config.trainer.resume_from_path, str), \"resume ckpt must be str type\"\n assert \"global_step_\" in self.config.trainer.resume_from_path, (\n \"resume ckpt must specify the global_steps\"\n )\n global_step_folder = self.config.trainer.resume_from_path\n if not os.path.isabs(global_step_folder):\n working_dir = os.getcwd()\n global_step_folder = os.path.join(working_dir, global_step_folder)\n print(f\"Load from checkpoint folder: {global_step_folder}\")\n # set global step\n self.global_steps = int(global_step_folder.split(\"global_step_\")[-1])\n\n print(f\"Setting global step to {self.global_steps}\")\n print(f\"Resuming from {global_step_folder}\")\n\n actor_path = os.path.join(global_step_folder, \"actor\")\n critic_path = os.path.join(global_step_folder, str(Role.Critic))\n # load actor\n self.actor_rollout_wg.load_checkpoint(\n actor_path, del_local_after_load=self.config.trainer.del_local_ckpt_after_load\n )\n # load critic\n if self.use_critic:\n self.critic_wg.load_checkpoint(\n critic_path, del_local_after_load=self.config.trainer.del_local_ckpt_after_load\n )\n\n # load dataloader,\n # TODO: from remote not implemented yet\n dataloader_local_path = os.path.join(global_step_folder, \"data.pt\")\n if os.path.exists(dataloader_local_path):\n dataloader_state_dict = torch.load(dataloader_local_path, weights_only=False)\n self.train_dataloader.load_state_dict(dataloader_state_dict)\n else:\n print(f\"Warning: No dataloader state found at {dataloader_local_path}, will start from scratch\")\n\n def _start_profiling(self, do_profile: bool) -> None:\n \"\"\"Start profiling for all worker groups if profiling is enabled.\"\"\"\n if do_profile:\n self.actor_rollout_wg.start_profile(role=\"e2e\", profile_step=self.global_steps)\n if self.use_reference_policy:\n self.ref_policy_wg.start_profile(profile_step=self.global_steps)\n if self.use_critic:\n self.critic_wg.start_profile(profile_step=self.global_steps)\n\n def _stop_profiling(self, do_profile: bool) -> None:\n \"\"\"Stop profiling for all worker groups if profiling is enabled.\"\"\"\n if do_profile:\n self.actor_rollout_wg.stop_profile()\n if self.use_reference_policy:\n self.ref_policy_wg.stop_profile()\n if self.use_critic:\n self.critic_wg.stop_profile()\n\n def _get_dp_size(self, worker_group, role: str) -> int:\n \"\"\"Get data parallel size from worker group dispatch info.\n\n This method retrieves the data parallel size by querying the dispatch info\n for the specified role. The dispatch info is cached for subsequent calls.\n\n Args:\n worker_group: The worker group to query dispatch info from.\n role: The role name (e.g., \"actor\", \"critic\") to get DP size for.\n\n Returns:\n The data parallel size (number of DP ranks).\n \"\"\"\n if role not in worker_group._dispatch_info:\n dp_rank_mapping = worker_group._query_dispatch_info(role)\n worker_group._dispatch_info[role] = dp_rank_mapping\n else:\n dp_rank_mapping = worker_group._dispatch_info[role]\n return max(dp_rank_mapping) + 1\n\n def _balance_batch(self, batch: DataProto, metrics, logging_prefix=\"global_seqlen\", keep_minibatch=False):\n \"\"\"Reorder the data on single controller such that each dp rank gets similar total tokens.\n\n When use_prefix_grouper is enabled, uses group-level balancing to keep samples with\n the same uid together on the same rank for prefix sharing optimization.\n \"\"\"\n attention_mask = batch.batch[\"attention_mask\"]\n batch_size = attention_mask.shape[0]\n global_seqlen_lst = batch.batch[\"attention_mask\"].view(batch_size, -1).sum(-1) # (train_batch_size,)\n workload_lst = calculate_workload(global_seqlen_lst)\n # Get dp_size from dispatch info to correctly balance across data parallel ranks\n # Note: world_size may include tensor/pipeline parallel dimensions, but we only want DP\n dp_size = self._get_dp_size(self.actor_rollout_wg, \"actor\")\n\n # Use group-level balancing for PrefixGrouper to keep same-uid samples together\n if getattr(self, \"use_prefix_grouper\", False) and \"uid\" in batch.non_tensor_batch:\n from verl.utils.seqlen_balancing import get_group_balanced_partitions\n\n uid_list = list(batch.non_tensor_batch[\"uid\"])\n seqlen_list = global_seqlen_lst.tolist()\n\n # Count number of uid groups\n num_groups = len(set(uid_list))\n\n if num_groups % dp_size != 0:\n raise ValueError(\n f\"PrefixGrouper with balance_batch requires num_uid_groups ({num_groups}) \"\n f\"% dp_size ({dp_size}) == 0. \"\n f\"This ensures each rank gets equal number of groups. \"\n f\"Current batch_size={batch_size}, adjust batch_size to be a multiple of \"\n f\"dp_size * rollout.n.\"\n )\n\n global_partition_lst = get_group_balanced_partitions(\n seqlen_list=seqlen_list,\n uid_list=uid_list,\n k_partitions=dp_size,\n )\n\n elif keep_minibatch:\n # Decouple the DP balancing and mini-batching.\n minibatch_size = self.config.actor_rollout_ref.actor.get(\"ppo_mini_batch_size\")\n minibatch_num = len(workload_lst) // minibatch_size\n global_partition_lst = [[] for _ in range(dp_size)]\n for i in range(minibatch_num):\n rearrange_minibatch_lst = get_seqlen_balanced_partitions(\n workload_lst[i * minibatch_size : (i + 1) * minibatch_size],\n k_partitions=dp_size,\n equal_size=True,\n )\n for j, part in enumerate(rearrange_minibatch_lst):\n global_partition_lst[j].extend([x + minibatch_size * i for x in part])\n else:\n global_partition_lst = get_seqlen_balanced_partitions(workload_lst, k_partitions=dp_size, equal_size=True)\n # Place smaller micro-batches at both ends to reduce the bubbles in pipeline parallel.\n # Skip reordering within partitions for PrefixGrouper to maintain uid grouping\n if not getattr(self, \"use_prefix_grouper\", False):\n for idx, partition in enumerate(global_partition_lst):\n partition.sort(key=lambda x: (workload_lst[x], x))\n ordered_partition = partition[::2] + partition[1::2][::-1]\n global_partition_lst[idx] = ordered_partition\n\n # reorder based on index. The data will be automatically equally partitioned by dispatch function\n global_idx = torch.tensor([j for partition in global_partition_lst for j in partition])\n batch.reorder(global_idx)\n global_balance_stats = log_seqlen_unbalance(\n seqlen_list=global_seqlen_lst.tolist(), partitions=global_partition_lst, prefix=logging_prefix\n )\n metrics.update(global_balance_stats)\n\n def _compute_values(self, batch: DataProto) -> DataProto:\n if self.use_legacy_worker_impl == \"disable\":\n batch_td = batch.to_tensordict()\n # step 2: convert from padding to nopadding\n batch_td = left_right_2_no_padding(batch_td)\n # step 3: add meta info\n tu.assign_non_tensor(batch_td, compute_loss=False)\n output = self.critic_wg.infer_batch(batch_td)\n output = output.get()\n values = tu.get(output, \"values\")\n values = no_padding_2_padding(values, batch_td)\n values = tu.get_tensordict({\"values\": values.float()})\n values = DataProto.from_tensordict(values)\n else:\n values = self.critic_wg.compute_values(batch)\n return values\n\n def _compute_ref_log_prob(self, batch: DataProto) -> DataProto:\n if self.use_legacy_worker_impl == \"disable\":\n # step 1: convert dataproto to tensordict.\n batch_td = batch.to_tensordict()\n # step 2: convert from padding to nopadding\n batch_td = left_right_2_no_padding(batch_td)\n # step 3: add meta info\n metadata = {\"calculate_entropy\": False, \"compute_loss\": False}\n if self.ref_in_actor:\n metadata[\"no_lora_adapter\"] = True\n tu.assign_non_tensor(batch_td, **metadata)\n if self.ref_in_actor:\n output = self.actor_rollout_wg.compute_log_prob(batch_td)\n else:\n output = self.ref_policy_wg.compute_ref_log_prob(batch_td)\n # gather output\n log_probs = tu.get(output, \"log_probs\")\n # step 4. No padding to padding\n log_probs = no_padding_2_padding(log_probs, batch_td)\n # step 5: rebuild a tensordict and convert to dataproto\n ref_log_prob = tu.get_tensordict({\"ref_log_prob\": log_probs.float()})\n ref_log_prob = DataProto.from_tensordict(ref_log_prob)\n else:\n ref_log_prob = self.ref_policy_wg.compute_ref_log_prob(batch)\n\n return ref_log_prob\n\n def _compute_old_log_prob(self, batch: DataProto):\n if self.use_legacy_worker_impl == \"disable\":\n # TODO: remove step 1, 2, 4 after we make the whole training tensordict and padding free\n # step 1: convert dataproto to tensordict.\n batch_td = batch.to_tensordict()\n # step 2: convert from padding to nopadding\n batch_td = left_right_2_no_padding(batch_td)\n # step 3: add meta info\n tu.assign_non_tensor(batch_td, calculate_entropy=True, compute_loss=False)\n output = self.actor_rollout_wg.compute_log_prob(batch_td)\n # gather output\n entropy = tu.get(output, \"entropy\")\n log_probs = tu.get(output, \"log_probs\")\n old_log_prob_mfu = tu.get(output, \"metrics\")[\"mfu\"]\n # step 4. No padding to padding\n entropy = no_padding_2_padding(entropy, batch_td)\n log_probs = no_padding_2_padding(log_probs, batch_td)\n # step 5: rebuild a tensordict and convert to dataproto\n old_log_prob = tu.get_tensordict({\"old_log_probs\": log_probs.float(), \"entropys\": entropy.float()})\n old_log_prob = DataProto.from_tensordict(old_log_prob)\n else:\n old_log_prob = self.actor_rollout_wg.compute_log_prob(batch)\n old_log_prob_mfu = 0\n return old_log_prob, old_log_prob_mfu\n\n def _update_actor(self, batch: DataProto) -> DataProto:\n rollout_config = self.config.actor_rollout_ref.rollout\n batch.meta_info[\"multi_turn\"] = rollout_config.multi_turn.enable\n # TODO: Make \"temperature\" single source of truth from generation.\n batch.meta_info[\"temperature\"] = rollout_config.temperature\n # update actor\n if self.use_legacy_worker_impl == \"disable\":\n batch_td = batch.to_tensordict()\n # step 2: convert from padding to no-padding\n batch_td = left_right_2_no_padding(batch_td)\n calculate_entropy = self.config.actor_rollout_ref.actor.entropy_coeff != 0.0\n ppo_mini_batch_size = self.config.actor_rollout_ref.actor.ppo_mini_batch_size\n ppo_mini_batch_size = ppo_mini_batch_size * self.config.actor_rollout_ref.rollout.n\n ppo_epochs = self.config.actor_rollout_ref.actor.ppo_epochs\n seed = self.config.actor_rollout_ref.actor.data_loader_seed\n shuffle = self.config.actor_rollout_ref.actor.shuffle\n tu.assign_non_tensor(\n batch_td,\n calculate_entropy=calculate_entropy,\n global_batch_size=ppo_mini_batch_size,\n mini_batch_size=ppo_mini_batch_size,\n epochs=ppo_epochs,\n seed=seed,\n dataloader_kwargs={\"shuffle\": shuffle},\n )\n\n actor_output = self.actor_rollout_wg.update_actor(batch_td)\n actor_output = tu.get(actor_output, \"metrics\")\n actor_output = rename_dict(actor_output, \"actor/\")\n # modify key name\n actor_output[\"perf/mfu/actor\"] = actor_output.pop(\"actor/mfu\")\n actor_output = DataProto.from_single_dict(data={}, meta_info={\"metrics\": actor_output})\n else:\n actor_output = self.actor_rollout_wg.update_actor(batch)\n\n return actor_output\n\n def _update_critic(self, batch: DataProto) -> DataProto:\n if self.use_legacy_worker_impl == \"disable\":\n batch_td = batch.to_tensordict()\n # step 2: convert from padding to no-padding\n batch_td = left_right_2_no_padding(batch_td)\n ppo_mini_batch_size = self.config.critic.ppo_mini_batch_size\n ppo_mini_batch_size = ppo_mini_batch_size * self.config.actor_rollout_ref.rollout.n\n ppo_epochs = self.config.critic.ppo_epochs\n seed = self.config.critic.data_loader_seed\n shuffle = self.config.critic.shuffle\n tu.assign_non_tensor(\n batch_td,\n global_batch_size=ppo_mini_batch_size,\n mini_batch_size=ppo_mini_batch_size,\n epochs=ppo_epochs,\n seed=seed,\n dataloader_kwargs={\"shuffle\": shuffle},\n )\n\n output = self.critic_wg.train_mini_batch(batch_td)\n output = output.get()\n output = tu.get(output, \"metrics\")\n output = rename_dict(output, \"critic/\")\n # modify key name\n output[\"perf/mfu/critic\"] = output.pop(\"critic/mfu\")\n critic_output = DataProto.from_single_dict(data={}, meta_info={\"metrics\": output})\n else:\n critic_output = self.critic_wg.update_critic(batch)\n return critic_output\n\n def fit(self):\n \"\"\"\n The training loop of PPO.\n The driver process only need to call the compute functions of the worker group through RPC\n to construct the PPO dataflow.\n The light-weight advantage computation is done on the driver process.\n \"\"\"\n from omegaconf import OmegaConf\n\n from verl.utils.tracking import Tracking\n\n logger = Tracking(\n project_name=self.config.trainer.project_name,\n experiment_name=self.config.trainer.experiment_name,\n default_backend=self.config.trainer.logger,\n config=OmegaConf.to_container(self.config, resolve=True),\n )\n\n self.global_steps = 0\n\n # load checkpoint and update weights before doing anything\n self._load_checkpoint()\n self.checkpoint_manager.update_weights()\n\n current_epoch = self.global_steps // len(self.train_dataloader)\n\n # perform validation before training\n # currently, we only support validation using the reward_function.\n if self.config.trainer.get(\"val_before_train\", True):\n val_metrics = self._validate()\n assert val_metrics, f\"{val_metrics=}\"\n pprint(f\"Initial validation metrics: {val_metrics}\")\n logger.log(data=val_metrics, step=self.global_steps)\n if self.config.trainer.get(\"val_only\", False):\n return\n\n if self.config.actor_rollout_ref.rollout.get(\"skip_rollout\", False):\n rollout_skip = RolloutSkip(self.config, self.async_rollout_manager)\n rollout_skip.wrap_generate_sequences()\n\n # add tqdm\n progress_bar = tqdm(total=self.total_training_steps, initial=self.global_steps, desc=\"Training Progress\")\n\n # we start from step 1\n self.global_steps += 1\n last_val_metrics = None\n self.max_steps_duration = 0\n\n prev_step_profile = False\n curr_step_profile = (\n self.global_steps in self.config.global_profiler.steps\n if self.config.global_profiler.steps is not None\n else False\n )\n next_step_profile = False\n\n for epoch in range(current_epoch, self.config.trainer.total_epochs):\n for batch_dict in self.train_dataloader:\n if hasattr(self.actor_rollout_wg, \"async_calls_finalize_fn_exec\"):\n self.actor_rollout_wg.async_calls_finalize_fn_exec(blocking=False)\n metrics = {}\n timing_raw = {}\n\n with marked_timer(\"start_profile\", timing_raw):\n self._start_profiling(\n not prev_step_profile and curr_step_profile\n if self.config.global_profiler.profile_continuous_steps\n else curr_step_profile\n )\n batch: DataProto = DataProto.from_single_dict(batch_dict)\n batch.meta_info[\"temperature\"] = self.config.actor_rollout_ref.rollout.temperature\n\n # add uid to batch\n batch.non_tensor_batch[\"uid\"] = np.array(\n [str(uuid.uuid4()) for _ in range(len(batch.batch))], dtype=object\n )\n\n gen_batch = self._get_gen_batch(batch)\n\n # pass global_steps to trace\n gen_batch.meta_info[\"global_steps\"] = self.global_steps\n gen_batch_output = gen_batch.repeat(\n repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True\n )\n\n is_last_step = self.global_steps >= self.total_training_steps\n with marked_timer(\"step\", timing_raw):\n # generate a batch\n with marked_timer(\"gen\", timing_raw, color=\"red\"):\n if curr_step_profile:\n self.async_rollout_manager.start_profile()\n gen_batch_output = self.async_rollout_manager.generate_sequences(gen_batch_output)\n self.checkpoint_manager.sleep_replicas()\n if curr_step_profile:\n self.async_rollout_manager.stop_profile()\n\n timing_raw.update(gen_batch_output.meta_info[\"timing\"])\n gen_batch_output.meta_info.pop(\"timing\", None)\n\n if self.config.algorithm.adv_estimator == AdvantageEstimator.REMAX:\n with marked_timer(\"gen_max\", timing_raw, color=\"purple\"):\n gen_baseline_batch = deepcopy(gen_batch)\n gen_baseline_batch.meta_info[\"do_sample\"] = False\n if curr_step_profile:\n self.async_rollout_manager.start_profile()\n gen_baseline_output = self.async_rollout_manager.generate_sequences(gen_baseline_batch)\n self.checkpoint_manager.sleep_replicas()\n if curr_step_profile:\n self.async_rollout_manager.stop_profile()\n batch = batch.union(gen_baseline_output)\n # compute reward model score on batch\n rm_scores = None\n if self.use_rm and \"rm_scores\" not in batch.batch.keys():\n batch_reward = self._compute_reward_colocate(batch)\n batch = batch.union(batch_reward)\n\n # Compute or extract reward for REMAX baseline\n reward_baseline_tensor = batch.batch[\"rm_scores\"].sum(dim=-1)\n\n keys_to_pop = set(gen_baseline_output.batch.keys())\n if rm_scores is not None:\n keys_to_pop.update(rm_scores.batch.keys())\n batch.pop(batch_keys=list(keys_to_pop))\n\n batch.batch[\"reward_baselines\"] = reward_baseline_tensor\n\n del rm_scores, gen_baseline_batch, gen_baseline_output\n # repeat to align with repeated responses in rollout\n batch = batch.repeat(repeat_times=self.config.actor_rollout_ref.rollout.n, interleave=True)\n batch = batch.union(gen_batch_output)\n\n if \"response_mask\" not in batch.batch.keys():\n batch.batch[\"response_mask\"] = compute_response_mask(batch)\n # Balance the number of valid tokens across DP ranks.\n # NOTE: This usually changes the order of data in the `batch`,\n # which won't affect the advantage calculation (since it's based on uid),\n # but might affect the loss calculation (due to the change of mini-batching).\n if self.config.trainer.balance_batch:\n self._balance_batch(batch, metrics=metrics)\n\n # compute global_valid tokens\n batch.meta_info[\"global_token_num\"] = torch.sum(batch.batch[\"attention_mask\"], dim=-1).tolist()\n # get images_seqlens\n images_seqlens_all = []\n for multi_modal_input in batch.non_tensor_batch[\"multi_modal_inputs\"]:\n if \"image_grid_thw\" not in multi_modal_input.keys():\n continue\n images_seqlens_all.extend(multi_modal_input[\"images_seqlens\"].tolist())\n batch.meta_info[\"images_seqlens\"] = images_seqlens_all\n with marked_timer(\"reward\", timing_raw, color=\"yellow\"):\n # compute reward model score\n if self.use_rm and \"rm_scores\" not in batch.batch.keys():\n batch_reward = self._compute_reward_colocate(batch)\n batch = batch.union(batch_reward)\n\n # extract reward_tensor and reward_extra_infos_dict for training\n reward_tensor, reward_extra_infos_dict = extract_reward(batch)\n\n # Operating Mode Selection:\n # - Bypass mode: Sets old_log_probs = rollout_log_probs (2 policies: π_rollout, π_θ)\n # - Decoupled mode: Recomputes old_log_probs as proximal anchor (3 policies: π_rollout, π_old, π_θ)\n # Note: π_old computed once per data batch, serves as stable reference during mini-batch updates\n rollout_corr_config = self.config.algorithm.get(\"rollout_correction\", None)\n bypass_recomputing_logprobs = rollout_corr_config and rollout_corr_config.get(\"bypass_mode\", False)\n if bypass_recomputing_logprobs: # Use `rollout_log_probs`\n from verl.trainer.ppo.rollout_corr_helper import apply_bypass_mode\n\n apply_bypass_mode(\n batch=batch,\n rollout_corr_config=rollout_corr_config,\n policy_loss_config=self.config.actor_rollout_ref.actor.policy_loss,\n )\n else: # Recompute old_log_probs\n with marked_timer(\"old_log_prob\", timing_raw, color=\"blue\"):\n old_log_prob, old_log_prob_mfu = self._compute_old_log_prob(batch)\n entropys = old_log_prob.batch[\"entropys\"]\n response_masks = batch.batch[\"response_mask\"]\n actor_config = self.config.actor_rollout_ref.actor\n entropy_agg = agg_loss(\n loss_mat=entropys,\n loss_mask=response_masks,\n loss_agg_mode=actor_config.loss_agg_mode,\n loss_scale_factor=actor_config.loss_scale_factor,\n )\n old_log_prob_metrics = {\n \"actor/entropy\": entropy_agg.detach().item(),\n \"perf/mfu/actor_infer\": old_log_prob_mfu,\n }\n metrics.update(old_log_prob_metrics)\n old_log_prob.batch.pop(\"entropys\")\n if \"routed_experts\" in batch.batch and \"routed_experts\" in old_log_prob.batch:\n router_mode = getattr(\n self.config.actor_rollout_ref.actor.router_replay, \"mode\", \"disabled\"\n )\n if router_mode == \"R2\":\n batch.batch.pop(\"routed_experts\")\n else:\n old_log_prob.batch.pop(\"routed_experts\")\n batch = batch.union(old_log_prob)\n if \"rollout_log_probs\" in batch.batch.keys():\n # TODO: we may want to add diff of probs too.\n from verl.utils.debug.metrics import calculate_debug_metrics\n\n metrics.update(calculate_debug_metrics(batch))\n\n assert \"old_log_probs\" in batch.batch, f'\"old_log_prob\" not in {batch.batch.keys()=}'\n\n if self.use_reference_policy:\n # compute reference log_prob\n with marked_timer(str(Role.RefPolicy), timing_raw, color=\"olive\"):\n ref_log_prob = self._compute_ref_log_prob(batch)\n batch = batch.union(ref_log_prob)\n\n # compute values\n if self.use_critic:\n with marked_timer(\"values\", timing_raw, color=\"cyan\"):\n values = self._compute_values(batch)\n batch = batch.union(values)\n\n with marked_timer(\"adv\", timing_raw, color=\"brown\"):\n # we combine with rule-based rm\n reward_extra_infos_dict: dict[str, list]\n batch.batch[\"token_level_scores\"] = reward_tensor\n\n if reward_extra_infos_dict:\n batch.non_tensor_batch.update({k: np.array(v) for k, v in reward_extra_infos_dict.items()})\n\n # compute rewards. apply_kl_penalty if available\n if self.config.algorithm.use_kl_in_reward:\n batch, kl_metrics = apply_kl_penalty(\n batch, kl_ctrl=self.kl_ctrl_in_reward, kl_penalty=self.config.algorithm.kl_penalty\n )\n metrics.update(kl_metrics)\n else:\n batch.batch[\"token_level_rewards\"] = batch.batch[\"token_level_scores\"]\n\n # Compute rollout correction: IS weights, rejection sampling, and metrics\n # Only runs in decoupled mode (computes once per batch using stable π_old)\n # In bypass mode, this is skipped - actor computes metrics from evolving π_θ vs π_rollout\n if (\n rollout_corr_config is not None\n and \"rollout_log_probs\" in batch.batch\n and not bypass_recomputing_logprobs # Only in decoupled mode\n ):\n from verl.trainer.ppo.rollout_corr_helper import compute_rollout_correction_and_add_to_batch\n\n # Compute IS weights, apply rejection sampling, compute metrics\n batch, is_metrics = compute_rollout_correction_and_add_to_batch(batch, rollout_corr_config)\n # IS and off-policy metrics already have rollout_corr/ prefix\n metrics.update(is_metrics)\n\n # compute advantages, executed on the driver process\n norm_adv_by_std_in_grpo = self.config.algorithm.get(\n \"norm_adv_by_std_in_grpo\", True\n ) # GRPO adv normalization factor\n\n batch = compute_advantage(\n batch,\n adv_estimator=self.config.algorithm.adv_estimator,\n gamma=self.config.algorithm.gamma,\n lam=self.config.algorithm.lam,\n num_repeat=self.config.actor_rollout_ref.rollout.n,\n norm_adv_by_std_in_grpo=norm_adv_by_std_in_grpo,\n config=self.config.algorithm,\n )\n\n # update critic\n if self.use_critic:\n with marked_timer(\"update_critic\", timing_raw, color=\"pink\"):\n critic_output = self._update_critic(batch)\n critic_output_metrics = reduce_metrics(critic_output.meta_info[\"metrics\"])\n metrics.update(critic_output_metrics)\n\n # implement critic warmup\n if self.config.trainer.critic_warmup <= self.global_steps:\n # update actor\n with marked_timer(\"update_actor\", timing_raw, color=\"red\"):\n actor_output = self._update_actor(batch)\n\n # Check if the ESI (Elastic Server Instance)/training plan is close to expiration.\n esi_close_to_expiration = should_save_ckpt_esi(\n max_steps_duration=self.max_steps_duration,\n redundant_time=self.config.trainer.esi_redundant_time,\n )\n # Check if the conditions for saving a checkpoint are met.\n # The conditions include a mandatory condition (1) and\n # one of the following optional conditions (2/3/4):\n # 1. The save frequency is set to a positive value.\n # 2. It's the last training step.\n # 3. The current step number is a multiple of the save frequency.\n # 4. The ESI(Elastic Server Instance)/training plan is close to expiration.\n if self.config.trainer.save_freq > 0 and (\n is_last_step\n or self.global_steps % self.config.trainer.save_freq == 0\n or esi_close_to_expiration\n ):\n if esi_close_to_expiration:\n print(\"Force saving checkpoint: ESI instance expiration approaching.\")\n with marked_timer(\"save_checkpoint\", timing_raw, color=\"green\"):\n self._save_checkpoint()\n\n # update weights from trainer to rollout\n with marked_timer(\"update_weights\", timing_raw, color=\"red\"):\n self.checkpoint_manager.update_weights()\n\n actor_output_metrics = reduce_metrics(actor_output.meta_info[\"metrics\"])\n metrics.update(actor_output_metrics)\n\n # Log rollout generations if enabled\n rollout_data_dir = self.config.trainer.get(\"rollout_data_dir\", None)\n if rollout_data_dir:\n self._log_rollout_data(batch, reward_extra_infos_dict, timing_raw, rollout_data_dir)\n\n # validate\n if self.config.trainer.test_freq > 0 and (\n is_last_step or self.global_steps % self.config.trainer.test_freq == 0\n ):\n with marked_timer(\"testing\", timing_raw, color=\"green\"):\n val_metrics: dict = self._validate()\n if is_last_step:\n last_val_metrics = val_metrics\n metrics.update(val_metrics)\n\n with marked_timer(\"stop_profile\", timing_raw):\n next_step_profile = (\n self.global_steps + 1 in self.config.global_profiler.steps\n if self.config.global_profiler.steps is not None\n else False\n )\n self._stop_profiling(\n curr_step_profile and not next_step_profile\n if self.config.global_profiler.profile_continuous_steps\n else curr_step_profile\n )\n prev_step_profile = curr_step_profile\n curr_step_profile = next_step_profile\n\n steps_duration = timing_raw[\"step\"]\n self.max_steps_duration = max(self.max_steps_duration, steps_duration)\n\n # training metrics\n metrics.update(\n {\n \"training/global_step\": self.global_steps,\n \"training/epoch\": epoch,\n }\n )\n # collect metrics\n metrics.update(compute_data_metrics(batch=batch, use_critic=self.use_critic))\n metrics.update(compute_timing_metrics(batch=batch, timing_raw=timing_raw))\n # TODO: implement actual tflpo and theoretical tflpo\n n_gpus = self.resource_pool_manager.get_n_gpus()\n metrics.update(compute_throughout_metrics(batch=batch, timing_raw=timing_raw, n_gpus=n_gpus))\n # compute variance proxy metrics\n gradient_norm = metrics.get(\"actor/grad_norm\", None)\n metrics.update(compute_variance_proxy_metrics(batch=batch, gradient_norm=gradient_norm))\n # Note: mismatch metrics (KL, PPL, etc.) are collected at line 1179 after advantage computation\n\n # this is experimental and may be changed/removed in the future in favor of a general-purpose one\n if isinstance(self.train_dataloader.sampler, AbstractCurriculumSampler):\n self.train_dataloader.sampler.update(batch=batch)\n\n # TODO: make a canonical logger that supports various backend\n logger.log(data=metrics, step=self.global_steps)\n\n progress_bar.update(1)\n self.global_steps += 1\n\n if (\n hasattr(self.config.actor_rollout_ref.actor, \"profiler\")\n and self.config.actor_rollout_ref.actor.profiler.tool == \"torch_memory\"\n ):\n self.actor_rollout_wg.dump_memory_snapshot(\n tag=f\"post_update_step{self.global_steps}\", sub_dir=f\"step{self.global_steps}\"\n )\n\n if is_last_step:\n if hasattr(self.actor_rollout_wg, \"async_calls_finalize_fn_exec\"):\n self.actor_rollout_wg.async_calls_finalize_fn_exec(blocking=True)\n pprint(f\"Final validation metrics: {last_val_metrics}\")\n progress_bar.close()\n return\n\n # this is experimental and may be changed/removed in the future\n # in favor of a general-purpose data buffer pool\n if hasattr(self.train_dataset, \"on_batch_end\"):\n # The dataset may be changed after each training batch\n self.train_dataset.on_batch_end(batch=batch)\n"} +{"file_name": "verl__trainer__sft_trainer.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nimport os\nfrom functools import partial\n\nfrom tensordict.tensorclass import NonTensorData\n\nos.environ[\"NCCL_DEBUG\"] = \"WARN\"\nos.environ[\"TOKENIZERS_PARALLELISM\"] = \"true\"\n\nimport logging\n\nimport hydra\nimport torch\nimport torch.distributed\nfrom omegaconf import OmegaConf\nfrom torch.utils.data import DistributedSampler\nfrom torchdata.stateful_dataloader import StatefulDataLoader\nfrom tqdm import tqdm\n\nfrom verl.utils import tensordict_utils as tu\nfrom verl.utils.checkpoint import CheckpointHandler\nfrom verl.utils.dataset.dataset_utils import SFTTensorCollator\nfrom verl.utils.dataset.multiturn_sft_dataset import MultiTurnSFTDataset\nfrom verl.utils.device import auto_set_device, get_device_name\nfrom verl.utils.distributed import destroy_global_process_group\nfrom verl.utils.logger import log_with_rank\nfrom verl.utils.memory_utils import aggressive_empty_cache\nfrom verl.utils.profiler import log_gpu_memory_usage\nfrom verl.utils.tracking import Tracking\nfrom verl.workers.engine_workers import TrainingWorker\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_SFT_LOGGING_LEVEL\", \"WARN\"))\n\n\nclass SFTTrainer:\n def __init__(\n self,\n config,\n ):\n self.config = config\n\n log_gpu_memory_usage(f\"rank {torch.distributed.get_rank()}: Before SFTTrainer init\", logger=logger)\n\n self.rank = torch.distributed.get_rank()\n\n self._build_config()\n self._build_dataset()\n\n self._build_engine()\n\n self._build_dataloader()\n\n self._init_engine()\n\n self._build_ckpt_handler()\n\n # Initialize resume-related variables\n self.resume_global_step = self.ckpt_handler.load_checkpoint()\n\n self.device_name = self.config.trainer.device\n\n if self.rank == 0:\n print(self.config)\n\n log_gpu_memory_usage(f\"rank {self.rank}: After SFTTrainer init\", logger=logger)\n\n def _build_ckpt_handler(self):\n resume_mode = getattr(self.config.trainer, \"resume_mode\", \"auto\")\n resume_from_path = getattr(self.config.trainer, \"resume_from_path\", None)\n max_ckpt_to_keep = getattr(self.config.trainer, \"max_ckpt_to_keep\", None)\n default_hdfs_dir = getattr(self.config.trainer, \"default_hdfs_dir\", None)\n\n self.ckpt_handler = CheckpointHandler(\n engine=self.engine,\n train_dataloader=self.train_dataloader,\n default_local_dir=self.config.trainer.default_local_dir,\n max_ckpt_to_keep=max_ckpt_to_keep,\n default_hdfs_dir=default_hdfs_dir,\n resume_mode=resume_mode,\n resume_from_path=resume_from_path,\n )\n\n def _build_config(self):\n from verl.utils.config import omega_conf_to_dataclass\n\n self.model_config = omega_conf_to_dataclass(self.config.model)\n self.engine_config = omega_conf_to_dataclass(self.config.engine)\n self.optimizer_config = omega_conf_to_dataclass(self.config.optim)\n self.checkpoint_config = omega_conf_to_dataclass(self.config.checkpoint)\n self.profiler_config = omega_conf_to_dataclass(self.config.profiler)\n\n # check profile interval\n self.profiler_interval = self.config.trainer.profile_interval\n self._validate_profiler_interval()\n\n def _validate_profiler_interval(self):\n assert len(self.profiler_interval) == 2\n self.start_profile_step = self.profiler_interval[0]\n self.end_profile_step = self.profiler_interval[1]\n assert self.end_profile_step >= self.start_profile_step\n if self.start_profile_step < 0:\n assert self.end_profile_step < 0\n\n def _build_engine(self):\n from verl.workers.engine_workers import TrainingWorkerConfig\n from verl.workers.utils.losses import sft_loss\n\n self.loss_fn = partial(sft_loss, config=None)\n\n config = TrainingWorkerConfig(\n model_type=\"language_model\",\n model_config=self.model_config,\n engine_config=self.engine_config,\n optimizer_config=self.optimizer_config,\n checkpoint_config=self.checkpoint_config,\n profiler_config=self.profiler_config,\n )\n\n self.training_client = TrainingWorker(config=config)\n self.training_client.set_loss_fn(loss_fn=self.loss_fn)\n # Note that in SPMD world, this abstraction has to break\n self.engine = self.training_client.engine\n\n def _init_engine(self):\n # patch optimizer config\n if self.config.trainer.total_training_steps is not None:\n self.total_training_steps = self.config.trainer.total_training_steps\n else:\n self.total_training_steps = len(self.train_dataloader) * self.config.trainer.total_epochs\n self.optimizer_config.total_training_steps = self.total_training_steps\n\n self.steps_per_epoch = len(self.train_dataloader)\n\n # manage save and test frequency\n self.save_freq = self.config.trainer.save_freq\n if self.save_freq == \"after_each_epoch\":\n self.save_freq = self.steps_per_epoch\n\n self.test_freq = self.config.trainer.test_freq\n if self.test_freq == \"after_each_epoch\":\n self.test_freq = self.steps_per_epoch\n\n self.training_client.reset()\n\n def _build_dataset(self):\n config = self.config\n tokenizer = self.model_config.tokenizer\n processor = self.model_config.processor\n train_dataset = create_sft_dataset(\n config.data.train_files,\n config.data,\n tokenizer,\n processor,\n max_samples=config.data.get(\"train_max_samples\", -1),\n )\n if config.data.val_files:\n val_dataset = create_sft_dataset(\n config.data.val_files,\n config.data,\n tokenizer,\n processor,\n max_samples=config.data.get(\"val_max_samples\", -1),\n )\n else:\n val_dataset = None\n\n self.train_dataset, self.val_dataset = train_dataset, val_dataset\n\n def _build_dataloader(self):\n # build dataset\n config = self.config\n # build dataloader\n # Use data parallel rank and size instead of global rank and world size\n\n # Set pin_memory_device when pin_memory is enabled.\n device_name = get_device_name()\n\n dp_rank = self.engine.get_data_parallel_rank()\n dp_size = self.engine.get_data_parallel_size()\n\n self.train_sampler = DistributedSampler(\n self.train_dataset, shuffle=True, num_replicas=dp_size, rank=dp_rank, drop_last=True\n )\n\n self.global_batch_size = config.data.train_batch_size\n self.train_batch_size_per_dp = self.global_batch_size // dp_size\n self.collate_fn = SFTTensorCollator(config.data.pad_mode)\n\n self.train_dataloader = StatefulDataLoader(\n dataset=self.train_dataset,\n batch_size=self.train_batch_size_per_dp,\n sampler=self.train_sampler,\n collate_fn=self.collate_fn,\n num_workers=self.config.data.num_workers,\n pin_memory=False,\n drop_last=True,\n pin_memory_device=device_name,\n )\n\n if self.val_dataset:\n self.val_sampler = DistributedSampler(\n self.val_dataset, shuffle=False, num_replicas=dp_size, rank=dp_rank, drop_last=True\n )\n self.val_dataloader = StatefulDataLoader(\n dataset=self.val_dataset,\n batch_size=self.train_batch_size_per_dp,\n sampler=self.val_sampler,\n collate_fn=self.collate_fn,\n num_workers=self.config.data.num_workers,\n pin_memory=False,\n drop_last=True,\n pin_memory_device=device_name,\n )\n else:\n self.val_dataloader = None\n\n def _get_batch_seqlens(self, data):\n # mean over dp group\n is_nested = data[\"input_ids\"].is_nested\n if is_nested:\n batch_seqlens: torch.Tensor = data[\"input_ids\"].offsets().diff()\n else:\n batch_seqlens: torch.Tensor = data[\"attention_mask\"].sum(dim=-1)\n batch_seqlens = batch_seqlens.to(self.device_name) # (global_bsz // dp)\n\n output_tensor = torch.empty(\n (batch_seqlens.shape[0] * self.engine.get_data_parallel_size(),),\n dtype=batch_seqlens.dtype,\n device=self.device_name,\n ) # (global_bsz,)\n\n torch.distributed.all_gather_into_tensor(\n output_tensor=output_tensor,\n input_tensor=batch_seqlens,\n group=self.engine.get_data_parallel_group(),\n )\n\n batch_seqlens = output_tensor.tolist()\n return batch_seqlens\n\n def fit(self):\n is_logging = self.engine.is_mp_src_rank_with_outputs() and self.engine.get_data_parallel_rank() == 0\n\n # TODO: add a unified tracking\n if is_logging:\n tracking = Tracking(\n project_name=self.config.trainer.project_name,\n experiment_name=self.config.trainer.experiment_name,\n default_backend=self.config.trainer.logger,\n config=OmegaConf.to_container(self.config, resolve=True),\n )\n\n global_step = self.resume_global_step # Start from resumed step\n last_valid_metric = None\n\n log_with_rank(\n f\"Total training steps: {self.total_training_steps},\",\n logger=logger,\n rank=0,\n log_only_rank_0=True,\n )\n\n # With StatefulDataLoader, we don't need to manually calculate epochs and steps\n # The dataloader will automatically resume from where it left off\n if global_step > 0:\n log_with_rank(\n f\"StatefulDataLoader will automatically resume from global step: {global_step}\",\n logger=logger,\n rank=0,\n log_only_rank_0=True,\n )\n\n # Calculate which epoch we're starting from for sampler.set_epoch()\n start_epoch = global_step // self.steps_per_epoch\n\n meta_info = {\n \"use_remove_padding\": self.config.model.use_remove_padding,\n \"use_dynamic_bsz\": self.config.data.use_dynamic_bsz,\n \"max_token_len_per_gpu\": self.config.data.max_token_len_per_gpu,\n \"micro_batch_size_per_gpu\": self.config.data.micro_batch_size_per_gpu,\n \"temperature\": 1.0,\n \"global_batch_size\": self.global_batch_size,\n \"pad_mode\": self.config.data.pad_mode,\n \"pad_token_id\": self.model_config.tokenizer.pad_token_id,\n }\n\n train_time = 0\n total_tokens = 0\n for epoch in range(start_epoch, self.config.trainer.total_epochs):\n self.train_sampler.set_epoch(epoch=epoch)\n\n aggressive_empty_cache(force_sync=True)\n log_gpu_memory_usage(f\"rank {self.rank}: At start of epoch {epoch}\", logger=logger)\n\n for step_in_epoch, data in enumerate(\n tqdm(\n self.train_dataloader,\n initial=global_step % self.steps_per_epoch if epoch == start_epoch else 0,\n total=self.steps_per_epoch,\n desc=f\"Epoch {epoch + 1}/{self.config.trainer.total_epochs}\",\n disable=not is_logging,\n )\n ):\n global_step += 1\n\n # construct tensordict\n data = tu.get_tensordict(tensor_dict=data, non_tensor_dict=meta_info)\n batch_seqlens = self._get_batch_seqlens(data=data)\n # this is necessary. Otherwise, it is interpreted as NonTensorStack\n batch_seqlens_ntd = NonTensorData(batch_seqlens)\n\n tu.assign_non_tensor(data, update_lr_scheduler=True, global_token_num=batch_seqlens_ntd)\n\n # start profile in SPMD mode\n if global_step == self.start_profile_step:\n self.training_client.start_profile()\n # train for on batch\n output = self.training_client.train_batch(data=data)\n\n if global_step == self.end_profile_step:\n self.training_client.stop_profile()\n\n if self.engine.is_mp_src_rank_with_outputs():\n metrics = tu.get(output, \"metrics\")\n\n # TODO: we can actual accumulate metrics for N steps and perform aggregate metrics\n for k in [\"loss\", \"grad_norm\", \"lr\", \"mfu\"]:\n if k in metrics.keys():\n value = metrics.pop(k)\n metrics[f\"train/{k}\"] = value\n\n metrics[\"train/global_tokens\"] = torch.sum(\n torch.tensor(batch_seqlens, device=self.device_name)\n ).item()\n total_tokens += metrics[\"train/global_tokens\"]\n metrics[\"train/total_tokens(B)\"] = total_tokens / 1e9\n\n if self.engine.get_data_parallel_rank() == 0:\n tracking.log(data=metrics, step=global_step)\n\n is_last_step = global_step >= self.total_training_steps\n is_valid_step = global_step % self.test_freq == 0\n is_save_step = global_step % self.save_freq == 0\n\n # early exit or validation step\n if is_last_step and self.val_dataloader is not None or (self.test_freq > 0 and is_valid_step):\n # Perform validation\n val_losses = []\n for val_data in self.val_dataloader:\n val_data = tu.get_tensordict(tensor_dict=val_data, non_tensor_dict=meta_info)\n output = self.training_client.infer_batch(val_data)\n\n if self.engine.is_mp_src_rank_with_outputs():\n metrics = tu.get(output, \"metrics\")\n val_losses.append(metrics[\"loss\"])\n\n if self.engine.is_mp_src_rank_with_outputs():\n val_loss = torch.mean(torch.tensor(val_losses, device=self.device_name))\n # average over data parallel group\n torch.distributed.all_reduce(\n val_loss, op=torch.distributed.ReduceOp.AVG, group=self.engine.get_data_parallel_group()\n )\n\n if is_logging:\n metric = {\"val/loss\": val_loss.detach().item()}\n tracking.log(data=metric, step=global_step)\n last_valid_metric = metric\n torch.distributed.barrier()\n\n if is_last_step or (self.save_freq > 0 and is_save_step):\n aggressive_empty_cache(force_sync=True)\n self.ckpt_handler.save_checkpoint(step=global_step)\n\n if is_last_step:\n if is_logging:\n print(f\"Total time for train steps: {train_time:.2f}s\")\n print(f\"Final validation metrics: {last_valid_metric}\")\n return\n\n\ndef run_sft(config):\n from verl.utils.distributed import initialize_global_process_group\n\n initialize_global_process_group()\n trainer = SFTTrainer(config=config)\n trainer.fit()\n destroy_global_process_group()\n\n\n@hydra.main(config_path=\"config\", config_name=\"sft_trainer_engine\", version_base=None)\ndef main(config):\n # Automatically set `config.trainer.device = npu` when running on Ascend NPU.\n auto_set_device(config)\n run_sft(config)\n\n\ndef create_sft_dataset(data_paths, data_config, tokenizer, processor, max_samples=-1):\n \"\"\"Create a dataset.\"\"\"\n # build dataset\n # First check if a custom dataset class is specified\n if data_config.custom_cls.get(\"path\", None):\n from verl.utils.import_utils import load_extern_object\n\n dataset_cls = load_extern_object(data_config.custom_cls.path, data_config.custom_cls.name)\n else:\n # Default to multi-turn dataset\n dataset_cls = MultiTurnSFTDataset\n\n # Create datasets based on the selected class\n dataset = dataset_cls(\n parquet_files=data_paths, tokenizer=tokenizer, config=data_config, processor=processor, max_samples=max_samples\n )\n return dataset\n\n\nif __name__ == \"__main__\":\n main()\n"} +{"file_name": "verl__utils__activation_offload.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n# Copyright (c) 2022-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Functionality for CPU offloading of tensors saved for backward pass.\"\"\"\n\nfrom __future__ import annotations\n\nimport functools\nimport logging\nimport os\nfrom typing import Any, Optional\n\nimport torch\nfrom torch.distributed.fsdp import FullyShardedDataParallel as FSDP\n\nfrom verl.utils.device import get_torch_device\nfrom verl.utils.fsdp_utils import FSDPModule as FSDP2\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef _get_unique_tensor_key(tensor):\n key = (tensor.untyped_storage().data_ptr() + tensor.storage_offset(), tensor.dtype)\n return key\n\n\nclass FSDPParameterFilter:\n def __init__(self):\n self.model_parameters_storage = set()\n\n def __call__(self, tensor):\n return tensor.untyped_storage().data_ptr() not in self.model_parameters_storage\n\n def update_model_parameters(self, model):\n new_storage = set()\n for p in model.parameters():\n new_storage.add(p.data.untyped_storage().data_ptr())\n self.model_parameters_storage = new_storage\n\n\nclass CpuOffloadHookWithOffloadHandler:\n \"\"\"Context-manager that offloads/recovers tensors through an offload hander.\n\n The hook just offloads/recovers the tensor object to the handler through `tensor_push`\n and `tensor_pop` interface. How the offload-handler manages the offloading, recovering\n or prefetching timing is transparent to this hook.\n \"\"\"\n\n def __init__(\n self,\n offload_handler: OffloadHandler,\n handler_extra_kwargs: Optional[dict[str, Any]] = None,\n ) -> None:\n if handler_extra_kwargs is None:\n handler_extra_kwargs = {}\n self.offload_handler: OffloadHandler = offload_handler\n self.handler_extra_kwargs: dict[str, Any] = handler_extra_kwargs\n self.inside_context = False\n\n def __enter__(self):\n self.inside_context = True\n torch._C._autograd._push_saved_tensors_default_hooks(self.on_save_for_backward, self.on_get_saved_tensor)\n\n def __exit__(self, *args: Any):\n self.inside_context = False\n torch._C._autograd._pop_saved_tensors_default_hooks()\n\n def on_save_for_backward(self, tensor: torch.Tensor) -> Any:\n retrieve_identifier = self.offload_handler.tensor_push(tensor, **self.handler_extra_kwargs)\n return retrieve_identifier\n\n def on_get_saved_tensor(self, saved_state: Any) -> torch.Tensor:\n tensor = self.offload_handler.tensor_pop(saved_state, **self.handler_extra_kwargs)\n return tensor\n\n\nclass OffloadHandler:\n \"\"\"A base class for CPU offload-handler.\"\"\"\n\n def __init__(self) -> None:\n pass\n\n def tensor_push(self, tensor: torch.Tensor, **kwargs) -> Any:\n \"\"\"Tensor push.\"\"\"\n raise NotImplementedError(\n \"`tensor_push is not implented in OffloadHandler class. Inherit this class and implement your \"\n \"custom tensor_push.\"\n )\n\n def tensor_pop(self, tensor_tag: Any, **kwargs):\n \"\"\"Tensor pop.\"\"\"\n raise NotImplementedError(\n \"`tensor_pop is not implented in OffloadHandler class. Inherit this class and implement your \"\n \"custom tensor_pop.\"\n )\n\n\nclass GroupCommitFunction(torch.autograd.Function):\n \"\"\"this is a dummy op with output identical to input.\n However, it is necessary for marking a timepoint for offload handler to\n accomplish all synchronizations. Implementing it as a function is necessary\n because we need to actions in both forward and backward.\n \"\"\"\n\n @staticmethod\n def forward(ctx, tensor, cpu_offload_handler):\n # pylint: disable=missing-function-docstring\n cpu_offload_handler.on_group_commit_forward()\n ctx.cpu_offload_handler = cpu_offload_handler\n # return the identical tensor\n return tensor\n\n @staticmethod\n def backward(ctx, grad_output):\n # pylint: disable=missing-function-docstring\n cpu_offload_handler = ctx.cpu_offload_handler\n cpu_offload_handler.on_group_commit_backward()\n return grad_output, None\n\n\ngroup_prefetch_offload_commit = GroupCommitFunction.apply\n\n\nclass SynchronizedGroupOffloadHandler(OffloadHandler):\n \"\"\"Offload Handler that offloads/reloads in a synchronized way.\n The device-to-host and host-to-device copying happen in the same stream\n as the computation kernels, thus the copying will block computation.\n \"\"\"\n\n def __init__(self, num_offload_group, tensor_need_offloading_checker=(lambda _: True)) -> None:\n super().__init__()\n\n self.num_offload_group = num_offload_group\n self.tensor_need_offloading_checker = tensor_need_offloading_checker\n\n self.groupid_reset()\n\n def groupid_reset(self):\n \"\"\"Groupid reset.\"\"\"\n # Data structures to label saved tensors and book-keep their cpu copies.\n # Currently, on push, create a new cpu tensor and copies; on pop, copies\n # the tensor back to gpu and deletes the cpu tensor.\n # These will increment whenever `group_commit()` is invoked\n self.current_group, self.tensor_count_current_group = (0, 0)\n self.torch_tensor_count = 0\n self.tensor_tag_to_state = {}\n\n def on_group_commit_forward(self):\n \"\"\"On group commit forward.\"\"\"\n # finishing up with updating current group and tensor count\n self.current_group += 1 # increment\n self.tensor_count_current_group = 0 # reset\n\n def on_group_commit_backward(self):\n \"\"\"On group commit backward.\"\"\"\n self.current_group -= 1\n assert self.current_group >= 0\n\n @staticmethod\n def offload(src_tensor, pin_memory=True):\n \"\"\"Offload.\"\"\"\n\n cpu_backup = torch.empty(\n src_tensor.size(),\n dtype=src_tensor.dtype,\n layout=src_tensor.layout,\n device=\"cpu\",\n pin_memory=pin_memory,\n )\n cpu_backup.copy_(src_tensor, non_blocking=True)\n state = (src_tensor.device, cpu_backup)\n return state\n\n @staticmethod\n def reload(state, non_blocking=None):\n \"\"\"Reload.\"\"\"\n dev, cpu_backup = state\n if non_blocking is None:\n non_blocking = cpu_backup.is_pinned()\n return cpu_backup.to(dev, non_blocking=non_blocking)\n\n def tensor_push(self, tensor: torch.Tensor, **kwargs):\n \"\"\"Tensor push.\"\"\"\n # obtain a unique tensor tag\n tensor_tag = (self.current_group, self.tensor_count_current_group)\n self.tensor_count_current_group += 1\n assert tensor_tag not in self.tensor_tag_to_state\n if self.current_group < self.num_offload_group and self.tensor_need_offloading_checker(tensor):\n state = SynchronizedGroupOffloadHandler.offload(tensor)\n self.tensor_tag_to_state[tensor_tag] = state\n else:\n # will be offloaded together after group commit\n self.tensor_tag_to_state[tensor_tag] = tensor\n\n return tensor_tag\n\n def tensor_pop(self, tensor_tag, **kwargs):\n \"\"\"Tensor pop.\"\"\"\n assert tensor_tag in self.tensor_tag_to_state\n state = self.tensor_tag_to_state.pop(tensor_tag)\n if isinstance(state, tuple):\n tensor = SynchronizedGroupOffloadHandler.reload(state)\n else:\n tensor = state\n return tensor\n\n\nclass AsyncDoubleBufferGroupOffloadHandler(SynchronizedGroupOffloadHandler):\n \"\"\"Compared to synchronize, this uses more memory because of the buffer but\n achieves better performance due to the overlapping. D2h and h2d copying are\n completely hidden behind computation if computation time of a layer is longer\n than host-device communication time. Bulk offloading with delay and bulk reloading\n with prefetch are implemented.\"\"\"\n\n def __init__(\n self,\n num_offload_group, # must be <= actual number of groups (number of commits)\n num_model_group,\n tensor_need_offloading_checker=(lambda t: True),\n ) -> None:\n super().__init__(\n num_offload_group=num_offload_group,\n tensor_need_offloading_checker=tensor_need_offloading_checker,\n )\n # Number of layers in the model\n self.num_layers = num_model_group\n # Data Structure to maintain reference to activation tensors\n self.tensor_tag_to_buf = {}\n # Tracking the number of layers offloaded\n self.offloaded_group_count = 0\n # Core data structure that decides the window for offloading\n self.layer_window_map = {}\n self.group_offload_mapping = {}\n\n # Logic to make offloading load balance across computation\n # for optimal CPU/GPU interconnect usage\n constant = 0\n for i in range(self.num_offload_group):\n self.layer_window_map[i] = ((self.num_layers // self.num_offload_group) * (i + 1)) - 1\n if i < (self.num_layers % self.num_offload_group):\n self.layer_window_map[i] += i + 1\n constant = i + 1\n else:\n self.layer_window_map[i] += constant\n\n # allocate streams and events for synchronization\n self.d2h_stream = get_torch_device().Stream()\n self.h2d_stream = get_torch_device().Stream()\n\n def tensor_push(self, tensor: torch.Tensor, **kwargs) -> Any:\n torch_stray_tensor = isinstance(\n tensor,\n torch._subclasses.fake_tensor.FakeTensor | torch._subclasses.functional_tensor.FunctionalTensor,\n )\n need_offload = not torch_stray_tensor\n need_offload = need_offload and self.tensor_need_offloading_checker(tensor)\n\n if need_offload:\n # obtain a unique tensor tag\n tensor_tag = (self.current_group, self.tensor_count_current_group)\n self.tensor_count_current_group += 1\n\n assert tensor_tag not in self.tensor_tag_to_state\n self.tensor_tag_to_state[tensor_tag] = tensor\n\n if self.current_group < self.num_offload_group:\n self.tensor_tag_to_buf[tensor_tag] = tensor\n else:\n tensor_tag = tensor\n return tensor_tag\n\n def tensor_pop(self, tensor_tag, **kwargs):\n \"\"\"Tensor pop.\"\"\"\n if isinstance(tensor_tag, torch.Tensor):\n return tensor_tag\n assert tensor_tag in self.tensor_tag_to_state\n tensor = self.tensor_tag_to_state.pop(tensor_tag)\n self.tensor_tag_to_buf.pop(tensor_tag, None)\n\n # the tensor should have been copied back in on_group_commit_backward()\n # which invokes bulk_reload_group.\n assert not isinstance(tensor, tuple)\n return tensor\n\n def bulk_offload_group(self, group_to_offload):\n \"\"\"Bulk offload group.\"\"\"\n offload_mapping = {}\n offload_size = 0\n with get_torch_device().stream(self.d2h_stream):\n for tensor_tag, state in self.tensor_tag_to_state.items():\n group_id, _ = tensor_tag\n if group_id == group_to_offload:\n assert not isinstance(state, tuple)\n key = _get_unique_tensor_key(state)\n if key not in offload_mapping:\n offload_mapping[key] = state\n # if offload, return the reference to cpu copy\n self.tensor_tag_to_state[tensor_tag] = (key, state.shape)\n for key, tensor in offload_mapping.items():\n state = SynchronizedGroupOffloadHandler.offload(tensor)\n offload_size += tensor.numel() * tensor.element_size()\n offload_mapping[key] = state\n\n self.group_offload_mapping[group_to_offload] = offload_mapping\n\n def synchronize_on_group_commit_forward(self, current_group):\n \"\"\"Synchronize on group commit forward.\"\"\"\n\n # For the first group, kickstart the offload after we have\n # the first compute completion\n if current_group == 0:\n self.d2h_stream.wait_stream(get_torch_device().current_stream())\n self.bulk_offload_group(current_group)\n\n # Window map data structure helps us synchronize based on number\n # of layers offloaded\n if self.layer_window_map[self.offloaded_group_count] == current_group:\n # Stream synchronization both ways\n self.d2h_stream.wait_stream(get_torch_device().current_stream())\n get_torch_device().current_stream().wait_stream(self.d2h_stream)\n\n # Time to free the activation memory after usage\n for tensor_tag, _ in self.tensor_tag_to_buf.items():\n if tensor_tag[0] == self.offloaded_group_count:\n self.tensor_tag_to_buf[tensor_tag] = None\n\n # Time to offload the next group\n if self.offloaded_group_count < (self.num_offload_group - 1):\n self.bulk_offload_group(self.offloaded_group_count + 1)\n\n # Increment the offload group count to keep track\n self.offloaded_group_count += 1\n\n def on_group_commit_forward(self):\n \"\"\"This function will cause host device synchronization\"\"\"\n # handle synchronization events\n self.synchronize_on_group_commit_forward(self.current_group)\n\n super().on_group_commit_forward()\n\n @torch.no_grad\n def bulk_reload_group(self, group_to_reload):\n \"\"\"Bulk reload group.\"\"\"\n assert group_to_reload < self.num_offload_group\n\n with get_torch_device().stream(self.h2d_stream):\n # move back tensors\n offload_mapping = self.group_offload_mapping.pop(group_to_reload)\n assert offload_mapping is not None\n for key, state in offload_mapping.items():\n offload_mapping[key] = SynchronizedGroupOffloadHandler.reload(state)\n for tensor_label, state in self.tensor_tag_to_state.items():\n group_id, _ = tensor_label\n if group_id == group_to_reload and not isinstance(state, torch.Tensor):\n assert isinstance(state, tuple), f\"{group_id} {state}\"\n key, shape = state\n recovered_tensor = offload_mapping[key].view(shape)\n self.tensor_tag_to_state[tensor_label] = recovered_tensor\n\n def on_group_commit_backward(self):\n # first decrement the current group.\n # after last commit in forward, the group will +1; in backward it -1.\n # Finally it should be decremented to 0.\n self.current_group -= 1\n assert self.current_group >= 0\n\n # Layer window data structure helps us to reload at right times\n if self.layer_window_map[self.offloaded_group_count - 1] == self.current_group:\n # Stream synchronization both ways\n self.h2d_stream.wait_stream(get_torch_device().current_stream())\n get_torch_device().current_stream().wait_stream(self.h2d_stream)\n\n # Time to reload the next group\n self.bulk_reload_group(self.offloaded_group_count - 1)\n\n # Decrease the offloading group counter\n self.offloaded_group_count -= 1 if self.offloaded_group_count > 1 else 0\n\n # Last group computation needs to wait till all the reloads complete\n if self.current_group == 0:\n get_torch_device().current_stream().wait_stream(self.h2d_stream)\n self.offloaded_group_count = 0\n\n\ndef get_activation_offload_context(\n num_layers: int = 1, model_layers: int = 1, tensor_need_offloading_checker=(lambda t: True)\n):\n cpu_offload_handler = AsyncDoubleBufferGroupOffloadHandler(\n num_offload_group=num_layers,\n num_model_group=model_layers,\n tensor_need_offloading_checker=tensor_need_offloading_checker,\n )\n\n def group_prefetch_offload_commit_async(tensor):\n return group_prefetch_offload_commit(tensor, cpu_offload_handler)\n\n return (\n CpuOffloadHookWithOffloadHandler(offload_handler=cpu_offload_handler),\n group_prefetch_offload_commit_async,\n )\n\n\nclass ActivationHandler:\n def __init__(self, offload_ctx, sync_func, tensor_filter, enable_ckpt):\n self._offload_ctx = offload_ctx\n self._sync_func = sync_func\n self._enable_ckpt = enable_ckpt\n self._tensor_filter = tensor_filter\n if enable_ckpt:\n self.checkpoint_fn = functools.partial(\n torch.utils.checkpoint.checkpoint,\n use_reentrant=True,\n )\n\n def pre_forward(self, module):\n if module.training:\n self._offload_ctx.__enter__()\n self._tensor_filter.update_model_parameters(module)\n\n def post_forward(self, module):\n if module.training:\n self._offload_ctx.__exit__(None, None, None)\n\n def _pack_kwargs(self, *args, **kwargs):\n kwarg_keys = []\n flat_args = list(args)\n for k, v in kwargs.items():\n kwarg_keys.append(k)\n flat_args.append(v)\n\n return tuple(flat_args), tuple(kwarg_keys)\n\n def _unpack_kwargs(self, flat_args, kwarg_keys):\n assert len(kwarg_keys) <= len(flat_args), f\"too many keys {len(kwarg_keys)} vs. {len(flat_args)}\"\n if len(kwarg_keys) == 0:\n return flat_args, {}\n args = flat_args[: -len(kwarg_keys)]\n kwargs = dict(zip(kwarg_keys, flat_args[-len(kwarg_keys) :], strict=True))\n return args, kwargs\n\n def _ckpt_forward(self, forward_method, *args, **kwargs):\n flat_args, kwarg_keys = self._pack_kwargs(*args, **kwargs)\n\n def my_function(*inputs):\n # unpack back into args and kwargs\n nonlocal forward_method, kwarg_keys\n unpacked_args, unpacked_kwargs = self._unpack_kwargs(inputs, kwarg_keys)\n # run original module\n return forward_method(*unpacked_args, **unpacked_kwargs)\n\n return self.checkpoint_fn(\n my_function,\n *flat_args,\n )\n\n def forward(self, module, forward_method, *args, **kwargs):\n if not module.training:\n return forward_method(*args, **kwargs)\n if not self._enable_ckpt:\n ret = forward_method(*args, **kwargs)\n else:\n ret = self._ckpt_forward(forward_method, *args, **kwargs)\n binded_tensor = ret\n if isinstance(ret, tuple):\n binded_tensor = ret[0]\n binded_tensor = self._sync_func(binded_tensor)\n final_ret = binded_tensor\n if isinstance(ret, tuple):\n final_ret = (final_ret,) + ret[1:]\n return final_ret\n\n def wrap_module_forward_method(self, module):\n orig_method = module.forward\n handler = self\n\n @functools.wraps(orig_method)\n def wrapped_method(model_self, *args, **kwargs):\n nonlocal handler\n handler.pre_forward(model_self)\n out = handler.forward(model_self, orig_method, *args, **kwargs)\n handler.post_forward(model_self)\n return out\n\n module.forward = wrapped_method.__get__(module, type(module))\n\n\ndef enable_activation_offloading(model, strategy, enable_ckpt=False):\n \"\"\"\n Enable activation offloading for the model. It groups activations by TransformerLayer and offloads activation\n groups asynchronously. This means that the offloading of the i-th activation group and the computation of the i+1-th\n activation group happen at the same time, and there are at most two activation groups in GPU memory.\n\n Args:\n model: the model to enable activation offloading\n strategy: the training strategy of the model, such as \"fsdp\"\n enable_ckpt: whether activation checkpointing(also called gradient checkpointing) has been enabled for the model\n\n Note:\n For best efficiency, activation offloading is usually combined with activation checkpointing. However, this\n implementation of activation offloading is conflicted with the implementation of activation checkpointing in\n some training strategies. This function resolves this conflict, and therefore requires the \"strategy\" and\n \"enable_ckpt\" arguments.\n\n Returns:\n\n \"\"\"\n\n assert strategy == \"fsdp\" or strategy == \"fsdp2\", \"activation offloading only supports fsdp strategy\"\n layers = []\n\n def get_layers(module):\n for name, child in module.named_children():\n if not isinstance(child, FSDP | FSDP2):\n get_layers(child)\n else:\n wrapped_module = child\n if isinstance(child, FSDP):\n wrapped_module = child._fsdp_wrapped_module\n # In some cases, torch.nn.Embedding is wrapped with FSDP alone. However, the activation\n # size of torch.nn.Embedding is small, so it's not necessary to offload it.\n if not isinstance(wrapped_module, torch.nn.Embedding):\n layers.append(child)\n\n get_layers(model)\n if len(layers) < 3:\n logger.warning(f\"Find only {len(layers)} fsdp layers, not necessary to enable async activation offloading\")\n return\n\n tensor_filter = FSDPParameterFilter()\n context, sync_func = get_activation_offload_context(len(layers) - 1, len(layers), tensor_filter)\n if enable_ckpt:\n # The implementation of activation checkpointing in transformers library is incompatible with\n # activation offloading,\n # so it will be disabled, but this implementation supports another version of activation checkpointing, so that\n # these two features can be enabled at the same time.\n for module in model.modules():\n if hasattr(module, \"gradient_checkpointing_disable\"):\n module.gradient_checkpointing_disable()\n\n handler = ActivationHandler(context, sync_func, tensor_filter, enable_ckpt)\n for layer in layers:\n module = layer\n if isinstance(layer, FSDP):\n module = module._fsdp_wrapped_module\n handler.wrap_module_forward_method(module)\n"} +{"file_name": "verl__utils__attention_utils.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom typing import Callable\n\n_index_first_axis, _pad_input, _rearrange, _unpad_input = None, None, None, None\n\n\ndef _get_attention_functions() -> tuple[Callable, Callable, Callable, Callable]:\n \"\"\"Dynamically import attention functions based on available hardware.\"\"\"\n\n from verl.utils.device import is_torch_npu_available\n\n global _index_first_axis, _pad_input, _rearrange, _unpad_input\n\n if is_torch_npu_available(check_device=False):\n from verl.utils.npu_flash_attn_utils import index_first_axis, pad_input, rearrange, unpad_input\n else:\n from flash_attn.bert_padding import index_first_axis, pad_input, rearrange, unpad_input\n\n _index_first_axis, _pad_input, _rearrange, _unpad_input = index_first_axis, pad_input, rearrange, unpad_input\n\n return _index_first_axis, _pad_input, _rearrange, _unpad_input\n\n\ndef index_first_axis(*args, **kwargs):\n \"\"\"\n Unified entry point for `index_first_axis` across CUDA and NPU backends.\n\n Dynamically dispatches to the appropriate device-specific implementation:\n - On CUDA: `flash_attn.bert_padding.index_first_axis`\n - On NPU: `transformers.integrations.npu_flash_attention.index_first_axis`\n (falls back to `transformers.modeling_flash_attention_utils._index_first_axis`\n in newer versions of transformers).\n\n Users can call this function directly without worrying about the underlying device.\n \"\"\"\n func, *_ = _get_attention_functions()\n return func(*args, **kwargs)\n\n\ndef pad_input(*args, **kwargs):\n \"\"\"\n Unified entry point for `pad_input` across CUDA and NPU backends.\n\n Dynamically dispatches to the appropriate device-specific implementation:\n - On CUDA: `flash_attn.bert_padding.pad_input`\n - On NPU: `transformers.integrations.npu_flash_attention.pad_input`\n (falls back to `transformers.modeling_flash_attention_utils._pad_input`\n in newer versions of transformers).\n\n Users can call this function directly without worrying about the underlying device.\n \"\"\"\n _, func, *_ = _get_attention_functions()\n return func(*args, **kwargs)\n\n\ndef rearrange(*args, **kwargs):\n \"\"\"\n Unified entry point for `rearrange` across CUDA and NPU backends.\n\n Dynamically dispatches to the appropriate device-specific implementation:\n - On CUDA: `flash_attn.bert_padding.rearrange`\n - On NPU: `transformers.integrations.npu_flash_attention.rearrange`\n (falls back to `einops.rearrange` if no dedicated NPU implementation exists).\n\n Users can call this function directly without worrying about the underlying device.\n \"\"\"\n *_, func, _ = _get_attention_functions()\n return func(*args, **kwargs)\n\n\ndef unpad_input(*args, **kwargs):\n \"\"\"\n Unified entry point for `unpad_input` across CUDA and NPU backends.\n\n Dynamically dispatches to the appropriate device-specific implementation:\n - On CUDA: `flash_attn.bert_padding.unpad_input`\n - On NPU: `transformers.integrations.npu_flash_attention.unpad_input`\n (falls back to `transformers.modeling_flash_attention_utils._unpad_input`\n in newer versions of transformers).\n\n Users can call this function directly without worrying about the underlying device.\n \"\"\"\n *_, func = _get_attention_functions()\n return func(*args, **kwargs)\n\n\n__all__ = [\"index_first_axis\", \"pad_input\", \"rearrange\", \"unpad_input\"]\n"} +{"file_name": "verl__utils__chat_template.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\nimport logging\nimport os\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef initialize_system_prompt(tokenizer, **apply_chat_template_kwargs) -> list[int]:\n \"\"\"\n Initialize system prompt tokens for chat templates that support them.\n\n Args:\n tokenizer: The tokenizer with a chat template\n **apply_chat_template_kwargs: Additional arguments for apply_chat_template\n\n Returns:\n List of token IDs for the system prompt, or empty list if not supported\n \"\"\"\n token1 = tokenizer.apply_chat_template(\n [{\"role\": \"user\", \"content\": \"\"}], add_generation_prompt=False, tokenize=True\n )\n token2 = tokenizer.apply_chat_template(\n [{\"role\": \"user\", \"content\": \"\"}] * 2, add_generation_prompt=False, tokenize=True\n )\n # get system prompt tokens\n system_prompt = token1[: -(len(token2) - len(token1))]\n return system_prompt\n\n\ndef extract_system_prompt_and_generation(tokenizer):\n token1 = tokenizer.apply_chat_template(\n [{\"role\": \"user\", \"content\": \"\"}], add_generation_prompt=False, tokenize=True\n )\n token2 = tokenizer.apply_chat_template(\n [{\"role\": \"user\", \"content\": \"\"}] * 2, add_generation_prompt=False, tokenize=True\n )\n # get system prompt tokens\n system_prompt = token1[: -(len(token2) - len(token1))]\n # get generate prompt tokens\n token3 = tokenizer.apply_chat_template([{\"role\": \"user\", \"content\": \"\"}], add_generation_prompt=True, tokenize=True)\n generate_prompt = token3[len(token1) :]\n\n return system_prompt, generate_prompt\n"} +{"file_name": "verl__utils__checkpoint__checkpoint_handler.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\n# TODO: add unit tests\n\nimport logging\nimport os\nimport re\nfrom enum import Enum\n\nimport torch\n\nimport verl.utils.hdfs_io as hdfs_io\nfrom verl.single_controller import WorkerGroup\nfrom verl.utils.checkpoint.checkpoint_manager import find_latest_ckpt_path, get_checkpoint_tracker_filename\nfrom verl.utils.logger import log_with_rank\nfrom verl.workers.engine import BaseEngine\n\n\ndef extract_step(path):\n match = re.search(r\"global_step_(\\d+)\", path)\n if match:\n return int(match.group(1))\n return None\n\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_SFT_LOGGING_LEVEL\", \"WARN\"))\n\n\nclass OrchestrationMode(Enum):\n SPMD = 0\n RAY = 1\n\n\nclass CheckpointHandler:\n \"\"\"\n Checkpoint handler handles the path, global_step of a checkpoint folder.\n Currently, it only works with a single model.\n We can expand it to support multiple models. It is expected to be used with SPMD style (e.g., torchrun)\n \"\"\"\n\n def __init__(\n self,\n engine: BaseEngine | WorkerGroup,\n train_dataloader,\n *,\n default_local_dir,\n max_ckpt_to_keep=None,\n default_hdfs_dir=None,\n resume_mode=\"auto\",\n resume_from_path=None,\n mode=OrchestrationMode.SPMD,\n ):\n self.default_local_dir = default_local_dir\n self.max_ckpt_to_keep = max_ckpt_to_keep\n self.default_hdfs_dir = default_hdfs_dir\n self.resume_mode = resume_mode\n self.resume_from_path = resume_from_path\n self.engine = engine\n self.train_dataloader = train_dataloader\n self.mode = mode\n\n if self.mode == OrchestrationMode.SPMD:\n self.rank = torch.distributed.get_rank()\n self.is_mp_src_rank_with_outputs = self.engine.is_mp_src_rank_with_outputs()\n self.dp_rank = self.engine.get_data_parallel_rank()\n elif self.mode == OrchestrationMode.RAY:\n self.rank = 0\n self.is_mp_src_rank_with_outputs = True\n self.dp_rank = 0\n else:\n raise ValueError(f\"Unknown {self.mode=}\")\n\n def save_checkpoint(self, step):\n \"\"\"Save checkpoint using FSDPCheckpointManager with improved tracking\"\"\"\n from verl.utils.fs import local_mkdir_safe\n\n # Determine checkpoint path\n local_global_step_folder = os.path.join(self.default_local_dir, f\"global_step_{step}\")\n if self.rank == 0:\n print(f\"Saving checkpoint to: {local_global_step_folder}\")\n\n # Get max checkpoints to keep\n max_ckpt_to_keep = self.max_ckpt_to_keep\n\n # Use checkpoint manager to save\n self.engine.save_checkpoint(\n local_path=local_global_step_folder, global_step=step, max_ckpt_to_keep=max_ckpt_to_keep\n )\n\n # Save dataloader state. Note that we only save the iterator in the train_dataloader.\n # So it's identical in each dp rank.\n if self.is_mp_src_rank_with_outputs:\n dp_rank = self.dp_rank\n local_mkdir_safe(local_global_step_folder)\n dataloader_local_path = os.path.join(local_global_step_folder, f\"data_{dp_rank}.pt\")\n\n # Use StatefulDataLoader's built-in state dict functionality\n dataloader_state_dict = self.train_dataloader.state_dict()\n torch.save(dataloader_state_dict, dataloader_local_path)\n print(f\"Saved dataloader state to: {dataloader_local_path}\")\n\n if self.rank == 0:\n # Update latest checkpoint tracker (atomic write)\n tracker_file = get_checkpoint_tracker_filename(self.default_local_dir)\n temp_tracker_file = tracker_file + \".tmp\"\n with open(temp_tracker_file, \"w\") as f:\n f.write(str(step))\n os.rename(temp_tracker_file, tracker_file)\n print(f\"Updated checkpoint tracker: {tracker_file}\")\n\n # Copy to HDFS if configured\n if self.rank == 0 and self.default_hdfs_dir:\n hdfs_io.makedirs(self.default_hdfs_dir, exist_ok=True)\n hdfs_io.copy(src=local_global_step_folder, dst=self.default_hdfs_dir, dirs_exist_ok=True)\n\n if self.mode == OrchestrationMode.SPMD:\n torch.distributed.barrier()\n\n def load_checkpoint(self):\n # Determine resume path based on configuration\n checkpoint_path = self._determine_resume_path()\n\n if checkpoint_path is None:\n return 0\n\n # extract resume step from checkpoint path\n resume_step = extract_step(checkpoint_path)\n if resume_step is None:\n log_with_rank(\n f\"Warning: Could not extract step number from {checkpoint_path}, starting from step 0\",\n logger=logger,\n rank=self.rank,\n level=logging.WARNING,\n log_only_rank_0=True,\n )\n return 0\n self.resume_global_step = resume_step\n\n # Use checkpoint manager to load model state\n self.engine.load_checkpoint(checkpoint_path)\n # Always load dataloader state for StatefulDataLoader\n self._load_dataloader_state(checkpoint_path)\n\n return resume_step\n\n def _load_dataloader_state(self, checkpoint_path: str):\n \"\"\"Load dataloader state from checkpoint\"\"\"\n dp_rank = self.dp_rank\n dataloader_path = os.path.join(checkpoint_path, f\"data_{dp_rank}.pt\")\n\n if os.path.exists(dataloader_path):\n # Use StatefulDataLoader's built-in state dict functionality\n dataloader_state_dict = torch.load(dataloader_path, map_location=\"cpu\", weights_only=False)\n self.train_dataloader.load_state_dict(dataloader_state_dict)\n\n log_with_rank(\n f\"Successfully loaded dataloader state from {dataloader_path}\",\n logger=logger,\n rank=self.rank,\n log_only_rank_0=True,\n )\n\n else:\n log_with_rank(\n f\"Warning: No dataloader state found at {dataloader_path}, will start from scratch\",\n logger=logger,\n rank=self.rank,\n level=logging.WARNING,\n log_only_rank_0=True,\n )\n\n def _determine_resume_path(self):\n \"\"\"Determine the path to resume from based on resume_mode configuration\"\"\"\n resume_mode = self.resume_mode\n resume_from_path = self.resume_from_path\n\n if resume_mode == \"disable\":\n return None\n elif resume_mode == \"auto\":\n if resume_from_path is not None:\n assert os.path.exists(resume_from_path), (\n \"resume_from_path must be null or an existing path when resume_mode is 'auto'\"\n )\n assert \"global_step_\" in resume_from_path, \"resume_from_path must specify the global_steps\"\n return resume_from_path\n # Try to find the latest checkpoint in the default directory\n return self._find_latest_checkpoint()\n elif resume_mode == \"resume_path\":\n assert os.path.exists(resume_from_path), (\n \"resume_from_path must be an existing path when resume_mode is 'resume_path'\"\n )\n assert \"global_step_\" in resume_from_path, \"resume_from_path must specify the global_steps\"\n return resume_from_path\n else:\n raise ValueError(f\"Invalid resume_mode: {resume_mode}. Must be 'auto', 'disable', or 'resume_path'\")\n\n def _find_latest_checkpoint(self):\n \"\"\"Find the latest checkpoint in the default local directory\"\"\"\n checkpoint_dir = self.default_local_dir\n\n if not os.path.exists(checkpoint_dir):\n return None\n\n latest_checkpoint = find_latest_ckpt_path(checkpoint_dir)\n\n if latest_checkpoint and self.rank == 0:\n step_num = extract_step(latest_checkpoint)\n print(f\"Found latest checkpoint: {latest_checkpoint} (step {step_num})\")\n\n return latest_checkpoint\n"} +{"file_name": "verl__utils__checkpoint__checkpoint_manager.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport os\nimport random\nimport shutil\n\nimport numpy as np\nimport torch\nimport torch.distributed\nfrom omegaconf import DictConfig\nfrom transformers import PreTrainedTokenizer, ProcessorMixin\n\nfrom verl.trainer.config import CheckpointConfig\nfrom verl.utils.device import get_device_name, get_torch_device\n\n\nclass BaseCheckpointManager:\n \"\"\"\n A checkpoint manager that saves and loads the following states in a SPMD way:\n - model\n - optimizer\n - lr_scheduler\n - extra_states\n\n We save\n - sharded model states and optimizer states\n - full lr_scheduler states\n - huggingface tokenizer and config for ckpt merge\n \"\"\"\n\n def __init__(\n self,\n model,\n optimizer: torch.optim.Optimizer,\n lr_scheduler: torch.optim.lr_scheduler.LRScheduler = None,\n processing_class: PreTrainedTokenizer | ProcessorMixin = None,\n checkpoint_config: DictConfig | CheckpointConfig = None,\n ):\n self.checkpoint_config = checkpoint_config\n checkpoint_load_contents = checkpoint_config.get(\"load_contents\", None) if checkpoint_config else None\n checkpoint_save_contents = checkpoint_config.get(\"save_contents\", None) if checkpoint_config else None\n if checkpoint_load_contents is None:\n checkpoint_load_contents = [\"model\", \"optimizer\", \"extra\"]\n if checkpoint_save_contents is None:\n checkpoint_save_contents = [\"model\", \"optimizer\", \"extra\"]\n self.previous_global_step = None\n self.previous_saved_paths = []\n\n self.model = model\n self.optimizer = optimizer\n self.lr_scheduler = lr_scheduler\n self.processing_class = processing_class\n self.checkpoint_load_contents = checkpoint_load_contents\n self.checkpoint_save_contents = checkpoint_save_contents\n\n self.rank = torch.distributed.get_rank()\n self.world_size = torch.distributed.get_world_size()\n\n @property\n def should_save_model(self) -> bool:\n \"\"\"\n Returns True if 'model' is in checkpoint_save_contents, indicating the model state should be saved.\n \"\"\"\n return \"model\" in self.checkpoint_save_contents\n\n @property\n def should_save_optimizer(self) -> bool:\n \"\"\"\n Returns True if 'optimizer' is in checkpoint_save_contents, indicating the optimizer state should be saved.\n \"\"\"\n return \"optimizer\" in self.checkpoint_save_contents\n\n @property\n def should_save_extra(self) -> bool:\n \"\"\"\n Returns True if 'extra' is in checkpoint_save_contents, indicating the extra state should be saved.\n \"\"\"\n return \"extra\" in self.checkpoint_save_contents\n\n @property\n def should_save_hf_model(self) -> bool:\n \"\"\"\n Returns True if 'hf_model' is in checkpoint_save_contents, indicating the model should be converted to hf\n model and saved.\n \"\"\"\n return \"hf_model\" in self.checkpoint_save_contents\n\n @property\n def should_load_model(self) -> bool:\n \"\"\"\n Returns True if 'model' is in checkpoint_load_contents, indicating the model state should be loaded.\n \"\"\"\n return \"model\" in self.checkpoint_load_contents\n\n @property\n def should_load_optimizer(self) -> bool:\n \"\"\"\n Returns True if 'optimizer' is in checkpoint_load_contents, indicating the optimizer state should be loaded.\n \"\"\"\n return \"optimizer\" in self.checkpoint_load_contents\n\n @property\n def should_load_extra(self) -> bool:\n \"\"\"\n Returns True if 'extra' is in checkpoint_load_contents, indicating the extra state should be loaded.\n \"\"\"\n return \"extra\" in self.checkpoint_load_contents\n\n def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load: bool = False):\n raise NotImplementedError\n\n def save_checkpoint(\n self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep: int = None\n ):\n raise NotImplementedError\n\n @staticmethod\n def checkpath(local_path: str, hdfs_path: str):\n assert local_path is not None or hdfs_path is not None, \"local_path and hdfs_path cannot be both None\"\n return local_path is not None, local_path if local_path is not None else hdfs_path\n\n def remove_previous_save_local_path(self, path):\n if isinstance(path, str):\n path = [path]\n for p in path:\n abs_path = os.path.abspath(p)\n print(f\"Checkpoint manager remove previous save local path: {abs_path}\")\n if not os.path.exists(abs_path):\n continue\n shutil.rmtree(abs_path, ignore_errors=True)\n\n def ensure_checkpoint_capacity(self, max_ckpt_to_keep: int):\n \"\"\"\n Remove old checkpoints to make room for a new one, keeping a safety buffer.\n\n With max_ckpt_to_keep=1, this does nothing - we keep the existing checkpoint\n until the new save completes successfully (handled by register_checkpoint).\n For max_ckpt_to_keep >= 2, we keep (max_ckpt_to_keep - 1) checkpoints before save.\n \"\"\"\n if not (max_ckpt_to_keep and isinstance(max_ckpt_to_keep, int) and max_ckpt_to_keep > 1):\n return\n if len(self.previous_saved_paths) >= max_ckpt_to_keep:\n keep_start = len(self.previous_saved_paths) - max_ckpt_to_keep + 1\n self.remove_previous_save_local_path(self.previous_saved_paths[:keep_start])\n self.previous_saved_paths = self.previous_saved_paths[keep_start:]\n\n def register_checkpoint(self, new_path: str, max_ckpt_to_keep: int):\n \"\"\"\n Register a successfully saved checkpoint and enforce retention limit.\n\n Adds the new checkpoint path to tracking and removes excess old\n checkpoints beyond max_ckpt_to_keep.\n \"\"\"\n self.previous_saved_paths.append(new_path)\n if not (max_ckpt_to_keep and isinstance(max_ckpt_to_keep, int) and max_ckpt_to_keep > 0):\n return\n if len(self.previous_saved_paths) > max_ckpt_to_keep:\n keep_start = len(self.previous_saved_paths) - max_ckpt_to_keep\n self.remove_previous_save_local_path(self.previous_saved_paths[:keep_start])\n self.previous_saved_paths = self.previous_saved_paths[keep_start:]\n\n @staticmethod\n def get_rng_state():\n rng_state = {\n \"cpu\": torch.get_rng_state(),\n \"numpy\": np.random.get_state(),\n \"random\": random.getstate(),\n }\n\n if get_device_name() != \"cpu\":\n rng_state[get_device_name()] = get_torch_device().get_rng_state()\n\n return rng_state\n\n @staticmethod\n def load_rng_state(rng_state):\n torch.set_rng_state(rng_state[\"cpu\"])\n np.random.set_state(rng_state[\"numpy\"])\n random.setstate(rng_state[\"random\"])\n\n if get_device_name() != \"cpu\":\n get_torch_device().set_rng_state(rng_state[get_device_name()])\n\n\ndef find_latest_ckpt_path(path, directory_format=\"global_step_{}\"):\n \"\"\"\n Return the most recent checkpoint directory based on a tracker file.\n\n Args:\n path (str): Base directory containing the checkpoint tracker.\n directory_format (str): Template for checkpoint subfolders with one\n placeholder for the iteration number (default \"global_step_{}\").\n\n Returns:\n str or None: Full path to the latest checkpoint directory, or\n None if the tracker or checkpoint folder is missing.\n \"\"\"\n if path is None:\n return None\n\n tracker_file = get_checkpoint_tracker_filename(path)\n if not os.path.exists(tracker_file):\n if not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0:\n print(f\"Checkpoint tracker file does not exist: {tracker_file}\")\n return None\n\n with open(tracker_file, \"rb\") as f:\n iteration = int(f.read().decode())\n ckpt_path = os.path.join(path, directory_format.format(iteration))\n if not os.path.exists(ckpt_path):\n print(\"Checkpoint does not exist: %s\", ckpt_path)\n return None\n\n print(\"Found checkpoint: %s\", ckpt_path)\n return ckpt_path\n\n\ndef get_checkpoint_tracker_filename(root_path: str):\n \"\"\"\n Tracker file rescords the latest chckpoint during training to restart from.\n \"\"\"\n return os.path.join(root_path, \"latest_checkpointed_iteration.txt\")\n\n\ndef should_save_ckpt_esi(max_steps_duration: float, save_ckpt_duration: float = 60, redundant_time: float = 0) -> bool:\n \"\"\"\n Determine if checkpoint should be saved based on capacity esi expiration.\n\n Args:\n max_steps_duration: Max estimated time (seconds) required to complete one training step\n save_ckpt_duration: Estimated time (seconds) required to save checkpoint (default: 60)\n redundant_time: Additional buffer time (seconds) for unexpected delays (default: 0)\n \"\"\"\n exp_ts_mlp = os.getenv(\"MLP_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP\") # vemlp\n exp_ts_aws = os.getenv(\"SAGEMAKER_CURRENT_CAPACITY_BLOCK_EXPIRATION_TIMESTAMP\") # aws\n if exp_ts_mlp:\n try:\n import time\n\n remaining = float(exp_ts_mlp) - time.time()\n except ValueError:\n return False\n return (\n remaining > 0\n and max_steps_duration > 0\n and remaining <= save_ckpt_duration + max_steps_duration + redundant_time\n )\n elif exp_ts_aws:\n from datetime import datetime, timedelta\n\n expiration_time = datetime.fromtimestamp(int(exp_ts_aws))\n time_difference = expiration_time - datetime.now()\n threshold_minutes = (save_ckpt_duration + max_steps_duration + redundant_time) / 60\n return time_difference < timedelta(minutes=threshold_minutes)\n else:\n return False\n"} +{"file_name": "verl__utils__checkpoint__fsdp_checkpoint_manager.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport json\nimport logging\nimport os\nimport warnings\nfrom dataclasses import asdict, dataclass\nfrom typing import Optional\n\nimport torch\nimport torch.distributed\nfrom accelerate import init_empty_weights\nfrom omegaconf import DictConfig\nfrom torch.distributed.fsdp import FullyShardedDataParallel as FSDP\nfrom torch.distributed.fsdp import ShardedOptimStateDictConfig, ShardedStateDictConfig, StateDictType\nfrom transformers import GenerationConfig, PreTrainedTokenizer, ProcessorMixin\nfrom transformers.dynamic_module_utils import custom_object_save\n\nfrom verl.utils.device import is_cuda_available\nfrom verl.utils.fs import copy_to_local, is_non_local, local_mkdir_safe\nfrom verl.utils.fsdp_utils import fsdp_version, get_fsdp_full_state_dict, get_fsdp_state_ctx\nfrom verl.utils.logger import log_with_rank\n\nfrom .checkpoint_manager import BaseCheckpointManager\n\n# Setup logging\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"INFO\"))\n\n\n@dataclass\nclass FSDPConfig:\n \"\"\"Configuration for FSDP checkpointing.\n\n Args:\n FSDP_version (int): Version of FSDP being used.\n world_size (int): Number of processes in the distributed training setup.\n \"\"\"\n\n FSDP_version: int\n world_size: int\n\n\nclass FSDPCheckpointManager(BaseCheckpointManager):\n \"\"\"\n Manage FSDP checkpointing in SPMD training.\n\n - Saves/loads per-rank sharded model & optimizer states\n - Persists full lr_scheduler and RNG state\n - Stores HF tokenizer/processor and model/config for unified restore\n\n Args:\n model (FSDP): Wrapped model instance.\n optimizer (Optimizer): Training optimizer.\n lr_scheduler (LRScheduler): Learning-rate scheduler.\n processing_class (PreTrainedTokenizer or ProcessorMixin, optional):\n Pre-/post-processing artifact handler.\n checkpoint_contents DictConfig: Configuration for checkpoint contents.\n - 'load': Components to load; must contain 'model'. Defaults to ['model', 'optimizer', 'extra'].\n - 'save': Components to save; must contain 'model'. Defaults to ['model', 'optimizer', 'extra'].\n trust_remote_code: Whether to trust_remote_code when loading the model configuration\n \"\"\"\n\n def __init__(\n self,\n model: FSDP,\n optimizer: Optional[torch.optim.Optimizer] = None,\n lr_scheduler: Optional[torch.optim.lr_scheduler.LRScheduler] = None,\n processing_class: PreTrainedTokenizer | ProcessorMixin = None,\n checkpoint_config: DictConfig = None,\n trust_remote_code: bool = False,\n **kwargs,\n ):\n if processing_class is None and \"tokenizer\" in kwargs:\n warnings.warn(\n \"`tokenizer` is deprecated. use `processing_class` instead.\", DeprecationWarning, stacklevel=2\n )\n processing_class = kwargs.pop(\"tokenizer\")\n\n super().__init__(\n model,\n optimizer,\n lr_scheduler=lr_scheduler,\n processing_class=processing_class,\n checkpoint_config=checkpoint_config,\n )\n self.trust_remote_code = trust_remote_code\n\n def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load=False):\n \"\"\"\n Load an FSDP checkpoint for this rank.\n\n Downloads and loads:\n - model and optimizer shards\n - extra state dict (scheduler + RNG)\n\n Args:\n local_path: Directory with per-rank checkpoint files.\n hdfs_path: Unused (for API compatibility).\n del_local_after_load: Remove local files after loading.\n \"\"\"\n if local_path is None:\n return\n\n # check if the checkpoint_load_contents is valid\n if self.should_load_model:\n assert self.model is not None, \"model must be provided when checkpoint_contents.load includes ['model']\"\n if self.should_load_optimizer:\n assert self.optimizer is not None, (\n \"optimizer must be provided when checkpoint_contents.load includes ['optimizer']\"\n )\n\n # every rank download its own checkpoint\n state_dict_cfg = (\n ShardedStateDictConfig(offload_to_cpu=True if is_cuda_available else False)\n if self.should_load_model\n else None\n )\n optim_cfg = (\n ShardedOptimStateDictConfig(offload_to_cpu=True if is_cuda_available else False)\n if self.should_load_optimizer\n else None\n )\n with get_fsdp_state_ctx(self.model, StateDictType.SHARDED_STATE_DICT, state_dict_cfg, optim_cfg):\n if self.should_load_model:\n remote_model_path = os.path.join(local_path, f\"model_world_size_{self.world_size}_rank_{self.rank}.pt\")\n local_model_path = copy_to_local(remote_model_path)\n model_state_dict = torch.load(local_model_path, weights_only=False)\n self.model.load_state_dict(model_state_dict)\n log_with_rank(f\"Loaded model from {remote_model_path}\", rank=self.rank, logger=logger)\n\n if self.should_load_optimizer:\n remote_optim_path = os.path.join(local_path, f\"optim_world_size_{self.world_size}_rank_{self.rank}.pt\")\n local_optim_path = copy_to_local(remote_optim_path)\n optimizer_state_dict = torch.load(local_optim_path, weights_only=False)\n self.optimizer.load_state_dict(optimizer_state_dict)\n log_with_rank(f\"Loaded optimizer from {remote_optim_path}\", rank=self.rank, logger=logger)\n\n if self.should_load_extra:\n remote_extra_state_path = os.path.join(\n local_path, f\"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt\"\n )\n local_extra_state_path = copy_to_local(remote_extra_state_path)\n extra_state_dict = torch.load(local_extra_state_path, weights_only=False)\n # recover random state\n if \"rng\" in extra_state_dict:\n # 'rng' may not exist for backward compatibility\n self.load_rng_state(extra_state_dict[\"rng\"])\n log_with_rank(f\"Loaded rng from {remote_extra_state_path}\", rank=self.rank, logger=logger)\n\n lr_scheduler_state_dict = extra_state_dict[\"lr_scheduler\"]\n if lr_scheduler_state_dict is not None and self.lr_scheduler is not None:\n self.lr_scheduler.load_state_dict(lr_scheduler_state_dict)\n log_with_rank(f\"Loaded lr_scheduler from {remote_extra_state_path}\", rank=self.rank, logger=logger)\n\n if self.rank == 0 and del_local_after_load:\n try:\n os.remove(local_model_path) if is_non_local(local_model_path) else None\n os.remove(local_optim_path) if is_non_local(local_optim_path) else None\n os.remove(local_extra_state_path) if is_non_local(local_extra_state_path) else None\n except Exception as e:\n log_with_rank(\n f\"remove local resume ckpt file after loading failed, exception {e} will be ignored\",\n rank=self.rank,\n logger=logger,\n )\n\n # wait for everyone to load checkpoints\n torch.distributed.barrier()\n\n def save_checkpoint(self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep=None):\n \"\"\"\n Save an FSDP checkpoint for this rank.\n\n Writes:\n - model & optimizer shard files\n - extra state dict (scheduler + RNG)\n - HF tokenizer/processor and model/config on rank 0\n - optional full HF model under 'huggingface/' if requested\n\n Rotates old checkpoints, keeping at most `max_ckpt_to_keep`.\n\n Args:\n local_path: Target directory for checkpoint files.\n hdfs_path: Unused (for API compatibility).\n global_step: Current training step (used for bookkeeping).\n max_ckpt_to_keep: Number of recent checkpoints to retain.\n \"\"\"\n if local_path is None:\n return\n\n # record the previous global step\n self.previous_global_step = global_step\n\n if self.rank == 0:\n self.ensure_checkpoint_capacity(max_ckpt_to_keep)\n\n local_path = local_mkdir_safe(local_path)\n torch.distributed.barrier()\n\n # check if the checkpoint_save_contents is valid\n if self.should_save_model:\n assert self.model is not None, \"model must be provided when checkpoint_contents.save includes ['model']\"\n if self.should_save_optimizer:\n assert self.optimizer is not None, (\n \"optimizer must be provided when checkpoint_contents.save includes ['optimizer']\"\n )\n\n # every rank will save its own model and optim shard\n state_dict_cfg = ShardedStateDictConfig(offload_to_cpu=True if is_cuda_available else False)\n optim_cfg = ShardedOptimStateDictConfig(offload_to_cpu=True if is_cuda_available else False)\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n with get_fsdp_state_ctx(self.model, StateDictType.SHARDED_STATE_DICT, state_dict_cfg, optim_cfg):\n model_path = os.path.join(local_path, f\"model_world_size_{self.world_size}_rank_{self.rank}.pt\")\n optim_path = os.path.join(local_path, f\"optim_world_size_{self.world_size}_rank_{self.rank}.pt\")\n extra_path = os.path.join(local_path, f\"extra_state_world_size_{self.world_size}_rank_{self.rank}.pt\")\n\n if self.should_save_model:\n model_state_dict = self.model.state_dict()\n torch.save(model_state_dict, model_path)\n log_with_rank(f\"Saved model to {os.path.abspath(model_path)}\", rank=self.rank, logger=logger)\n\n if self.should_save_optimizer:\n optimizer_state_dict = self.optimizer.state_dict()\n torch.save(optimizer_state_dict, optim_path)\n log_with_rank(f\"Saved optim to {os.path.abspath(optim_path)}\", rank=self.rank, logger=logger)\n\n if self.should_save_extra:\n lr_scheduler_state_dict = self.lr_scheduler.state_dict() if self.lr_scheduler is not None else None\n extra_state_dict = {\n \"lr_scheduler\": lr_scheduler_state_dict,\n \"rng\": self.get_rng_state(),\n }\n torch.save(extra_state_dict, extra_path)\n log_with_rank(f\"Saved extra_state to {os.path.abspath(extra_path)}\", rank=self.rank, logger=logger)\n\n if self.rank == 0:\n # Save HF tokenizer/processor and model config on rank 0 to huggingface/ directory, no matter whether\n # huggingface model is requested to be saved or not.\n\n if fsdp_version(self.model) == 1:\n unwrap_model = self.model._fsdp_wrapped_module\n else:\n unwrap_model = self.model\n\n hf_config_tokenizer_path = os.path.join(local_path, \"huggingface\")\n local_mkdir_safe(hf_config_tokenizer_path)\n model_config = unwrap_model.config\n generation_config = None\n if unwrap_model.can_generate() and hasattr(model_config, \"name_or_path\") and model_config.name_or_path:\n try:\n # Some model's name_or_path is empty if not initialized from pretrained,\n # in this cases, we don't save generation config.\n generation_config = GenerationConfig.from_pretrained(model_config.name_or_path)\n generation_config.save_pretrained(hf_config_tokenizer_path)\n except Exception:\n # if the generation config isn't available, we don't save it\n pass\n\n if hasattr(model_config, \"auto_map\") and None in model_config.auto_map:\n model_config.auto_map = {k: v for k, v in model_config.auto_map.items() if k is not None}\n\n model_config.save_pretrained(hf_config_tokenizer_path)\n if self.processing_class is not None:\n self.processing_class.save_pretrained(hf_config_tokenizer_path)\n log_with_rank(\n f\"Saved model config and tokenizer class to {os.path.abspath(hf_config_tokenizer_path)}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n\n # If we have a custom model, we copy the file defining it in the folder and set the attributes so it can be\n # loaded from the Hub.\n if hasattr(model_config, \"auto_map\"):\n custom_object_save(unwrap_model, hf_config_tokenizer_path, config=model_config)\n\n # Also save runtime FSDP config\n fsdp_config_path = os.path.join(local_path, \"fsdp_config.json\")\n fsdp_config = FSDPConfig(\n FSDP_version=fsdp_version(self.model),\n world_size=self.world_size,\n )\n with open(fsdp_config_path, \"w\") as f:\n json.dump(asdict(fsdp_config), f, indent=4)\n\n # wait for everyone to dump to local\n torch.distributed.barrier()\n\n if self.should_save_hf_model:\n # Only rank 0 will save hf model and,\n # offload to cpu to save LLMs which may be too large to fit in one GPU\n state_dict = get_fsdp_full_state_dict(self.model, offload_to_cpu=True, rank0_only=True)\n\n if self.rank == 0:\n hf_local_path = os.path.join(local_path, \"huggingface\")\n os.makedirs(hf_local_path, exist_ok=True)\n\n if \"ForTokenClassification\" in model_config.architectures[0]:\n from transformers import AutoModelForTokenClassification\n\n auto_model_cls = AutoModelForTokenClassification\n elif \"ForCausalLM\" in model_config.architectures[0]:\n from transformers import AutoModelForCausalLM\n\n auto_model_cls = AutoModelForCausalLM\n elif \"ForConditionalGeneration\" in model_config.architectures[0]:\n # Handle different transformers versions for Vision2Seq models\n import transformers\n from packaging import version\n\n if version.parse(transformers.__version__) >= version.parse(\"4.54.0\"):\n # transformers >= 4.54.0 uses AutoModelForImageTextToText\n from transformers import AutoModelForImageTextToText\n\n auto_model_cls = AutoModelForImageTextToText\n else:\n # transformers < 4.54.0 uses AutoModelForVision2Seq\n from transformers import AutoModelForVision2Seq\n\n auto_model_cls = AutoModelForVision2Seq\n else:\n raise NotImplementedError(f\"Unknown architecture {model_config['architectures']}\")\n\n with init_empty_weights():\n save_model = auto_model_cls.from_config(\n model_config, torch_dtype=torch.bfloat16, trust_remote_code=self.trust_remote_code\n )\n\n save_model.to_empty(device=\"cpu\")\n\n if save_model.can_generate():\n if generation_config is not None:\n save_model.generation_config = generation_config\n else:\n print(\n f\"Warning: {self.__class__.__name__}.save_checkpoint: Generation config file not found \"\n f\"in, using a generation config created from the model config when saving hf_model.\"\n )\n\n save_model.save_pretrained(hf_local_path, state_dict=state_dict)\n log_with_rank(\n f\"Saved hf_model to {os.path.abspath(hf_local_path)}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n del state_dict\n del save_model\n\n # wait for rank0 to dump hf_model to local\n torch.distributed.barrier()\n\n if self.rank == 0:\n self.register_checkpoint(local_path, max_ckpt_to_keep)\n"} +{"file_name": "verl__utils__checkpoint__megatron_checkpoint_manager.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport inspect\nimport json\nimport logging\nimport os\nimport random\nfrom collections.abc import Callable\nfrom dataclasses import asdict\n\nimport megatron.core\nimport numpy as np\nimport torch\nimport torch.distributed\nfrom megatron.core import dist_checkpointing, mpu, tensor_parallel\nfrom megatron.core.dist_checkpointing.mapping import ShardedObject\nfrom megatron.core.transformer.enums import AttnBackend\nfrom packaging import version\nfrom transformers import GenerationConfig\n\nfrom verl.models.weight_loader_registry import get_weight_saver\nfrom verl.utils.device import get_device_name, get_torch_device\nfrom verl.utils.fs import is_non_local, local_mkdir_safe\nfrom verl.utils.logger import log_with_rank\nfrom verl.utils.megatron.dist_checkpointing import load_dist_checkpointing, save_dist_checkpointing\nfrom verl.utils.megatron_utils import (\n get_dist_checkpoint_path,\n get_hf_model_checkpoint_path,\n get_transformer_config_checkpoint_path,\n)\n\nfrom .checkpoint_manager import BaseCheckpointManager\n\n# Setup logging\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"INFO\"))\nmcore_ge_014 = version.parse(megatron.core.__version__) >= version.parse(\"0.14.0\")\nif not mcore_ge_014:\n logger.warning(\n \"Detected megatron.core %s, recommend upgrading to >= 0.14.0 for better checkpoint compatibility\",\n megatron.core.__version__,\n )\n\n\nclass MegatronCheckpointManager(BaseCheckpointManager):\n \"\"\"\n Checkpoint manager for Megatron-LM distributed training.\n\n This class manages the saving and loading of model checkpoints in a Megatron-LM\n distributed training environment. It handles various aspects of checkpointing\n including model states, optimizer states, learning rate schedulers, and random\n number generator states, ensuring compatibility with HuggingFace formats.\n\n Key features:\n - Distributed checkpoint saving and loading using Megatron's dist_checkpointing\n - Support for tensor parallel, pipeline parallel, and data parallel configurations\n - Automatic handling of model state dictionaries across multiple pipeline stages\n - Integration with HuggingFace model configurations and tokenizers\n - Random number generator state management for reproducibility\n - Support for both synchronous and asynchronous checkpoint operations\n\n The manager automatically handles:\n - Directory structure creation based on global steps and process ranks\n - Model configuration and tokenizer saving in HuggingFace format\n - Optimizer and scheduler state persistence\n - CUDA RNG state management for deterministic training\n - Checkpoint cleanup and retention policies\n\n Args:\n model: The Megatron model instance to checkpoint\n optimizer: The optimizer instance (optional)\n lr_scheduler: The learning rate scheduler instance (optional)\n\n Attributes:\n model: Reference to the Megatron model being checkpointed\n optimizer: Reference to the optimizer (if provided)\n lr_scheduler: Reference to the learning rate scheduler (if provided)\n rank: Current process rank in the distributed setup\n\n Example:\n ```python\n checkpoint_manager = MegatronCheckpointManager(\n model=megatron_model,\n optimizer=optimizer,\n lr_scheduler=scheduler\n )\n\n checkpoint_manager.save_checkpoint(\n local_path=\"checkpoints/step_1000\",\n global_step=1000\n )\n\n checkpoint_manager.load_checkpoint(\n local_path=\"checkpoints/step_1000\"\n )\n ```\n \"\"\"\n\n def __init__(\n self,\n config,\n checkpoint_config,\n model_config,\n transformer_config,\n role,\n model: torch.nn.ModuleList,\n arch: str,\n hf_config,\n param_dtype: torch.dtype,\n share_embeddings_and_output_weights: bool,\n processing_class,\n optimizer,\n optimizer_scheduler,\n use_distributed_optimizer: bool,\n use_checkpoint_opt_param_scheduler: bool = False,\n use_dist_checkpointing: bool = True,\n bridge=None,\n provider=None,\n peft_cls=None,\n **kwargs,\n ):\n super().__init__(\n model,\n optimizer=optimizer,\n lr_scheduler=optimizer_scheduler,\n processing_class=processing_class,\n checkpoint_config=checkpoint_config,\n )\n self.arch = arch\n self.config = config\n self.transformer_config = transformer_config\n self.role = role\n self.is_value_model = False\n if self.role in [\"reward\", \"critic\"]:\n self.is_value_model = True\n self.model_config = model_config\n self.hf_config = hf_config\n self.param_dtype = param_dtype\n self.share_embeddings_and_output_weights = share_embeddings_and_output_weights\n self.model_path = self.config.model.path\n self.use_distributed_optimizer = use_distributed_optimizer\n self.use_checkpoint_opt_param_scheduler = use_checkpoint_opt_param_scheduler\n self.bridge = bridge\n self.provider = provider\n self.vanilla_bridge = self.provider is None\n self.peft_cls = peft_cls\n self.rank = torch.distributed.get_rank()\n # Megatron-Bridge is Okay to load/save HF checkpoint for value model as well\n self.use_dist_checkpointing = (\n use_dist_checkpointing or not self.bridge or (self.vanilla_bridge and self.is_value_model)\n )\n self.use_hf_checkpoint = not self.use_dist_checkpointing\n\n self.weight_saver = None\n if self.bridge is None:\n self.weight_saver = get_weight_saver(self.arch)\n\n def get_rng_state(self, use_dist_ckpt: bool = True, data_parallel_random_init: bool = False):\n \"\"\"collect rng state across data parallel ranks\"\"\"\n rng_state = {\n \"random_rng_state\": random.getstate(),\n \"np_rng_state\": np.random.get_state(),\n \"torch_rng_state\": torch.get_rng_state(),\n \"rng_tracker_states\": tensor_parallel.get_cuda_rng_tracker().get_states(),\n }\n\n if get_device_name() != \"cpu\":\n rng_state[f\"{get_device_name()}_rng_state\"] = get_torch_device().get_rng_state()\n\n rng_state_list = None\n if torch.distributed.is_initialized() and mpu.get_data_parallel_world_size() > 1 and data_parallel_random_init:\n rng_state_list = [None for i in range(mpu.get_data_parallel_world_size())]\n torch.distributed.all_gather_object(rng_state_list, rng_state, group=mpu.get_data_parallel_group())\n else:\n rng_state_list = [rng_state]\n\n if use_dist_ckpt:\n pp_rank = mpu.get_pipeline_model_parallel_rank()\n pp_size = mpu.get_pipeline_model_parallel_world_size()\n tp_rank = mpu.get_tensor_model_parallel_rank()\n tp_size = mpu.get_tensor_model_parallel_world_size()\n rng_state_list = ShardedObject(\n \"rng_state\",\n rng_state_list,\n (pp_size, tp_size),\n (pp_rank, tp_rank),\n replica_id=mpu.get_data_parallel_rank(with_context_parallel=True),\n )\n\n return rng_state_list\n\n def get_checkpoint_name(\n self,\n checkpoints_path,\n pipeline_parallel=None,\n tensor_rank=None,\n pipeline_rank=None,\n cp_rank=None,\n expert_parallel=None,\n expert_rank=None,\n return_base_dir=True,\n basename=\"model.pt\",\n ):\n \"\"\"Determine the directory name for this rank's checkpoint.\"\"\"\n # Use both the tensor and pipeline MP rank.\n if pipeline_parallel is None:\n pipeline_parallel = mpu.get_pipeline_model_parallel_world_size() > 1\n if tensor_rank is None:\n tensor_rank = mpu.get_tensor_model_parallel_rank()\n if pipeline_rank is None:\n pipeline_rank = mpu.get_pipeline_model_parallel_rank()\n if cp_rank is None:\n cp_rank = mpu.get_context_parallel_rank()\n if expert_parallel is None:\n expert_parallel = mpu.get_expert_model_parallel_world_size() > 1\n if expert_rank is None:\n expert_rank = mpu.get_expert_model_parallel_rank()\n\n # Use both the tensor and pipeline MP rank. If using the distributed\n # optimizer, then the optimizer's path must additionally include the\n # data parallel rank.\n\n # due to the fact that models are identical across cp ranks, cp rank is not used in the checkpoint path\n if not pipeline_parallel:\n common_path = os.path.join(checkpoints_path, f\"mp_rank_{tensor_rank:02d}\")\n else:\n common_path = os.path.join(checkpoints_path, f\"mp_rank_{tensor_rank:02d}_{pipeline_rank:03d}\")\n\n if expert_parallel:\n common_path = common_path + f\"_{expert_rank:03d}\"\n\n os.makedirs(common_path, exist_ok=True)\n\n if return_base_dir:\n return common_path\n return os.path.join(common_path, basename)\n\n def generate_state_dict(\n self,\n generate_model: bool = True,\n generate_optimizer: bool = True,\n generate_extra: bool = True,\n is_loading: bool = False,\n metadata: dict | None = None,\n ):\n # For save dist checkpointing\n state_dict = {}\n base_metadata = metadata or self._build_sharded_state_dict_metadata()\n\n # Should always generate model state dict\n # All ranks Save Model to reduce memory pressure\n # Get sharded state dict, notice that state_dict will collect among dp groups, causing memory pressure\n for vpp_rank, model in enumerate(self.model):\n if len(self.model) > 1:\n mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)\n key = f\"model{vpp_rank}\" if len(self.model) > 1 else \"model\"\n else:\n key = \"model\"\n if hasattr(model, \"module\"):\n model = model.module\n\n # GPTModel's sharded_state_dict function when having mtp requires metadata['dp_cp_group']\n model_metadata = dict(base_metadata)\n model_metadata[\"dp_cp_group\"] = mpu.get_data_parallel_group(with_context_parallel=True)\n kwargs = {\"metadata\": model_metadata}\n state_dict[key] = model.sharded_state_dict(**kwargs)\n\n # Optimizer State Dict\n if generate_optimizer:\n torch.distributed.barrier()\n sharded_state_dict_kwargs = {\"is_loading\": is_loading}\n if base_metadata is not None:\n # https://github.com/NVIDIA/Megatron-LM/blob/core_v0.14.0/megatron/core/optimizer/distrib_optimizer.py#L1109-L1123\n if mcore_ge_014:\n sharded_state_dict_kwargs[\"metadata\"] = base_metadata\n optimizer_sharded_states = self.optimizer.sharded_state_dict(state_dict, **sharded_state_dict_kwargs)\n state_dict[\"optimizer\"] = optimizer_sharded_states\n\n if self.lr_scheduler is not None:\n lr_state_dict = self.lr_scheduler.state_dict()\n state_dict[\"lr_scheduler\"] = lr_state_dict\n\n if not generate_model:\n state_dict.pop(\"model\", None)\n\n # RNG States State Dict\n if generate_extra:\n torch.distributed.barrier()\n rng_state = self.get_rng_state()\n state_dict[\"rng_state\"] = rng_state\n\n return state_dict\n\n def _build_sharded_state_dict_metadata(self) -> dict:\n \"\"\"Builds metadata used for sharded_state_dict versioning.\n\n\n The whole content metadata is passed to ``sharded_state_dict`` model and optimizer methods\n and therefore affects only the logic behind sharded_state_dict creation.\n The content metadata should be minimalistic, ideally flat (or with a single nesting level)\n and with semantically meaningful flag names (e.g. `distrib_optim_sharding_type`).\n In particular, a simple integer (or SemVer) versioning flag (e.g. `metadata['version'] = 3.4`)\n is discouraged, because the metadata serves for all models and optimizers and it's practically\n impossible to enforce a linearly increasing versioning for this whole space.\n \"\"\"\n metadata: dict = {}\n\n if not mcore_ge_014:\n # For backward compatibility with Megatron core < v0.14.0\n if self.use_distributed_optimizer:\n metadata[\"distrib_optim_sharding_type\"] = \"fully_sharded_model_space\"\n return metadata\n\n if self.use_distributed_optimizer:\n megatron_config = getattr(self.config, self.role, self.config).megatron\n dist_ckpt_optim_fully_reshardable = megatron_config.dist_ckpt_optim_fully_reshardable\n distrib_optim_fully_reshardable_mem_efficient = (\n megatron_config.distrib_optim_fully_reshardable_mem_efficient\n )\n if dist_ckpt_optim_fully_reshardable:\n metadata[\"distrib_optim_sharding_type\"] = \"fully_reshardable\"\n metadata[\"distrib_optim_fully_reshardable_mem_efficient\"] = (\n distrib_optim_fully_reshardable_mem_efficient\n )\n else:\n metadata[\"distrib_optim_sharding_type\"] = \"dp_reshardable\"\n\n metadata[\"singleton_local_shards\"] = False\n metadata[\"chained_optim_avoid_prefix\"] = True\n return metadata\n\n def load_rng_states(self, rng_states, data_parallel_random_init=False, use_dist_ckpt=True):\n # access rng_state for data parallel rank\n if data_parallel_random_init:\n rng_states = rng_states[mpu.get_data_parallel_rank()]\n else:\n rng_states = rng_states[0]\n random.setstate(rng_states[\"random_rng_state\"])\n np.random.set_state(rng_states[\"np_rng_state\"])\n torch.set_rng_state(rng_states[\"torch_rng_state\"])\n\n if get_device_name() != \"cpu\":\n get_torch_device().set_rng_state(rng_states[f\"{get_device_name()}_rng_state\"])\n\n # Check for empty states array\n if not rng_states[\"rng_tracker_states\"]:\n raise KeyError\n tensor_parallel.get_cuda_rng_tracker().set_states(rng_states[\"rng_tracker_states\"])\n\n def load_checkpoint(self, local_path: str, hdfs_path: str = None, del_local_after_load=False):\n if local_path is not None:\n assert os.path.exists(local_path), f\"Checkpoint path {local_path} does not exist.\"\n\n # For load optimizer dist_ckpt\n try:\n import transformer_engine\n\n torch.serialization.add_safe_globals([torch.optim.AdamW])\n torch.serialization.add_safe_globals([transformer_engine.pytorch.optimizers.fused_adam.FusedAdam])\n except Exception:\n pass\n\n dist_checkpoint_path = get_dist_checkpoint_path(local_path)\n\n load_content_metadata = getattr(dist_checkpointing, \"load_content_metadata\", None)\n if load_content_metadata is None:\n # For backward compatibility\n sharded_sd_metadata = None\n else:\n sharded_sd_metadata = load_content_metadata(checkpoint_dir=dist_checkpoint_path)\n if sharded_sd_metadata is None:\n if self.use_distributed_optimizer:\n # Backward-compatibility with old checkpoints which don't have content versioning\n # Can be removed after ending support for MLM optimizer checkpoints with MCore < v0.13\n # (for MCore v0.13+ checkpoints `sharded_sd_metadata is not None`)\n sharded_sd_metadata = {\n \"distrib_optim_sharding_type\": \"fully_sharded_model_space\",\n }\n else:\n sharded_sd_metadata = self._build_sharded_state_dict_metadata()\n\n # Get State Dict for loading\n sharded_state_dict = self.generate_state_dict(\n self.should_load_model and self.use_dist_checkpointing,\n self.should_load_optimizer,\n self.should_load_extra,\n is_loading=True,\n metadata=sharded_sd_metadata,\n )\n log_with_rank(f\"Generated state dict for loading: {sharded_state_dict.keys()}\", rank=self.rank, logger=logger)\n\n # Load Dist Checkpointing\n state_dict = load_dist_checkpointing(\n sharded_state_dict=sharded_state_dict,\n ckpt_dir=dist_checkpoint_path,\n )\n\n if self.should_load_model and self.use_dist_checkpointing:\n assert \"model\" in state_dict or any(\n f\"model{vpp_rank}\" in state_dict for vpp_rank in range(len(self.model))\n ), f\"Model state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}.\"\n for vpp_rank, model in enumerate(self.model):\n if len(self.model) == 1:\n model_state_dict = state_dict[\"model\"]\n else:\n assert f\"model{vpp_rank}\" in state_dict, f\"model{vpp_rank} not found in state_dict\"\n model_state_dict = state_dict[f\"model{vpp_rank}\"]\n mpu.set_virtual_pipeline_model_parallel_rank(vpp_rank)\n self.model[vpp_rank].load_state_dict(model_state_dict)\n log_with_rank(f\"Loaded sharded model checkpoint from {local_path}\", rank=self.rank, logger=logger)\n\n # Skip HF checkpoint loading if PEFT is used\n elif self.should_load_model and self.use_hf_checkpoint and self.peft_cls is None:\n hf_model_path = get_hf_model_checkpoint_path(local_path)\n if self.vanilla_bridge:\n self.bridge.load_weights(self.model, hf_model_path)\n else:\n self.bridge.load_hf_weights(self.model, hf_model_path)\n log_with_rank(f\"Loaded HF model checkpoint from {hf_model_path} with bridge\", rank=self.rank, logger=logger)\n # Load PEFT adapter checkpoint if available\n if self.should_load_model and self.peft_cls is not None:\n adapter_ckpt_path = os.path.join(local_path, \"adapter_checkpoint\")\n if os.path.exists(adapter_ckpt_path):\n from verl.utils.megatron_peft_utils import load_adapter_checkpoint\n\n # TODO: a better format for adapter checkpoint, waiting megatron-bridge support\n\n load_adapter_checkpoint(\n self.model,\n adapter_ckpt_path,\n )\n log_with_rank(\n f\"Loaded adapter checkpoint from {adapter_ckpt_path}\",\n rank=self.rank,\n logger=logger,\n )\n else:\n log_with_rank(\n f\"PEFT config is set but no adapter checkpoint found at {adapter_ckpt_path}\",\n rank=self.rank,\n logger=logger,\n )\n\n if self.should_load_optimizer:\n assert \"optimizer\" in state_dict, (\n f\"Optimizer state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}.\"\n )\n optimizer_state_dict = state_dict[\"optimizer\"]\n self.optimizer.load_state_dict(optimizer_state_dict)\n log_with_rank(f\"Loaded optimizer checkpoint from {local_path}\", rank=self.rank, logger=logger)\n if self.use_checkpoint_opt_param_scheduler:\n assert \"lr_scheduler\" in state_dict, (\n f\"LR scheduler state dict not found in {state_dict.keys()}. Please check the checkpoint file \"\n f\"{local_path}.\"\n )\n lr_scheduler_state_dict = state_dict[\"lr_scheduler\"]\n if self.lr_scheduler is not None:\n self.lr_scheduler.load_state_dict(lr_scheduler_state_dict)\n log_with_rank(f\"Loaded LR scheduler checkpoint from {local_path}\", rank=self.rank, logger=logger)\n\n if self.should_load_extra:\n assert \"rng_state\" in state_dict, (\n f\"RNG state dict not found in {state_dict.keys()}. Please check the checkpoint file {local_path}.\"\n )\n rng_state = state_dict[\"rng_state\"]\n self.load_rng_states(rng_state)\n log_with_rank(f\"Loaded RNG states from {local_path}\", rank=self.rank, logger=logger)\n\n if del_local_after_load:\n try:\n os.remove(local_path) if is_non_local(local_path) else None\n except Exception as e:\n log_with_rank(\n f\"remove local resume ckpt file after loading failed, exception {e} will be ignored\",\n rank=self.rank,\n logger=logger,\n )\n\n def save_checkpoint(self, local_path: str, hdfs_path: str = None, global_step: int = 0, max_ckpt_to_keep=None):\n # record the previous global step\n self.previous_global_step = global_step\n\n if not self.checkpoint_config.async_save:\n self.ensure_checkpoint_capacity(max_ckpt_to_keep)\n\n local_path = local_mkdir_safe(local_path)\n dist_checkpoint_path = get_dist_checkpoint_path(local_path)\n\n # Note that model weights, optimizer states, and extra states are generated\n # together in a state dict, we save them in one time\n if self.use_dist_checkpointing:\n # Generate state dict for saving\n sharded_sd_metadata = self._build_sharded_state_dict_metadata()\n state_dict = self.generate_state_dict(\n self.should_save_model,\n self.should_save_optimizer,\n self.should_save_extra,\n metadata=sharded_sd_metadata,\n )\n log_with_rank(f\"Generated state dict for saving: {state_dict.keys()}\", rank=self.rank, logger=logger)\n for vpp_rank, model in enumerate(self.model):\n if len(self.model) > 1:\n model_i_keys = state_dict[f\"model{vpp_rank}\"].keys()\n log_with_rank(f\"Generated state dict for saving: {model_i_keys}\", rank=self.rank, logger=logger)\n else:\n log_with_rank(\n f\"Generated state dict for saving: {state_dict['model'].keys()}\", rank=self.rank, logger=logger\n )\n # Start Async save if enabled\n async_save_request = save_dist_checkpointing(\n sharded_state_dict=state_dict,\n ckpt_path=dist_checkpoint_path,\n async_save=self.checkpoint_config.async_save,\n content_metadata=sharded_sd_metadata,\n )\n\n # Synchronize all async save requests\n if not self.checkpoint_config.async_save:\n assert async_save_request is None, \"Async save request should be None when not using async save.\"\n torch.distributed.barrier()\n else:\n assert self.use_hf_checkpoint, \"When not using distributed checkpointing, use_hf_checkpoint should be True.\"\n # Generate optimizer and exra state dicts\n sharded_sd_metadata = self._build_sharded_state_dict_metadata()\n state_dict = self.generate_state_dict(\n generate_model=False,\n generate_optimizer=self.should_save_optimizer,\n generate_extra=self.should_save_extra,\n metadata=sharded_sd_metadata,\n )\n # Save optimizer and extra states to local path\n # Start Async save if enabled\n async_save_request = save_dist_checkpointing(\n sharded_state_dict=state_dict,\n ckpt_path=dist_checkpoint_path,\n async_save=self.checkpoint_config.async_save,\n content_metadata=sharded_sd_metadata,\n )\n\n # Synchronize all async save requests\n if not self.checkpoint_config.async_save:\n assert async_save_request is None, \"Async save request should be None when not using async save.\"\n torch.distributed.barrier()\n\n if self.should_save_model:\n # Save adapter-only checkpoint if PEFT is enabled\n if self.peft_cls is not None:\n from verl.utils.megatron_peft_utils import save_adapter_checkpoint\n\n adapter_ckpt_path = os.path.join(local_path, \"adapter_checkpoint\")\n\n # Save adapter weights only (much smaller than full model)\n save_adapter_checkpoint(\n self.model,\n adapter_ckpt_path,\n self.rank,\n )\n\n log_with_rank(\n f\"Saved adapter-only checkpoint to {adapter_ckpt_path}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n elif self.use_hf_checkpoint:\n # Use mbridge to save HF model checkpoint\n log_with_rank(f\"Saving HF model checkpoint to {local_path} with bridge\", rank=self.rank, logger=logger)\n hf_ckpt_path = get_hf_model_checkpoint_path(local_path)\n if self.vanilla_bridge:\n extended_args = {}\n mbridge_config = getattr(self.checkpoint_config, \"mbridge_config\", None) or {}\n for sig in inspect.signature(self.bridge.save_weights).parameters:\n if sig == \"weights_path\" or sig == \"models\":\n continue\n if sig in mbridge_config:\n extended_args[sig] = mbridge_config[sig]\n self.bridge.save_weights(self.model, hf_ckpt_path, **extended_args)\n else:\n self.bridge.save_hf_weights(self.model, hf_ckpt_path)\n\n log_with_rank(f\"Saved bridge checkpoint to {hf_ckpt_path}\", rank=self.rank, logger=logger)\n\n # Only rank 0 saves the hf config and tokenizer to huggingface path\n # No matter whether we save hf model or not\n if self.rank == 0:\n # Save tokenizer\n hf_config_tokenizer_path = get_hf_model_checkpoint_path(local_path)\n if self.processing_class is not None:\n self.processing_class.save_pretrained(hf_config_tokenizer_path)\n # Save huggingface config\n self.hf_config.save_pretrained(hf_config_tokenizer_path)\n if hasattr(self.hf_config, \"name_or_path\") and self.hf_config.name_or_path:\n try:\n generation_config = GenerationConfig.from_pretrained(self.hf_config.name_or_path)\n generation_config.save_pretrained(hf_config_tokenizer_path)\n except Exception:\n # if the generation config isn't available, we don't save it\n pass\n log_with_rank(\n f\"Saved Huggingface config and tokenizer to {hf_config_tokenizer_path}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n\n if self.should_save_extra:\n if self.rank == 0:\n # Save transformer config\n print(self.transformer_config)\n bypass_keys = [\n \"finalize_model_grads_func\",\n \"grad_scale_func\",\n \"no_sync_func\",\n \"grad_sync_func\",\n \"param_sync_func\",\n \"generation_config\",\n \"_pg_collection\",\n ]\n backup = {}\n for k in bypass_keys:\n if hasattr(self.transformer_config, k):\n backup[k] = getattr(self.transformer_config, k, None)\n delattr(self.transformer_config, k)\n transformer_config_dict = asdict(self.transformer_config)\n for k in backup:\n setattr(self.transformer_config, k, backup[k])\n to_convert_types = {torch.dtype: str, AttnBackend: str}\n ignore_types = [Callable]\n pop_keys = []\n for key, value in transformer_config_dict.items():\n if type(value) in to_convert_types:\n transformer_config_dict[key] = to_convert_types[type(value)](value)\n if type(value) in ignore_types:\n pop_keys.append(key)\n if callable(value):\n pop_keys.append(key)\n for key in pop_keys:\n transformer_config_dict.pop(key)\n transformer_config_path = get_transformer_config_checkpoint_path(local_path)\n with open(transformer_config_path, \"w\") as f:\n json.dump(transformer_config_dict, f, indent=2)\n\n if self.should_save_hf_model and not self.use_hf_checkpoint:\n # wait for everyone to dump to local\n if self.bridge is not None:\n hf_model_ckpt_path = get_hf_model_checkpoint_path(local_path)\n if self.vanilla_bridge:\n extended_args = {}\n mbridge_config = getattr(self.checkpoint_config, \"mbridge_config\", None) or {}\n for sig in inspect.signature(self.bridge.save_weights).parameters:\n if sig == \"weights_path\" or sig == \"models\":\n continue\n if sig in mbridge_config:\n extended_args[sig] = mbridge_config[sig]\n self.bridge.save_weights(self.model, hf_model_ckpt_path, **extended_args)\n else:\n self.bridge.save_hf_weights(self.model, hf_model_ckpt_path)\n else:\n state_dict = self.weight_saver(\n self.model,\n self.hf_config,\n dtype=self.param_dtype,\n is_value_model=self.is_value_model,\n tie_word_embeddings=self.share_embeddings_and_output_weights,\n )\n\n torch.distributed.barrier()\n if self.rank == 0:\n hf_model_ckpt_path = get_hf_model_checkpoint_path(local_path)\n import warnings\n\n from accelerate import init_empty_weights\n\n with init_empty_weights(), warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n if \"mistral7b-rm\" in self.config.model.path:\n from transformers import MistralForSequenceClassification\n\n model = MistralForSequenceClassification.from_pretrained(\n self.config.model.path\n ) # use score head instead of lm_head\n state_dict[\"score.weight\"] = state_dict[\"score.weight\"]\n else:\n from transformers import AutoModelForCausalLM\n\n model = AutoModelForCausalLM.from_pretrained(self.config.model.path, torch_dtype=\"auto\")\n model.save_pretrained(hf_model_ckpt_path, state_dict=state_dict)\n log_with_rank(\n f\"Saved Huggingface config and tokenizer to {hf_model_ckpt_path}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n\n if hdfs_path is not None:\n log_with_rank(\n f\"Uploading checkpoint to {hdfs_path}\", rank=self.rank, logger=logger, log_only_rank_0=True\n )\n from verl.utils import hdfs_io\n\n hdfs_io.makedirs(hdfs_path, exist_ok=True)\n hdfs_io.copy(src=hf_model_ckpt_path, dst=hdfs_path, dirs_exist_ok=True)\n log_with_rank(\n f\"HDFS checkpoint uploaded to {hdfs_path}\",\n rank=self.rank,\n logger=logger,\n log_only_rank_0=True,\n )\n\n def finalize_save_fn():\n # Rank 0 uploads checkpoint to HDFS if hdfs_path is provided\n log_with_rank(\n f\"Dist checkpointing save completed for {dist_checkpoint_path}\", rank=self.rank, logger=logger\n )\n if self.rank == 0:\n if hdfs_path is not None:\n log_with_rank(f\"Uploading checkpoint to {hdfs_path}\", rank=self.rank, logger=logger)\n from verl.utils import hdfs_io\n\n hdfs_io.makedirs(hdfs_path, exist_ok=True)\n hdfs_io.copy(src=dist_checkpoint_path, dst=hdfs_path, dirs_exist_ok=True)\n hdfs_io.copy(src=hf_config_tokenizer_path, dst=hdfs_path, dirs_exist_ok=True)\n\n # update latest_checkpointed_iteration.txt when async_save is True\n if self.checkpoint_config.async_save and self.rank == 0:\n log_with_rank(\n f\"Update latest_checkpointed_iteration.txt to step {global_step}\",\n rank=self.rank,\n logger=logger,\n )\n local_latest_checkpointed_iteration = os.path.join(\n os.path.dirname(os.path.dirname(local_path)), \"latest_checkpointed_iteration.txt\"\n )\n with open(local_latest_checkpointed_iteration, \"w\") as f:\n f.write(str(global_step))\n\n self.register_checkpoint(local_path, max_ckpt_to_keep)\n\n if self.checkpoint_config.async_save:\n assert async_save_request is not None, \"Async save request should not be None when using async save.\"\n async_save_request.add_finalize_fn(finalize_save_fn)\n from megatron.core.dist_checkpointing.strategies.base import async_calls\n\n async_calls.schedule_async_request(async_save_request)\n else:\n finalize_save_fn()\n"} +{"file_name": "verl__utils__dataset__dataset_utils.py", "text": "# Copyright 2025 Bytedance Ltd. and/or its affiliates\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\nfrom enum import Enum\n\nimport torch\nfrom tensordict.tensorclass import NonTensorData\n\n\nclass DatasetPadMode(str, Enum):\n \"\"\"Padding mode for dataset\"\"\"\n\n RIGHT = \"right\"\n LEFT_RIGHT = \"left_right\"\n NO_PADDING = \"no_padding\"\n\n\nclass SFTTensorCollator:\n \"\"\"\n A custom collate_fn that handles batching of sequences.\n 1. for variable-length sequences, convert them into NestedTensors.\n 2. for fixed-length sequences, use default_collate.\n \"\"\"\n\n def __init__(self, pad_mode: DatasetPadMode = DatasetPadMode.LEFT_RIGHT):\n self.pad_mode = pad_mode\n\n def __call__(self, batch: list[dict[str, any]]) -> dict[str, any]:\n if self.pad_mode == DatasetPadMode.NO_PADDING:\n return self.collate_variable_batch(batch)\n elif self.pad_mode in [DatasetPadMode.RIGHT, DatasetPadMode.LEFT_RIGHT]:\n from torch.utils.data import default_collate\n\n return default_collate(batch)\n else:\n raise NotImplementedError(f\"pad_mode {self.pad_mode} not implemented\")\n\n def collate_variable_batch(self, batch: list[dict[str, any]]) -> dict[str, any]:\n \"\"\"\n Collates a list of samples into a single batch.\n\n Args:\n batch: A list of dictionary samples from the dataset.\n\n Returns:\n A dictionary representing the batched data, with variable-length\n sequences converted to NestedTensors.\n \"\"\"\n\n final_batch = {}\n\n tensor_keys = set().union(*(d.keys() for d in batch))\n\n # Handle tensor values by creating a NestedTensor.\n for key in tensor_keys:\n if isinstance(batch[0][key], torch.Tensor):\n tensors = [item[key] for item in batch]\n final_batch[key] = torch.nested.as_nested_tensor(tensors, layout=torch.jagged)\n else:\n tensors = [NonTensorData(item.get(key)) for item in batch]\n final_batch[key] = torch.stack(tensors, dim=0)\n\n return final_batch\n"} +{"file_name": "verl__utils__dataset__multiturn_sft_dataset.py", "text": "# Copyright 2024 Bytedance Ltd. and/or its affiliates\n# Copyright 2025 ModelBest Inc. and/or its affiliates\n\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n\n# http://www.apache.org/licenses/LICENSE-2.0\n\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nMulti-turn SFT dataset that supports training on conversation data with multiple turns\n\"\"\"\n\nimport logging\nimport os\nimport re\nfrom functools import wraps\nfrom typing import Any, Optional\n\nimport numpy as np\nimport pandas as pd\nimport torch\nimport torch.nn.functional as F\nfrom omegaconf import DictConfig, ListConfig\nfrom torch.utils.data import Dataset\nfrom transformers import PreTrainedTokenizer, ProcessorMixin\n\nfrom verl.models.transformers.qwen2_vl import get_rope_index\nfrom verl.utils import hf_tokenizer\nfrom verl.utils.chat_template import extract_system_prompt_and_generation\nfrom verl.utils.dataset.dataset_utils import DatasetPadMode\nfrom verl.utils.dataset.vision_utils import process_image, process_video\nfrom verl.utils.fs import copy_local_path_from_hdfs\n\nlogger = logging.getLogger(__file__)\nlogger.setLevel(os.getenv(\"VERL_LOGGING_LEVEL\", \"WARN\"))\n\n\ndef once(func):\n \"\"\"Decorator to ensure a function runs only once. Subsequent calls do nothing.\"\"\"\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n if not hasattr(wrapper, \"called\"):\n wrapper.called = True\n return func(*args, **kwargs)\n\n return wrapper\n\n\n@once\ndef print_assembled_message(tokenizer, message_list, input_ids, loss_mask, attn_mask, tools):\n \"\"\"\n Print the message after applying the chat template\n \"\"\"\n\n tokenized = tokenizer.apply_chat_template(message_list, add_generation_prompt=False, tokenize=False, tools=tools)\n sep = \"\\n\\n\"\n str = f\"tokenized entire message:\\n{tokenized}\"\n str += sep\n str += f\"tokenized seperately :\\n{tokenizer.decode(input_ids)}\"\n\n logger.debug(str)\n\n\ndef convert_nested_value_to_list_recursive(data_item):\n if isinstance(data_item, dict):\n return {k: convert_nested_value_to_list_recursive(v) for k, v in data_item.items()}\n elif isinstance(data_item, list):\n return [convert_nested_value_to_list_recursive(elem) for elem in data_item]\n elif isinstance(data_item, np.ndarray):\n # Convert to list, then recursively process the elements of the new list\n return convert_nested_value_to_list_recursive(data_item.tolist())\n else:\n # Base case: item is already a primitive type (int, str, float, bool, etc.)\n return data_item\n\n\nclass MultiTurnSFTDataset(Dataset):\n \"\"\"\n Dataset for multi-turn conversations where each assistant response should be trained\n\n Args:\n data_files (str or list): Path(s) to Parquet file(s).\n tokenizer (PreTrainedTokenizer): For the tokenization of text to token IDs.\n config (DictConfig): Options like cache_dir, prompt_key, max_prompt_length, truncation, etc.\n processor (ProcessorMixin, optional): Multimodal preprocessor for images/videos.\n max_samples (int, optional): Limit the number of samples. Defaults to -1 (use all).\n \"\"\"\n\n def __init__(\n self,\n parquet_files: str | list[str],\n tokenizer: PreTrainedTokenizer,\n config: DictConfig,\n processor: Optional[ProcessorMixin] = None,\n max_samples: int = -1,\n ):\n # Set defaults and extract parameters from config if provided\n config = config or {}\n self.pad_mode = config.get(\"pad_mode\", \"right\")\n assert self.pad_mode in [\"right\", \"no_padding\"], (\n f\"Expect pad_mode to be 'right' or 'no_padding'. Got {self.pad_mode}\"\n )\n self.truncation = config.get(\"truncation\", \"error\")\n # for right padding\n self.max_length = config.get(\"max_length\", 1024)\n # Get messages_key from the new multiturn config structure\n self.messages_key = config.get(\"messages_key\", \"messages\")\n self.image_key = config.get(\"image_key\", \"images\")\n self.video_key = config.get(\"video_key\", \"videos\")\n self.image_patch_size = config.get(\n \"image_patch_size\", processor.image_processor.patch_size if processor else None\n )\n self.tools_key = config.get(\"tools_key\", \"tools\")\n self.enable_thinking_key = config.get(\"enable_thinking_key\", \"enable_thinking\")\n self.enable_thinking_default = config.get(\"enable_thinking_default\", None)\n self.apply_chat_template_kwargs = config.get(\"apply_chat_template_kwargs\", {})\n self.shuffle = config.get(\"shuffle\", False)\n self.seed = config.get(\"seed\")\n self.max_samples = max_samples\n self.ignore_input_ids_mismatch = config.get(\"ignore_input_ids_mismatch\", False)\n assert self.truncation in [\"error\", \"left\", \"right\"]\n\n if not isinstance(parquet_files, list | ListConfig):\n parquet_files = [parquet_files]\n\n self.parquet_files = parquet_files\n if isinstance(tokenizer, str):\n tokenizer = hf_tokenizer(tokenizer)\n self.tokenizer: PreTrainedTokenizer = tokenizer\n self.processor = processor\n\n self._download()\n self._read_files_and_process()\n\n def _download(self):\n for i, parquet_file in enumerate(self.parquet_files):\n self.parquet_files[i] = copy_local_path_from_hdfs(parquet_file, verbose=True)\n\n def _read_files_and_process(self):\n def series_to_item(ls):\n import numpy\n import pandas\n\n while isinstance(ls, pandas.core.series.Series | numpy.ndarray) and len(ls) == 1:\n ls = ls[0]\n return ls\n\n dataframes = []\n for parquet_file in self.parquet_files:\n # default loader loads some list as np.ndarray, which fails the tokenizer\n dataframe = pd.read_parquet(parquet_file, dtype_backend=\"pyarrow\")\n dataframes.append(dataframe)\n self.dataframe = pd.concat(dataframes)\n\n total = len(self.dataframe)\n print(f\"dataset len: {len(self.dataframe)}\")\n\n if self.max_samples > 0 and self.max_samples < total:\n if self.shuffle:\n rngs_args = (self.seed,) if self.seed is not None else ()\n rng = np.random.default_rng(*rngs_args)\n indices = rng.choice(total, size=self.max_samples, replace=False)\n else:\n indices = np.arange(self.max_samples)\n self.dataframe = self.dataframe.iloc[indices.tolist()]\n print(f\"selected {self.max_samples} random samples out of {total}\")\n\n # Extract messages list from dataframe\n self.messages = self.dataframe[self.messages_key].apply(convert_nested_value_to_list_recursive).tolist()\n\n # Extract tools list from dataframe\n if self.tools_key in self.dataframe.columns:\n self.tools = self.dataframe[self.tools_key].apply(convert_nested_value_to_list_recursive).tolist()\n else:\n self.tools = None\n # Extract enable_thinking list from dataframe\n if self.enable_thinking_key in self.dataframe.columns:\n self.enable_thinking = self.dataframe[self.enable_thinking_key].tolist()\n else:\n self.enable_thinking = None\n\n # system prompt: <|im_start|>system\\nYou are a helpful assistant.<|im_end|>\\n\n # generation prompt: <|im_start|>assistant\\n\n self.system_prompt, self.generation_prompt = extract_system_prompt_and_generation(self.tokenizer)\n\n def __len__(self):\n return len(self.messages)\n\n def _process_single_message(\n self,\n index: int,\n message: dict[str, Any],\n full_message: list,\n tools: Optional[list[dict[str, Any]]] = None,\n enable_thinking: Optional[bool] = None,\n ) -> tuple[list[int], list[int], list[int]]:\n \"\"\"\n Process a single message and return its tokenized representation.\n\n Args:\n index: turn index in the conversation\n message: A single message dictionary\n images: List of images to be used\n videos: List of videos to be used\n tools: List of tools to be used\n enable_thinking: Whether to enable thinking mode\n\n Returns:\n Tuple of (input_ids, loss_mask, attention_mask, dict[str, torch.Tensor])\n \"\"\"\n processor = self.processor if self.processor is not None else self.tokenizer\n apply_chat_template_kwargs = {**self.apply_chat_template_kwargs}\n if enable_thinking is not None:\n apply_chat_template_kwargs[\"enable_thinking\"] = enable_thinking\n\n inputs = processor.apply_chat_template(\n [message],\n tools=tools,\n add_generation_prompt=False,\n tokenize=True,\n return_dict=True,\n return_tensors=\"pt\",\n **apply_chat_template_kwargs,\n )\n\n inputs = dict(inputs)\n input_ids = inputs.pop(\"input_ids\")[0]\n attention_mask = inputs.pop(\"attention_mask\")[0]\n\n # remove system prompt if exists\n if index != 0 and message[\"role\"] != \"system\":\n input_ids = input_ids[len(self.system_prompt) :]\n attention_mask = attention_mask[len(self.system_prompt) :]\n\n if message[\"role\"] == \"assistant\":\n loss_mask = torch.ones_like(attention_mask)\n # mask out generation prompt if assistant message\n loss_mask[: len(self.generation_prompt)] = 0\n else:\n loss_mask = torch.zeros_like(attention_mask)\n\n return input_ids, loss_mask, attention_mask, inputs\n\n def _build_messages(self, example: dict):\n \"\"\"Replace and