step_train/src/model/memory_lora.py

"""Memory LoRA_u module: create, load, save per-user LoRA adapters."""

import os
import re

from peft import LoraConfig, get_peft_model, PeftModel

from src.utils import load_yaml, setup_logger

logger = setup_logger(__name__)


def create_memory_lora(model, config_path: str = "configs/model/memory_lora.yaml"):
    """Create a new Memory LoRA adapter on the base model.

    Targets early-to-mid layers (0-23 out of 36) for knowledge memory.

    Args:
        model: Base model (Qwen3ForCausalLM).
        config_path: Path to memory LoRA config.

    Returns:
        PEFT model with LoRA adapter.
    """
    config = load_yaml(config_path)

    # Build layers_to_transform list (early-to-mid layers)
    num_target_layers = config.get("num_target_layers", 24)
    layers_to_transform = list(range(num_target_layers))

    lora_config = LoraConfig(
        r=config["lora_rank"],
        lora_alpha=config["lora_alpha"],
        lora_dropout=config["lora_dropout"],
        target_modules=config["target_modules"],
        layers_to_transform=layers_to_transform,
        bias="none",
        task_type="CAUSAL_LM",
    )

    peft_model = get_peft_model(model, lora_config)

    trainable_params = sum(p.numel() for p in peft_model.parameters() if p.requires_grad)
    total_params = sum(p.numel() for p in peft_model.parameters())
    logger.info(
        f"Memory LoRA created: {trainable_params:,} trainable / {total_params:,} total "
        f"({100 * trainable_params / total_params:.2f}%)"
    )
    logger.info(f"Target layers: 0-{num_target_layers - 1}, modules: {config['target_modules']}")

    return peft_model


def resolve_lora_path(user_dir: str, step: str = "latest") -> str:
    """Resolve the actual adapter path for a user.

    Args:
        user_dir: User's LoRA directory (e.g., checkpoints/memory_lora_longmem/user_001/).
        step: Which checkpoint to load:
            - "latest" or "final": root directory (final save after training)
            - "max": highest step_N checkpoint
            - integer string (e.g., "66"): specific step_66/ checkpoint

    Returns:
        Resolved path containing adapter_config.json.

    Raises:
        FileNotFoundError: if no valid adapter found.
    """
    # Try root directory first for "latest"/"final"
    root_adapter = os.path.join(user_dir, "adapter_config.json")
    if step in ("latest", "final"):
        if os.path.exists(root_adapter):
            return user_dir
        # Fallback: find max step checkpoint
        step = "max"

    # Find all step_N checkpoints
    step_dirs = []
    if os.path.isdir(user_dir):
        for name in os.listdir(user_dir):
            m = re.match(r"step_(\d+)$", name)
            if m:
                ckpt_path = os.path.join(user_dir, name)
                if os.path.exists(os.path.join(ckpt_path, "adapter_config.json")):
                    step_dirs.append((int(m.group(1)), ckpt_path))

    if not step_dirs:
        if os.path.exists(root_adapter):
            return user_dir
        raise FileNotFoundError(f"No adapter found in {user_dir}")

    step_dirs.sort(key=lambda x: x[0])

    if step == "max":
        return step_dirs[-1][1]

    # Specific step number
    target_step = int(step)
    for s, path in step_dirs:
        if s == target_step:
            return path

    raise FileNotFoundError(
        f"step_{target_step} not found in {user_dir}. "
        f"Available: {[s for s, _ in step_dirs]}"
    )


def load_memory_lora(base_model, adapter_path: str, step: str = "latest"):
    """Load a pre-trained Memory LoRA adapter.

    Args:
        base_model: Base model without adapter.
        adapter_path: User's LoRA directory (e.g., checkpoints/memory_lora_longmem/user_001/).
        step: Which checkpoint to load ("latest", "max", or specific step number).

    Returns:
        Model with loaded adapter.
    """
    resolved_path = resolve_lora_path(adapter_path, step=step)
    logger.info(f"Loading Memory LoRA from {resolved_path}")
    model = PeftModel.from_pretrained(base_model, resolved_path)
    return model


def save_memory_lora(peft_model, save_path: str):
    """Save only the LoRA adapter weights.

    Args:
        peft_model: PEFT model with adapter.
        save_path: Directory to save adapter.
    """
    logger.info(f"Saving Memory LoRA to {save_path}")
    peft_model.save_pretrained(save_path)