| |
| """STAIR reproduction -- retrieval evaluation for one or all books. |
| |
| Modes: |
| --selftest : validate metric math on synthetic gold/candidates (no data needed). |
| --bm25 : rank leaves with a rank_bm25-style BM25Okapi implemented here, |
| over leaf_docs tokenized text; per-book + macro metrics. |
| --predictions FILE : load {book_id: {paragraph_id: [leaf_id, ...]}} JSON |
| produced by a trained-model inference job; per-book + macro metrics. |
| --hallucination-rate : fraction of test queries whose top candidate is not a |
| valid leaf of the book (with --bm25 it is 0 by construction). |
| |
| Test questions are subsampled per book (--max-per-book, default 800) with a |
| fixed seed -> deterministic across runs. |
| |
| Examples: |
| python eval_retrieval.py --selftest |
| python eval_retrieval.py --bm25 --book compgov --max-per-book 100 |
| python eval_retrieval.py --predictions preds.json --hallucination-rate |
| """ |
| import argparse, json, math, os, random, re, sys |
| from collections import Counter |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from stair_common import BOOKS, load_books, load_questions, evaluate_rankings |
|
|
| TOKEN_RE = re.compile(r"[a-z0-9]+") |
|
|
| |
| |
| |
|
|
| def tokenize(text): |
| return TOKEN_RE.findall(text.lower()) |
|
|
|
|
| class BM25Okapi: |
| """Okapi BM25 over pre-tokenized documents (same math as rank_bm25, |
| including its epsilon flooring of negative idfs).""" |
|
|
| def __init__(self, corpus_tokens, k1=1.5, b=0.75, epsilon=0.25): |
| self.k1, self.b, self.epsilon = k1, b, epsilon |
| self.doc_count = len(corpus_tokens) |
| self.doc_len = [len(d) for d in corpus_tokens] |
| self.avgdl = sum(self.doc_len) / max(1, self.doc_count) |
| self.doc_freqs = [Counter(d) for d in corpus_tokens] |
| df = Counter() |
| for freqs in self.doc_freqs: |
| for t in freqs: |
| df[t] += 1 |
| nd = self.doc_count |
| self.idf = {t: math.log((nd - n + 0.5) / (n + 0.5) + 1) for t, n in df.items()} |
| mean_idf = sum(self.idf.values()) / len(self.idf) if self.idf else 0.0 |
| for t in list(self.idf): |
| if self.idf[t] < 0: |
| self.idf[t] = self.epsilon_floor(0.25, mean_idf) |
|
|
| @staticmethod |
| def epsilon_floor(epsilon, mean_idf): |
| return epsilon * mean_idf |
|
|
| def get_scores(self, query_tokens): |
| scores = [0.0] * self.doc_count |
| q = Counter(query_tokens) |
| for i in range(self.doc_count): |
| dl = self.doc_len[i] |
| denom_bias = self.k1 * (1 - self.b + self.b * dl / self.avgdl) |
| freqs = self.doc_freqs[i] |
| s = 0.0 |
| for t, qw in q.items(): |
| f = freqs.get(t, 0) |
| if f == 0: |
| continue |
| s += self.idf.get(t, 0.0) * f * (self.k1 + 1) / (f + denom_bias) |
| scores[i] = s |
| return scores |
|
|
|
|
| def rank_leaves_bm25(query, leaf_docs, bm25): |
| """leaf_ids ranked by BM25 score for `query` (descending).""" |
| scores = bm25.get_scores(tokenize(query)) |
| order = sorted(range(len(scores)), key=lambda i: -scores[i]) |
| return [leaf_docs[i]["leaf_id"] for i in order] |
|
|
| |
| |
| |
|
|
| def subsample_test(questions, max_per_book, seed=42): |
| """{book_id: [rec, ...]} -- deterministic subsample of the test split.""" |
| rng = random.Random(seed) |
| out = {} |
| for book_id, per_split in questions.items(): |
| test = list(per_split["test"]) |
| if max_per_book and len(test) > max_per_book: |
| test = rng.sample(test, max_per_book) |
| out[book_id] = test |
| return out |
|
|
|
|
| def top1_hallucination_rate(ranked_by_query, valid_leaf_ids): |
| """Fraction of queries whose TOP candidate is not a valid leaf id.""" |
| valid = set(valid_leaf_ids) |
| n = bad = 0 |
| for qid, cands in ranked_by_query.items(): |
| n += 1 |
| if not cands or cands[0] not in valid: |
| bad += 1 |
| return bad / n if n else 0.0 |
|
|
| |
|
|
| def run_selftest(): |
| """Validate metric math with known-answer cases (random gold / empty cands).""" |
| from stair_common import recall_at_k, ndcg_at_k, evaluate_rankings |
| ok = lambda c, m: abs(c - m) < 1e-9 |
| cases = [] |
| cases.append(("recall@1, gold at 1", recall_at_k(["a", "b", "c"], "a", 1), 1.0)) |
| cases.append(("recall@1, gold at 2", recall_at_k(["a", "b", "c"], "b", 1), 0.0)) |
| cases.append(("recall@3, gold at 3", recall_at_k(["a", "b", "c"], "c", 3), 1.0)) |
| cases.append(("recall@3, gold missing", recall_at_k(["a", "b", "c"], "z", 3), 0.0)) |
| cases.append(("recall@3, empty candidates", recall_at_k([], "a", 3), 0.0)) |
| |
| cases.append(("ndcg@3, gold at 1", ndcg_at_k(["a", "b", "c"], "a", 3), 1.0)) |
| cases.append(("ndcg@3, gold at 2", ndcg_at_k(["a", "b", "c"], "b", 3), 1 / math.log2(3))) |
| cases.append(("ndcg@3, gold at 3", ndcg_at_k(["a", "b", "c"], "c", 3), 1 / math.log2(4))) |
| cases.append(("ndcg@3, gold at 4 (outside k)", ndcg_at_k(["a", "b", "c", "d"], "d", 3), 0.0)) |
| cases.append(("ndcg@3, empty candidates", ndcg_at_k([], "a", 3), 0.0)) |
| cases.append(("ndcg@3, gold None", ndcg_at_k(["a"], None, 3), 0.0)) |
| |
| e = evaluate_rankings({"q1": ["a", "b", "c"], "q2": ["x", "a", "c"], "q3": []}, |
| {"q1": "a", "q2": "a", "q3": "a"}) |
| cases.append(("macro recall@1", e["recall@1"], (1 + 0 + 0) / 3)) |
| |
| cases.append(("macro recall@3", e["recall@3"], 2 / 3)) |
| cases.append(("macro ndcg@3", e["ndcg@3"], (1.0 + 1 / math.log2(3)) / 3)) |
| bad = [(n, got, exp) for n, got, exp in cases if not ok(got, exp)] |
| for n, got, exp in cases: |
| status = "ok " if ok(got, exp) else "FAIL" |
| print(f" [{status}] {n:<28} got={got:.6f} expected={exp:.6f}") |
| if bad: |
| raise SystemExit(f"selftest FAILED: {len(bad)} case(s) wrong") |
| print(f"selftest passed: {len(cases)}/{len(cases)} metric checks ok") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--selftest", action="store_true", |
| help="validate metric math on synthetic data and exit") |
| ap.add_argument("--book", action="append", default=None, |
| help="book_id to evaluate (repeatable; default: all six)") |
| ap.add_argument("--max-per-book", type=int, default=800, |
| help="deterministic test subsample per book (default 800)") |
| ap.add_argument("--bm25", action="store_true", |
| help="rank leaves with built-in BM25Okapi over leaf_docs text") |
| ap.add_argument("--predictions", default=None, |
| help="JSON file {book_id: {paragraph_id: [leaf_id, ...]}} from a trained model") |
| ap.add_argument("--hallucination-rate", action="store_true", |
| help="also report fraction of test queries whose top candidate is not a valid leaf") |
| ap.add_argument("--seed", type=int, default=42) |
| args = ap.parse_args() |
|
|
| if args.selftest: |
| run_selftest() |
| return |
|
|
| if not args.bm25 and not args.predictions: |
| ap.error("choose --bm25 or --predictions FILE (or --selftest)") |
|
|
| books = load_books() |
| questions = load_questions(splits=("test",)) |
| all_ids = [bid for dom in BOOKS.values() for bid, _ in dom] |
| want = set(args.book) if args.book else set(all_ids) |
| sampled = {bid: qs for bid, qs in |
| subsample_test(questions, args.max_per_book, seed=args.seed).items() |
| if bid in want} |
|
|
| preds_all = None |
| if args.predictions: |
| with open(args.predictions) as f: |
| preds_all = json.load(f) |
|
|
| per_book = {} |
| for bid, test_recs in sampled.items(): |
| b = books[bid] |
| valid_ids = [l["leaf_id"] for l in b["leaves"]] |
| ranked_by_query, gold_by_query = {}, {} |
| if args.bm25: |
| corpus = [d["text"] for d in b["leaf_docs"]] |
| if not corpus: |
| print(f"[warn] {bid}: no leaf_docs, skipping") |
| continue |
| bm25 = BM25Okapi([tokenize(d) for d in corpus]) |
| for i, r in enumerate(test_recs): |
| key = r.get("paragraph_id", str(i)) |
| ranked_by_query[key] = rank_leaves_bm25(r["query"], b["leaf_docs"], bm25) |
| gold_by_query[key] = r.get("leaf_id") |
| else: |
| preds = preds_all.get(bid, {}) |
| for i, r in enumerate(test_recs): |
| key = r.get("paragraph_id", str(i)) |
| ranked_by_query[key] = preds.get(key, []) |
| gold_by_query[key] = r.get("leaf_id") |
| m = evaluate_rankings(ranked_by_query, gold_by_query, k=3) |
| if args.hallucination_rate: |
| m["hallucination_rate"] = (0.0 if args.bm25 |
| else top1_hallucination_rate(ranked_by_query, valid_ids)) |
| per_book[bid] = m |
|
|
| hdr = f"{'book':<22}{'n':>6}{'recall@1':>10}{'recall@3':>10}{'ndcg@3':>10}" |
| if args.hallucination_rate: |
| hdr += f"{'halluc':>10}" |
| print(hdr) |
| for bid, m in per_book.items(): |
| line = f"{bid:<22}{m['n']:>6}{m['recall@1']:>10.4f}{m['recall@3']:>10.4f}{m['ndcg@3']:>10.4f}" |
| if args.hallucination_rate: |
| line += f"{m.get('hallucination_rate', 0.0):>10.4f}" |
| print(line) |
| if per_book: |
| n_books = len(per_book) |
| macro = {k: sum(m[k] for m in per_book.values()) / n_books |
| for k in ("recall@1", "recall@3", "ndcg@3")} |
| line = f"{'MACRO-AVG':<22}{'':>6}{macro['recall@1']:>10.4f}{macro['recall@3']:>10.4f}{macro['ndcg@3']:>10.4f}" |
| if args.hallucination_rate: |
| line += f"{sum(m.get('hallucination_rate', 0.0) for m in per_book.values()) / n_books:>10.4f}" |
| print(line) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
