step_train/scripts_train/11_eval.py

"""Step 11: Evaluate MetaMem on LongMemEval-S (same口径 as base_model_test BGE-M3 RAG).

Runs the full MetaMem pipeline GREEDILY (temp=0) via the SAME rollout machinery used
in RL (so budget/truncation/answer-length are byte-identical), then scores answers and
aggregates by FIR state / query_type. LongMemEval-S is evaluated ONCE (no-val).

For each query:
  - load user cartridge (find_cartridge_path on cartridge_dir)
  - build BGE-M3 user-turn-only index
  - greedy rollout → decision (MS/ACT/query) → retrieval (if non-DIRECT) → answer
  - score: EM / F1 / (optional gpt-4o-mini judge) / hallucination
  - record retrieval recall, ranks, cost

Requires GPU + FlagEmbedding (BGE-M3).

Usage:
    python scripts/train/11_eval.py --config configs/eval/eval.yaml
    python scripts/train/11_eval.py --lora-dir checkpoints/sft/Qwen3-8B --max-users 20
    python scripts/train/11_eval.py --stage eval   # only re-aggregate from existing jsonl
"""

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.evaluation.eval_metrics import aggregate
from src.evaluation.metrics.answer_metrics import gpt4o_mini_judge, judge_answer
from src.utils import load_json, load_yaml, save_json, 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 run_inference(cfg):
    import torch

    from src.model.capability_lora import load_capability_lora
    from src.model.metamem_model import load_metamem_base
    from src.retrieval.bge_m3_retriever import BGEM3Retriever, session_full_text
    from src.train.rl.parse import ANSWER_MAX_NEW_TOKENS
    from src.train.rl.reward import _has_hallucinated_personalization
    from src.train.rl.rollout import rollout_one
    from src.train.rl.trajectory import Anchor
    from src.utils.cartridge_utils import find_cartridge_path
    from cartridges.cache import TrainableCache

    dataset = load_json(_r(cfg["dataset"]))
    cartridge_dir = _r(cfg["cartridge_dir"])
    retriever = BGEM3Retriever(load_yaml(_r(cfg["retrieval_config"])))

    finetune_mode = cfg.get("finetune_mode", "lora")
    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,
        finetune_mode=finetune_mode,
    )
    lora_dir = _r(cfg["lora_dir"])
    if finetune_mode == "full":
        # lora_dir points at a full-model checkpoint dir (DAPO step / SFT output).
        from src.model.full_finetune import load_full_model
        if os.path.isdir(lora_dir) and any(f.endswith(".safetensors") for f in os.listdir(lora_dir)):
            load_full_model(mm.model, lora_dir)
            logger.info(f"Loaded eval full model from {lora_dir}")
        else:
            logger.warning(f"No full checkpoint at {lora_dir}; evaluating base+cartridge only")
    elif 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 eval LoRA from {lora_dir}")
    else:
        logger.warning(f"No LoRA at {lora_dir}; evaluating base+cartridge only")
    mm.set_adapter("policy")
    mm.model.eval()

    # LLM answer judge (same module/prompt as RL reward → 口径一致). Built from either the
    # `reward_judge` block (shared with dapo.yaml) or legacy use_judge flag.
    from src.evaluation.metrics.llm_judge import build_judge_from_cfg
    eval_judge = build_judge_from_cfg(cfg.get("reward_judge"), PROJECT_ROOT)
    if eval_judge is None and cfg.get("use_judge"):
        eval_judge = build_judge_from_cfg(
            {"enabled": True, "model": cfg.get("judge_model", "gpt-4o-mini"),
             "cache_path": cfg.get("judge_cache_path", "data/cache/llm_judge_eval.jsonl")},
            PROJECT_ROOT)
    if eval_judge is not None:
        logger.info(f"Eval LLM judge ENABLED: {eval_judge.model}")

    out_path = _r(cfg["output_path"])
    os.makedirs(os.path.dirname(out_path), exist_ok=True)

    # resume support
    done_qids = set()
    if os.path.exists(out_path):
        with open(out_path) as f:
            for line in f:
                line = line.strip()
                if line:
                    try:
                        done_qids.add(json.loads(line)["query_id"])
                    except Exception:
                        pass
        logger.info(f"Resuming: {len(done_qids)} queries already done")

    max_users = cfg.get("max_users")
    # 🔴 max_qa caps TOTAL queries evaluated (across users), independent of user count
    # (metamem ~2.57 QA/user, LME-S ~1 QA/user → "100 QA" ≠ "100 users"). Counts only
    # NEWLY-evaluated queries this run (resume-safe: already-done qids don't count).
    max_qa = cfg.get("max_qa")
    out_f = open(out_path, "a", encoding="utf-8")
    n_done = 0
    n_no_cart = 0
    for ui, ud in enumerate(dataset):
        if max_users and ui >= max_users:
            break
        if max_qa and n_done >= max_qa:
            break
        uid = ud["user_id"]
        cpath = find_cartridge_path(cartridge_dir, uid)
        if cpath is None:
            n_no_cart += 1
            continue
        cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
        mm.set_cartridge(cache)
        retriever.build_user_index(uid, ud["user_sessions"])
        sessions_by_id = {s["session_id"]: s for s in ud["user_sessions"]}
        dates_by_id = {s["session_id"]: s.get("timestamp", "") for s in ud["user_sessions"]}
        idx_by_id = {s["session_id"]: i for i, s in enumerate(ud["user_sessions"])}
        # full-session text (user+assistant) for hallucination grounding (NOT the
        # user-turns-only retrieval corpus口径).
        mem_texts = [session_full_text(s) for s in ud["user_sessions"]]

        for q in ud["queries"]:
            if max_qa and n_done >= max_qa:
                break
            qid = q["id"]
            if qid in done_qids:
                continue
            anchor = Anchor(
                user_id=uid, query=q["query"], gold_answer=q["answer"],
                gold_aliases=[q["answer"]], gold_evidence_ids=q.get("evidence_session_ids", []),
                oracle_label=q.get("ms_label") or "NA", cartridge_path=cpath,
                base_rank=-1, memory_bank_texts=mem_texts,
                question_date=(q.get("extra") or {}).get("question_date"),
            )
            mm.set_cartridge(cache)
            # 🔴 answer_max_new_tokens fixed to ANSWER_MAX_NEW_TOKENS (=800) so eval and
            # RL share the identical left-truncate budget (plan §4.3). Not from YAML.
            traj = rollout_one(
                mm, tok, anchor, retriever,
                temperature=cfg.get("temperature", 0.0),
                decision_temperature=cfg.get("temperature", 0.0),
                answer_max_new_tokens=ANSWER_MAX_NEW_TOKENS,
                sessions_by_id=sessions_by_id, dates_by_id=dates_by_id, idx_by_id=idx_by_id,
            )
            em, partial, f1 = judge_answer(traj.answer, q["answer"], [q["answer"]])
            judge = None
            if eval_judge is not None:
                # 🔴 SAME LLMJudge (same prompt, three-tier) as RL reward → 训练/评估口径一致。
                # store the raw verdict string (correct/partial/wrong) for downstream agg.
                v, ok = eval_judge.judge_one(q["query"], q["answer"], traj.answer,
                                             q.get("query_type", ""))
                judge = v if ok else None
            # hallucination check only meaningful for NM/VM non-DIRECT (matches reward
            # semantics in reward._has_hallucinated_personalization usage).
            hallu = (
                _has_hallucinated_personalization(traj.answer, mem_texts)
                if (q.get("ms_label") in ("NM", "VM") and traj.act != "DIRECT")
                else False
            )
            rec = {
                "query_id": qid, "user_id": uid,
                "query_type": q.get("query_type"),
                "oracle_ms": q.get("ms_label"),
                "pred_ms": traj.ms, "act": traj.act, "query_text": traj.query_text,
                "answer": traj.answer, "gold": q["answer"],
                "answer_em": bool(em), "answer_f1": float(f1), "answer_judge": judge,
                "retrieved": traj.retrieved, "gold_evidence_ids": q.get("evidence_session_ids", []),
                "new_rank": traj.new_rank, "retrieved_tokens": traj.retrieved_tokens,
                "retrieval_calls": traj.retrieval_calls,
                "gen_tokens": traj.gen_token_count,
                "hallucinated": bool(hallu), "format_valid": traj.format_valid,
            }
            out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
            out_f.flush()
            n_done += 1
            if n_done % 20 == 0:
                logger.info(f"  evaluated {n_done} queries (user {ui+1}/{len(dataset)})")
    out_f.close()
    logger.info(f"Inference done: {n_done} new queries, {n_no_cart} users without cartridge")
    return out_path


def run_aggregate(cfg):
    out_path = _r(cfg["output_path"])
    records = []
    with open(out_path) as f:
        for line in f:
            line = line.strip()
            if line:
                records.append(json.loads(line))
    stats = aggregate(records, k=cfg.get("top_k", 10))
    stats_path = out_path.replace(".jsonl", ".stats.json")
    save_json(stats, stats_path)
    logger.info(f"Aggregated {len(records)} records → {stats_path}")
    print(json.dumps(stats, ensure_ascii=False, indent=2))
    return stats


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--config", default="configs/eval/eval.yaml")
    ap.add_argument("--lora-dir", default=None)
    ap.add_argument("--cartridge-dir", default=None)
    ap.add_argument("--output-path", default=None)
    ap.add_argument("--max-users", type=int, default=None)
    ap.add_argument("--max-qa", type=int, default=None,
                    help="Cap TOTAL queries evaluated across users (e.g. 100 QA). "
                         "Independent of --max-users.")
    ap.add_argument("--dataset", default=None, help="Override dataset path from config.")
    ap.add_argument("--no-judge", action="store_true",
                    help="Disable the LLM judge (no API needed). pred_ms/act label "
                         "distribution + EM/F1 are still produced; judge_acc is null.")
    ap.add_argument("--stage", choices=["infer", "eval", "both"], default="both")
    args = ap.parse_args()

    cfg = load_yaml(args.config if os.path.isabs(args.config) else os.path.join(PROJECT_ROOT, args.config))
    if args.lora_dir:
        cfg["lora_dir"] = args.lora_dir
    if args.cartridge_dir:
        cfg["cartridge_dir"] = args.cartridge_dir
    if args.output_path:
        cfg["output_path"] = args.output_path
    if args.dataset:
        cfg["dataset"] = args.dataset
    if args.max_users is not None:
        cfg["max_users"] = args.max_users
    if args.max_qa is not None:
        cfg["max_qa"] = args.max_qa
    if args.no_judge:
        # drop both judge configs → build_judge_from_cfg returns None → EM/F1 + label
        # distribution only, no API calls.
        cfg["reward_judge"] = {"enabled": False}
        cfg["use_judge"] = False
    set_seed(cfg.get("seed", 42))

    if args.stage in ("infer", "both"):
        run_inference(cfg)
    if args.stage in ("eval", "both"):
        run_aggregate(cfg)


if __name__ == "__main__":
    main()