"""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()