step_train/scripts_train/eval_direct_ask.py

"""Direct-ask cartridge eval for the trainable-KV length ablation.

Pure "inject cartridge -> ask the user's OWN question -> greedy answer -> judge".
NO retrieval, NO MS/ACT decision pipeline, NO SFT LoRA. This isolates the question
"how much did the trainable-KV cartridge actually memorize?" from the rest of the
MetaMem machinery, so accuracy reflects ONLY the cartridge at a given KV length p.

One (dataset, p) cell per invocation; ALL outputs land under ISOLATED paths keyed by
(dataset, p) — see run_kvlen_cell.sh. Reuses the FIR-probing generation path and the
production gpt-4o-mini LLMJudge so the answer/judge口径 matches the rest of the repo.

Usage:
    python scripts/train/eval_direct_ask.py \
        --dataset       data/processed/longmemeval_s/dataset.json \
        --users-list    data/processed/longmemeval_s/splits/kvlen_sample200_seed42.json \
        --cartridge-dir checkpoints/kvlen/lmes/p256 \
        --output-path   data/eval/kvlen/lmes/p256/preds.jsonl \
        --judge-cache-path data/cache/kvlen/lmes/p256/llm_judge.jsonl \
        --model-path    /mnt/train-gui-agent/zhangzeyu/models/Qwen2.5-7B-Instruct

    # generation only (no API), then judge separately:
    python scripts/train/eval_direct_ask.py ... --no-judge --stage infer
    python scripts/train/eval_direct_ask.py ... --stage eval
"""

import argparse
import json
import os
import sys
from collections import defaultdict

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, save_json, set_seed, setup_logger

logger = setup_logger(__name__)

DEFAULT_MODEL_PATH = "/mnt/train-gui-agent/zhangzeyu/models/Qwen2.5-7B-Instruct"
DEFAULT_MAX_NEW_TOKENS = 256


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


# --------------------------------------------------------------------------------------
# Inference: inject cartridge, greedily answer the user's own questions
# --------------------------------------------------------------------------------------
def _generate_answer(model, tokenizer, cache, query, max_new_tokens):
    """Greedy (temp=0 -> argmax) answer with the cartridge as a CONSTANT KV prefix.

    Mirrors src/data_construction/fir_probing.py::_generate_samples_cartridge but
    single-sample at temperature 0 (deterministic). flex_generate already clears the
    transient per-token KV at the end; we clear again as belt-and-suspenders so no KV
    bleeds across queries.
    """
    import torch
    from cartridges.generation import flex_generate
    from src.data_construction.fir_probing import format_probe_prompt

    prompt = format_probe_prompt(query, tokenizer, mode="answer", enable_thinking=False)
    input_ids = tokenizer.encode(prompt, add_special_tokens=False)
    device = next(model.parameters()).device
    input_ids = torch.tensor(input_ids, device=device)
    seq_ids = torch.zeros_like(input_ids)
    position_ids = torch.arange(len(input_ids), device=device)

    out = flex_generate(
        model=model, tokenizer=tokenizer,
        input_ids=input_ids, seq_ids=seq_ids, position_ids=position_ids,
        cache=cache, max_new_tokens=max_new_tokens, temperature=0.0,  # GREEDY
    )  # Dict[seq_id, List[token_id]]
    cache.clear()
    tok_ids = list(out.values())[0] if out else []
    return tokenizer.decode(tok_ids, skip_special_tokens=True).strip()


def run_inference(cfg):
    import torch
    from transformers import AutoTokenizer
    from cartridges.cache import TrainableCache

    from src.cartridge.model_factory import get_flex_model_cls
    from src.evaluation.metrics.answer_metrics import judge_answer
    from src.utils.cartridge_utils import find_cartridge_path

    dataset = load_json(_r(cfg["dataset"]))
    user_ids = load_json(_r(cfg["users_list"]))
    cartridge_dir = _r(cfg["cartridge_dir"])
    out_path = _r(cfg["output_path"])
    max_new_tokens = cfg.get("max_new_tokens", DEFAULT_MAX_NEW_TOKENS)
    model_path = cfg.get("model_path", DEFAULT_MODEL_PATH)

    user_map = {ud["user_id"]: ud for ud in dataset}
    # Fail loud if the sampled users aren't in this dataset (wrong --dataset path).
    if sum(1 for u in user_ids if u in user_map) == 0:
        raise ValueError(
            f"None of the {len(user_ids)} sampled users exist in {cfg['dataset']}. "
            f"Wrong --dataset? (lmes -> longmemeval_s, metamem5k -> metamem_5k)"
        )

    # Resume: skip query_ids already written.
    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 generated")

    # Load model ONCE; swap the cartridge per user.
    # 🔴 device_map={"": 0} forces the WHOLE model onto a single GPU — do NOT use "auto".
    # The eval step runs with ALL 8 GPUs visible (unlike the per-GPU-pinned training
    # steps), so "auto" would shard the 7B across cuda:0..7, and the cartridge attention
    # path isn't model-parallel-safe (rotary cos/sin don't follow each layer's shard ->
    # "tensors on cuda:1 and cuda:6" crash in apply_rotary_pos_emb). A 7B in bf16 (~15GB)
    # fits on one card and serial greedy decode needs no sharding. The cartridge cache is
    # loaded with device="cuda" (current device = GPU 0), so model + cache + inputs all
    # land on the same device. Pin a specific GPU via CUDA_VISIBLE_DEVICES if GPU 0 is busy.
    model_cls = get_flex_model_cls(model_path)
    logger.info(f"Loading {model_cls.__name__} from {model_path} (single GPU)...")
    model = model_cls.from_pretrained(
        model_path, torch_dtype=torch.bfloat16, device_map={"": 0}
    )
    model.eval()
    tokenizer = AutoTokenizer.from_pretrained(model_path)

    os.makedirs(os.path.dirname(out_path), exist_ok=True)
    f = open(out_path, "a", encoding="utf-8")
    n_done = 0
    n_no_cart = 0
    n_stage1_only = 0
    for ui, uid in enumerate(user_ids):
        ud = user_map.get(uid)
        if ud is None:
            logger.warning(f"[{ui+1}/{len(user_ids)}] user {uid} not in dataset, skip")
            continue
        cpath = find_cartridge_path(cartridge_dir, uid)
        if cpath is None:
            n_no_cart += 1
            logger.warning(f"[{ui+1}/{len(user_ids)}] user {uid}: no cartridge, skip")
            continue
        # REFUSE Stage-1-only fallback: with --skip-probing there's no done.flag gate, so
        # find_cartridge_path may silently return the (weaker) ntp_recon_stage1 cartridge.
        # Evaluating that would mix Stage-1-only results into this p-cell's accuracy.
        # Require the Stage-2 CD warmstart cartridge; otherwise treat as "no cartridge".
        if "warmstart" not in os.path.basename(os.path.dirname(cpath)):
            n_stage1_only += 1
            logger.warning(
                f"[{ui+1}/{len(user_ids)}] user {uid}: only Stage-1 cartridge "
                f"({cpath}) — refusing fallback, skip (Stage-2 warmstart missing)"
            )
            continue

        cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
        for q in ud["queries"]:
            qid = q["id"]
            if qid in done_qids:
                continue
            ans = _generate_answer(model, tokenizer, cache, q["query"], max_new_tokens)
            em, _partial, f1 = judge_answer(ans, q["answer"], [q["answer"]])
            rec = {
                "query_id": qid, "user_id": uid,
                "query_type": q.get("query_type"),
                "oracle_ms": q.get("ms_label"),  # None for metamem_5k; present for lmes
                "act": "DIRECT",                 # required key for downstream aggregators
                "query_text": q["query"], "answer": ans, "gold": q["answer"],
                "answer_em": bool(em), "answer_f1": float(f1),
                "answer_judge": None,            # filled in the judge stage
                "cartridge_path": cpath,
            }
            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
            f.flush()
            n_done += 1
            if n_done % 50 == 0:
                logger.info(f"  generated {n_done} answers (user {ui+1}/{len(user_ids)})")
        # free per-user VRAM before next cartridge
        del cache
        torch.cuda.empty_cache()
    f.close()
    logger.info(
        f"Inference done: {n_done} new answers | {n_no_cart} users w/o cartridge | "
        f"{n_stage1_only} users Stage-1-only (skipped)"
    )
    return out_path


# --------------------------------------------------------------------------------------
# Judge: batched gpt-4o-mini verdicts (correct/partial/wrong)
# --------------------------------------------------------------------------------------
def run_judge(cfg):
    from src.evaluation.metrics.llm_judge import build_judge_from_cfg

    out_path = _r(cfg["output_path"])
    recs = []
    with open(out_path) as fh:
        for line in fh:
            line = line.strip()
            if line:
                recs.append(json.loads(line))

    if not cfg.get("no_judge", False):
        judge = build_judge_from_cfg(
            {"enabled": True, "model": cfg.get("judge_model", "gpt-4o-mini"),
             "cache_path": cfg["judge_cache_path"]},
            PROJECT_ROOT,
        )
        if judge is not None:
            logger.info(f"Judging {len(recs)} answers with {judge.model} (batched)...")
            items = [{"question": r["query_text"], "gold": r["gold"],
                      "answer": r["answer"], "qtype": r.get("query_type") or ""}
                     for r in recs]
            for r, (v, ok) in zip(recs, judge.judge_batch(items)):
                r["answer_judge"] = v if ok else None
            # rewrite jsonl atomically with verdicts filled in
            tmp = out_path + ".tmp"
            with open(tmp, "w", encoding="utf-8") as g:
                for r in recs:
                    g.write(json.dumps(r, ensure_ascii=False) + "\n")
            os.replace(tmp, out_path)

    stats = aggregate_direct(recs)
    stats_path = out_path.replace(".jsonl", ".stats.json")
    save_json(stats, stats_path)
    logger.info(f"Aggregated {len(recs)} records -> {stats_path}")
    print(json.dumps(stats, ensure_ascii=False, indent=2))
    return stats


def aggregate_direct(recs):
    """Bespoke aggregator — only the metrics that MEAN something for direct-ask.

    The stock src/evaluation/eval_metrics.aggregate() emits null/misleading retrieval +
    strategy fields here (every record is act="DIRECT", metamem_5k has no ms_label), so
    we report exactly: n / judge_acc / judge_correct_rate / em / f1, plus the same
    broken out by_query_type. verdict->numeric mapping matches eval_metrics._judge_num.
    """
    def jn(v):
        if isinstance(v, str):
            return {"correct": 1.0, "partial": 0.5, "wrong": 0.0}.get(v)
        if isinstance(v, bool):
            return 1.0 if v else 0.0
        return None

    def mean(xs):
        xs = [x for x in xs if x is not None]
        return round(sum(xs) / len(xs), 4) if xs else None

    jc = [1.0 if r.get("answer_judge") == "correct" else 0.0
          for r in recs if r.get("answer_judge") is not None]
    out = {
        "n": len(recs),
        "n_judged": len(jc),
        "judge_acc": mean([jn(r.get("answer_judge")) for r in recs]),
        "judge_correct_rate": round(sum(jc) / len(jc), 4) if jc else None,
        "em": mean([r["answer_em"] for r in recs]),
        "f1": mean([r["answer_f1"] for r in recs]),
    }
    by = defaultdict(list)
    for r in recs:
        by[r.get("query_type")].append(r)
    out["by_query_type"] = {
        str(qt): {
            "n": len(rs),
            "judge_acc": mean([jn(r.get("answer_judge")) for r in rs]),
            "em": mean([r["answer_em"] for r in rs]),
            "f1": mean([r["answer_f1"] for r in rs]),
        }
        for qt, rs in sorted(by.items(), key=lambda kv: str(kv[0]))
    }
    return out


def main():
    ap = argparse.ArgumentParser(description="Direct-ask cartridge eval (KV-length ablation)")
    ap.add_argument("--dataset", required=True, help="Path to dataset.json")
    ap.add_argument("--users-list", required=True, help="Seeded 200-user split JSON")
    ap.add_argument("--cartridge-dir", required=True, help="ISOLATED cartridge_root for this cell")
    ap.add_argument("--output-path", required=True, help="ISOLATED preds.jsonl for this cell")
    ap.add_argument("--judge-cache-path", required=True, help="ISOLATED judge cache for this cell")
    ap.add_argument("--model-path", default=DEFAULT_MODEL_PATH)
    ap.add_argument("--max-new-tokens", type=int, default=DEFAULT_MAX_NEW_TOKENS)
    ap.add_argument("--judge-model", default="gpt-4o-mini")
    ap.add_argument("--no-judge", action="store_true",
                    help="Skip the LLM judge (no API). EM/F1 + label dist still produced.")
    ap.add_argument("--stage", choices=["infer", "eval", "both"], default="both")
    ap.add_argument("--seed", type=int, default=42)
    args = ap.parse_args()

    set_seed(args.seed)
    cfg = {
        "dataset": args.dataset, "users_list": args.users_list,
        "cartridge_dir": args.cartridge_dir, "output_path": args.output_path,
        "judge_cache_path": args.judge_cache_path, "model_path": args.model_path,
        "max_new_tokens": args.max_new_tokens, "judge_model": args.judge_model,
        "no_judge": args.no_judge,
    }
    if args.stage in ("infer", "both"):
        run_inference(cfg)
    if args.stage in ("eval", "both"):
        run_judge(cfg)


if __name__ == "__main__":
    main()