Datasets:
File size: 10,724 Bytes
e1ced61 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 | """Padding-aligned GRPO trainer for the pinned TRL 1.9.1 + Qwen3.5-VL stack.
TRL 1.9.1's ``GRPOTrainer._generate_and_score_completions`` builds the
multimodal forward inputs for a VLM batch from *two* separate processor calls
that pad on opposite sides:
* ``prompt_ids`` come from ``_tokenize_prompts`` and are later left-padded
(``padding_side="left"``) so the causal model can decode from the right edge.
* ``mm_token_type_ids`` and ``image_grid_thw`` come from a second call
``processing_class(images=..., text=..., padding=True)`` whose Qwen processor
pads on the **right**.
For a batch whose prompts have unequal token lengths the two tensors no longer
describe the same columns: the image markers in ``mm_token_type_ids`` sit at
different positions than the real image-pad tokens in the left-padded
``prompt_completion_ids``. ``Qwen3_5VLForConditionalGeneration.get_rope_index``
then groups the (misaligned) ``mm_token_type_ids``, consumes a full
``image_grid_thw`` entry for a *partial* image-marker run, and produces an
``llm_positions`` tensor whose column count exceeds the non-padded token count
of the row — raising::
RuntimeError: shape mismatch: value tensor of shape [3, 929] cannot be
broadcast to indexing result of shape [3, 613]
The crash is data- and batch-composition-dependent: equal-length batches pad
trivially and run; a heterogeneous batch (different image patch counts / prompt
lengths) misaligns and crashes. The same misalignment can also fail *silently*,
dropping an image's vision positions entirely (text-only fallback) without
raising.
The fix recomputes ``mm_token_type_ids`` from the actual ``input_ids`` that
reach the model: every image-pad token marks a vision position, every other
token marks a text position. This is exactly the construction TRL already uses
for the tool-image path (``grpo_trainer.py`` ~line 2524), ported to the
non-tool path. Because ``input_ids`` is the left-padded
``prompt_completion_ids`` itself, the rebuilt marker tensor is aligned to it by
construction, regardless of how the second processor call padded. Only the
per-token marker tensor is rewritten; ``pixel_values``, ``image_grid_thw``,
``num_images``, prompts, completions, masks, and the rollout are untouched, so
vLLM generation (which uses its own path) and all sampling are unchanged — this
is a correctness fix to the training forward, not a hyperparameter.
The override lives on a single shared base so every controlled RL arm
(``grpo``, ``papo_controlled``, ``evi_po``) inherits it.
"""
from __future__ import annotations
import logging
import os
from typing import Any, cast
import torch
from trl import GRPOTrainer
from .vllm_runtime import (
CUDAGRAPH_ENV_VAR,
cudagraphs_enabled,
patched_rollout_engine,
rollout_engine_kwargs,
)
logger = logging.getLogger(__name__)
def install_reload_weights_skip(vllm_generation: Any) -> bool:
"""No-op vLLM's per-step ``reload_weights`` disk-reload on CUDA colocate.
TRL 1.9.1's colocate + sleep_mode generate path calls
``self.llm.collective_rpc("reload_weights")`` every step as a workaround
for vLLM issue #29341 (weights going stale after ``sleep``/``wake_up``).
On CUDA + vLLM 0.25.1 this disk reload leaks file/mmap handles: the
per-step "Loading safetensors checkpoint shards" duration grows
exponentially (~0.7s -> ~12s over ~30 steps around step 2900) and
hard-hangs after ~2900 sleep/wake cycles, which is fatal for the 5750-step
main/ablation runs (the stall is deterministic -- every retry replays the
same batch and re-trips the leak).
The reload is redundant here. ``sync_weights`` already pushes the merged
LoRA weights into vLLM every step via ``load_weights``
(``_push_param_to_vllm``), and ``wake_up(tags=["weights"])`` restores the
weight-memory mapping. That push+wake path is exactly what TRL falls back
to on backends that do not implement ``reload_weights`` (the
``except NotImplementedError`` branch in ``generate``), so skipping the
disk reload on CUDA is equivalent to that already-supported fallback and
keeps the rolled-out weights correct every step.
``collective_rpc`` is invoked exactly once in TRL's vLLM generation module
-- with ``"reload_weights"`` -- so narrowing the no-op to that method name
leaves every other engine RPC untouched. Returns whether the patch was
applied (the LLM object is absent in non-vLLM / server-mode arms).
"""
llm = getattr(vllm_generation, "llm", None)
if llm is None or not callable(getattr(llm, "collective_rpc", None)):
return False
original = llm.collective_rpc
def collective_rpc(method: str, *args: Any, **kwargs: Any) -> Any:
if method == "reload_weights":
return None
return original(method, *args, **kwargs)
try:
llm.collective_rpc = collective_rpc # type: ignore[method-assign]
except AttributeError:
logger.warning(
"vLLM LLM object rejects instance-level collective_rpc override "
"(__slots__); per-step reload_weights leak NOT patched."
)
return False
logger.info(
"Patched vLLM collective_rpc to skip per-step reload_weights "
"(vLLM #29341 workaround leaks on CUDA; sync_weights push suffices)."
)
return True
def realign_mm_token_type_ids(
input_ids: torch.Tensor,
mm_token_type_ids: torch.Tensor | None,
image_pad_token_id: int | None,
) -> torch.Tensor | None:
"""Rebuild ``mm_token_type_ids`` aligned to ``input_ids``.
Returns ``None`` when there is nothing to realign (no multimodal markers, or
the image-pad token id is unknown). Otherwise returns a new ``long`` tensor
the same shape as ``input_ids`` with ``1`` at every image-pad token position
and ``0`` elsewhere — aligned to the (left-padded) ``input_ids`` the model
sees, instead of the right-padded markers TRL's second processor call emits.
"""
if mm_token_type_ids is None or image_pad_token_id is None:
return mm_token_type_ids
realigned = torch.zeros_like(input_ids, dtype=torch.long)
realigned[input_ids == image_pad_token_id] = 1
return realigned
class AlignedGRPOTrainer(GRPOTrainer): # type: ignore[misc]
"""``GRPOTrainer`` with Qwen3.5-VL ``mm_token_type_ids`` realigned to ``input_ids``."""
def __init__(self, *args: Any, **kwargs: Any) -> None:
# Build the vLLM rollout engine with cuda-graphs off. vLLM V1 cuda-graph
# execution of the Qwen3.5-VL Gated-DeltaNet decode wedges mid-step
# (GPU 100%, CPU idle, SIGTERM ignored) about once per 600-900 steps,
# which forces the stall watchdog to SIGKILL and resume. The override
# must wrap super().__init__ because that is where TRL constructs the
# engine; see vllm_runtime for why cudagraph_mode beats enforce_eager
# and why this deliberately stays out of the frozen vllm_config.
engine_kwargs = rollout_engine_kwargs(os.environ)
with patched_rollout_engine(engine_kwargs) as patched:
if patched:
logger.info(
"vLLM rollout engine: cuda-graphs disabled "
"(compilation_config=%s) to avoid the V1 cuda-graph "
"generation deadlock; set %s=1 to restore upstream behaviour.",
engine_kwargs.get("compilation_config"),
CUDAGRAPH_ENV_VAR,
)
elif cudagraphs_enabled(os.environ):
logger.info(
"vLLM rollout engine: cuda-graphs left ENABLED by %s; "
"the V1 cuda-graph generation deadlock can recur "
"(~1 per 600-900 steps).",
CUDAGRAPH_ENV_VAR,
)
super().__init__(*args, **kwargs)
# Neutralize the per-step vLLM reload_weights disk-reload, which leaks
# on CUDA and hard-hangs long RL runs after ~2900 sleep/wake cycles.
# Applied after super().__init__ so ``self.vllm_generation`` exists; it
# is a per-rank instance, so every DDP worker patches its own vLLM.
vllm_generation = getattr(self, "vllm_generation", None)
if vllm_generation is not None:
install_reload_weights_skip(vllm_generation)
def _get_per_token_logps_and_entropies(
self,
model: Any,
input_ids: torch.Tensor,
attention_mask: torch.Tensor,
logits_to_keep: int,
batch_size: int | None = None,
compute_entropy: bool = False,
compute_aux_loss: bool = False,
pixel_values: torch.Tensor | None = None,
image_grid_thw: torch.Tensor | None = None,
num_images: list[int] | None = None,
pixel_attention_mask: torch.Tensor | None = None,
spatial_shapes: torch.Tensor | None = None,
num_tiles: list[int] | None = None,
image_sizes: torch.Tensor | None = None,
token_type_ids: torch.Tensor | None = None,
mm_token_type_ids: torch.Tensor | None = None,
image_position_ids: torch.Tensor | None = None,
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor | None]:
# Realign the multimodal token-type markers to the (left-padded)
# input_ids the model is about to see. TRL's non-tool VLM path builds
# mm_token_type_ids from a second, right-padded processor call, which
# misaligns from input_ids in heterogeneous-length batches and crashes
# Qwen3.5-VL's 3D-RoPE index construction. Rebuilding from the image-pad
# token positions in input_ids restores per-column alignment.
mm_token_type_ids = realign_mm_token_type_ids(
input_ids, mm_token_type_ids, getattr(self, "_image_pad_token_id", None)
)
return cast(
tuple[torch.Tensor, torch.Tensor, torch.Tensor | None],
super()._get_per_token_logps_and_entropies(
model,
input_ids,
attention_mask,
logits_to_keep,
batch_size=batch_size,
compute_entropy=compute_entropy,
compute_aux_loss=compute_aux_loss,
pixel_values=pixel_values,
image_grid_thw=image_grid_thw,
num_images=num_images,
pixel_attention_mask=pixel_attention_mask,
spatial_shapes=spatial_shapes,
num_tiles=num_tiles,
image_sizes=image_sizes,
token_type_ids=token_type_ids,
mm_token_type_ids=mm_token_type_ids,
image_position_ids=image_position_ids,
),
)
|