DOVE-Bench / scripts /run_dove.py
XinNUS's picture
DOVE v1: 180 groups, 530 intervals, 1,223 human-verified probes
92186b3 verified
Raw History Blame Contribute Delete
18.6 kB
#!/usr/bin/env python3
"""Model-agnostic inference and scoring entry point for DOVE.
The public model interface is a JSONL file with at least ``qid`` and
``caption``. ``infer`` is an optional convenience layer for Python adapters;
``judge`` and ``score`` work with predictions produced by any framework.
"""
from __future__ import annotations
import argparse
import importlib.util
import json
import re
import threading
import time
from collections import Counter, defaultdict
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import Any, Callable
ROOT = Path(__file__).resolve().parents[1]
DEFAULT_QUESTIONS = ROOT / "data/public/questions.jsonl"
DEFAULT_PROBES = ROOT / "data/private/temporal_probes.jsonl"
JUDGE_SYSTEM = """You are a strict caption-evidence checker. Use only the candidate caption.
Do not answer from common sense or outside knowledge. If the caption explicitly supports exactly
one choice, return state=answered and its zero-based index. If it lacks the required temporal
information, return state=not_mentioned. If it supports multiple incompatible choices or is truly
unclear, return state=ambiguous. Return JSON only."""
def read_jsonl(path: Path) -> list[dict[str, Any]]:
rows: list[dict[str, Any]] = []
with path.open(encoding="utf-8") as handle:
for number, line in enumerate(handle, 1):
if not line.strip():
continue
try:
value = json.loads(line)
except json.JSONDecodeError as exc:
raise ValueError(f"{path}:{number}: invalid JSON: {exc}") from exc
if not isinstance(value, dict):
raise ValueError(f"{path}:{number}: expected a JSON object")
rows.append(value)
return rows
def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
temporary = path.with_suffix(path.suffix + ".tmp")
with temporary.open("w", encoding="utf-8") as handle:
for row in rows:
handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
temporary.replace(path)
def unique_by(rows: list[dict[str, Any]], field: str, source: Path) -> dict[str, dict[str, Any]]:
values: dict[str, dict[str, Any]] = {}
duplicates: list[str] = []
for row in rows:
key = str(row.get(field, ""))
if not key:
raise ValueError(f"{source}: row missing {field!r}")
if key in values:
duplicates.append(key)
values[key] = row
if duplicates:
raise ValueError(f"{source}: duplicate {field}s: {duplicates[:5]}")
return values
def parse_object(value: str) -> dict[str, Any]:
parsed = json.loads(value)
if not isinstance(parsed, dict):
raise argparse.ArgumentTypeError("--model-args must be a JSON object")
return parsed
def resolve_question_video(row: dict[str, Any]) -> dict[str, Any]:
result = dict(row)
path = Path(str(result["video"]))
result["video"] = str(path if path.is_absolute() else ROOT / path)
return result
def validate_release(questions_path: Path, probes_path: Path, check_videos: bool) -> dict[str, Any]:
questions = read_jsonl(questions_path)
probes = read_jsonl(probes_path)
qmap = unique_by(questions, "qid", questions_path)
pmap = unique_by(probes, "probe_id", probes_path)
unknown = sorted({str(row.get("qid")) for row in probes} - set(qmap))
if unknown:
raise ValueError(f"private probes reference {len(unknown)} unknown qids")
protocols = Counter(str(row.get("input_protocol")) for row in questions)
axes = Counter(str(row.get("axis")) for row in probes)
missing_videos: list[str] = []
if check_videos:
for row in questions:
path = Path(resolve_question_video(row)["video"])
if not path.is_file():
missing_videos.append(str(path))
if missing_videos:
raise FileNotFoundError(f"missing {len(missing_videos)} videos; first={missing_videos[0]}")
return {
"questions": len(questions),
"groups": len({int(row["gid"]) for row in questions}),
"unique_videos": len({str(row["video"]) for row in questions}),
"probes": len(pmap),
"scored_clips": len({str(row["qid"]) for row in probes}),
"unscored_qids": sorted(set(qmap) - {str(row["qid"]) for row in probes}),
"protocols": dict(protocols),
"axes": dict(axes),
"videos_checked": check_videos,
}
def load_adapter(path: Path, model_args: dict[str, Any]) -> Callable[[dict[str, Any]], str]:
spec = importlib.util.spec_from_file_location("dove_user_adapter", path)
if spec is None or spec.loader is None:
raise ValueError(f"cannot load adapter: {path}")
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
factory = getattr(module, "create_predictor", None)
if not callable(factory):
raise ValueError(f"{path} must define create_predictor(model_args)")
predictor = factory(model_args)
if not callable(predictor):
raise ValueError("create_predictor must return a callable")
return predictor
def infer(args: argparse.Namespace) -> None:
questions = read_jsonl(args.questions)
if args.num_shards < 1 or not 0 <= args.shard_id < args.num_shards:
raise ValueError("require num_shards >= 1 and 0 <= shard_id < num_shards")
questions = questions[args.shard_id :: args.num_shards]
if args.limit > 0:
questions = questions[: args.limit]
existing: dict[str, dict[str, Any]] = {}
if args.output.exists():
existing = unique_by(read_jsonl(args.output), "qid", args.output)
work = [row for row in questions if str(row["qid"]) not in existing]
print(f"assigned={len(questions)} done={len(questions)-len(work)} remaining={len(work)}")
if not work:
return
predictor = load_adapter(args.adapter, args.model_args)
args.output.parent.mkdir(parents=True, exist_ok=True)
with args.output.open("a", encoding="utf-8") as handle:
for index, row in enumerate(work, 1):
request = resolve_question_video(row)
video = Path(request["video"])
if not video.is_file():
raise FileNotFoundError(video)
caption = predictor(request)
if not isinstance(caption, str):
raise TypeError(f"adapter returned {type(caption).__name__}, expected str")
output = {
"qid": row["qid"],
"gid": row["gid"],
"seg_index": row["seg_index"],
"input_protocol": row["input_protocol"],
"caption": caption.strip(),
"model": args.model_name,
}
handle.write(json.dumps(output, ensure_ascii=False, sort_keys=True) + "\n")
handle.flush()
if index % 10 == 0 or index == len(work):
print(f"completed={index}/{len(work)}", flush=True)
def validate_predictions(questions_path: Path, predictions_path: Path, allow_partial: bool = False) -> dict[str, dict[str, Any]]:
questions = unique_by(read_jsonl(questions_path), "qid", questions_path)
predictions = unique_by(read_jsonl(predictions_path), "qid", predictions_path)
extra = sorted(set(predictions) - set(questions))
missing = sorted(set(questions) - set(predictions))
if extra:
raise ValueError(f"predictions contain {len(extra)} unknown qids; first={extra[0]}")
if missing and not allow_partial:
raise ValueError(f"predictions are missing {len(missing)} qids; first={missing[0]}")
for qid, row in predictions.items():
if not isinstance(row.get("caption"), str):
raise ValueError(f"prediction {qid}: caption must be a string")
protocol = row.get("input_protocol")
if protocol is not None and protocol != questions[qid].get("input_protocol"):
raise ValueError(f"prediction {qid}: input_protocol mismatch")
return predictions
def parse_json_object(text: str) -> dict[str, Any]:
fenced = re.search(r"```(?:json)?\s*(.*?)```", text, re.S)
if fenced:
text = fenced.group(1)
start = text.find("{")
if start < 0:
raise ValueError("response contains no JSON object")
depth = 0
in_string = False
escaped = False
for index, char in enumerate(text[start:], start):
if in_string:
if escaped:
escaped = False
elif char == "\\":
escaped = True
elif char == '"':
in_string = False
elif char == '"':
in_string = True
elif char == "{":
depth += 1
elif char == "}":
depth -= 1
if depth == 0:
return json.loads(text[start : index + 1])
raise ValueError("unterminated JSON object")
def judge(args: argparse.Namespace) -> None:
try:
from openai import OpenAI
except ImportError as exc:
raise RuntimeError("judge requires `pip install openai`") from exc
predictions = validate_predictions(args.questions, args.predictions)
probes = read_jsonl(args.probes)
unique_by(probes, "probe_id", args.probes)
completed: dict[str, dict[str, Any]] = {}
if args.output.exists():
completed = {
str(row["probe_id"]): row
for row in read_jsonl(args.output)
if row.get("ok") and row.get("probe_id")
}
work = [row for row in probes if str(row["probe_id"]) not in completed]
print(f"probes={len(probes)} done={len(completed)} remaining={len(work)}")
local = threading.local()
def client() -> Any:
if not hasattr(local, "client"):
local.client = OpenAI(base_url=args.base_url, api_key=args.api_key, timeout=args.timeout)
return local.client
def judge_one(probe: dict[str, Any]) -> dict[str, Any]:
caption = predictions[str(probe["qid"])]["caption"].strip()
if not caption:
return {
"probe_id": probe["probe_id"],
"state": "not_mentioned",
"selected_index": None,
"ok": True,
"backend": "empty-caption-zero-score",
}
choices = "\n".join(f"{i}. {value}" for i, value in enumerate(probe["choices"]))
request = (
f"CANDIDATE CAPTION:\n{caption}\n\nQUESTION:\n{probe['question']}\n\n"
f"CHOICES:\n{choices}\n\n"
'Return exactly {"state":"answered|not_mentioned|ambiguous","selected_index":0}. '
"For not_mentioned or ambiguous, selected_index must be null."
)
error = ""
for attempt in range(args.retries):
try:
response = client().chat.completions.create(
model=args.judge_model,
temperature=0,
max_tokens=96,
messages=[
{"role": "system", "content": JUDGE_SYSTEM},
{"role": "user", "content": request},
],
)
value = parse_json_object(response.choices[0].message.content or "")
state = value.get("state")
selected = value.get("selected_index")
if state not in {"answered", "not_mentioned", "ambiguous"}:
raise ValueError(f"invalid state: {state!r}")
if state == "answered" and selected not in range(4):
state, selected = "ambiguous", None
if state != "answered":
selected = None
return {
"probe_id": probe["probe_id"],
"state": state,
"selected_index": selected,
"ok": True,
"backend": args.judge_model,
}
except Exception as exc: # noqa: BLE001
error = f"{type(exc).__name__}: {exc}"[:500]
time.sleep(1.5 * (attempt + 1))
return {"probe_id": probe["probe_id"], "ok": False, "error": error}
args.output.parent.mkdir(parents=True, exist_ok=True)
with args.output.open("a", encoding="utf-8") as handle, ThreadPoolExecutor(max_workers=args.workers) as pool:
for index, result in enumerate(pool.map(judge_one, work), 1):
handle.write(json.dumps(result, ensure_ascii=False, sort_keys=True) + "\n")
handle.flush()
if index % 50 == 0 or index == len(work):
print(f"completed={index}/{len(work)}", flush=True)
latest = {
str(row["probe_id"]): row
for row in read_jsonl(args.output)
if row.get("probe_id")
}
incomplete = [
probe["probe_id"]
for probe in probes
if not latest.get(str(probe["probe_id"]), {}).get("ok")
]
if incomplete:
raise RuntimeError(
f"judging incomplete: {len(incomplete)} failed/missing probes; rerun to retry"
)
def mean(values: list[float]) -> float:
return sum(values) / len(values) if values else 0.0
def score(args: argparse.Namespace) -> dict[str, Any]:
probes = unique_by(read_jsonl(args.probes), "probe_id", args.probes)
# The judge is append-only. A successful retry intentionally follows an
# older failed row with the same probe_id, so consume the latest attempt.
latest_judgments = {
str(row["probe_id"]): row
for row in read_jsonl(args.judgments)
if row.get("probe_id")
}
judgments = {
key: value
for key, value in latest_judgments.items()
if value.get("ok", True) and key in probes
}
missing = sorted(set(probes) - set(judgments))
if missing:
raise ValueError(f"incomplete judgments: missing {len(missing)}; first={missing[0]}")
per_axis: dict[str, list[float]] = defaultdict(list)
per_clip: dict[str, list[float]] = defaultdict(list)
wrong = absent = 0
for probe_id, probe in probes.items():
judgment = judgments[probe_id]
state = judgment.get("state")
selected = judgment.get("selected_index")
correct = float(state == "answered" and selected == probe["answer_index"])
wrong += int(state == "answered" and selected != probe["answer_index"])
absent += int(state in {"not_mentioned", "ambiguous"})
per_axis[str(probe["axis"])].append(correct)
per_clip[str(probe["qid"])].append(correct)
axis_scores = {axis: mean(per_axis[axis]) for axis in ("order", "state", "outcome")}
all_values = [value for values in per_axis.values() for value in values]
report = {
"schema_version": "dove-v2-score-v1",
"probes": len(probes),
"clips": len(per_clip),
"groups": len({int(row["gid"]) for row in probes.values()}),
"temp_cov": mean(all_values),
"tec": mean(list(axis_scores.values())),
"clip_complete": mean([float(all(values)) for values in per_clip.values()]),
"by_axis": {
axis: {"count": len(per_axis[axis]), "temp_cov": axis_scores[axis]}
for axis in ("order", "state", "outcome")
},
"contradiction_rate": wrong / len(probes),
"not_mentioned_rate": absent / len(probes),
}
text = json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True) + "\n"
if args.output:
args.output.parent.mkdir(parents=True, exist_ok=True)
args.output.write_text(text, encoding="utf-8")
print(text, end="")
return report
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
sub = parser.add_subparsers(dest="command", required=True)
release = sub.add_parser("validate", help="validate the packaged data and optional predictions")
release.add_argument("--questions", type=Path, default=DEFAULT_QUESTIONS)
release.add_argument("--probes", type=Path, default=DEFAULT_PROBES)
release.add_argument("--skip-videos", action="store_true")
release.add_argument("--predictions", type=Path)
inference = sub.add_parser("infer", help="generate captions through a user-supplied Python adapter")
inference.add_argument("--adapter", type=Path, required=True)
inference.add_argument("--model-name", required=True)
inference.add_argument("--model-args", type=parse_object, default={})
inference.add_argument("--questions", type=Path, default=DEFAULT_QUESTIONS)
inference.add_argument("--output", type=Path, required=True)
inference.add_argument("--num-shards", type=int, default=1)
inference.add_argument("--shard-id", type=int, default=0)
inference.add_argument("--limit", type=int, default=0)
judging = sub.add_parser("judge", help="judge caption support for the frozen private probes")
judging.add_argument("--predictions", type=Path, required=True)
judging.add_argument("--output", type=Path, required=True)
judging.add_argument("--questions", type=Path, default=DEFAULT_QUESTIONS)
judging.add_argument("--probes", type=Path, default=DEFAULT_PROBES)
judging.add_argument("--base-url", default="http://127.0.0.1:18901/v1")
judging.add_argument("--api-key", default="EMPTY")
judging.add_argument("--judge-model", default="qwen-judge")
judging.add_argument("--workers", type=int, default=32)
judging.add_argument("--retries", type=int, default=4)
judging.add_argument("--timeout", type=float, default=90)
scoring = sub.add_parser("score", help="aggregate complete frozen-probe judgments")
scoring.add_argument("--judgments", type=Path, required=True)
scoring.add_argument("--probes", type=Path, default=DEFAULT_PROBES)
scoring.add_argument("--output", type=Path)
return parser
def main() -> None:
parser = build_parser()
args = parser.parse_args()
if args.command == "validate":
report = validate_release(args.questions, args.probes, not args.skip_videos)
if args.predictions:
predictions = validate_predictions(args.questions, args.predictions)
report["predictions"] = len(predictions)
print(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True))
elif args.command == "infer":
infer(args)
elif args.command == "judge":
judge(args)
elif args.command == "score":
score(args)
else: # pragma: no cover
parser.error(f"unknown command: {args.command}")
if __name__ == "__main__":
main()