step_train/src/model/capability_lora.py

"""Shared Capability LoRA_cap: inject / freeze / save / load.

🔴 Architecture fix (verified): get_peft_model(FlexQwen3...) CRASHES — PEFT's
PeftModelForCausalLM.forward unconditionally injects attention_mask=None /
output_attentions=None / output_hidden_states=None, which FlexQwen3.forward does
not accept → TypeError. So we use peft.inject_adapter_in_model(LoraConfig, model)
to add LoRA layers IN PLACE and keep FlexQwen3's native forward. Calls go through
MetaMemModel (src/model/metamem_model.py) with the native kwargs.

We restrict LoRA to mid/late attention layers via LoraConfig.layers_to_transform +
layers_pattern="layers" (module path is model.layers.{i}.self_attn.{q,k,v,o}_proj).
"""

import os
import re
from typing import List

import torch
from peft import LoraConfig, inject_adapter_in_model
from peft.tuners.tuners_utils import BaseTunerLayer
from safetensors.torch import load_file as safe_load_file
from safetensors.torch import save_file as safe_save_file

from src.utils import load_yaml, setup_logger

logger = setup_logger(__name__)

_LORA_WEIGHTS_NAME = "capability_lora.safetensors"


def build_lora_config(cfg: dict) -> LoraConfig:
    """Construct a LoraConfig from the capability_lora.yaml dict."""
    start = cfg.get("layers_to_transform_start")
    end = cfg.get("layers_to_transform_end")
    layers_to_transform = None
    layers_pattern = None
    if start is not None and end is not None:
        layers_to_transform = list(range(start, end + 1))
        layers_pattern = "layers"
    return LoraConfig(
        r=cfg["lora_rank"],
        lora_alpha=cfg["lora_alpha"],
        lora_dropout=cfg.get("lora_dropout", 0.05),
        target_modules=cfg["target_modules"],
        layers_to_transform=layers_to_transform,
        layers_pattern=layers_pattern,
        bias=cfg.get("bias", "none"),
        task_type=cfg.get("task_type", "CAUSAL_LM"),
    )


def attach_capability_lora(model, cfg: dict, adapter_name: str = "policy"):
    """Inject a LoRA adapter in place (does NOT wrap the model).

    Returns the same model object (mutated). Supports calling twice with different
    adapter_name to add a second adapter (RL policy + ref).
    """
    lora_cfg = build_lora_config(cfg)
    inject_adapter_in_model(lora_cfg, model, adapter_name=adapter_name)
    n_lora = sum(1 for n, _ in model.named_parameters() if "lora_" in n and adapter_name in n)
    logger.info(f"Injected LoRA adapter '{adapter_name}': {n_lora} lora param tensors")

    # 🔴 Fail loud on layer-range mismatch. PEFT silently drops out-of-range
    # layers_to_transform indices (no error) — e.g. a 12-35 config on a 28-layer
    # model injects only 12-27. Validate the REALIZED injection against the request
    # so such a config crashes here instead of training a half-empty LoRA.
    start = cfg.get("layers_to_transform_start")
    end = cfg.get("layers_to_transform_end")
    if start is not None and end is not None:
        want = set(range(start, end + 1))
        got = set()
        for n, _ in model.named_parameters():
            if "lora_" in n and adapter_name in n:
                m = re.search(r"\.layers\.(\d+)\.", n)
                if m:
                    got.add(int(m.group(1)))
        if got != want:
            raise ValueError(
                f"Capability LoRA layer mismatch for adapter '{adapter_name}': requested "
                f"layers {sorted(want)} but injected {sorted(got)}. Out-of-range layers "
                f"are silently dropped by PEFT — check layers_to_transform_start/end "
                f"({start}/{end}) against the model's num_hidden_layers."
            )
    return model


def iter_lora_layers(model):
    """Yield every PEFT tuner layer (modules that hold lora_A/lora_B)."""
    for module in model.modules():
        if isinstance(module, BaseTunerLayer):
            yield module


def set_active_adapter(model, adapter_name: str, inference_mode: bool = True):
    """Switch the active adapter on all tuner layers (for policy/ref swapping).

    🔴 PEFT's BaseTunerLayer.set_adapter(names, inference_mode) has a grad side-effect:
    inference_mode=False sets the named adapter requires_grad=True and others False;
    inference_mode=True sets ALL adapters requires_grad=False. There is no value that
    leaves requires_grad untouched. We therefore default inference_mode=True (pure
    activation switch, freezes everything) and let the CALLER re-establish the canonical
    grad state via set_capability_trainable afterwards (MetaMemModel.set_adapter does
    this automatically). This keeps "switch active adapter" and "which adapter trains"
    cleanly separated.
    """
    for layer in iter_lora_layers(model):
        try:
            layer.set_adapter(adapter_name, inference_mode=inference_mode)
        except TypeError:
            # older PEFT without the kwarg
            layer.set_adapter(adapter_name)


def set_capability_trainable(model, adapter_name: str = "policy"):
    """Freeze base + embedding + lm_head; train ONLY the named LoRA adapter.

    Pseudo-token route: embedding/lm_head are NOT trained (vocab untouched).
    """
    for name, param in model.named_parameters():
        if "lora_" in name and f".{adapter_name}." in f".{name}.":
            param.requires_grad = True
        elif "lora_" in name:
            # other adapter (e.g. ref) — keep frozen
            param.requires_grad = False
        else:
            param.requires_grad = False
    n_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    logger.info(f"Trainable params (adapter '{adapter_name}'): {n_trainable:,}")
    return model


def _adapter_state_dict(model, adapter_name: str) -> dict:
    """Collect LoRA weight tensors for one adapter."""
    state = {}
    for name, param in model.named_parameters():
        if "lora_" in name and f".{adapter_name}." in name:
            state[name] = param.detach().cpu()
    return state


def save_capability_lora(model, out_dir: str, adapter_name: str = "policy"):
    """Save ONLY the LoRA weights of one adapter (no embedding/tokenizer)."""
    os.makedirs(out_dir, exist_ok=True)
    state = _adapter_state_dict(model, adapter_name)
    if not state:
        raise RuntimeError(f"No LoRA params found for adapter '{adapter_name}'")
    safe_save_file(state, os.path.join(out_dir, _LORA_WEIGHTS_NAME))
    logger.info(f"Saved {len(state)} LoRA tensors for '{adapter_name}' to {out_dir}")


def load_capability_lora(model, in_dir: str, adapter_name: str = "policy", strict: bool = False):
    """Load LoRA weights for one adapter from a saved capability_lora dir.

    The saved keys include the adapter_name they were saved under; if loading into a
    different adapter_name, we remap the adapter segment in the key.
    """
    path = os.path.join(in_dir, _LORA_WEIGHTS_NAME)
    saved = safe_load_file(path)
    own = dict(model.named_parameters())

    # Detect the adapter name embedded in saved keys (e.g. ".policy.")
    saved_adapter = None
    for k in saved:
        for cand in (".policy.", ".ref.", ".default."):
            if cand in k:
                saved_adapter = cand.strip(".")
                break
        if saved_adapter:
            break

    loaded = 0
    with torch.no_grad():
        for k, v in saved.items():
            tgt_key = k
            if saved_adapter and saved_adapter != adapter_name:
                tgt_key = k.replace(f".{saved_adapter}.", f".{adapter_name}.")
            if tgt_key in own:
                own[tgt_key].copy_(v.to(own[tgt_key].device, own[tgt_key].dtype))
                loaded += 1
            elif strict:
                raise KeyError(f"LoRA key not found in model: {tgt_key}")
    logger.info(f"Loaded {loaded}/{len(saved)} LoRA tensors into adapter '{adapter_name}' from {in_dir}")
    return model


def load_capability_lora_config(config_path: str = "configs/model/capability_lora.yaml") -> dict:
    return load_yaml(config_path)