| """The scorer: every benchmark number, computed from the artifacts alone. |
| |
| python -m scoring # from the vybbench1.0/ directory |
| |
| Reads ``data/`` (the cases), ``starts/`` (each edit's shared starting design), |
| ``outputs/`` (every model's generations), and ``verdicts/`` (the recorded |
| judge verdicts), and prints the three score tables. No model APIs and no keys: |
| the one non-deterministic step, the edit judge, ships as recorded verdicts. |
| |
| The benchmark runner scores with these same functions, so the published scorer |
| is the code that produced the numbers. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import statistics |
| from concurrent.futures import ProcessPoolExecutor |
| from functools import partial |
| from pathlib import Path |
|
|
| from PIL import Image |
|
|
| from . import colors, edits, fonts |
| from .cases import color_cases, edit_cases, font_cases |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| OUTPUTS = ROOT / "outputs" |
| VERDICTS = ROOT / "verdicts" |
| ARMS = ("ours", "gpt", "muse", "recraft") |
|
|
|
|
| def slug(case_id: str) -> str: |
| return case_id.replace("/", "_").replace("#", "").lower() |
|
|
|
|
| def _attempt_paths(arm: str, subtest: str, case_id: str) -> list[Path]: |
| directory = OUTPUTS / arm / subtest / slug(case_id) |
| return sorted(directory.glob("a*.png")) if directory.is_dir() else [] |
|
|
|
|
| def _percentiles(values: list[float], points: tuple[int, ...]) -> dict: |
| if not values: |
| return {} |
| ranked = sorted(values) |
| out = {"mean": statistics.fmean(ranked), "median": statistics.median(ranked)} |
| for p in points: |
| out[f"p{p}"] = ranked[min(len(ranked) - 1, int(round(p / 100 * (len(ranked) - 1))))] |
| return out |
|
|
|
|
| def _font_case_ious(case, arms: tuple[str, ...]) -> dict: |
| """One case's per-arm attempt IoUs; alignment search is CPU-heavy, so |
| score_fonts fans cases out over processes.""" |
| reference = Image.open(ROOT / "references" / f"{slug(case.case_id)}.png") |
| components = fonts.max_ink_components(case.word) |
| out = {} |
| for arm in arms: |
| ious = [ |
| 1.0 - result.mismatch_fraction |
| for path in _attempt_paths(arm, "fonts", case.case_id) |
| if (result := fonts.font_mismatch( |
| reference, Image.open(path), components)).valid |
| ] |
| if ious: |
| out[arm] = ious |
| return out |
|
|
|
|
| def score_fonts(arms: tuple[str, ...] = ARMS) -> dict: |
| """Per-arm IoU distribution over every scored attempt, plus the recorded |
| measurement noise floor over the same word set.""" |
| cases = font_cases() |
| with ProcessPoolExecutor() as pool: |
| case_scores = list(pool.map(partial(_font_case_ious, arms=arms), cases)) |
| per_arm = { |
| arm: [iou for scores in case_scores for iou in scores.get(arm, [])] |
| for arm in arms |
| } |
| summary = {arm: _percentiles(vals, (20, 10, 5)) for arm, vals in per_arm.items()} |
| summary["noise_floor"] = _percentiles( |
| [1.0 - case.noise_floor for case in cases], (20, 10, 5), |
| ) |
| return summary |
|
|
|
|
| def score_colors(arms: tuple[str, ...] = ARMS) -> dict: |
| """Per-arm max-channel error distribution over every scored attempt.""" |
| per_arm: dict = {arm: [] for arm in arms} |
| for case in color_cases(): |
| for arm in arms: |
| per_arm[arm] += [ |
| float(result.channel_error) |
| for path in _attempt_paths(arm, "colors", case.case_id) |
| if (result := colors.color_error(Image.open(path), case.hex)).valid |
| ] |
| return {arm: _percentiles(vals, (80, 90, 95)) for arm, vals in per_arm.items()} |
|
|
|
|
| def score_edits(arms: tuple[str, ...] = ARMS) -> dict: |
| """Two numbers per arm, each over every generation: the whole-image change, |
| and the rate at which the judge accepted the requested change as made.""" |
| change: dict = {arm: [] for arm in arms} |
| attempts: dict = {arm: [] for arm in arms} |
| for case in edit_cases(): |
| start = Image.open(ROOT / case.start_png) |
| for arm in arms: |
| change[arm] += [ |
| edits.whole_change(start, Image.open(path)) |
| for path in _attempt_paths(arm, "edits", case.design_id) |
| ] |
| attempts[arm] += [ |
| json.loads(path.read_text())["satisfied"] |
| for path in sorted( |
| VERDICTS.glob(f"{slug(case.design_id)}_{arm}_a*.json") |
| ) |
| ] |
| summary = {} |
| for arm in arms: |
| summary[arm] = { |
| **_percentiles(change[arm], (80, 90, 95)), |
| "satisfied_rate": ( |
| statistics.fmean(attempts[arm]) if attempts[arm] else None |
| ), |
| } |
| return summary |
|
|
|
|
| def print_summary(label: str, summary: dict) -> None: |
| print(f"\n=== {label} ===") |
| for arm, stats in summary.items(): |
| line = " ".join( |
| f"{key}={value:.4f}" if isinstance(value, float) else f"{key}={value}" |
| for key, value in stats.items() |
| ) |
| print(f" {arm:12s} {line}") |
|
|
|
|
| def main() -> None: |
| print_summary("fonts (IoU, higher is better)", score_fonts()) |
| print_summary("colors (max channel error, lower is better)", score_colors()) |
| print_summary("edits (fraction changed, lower is better)", score_edits()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
