Upload benchmark/Eval/Reason2GenBench/reason2gen_gpt_eval.py with huggingface_hub

benchmark/Eval/Reason2GenBench/reason2gen_gpt_eval.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import argparse
+import base64
+import csv
+import json
+import os
+import re
+import time
+from dataclasses import dataclass
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple
+
+from openai import OpenAI
+
+IMG_EXTS = {".png", ".jpg", ".jpeg", ".webp"}
+ID_RE = re.compile(r"(\d{3,4})")
+
+
+@dataclass(frozen=True)
+class TaskItem:
+    task: str
+    ex_id: int
+    image_input: str
+    image_target: str
+    instruction: str
+
+
+def _guess_mime(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in {".jpg", ".jpeg"}:
+        return "image/jpeg"
+    if ext == ".webp":
+        return "image/webp"
+    return "image/png"
+
+
+def _encode_image_to_data_url(path: str) -> str:
+    with open(path, "rb") as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode("utf-8")
+    return f"data:{_guess_mime(path)};base64,{b64}"
+
+
+def _safe_int(x, default: int = 0) -> int:
+    try:
+        return int(x)
+    except Exception:
+        return default
+
+
+def _read_json(path: str):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _list_tasks(base_dir: str, tasks_filter: Optional[Set[str]] = None) -> List[str]:
+    out: List[str] = []
+    for name in sorted(os.listdir(base_dir)):
+        task_dir = os.path.join(base_dir, name)
+        if not os.path.isdir(task_dir):
+            continue
+        if tasks_filter is not None and name not in tasks_filter:
+            continue
+        json_path = os.path.join(task_dir, f"{name}.json")
+        if os.path.isfile(json_path):
+            out.append(name)
+    return out
+
+
+def _load_task_items(base_dir: str, task: str, max_samples: int = 0) -> List[TaskItem]:
+    json_path = os.path.join(base_dir, task, f"{task}.json")
+    data = _read_json(json_path)
+    if not isinstance(data, list):
+        raise ValueError(f"Task JSON is not a list: {json_path}")
+
+    items: List[TaskItem] = []
+    for obj in data:
+        if not isinstance(obj, dict):
+            continue
+        ex_id = _safe_int(obj.get("id"), default=-1)
+        if ex_id < 0:
+            continue
+        image_input = str(obj.get("image_input") or "")
+        image_target = str(obj.get("image_target") or "")
+        instruction = str(obj.get("instruction") or "")
+        if not image_input or not image_target or not instruction:
+            continue
+        items.append(TaskItem(task=task, ex_id=ex_id, image_input=image_input, image_target=image_target, instruction=instruction))
+        if max_samples and len(items) >= max_samples:
+            break
+    return items
+
+
+def _iter_image_files(root: str) -> Iterable[str]:
+    if not os.path.isdir(root):
+        return
+    for dirpath, _, filenames in os.walk(root):
+        for fn in filenames:
+            if os.path.splitext(fn)[1].lower() in IMG_EXTS:
+                yield os.path.join(dirpath, fn)
+
+
+def _pick_better_path(current: Optional[str], cand: str, image_suffix: str) -> str:
+    if current is None:
+        return cand
+    cur_bn = os.path.basename(current)
+    cand_bn = os.path.basename(cand)
+    if image_suffix:
+        cur_match = cur_bn.endswith(image_suffix)
+        cand_match = cand_bn.endswith(image_suffix)
+        if cand_match and not cur_match:
+            return cand
+        if cur_match and not cand_match:
+            return current
+    if (len(cand_bn), cand_bn) < (len(cur_bn), cur_bn):
+        return cand
+    return current
+
+
+def _build_pred_index(pred_dir: str, image_suffix: str) -> Dict[int, str]:
+    idx: Dict[int, str] = {}
+    for p in _iter_image_files(pred_dir):
+        bn = os.path.basename(p)
+        ms = ID_RE.findall(bn)
+        if not ms:
+            continue
+        ex_id = int(ms[-1])
+        idx[ex_id] = _pick_better_path(idx.get(ex_id), p, image_suffix=image_suffix)
+    return idx
+
+
+def _build_task_pred_index(result_root: str, task: str, method_name: str, image_suffix: str) -> Dict[int, str]:
+    idx: Dict[int, str] = {}
+    cand_dirs = [
+        os.path.join(result_root, task, method_name),
+        os.path.join(result_root, task, method_name, "edited"),
+    ]
+    for d in cand_dirs:
+        if not os.path.isdir(d):
+            continue
+        sub = _build_pred_index(d, image_suffix=image_suffix)
+        for ex_id, p in sub.items():
+            idx[ex_id] = _pick_better_path(idx.get(ex_id), p, image_suffix=image_suffix)
+    return idx
+
+
+def _call_gpt_judge(
+    client: OpenAI,
+    model: str,
+    instruction: str,
+    q_path: str,
+    gt_path: str,
+    pred_path: str,
+    json_mode: bool,
+    max_retries: int,
+    retry_min_seconds: float,
+    retry_max_seconds: float,
+) -> Tuple[int, str, str]:
+    q_url = _encode_image_to_data_url(q_path)
+    gt_url = _encode_image_to_data_url(gt_path)
+    pred_url = _encode_image_to_data_url(pred_path)
+
+    messages = [
+        {"role": "system", "content": "You are a strict, deterministic visual judge. Return only JSON."},
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": (
+                        "Evaluate whether model_output is a correct solution to the task.\n\n"
+                        "Task instruction (for context):\n"
+                        f"{instruction}\n\n"
+                        "You will see three images: question_input, ground_truth, model_output.\n"
+                        "Use ground_truth as the reference for correctness. Minor stylistic differences are allowed, "
+                        "but the final answer/state must match the ground truth.\n\n"
+                        "Return a single JSON object with fields: label (1 or 0), reason (one short sentence)."
+                    ),
+                },
+                {"type": "text", "text": "question_input:"},
+                {"type": "image_url", "image_url": {"url": q_url}},
+                {"type": "text", "text": "ground_truth:"},
+                {"type": "image_url", "image_url": {"url": gt_url}},
+                {"type": "text", "text": "model_output:"},
+                {"type": "image_url", "image_url": {"url": pred_url}},
+            ],
+        },
+    ]
+
+    last_err: Optional[Exception] = None
+    for attempt in range(max_retries + 1):
+        try:
+            kwargs = {"model": model, "messages": messages, "temperature": 0}
+            if json_mode:
+                kwargs["response_format"] = {"type": "json_object"}
+            resp = client.chat.completions.create(**kwargs)
+            raw = resp.choices[0].message.content or ""
+            txt = raw.strip()
+
+            try:
+                obj = json.loads(txt)
+            except Exception:
+                obj = None
+
+            if isinstance(obj, dict):
+                label = _safe_int(obj.get("label"), default=0)
+                if label not in (0, 1):
+                    label = 0
+                reason = str(obj.get("reason") or "").strip().replace("\n", " ")
+                reason = re.sub(r"\s+", " ", reason)[:200]
+                return label, reason, txt
+
+            return 0, "PARSE_FAILED", txt
+        except Exception as e:
+            last_err = e
+            if attempt >= max_retries:
+                break
+            time.sleep(min(retry_min_seconds * (2**attempt), retry_max_seconds))
+
+    return 0, f"ERROR: {type(last_err).__name__}", ""
+
+
+def _ensure_parent_dir(path: str) -> None:
+    parent = os.path.dirname(os.path.abspath(path))
+    if parent and not os.path.isdir(parent):
+        os.makedirs(parent, exist_ok=True)
+
+
+def _load_done_keys(csv_path: str) -> Set[Tuple[str, int, str]]:
+    if not os.path.isfile(csv_path):
+        return set()
+    done: Set[Tuple[str, int, str]] = set()
+    with open(csv_path, "r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            task = (row.get("task") or "").strip()
+            method = (row.get("method") or "").strip()
+            ex_id = _safe_int(row.get("id"), default=-1)
+            if task and method and ex_id >= 0:
+                done.add((task, ex_id, method))
+    return done
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base_dir", required=True, help="Path to benchmark/Reason2Gen")
+    parser.add_argument("--result_root", required=True, help="Path to prediction root")
+    parser.add_argument("--method_name", required=True, help="Method name under each task")
+    parser.add_argument("--image_suffix", default="", help="Prefer predictions that end with this suffix")
+    parser.add_argument("--model", default="gpt-4o-mini", help="OpenAI model name")
+    parser.add_argument("--max_samples_per_task", type=int, default=0, help="0 means no limit")
+    parser.add_argument("--tasks", default="", help="Comma-separated task names (optional)")
+    parser.add_argument("--out_csv", default="", help="CSV output path (optional)")
+    parser.add_argument("--json_mode", action="store_true", help="Use response_format=json_object")
+    parser.add_argument("--max_retries", type=int, default=5)
+    parser.add_argument("--retry_min_seconds", type=float, default=1.0)
+    parser.add_argument("--retry_max_seconds", type=float, default=20.0)
+
+    args = parser.parse_args(argv)
+
+    tasks_filter: Optional[Set[str]] = None
+    if args.tasks.strip():
+        tasks_filter = {t.strip() for t in args.tasks.split(",") if t.strip()}
+
+    out_csv = args.out_csv.strip() or os.path.join(args.result_root, f"{args.method_name}_gpt_eval.csv")
+    _ensure_parent_dir(out_csv)
+
+    done = _load_done_keys(out_csv)
+    client = OpenAI()
+
+    fieldnames = ["task", "id", "method", "q_path", "gt_path", "pred_path", "label", "reason", "raw_judge"]
+    need_header = not os.path.isfile(out_csv)
+
+    with open(out_csv, "a", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        if need_header:
+            writer.writeheader()
+
+        tasks = _list_tasks(args.base_dir, tasks_filter=tasks_filter)
+        total_correct = 0
+        total_eval = 0
+
+        for task in tasks:
+            items = _load_task_items(args.base_dir, task, max_samples=args.max_samples_per_task)
+            pred_index = _build_task_pred_index(args.result_root, task, args.method_name, image_suffix=args.image_suffix)
+
+            task_correct = 0
+            task_eval = 0
+
+            for it in items:
+                key = (it.task, it.ex_id, args.method_name)
+                if key in done:
+                    continue
+
+                q_path = os.path.join(args.base_dir, task, "question", it.image_input)
+                gt_path = os.path.join(args.base_dir, task, "answer", it.image_target)
+                pred_path = pred_index.get(it.ex_id)
+
+                if not os.path.isfile(q_path) or not os.path.isfile(gt_path) or not pred_path or not os.path.isfile(pred_path):
+                    writer.writerow({"task": task, "id": it.ex_id, "method": args.method_name, "q_path": q_path, "gt_path": gt_path, "pred_path": pred_path or "", "label": "", "reason": "MISSING_IMAGE", "raw_judge": ""})
+                    f.flush()
+                    done.add(key)
+                    continue
+
+                label, reason, raw = _call_gpt_judge(
+                    client=client,
+                    model=args.model,
+                    instruction=it.instruction,
+                    q_path=q_path,
+                    gt_path=gt_path,
+                    pred_path=pred_path,
+                    json_mode=bool(args.json_mode),
+                    max_retries=args.max_retries,
+                    retry_min_seconds=args.retry_min_seconds,
+                    retry_max_seconds=args.retry_max_seconds,
+                )
+
+                writer.writerow({"task": task, "id": it.ex_id, "method": args.method_name, "q_path": q_path, "gt_path": gt_path, "pred_path": pred_path, "label": label, "reason": reason, "raw_judge": raw})
+                f.flush()
+
+                done.add(key)
+                task_eval += 1
+                total_eval += 1
+                if label == 1:
+                    task_correct += 1
+                    total_correct += 1
+
+            if task_eval:
+                print(f"[TASK] {task}: {task_correct}/{task_eval} = {task_correct / task_eval:.4f}")
+            else:
+                print(f"[TASK] {task}: no evaluated samples")
+
+        if total_eval:
+            print(f"[ALL] {total_correct}/{total_eval} = {total_correct / total_eval:.4f}")
+        else:
+            print("[ALL] no evaluated samples")
+
+    print(f"Saved: {out_csv}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())