#!/usr/bin/env python3 """Fast variant of evaluate_from_hf.py for image-heavy datasets (ACoPPer). `evaluate_from_hf.py`'s `Dataset.from_parquet(...)` materializes every column, including full-page scan images -- on ACoPPer this took 15-20+ minutes per invocation even with the parquet files already cached locally, because the `datasets` library decodes/rewrites the embedded image bytes into its own arrow cache regardless of whether anything downstream actually reads them. Scoring only needs `page_id` and `annotations`; reading just those two columns directly via `pyarrow.parquet.read_table(files, columns=[...])` takes well under a second for the same 197 pages. Two modes this enables that the slow path made impractical for iterative work: - `--pages page1 page2 ...`: score only a specific subset (e.g. the handful of pages a candidate repair actually touched) for a fast accept/reject signal before paying for a full run. - default (no `--pages`): score every page, same as `evaluate_from_hf.py` -- now fast too, so "compute the total CER to confirm" is cheap once a subset check looks promising. Same evaluation engine, same output shape, same GT-blind contract as `evaluate_from_hf.py` (ground truth is only ever consulted inside the scorer to produce the final CER numbers, never surfaced as text to the caller). Kept as a separate script rather than a flag on `evaluate_from_hf.py` so the original stays untouched. """ from __future__ import annotations import argparse import json import sys from pathlib import Path from typing import Any _ROOT = Path(__file__).resolve().parent for _subdir in ("evaluation", "box_grouping"): _path = str(_ROOT / _subdir) if _path not in sys.path: sys.path.insert(0, _path) from measure_accuracy import evaluate_rows, parse_filter_names # noqa: E402 from measure_overall_accuracy import aggregate_reports # noqa: E402 from generate_accuracy_report_variants import REPORT_VARIANTS # noqa: E402 from loading import load_predicted_rows # noqa: E402 sys.path.insert(0, str(_ROOT)) from evaluate_from_hf import annotation_boxes_from_hf_row # noqa: E402 def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--dataset", default="RLALT/ACoPPer") parser.add_argument("--split", default="test") parser.add_argument("--predictions-dir", type=Path, required=True) parser.add_argument("--output-dir", type=Path, required=True) parser.add_argument("--unit-level", choices=["word", "line"], default="word") parser.add_argument("--coverage-threshold", type=float, default=1.0) parser.add_argument("--failure-example-count", type=int, default=5) parser.add_argument("--variant", choices=[v["name"] for v in REPORT_VARIANTS], default=None) parser.add_argument( "--pages", nargs="*", default=None, help="Score only these page_ids (fast subset check). Omit to score all pages.", ) return parser.parse_args() def load_annotations_only(dataset: str, split: str) -> list[dict[str, Any]]: import pyarrow.parquet as pq from huggingface_hub import snapshot_download snapshot_dir = Path( snapshot_download(repo_id=dataset, repo_type="dataset", allow_patterns=[f"data/{split}-*.parquet"]) ) parquet_files = sorted(str(p) for p in snapshot_dir.glob(f"data/{split}-*.parquet")) if not parquet_files: raise ValueError(f"{dataset}: no data/{split}-*.parquet files found") table = pq.read_table(parquet_files, columns=["page_id", "annotations"]) return table.to_pylist() def main() -> None: args = parse_args() rows = load_annotations_only(args.dataset, args.split) if args.pages: wanted = set(args.pages) rows = [r for r in rows if r["page_id"] in wanted] missing_requested = wanted - {r["page_id"] for r in rows} if missing_requested: print(f"Warning: requested page(s) not found in dataset: {sorted(missing_requested)}") print(f"Scoring {len(rows)} page(s) from {args.dataset}[{args.split}]" + (" (subset)" if args.pages else "")) variants = REPORT_VARIANTS if args.variant: variants = tuple(v for v in REPORT_VARIANTS if v["name"] == args.variant) page_reports_by_variant: dict[str, list[dict[str, Any]]] = {v["name"]: [] for v in variants} missing_predictions: list[str] = [] for row in rows: page_id = row["page_id"] predictions_csv = args.predictions_dir / f"{page_id}.csv" if not predictions_csv.exists(): missing_predictions.append(page_id) continue annotation_boxes = annotation_boxes_from_hf_row(row) predicted_rows = load_predicted_rows(predictions_csv, unit_level=args.unit_level) for variant in variants: filters = parse_filter_names(variant["filters"]) report = evaluate_rows( predicted_rows=predicted_rows, annotation_boxes=annotation_boxes, coverage_threshold=args.coverage_threshold, failure_example_count=args.failure_example_count, hide_zero_cer_details=False, filters=filters, unit_level=args.unit_level, ) page_reports_by_variant[variant["name"]].append( { "page_name": page_id, "predictions_csv": str(predictions_csv), "annotations_json": f"hf://{args.dataset}/{args.split}#{page_id}", "report": report, } ) if missing_predictions: print( f"Warning: {len(missing_predictions)} page(s) had no matching CSV, skipped: " f"{', '.join(sorted(missing_predictions)[:10])}" + (" ..." if len(missing_predictions) > 10 else ""), flush=True, ) args.output_dir.mkdir(parents=True, exist_ok=True) for variant in variants: aggregate_report = aggregate_reports( page_reports=page_reports_by_variant[variant["name"]], coverage_threshold=args.coverage_threshold, failure_example_count=args.failure_example_count, unit_level=args.unit_level, ) output_path = args.output_dir / variant["filename"] output_path.write_text(json.dumps(aggregate_report, ensure_ascii=False, indent=2), encoding="utf-8") summary = aggregate_report["summary"] print( f"{variant['name']}: cer={summary['ocr_region_cer']:.4f} " f"({summary['pair_count']} page(s)) -> {output_path}", flush=True, ) if __name__ == "__main__": main()