step_train/scripts_train/probe_forced_direct.py

"""Oracle-forced DIRECT probe (诊断: 模型"会找不会答" vs "策略坍缩").

Bypasses the decision stage entirely. For each LME-S query, feeds ONLY the cartridge
(no retrieval, no RAG block) + the answer cue, and generates an answer greedily. This is
the pure DIRECT path: "can the model read its own memory and answer directly?".

Compares against the already-run eval (data/eval/metamem_longmemeval_s.jsonl, which is
the model's OWN decision → ~100% RETRIEVE). Optionally also runs a NO-cartridge baseline
to isolate how much the cartridge contributes.

Verdict:
  - forced-DIRECT 答对率 高  → 模型 CAN answer directly → 当前全 RETRIEVE 是策略坍缩(RL 可救)
  - forced-DIRECT 答对率 低  → 能力/记忆读取问题 → DAPO 调参救不了,回 SFT/cartridge

Usage:
    python scripts/train/probe_forced_direct.py --max-users 80
    python scripts/train/probe_forced_direct.py --max-users 80 --no-cartridge   # ablation
"""

import argparse
import json
import os
import sys

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
os.environ.setdefault("CARTRIDGES_DIR", os.path.join(PROJECT_ROOT, "cartridges-lib"))
os.environ.setdefault("CARTRIDGES_OUTPUT_DIR", os.path.join(PROJECT_ROOT, "checkpoints/cartridge"))

from src.utils import load_json, load_yaml, set_seed, setup_logger

logger = setup_logger(__name__)


def _r(p):
    return p if os.path.isabs(p) else os.path.join(PROJECT_ROOT, p)


def main():
    import torch
    from cartridges.cache import TrainableCache
    from cartridges.generation import flex_generate

    from src.model.capability_lora import load_capability_lora
    from src.model.metamem_model import load_metamem_base
    from src.model.prompts import build_answer_suffix
    from src.model.tokenizer_utils import clean_answer_text
    from src.train.rl.parse import ANSWER_MAX_NEW_TOKENS, MODEL_MAX, left_truncate_ids
    from src.evaluation.metrics.answer_metrics import judge_answer, normalize
    from src.utils.cartridge_utils import find_cartridge_path

    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/eval/eval.yaml")
    ap.add_argument("--lora-dir", default="checkpoints/dapo/Qwen3-8B/final")
    ap.add_argument("--max-users", type=int, default=80)
    ap.add_argument("--no-cartridge", action="store_true",
                    help="ablation: do NOT load cartridge (isolate memory contribution)")
    ap.add_argument("--out", default="data/eval/probe_forced_direct.jsonl")
    args = ap.parse_args()

    cfg = load_yaml(_r(args.config))
    set_seed(42)

    mm, tok = load_metamem_base(
        base_cfg_path=_r(cfg["base_model_config"]),
        lora_cfg_path=_r(cfg["lora_config"]),
        project_root=PROJECT_ROOT,
        adapter_names=("policy",),
        set_trainable=None,
    )
    lora_dir = _r(args.lora_dir)
    if os.path.exists(os.path.join(lora_dir, "capability_lora.safetensors")):
        load_capability_lora(mm.model, lora_dir, adapter_name="policy")
        logger.info(f"Loaded LoRA from {lora_dir}")
    mm.set_adapter("policy")
    mm.model.eval()

    dataset = load_json(_r(cfg["dataset"]))
    cartridge_dir = _r(cfg["cartridge_dir"])
    out_path = _r(args.out)
    os.makedirs(os.path.dirname(out_path), exist_ok=True)
    out_f = open(out_path, "w", encoding="utf-8")

    device = mm.device
    n_done = 0
    for ui, ud in enumerate(dataset):
        if ui >= args.max_users:
            break
        uid = ud["user_id"]
        cpath = find_cartridge_path(cartridge_dir, uid)
        if cpath is None:
            continue
        if args.no_cartridge:
            mm.set_cartridge(None)
        else:
            cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
            mm.set_cartridge(cache)

        for q in ud["queries"]:
            qdate = (q.get("extra") or {}).get("question_date")
            # 🔴 pure DIRECT: NO decision prompt, NO retrieval block. Just the answer cue,
            # conditioned only on the cartridge KV-prefix (the user's parametric memory).
            suffix = build_answer_suffix(query=q["query"], question_date=qdate)
            full_ids = tok.encode(suffix, add_special_tokens=False)
            if len(full_ids) > MODEL_MAX - ANSWER_MAX_NEW_TOKENS:
                full_ids, _ = left_truncate_ids(full_ids, [False] * len(full_ids),
                                                MODEL_MAX - ANSWER_MAX_NEW_TOKENS)
            if args.no_cartridge:
                mm.set_cartridge(None)
            else:
                mm.set_cartridge(cache)
            input_ids = torch.tensor(full_ids, dtype=torch.long, device=device)
            seq_ids = torch.zeros_like(input_ids)
            position_ids = torch.arange(len(input_ids), device=device)
            gen = flex_generate(
                model=mm.model, tokenizer=tok, input_ids=input_ids,
                seq_ids=seq_ids, position_ids=position_ids, cache=mm.cache,
                max_new_tokens=ANSWER_MAX_NEW_TOKENS, temperature=0.0,
            )
            ans_ids = list(gen.values())[0] if gen else []
            answer = clean_answer_text(tok.decode(ans_ids, skip_special_tokens=True))
            em, partial, f1 = judge_answer(answer, q["answer"], [q["answer"]])
            g = normalize(str(q["answer"]))
            soft = bool(g) and g in normalize(answer)
            rec = {
                "query_id": q["id"], "user_id": uid,
                "query_type": q.get("query_type"), "oracle_ms": q.get("ms_label"),
                "answer": answer, "gold": q["answer"],
                "answer_em": bool(em), "answer_f1": float(f1), "soft_hit": soft,
                "gen_tokens": len(ans_ids),
            }
            out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
            out_f.flush()
            n_done += 1
            if n_done % 20 == 0:
                logger.info(f"...{n_done} done")

    out_f.close()
    logger.info(f"Probe done: {n_done} queries → {out_path}")


if __name__ == "__main__":
    main()