MIPR / evaluation /evaluate.py
leequeue's picture
Upload folder using huggingface_hub (part 38)
1dda194 verified
Raw History Blame Contribute Delete
5.84 kB
"""Main retrieval/reranking metrics and candidate-pool Oracle."""
import argparse
import json
from pathlib import Path
import utils as data
import math
KS = [10, 20, 50]
GAINS = {"L1": 2, "L2": 1}
COLS = (
[f"ndcg@{k}" for k in KS]
+ [f"recall_l1@{k}" for k in KS]
+ ["l1_hit@1", "l1_hit@10", "scr@10"]
+ ["l1_hit@1_mc", "l1_hit@10_mc", "scr@10_mc"]
)
def evaluate(run, ann, treecate):
"""ann: qid -> {item_id: final_grade} (all grades); only L1/L2 gain."""
run = validate_run(run, ann, treecate)
acc = {c: [] for c in COLS}
n = 0
for entry in run:
grades = ann.get(str(entry["qid"]))
if grades is None:
continue
n += 1
rels = {d: g for d, g in grades.items() if g in GAINS}
l1 = {i for i, g in rels.items() if g == "L1"}
all_cates = {treecate[i] for i in l1}
gains = sorted((GAINS[g] for g in rels.values()), reverse=True)
dids = [r["did"] for r in entry["ranked"]]
for k in KS:
top = dids[:k]
if gains:
dcg = sum(
GAINS[rels[d]] / math.log2(r + 2)
for r, d in enumerate(top)
if d in rels
)
idcg = sum(g / math.log2(r + 2) for r, g in enumerate(gains[:k]))
acc[f"ndcg@{k}"].append(dcg / idcg)
if l1:
acc[f"recall_l1@{k}"].append(len(l1.intersection(top)) / len(l1))
if not l1:
continue
top10 = dids[:10]
hit1 = float(bool(dids) and dids[0] in l1)
hit10 = float(any(d in l1 for d in top10))
got_cates = {treecate[d] for d in top10 if d in l1}
scr = len(got_cates) / len(all_cates)
acc["l1_hit@1"].append(hit1)
acc["l1_hit@10"].append(hit10)
acc["scr@10"].append(scr)
if len(all_cates) >= 2:
acc["l1_hit@1_mc"].append(hit1)
acc["l1_hit@10_mc"].append(hit10)
acc["scr@10_mc"].append(scr)
counts = {c: len(v) for c, v in acc.items()}
return {c: sum(v) / len(v) if v else float("nan") for c, v in acc.items()}, n, counts
def oracle_run(baseline, ann, treecate):
"""Judgment-based upper bound within the candidate pool: first one L1
product from each distinct L1 leaf category (round-robin across
categories to maximize prefix coverage), then the remaining L1, then L2,
then everything else, keeping baseline order within each group."""
out = []
for e in baseline:
rels = ann.get(str(e["qid"]), {})
dids = [r["did"] for r in e["ranked"]]
l1 = [d for d in dids if rels.get(d) == "L1"]
l2 = [d for d in dids if rels.get(d) == "L2"]
rest = [d for d in dids if rels.get(d) not in GAINS]
by_cate = {}
for d in l1:
by_cate.setdefault(treecate[d], []).append(d)
groups = list(by_cate.values())
l1_rr = []
j = 0
while len(l1_rr) < len(l1):
for g in groups:
if j < len(g):
l1_rr.append(g[j])
j += 1
ordered = l1_rr + l2 + rest
out.append({"qid": e["qid"], "ranked": [{"did": d} for d in ordered]})
return out
def norm_run(run):
return [{"qid": str(e["qid"]), "ranked": [dict(r, did=str(r["did"]))
for r in e["ranked"]]} for e in run]
def validate_run(run, query_ids, corpus_ids, baseline=None):
"""Require complete query coverage, unique IDs and known corpus items."""
if not isinstance(run, list):
raise ValueError("Run must be a JSON list")
run = norm_run(run)
seen = set()
pools = {e["qid"]: {r["did"] for r in e["ranked"]}
for e in baseline} if baseline is not None else None
for e in run:
qid = e["qid"]
if qid in seen or qid not in query_ids:
raise ValueError(f"Duplicate or unknown query: {qid}")
seen.add(qid)
dids = [r["did"] for r in e["ranked"]]
if len(dids) != len(set(dids)) or any(d not in corpus_ids for d in dids):
raise ValueError(f"Duplicate or unknown corpus item for query {qid}")
if pools is not None and set(dids) != pools[qid]:
raise ValueError(f"Reranking changed the candidate pool for query {qid}")
if seen != set(query_ids):
raise ValueError(f"Incomplete run: expected {len(query_ids)} queries, got {len(seen)}")
return run
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("runs", nargs="+", help="Ranking JSON files")
p.add_argument("--data", default=None)
p.add_argument("--rerank", action="store_true", help="Check the top-50 pool and include baseline/Oracle")
p.add_argument("--baseline", default=None)
args = p.parse_args()
ann, treecate = data.load_annotation(args.data), data.load_treecate(args.data)
runs = []
baseline = None
if args.rerank:
path = Path(args.baseline) if args.baseline else data.data_root(args.data) / "baseline/qwen3_vl_embedding_8b_top50.json"
baseline = validate_run(json.loads(path.read_text()), ann, treecate)
if any(len(row["ranked"]) != 50 for row in baseline):
raise ValueError("Reranking requires 50 candidates per query")
runs.append(("embedding_baseline", baseline))
for path in args.runs:
run = validate_run(json.loads(Path(path).read_text()), ann, treecate, baseline)
runs.append((Path(path).stem, run))
if baseline is not None:
runs.append(("Oracle", oracle_run(baseline, ann, treecate)))
print("model\t" + "\t".join(COLS))
for name, run in runs:
values, _, _ = evaluate(run, ann, treecate)
print(name + "\t" + "\t".join(f"{values[key] * 100:.2f}" for key in COLS))
if __name__ == "__main__":
main()