Datasets:
Formats:
parquet
Languages:
English
Size:
100K - 1M
ArXiv:
Tags:
vision-language-models
decision-trees
hierarchical-reasoning
structured-reasoning
vlm-evaluation
License:
| """ | |
| Minimal MYOPIA evaluation harness. | |
| Runs a vision-language model behind any OpenAI-compatible chat endpoint on one | |
| MYOPIA split, either zero-shot or by walking the released decision tree one | |
| question at a time, and scores the result. Prompts, answer parsing and image | |
| encoding follow the paper's primary condition (no history, no descriptions). | |
| # tree-based inference on GTSRB with GPT-4o via OpenRouter | |
| export OPENROUTER_API_KEY=... | |
| python evaluate.py run --dataset gtsrb --method tree \ | |
| --model openai/gpt-4o --base-url https://openrouter.ai/api/v1 \ | |
| --api-key-env OPENROUTER_API_KEY --out gtsrb_tree_gpt4o.jsonl | |
| # accuracy of a predictions file | |
| python evaluate.py score gtsrb_tree_gpt4o.jsonl | |
| `--source` is either a local copy of the benchmark (default: the folder this | |
| script ships in) or a Hugging Face dataset id. Runs resume: image ids already | |
| present in `--out` are skipped. | |
| """ | |
| import argparse | |
| import base64 | |
| import io | |
| import json | |
| import os | |
| import re | |
| import time | |
| from pathlib import Path | |
| DATASET_NAMES = {"gtsrb": "GTSRB", "mnist": "MNIST", "cifar10": "CIFAR-10", "mscoco": "MSCOCO"} | |
| LOCAL_ROOT = Path(__file__).resolve().parent.parent | |
| # ----------------------------------------------------------------- loading | |
| def resolve(source, filename): | |
| """Path to `filename` inside a local benchmark copy or a Hub dataset repo.""" | |
| if Path(source).is_dir(): | |
| return Path(source) / filename | |
| from huggingface_hub import hf_hub_download | |
| return Path(hf_hub_download(source, filename, repo_type="dataset")) | |
| def load_split(source, key): | |
| from datasets import load_dataset | |
| return load_dataset("parquet", data_files=str(resolve(source, f"data/{key}/test.parquet")), split="train") | |
| def load_json(source, filename): | |
| return json.loads(resolve(source, filename).read_text()) | |
| def encode_image(example): | |
| """Base64 JPEG, as in the paper's harness. MSCOCO images are fetched by URL.""" | |
| from PIL import Image | |
| image = example["image"] | |
| if image is None: | |
| import requests | |
| response = requests.get(example["image_url"], timeout=60) | |
| response.raise_for_status() | |
| image = Image.open(io.BytesIO(response.content)) | |
| buf = io.BytesIO() | |
| image.convert("RGB").save(buf, format="JPEG") | |
| return base64.b64encode(buf.getvalue()).decode("utf-8") | |
| # --------------------------------------------------------------- inference | |
| class Model: | |
| def __init__(self, model, base_url, api_key, temperature, max_tokens): | |
| from openai import OpenAI | |
| self.client = OpenAI(base_url=base_url, api_key=api_key) | |
| self.model = model | |
| self.temperature = temperature | |
| self.max_tokens = max_tokens | |
| def ask(self, text, image_b64): | |
| completion = self.client.chat.completions.create( | |
| model=self.model, | |
| temperature=self.temperature, | |
| max_tokens=self.max_tokens, | |
| messages=[{"role": "user", "content": [ | |
| {"type": "text", "text": text}, | |
| {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}, | |
| ]}], | |
| ) | |
| return completion.choices[0].message.content or "" | |
| def zero_shot(model, image_b64, prompt_template, class_names): | |
| class_names_str = ", ".join(f"{i}: {class_names[str(i)]}" for i in sorted(int(k) for k in class_names)) | |
| response = model.ask(prompt_template.replace("{class_names_str}", class_names_str), image_b64) | |
| # First integer in the response; -1 if absent or not a valid class id. | |
| match = re.search(r"^\D*(\d+)", response) | |
| if match and str(int(match.group(1))) in class_names: | |
| return int(match.group(1)), response | |
| return -1, response | |
| def tree_walk(model, image_b64, tree, sleep): | |
| """Ask each node's question until a leaf is reached; -1 if an answer cannot be parsed.""" | |
| node, path = tree["root"], [] | |
| while "question" in node: | |
| response = model.ask(tree["node_prompt"].format(question=node["question"], answers=node["answers"]), image_b64) | |
| # Longest answers first so e.g. "no entry" is not matched as "no". | |
| answers = sorted(node["answers"], key=len, reverse=True) | |
| match = re.search("(" + "|".join(rf"\b{re.escape(a.lower())}\b" for a in answers) + ")", response.lower()) | |
| if not match: | |
| path.append({"question": node["question"], "answer": response.strip()}) | |
| return -1, path | |
| answer = next(a for a in answers if a.lower() == match.group(1)) | |
| path.append({"question": node["question"], "answer": answer}) | |
| node = node["children"][answer] | |
| time.sleep(sleep) | |
| return node["label"], path | |
| def run(args): | |
| split = load_split(args.source, args.dataset) | |
| class_names = load_json(args.source, f"data/{args.dataset}/class_names.json") | |
| tree = load_json(args.source, f"trees/{args.dataset}.json") | |
| prompts = load_json(args.source, f"prompts/{DATASET_NAMES[args.dataset]}/zs_prompts.json")["prompts"] | |
| model = Model(args.model, args.base_url, os.environ.get(args.api_key_env, ""), args.temperature, args.max_tokens) | |
| out = Path(args.out) | |
| done = set() | |
| if out.exists(): | |
| done = {json.loads(line)["image_id"] for line in out.read_text().splitlines() if line.strip()} | |
| todo = [i for i, image_id in enumerate(split["image_id"]) if image_id not in done][: args.limit] | |
| print(f"{args.dataset}: {len(done)} done, running {len(todo)}") | |
| with out.open("a") as f: | |
| for n, i in enumerate(todo, 1): | |
| example = split[i] | |
| image_b64 = encode_image(example) | |
| if args.method == "tree": | |
| prediction, output = tree_walk(model, image_b64, tree, args.sleep) | |
| else: | |
| prediction, output = zero_shot(model, image_b64, prompts[args.prompt_id], class_names) | |
| f.write(json.dumps({ | |
| "image_id": example["image_id"], "label": example["label"], "prediction": prediction, | |
| "method": args.method, "model": args.model, "output": output, | |
| }, ensure_ascii=False) + "\n") | |
| f.flush() | |
| if n % 25 == 0: | |
| print(f" {n}/{len(todo)}") | |
| score(argparse.Namespace(predictions=[str(out)])) | |
| # ----------------------------------------------------------------- scoring | |
| def score(args): | |
| for path in args.predictions: | |
| rows = [json.loads(line) for line in Path(path).read_text().splitlines() if line.strip()] | |
| correct = sum(r["prediction"] == r["label"] for r in rows) | |
| invalid = sum(r["prediction"] == -1 for r in rows) | |
| print(f"{path}: accuracy {100 * correct / max(len(rows), 1):.2f}% " | |
| f"({correct}/{len(rows)}), unparseable {invalid}") | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) | |
| sub = parser.add_subparsers(dest="command", required=True) | |
| r = sub.add_parser("run", help="run a model on one split") | |
| r.add_argument("--dataset", choices=sorted(DATASET_NAMES), required=True) | |
| r.add_argument("--method", choices=["tree", "zero_shot"], required=True) | |
| r.add_argument("--model", required=True, help="model name as the endpoint expects it") | |
| r.add_argument("--base-url", required=True, help="OpenAI-compatible endpoint") | |
| r.add_argument("--api-key-env", default="OPENAI_API_KEY", help="environment variable holding the API key") | |
| r.add_argument("--source", default=str(LOCAL_ROOT), help="local benchmark folder or Hugging Face dataset id") | |
| r.add_argument("--out", required=True, help="predictions JSONL (appended to, resumable)") | |
| r.add_argument("--temperature", type=float, default=0.7) | |
| r.add_argument("--max-tokens", type=int, default=100) | |
| r.add_argument("--prompt-id", type=int, default=0, choices=range(10), help="zero-shot paraphrase (paper: 0)") | |
| r.add_argument("--sleep", type=float, default=1.0, help="seconds between tree questions") | |
| r.add_argument("--limit", type=int, help="evaluate at most this many new images") | |
| r.set_defaults(func=run) | |
| s = sub.add_parser("score", help="score one or more predictions files") | |
| s.add_argument("predictions", nargs="+") | |
| s.set_defaults(func=score) | |
| args = parser.parse_args() | |
| args.func(args) | |
| if __name__ == "__main__": | |
| main() | |