Datasets:
File size: 6,723 Bytes
d0231a6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | #!/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()
|