Datasets:
Download evaluation/evaluate.py from leequeue/MIPR: direct link, hf CLI and curl.
- Browser
- Download file 5.84 kB
-
https://huggingface.co/datasets/leequeue/MIPR/resolve/main/evaluation/evaluate.py
- Command line
-
hf download hf://datasets/leequeue/MIPR/evaluation/evaluate.py
-
curl -L -o evaluate.py https://huggingface.co/datasets/leequeue/MIPR/resolve/main/evaluation/evaluate.py
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() | |