"""Step 11b: PURE RAG baseline eval — NO cartridge, NO Capability LoRA, NO MS/ACT decision. 对照实验:衡量「我们的方法整体(参数记忆 cartridge + 元认知决策/改写)」相对「纯外部检索」的差距。 本脚本是后者:原始 base 模型(Qwen2.5-7B-Instruct,无 cartridge、无 LoRA)永远用【原问题】 检索 top-k,把检索到的 session 拼进 prompt 直接作答。 🔴 与 scripts/train/11_eval.py 逐 bit 同口径,仅有的区别是: - 模型 = 纯 base(finetune_mode=full + freeze_all,既不注入 LoRA 也不挂 cartridge) - 检索 query 永远是 anchor.query(原问题),没有 MS/ACT 决策、没有 query 改写、不会 DIRECT 其余完全复用同一套: - 同一个 BGEM3Retriever(user-turn-only 索引、同 top_k) - 同一组 prompt 拼接函数(format_session_block / build_rag_block / build_answer_suffix) - 同一检索预算 MAX_RETRIEVAL_TOKENS(=30200) + 同 ANSWER_MAX_NEW_TOKENS(=800) + 同 MODEL_MAX 截断 - 同一个 flex_generate(greedy temp=0) - 同一个 LLMJudge(gpt-4o-mini 三档) + 同一个 aggregate() + 同样的 hallucination 口径 - 同样的 resume / max_users / max_qa / record schema → 产出可直接喂 analyze_eval_lmes_full.py 每条 RAG 记录的 act 固定写 "RETRIEVE"、pred_ms 写 None(无决策),这样 aggregate 的 recall/MRR/ cost 都照常计算,且与 MetaMem 的记录 schema 完全一致,可并排对比。 Requires GPU + FlagEmbedding (BGE-M3). Usage: python scripts/train/11b_eval_rag_baseline.py --config configs/eval/eval_lmes_full_rag_baseline.yaml """ 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 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 _gen_answer(mm, tokenizer, prefix_ids, max_new_tokens, temperature): """Re-feed the full prefix and greedily generate the answer (base model, cache=None → flex_generate self-builds an empty TrainableCache, i.e. NO cartridge prefix).""" import torch from cartridges.generation import flex_generate device = mm.device input_ids = torch.tensor(prefix_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=tokenizer, input_ids=input_ids, seq_ids=seq_ids, position_ids=position_ids, cache=None, # 🔴 no cartridge max_new_tokens=max_new_tokens, temperature=temperature, ) return list(gen.values())[0] if gen else [] def run_inference(cfg): from src.model.metamem_model import load_metamem_base from src.model.prompts import build_answer_suffix, build_rag_block, format_session_block from src.model.tokenizer_utils import clean_answer_text from src.retrieval.bge_m3_retriever import BGEM3Retriever, session_full_text from src.train.rl.parse import (ANSWER_MAX_NEW_TOKENS, MAX_RETRIEVAL_TOKENS, MODEL_MAX, crop_retrieval_text, left_truncate_ids) from src.train.rl.reward import _has_hallucinated_personalization dataset = load_json(_r(cfg["dataset"])) retriever = BGEM3Retriever(load_yaml(_r(cfg["retrieval_config"]))) # 🔴 PURE base model: finetune_mode="full" + set_trainable=None → freeze_all, NO PEFT # adapter injected, NO cartridge ever set. This is the original Qwen2.5-7B-Instruct. 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=(), set_trainable=None, finetune_mode="full", ) mm.model.eval() logger.info("Loaded PURE base model (no cartridge, no capability LoRA) for RAG baseline") 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 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) 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 = cfg.get("max_qa") top_k = retriever.default_top_k out_f = open(out_path, "a", encoding="utf-8") n_done = 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"] 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"])} 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 query = q["query"] question_date = (q.get("extra") or {}).get("question_date") # --- retrieval with the ORIGINAL query (no rewrite, no decision) --- results = retriever.search(uid, query, top_k=top_k) retrieved_ids = [rid for rid, _ in results] new_rank = retriever.get_rank(uid, query, set(q.get("evidence_session_ids", [])), window=top_k) # --- build the SAME RAG prompt (sessions ordered by original index) --- ordered = sorted(retrieved_ids, key=lambda rid: idx_by_id.get(rid, 1 << 30)) blocks = [] for rank, rid in enumerate(ordered): sess = sessions_by_id.get(rid) if sess is None: continue date = dates_by_id.get(rid, sess.get("timestamp", "")) blocks.append(format_session_block(date, sess.get("turns", []), rank)) history = crop_retrieval_text("".join(blocks), MAX_RETRIEVAL_TOKENS) rag_block = build_rag_block([history]) if history else build_rag_block([]) suffix = build_answer_suffix(query=query, question_date=question_date) # prefix = [RETRIEVED]block + answer cue ([ANS] marker). No decision prompt. prefix_ids = tok.encode(rag_block + suffix, add_special_tokens=False) retrieved_tokens = len(tok.encode(rag_block, add_special_tokens=False)) # pre-answer length guard (same cap as rollout: budget + headroom) pre_answer_cap = min(MODEL_MAX - ANSWER_MAX_NEW_TOKENS, MAX_RETRIEVAL_TOKENS + 2048) if len(prefix_ids) > pre_answer_cap: # left-truncate the prefix ids (drop oldest retrieved content first) prefix_ids, _ = left_truncate_ids(prefix_ids, [False] * len(prefix_ids), pre_answer_cap) ans_ids = _gen_answer(mm, tok, prefix_ids, ANSWER_MAX_NEW_TOKENS, cfg.get("temperature", 0.0)) answer = clean_answer_text(tok.decode(ans_ids, skip_special_tokens=True)) em, partial, f1 = judge_answer(answer, q["answer"], [q["answer"]]) judge = None if eval_judge is not None: v, ok = eval_judge.judge_one(query, q["answer"], answer, q.get("query_type", "")) judge = v if ok else None # RAG always retrieves → hallucination check applies (matches reward semantics # for non-DIRECT). oracle_ms unknown here → gate only on act != DIRECT. hallu = _has_hallucinated_personalization(answer, mem_texts) rec = { "query_id": qid, "user_id": uid, "query_type": q.get("query_type"), "oracle_ms": q.get("ms_label"), # None on LME-S; backfilled by analyzer if available "pred_ms": None, "act": "RETRIEVE", "query_text": query, "answer": answer, "gold": q["answer"], "answer_em": bool(em), "answer_f1": float(f1), "answer_judge": judge, "retrieved": retrieved_ids, "gold_evidence_ids": q.get("evidence_session_ids", []), "new_rank": new_rank, "retrieved_tokens": retrieved_tokens, "retrieval_calls": 1, "gen_tokens": len(ans_ids), "hallucinated": bool(hallu), "format_valid": True, } 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"RAG baseline inference done: {n_done} new queries") 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_lmes_full_rag_baseline.yaml") ap.add_argument("--output-path", default=None) ap.add_argument("--dataset", default=None) ap.add_argument("--max-users", type=int, default=None) ap.add_argument("--max-qa", type=int, default=None) ap.add_argument("--no-judge", action="store_true") 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.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: 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()