| |
| """Evaluate a GPT model on PhysCount with the paper's independent-QA prompt.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import io |
| import json |
| import os |
| import re |
| import threading |
| import time |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from functools import lru_cache |
| from pathlib import Path |
|
|
| from openai import OpenAI |
| from PIL import Image, ImageOps |
|
|
|
|
| PROMPT = """Answer the following counting question about this image. Carefully distinguish |
| visual appearances from physical entities, including appearances formed by |
| reflections or seen through glass, and use appearance-entity correspondences |
| when required by the question. Follow the counting target specified in the |
| question. Return exactly one non-negative integer, with no labels or prose. |
| |
| Question: {question}""" |
|
|
| INTEGER_RE = re.compile(r"^\s*(\d+)\s*$") |
| MAX_VALID_COUNT = 10_000 |
| _CLIENT_LOCAL = threading.local() |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--data-root", type=Path, default=Path(__file__).parents[1]) |
| parser.add_argument("--model", required=True, help="OpenAI API model identifier") |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument( |
| "--reasoning-effort", |
| required=True, |
| choices=("none", "low", "medium", "high", "xhigh"), |
| help="Use the strongest level supported by the selected model", |
| ) |
| parser.add_argument("--max-output-tokens", type=int, default=32768) |
| parser.add_argument("--temperature", type=float) |
| parser.add_argument("--top-p", type=float) |
| parser.add_argument("--long-edge", type=int, default=4096) |
| parser.add_argument("--workers", type=int, default=4) |
| parser.add_argument("--retries", type=int, default=3) |
| parser.add_argument("--limit", type=int) |
| return parser.parse_args() |
|
|
|
|
| def client() -> OpenAI: |
| if not hasattr(_CLIENT_LOCAL, "client"): |
| _CLIENT_LOCAL.client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY")) |
| return _CLIENT_LOCAL.client |
|
|
|
|
| @lru_cache(maxsize=16) |
| def prepare_image(path_text: str, long_edge: int) -> tuple[str, list[int], list[int]]: |
| path = Path(path_text) |
| with Image.open(path) as opened: |
| original_size = list(opened.size) |
| image = ImageOps.exif_transpose(opened) |
| if max(image.size) <= long_edge: |
| payload = path.read_bytes() |
| suffix = path.suffix.lower() |
| mime = "image/png" if suffix == ".png" else "image/jpeg" |
| sent_size = list(image.size) |
| else: |
| scale = long_edge / max(image.size) |
| sent_size = [round(image.width * scale), round(image.height * scale)] |
| image = image.convert("RGB").resize(tuple(sent_size), Image.Resampling.LANCZOS) |
| buffer = io.BytesIO() |
| image.save(buffer, format="JPEG", quality=95, subsampling=0) |
| payload = buffer.getvalue() |
| mime = "image/jpeg" |
| encoded = base64.b64encode(payload).decode("ascii") |
| return f"data:{mime};base64,{encoded}", original_size, sent_size |
|
|
|
|
| def parse_prediction(text: str) -> tuple[int | None, bool]: |
| match = INTEGER_RE.fullmatch(text) |
| if match is None: |
| return None, False |
| value = int(match.group(1)) |
| if value >= MAX_VALID_COUNT: |
| return None, False |
| return value, True |
|
|
|
|
| def evaluate_one(row: dict, args: argparse.Namespace) -> dict: |
| image_path = (args.data_root / row["image"]).resolve() |
| image_url, original_size, sent_size = prepare_image( |
| str(image_path), args.long_edge |
| ) |
| request = { |
| "model": args.model, |
| "input": [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "input_image", "image_url": image_url}, |
| { |
| "type": "input_text", |
| "text": PROMPT.format(question=row["question"]), |
| }, |
| ], |
| } |
| ], |
| "max_output_tokens": args.max_output_tokens, |
| } |
| if args.reasoning_effort != "none": |
| request["reasoning"] = {"effort": args.reasoning_effort} |
| if args.temperature is not None: |
| request["temperature"] = args.temperature |
| if args.top_p is not None: |
| request["top_p"] = args.top_p |
|
|
| last_error = None |
| for attempt in range(args.retries): |
| started = time.monotonic() |
| try: |
| response = client().responses.create(**request) |
| raw_output = response.output_text |
| prediction, valid = parse_prediction(raw_output) |
| return { |
| "question_id": row["question_id"], |
| "group_id": row["group_id"], |
| "model": args.model, |
| "prediction": prediction, |
| "valid": valid, |
| "raw_output": raw_output, |
| "original_size": original_size, |
| "sent_size": sent_size, |
| "elapsed_seconds": round(time.monotonic() - started, 3), |
| } |
| except Exception as exc: |
| last_error = f"{type(exc).__name__}: {exc}" |
| if attempt + 1 < args.retries: |
| time.sleep(2**attempt) |
| return { |
| "question_id": row["question_id"], |
| "group_id": row["group_id"], |
| "model": args.model, |
| "prediction": None, |
| "valid": False, |
| "raw_output": "", |
| "original_size": original_size, |
| "sent_size": sent_size, |
| "error": last_error, |
| } |
|
|
|
|
| def read_jsonl(path: Path) -> list[dict]: |
| with path.open("r", encoding="utf-8") as handle: |
| return [json.loads(line) for line in handle if line.strip()] |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| if not os.environ.get("OPENAI_API_KEY"): |
| raise SystemExit("OPENAI_API_KEY is not set") |
|
|
| questions = read_jsonl(args.data_root / "data" / "questions.jsonl") |
| if args.limit is not None: |
| questions = questions[: args.limit] |
|
|
| completed: set[str] = set() |
| if args.output.exists(): |
| completed = {row["question_id"] for row in read_jsonl(args.output)} |
| pending = [row for row in questions if row["question_id"] not in completed] |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
|
|
| with args.output.open("a", encoding="utf-8", newline="\n") as handle: |
| with ThreadPoolExecutor(max_workers=args.workers) as executor: |
| futures = {executor.submit(evaluate_one, row, args): row for row in pending} |
| for index, future in enumerate(as_completed(futures), start=1): |
| result = future.result() |
| handle.write(json.dumps(result, ensure_ascii=False) + "\n") |
| handle.flush() |
| print( |
| f"[{index}/{len(pending)}] {result['question_id']} " |
| f"prediction={result['prediction']} valid={result['valid']}", |
| flush=True, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
