freesolo-flash-dev 0.2.50__tar.gz → 0.2.55__tar.gz

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 0.2.50
+Version: 0.2.55
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/cli/training_doc.py

@@ -418,8 +418,18 @@ epochs = 1
 max_examples = 2
 lora_rank = 32
 # kl_penalty_coef = 1.0                                 # reverse-KL scale
+# opd_eos_loss_coef = 0.5                               # terminal-EOS reinforcement; raise if the
+#                                                       # student runs past the length cap without
+#                                                       # stopping, 0 to disable
 ```
 
+The cross-tokenizer reverse-KL is computed over shared decoded-text spans and so **cannot supervise
+the zero-width stop token** — distilling toward a verbose teacher (GLM-5.2) erodes the student's
+termination and rollouts run away to `max_completion_tokens`. `opd_eos_loss_coef` (default 0.5) adds a
+bounded, self-limiting behaviour-cloning term that reinstates the stop signal on rollouts that
+terminated naturally; watch `truncated_rollouts` fall and `mean_eos_logprob` rise in the run metrics.
+Warm-starting from an SFT adapter (which already encodes termination) compounds it.
+
 ---
 
 ## GRPO knobs that matter
@@ -472,6 +482,7 @@ targeted fix rather than leaning on the reward gate to slowly select against it.
 | Repetition / looping collapse | the same phrase repeats until truncation | repetition or length penalty; lower `temperature` |
 | Overthinking / verbose reasoning | reasoning eats the whole token budget | `thinking_length_penalty_coef`; tighten the prompt |
 | Completion truncation | answers cut off mid-thought | raise `max_completion_tokens` / `max_context_tokens` |
+| OPD rollouts never stop (high `truncated_rollouts`) | on-policy completions run to the length cap without an EOS; raising the cap barely helps | raise `opd_eos_loss_coef` and warm-start from SFT — the reverse-KL can't supervise the stop token on its own |
 | Unparsed / over-escaped output | reward can't read the answer | robust parser; return `0.0` on parse fail; format gate |
 | Wrapper / markdown around structured output | prose around the JSON/answer | a format gate; `stop_sequences` |
 | Uniform-reward groups | every rollout in a group scores the same → no gradient | shape the reward for partial credit; raise `temperature` |

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/multiturn_rollout.py

@@ -227,12 +227,12 @@ def rollout_one_records(
 
     - ``generate(prefix_ids, max_new)`` returns an OBJECT (opaque here) exposing ``completion_ids``
       (``list[int] | None``), ``completion_text`` (``str``), ``truncated`` (``bool``) and ``skip``
-      (``bool``) — OPD passes its ``_GenResult`` from ``_generate_one`` (termination/trim/U+FFFD gates
-      already applied), so the record drops straight into the existing teacher-scoring + gkd-loss path.
+      (``bool``) — OPD passes its ``_GenResult`` after termination/trim/U+FFFD gates have already been
+      applied, so the record drops straight into the existing teacher-scoring + batched-loss path.
     - Every turn (including a truncated/empty one) is recorded so the caller counts it; a
       truncated/skip turn ENDS the episode (a student that didn't terminate its turn, or emitted an
       empty/invalid completion, can't meaningfully continue — and its bad turn is skipped, not
-      distilled, by the caller's ``_resolve_sample``).
+      distilled, by the caller's no-loss sample handling).
     - ``on_turn_generated`` (optional) fires AFTER each turn's generation to refresh the worker stall
       clock and advance the sample counter — a many-turn episode is a long serial stretch of GPU
       generates + teacher-less env steps that would otherwise emit no progress ping.

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/recipe.py

@@ -70,6 +70,15 @@ class OPDConfig:
     # (student_logsum - teacher_logsum) advantage. 1.0 is plain reverse KL (Thinking Machines,
     # *On-Policy Distillation*). Overridable via [train].kl_penalty_coef.
     kl_coef: float = 1.0
+    # Weight of the terminal-EOS behaviour-cloning term added to the reverse-KL loss. The
+    # cross-tokenizer text-span alignment CANNOT supervise the stop token — a special/eos token is
+    # zero-width (decodes to nothing), so it lands in no alignment group and the reverse-KL gives it
+    # NO gradient. Distilling only the content tokens toward a strong, verbose teacher (GLM-5.2) then
+    # erodes the student's termination and rollouts run away to the length cap (observed across OPD
+    # runs as thousands of non-terminated rollouts). This adds a bounded, self-limiting cross-entropy
+    # that pushes up log P(eos) at the position a rollout naturally terminated, restoring the stop
+    # signal the alignment cannot express. 0 disables it; overridable via [train].opd_eos_loss_coef.
+    eos_loss_coef: float = 0.5
 
 
 @dataclass(frozen=True)

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/vram.py

@@ -110,6 +110,19 @@ def opd_rollout_concurrency(prompts_per_step: int = 1, group_size: int = 1) -> i
     return _positive_int(prompts_per_step, 1) * _positive_int(group_size, 1)
 
 
+def opd_loss_microbatch(params_b: float, prompts_per_step: int = 1, group_size: int = 1) -> int:
+    """Loss microbatch size used by OPD's dense-logit GKD backward.
+
+    Keep this in lockstep with worker.opd._opd_loss_microbatch_size without importing the worker from
+    the sizing path. Small/medium catalog models run up to four loss samples per forward; 35B-class
+    models stay serial for VRAM safety.
+    """
+    total = opd_rollout_concurrency(prompts_per_step, group_size)
+    params = float(params_b or 0.0)
+    default = 4 if params and params <= 10.0 else 1
+    return max(1, min(total, default))
+
+
 def _resident_kv_gb(
     params_b: float | None, vllm_max_len: int, num_generations: int = 8, fp8_kv: bool = False
 ) -> float:
@@ -366,11 +379,11 @@ def estimate_vram_gb(
         # OPD recipe default (thinking uses the longer max_completion_len_thinking). A GRPO-style
         # min(seq_len, 1024) fallback would UNDER-budget a thinking opd job (1536-token completions).
         completion = opd_completion_len(max_tokens, thinking)
-        # run_opd backprops ONE completion at a time (_train_one), so the activations + dense logits
-        # are SINGLE-sequence — NOT sft_per_device(batch_size). The batch-size activation term
-        # over-budgeted opd and bumped the GPU tier unnecessarily (reported by codex[bot]).
-        activations = _ACT_COEF * (seq_len / 1024.0) * width
-        # Dense-logit peak spans BOTH the forward and the loss BACKWARD (gkd_loss has no fused CE):
+        # run_opd backprops a small loss microbatch. Budget that actual dense-logit microbatch, not
+        # the full rollout/teacher batch and not a single sequence.
+        loss_mb = opd_loss_microbatch(params_b, batch_size, group_size)
+        activations = loss_mb * _ACT_COEF * (seq_len / 1024.0) * width
+        # Dense-logit peak spans BOTH the forward and the loss BACKWARD (OPD has no fused CE):
         #   - forward:  bf16 full-sequence logits [seq, vocab]        (seq * 2)
         #               fp32 completion rows [completion, vocab] for logsumexp, saved for backward
         #                                                             (completion * 4)
@@ -380,10 +393,10 @@ def estimate_vram_gb(
         #                                                             (seq * 2)
         # All four coexist at the backward peak. The old formula counted only the two FORWARD buffers,
         # so a long-completion / large-vocab (248k) opd job under-budgeted the loss backward by
-        # ~(completion*4 + seq*2)*vocab bytes and could route to a GPU that OOMs in gkd_loss.backward
+        # ~(completion*4 + seq*2)*vocab bytes and could route to a GPU that OOMs in OPD loss backward
         # (codex[bot]). Mirror the SFT dense-logit sizing by budgeting the backward buffers too.
-        logits_fwd = (seq_len * 2 + completion * 4) * vocab
-        logits_bwd = (seq_len * 2 + completion * 4) * vocab
+        logits_fwd = loss_mb * (seq_len * 2 + completion * 4) * vocab
+        logits_bwd = loss_mb * (seq_len * 2 + completion * 4) * vocab
         logits = (logits_fwd + logits_bwd) / 1e9
         return base + rollout + activations + logits
     # Actual TRL SFT keeps fused CE disabled (see worker/sft.py), so dense logits materialize even
@@ -577,6 +590,7 @@ def model_required_vram_gb(
         use_vllm: bool = True,
         vocab: int = _VOCAB_DEFAULT,
         active_params_b: float | None = None,
+        fp8_kv: bool = False,
     ) -> int:
         est = estimate_vram_gb(
             params_b,
@@ -591,10 +605,45 @@ def model_required_vram_gb(
             use_vllm=use_vllm,
             vocab=vocab,
             active_params_b=active_params_b,
+            fp8_kv=fp8_kv,
             sft_fused_ce=sft_fused_ce,
         )
         return math.ceil(est * headroom)
 
+    def _opd_fp8_adjust(
+        need: int,
+        params_b: float,
+        *,
+        quant: str = "bf16",
+        use_vllm: bool = True,
+        vocab: int = _VOCAB_DEFAULT,
+        active_params_b: float | None = None,
+    ) -> int:
+        """Re-size an OPD requirement with an fp8 KV cache once the run is provably modern-card-only.
+
+        The colocated OPD vLLM rollout engine reserves an fp8 KV cache on cc >= 8.9 hardware
+        (engine/worker/opd_vllm.py), but the estimate defaults to a bf16 KV pool. Any OPD run needing
+        more VRAM than the biggest non-fp8 validated card (the 80 GB A100) can ONLY land on a modern
+        (cc >= 8.9) card, so that bf16 pool is a phantom: it doubles the real KV and wrongly rejects
+        full-context / grouped OPD configs on the 35B that actually fit a B200. Halve it — but only
+        while the fp8-sized requirement still clears the non-fp8 ceiling, so the discount can never
+        pull the run back onto a card that would NOT use fp8 (which would then OOM)."""
+        from flash.providers.base import max_non_fp8_kv_vram_gb
+
+        ceiling = max_non_fp8_kv_vram_gb()
+        if need <= ceiling:
+            return need
+        fp8_need = _need(
+            params_b,
+            "opd",
+            quant=quant,
+            use_vllm=use_vllm,
+            vocab=vocab,
+            active_params_b=active_params_b,
+            fp8_kv=True,
+        )
+        return fp8_need if fp8_need > ceiling else need
+
     from flash.catalog import MODELS, vocab_size_for
 
     info = MODELS.get(model_id)
@@ -624,6 +673,15 @@ def model_required_vram_gb(
             vocab=model_vocab,
             active_params_b=active_b,
         )
+        if is_opd:
+            need = _opd_fp8_adjust(
+                need,
+                params_b or 4.0,
+                quant=quant,
+                use_vllm=use_vllm,
+                vocab=model_vocab,
+                active_params_b=active_b,
+            )
         floor = 0
         if is_grpo and getattr(info, "grpo_min_vram_gb", 0):
             floor = int(info.grpo_min_vram_gb)
@@ -689,6 +747,8 @@ def model_required_vram_gb(
     # open-model OPD uses its own dense-logit + colocated-vLLM estimator. The grpo-only sequence
     # escalation stays gated on is_grpo.
     need = _need(params_b, algorithm, vocab=model_vocab)
+    if is_opd:
+        need = _opd_fp8_adjust(need, params_b, vocab=model_vocab)
     if is_grpo:
         need += grpo_seq_escalation_gb(params_b, seq_len)
     if is_vllm_rollout:

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/worker/__init__.py

@@ -21,6 +21,7 @@ from flash.engine.worker.adapter import (
     _init_adapter_model,
     _resolve_adapter_ref,
     make_lora,
+    prepare_fresh_lora_base,
     recombined_warmstart_adapter_dir,
     require_vllm_for_rollout_func,
 )
@@ -87,7 +88,6 @@ from flash.engine.worker.lora import (
     is_vl_checkpoint,
     patch_grpo_mask_aware_lm_head,
     recombine_lora_adapters,
-    strip_language_model_infix,
 )
 from flash.engine.worker.opd import run_opd
 from flash.engine.worker.perf import (
@@ -447,6 +447,7 @@ __all__ = [
     "patch_grpo_mask_aware_lm_head",
     "patch_trl_colocate_llm_kwargs",
     "prefetch_model",
+    "prepare_fresh_lora_base",
     "prompt_opens_thinking",
     "publish_deployable_checkpoint",
     "recombine_lora_adapters",
@@ -460,7 +461,6 @@ __all__ = [
     "run_rl",
     "run_sft",
     "setup_perf_backends",
-    "strip_language_model_infix",
     "strip_think",
     "think_token_count",
     "thinking_text",

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/worker/adapter.py

@@ -12,6 +12,7 @@ from flash.engine.worker.lora import (
     assert_adapter_delta_nonzero,
     assert_adapter_load_clean,
     assert_lora_applied,
+    is_vl_checkpoint,
     recombine_lora_adapters,
     validate_recombined_lora_rank,
 )
@@ -20,7 +21,7 @@ from flash.engine.worker.perf import optimal_attn_impl
 
 def make_lora(model_id: str | None = None):
     """Build LoRA config targeting all linear layers (VL models included: the vision tower /
-    projector / MTP linears are adapted too; on text-only data they simply get no gradient)."""
+    projector / MTP linears are adapted too; on examples without images they simply get no gradient)."""
     from peft import LoraConfig
 
     targets = "all-linear"
@@ -43,6 +44,38 @@ def make_lora(model_id: str | None = None):
     return LoraConfig(**kwargs)
 
 
+def prepare_fresh_lora_base(
+    model_source: str,
+    model_id: str,
+    model_init_kwargs: dict,
+    *,
+    force: bool = False,
+    phase: str = "train",
+):
+    """Prepare the correct base object/path for fresh-LoRA training.
+
+    PEFT expands ``target_modules`` against the concrete model object it wraps. TRL's default string
+    loader can resolve Qwen VL checkpoints to a language-only tree, while OPD and serving use the full
+    image-text tree. Therefore every fresh LoRA on a VL checkpoint must preload
+    ``AutoModelForImageTextToText`` so SFT/GRPO/OPD adapter tensor sets stay identical, including
+    zero-gradient vision-tower LoRA tensors on examples without images. Non-VL checkpoints keep the original
+    model path for TRL's normal loader. ``force`` is used after a VL warm-start merge already proved
+    the source adapter is VL, so a transient config-probe failure cannot send the fresh stage back to
+    a language-only loader.
+    """
+    if not (force or is_vl_checkpoint(model_id)):
+        return model_source
+    from transformers import AutoModelForImageTextToText
+
+    print(
+        f"[{phase}] VL checkpoint: loading full multimodal model for fresh LoRA target parity "
+        f"({model_source})"
+    )
+    return AutoModelForImageTextToText.from_pretrained(
+        model_source, trust_remote_code=True, **model_init_kwargs
+    )
+
+
 def require_vllm_for_rollout_func(use_rollout_func: bool, use_vllm: bool, model_id: str) -> None:
     """Fail fast when multi-turn GRPO needs colocated vLLM but it's disabled."""
     if use_rollout_func and not use_vllm:
@@ -65,10 +98,10 @@ def _merge_vl_warmstart_adapter(adir: str, model_id: str, attn_kw: dict) -> str:
     """VL warm-start (#296): MERGE the SFT into the FULL multimodal base and save the merged model to a
     fresh temp dir — the new training base for a GRPO LoRA trained from scratch. Continuing the live SFT
     LoRA instead makes the colocated vLLM rollout AND KL reference run off the BARE base (the SFT only
-    reaches vLLM via a text<->VL weight-sync that round-trips poorly for ``*ForConditionalGeneration``
+    reaches vLLM via a language/VL weight-sync that round-trips poorly for ``*ForConditionalGeneration``
     models), so GRPO rolls out base-verbose and collapses a working SFT back to base (observed: every
     Qwen3.5 GRPO reverts; non-VL MiniCPM does not). Merging into the full multimodal model (NOT the
-    text-only tree) keeps the VL config + ``language_model.*`` keys that both the trainer reload and
+    language-only tree) keeps the VL config + ``language_model.*`` keys that both the trainer reload and
     vLLM's VL loader expect; the SFT keys match here WITHOUT the infix strip. Records the SFT dir for the
     finalize recombine and returns the merged dir."""
     import gc

{freesolo_flash_dev-0.2.50 → freesolo_flash_dev-0.2.55}/flash/engine/worker/lora.py

@@ -10,9 +10,9 @@ CPU-importable.
 from __future__ import annotations
 
 # Natively-multimodal model types (Qwen3.5/3.6). Their LoRA adapters adapt the FULL module
-# tree — vision tower / projector / MTP head included, like every other linear (on text-only
+# tree — vision tower / projector / MTP head included, like every other linear (on no-image
 # data those get no gradient, so their lora_B stays zero-init). The engine loads and serves
-# the whole VL model (vision tower included); there is no text-only / language_model_only path.
+# the whole VL model (vision tower included); there is no language-only VL adapter path.
 _VL_MODEL_TYPES = ("qwen3_5", "qwen3_5_moe", "qwen3_6")
 
 
@@ -171,36 +171,13 @@ def disable_liger_grpo_torch_compile(trainer) -> bool:
 # --------------------------------------------------------------------------------------------
 # Warm-start (init_from_adapter) SFT-adapter key namespace for VL checkpoints.
 #
-# SFT (run_sft) trains the FULL multimodal model: ``SFTTrainer(model=model_id,
-# peft_config=make_lora(...))`` loads ``Qwen3_5ForConditionalGeneration`` whose LM modules live
-# under ``language_model.``, so the SAVED adapter's keys are
-# ``base_model.model.model.language_model.layers.X...``. Warm-started GRPO (``_init_adapter_model``)
-# loads the base via ``AutoModelForCausalLM``; when that resolves to the TEXT-ONLY module tree its
-# LoRA targets are named ``base_model.model.model.layers.X...`` (no ``language_model.`` infix), so
-# the two adapters name the SAME modules differently. ``strip_language_model_infix`` lines them up
-# for the ``recombine_lora_adapters`` SFT⊕GRPO stacking (deploy-time), then the recombine re-emits
-# the serving ``language_model`` namespace. ``_LANGUAGE_MODEL_INFIX`` is also the signal
-# ``adapter_is_vl_warmstart`` reads to detect a VL warm-start adapter from its keys.
+# SFT/GRPO/OPD now force fresh LoRA training for VL checkpoints through the FULL multimodal model so
+# their module sets match exactly. ``_LANGUAGE_MODEL_INFIX`` is the signal
+# ``adapter_is_vl_warmstart`` reads to detect a full-VL warm-start adapter from its keys.
 
 _LANGUAGE_MODEL_INFIX = ".language_model."
 
 
-def strip_language_model_infix(key: str) -> str:
-    """Strip the FIRST ``.language_model.`` infix from a peft adapter weight key.
-
-    ``base_model.model.model.language_model.layers.0.linear_attn.out_proj.lora_A.default.weight``
-    -> ``base_model.model.model.layers.0.linear_attn.out_proj.lora_A.default.weight``.
-
-    Only the first occurrence is removed (the LM-vs-VL boundary appears once in the path); keys
-    without the infix are returned unchanged.
-    """
-    i = key.find(_LANGUAGE_MODEL_INFIX)
-    if i == -1:
-        return key
-    # Replace ".language_model." with "." (keep one separator dot).
-    return key[:i] + "." + key[i + len(_LANGUAGE_MODEL_INFIX) :]
-
-
 # Substrings that identify a peft LoRA weight key (vs a base-model param). The whole adapter file
 # is LoRA weights, but a wrong-arch / corrupt checkpoint can contain non-LoRA tensors, so we filter.
 _LORA_KEY_MARKERS = (".lora_A.", ".lora_B.", ".lora_embedding_A.", ".lora_embedding_B.", "lora_")
@@ -219,7 +196,7 @@ _MAX_SAFETENSORS_HEADER_BYTES = 100 * 1024 * 1024
 def _read_adapter_tensor_keys(adir: str) -> list[str] | None:
     """Tensor key names in the downloaded adapter.
 
-    For safetensors, read ONLY the JSON header (pure stdlib, no tensor data). For legacy PEFT
+    For safetensors, read ONLY the JSON header (pure stdlib, no tensor data). For PEFT
     ``adapter_model.bin``, use Torch's weights-only loader and inspect the state-dict keys. Returns
     ``None`` when no adapter weights exist in ``adir``.
     """
@@ -292,12 +269,12 @@ def adapter_is_vl_warmstart(adir: str, model_id: str) -> bool:
 
     Robust to a transient ``is_vl_checkpoint`` config-probe failure (it calls
     ``AutoConfig.from_pretrained`` and swallows EVERY exception to return False, so an HF
-    rate-limit / network hiccup / uncached config could silently route a genuine VL warm-start down
-    the text-only path and reintroduce the trainer<->vLLM mismatch — issue #286). An adapter that
-    actually carries ``.language_model.`` LoRA keys was saved against the full multimodal model and
+    rate-limit / network hiccup / uncached config could silently route a genuine VL warm-start away
+    from the full-VL merge path and reintroduce the trainer<->vLLM mismatch — issue #286). An adapter
+    that actually carries ``.language_model.`` LoRA keys was saved against the full multimodal model and
     IS a VL warm-start regardless of the probe (the adapter's own keys are the authoritative signal).
     Falls back to the config probe only when the adapter can't be read or carries no
-    ``.language_model.`` LoRA keys (already-text-only / non-VL)."""
+    ``.language_model.`` LoRA keys."""
     try:
         keys = _read_adapter_tensor_keys(adir)
         if keys and any(_LANGUAGE_MODEL_INFIX in k for k in keys if _is_lora_key(k)):
@@ -450,39 +427,6 @@ def recombine_lora_adapters(
     old_cfg, old_sd = _load(old_dir)
     new_cfg, new_sd = _load(new_dir)
 
-    # Normalize the ``.language_model.`` infix on BOTH adapters' keys before comparing/stacking.
-    # The VL merge warm-start (#296) trains the prior adapter against the FULL multimodal model, so the
-    # warm-start adapter's keys carry the infix (``base_model.model.model.language_model.layers...``),
-    # while a fresh LoRA saved by the text-only ``AutoModelForCausalLM`` trainer has no infix
-    # (``base_model.model.model.layers...``). Without this, the equivalent LM modules compare as
-    # DIFFERENT targets and the recombine wrongly aborts. The normalized form is only an INTERNAL math
-    # key: if either source adapter used the VL ``language_model`` namespace for a tensor, the
-    # recombined output uses that same serving-compatible key instead of the stripped text-only key.
-    def _normalize_infix(sd, which):
-        norm: dict = {}
-        infixed_keys: dict[str, str] = {}
-        for k, v in sd.items():
-            nk = strip_language_model_infix(k)
-            # Fail closed on ANY post-normalization collision. A malformed adapter carrying BOTH the
-            # infixed and the already-text-only form of a key would otherwise let the second write
-            # silently overwrite the first (the text-only key has nk == k, so a ``nk != k`` guard
-            # would skip it) — recombining whichever duplicate wins instead of rejecting the mix.
-            if nk in norm:
-                raise ValueError(
-                    f"recombine: {which} adapter key {k!r} collides with another after stripping "
-                    "the '.language_model.' infix — cannot normalize a mixed VL adapter"
-                )
-            norm[nk] = v
-            if _LANGUAGE_MODEL_INFIX in k:
-                infixed_keys[nk] = k
-        return norm, infixed_keys
-
-    old_sd, old_infixed_keys = _normalize_infix(old_sd, "warm-start")
-    new_sd, new_infixed_keys = _normalize_infix(new_sd, "fresh")
-
-    def _output_key(k: str) -> str:
-        return old_infixed_keys.get(k) or new_infixed_keys.get(k) or k
-
     for name, cfg in (("warm-start", old_cfg), ("fresh", new_cfg)):
         # peft_type defaults to LORA for older configs that omit it; anything else (e.g. ADALORA)
         # has different tensor/scale semantics the cat-recombine math doesn't model.
@@ -583,15 +527,8 @@ def recombine_lora_adapters(
                 f"recombine: lora_A key {ak!r} has no matching lora_B key {bk!r} — the adapter is "
                 "malformed (unpaired LoRA tensors)"
             )
-        out_ak = _output_key(ak)
-        out_bk = _output_key(bk)
-        if out_ak in out or out_bk in out:
-            raise ValueError(
-                "recombine: output key collision while restoring the '.language_model.' infix "
-                f"(A={out_ak!r}, B={out_bk!r})"
-            )
         # A: (r, in_features) — stacked along the rank axis (no scaling; scale lives on B).
-        out[out_ak] = torch.cat([old_sd[ak], new_sd[ak]], dim=0).contiguous()
+        out[ak] = torch.cat([old_sd[ak], new_sd[ak]], dim=0).contiguous()
         # B: (out_features, r) — bake each adapter's own scale, then stack along the rank axis. The
         # combined adapter carries unit scale, so the per-component scales survive intact.
         # Promote to the higher of the two input dtypes (don't force the warm-start's, which would
@@ -600,16 +537,7 @@ def recombine_lora_adapters(
         dt = torch.promote_types(old_sd[bk].dtype, new_sd[bk].dtype)
         b_old = old_sd[bk].to(torch.float32) * s_old
         b_new = new_sd[bk].to(torch.float32) * s_new
-        out[out_bk] = torch.cat([b_old, b_new], dim=1).to(dt).contiguous()
-
-    if old_infixed_keys or new_infixed_keys:
-        plain_layer_keys = sorted(k for k in out if k.startswith("base_model.model.model.layers."))
-        if plain_layer_keys:
-            raise ValueError(
-                "recombine: VL warm-start output would use plain model.layers LoRA keys "
-                f"(e.g. {plain_layer_keys[:3]}). Serving expects the language_model namespace; "
-                "refusing to write a known-bad deploy artifact."
-            )
+        out[bk] = torch.cat([b_old, b_new], dim=1).to(dt).contiguous()
 
     out_cfg = dict(new_cfg)
     out_cfg["r"] = r_out
@@ -619,7 +547,7 @@ def recombine_lora_adapters(
     out_cfg["alpha_pattern"] = {}
     # The fresh adapter was trained on the ephemeral warm-start-merged temp dir, so out_cfg (copied
     # from new_cfg) still names that temp path as base_model_name_or_path. Replace it with the real
-    # catalog base from the warm-start config; if that config carries none (e.g. an external/legacy
+    # catalog base from the warm-start config; if that config carries none (e.g. an external
     # adapter), DROP the field rather than ship a deployed config pointing at a now-deleted temp dir.
     old_base = old_cfg.get("base_model_name_or_path")
     if old_base: