Replace evaluation kit with evaluation_kit/ folder content

evaluation_kit/README.md

@@ -401,34 +401,6 @@ python3 evaluate_from_hf.py \
 This prints one line per filter variant (`cer=... (N pages) -> path`)
 and writes the four standard report JSONs (§6, §7) to `results/`.
 
-#### Per-document (per-page) breakdown
-
-Every run also writes `results/pages_summary.json`: a flat table with one row
-per (page, variant) — `page_name`, `variant`, `ocr_region_count`,
-`ocr_region_gt_char_count`, `ocr_region_char_edit_distance`, `ocr_region_cer` —
-sorted worst CER first within each variant, so the pages dragging the score
-down are visible without opening the `pages` list inside each full report JSON.
-Same data, same file, on `evaluate_from_hf_fast.py`.
-
-#### Per-source (or per-column) breakdown
-
-Add `--group-by <column>` to also get one set of report JSONs per distinct
-value of a dataset column, on top of the all-pages reports:
-
-```bash
-python3 evaluate_from_hf.py \
-  --dataset RLALT/ACoPDoc \
-  --predictions-dir evaluation_csvs \
-  --output-dir results \
-  --unit-level word \
-  --group-by source
-```
-
-For ACoPDoc's `source` column this is a per-document breakdown (20 groups of
-10 pages). Output goes to `results/by_source/<value>/<variant>.json` plus a
-flat `results/summary_by_source.json` table (`source`, `variant`, `pages`,
-`ocr_region_cer`). `--group-by` works the same on `evaluate_from_hf_fast.py`.
-
 `evaluate_from_hf.py` builds `AnnotationBox` objects directly from each row's
 `annotations` list — the HF schema is already flattened compared to what the
 local-JSON loader (`load_annotation_boxes`, used by the scripts in §8)

evaluation_kit/REPORT_JSON_METRICS.md

@@ -226,10 +226,4 @@ overall_accuracy_filtered_all_report.json
 ```
 
 The overlay PNGs and matching JSON legends are written under
-`region_overlays/<report-name>/` inside the selected results directory.
-
-It also writes `pages_summary.json`, a flat per-document (per-page) table
-derived from the `pages` list of each variant report: one row per
-`(page_name, variant)` with `ocr_region_count`, `ocr_region_gt_char_count`,
-`ocr_region_char_edit_distance`, and `ocr_region_cer`, sorted worst CER first
-within each variant.
+`region_overlays/<report-name>/` inside the selected results directory.

evaluation_kit/evaluate_from_hf.py

@@ -113,119 +113,9 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="Generate only this filter variant. Omit to generate all four.",
     )
-    parser.add_argument(
-        "--group-by",
-        default=None,
-        help=(
-            "Also write a per-group breakdown, bucketing pages by this dataset "
-            "column (e.g. 'source' -> one report per newspaper issue / document). "
-            "Reports go to <output-dir>/by_<column>/<value>/ plus a "
-            "summary_by_<column>.json table. The unaggregated all-pages reports "
-            "are still written as usual."
-        ),
-    )
     return parser.parse_args()
 
 
-def sanitize_group_value(value: str) -> str:
-    """Make a group value safe to use as a single path segment."""
-    return "".join("_" if ch in '/\\\0' or ch.isspace() else ch for ch in value) or "__empty__"
-
-
-def write_grouped_reports(
-    output_dir: Path,
-    variants: tuple[dict[str, Any], ...],
-    page_reports_by_variant: dict[str, list[dict[str, Any]]],
-    group_by: str,
-    coverage_threshold: float,
-    failure_example_count: int,
-    unit_level: str,
-) -> None:
-    """Write one aggregate report per (group value, variant), plus a summary table.
-
-    Each page report dict must carry a "group" key holding the row's value for
-    the grouped column; pages that somehow lack one are bucketed under
-    "__ungrouped__" so nothing is silently dropped.
-    """
-    group_root = output_dir / f"by_{group_by}"
-    group_root.mkdir(parents=True, exist_ok=True)
-    summary_rows: list[dict[str, Any]] = []
-
-    for variant in variants:
-        by_group: dict[str, list[dict[str, Any]]] = {}
-        for page_report in page_reports_by_variant[variant["name"]]:
-            key = page_report.get("group") or "__ungrouped__"
-            by_group.setdefault(key, []).append(page_report)
-
-        for group_value in sorted(by_group):
-            group_page_reports = by_group[group_value]
-            aggregate_report = aggregate_reports(
-                page_reports=group_page_reports,
-                coverage_threshold=coverage_threshold,
-                failure_example_count=failure_example_count,
-                unit_level=unit_level,
-            )
-            group_dir = group_root / sanitize_group_value(group_value)
-            group_dir.mkdir(parents=True, exist_ok=True)
-            (group_dir / variant["filename"]).write_text(
-                json.dumps(aggregate_report, ensure_ascii=False, indent=2),
-                encoding="utf-8",
-            )
-            summary = aggregate_report["summary"]
-            summary_rows.append(
-                {
-                    group_by: group_value,
-                    "variant": variant["name"],
-                    "pages": summary["pair_count"],
-                    "ocr_region_cer": summary["ocr_region_cer"],
-                }
-            )
-            print(
-                f"  [{group_by}={group_value}] {variant['name']}: "
-                f"cer={summary['ocr_region_cer']:.4f} ({summary['pair_count']} page(s))",
-                flush=True,
-            )
-
-    (output_dir / f"summary_by_{group_by}.json").write_text(
-        json.dumps(summary_rows, ensure_ascii=False, indent=2),
-        encoding="utf-8",
-    )
-    print(f"Wrote per-{group_by} reports to {group_root}", flush=True)
-
-
-def write_page_summary(
-    output_dir: Path,
-    variants: tuple[dict[str, Any], ...],
-    aggregate_report_by_variant: dict[str, dict[str, Any]],
-) -> None:
-    """Write a flat per-document (per-page) CER table to `pages_summary.json`.
-
-    One row per (page, variant), sorted worst CER first within each variant, so
-    the pages dragging a run's score down are visible without digging through
-    the `pages` list inside each full report JSON.
-    """
-    rows: list[dict[str, Any]] = []
-    for variant in variants:
-        for page in aggregate_report_by_variant[variant["name"]]["pages"]:
-            summary = page["summary"]
-            rows.append(
-                {
-                    "page_name": page["page_name"],
-                    "variant": variant["name"],
-                    "ocr_region_count": summary["ocr_region_count"],
-                    "ocr_region_gt_char_count": summary["ocr_region_gt_char_count"],
-                    "ocr_region_char_edit_distance": summary["ocr_region_char_edit_distance"],
-                    "ocr_region_cer": summary["ocr_region_cer"],
-                }
-            )
-    rows.sort(key=lambda r: (r["variant"], -r["ocr_region_cer"], r["page_name"]))
-    (output_dir / "pages_summary.json").write_text(
-        json.dumps(rows, ensure_ascii=False, indent=2),
-        encoding="utf-8",
-    )
-    print(f"Wrote per-page summary to {output_dir / 'pages_summary.json'}", flush=True)
-
-
 def annotation_box_from_hf_item(item: dict[str, Any]) -> AnnotationBox:
     """Build an AnnotationBox from one entry of the dataset's `annotations` column.
 
@@ -335,12 +225,6 @@ def main() -> None:
         )
     print(f"Loaded {len(dataset)} page(s) from {args.dataset}[{args.split}]")
 
-    if args.group_by and args.group_by not in dataset.column_names:
-        raise SystemExit(
-            f"--group-by {args.group_by!r}: column not in dataset "
-            f"({', '.join(dataset.column_names)})"
-        )
-
     variants = REPORT_VARIANTS
     if args.variant:
         variants = tuple(v for v in REPORT_VARIANTS if v["name"] == args.variant)
@@ -371,15 +255,14 @@ def main() -> None:
                 filters=filters,
                 unit_level=args.unit_level,
             )
-            page_report = {
-                "page_name": page_id,
-                "predictions_csv": str(predictions_csv),
-                "annotations_json": f"hf://{args.dataset}/{args.split}#{page_id}",
-                "report": report,
-            }
-            if args.group_by:
-                page_report["group"] = str(row[args.group_by])
-            page_reports_by_variant[variant["name"]].append(page_report)
+            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(
@@ -390,7 +273,6 @@ def main() -> None:
         )
 
     args.output_dir.mkdir(parents=True, exist_ok=True)
-    aggregate_report_by_variant: dict[str, dict[str, Any]] = {}
     for variant in variants:
         aggregate_report = aggregate_reports(
             page_reports=page_reports_by_variant[variant["name"]],
@@ -398,7 +280,6 @@ def main() -> None:
             failure_example_count=args.failure_example_count,
             unit_level=args.unit_level,
         )
-        aggregate_report_by_variant[variant["name"]] = aggregate_report
         output_path = args.output_dir / variant["filename"]
         output_path.write_text(
             json.dumps(aggregate_report, ensure_ascii=False, indent=2),
@@ -411,19 +292,6 @@ def main() -> None:
             flush=True,
         )
 
-    write_page_summary(args.output_dir, variants, aggregate_report_by_variant)
-
-    if args.group_by:
-        write_grouped_reports(
-            output_dir=args.output_dir,
-            variants=variants,
-            page_reports_by_variant=page_reports_by_variant,
-            group_by=args.group_by,
-            coverage_threshold=args.coverage_threshold,
-            failure_example_count=args.failure_example_count,
-            unit_level=args.unit_level,
-        )
-
 
 if __name__ == "__main__":
     main()

evaluation_kit/evaluate_from_hf_fast.py

@@ -49,11 +49,7 @@ 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 (  # noqa: E402
-    annotation_boxes_from_hf_row,
-    write_grouped_reports,
-    write_page_summary,
-)
+from evaluate_from_hf import annotation_boxes_from_hf_row  # noqa: E402
 
 
 def parse_args() -> argparse.Namespace:
@@ -72,21 +68,10 @@ def parse_args() -> argparse.Namespace:
         default=None,
         help="Score only these page_ids (fast subset check). Omit to score all pages.",
     )
-    parser.add_argument(
-        "--group-by",
-        default=None,
-        help=(
-            "Also write a per-group breakdown, bucketing pages by this dataset "
-            "column (e.g. 'source'). Reports go to <output-dir>/by_<column>/<value>/ "
-            "plus a summary_by_<column>.json table."
-        ),
-    )
     return parser.parse_args()
 
 
-def load_annotations_only(
-    dataset: str, split: str, extra_columns: list[str] | None = None
-) -> list[dict[str, Any]]:
+def load_annotations_only(dataset: str, split: str) -> list[dict[str, Any]]:
     import pyarrow.parquet as pq
     from huggingface_hub import snapshot_download
 
@@ -96,25 +81,14 @@ def load_annotations_only(
     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")
-    columns = ["page_id", "annotations"]
-    for column in extra_columns or []:
-        if column not in columns:
-            available = pq.read_schema(parquet_files[0]).names
-            if column not in available:
-                raise SystemExit(
-                    f"--group-by {column!r}: column not in dataset ({', '.join(available)})"
-                )
-            columns.append(column)
-    table = pq.read_table(parquet_files, columns=columns)
+    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, extra_columns=[args.group_by] if args.group_by else None
-    )
+    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]
@@ -151,15 +125,14 @@ def main() -> None:
                 filters=filters,
                 unit_level=args.unit_level,
             )
-            page_report = {
-                "page_name": page_id,
-                "predictions_csv": str(predictions_csv),
-                "annotations_json": f"hf://{args.dataset}/{args.split}#{page_id}",
-                "report": report,
-            }
-            if args.group_by:
-                page_report["group"] = str(row[args.group_by])
-            page_reports_by_variant[variant["name"]].append(page_report)
+            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(
@@ -169,7 +142,6 @@ def main() -> None:
         )
 
     args.output_dir.mkdir(parents=True, exist_ok=True)
-    aggregate_report_by_variant: dict[str, dict[str, Any]] = {}
     for variant in variants:
         aggregate_report = aggregate_reports(
             page_reports=page_reports_by_variant[variant["name"]],
@@ -177,7 +149,6 @@ def main() -> None:
             failure_example_count=args.failure_example_count,
             unit_level=args.unit_level,
         )
-        aggregate_report_by_variant[variant["name"]] = aggregate_report
         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"]
@@ -187,19 +158,6 @@ def main() -> None:
             flush=True,
         )
 
-    write_page_summary(args.output_dir, variants, aggregate_report_by_variant)
-
-    if args.group_by:
-        write_grouped_reports(
-            output_dir=args.output_dir,
-            variants=variants,
-            page_reports_by_variant=page_reports_by_variant,
-            group_by=args.group_by,
-            coverage_threshold=args.coverage_threshold,
-            failure_example_count=args.failure_example_count,
-            unit_level=args.unit_level,
-        )
-
 
 if __name__ == "__main__":
     main()