New: constrained-decoding inference over test queries -> preds.json for eval_retrieval.py

infer_constrained.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""STAIR reproduction -- constrained-decoding inference for retrieval evaluation.
+
+Loads a finetuned model (STAIR LoRA or DSI full-FT), runs generate() with
+ConstrainedLeafLogitsProcessor over the deterministic test subsample (same
+seed/subsample as eval_retrieval.py), and writes preds.json:
+  {book_id: {paragraph_id: [leaf_id, ...]}}   (candidates in generation order)
+
+Usage:
+  python infer_constrained.py --model <hub_or_path> --lora <adapter_path|hub_id> \
+      --mode stair|dsi --out /data/preds_stair.json --max-per-book 800
+  --mode dsi uses prompts without the ToC block; trie still built per book.
+"""
+import argparse, json, os, sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from stair_common import (BOOKS, load_books, load_questions, stair_prompt,
+                          dsi_prompt, LeafTrie, ConstrainedLeafLogitsProcessor,
+                          parse_leaf_output)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", required=True, help="base model id or path")
+    ap.add_argument("--lora", default=None, help="LoRA adapter id/path (STAIR); omit for full FT/DSI")
+    ap.add_argument("--mode", choices=("stair", "dsi"), default="stair")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--max-per-book", type=int, default=200)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--smoke", action="store_true", help="5 queries per book, print outputs")
+    args = ap.parse_args()
+
+    import random
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    from stair_common import load_books, load_questions
+
+    books = load_books()
+    questions = load_questions(splits=("test",))
+
+    # same subsample logic as eval_retrieval.subsample_test
+    import random as _random
+    rng = _random.Random(args.seed)
+    sampled = {}
+    for book_id, per_split in questions.items():
+        test = list(per_split["test"])
+        cap = 5 if args.smoke else args.max_per_book
+        if cap and len(test) > cap:
+            test = rng.sample(test, cap)
+        sampled[book_id] = test
+
+    tok = AutoTokenizer.from_pretrained(args.model_id if args.lora else args.model)
+    tok.pad_token = tok.pad_token or tok.eos_token
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model, dtype=torch.bfloat16, attn_implementation="sdpa",
+        device_map="auto")
+    if args.lora:
+        from peft import PeftModel
+        model = PeftModel.from_pretrained(model, args.lora)
+        model = model.merge_and_unload()
+    model.eval()
+
+    preds = {bid: {} for bid in sampled}
+    parsed = unparsed = 0
+    for bid, test_recs in sampled.items():
+        b = books[bid]
+        trie = LeafTrie(b["leaves"], tok)
+        proc = ConstrainedLeafLogitsProcessor(trie, eos_token_id=tok.eos_token_id)
+        for i, r in enumerate(test_recs):
+            key = r.get("paragraph_id", str(i))
+            if args.mode == "stair":
+                prompt = stair_prompt(b["title"], r["query"], b["leaves"])
+            else:
+                prompt = dsi_prompt(b["title"], r["query"])
+            ids = tok(prompt, return_tensors="pt", truncation=True, max_length=8192).to(model.device)
+            with torch.no_grad():
+                out = model.generate(
+                    **ids, max_new_tokens=128, do_sample=False, num_beams=1,
+                    logits_processor=[proc], pad_token_id=tok.pad_token_id)
+            gen = out[0][ids["input_ids"].shape[1]:]
+            text = tok.decode(gen, skip_special_tokens=True)
+            lid = parse_leaf_output(text, leaves=b["leaves"])
+            if lid is None:
+                # fall back: exact-match the generated string against completions
+                cands = [l["leaf_id"] for l in b["leaves"]
+                         if text.strip().endswith(l["title"]) or text.strip() == f"leaf {l['leaf_id']} {l['title']}"]
+                lid = cands[0] if cands else None
+            if lid is not None:
+                preds[bid][key] = [lid]
+                parsed += 1
+            else:
+                preds[bid][key] = []
+                unparsed += 1
+            if args.smoke:
+                print(f"[{bid}|{key}] gold={r.get('leaf_id')} gen={text.strip()[:120]!r} -> {lid}")
+
+    total = parsed + unparsed
+    print(f"[infer] parsed {parsed}/{total} outputs to valid leaves ({unparsed} unparsed)")
+    with open(args.out, "w") as f:
+        json.dump(preds, f)
+    print("[infer] predictions written to", args.out)
+
+
+if __name__ == "__main__":
+    main()