Datasets:
Download construction/pooling.py from leequeue/MIPR: direct link, hf CLI and curl.
- Browser
- Download file 7.21 kB
-
https://huggingface.co/datasets/leequeue/MIPR/resolve/main/construction/pooling.py
- Command line
-
hf download hf://datasets/leequeue/MIPR/construction/pooling.py
-
curl -L -o pooling.py https://huggingface.co/datasets/leequeue/MIPR/resolve/main/construction/pooling.py
7.21 kB
| #!/usr/bin/env python3 | |
| """Pool top-20 runs, annotate unseen pairs, and export complete five-way qrels.""" | |
| import argparse | |
| import json | |
| from collections import defaultdict | |
| from pathlib import Path | |
| from utils import GRADE_ALIASES, index_pairs, pair_key, read_jsonl, read_pairs, write_jsonl | |
| def build_pool(recall_path, run_paths, output_path, top_k=20): | |
| if top_k < 1 or not run_paths: | |
| raise ValueError("Supply retrieval runs and a positive top_k") | |
| pairs = {} | |
| for row in read_pairs(recall_path): | |
| key = pair_key(row) | |
| pairs.setdefault(key, set()).update(row.get("retrieved_by", [])) | |
| query_ids = {qid for qid, _ in pairs} | |
| if not query_ids: | |
| raise ValueError("Initial candidate pool is empty") | |
| for path in run_paths: | |
| with open(path, encoding="utf-8") as f: | |
| run = json.load(f) | |
| qids = [str(row["qid"]) for row in run] | |
| if len(set(qids)) != len(qids) or set(qids) != query_ids: | |
| raise ValueError(f"Run query IDs must match initial pool exactly: {path}") | |
| source = f"model:{Path(path).parent.name}/{Path(path).name}" | |
| for row in run: | |
| hits = row["ranked"][:top_k] | |
| ids = [str(hit["did"]) for hit in hits] | |
| if len(ids) < top_k or len(set(ids)) != len(ids): | |
| raise ValueError(f"Run needs {top_k} unique products per query: {path}, {row['qid']}") | |
| for did in ids: | |
| pairs.setdefault((str(row["qid"]), did), set()).add(source) | |
| rows = [{"idx": qid, "item_id": did, "retrieved_by": sorted(sources)} | |
| for (qid, did), sources in sorted(pairs.items())] | |
| write_jsonl(output_path, rows) | |
| return rows | |
| def coarse_index(paths): | |
| rows = index_pairs([row for path in paths for row in read_pairs(path)]) | |
| for row in rows.values(): | |
| if row.get("decision") not in {"keep", "discard"}: | |
| raise ValueError(f"Invalid coarse decision: {pair_key(row)}") | |
| return rows | |
| def prepare_coarse(merged_path, coarse_path, output_path, todo_path): | |
| pool = index_pairs(read_pairs(merged_path)) | |
| coarse = coarse_index([coarse_path]) | |
| if set(coarse) - set(pool): | |
| raise ValueError("Existing coarse results contain pairs outside the pool") | |
| done, todo = [], [] | |
| for key, row in pool.items(): | |
| if key in coarse: | |
| done.append({**row, "decision": coarse[key]["decision"], | |
| "reason": coarse[key].get("reason", "")}) | |
| else: | |
| todo.append(row) | |
| write_jsonl(output_path, done) | |
| write_jsonl(todo_path, todo) | |
| return done, todo | |
| def merge_coarse(merged_path, result_paths, output_path): | |
| pool = index_pairs(read_pairs(merged_path)) | |
| results = coarse_index(result_paths) | |
| if set(pool) != set(results): | |
| raise ValueError(f"Incomplete coarse results: missing={len(set(pool)-set(results))}, " | |
| f"extra={len(set(results)-set(pool))}") | |
| rows = [{**row, "decision": results[key]["decision"], | |
| "reason": results[key].get("reason", "")} for key, row in pool.items()] | |
| write_jsonl(output_path, rows) | |
| return rows | |
| def finalize(pool_path, coarse_paths, fine_paths, queries_path, output_dir): | |
| """Require complete labels; filter queries only after initial and pooled labeling.""" | |
| pool = index_pairs(read_pairs(pool_path)) | |
| coarse = coarse_index(coarse_paths) | |
| fine = index_pairs([row for path in fine_paths for row in read_pairs(path)]) | |
| if set(coarse) != set(pool): | |
| raise ValueError("Coarse results must cover exactly the complete pool") | |
| kept_pairs = {key for key, row in coarse.items() if row["decision"] == "keep"} | |
| if set(fine) != kept_pairs: | |
| raise ValueError(f"Fine results must cover all and only coarse-kept pairs: " | |
| f"missing={len(kept_pairs-set(fine))}, extra={len(set(fine)-kept_pairs)}") | |
| queries = read_jsonl(queries_path) | |
| qids = [str(row["idx"]) for row in queries] | |
| if len(set(qids)) != len(qids) or set(qids) != {qid for qid, _ in pool}: | |
| raise ValueError("Query IDs must match the complete pool exactly") | |
| judgments = defaultdict(list) | |
| membership = [] | |
| for key, pair in pool.items(): | |
| if coarse[key]["decision"] == "discard": | |
| grade = "N3" | |
| else: | |
| raw_grade = fine[key].get("final_grade") | |
| if not isinstance(raw_grade, str) or raw_grade not in GRADE_ALIASES: | |
| raise ValueError(f"Missing or invalid final grade: {key}") | |
| grade = GRADE_ALIASES[raw_grade] | |
| judgments[key[0]].append({"item_id": key[1], "final_grade": grade}) | |
| membership.append({**pair, "final_grade": grade}) | |
| retained = {qid for qid, items in judgments.items() | |
| if 1 <= sum(item["final_grade"] == "L1" for item in items) <= 20} | |
| final_queries = [{"idx": str(row["idx"]), "query": row["query"], "image_url": row["image_url"]} | |
| for row in queries if str(row["idx"]) in retained] | |
| out = Path(output_dir) | |
| # Keep IDs and corpus unchanged; only the final query set is filtered. | |
| write_jsonl(out / "mipr_query.jsonl", final_queries) | |
| write_jsonl(out / "mipr_annotation.jsonl", [ | |
| {"idx": qid, "items": judgments[qid]} for qid in qids if qid in retained]) | |
| write_jsonl(out / "pool_membership.jsonl", [row for row in membership if row["idx"] in retained]) | |
| return retained | |
| def main(): | |
| p = argparse.ArgumentParser(description=__doc__) | |
| sub = p.add_subparsers(dest="command", required=True) | |
| build = sub.add_parser("build", help="Merge initial flat pairs and model top-20 runs") | |
| build.add_argument("--recall", required=True) | |
| build.add_argument("--runs", nargs="+", required=True) | |
| build.add_argument("--top-k", type=int, default=20) | |
| build.add_argument("--output", required=True) | |
| prepare = sub.add_parser("prepare", help="Reuse old coarse results and emit unseen pairs") | |
| prepare.add_argument("--pool", required=True) | |
| prepare.add_argument("--coarse", required=True) | |
| prepare.add_argument("--done", required=True) | |
| prepare.add_argument("--todo", required=True) | |
| merge = sub.add_parser("merge", help="Combine reused and newly screened pairs") | |
| merge.add_argument("--pool", required=True) | |
| merge.add_argument("--results", nargs="+", required=True) | |
| merge.add_argument("--output", required=True) | |
| final = sub.add_parser("finalize", help="Merge all labels, map N1/N2/N3, and filter queries") | |
| final.add_argument("--pool", required=True) | |
| final.add_argument("--coarse", nargs="+", required=True) | |
| final.add_argument("--fine", nargs="+", required=True) | |
| final.add_argument("--queries", required=True) | |
| final.add_argument("--output-dir", required=True) | |
| args = p.parse_args() | |
| if args.command == "build": | |
| build_pool(args.recall, args.runs, args.output, args.top_k) | |
| elif args.command == "prepare": | |
| prepare_coarse(args.pool, args.coarse, args.done, args.todo) | |
| elif args.command == "merge": | |
| merge_coarse(args.pool, args.results, args.output) | |
| else: | |
| finalize(args.pool, args.coarse, args.fine, args.queries, args.output_dir) | |
| if __name__ == "__main__": | |
| main() | |