| |
|
|
| """Convert per-page prediction JSONs into evaluation CSVs for the benchmark. |
| |
| Each input JSON is a list of {"box": [x1, y1, x2, y2], "text": "..."} items. |
| Each item becomes one CSV row with a unique group_row. |
| |
| Pass --unit-level to match what you will give the evaluator: |
| line — each item is already a complete text line (Surya, most VLMs) |
| word — each item is an individual word |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument( |
| "--predictions-dir", |
| type=Path, |
| required=True, |
| help="Directory containing per-page prediction JSON files.", |
| ) |
| parser.add_argument( |
| "--output-dir", |
| type=Path, |
| required=True, |
| help="Directory where per-page evaluation CSV files will be written.", |
| ) |
| parser.add_argument( |
| "--unit-level", |
| choices=("line", "word"), |
| default="word", |
| help=( |
| "Granularity of prediction items. Does not change the CSV structure " |
| "(each item always gets its own group_row), but should match the " |
| "--unit-level flag you pass to the evaluator." |
| ), |
| ) |
| parser.add_argument( |
| "--overwrite", |
| action="store_true", |
| help="Overwrite existing output files.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def load_predictions(path: Path) -> list[Any]: |
| with path.open("r", encoding="utf-8") as handle: |
| data = json.load(handle) |
| if not isinstance(data, list): |
| raise ValueError(f"{path}: expected a top-level JSON array") |
| return data |
|
|
|
|
| def item_box(item: Any, *, path: Path, index: int) -> list[float]: |
| if not isinstance(item, dict): |
| raise ValueError(f"{path}: item {index} must be a JSON object") |
| box = item.get("box") |
| if not isinstance(box, (list, tuple)) or len(box) != 4: |
| raise ValueError(f"{path}: item {index} is missing a valid 'box'") |
| try: |
| return [float(v) for v in box] |
| except (TypeError, ValueError) as exc: |
| raise ValueError(f"{path}: item {index} box coordinates must be numeric") from exc |
|
|
|
|
| def item_text(item: Any) -> str: |
| if isinstance(item, dict): |
| return str(item.get("text", "")) |
| return "" |
|
|
|
|
| def to_csv_rows(predictions: list[Any], *, path: Path) -> list[dict[str, Any]]: |
| rows = [] |
| for index, item in enumerate(predictions): |
| box = item_box(item, path=path, index=index) |
| rows.append( |
| { |
| "x1": box[0], |
| "y1": box[1], |
| "x2": box[2], |
| "y2": box[3], |
| "group_row": str(index), |
| "text": item_text(item), |
| } |
| ) |
| return rows |
|
|
|
|
| def write_csv(rows: list[dict[str, Any]], path: Path) -> None: |
| fieldnames = ["x1", "y1", "x2", "y2", "group_row", "text"] |
| with path.open("w", encoding="utf-8", newline="") as handle: |
| writer = csv.DictWriter(handle, fieldnames=fieldnames) |
| writer.writeheader() |
| writer.writerows(rows) |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
|
|
| prediction_files = sorted(args.predictions_dir.glob("*.json")) |
| if not prediction_files: |
| raise FileNotFoundError(f"No JSON files found in {args.predictions_dir}") |
|
|
| written = 0 |
| skipped = 0 |
| for pred_path in prediction_files: |
| output_path = args.output_dir / pred_path.with_suffix(".csv").name |
| if output_path.exists() and not args.overwrite: |
| skipped += 1 |
| continue |
|
|
| predictions = load_predictions(pred_path) |
| rows = to_csv_rows(predictions, path=pred_path) |
| write_csv(rows, output_path) |
| written += 1 |
|
|
| print(f"Wrote {written} evaluation CSV files to {args.output_dir} ({skipped} skipped)") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
