Add EditJudge-Bench evaluation code

.gitignore

@@ -0,0 +1,5 @@
+.cache/
+__pycache__/
+*.egg-info/
+outputs/
+.venv/

README.md

@@ -0,0 +1,113 @@
+---
+pretty_name: EditJudge-Bench Evaluation Code
+tags:
+- benchmark
+- evaluation
+- vision-language-models
+- image-editing
+- vlm-as-a-judge
+---
+
+# EditJudge-Bench Evaluation Code
+
+This repository contains lightweight, anonymous evaluation utilities for the
+EditJudge-Bench dataset release. The code validates a local dataset snapshot, expands
+edit-level rows into verification triplets, and computes the AUROC metrics used
+to audit VLM-as-a-judge behaviour.
+
+Dataset URL: `https://huggingface.co/datasets/EDAnonSubmission/benchmark`
+
+## Install
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+## Dataset Layout
+
+The scripts expect a local dataset snapshot with:
+
+```text
+benchmark.parquet
+images/<sample_id>/before.jpg
+images/<sample_id>/after.jpg
+```
+
+Each parquet row is one edit pair. A positive verification triplet is created
+from `instruction_pos`; negative triplets are created from
+`instruction_neg_list` and `instruction_neg_types`.
+
+## Validate the Dataset
+
+```bash
+python scripts/validate_dataset.py \
+  --dataset-root /path/to/benchmark
+```
+
+The validator checks row count, image coverage, negative-instruction alignment,
+edit-type balance, and that image paths are portable and repo-relative.
+
+## Prediction Schema
+
+Prediction files may be CSV, JSONL, JSON, or Parquet. The simplest schema is:
+
+```text
+sample_id,example_type,negative_index,score
+```
+
+For positives, set `example_type=positive` and `negative_index=-1`. For negatives,
+set `example_type=negative` and use the index in `instruction_neg_list`.
+
+The scripts also accept `parquet_row_index` instead of `sample_id`, or an
+expanded table that already contains `label`, `edit_type`, `negative_type`, and
+`score`.
+
+## Compute Main Metrics
+
+```bash
+python scripts/compute_benchpress_metrics.py \
+  --dataset-root /path/to/benchmark \
+  --predictions /path/to/predictions.parquet \
+  --out-dir outputs/judge_name
+```
+
+Outputs:
+
+- `overall_metrics.csv`: global AUROC and macro edit-type AUROC.
+- `per_edit_type_auc.csv`: AUROC for each edit type.
+
+## Negative-Type Breakdown
+
+```bash
+python scripts/compute_negative_type_breakdown.py \
+  --dataset-root /path/to/benchmark \
+  --predictions /path/to/predictions.parquet \
+  --out-dir outputs/judge_name
+```
+
+Outputs:
+
+- `per_negative_type_auc.csv`
+- `semantic_vs_noedit_summary.csv`
+
+## Ground-Truth Salience Tables
+
+```bash
+python scripts/make_salience_tables.py \
+  --dataset-root /path/to/benchmark \
+  --predictions /path/to/predictions.parquet \
+  --out-dir outputs/judge_name \
+  --bins 5
+```
+
+This conditions no-edit rejection AUROC on saved Blender parameters such as
+shape delta, articulation delta, scale delta, movement distance, rotation angle,
+lighting magnitude, and camera changes.
+
+## Notes
+
+This code release evaluates judge scores; it does not run VLM inference. The
+paper's model-specific prompts and inference wrappers are implementation details
+around producing the prediction files consumed here.

benchpress_eval/__init__.py

@@ -0,0 +1,19 @@
+"""Small utilities for evaluating judges on the EditJudge-Bench dataset release."""
+
+from .data import expand_triplets, load_dataset, validate_dataset
+from .metrics import (
+    align_predictions,
+    compute_overall_metrics,
+    per_edit_type_auc,
+    per_negative_type_auc,
+)
+
+__all__ = [
+    "align_predictions",
+    "compute_overall_metrics",
+    "expand_triplets",
+    "load_dataset",
+    "per_edit_type_auc",
+    "per_negative_type_auc",
+    "validate_dataset",
+]

benchpress_eval/data.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+REQUIRED_COLUMNS = (
+    "sample_id",
+    "edit_type",
+    "before",
+    "after",
+    "instruction_pos",
+    "instruction_neg_list",
+    "instruction_neg_types",
+)
+
+PATH_COLUMNS = ("before", "after")
+
+
+def load_dataset(dataset_root: str | Path) -> pd.DataFrame:
+    dataset_root = Path(dataset_root)
+    parquet_path = dataset_root / "benchmark.parquet"
+    if not parquet_path.exists():
+        raise FileNotFoundError(f"Missing dataset parquet: {parquet_path}")
+    return pd.read_parquet(parquet_path)
+
+
+def as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, float) and np.isnan(value):
+        return []
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, (list, tuple)):
+        return list(value)
+    return [value]
+
+
+def parse_metadata(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+            return parsed if isinstance(parsed, dict) else {}
+        except json.JSONDecodeError:
+            return {}
+    return {}
+
+
+def expand_triplets(df: pd.DataFrame) -> pd.DataFrame:
+    """Expand edit-level rows into positive/negative verification triplets."""
+    rows: list[dict[str, Any]] = []
+    for row_index, row in df.reset_index(drop=True).iterrows():
+        sample_id = row.get("sample_id", f"row-{row_index:05d}")
+        base = {
+            "sample_id": sample_id,
+            "parquet_row_index": int(row.get("parquet_row_index", row_index)),
+            "edit_type": row["edit_type"],
+            "before": row["before"],
+            "after": row["after"],
+        }
+        rows.append(
+            {
+                **base,
+                "instruction": row["instruction_pos"],
+                "label": 1,
+                "ground_truth": True,
+                "example_type": "positive",
+                "negative_type": "positive",
+                "negative_index": -1,
+            }
+        )
+
+        negs = as_list(row["instruction_neg_list"])
+        neg_types = as_list(row["instruction_neg_types"])
+        if len(negs) != len(neg_types):
+            raise ValueError(f"Negative instruction/type length mismatch for {sample_id}")
+        for neg_index, (instruction, negative_type) in enumerate(zip(negs, neg_types)):
+            rows.append(
+                {
+                    **base,
+                    "instruction": instruction,
+                    "label": 0,
+                    "ground_truth": False,
+                    "example_type": "negative",
+                    "negative_type": str(negative_type),
+                    "negative_index": neg_index,
+                }
+            )
+    return pd.DataFrame(rows)
+
+
+def _is_portable_relative_path(value: Any) -> bool:
+    if value is None:
+        return False
+    path = Path(str(value))
+    return not path.is_absolute() and ".." not in path.parts
+
+
+def validate_dataset(dataset_root: str | Path, strict_core: bool = True) -> dict[str, Any]:
+    """Validate the public Hugging Face dataset layout."""
+    dataset_root = Path(dataset_root)
+    df = load_dataset(dataset_root)
+    report: dict[str, Any] = {
+        "row_count": int(len(df)),
+        "required_missing": [col for col in REQUIRED_COLUMNS if col not in df.columns],
+        "edit_type_counts": df["edit_type"].value_counts().sort_index().to_dict()
+        if "edit_type" in df.columns
+        else {},
+    }
+
+    before_exists = df["before"].map(lambda p: (dataset_root / str(p)).exists())
+    after_exists = df["after"].map(lambda p: (dataset_root / str(p)).exists())
+    report["before_paths_resolvable"] = int(before_exists.sum())
+    report["after_paths_resolvable"] = int(after_exists.sum())
+
+    length_matches = []
+    for _, row in df.iterrows():
+        length_matches.append(
+            len(as_list(row["instruction_neg_list"])) == len(as_list(row["instruction_neg_types"]))
+        )
+    report["negative_instruction_lengths_match"] = int(sum(length_matches))
+
+    non_portable_paths: dict[str, int] = {}
+    for col in PATH_COLUMNS:
+        if col in df.columns:
+            bad_count = int((~df[col].map(_is_portable_relative_path)).sum())
+            if bad_count:
+                non_portable_paths[col] = bad_count
+    report["non_portable_path_columns"] = non_portable_paths
+
+    dimensions: dict[str, int] = {}
+    for path_text in pd.concat([df["before"], df["after"]]).head(100):
+        path = dataset_root / str(path_text)
+        if path.exists():
+            with Image.open(path) as image:
+                key = f"{image.width}x{image.height}"
+                dimensions[key] = dimensions.get(key, 0) + 1
+    report["sampled_image_dimension_counts"] = dimensions
+
+    checks = [
+        not report["required_missing"],
+        report["before_paths_resolvable"] == len(df),
+        report["after_paths_resolvable"] == len(df),
+        report["negative_instruction_lengths_match"] == len(df),
+        not report["non_portable_path_columns"],
+    ]
+    if strict_core:
+        checks.extend(
+            [
+                len(df) == 1500,
+                set(report["edit_type_counts"].values()) == {150},
+            ]
+        )
+    report["passed"] = bool(all(checks))
+    return report

benchpress_eval/io.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+def read_table(path: str | Path) -> pd.DataFrame:
+    """Read a CSV, JSONL, JSON, or Parquet table."""
+    path = Path(path)
+    suffix = path.suffix.lower()
+    if suffix == ".parquet":
+        return pd.read_parquet(path)
+    if suffix == ".csv":
+        return pd.read_csv(path)
+    if suffix == ".jsonl":
+        return pd.read_json(path, lines=True)
+    if suffix == ".json":
+        return pd.read_json(path)
+    raise ValueError(f"Unsupported table format: {path}")
+
+
+def write_json(obj: dict[str, Any], path: str | Path) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(obj, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def write_csv(df: pd.DataFrame, path: str | Path) -> None:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(path, index=False)

benchpress_eval/metrics.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from .data import expand_triplets
+
+
+def auroc_safe(y_true: pd.Series | np.ndarray, y_score: pd.Series | np.ndarray) -> float:
+    """Rank-based AUROC with average ranks for ties."""
+    y = pd.Series(y_true).astype(float)
+    s = pd.to_numeric(pd.Series(y_score), errors="coerce")
+    mask = np.isfinite(y) & np.isfinite(s)
+    y = y[mask].astype(int)
+    s = s[mask].astype(float)
+    if y.nunique() < 2:
+        return float("nan")
+    n_pos = int((y == 1).sum())
+    n_neg = int((y == 0).sum())
+    if n_pos == 0 or n_neg == 0:
+        return float("nan")
+    ranks = s.rank(method="average")
+    pos_rank_sum = float(ranks[y == 1].sum())
+    return (pos_rank_sum - n_pos * (n_pos + 1) / 2.0) / (n_pos * n_neg)
+
+
+def _score_column(predictions: pd.DataFrame, requested: str | None) -> str:
+    if requested and requested in predictions.columns:
+        return requested
+    for candidate in ("score", "score_norm", "raw_score"):
+        if candidate in predictions.columns:
+            return candidate
+    raise ValueError("Predictions must contain a score column, e.g. score or score_norm.")
+
+
+def _standardize_negative_index(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    if "negative_index" in df.columns:
+        df["negative_index"] = pd.to_numeric(df["negative_index"], errors="coerce").fillna(-1).astype(int)
+    return df
+
+
+def align_predictions(
+    dataset_df: pd.DataFrame,
+    predictions: pd.DataFrame,
+    score_col: str | None = None,
+) -> pd.DataFrame:
+    """Align model scores to EditJudge-Bench triplets.
+
+    Supported prediction schemas:
+    1. Expanded rows with label/edit_type/negative_type/score already present.
+    2. Rows keyed by sample_id or parquet_row_index plus example_type and negative_index.
+    3. Rows keyed by sample_id or parquet_row_index plus instruction text.
+    """
+    predictions = _standardize_negative_index(predictions)
+    score_col = _score_column(predictions, score_col)
+    predictions = predictions.rename(columns={score_col: "score"}).copy()
+    predictions["score"] = pd.to_numeric(predictions["score"], errors="coerce")
+
+    expanded_cols = {"label", "edit_type", "negative_type", "score"}
+    if expanded_cols.issubset(predictions.columns):
+        out = predictions.copy()
+        if "ground_truth" not in out.columns:
+            out["ground_truth"] = out["label"].astype(bool)
+        return out
+
+    triplets = expand_triplets(dataset_df)
+    key = "sample_id" if "sample_id" in predictions.columns else "parquet_row_index"
+    if key not in predictions.columns:
+        raise ValueError("Predictions must contain sample_id or parquet_row_index.")
+
+    if {"example_type", "negative_index"}.issubset(predictions.columns):
+        join_cols = [key, "example_type", "negative_index"]
+    elif "instruction" in predictions.columns:
+        join_cols = [key, "instruction"]
+    else:
+        raise ValueError(
+            "Predictions must include either example_type+negative_index or instruction."
+        )
+
+    keep_cols = join_cols + ["score"] + [
+        col for col in ("raw_score", "raw_output", "model", "method") if col in predictions.columns
+    ]
+    merged = triplets.merge(predictions[keep_cols], on=join_cols, how="left", validate="one_to_one")
+    missing = int(merged["score"].isna().sum())
+    if missing:
+        raise ValueError(f"Could not align {missing} triplets to prediction scores.")
+    return merged
+
+
+def compute_overall_metrics(aligned: pd.DataFrame) -> pd.DataFrame:
+    per_edit = per_edit_type_auc(aligned)
+    row: dict[str, Any] = {
+        "global_auc": auroc_safe(aligned["label"], aligned["score"]),
+        "macro_edit_auc": per_edit["auc"].mean(),
+        "n_triplets": int(len(aligned)),
+        "n_edits": int(aligned["sample_id"].nunique()) if "sample_id" in aligned.columns else np.nan,
+    }
+    return pd.DataFrame([row])
+
+
+def per_edit_type_auc(aligned: pd.DataFrame) -> pd.DataFrame:
+    rows = []
+    for edit_type, group in aligned.groupby("edit_type", sort=True):
+        rows.append(
+            {
+                "edit_type": edit_type,
+                "auc": auroc_safe(group["label"], group["score"]),
+                "n_triplets": int(len(group)),
+                "n_edits": int(group["sample_id"].nunique()) if "sample_id" in group.columns else np.nan,
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def per_negative_type_auc(aligned: pd.DataFrame) -> pd.DataFrame:
+    positives = aligned[aligned["label"] == 1]
+    negatives = aligned[aligned["label"] == 0]
+    rows = []
+    for negative_type, neg_group in negatives.groupby("negative_type", sort=True):
+        group = pd.concat([positives, neg_group], ignore_index=True)
+        rows.append(
+            {
+                "negative_type": negative_type,
+                "auc": auroc_safe(group["label"], group["score"]),
+                "n_negative_triplets": int(len(neg_group)),
+                "n_positive_triplets": int(len(positives)),
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def semantic_vs_noedit_summary(per_negative: pd.DataFrame) -> pd.DataFrame:
+    semantic_names = {"counterfactual", "cross_type", "wrong_object"}
+    semantic = per_negative[per_negative["negative_type"].isin(semantic_names)]
+    no_edit = per_negative[per_negative["negative_type"].eq("no_edit")]
+    return pd.DataFrame(
+        [
+            {
+                "semantic_auc": semantic["auc"].mean(),
+                "no_edit_auc": no_edit["auc"].mean(),
+                "semantic_negative_types": ",".join(sorted(semantic["negative_type"].unique())),
+            }
+        ]
+    )

benchpress_eval/salience.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+import numpy as np
+import pandas as pd
+
+from .data import parse_metadata
+from .metrics import auroc_safe
+
+
+@dataclass(frozen=True)
+class ParameterSpec:
+    name: str
+    edit_types: tuple[str, ...]
+    column_candidates: tuple[str, ...]
+    metadata_candidates: tuple[str, ...] = ()
+    transform: Callable[[pd.Series], pd.Series] | None = None
+
+
+def _abs(series: pd.Series) -> pd.Series:
+    return pd.to_numeric(series, errors="coerce").abs()
+
+
+def _scale_delta(series: pd.Series) -> pd.Series:
+    return (pd.to_numeric(series, errors="coerce") - 1.0).abs()
+
+
+PARAMETERS = (
+    ParameterSpec(
+        "shape_delta",
+        ("shape",),
+        ("meta.delta", "shape_delta", "delta_theta"),
+        ("delta", "shape_delta", "delta_theta"),
+        _abs,
+    ),
+    ParameterSpec(
+        "articulation_delta",
+        ("articulation",),
+        ("meta.delta", "articulation_delta", "delta_psi"),
+        ("delta", "articulation_delta", "delta_psi"),
+        _abs,
+    ),
+    ParameterSpec(
+        "scale_delta",
+        ("scale",),
+        ("meta.factor", "scale_factor", "factor"),
+        ("factor", "scale_factor"),
+        _scale_delta,
+    ),
+    ParameterSpec(
+        "movement_distance",
+        ("movement",),
+        ("meta.distance_moved", "movement_distance", "distance_moved"),
+        ("distance_moved", "movement_distance"),
+        None,
+    ),
+    ParameterSpec(
+        "rotation_angle",
+        ("rotation",),
+        ("meta.angle_deg", "rotation_angle_deg", "angle_deg"),
+        ("angle_deg", "rotation_angle_deg"),
+        _abs,
+    ),
+    ParameterSpec(
+        "camera_position_delta",
+        ("camera",),
+        ("meta.position_delta", "camera_position_delta", "position_delta"),
+        ("position_delta", "camera_position_delta"),
+        None,
+    ),
+    ParameterSpec(
+        "camera_focal_delta",
+        ("camera",),
+        ("meta.delta_lens", "focal_delta", "delta_f"),
+        ("delta_lens", "focal_delta", "delta_f"),
+        _abs,
+    ),
+    ParameterSpec(
+        "lighting_magnitude",
+        ("lighting",),
+        ("meta.magnitude", "lighting_magnitude"),
+        ("magnitude", "lighting_magnitude"),
+        None,
+    ),
+    ParameterSpec(
+        "removal_visibility",
+        ("removal",),
+        ("meta.visibility", "visibility"),
+        ("visibility",),
+        None,
+    ),
+)
+
+
+def _metadata_series(df: pd.DataFrame, candidates: tuple[str, ...]) -> pd.Series:
+    if "metadata" not in df.columns:
+        return pd.Series(np.nan, index=df.index)
+    values = []
+    for value in df["metadata"]:
+        metadata = parse_metadata(value)
+        found = np.nan
+        for key in candidates:
+            if key in metadata:
+                found = metadata[key]
+                break
+        values.append(found)
+    return pd.Series(values, index=df.index)
+
+
+def parameter_values(dataset_df: pd.DataFrame, spec: ParameterSpec) -> pd.Series:
+    values = pd.Series(np.nan, index=dataset_df.index, dtype="float64")
+    for column in spec.column_candidates:
+        if column in dataset_df.columns:
+            values = pd.to_numeric(dataset_df[column], errors="coerce")
+            break
+    if values.isna().all() and spec.metadata_candidates:
+        values = pd.to_numeric(_metadata_series(dataset_df, spec.metadata_candidates), errors="coerce")
+    if spec.transform:
+        values = spec.transform(values)
+    return values
+
+
+def compute_noedit_salience(
+    dataset_df: pd.DataFrame,
+    aligned_predictions: pd.DataFrame,
+    n_bins: int = 5,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Compute no-edit AUROC stratified by ground-truth parameter magnitude."""
+    id_col = "sample_id" if "sample_id" in aligned_predictions.columns else "parquet_row_index"
+    base = dataset_df.reset_index(drop=True).copy()
+    if "parquet_row_index" not in base.columns:
+        base["parquet_row_index"] = base.index
+
+    usable = aligned_predictions[
+        (aligned_predictions["label"].eq(1)) | (aligned_predictions["negative_type"].eq("no_edit"))
+    ].copy()
+    rows = []
+    summary = []
+
+    for spec in PARAMETERS:
+        mask = base["edit_type"].isin(spec.edit_types)
+        param = parameter_values(base, spec)
+        param_df = base.loc[mask, [id_col if id_col in base.columns else "parquet_row_index"]].copy()
+        param_df["parameter_value"] = param[mask].values
+        param_df = param_df.dropna(subset=["parameter_value"])
+        if param_df["parameter_value"].nunique() < 2:
+            continue
+
+        try:
+            bins = pd.qcut(param_df["parameter_value"], q=n_bins, duplicates="drop")
+        except ValueError:
+            continue
+        param_df["bin"] = bins.astype(str)
+        merged = usable.merge(param_df, on=id_col, how="inner")
+        if merged.empty:
+            continue
+
+        for bin_label, group in merged.groupby("bin", sort=False):
+            rows.append(
+                {
+                    "parameter": spec.name,
+                    "edit_types": ",".join(spec.edit_types),
+                    "bin": bin_label,
+                    "auc": auroc_safe(group["label"], group["score"]),
+                    "n_triplets": int(len(group)),
+                    "n_edits": int(group[id_col].nunique()),
+                    "value_min": float(group["parameter_value"].min()),
+                    "value_max": float(group["parameter_value"].max()),
+                }
+            )
+
+        summary.append(
+            {
+                "parameter": spec.name,
+                "edit_types": ",".join(spec.edit_types),
+                "spearman_auc_vs_bin_midpoint": _bin_spearman(rows, spec.name),
+                "n_bins": int(param_df["bin"].nunique()),
+                "n_edits": int(param_df[id_col].nunique()),
+            }
+        )
+
+    return pd.DataFrame(rows), pd.DataFrame(summary)
+
+
+def _bin_spearman(rows: list[dict], parameter_name: str) -> float:
+    subset = pd.DataFrame([row for row in rows if row["parameter"] == parameter_name])
+    if len(subset) < 2:
+        return float("nan")
+    mids = (subset["value_min"] + subset["value_max"]) / 2.0
+    x = pd.to_numeric(mids, errors="coerce")
+    y = pd.to_numeric(subset["auc"], errors="coerce")
+    mask = x.notna() & y.notna()
+    if mask.sum() < 2:
+        return float("nan")
+    x_rank = x[mask].rank(method="average")
+    y_rank = y[mask].rank(method="average")
+    if x_rank.nunique() < 2 or y_rank.nunique() < 2:
+        return float("nan")
+    return float(x_rank.corr(y_rank))

examples/README.md

@@ -0,0 +1,12 @@
+# Example prediction file
+
+`example_predictions.csv` is a tiny synthetic score file for smoke-testing the metric
+scripts. It is not a model result. Real judge outputs can use the same schema:
+
+```text
+sample_id,example_type,negative_index,score
+```
+
+For positive triplets, use `example_type=positive` and `negative_index=-1`.
+For negative triplets, use `example_type=negative` and the index of the
+corresponding entry in `instruction_neg_list`.

pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "benchpress_eval"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+  "pandas>=2.0",
+  "pyarrow>=14.0",
+  "numpy>=1.23",
+  "Pillow>=10.0",
+]

requirements.txt

@@ -0,0 +1,4 @@
+pandas>=2.0
+pyarrow>=14.0
+numpy>=1.23
+Pillow>=10.0

scripts/compute_benchpress_metrics.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from benchpress_eval.data import load_dataset
+from benchpress_eval.io import read_table, write_csv
+from benchpress_eval.metrics import align_predictions, compute_overall_metrics, per_edit_type_auc
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Compute EditJudge-Bench AUROC metrics for one judge run.")
+    parser.add_argument("--dataset-root", required=True, help="Folder containing benchmark.parquet.")
+    parser.add_argument("--predictions", required=True, help="CSV/JSONL/Parquet prediction file.")
+    parser.add_argument("--out-dir", required=True, help="Directory for metric CSV outputs.")
+    parser.add_argument("--score-col", default=None, help="Prediction score column; auto-detected by default.")
+    args = parser.parse_args()
+
+    out_dir = Path(args.out_dir)
+    dataset = load_dataset(args.dataset_root)
+    predictions = read_table(args.predictions)
+    aligned = align_predictions(dataset, predictions, score_col=args.score_col)
+
+    write_csv(compute_overall_metrics(aligned), out_dir / "overall_metrics.csv")
+    write_csv(per_edit_type_auc(aligned), out_dir / "per_edit_type_auc.csv")
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_negative_type_breakdown.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from benchpress_eval.data import load_dataset
+from benchpress_eval.io import read_table, write_csv
+from benchpress_eval.metrics import align_predictions, per_negative_type_auc, semantic_vs_noedit_summary
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Compute AUROC by negative instruction family.")
+    parser.add_argument("--dataset-root", required=True)
+    parser.add_argument("--predictions", required=True)
+    parser.add_argument("--out-dir", required=True)
+    parser.add_argument("--score-col", default=None)
+    args = parser.parse_args()
+
+    out_dir = Path(args.out_dir)
+    dataset = load_dataset(args.dataset_root)
+    predictions = read_table(args.predictions)
+    aligned = align_predictions(dataset, predictions, score_col=args.score_col)
+    per_negative = per_negative_type_auc(aligned)
+
+    write_csv(per_negative, out_dir / "per_negative_type_auc.csv")
+    write_csv(semantic_vs_noedit_summary(per_negative), out_dir / "semantic_vs_noedit_summary.csv")
+
+
+if __name__ == "__main__":
+    main()

scripts/make_salience_tables.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from benchpress_eval.data import load_dataset
+from benchpress_eval.io import read_table, write_csv
+from benchpress_eval.metrics import align_predictions
+from benchpress_eval.salience import compute_noedit_salience
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Compute no-edit AUROC stratified by ground-truth edit parameters."
+    )
+    parser.add_argument("--dataset-root", required=True)
+    parser.add_argument("--predictions", required=True)
+    parser.add_argument("--out-dir", required=True)
+    parser.add_argument("--score-col", default=None)
+    parser.add_argument("--bins", type=int, default=5)
+    args = parser.parse_args()
+
+    out_dir = Path(args.out_dir)
+    dataset = load_dataset(args.dataset_root)
+    predictions = read_table(args.predictions)
+    aligned = align_predictions(dataset, predictions, score_col=args.score_col)
+    by_bin, summary = compute_noedit_salience(dataset, aligned, n_bins=args.bins)
+
+    write_csv(by_bin, out_dir / "salience_by_parameter_bin.csv")
+    write_csv(summary, out_dir / "salience_summary.csv")
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import argparse
+import json
+
+from benchpress_eval.data import validate_dataset
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Validate a local EditJudge-Bench dataset snapshot.")
+    parser.add_argument("--dataset-root", required=True, help="Folder containing benchmark.parquet.")
+    parser.add_argument("--no-strict-core", action="store_true", help="Do not require the 1,500-row core release.")
+    args = parser.parse_args()
+
+    report = validate_dataset(args.dataset_root, strict_core=not args.no_strict_core)
+    print(json.dumps(report, indent=2, sort_keys=True))
+    if not report["passed"]:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()