Datasets:
Download scripts/run_dove.py from XinNUS/DOVE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 18.6 kB
-
https://huggingface.co/datasets/XinNUS/DOVE-Bench/resolve/main/scripts/run_dove.py
- Command line
-
hf download hf://datasets/XinNUS/DOVE-Bench/scripts/run_dove.py
-
curl -L -o run_dove.py https://huggingface.co/datasets/XinNUS/DOVE-Bench/resolve/main/scripts/run_dove.py
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() | |