| """Shared helpers for VisSlideBench evaluation. |
| |
| The judge is any OpenAI-compatible chat endpoint. Configure it with |
| environment variables; nothing is hard-coded: |
| |
| export OPENAI_API_KEY=... |
| export OPENAI_BASE_URL=... # optional, defaults to the official endpoint |
| export VISSLIDEBENCH_JUDGE=gpt-4.1 # optional |
| """ |
|
|
| import base64 |
| import json |
| import os |
| import re |
| import time |
| from io import BytesIO |
| from pathlib import Path |
|
|
| from PIL import Image |
|
|
| BENCH_ROOT = Path(__file__).resolve().parents[1] |
| PROMPT_DIR = Path(__file__).resolve().parent / "prompts" |
| JUDGE_MODEL = os.environ.get("VISSLIDEBENCH_JUDGE", "gpt-4.1") |
| MAX_RETRIES = 3 |
|
|
|
|
| def load_jsonl(path): |
| with open(path, "r", encoding="utf-8") as f: |
| return [json.loads(line) for line in f if line.strip()] |
|
|
|
|
| def write_jsonl(path, rows): |
| Path(path).parent.mkdir(parents=True, exist_ok=True) |
| with open(path, "w", encoding="utf-8") as f: |
| for row in rows: |
| f.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
|
|
| def load_prompt(name): |
| return (PROMPT_DIR / name).read_text(encoding="utf-8") |
|
|
|
|
| def bench_path(rel): |
| return str(BENCH_ROOT / rel) |
|
|
|
|
| def get_client(): |
| from openai import OpenAI |
|
|
| return OpenAI() |
|
|
|
|
| def image_to_data_uri(path, max_size=1600): |
| """JPEG-encode an image with its long side capped at `max_size` pixels.""" |
| img = Image.open(path).convert("RGB") |
| w, h = img.size |
| if max(w, h) > max_size: |
| r = max_size / max(w, h) |
| img = img.resize((int(w * r), int(h * r)), Image.LANCZOS) |
| buf = BytesIO() |
| img.save(buf, format="JPEG", quality=85) |
| return "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("utf-8") |
|
|
|
|
| def image_part(path): |
| return {"type": "image_url", "image_url": {"url": image_to_data_uri(path), "detail": "high"}} |
|
|
|
|
| def text_part(text): |
| return {"type": "text", "text": text} |
|
|
|
|
| def parse_json_block(text): |
| """Return the first JSON object or array found in a model reply.""" |
| text = text.strip() |
| m = re.search(r"```(?:json)?\s*\n(.*?)```", text, re.DOTALL) |
| if m: |
| text = m.group(1).strip() |
| else: |
| starts = [i for i in (text.find("{"), text.find("[")) if i >= 0] |
| if starts: |
| s = min(starts) |
| e = max(text.rfind("}"), text.rfind("]")) |
| if e > s: |
| text = text[s : e + 1] |
| return json.loads(text) |
|
|
|
|
| def chat(client, system, user_content, temperature, max_tokens): |
| """Call the judge with retries; returns the parsed JSON reply.""" |
| err = None |
| for attempt in range(1, MAX_RETRIES + 1): |
| try: |
| resp = client.chat.completions.create( |
| model=JUDGE_MODEL, |
| messages=([{"role": "system", "content": system}] if system else []) |
| + [{"role": "user", "content": user_content}], |
| temperature=temperature, |
| max_tokens=max_tokens, |
| ) |
| return parse_json_block(resp.choices[0].message.content) |
| except Exception as e: |
| err = e |
| if attempt < MAX_RETRIES: |
| time.sleep(2 ** attempt) |
| raise RuntimeError(f"judge call failed after {MAX_RETRIES} attempts: {err}") |
|
|
|
|
| def mean(xs): |
| xs = list(xs) |
| return sum(xs) / len(xs) if xs else None |
|
|
|
|
| def subdimension_mean(result): |
| """Unweighted mean of the per-dimension `score` fields of a judge reply. |
| |
| The judge also returns an `overall_score`; it is not used. |
| """ |
| scores = [v["score"] for v in result.values() if isinstance(v, dict) and "score" in v] |
| return mean(float(s) for s in scores) |
|
|
