Datasets:
File size: 5,260 Bytes
bd00f85 | 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 | """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()
|