step_train/scripts_train/11b_eval_rag_baseline.py

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