step_train/scripts_train/smoke_d_logprob.py

"""SMOKE D — single-sequence logprob recompute correctness. Requires GPU.

Validates (plan step 9):
  - step0: token-by-token current_logp == behavior_logp (same weights, same seq) —
    not just ratio≈1, the per-token logprobs are numerically equal.
  - ratio = exp(current - behavior) ≈ 1.
  - ref logprob (other adapter) is finite.
  - policy_token_mask correctly excludes the retrieved block (retrieved tokens are
    not in the selected logprob set).

Usage: python scripts/train/smoke_d_logprob.py --user-id u0001
"""

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.metamem_model import load_metamem_base
from src.retrieval.bge_m3_retriever import BGEM3Retriever
from src.train.rl.logprob_recompute import recompute_logprobs
from src.train.rl.rollout import rollout_one
from src.train.rl.trajectory import Anchor
from src.utils import load_json, load_yaml
from src.utils.cartridge_utils import find_cartridge_path


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--user-id", default="u0001")
    ap.add_argument("--dataset", default="data/processed/metamem/dataset.json")
    ap.add_argument("--cartridge-dir", default="checkpoints/cartridge/Qwen3-8B")
    args = ap.parse_args()

    # inject BOTH adapters (policy + ref) to exercise ref logprob
    mm, tok = load_metamem_base(adapter_names=("policy", "ref"), set_trainable="policy")
    from cartridges.cache import TrainableCache

    dataset = load_json(os.path.join(PROJECT_ROOT, args.dataset))
    ud = next(u for u in dataset if u["user_id"] == args.user_id)
    q = ud["queries"][0]
    cpath = find_cartridge_path(os.path.join(PROJECT_ROOT, args.cartridge_dir), args.user_id)
    cache = TrainableCache.from_pretrained(cpath, device="cuda").to("cuda")
    mm.set_cartridge(cache)

    rcfg = load_yaml(os.path.join(PROJECT_ROOT, "configs/retrieval/bge_m3.yaml"))
    ret = BGEM3Retriever(rcfg)
    ret.build_user_index(args.user_id, 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"]}

    anchor = Anchor(
        user_id=args.user_id, query=q["query"], gold_answer=q["answer"],
        gold_aliases=[q["answer"]], gold_evidence_ids=q.get("evidence_session_ids", []),
        oracle_label="PM", cartridge_path=cpath, base_rank=-1, memory_bank_texts=[],
    )

    mm.set_adapter("policy")
    traj = rollout_one(mm, tok, anchor, ret, temperature=1.0,
                       sessions_by_id=sessions_by_id, dates_by_id=dates_by_id)
    print(f"[D] full_ids={len(traj.full_ids)} n_policy={traj.n_policy_tokens()}")

    # behavior (detached, current policy)
    mm.set_adapter("policy")
    behavior, _ = recompute_logprobs(mm, traj.full_ids, traj.policy_token_mask, detach=True)
    # current (grad, same policy, step0)
    current, _ = recompute_logprobs(mm, traj.full_ids, traj.policy_token_mask, detach=False)
    diff = (current.detach() - behavior).abs().max().item()
    ratio = torch.exp(current.detach() - behavior)
    print(f"[D] max|current-behavior| = {diff:.3e}  (should be ~0 at step0)")
    print(f"[D] ratio mean={ratio.mean().item():.6f} min={ratio.min().item():.6f} max={ratio.max().item():.6f}")
    assert diff < 1e-3, "step0 current != behavior — logprob recompute inconsistent"

    # ref logprob finite
    mm.set_adapter("ref")
    ref, _ = recompute_logprobs(mm, traj.full_ids, traj.policy_token_mask, detach=True)
    assert torch.isfinite(ref).all(), "ref logprob not finite"
    print(f"[D] ref logprob finite, mean={ref.mean().item():.4f}")
    mm.set_adapter("policy")

    # mask excludes retrieved block: K == #True in mask
    assert behavior.numel() == sum(traj.policy_token_mask), "selected != mask True count"
    # sanity: retrieved tokens (mask False) are far more than selected when retrieval happened
    print(f"[D] selected={behavior.numel()} of full={len(traj.full_ids)} "
          f"(masked-out includes the {traj.retrieved_tokens}-token retrieved block)")

    print("\n[D] SMOKE D PASSED ✅")


if __name__ == "__main__":
    main()