#!/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()