eval.py

#!/usr/bin/env python3
"""
Score a VLM output JSON for the BEAR benchmark and report the final accuracy.

The inference runners (run_api_model.py / run_image_model.py) produce a JSON list
where each item keeps its original fields and adds `direct_reply` and (for API
models) `cot_reply`. This script turns those free-form replies into a final score:

  * Multiple-choice tasks (default): an **LLM judge** (default: gpt-4o-mini) reads
    the model's reply plus the options and returns the chosen letter A/B/C/D, which
    is compared against the ground-truth `gt`.
  * Pointing tasks:  the predicted (x, y) must fall inside the ground-truth mask.
  * Bounding-box tasks:  IoU between the predicted box and the ground-truth mask.

Requires OPENAI_API_KEY in the environment (used only for multiple-choice grading).

Usage:
    export OPENAI_API_KEY=sk-...
    python eval.py --input_json final_gpt-4o_evaluate_next_action_prediction_official.json
    # -> writes  *_scored.json  and  *_scored_summary.json, prints the summary.

    # long-horizon (episode-level strict accuracy):
    python eval.py --input_json final_gpt-4o_evaluate_vqa_all_episodes.json --episode
"""
import os
import re
import json
import argparse
from collections import defaultdict

import numpy as np
from PIL import Image
from openai import OpenAI

client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", "EMPTY"))


# --------------------------------------------------------------------------- #
# Extraction helpers
# --------------------------------------------------------------------------- #
def extract_xy(reply):
    """Extract a normalized (x, y) point from a reply string, or None."""
    if not isinstance(reply, str):
        return None
    m = re.search(r"\(\s*([\d.]+)\s*,\s*([\d.]+)\s*\)", reply)
    if not m:
        return None
    try:
        return float(m.group(1)), float(m.group(2))
    except ValueError:
        return None


def extract_bbox(reply):
    """Extract a normalized (x1, y1, x2, y2) box from a reply string, or None."""
    if not isinstance(reply, str):
        return None
    m = re.search(
        r"\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)", reply
    )
    if not m:
        return None
    try:
        return tuple(float(g) for g in m.groups())
    except ValueError:
        return None


def point_in_mask(mask_path, xy, normalize=True):
    """True if the (normalized) point lands on a non-zero mask pixel."""
    if xy is None:
        return False
    mask = np.array(Image.open(mask_path).convert("L"))
    h, w = mask.shape
    x, y = xy
    if normalize:
        x, y = int(x * w), int(y * h)
    else:
        x, y = int(x), int(y)
    if x < 0 or x >= w or y < 0 or y >= h:
        return False
    return bool(mask[y, x] > 0)


def bbox_iou(mask_path, bbox, normalize=True):
    """IoU between a (normalized) predicted box and a ground-truth mask."""
    if bbox is None:
        return 0.0
    mask = np.array(Image.open(mask_path).convert("L"))
    h, w = mask.shape
    x1, y1, x2, y2 = bbox
    if normalize:
        x1, x2 = int(x1 * w), int(x2 * w)
        y1, y2 = int(y1 * h), int(y2 * h)
    else:
        x1, y1, x2, y2 = map(int, (x1, y1, x2, y2))
    x1, x2 = max(0, min(x1, w - 1)), max(0, min(x2, w - 1))
    y1, y2 = max(0, min(y1, h - 1)), max(0, min(y2, h - 1))
    if x2 <= x1 or y2 <= y1:
        return 0.0
    pred = np.zeros_like(mask)
    pred[y1:y2 + 1, x1:x2 + 1] = 1
    gt = (mask > 0).astype(np.uint8)
    inter = np.logical_and(pred, gt).sum()
    union = np.logical_or(pred, gt).sum()
    return float(inter / union) if union else 0.0


# --------------------------------------------------------------------------- #
# LLM judge for multiple-choice answers
# --------------------------------------------------------------------------- #
def options_to_text(options):
    if isinstance(options, dict):
        return " ".join(f"{k}. {v}" for k, v in options.items() if str(v).strip())
    return str(options)


def judge_option(reply, options_text, model):
    """Use an LLM to extract the chosen option letter (A/B/C/D) from `reply`."""
    if not reply or not isinstance(reply, str):
        return None
    messages = [
        {
            "role": "system",
            "content": "You extract the chosen option from a model's answer. "
                       "Reply with ONLY one uppercase letter: A, B, C, or D.",
        },
        {
            "role": "user",
            "content": f"The model's answer:\n{reply}\n\n"
                       f"The options were:\n{options_text}\n\n"
                       "Which option (A, B, C, or D) did the model choose? "
                       "Reply with a single letter.",
        },
    ]
    for _ in range(3):
        try:
            r = client.chat.completions.create(
                model=model, messages=messages, temperature=0
            )
            ans = r.choices[0].message.content.strip().upper()
            m = re.search(r"[ABCD]", ans)
            if m:
                return m.group(0)
        except Exception:
            continue
    return None


# --------------------------------------------------------------------------- #
# Scoring
# --------------------------------------------------------------------------- #
REPLIES = ["direct_reply", "cot_reply"]


def score(items, judge_model):
    tallies = {
        r: defaultdict(lambda: {"n": 0, "correct": 0, "iou_sum": 0.0}) for r in REPLIES
    }
    for item in items:
        cat = item.get("category", "")
        kind = "pointing" if cat == "pointing" else "bbox" if cat == "bbox" else "mcq"
        for r in REPLIES:
            if r not in item:
                continue
            prefix = r.split("_")[0]  # "direct" / "cot"
            reply = item.get(r, "")
            t = tallies[r][kind]
            t["n"] += 1
            if kind == "pointing":
                hit = point_in_mask(item.get("mask"), extract_xy(reply))
                item[f"{prefix}_hit"] = int(hit)
                t["correct"] += int(hit)
            elif kind == "bbox":
                iou = bbox_iou(item.get("mask"), extract_bbox(reply))
                item[f"{prefix}_iou"] = iou
                t["iou_sum"] += iou
            else:
                pred = judge_option(
                    reply, options_to_text(item.get("options", {})), judge_model
                )
                gt = str(item.get("gt", "")).strip().upper()
                hit = pred is not None and pred == gt
                item[f"{prefix}_pred"] = pred
                item[f"{prefix}_hit"] = int(hit)
                t["correct"] += int(hit)
    return tallies


def summarize(tallies):
    out = {}
    for r, kinds in tallies.items():
        rep = {}
        for kind, t in kinds.items():
            if not t["n"]:
                continue
            if kind == "bbox":
                rep[kind] = {"n": t["n"], "mean_iou": round(t["iou_sum"] / t["n"], 4)}
            else:
                rep[kind] = {"n": t["n"], "accuracy": round(t["correct"] / t["n"], 4)}
        out[r] = rep
    return out


def episode_strict(items, policy="direct"):
    """Long-horizon: an episode is correct only if ALL its questions are correct."""
    key = f"{policy}_hit"
    ep = defaultdict(list)
    for it in items:
        if "episode_id" in it and key in it:
            ep[str(it["episode_id"])].append(it[key])
    per = {e: all(h == 1 for h in hits) for e, hits in ep.items()}
    full = sum(1 for v in per.values() if v)
    return {
        "total_episodes": len(per),
        "fully_correct_episodes": full,
        "episode_level_acc": round(full / len(per), 4) if per else 0.0,
        "policy": policy,
    }


# --------------------------------------------------------------------------- #
# CLI
# --------------------------------------------------------------------------- #
if __name__ == "__main__":
    ap = argparse.ArgumentParser(
        description="Score BEAR VLM outputs (LLM judge for MCQ, geometric for pointing/bbox)."
    )
    ap.add_argument("--input_json", required=True,
                    help="VLM output JSON produced by run_api_model.py / run_image_model.py.")
    ap.add_argument("--output_json", default=None,
                    help="Scored per-item JSON. Default: <input>_scored.json")
    ap.add_argument("--judge_model", default="gpt-4o-mini",
                    help="OpenAI model used to extract the chosen option for MCQ tasks.")
    ap.add_argument("--episode", action="store_true",
                    help="Also compute episode-level strict accuracy (long_horizon).")
    args = ap.parse_args()

    if os.environ.get("OPENAI_API_KEY", "EMPTY") in (None, "", "EMPTY"):
        print("WARNING: OPENAI_API_KEY is not set — multiple-choice grading will fail.")

    with open(args.input_json) as f:
        items = json.load(f)

    tallies = score(items, args.judge_model)
    summary = summarize(tallies)
    if args.episode:
        summary["episode_strict"] = {p: episode_strict(items, p) for p in ("direct", "cot")}

    out_json = args.output_json or (os.path.splitext(args.input_json)[0] + "_scored.json")
    with open(out_json, "w") as f:
        json.dump(items, f, indent=2, ensure_ascii=False)
    summary_path = os.path.splitext(out_json)[0] + "_summary.json"
    with open(summary_path, "w") as f:
        json.dump(summary, f, indent=2, ensure_ascii=False)

    print(json.dumps(summary, indent=2, ensure_ascii=False))
    print(f"\nScored items -> {out_json}\nSummary      -> {summary_path}")