step_train/scripts_train/debug_interaction.py

"""Debug一次完整交互:加载某用户 cartridge + Capability LoRA,喂一个 query,把
rollout 内部每一段(决策 prompt / 决策原始输出 / 解析 MS·ACT·query / 检索结果 /
拼进去的 RAG block / 答案段输入 / 答案输出)逐段打印出来,用来肉眼检查交互流程是否正确。

不算指标,只 dump 完整对话链路。

用法:
  python scripts/train/debug_interaction.py --dataset data/processed/longmemeval_s/dataset.json \
      --cartridge-dir checkpoints/cartridge_longmem/Qwen3-8B \
      --lora-dir checkpoints/sft/Qwen3-8B \
      --user-id e47becba          # 不给则取第一个用户
      [--query "..."]             # 不给则用该用户第一个 query
"""

import argparse
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"))

import torch

from src.model.capability_lora import load_capability_lora
from src.model.metamem_model import load_metamem_base
from src.model.prompts import (
    build_answer_suffix, build_rag_block, format_decision_prompt, format_session_block,
)
from src.model.tokenizer_utils import extract_control_strings, find_marker_token_span
from src.retrieval.bge_m3_retriever import BGEM3Retriever, session_full_text
from src.train.rl.parse import (
    ANSWER_MAX_NEW_TOKENS, DECISION_MAX_NEW_TOKENS, MAX_RETRIEVAL_TOKENS, MODEL_MAX,
    crop_retrieval_text, left_truncate_ids,
)
from src.utils import load_json, load_yaml, set_seed
from src.utils.cartridge_utils import find_cartridge_path
from src.utils.special_tokens import EOQ_TOKEN
from cartridges.cache import TrainableCache
from cartridges.generation import flex_generate

SEP = "=" * 100


def hr(title):
    print(f"\n{SEP}\n### {title}\n{SEP}")


def gen_segment(mm, tok, prefix_ids, max_new_tokens, temperature):
    device = mm.device
    input_ids = torch.tensor(prefix_ids, dtype=torch.long, device=device)
    gen = flex_generate(
        model=mm.model, tokenizer=tok, input_ids=input_ids,
        seq_ids=torch.zeros_like(input_ids),
        position_ids=torch.arange(len(input_ids), device=device),
        cache=mm.cache, max_new_tokens=max_new_tokens, temperature=temperature,
    )
    return list(gen.values())[0] if gen else []


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dataset", default="data/processed/longmemeval_s/dataset.json")
    ap.add_argument("--cartridge-dir", default="checkpoints/cartridge_longmem/Qwen3-8B")
    ap.add_argument("--lora-dir", default="checkpoints/sft/Qwen3-8B")
    ap.add_argument("--retrieval-config", default="configs/retrieval/bge_m3.yaml")
    ap.add_argument("--user-id", default=None)
    ap.add_argument("--query", default=None)
    ap.add_argument("--temperature", type=float, default=0.0)
    args = ap.parse_args()

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

    set_seed(42)
    dataset = load_json(_r(args.dataset))
    by_uid = {u["user_id"]: u for u in dataset}
    ud = by_uid[args.user_id] if args.user_id else dataset[0]
    uid = ud["user_id"]
    q = args.query or ud["queries"][0]["query"]
    gold = ud["queries"][0]["answer"] if not args.query else "(custom query, no gold)"
    qdate = (ud["queries"][0].get("extra") or {}).get("question_date")
    gold_ev = ud["queries"][0].get("evidence_session_ids", [])

    hr("0. 输入")
    print(f"user_id            : {uid}")
    print(f"#sessions          : {len(ud['user_sessions'])}")
    print(f"query              : {q}")
    print(f"gold answer        : {gold}")
    print(f"gold evidence ids  : {gold_ev}")
    print(f"question_date      : {qdate}")
    print(f"temperature        : {args.temperature}")

    # ---- load model + LoRA + cartridge ----
    mm, tok = load_metamem_base(
        base_cfg_path=_r("configs/model/base_model.yaml"),
        lora_cfg_path=_r("configs/model/capability_lora.yaml"),
        project_root=PROJECT_ROOT, adapter_names=("policy",), set_trainable=None,
    )
    lora_path = os.path.join(_r(args.lora_dir), "capability_lora.safetensors")
    if os.path.exists(lora_path):
        load_capability_lora(mm.model, _r(args.lora_dir), adapter_name="policy")
        print(f"\n[loaded] Capability LoRA ← {args.lora_dir}")
    else:
        print(f"\n[WARN] no LoRA at {args.lora_dir} — base+cartridge only")
    mm.set_adapter("policy")
    mm.model.eval()

    cpath = find_cartridge_path(_r(args.cartridge_dir), uid)
    cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
    mm.set_cartridge(cache)
    print(f"[loaded] cartridge ({cache.num_cartridge_tokens()} tokens) ← {cpath}")

    retriever = BGEM3Retriever(load_yaml(_r(args.retrieval_config)))
    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"])}

    # ===== STAGE 1: decision prompt =====
    hr("1. 决策阶段 —— 喂给模型的 PROMPT(cartridge 注入在 KV 前缀,此处是文本部分)")
    prompt = format_decision_prompt(q, tok, qdate)
    print(prompt)

    prompt_ids = tok.encode(prompt, add_special_tokens=False)
    mm.set_cartridge(cache)
    gen_ids = gen_segment(mm, tok, prompt_ids, DECISION_MAX_NEW_TOKENS, args.temperature)

    hr("2. 决策阶段 —— 模型原始输出(decode 全部生成 token,未截断)")
    print(repr(tok.decode(gen_ids)))

    span = find_marker_token_span(gen_ids, tok, EOQ_TOKEN)
    decision_ids = gen_ids[:span[1]] if span else gen_ids
    decision_text = tok.decode(decision_ids)
    parsed = extract_control_strings(decision_text)

    hr("3. 决策阶段 —— 截到 [EOQ] 后的决策串 + 解析结果")
    print(f"decision text (截到 EOQ): {repr(decision_text)}")
    print(f"  → 解析 MS   : {parsed['ms']}")
    print(f"  → 解析 ACT  : {parsed['act']}")
    print(f"  → rewrite_q : {repr(parsed['query_text'])}")
    print(f"  → has_eoq   : {parsed['has_eoq']}  | format_valid: {parsed['valid'] and parsed['has_eoq']}")
    act = parsed["act"] if parsed["act"] else "RETRIEVE"
    print(f"  → 实际动作  : {act}  ({'fallback→RETRIEVE' if not parsed['act'] else 'parsed'})")

    # ===== STAGE 2: retrieval =====
    full_ids = list(prompt_ids) + list(decision_ids)
    if act != "DIRECT":
        rq = parsed["query_text"] or q
        hr(f"4. 检索阶段 —— 用 query 检索 top-{retriever.default_top_k}")
        print(f"检索 query: {repr(rq)}")
        results = retriever.search(uid, rq, top_k=retriever.default_top_k)
        new_rank = retriever.get_rank(uid, rq, set(gold_ev), window=retriever.default_top_k)
        print(f"\n检索到的 session (按相关度):")
        for rank, (rid, score) in enumerate(results):
            hit = " <== GOLD EVIDENCE" if rid in set(gold_ev) else ""
            print(f"  [{rank+1:2d}] {rid}  score={score:.4f}{hit}")
        print(f"\ngold evidence 在 top-{retriever.default_top_k} 的 rank: {new_rank}  (-1=窗口外)")

        ordered = sorted([rid for rid, _ in results], key=lambda r: idx_by_id.get(r, 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([])
        block_ids = tok.encode(rag_block, add_special_tokens=False)

        hr("5. 检索阶段 —— 拼进序列的 [RETRIEVED] block(只显示前 1500 字符)")
        print(rag_block[:1500])
        print(f"\n... [RETRIEVED block 共 {len(block_ids)} tokens,按 haystack 顺序排列] ...")
        full_ids += block_ids
    else:
        new_rank = None
        hr("4-5. 检索阶段 —— act=DIRECT,跳过检索")

    # ===== STAGE 3: answer =====
    suffix = build_answer_suffix(query=q, question_date=qdate)
    suffix_ids = tok.encode(suffix, add_special_tokens=False)
    full_ids += suffix_ids

    hr("6. 答案阶段 —— 答案提示串([ANS] 之前,baseline 同款 wording)")
    print(suffix)

    if len(full_ids) > MODEL_MAX - ANSWER_MAX_NEW_TOKENS:
        before = len(full_ids)
        full_ids, _, _ = left_truncate_ids(
            full_ids, [False] * len(full_ids), MODEL_MAX - ANSWER_MAX_NEW_TOKENS, [False] * len(full_ids)
        )
        print(f"\n[left-truncate] {before} → {len(full_ids)} tokens (预算 {MODEL_MAX-ANSWER_MAX_NEW_TOKENS})")

    mm.set_cartridge(cache)
    ans_ids = gen_segment(mm, tok, full_ids, ANSWER_MAX_NEW_TOKENS, args.temperature)

    hr("7. 答案阶段 —— 模型最终输出")
    print(f"raw answer (decode, 保留所有伪 token): {repr(tok.decode(ans_ids))}")
    print(f"\nanswer (skip_special_tokens, strip)  : {repr(tok.decode(ans_ids, skip_special_tokens=True).strip())}")
    print(f"\ngen_token_count: {len(ans_ids)}")

    hr("8. 全链路小结")
    print(f"query     : {q}")
    print(f"decision  : [MS:{parsed['ms']}] [ACT:{act}] query={repr(parsed['query_text'])}")
    print(f"retrieval : {'DIRECT(跳过)' if act=='DIRECT' else f'top-{retriever.default_top_k}, gold@rank={new_rank}'}")
    print(f"answer    : {repr(tok.decode(ans_ids, skip_special_tokens=True).strip())}")
    print(f"gold      : {gold}")


if __name__ == "__main__":
    main()