| |
| """Evaluate both RunningBench QA sets with the original 64-frame protocol. |
| |
| Uses an OpenAI-compatible vision chat endpoint (for example, a local vLLM server). |
| No model is downloaded or started by this script. |
| """ |
|
|
| import argparse |
| import base64 |
| import collections |
| import hashlib |
| import json |
| import os |
| import random |
| import re |
| import subprocess |
| import sys |
| import tarfile |
| import threading |
| import time |
| import urllib.error |
| import urllib.request |
| from concurrent.futures import ThreadPoolExecutor, as_completed |
| from pathlib import Path |
|
|
|
|
| VERSION = "runningbench-unified-v8" |
| |
| FRAME_VERSION = "runningbench-unified-v7" |
| DATASETS = { |
| "single_698": "segments_60s_gemini_verification/final/segments_700_verified.jsonl", |
| "single_567_human": "human_answer_repair_567/single_567_human_eval.jsonl", |
| "mixed_1487": "qa_fix_gold_recovery_and_adjudication/data/runningbench_v2_kept.jsonl", |
| } |
| MULTI_VIDEO_PROMPT = """Answer this multiple-choice question about egocentric walking/running footage. |
| The frames below are sampled in order from the clip(s) the question refers to; each clip is |
| introduced by its label. |
| |
| Watch before deciding. Do not answer from the wording of the options alone. |
| |
| QUESTION: {question} |
| |
| OPTIONS: |
| {options} |
| |
| Select exactly {n} option{plural}. |
| Return ONLY JSON: {{"answer": [{example}]}}""" |
| SINGLE_VIDEO_PROMPT = """Answer this multiple-choice question about egocentric walking/running footage. |
| The frames below are sampled in chronological order from the single video clip (at most 60 seconds long) associated with this question. |
| |
| Watch the video frames before deciding. Base your answer on visual evidence from this video. Do not answer from the wording of the options alone. |
| |
| QUESTION: {question} |
| |
| OPTIONS: |
| {options} |
| |
| Select exactly {n} option{plural}. |
| Return ONLY JSON: {{"answer": [{example}]}}""" |
| MULTI_UNITS = {"cross_video", "cross_recording", "anonymous_multi_clip"} |
|
|
|
|
| def jsonl(path): |
| with open(path, encoding="utf-8") as fh: |
| for line in fh: |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def file_hash(path): |
| h = hashlib.sha256() |
| with open(path, "rb") as fh: |
| for chunk in iter(lambda: fh.read(1024 * 1024), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def question_id(q, dataset): |
| return q["id"] if dataset.startswith("single_") else q["review_id"] |
|
|
|
|
| def load_questions(root, dataset): |
| path = root / DATASETS[dataset] |
| questions = list(jsonl(path)) |
| ids = [question_id(q, dataset) for q in questions] |
| if len(ids) != len(set(ids)): |
| raise ValueError(f"Duplicate question IDs in {path}") |
| return path, questions |
|
|
|
|
| def shuffled_view(options, seed): |
| real = sorted(options) |
| order = list(real) |
| random.Random(seed).shuffle(order) |
| shown = {real[i]: options[order[i]] for i in range(len(real))} |
| back = {real[i]: order[i] for i in range(len(real))} |
| return shown, back |
|
|
|
|
| ANSWER_ITEM = re.compile(r"^(?:option\s+)?\(?([A-Z])\)?[.):]?$", re.I) |
|
|
|
|
| def parse_answer(raw, letters): |
| """Return (displayed letters, error) from the last JSON object that has an "answer" key. |
| |
| Strict by design: no free-text letter fallback, and a letter outside the shown options |
| is an error rather than being silently dropped. |
| """ |
| text = raw or "" |
| decoder = json.JSONDecoder() |
| found = None |
| for match in re.finditer(r"\{", text): |
| try: |
| obj, _ = decoder.raw_decode(text, match.start()) |
| except ValueError: |
| continue |
| if isinstance(obj, dict) and "answer" in obj: |
| found = obj |
| if found is None: |
| return None, 'No JSON object with an "answer" key' |
| answer = found["answer"] |
| if isinstance(answer, str): |
| answer = re.split(r"\s*[,;/]\s*", answer.strip()) |
| if not isinstance(answer, list): |
| return None, f"Answer is not a list: {answer!r}"[:200] |
| chosen = set() |
| for item in answer: |
| match = ANSWER_ITEM.match(item.strip()) if isinstance(item, str) else None |
| if not match: |
| return None, f"Unrecognized answer item: {item!r}"[:200] |
| letter = match.group(1).upper() |
| if letter not in letters: |
| return None, f"Answer letter {letter} is not among the shown options" |
| chosen.add(letter) |
| if not chosen: |
| return None, "Empty answer" |
| return sorted(chosen), None |
|
|
|
|
| def split_reasoning(raw): |
| """Separate a <think> trace from the final answer text. |
| |
| Handles templates that pre-fill the opening <think> so only </think> is generated. |
| """ |
| if "</think>" not in raw: |
| return None, raw |
| head, answer_text = raw.rsplit("</think>", 1) |
| if "<think>" in head: |
| head = head.split("<think>", 1)[1] |
| return head.strip() or None, answer_text |
|
|
|
|
| def allocate(durations, total, floor): |
| """Match model_evaluation_harness/code/extract_frames.py.""" |
| n = len(durations) |
| if not n: |
| raise ValueError("Question has no clips") |
| if n * floor >= total: |
| return [floor] * n |
| summed = sum(durations) or 1.0 |
| raw = [d / summed * total for d in durations] |
| base = [max(floor, int(x)) for x in raw] |
| while sum(base) > total: |
| i = max(range(n), key=lambda j: (base[j] - floor, raw[j])) |
| if base[i] <= floor: |
| break |
| base[i] -= 1 |
| remainder = total - sum(base) |
| order = sorted(range(n), key=lambda j: -(raw[j] - int(raw[j]))) |
| for i in range(remainder): |
| base[order[i % n]] += 1 |
| return base |
|
|
|
|
| def video_duration(path): |
| result = subprocess.run( |
| ["ffmpeg", "-i", str(path)], capture_output=True, timeout=120, |
| ) |
| match = re.search(r"Duration:\s*(\d+):(\d\d):(\d\d(?:\.\d+)?)", |
| result.stderr.decode("utf-8", "replace")) |
| if not match: |
| return 60.0 |
| return int(match.group(1)) * 3600 + int(match.group(2)) * 60 + float(match.group(3)) |
|
|
|
|
| class MediaResolver: |
| def __init__(self, root, single_clips, cache): |
| self.root, self.single_clips, self.cache = root, single_clips, cache |
| self.tars = {} |
|
|
| def close(self): |
| for archive in self.tars.values(): |
| archive.close() |
|
|
| def clips(self, dataset, question): |
| if dataset.startswith("single_"): |
| path = self.single_clips / f"{question['id']}.mp4" |
| if not path.is_file(): |
| raise FileNotFoundError(path) |
| return [("CLIP_1", path)] |
|
|
| bundle = question["bundle"] |
| archive = self.tars.get(bundle) |
| if archive is None: |
| path = self.root / "annotation_bundles" / f"{bundle}.tar" |
| archive = tarfile.open(path, "r") |
| self.tars[bundle] = archive |
| resolved = [] |
| for clip in question["clips"]: |
| member_name = f"{bundle}/{clip['path']}" |
| member = archive.getmember(member_name) |
| if not member.isfile(): |
| raise ValueError(f"Not a media file: {member_name}") |
| target = self.cache / bundle / question["review_id"] / Path(clip["path"]).name |
| if not target.is_file() or target.stat().st_size != member.size: |
| target.parent.mkdir(parents=True, exist_ok=True) |
| temp = target.with_suffix(target.suffix + ".part") |
| with archive.extractfile(member) as source, open(temp, "wb") as destination: |
| while chunk := source.read(1024 * 1024): |
| destination.write(chunk) |
| os.replace(temp, target) |
| resolved.append((clip["label"], target)) |
| return resolved |
|
|
|
|
| def extract_question_frames(dataset, qid, clips, cache, budget=64, floor=4, width=480): |
| durations = [video_duration(path) for _, path in clips] |
| quotas = allocate(durations, budget, floor) |
| base = cache / dataset / f"f{budget}_m{floor}_w{width}" / qid |
| all_clips = [] |
| for i, ((label, source), duration, quota) in enumerate(zip(clips, durations, quotas)): |
| directory = base / f"c{i:02d}" |
| directory.mkdir(parents=True, exist_ok=True) |
| marker = directory / "frames.json" |
| expected = {"version": FRAME_VERSION, "source": str(source), "source_size": source.stat().st_size, |
| "quota": quota, "width": width} |
| frames = [] |
| if marker.is_file(): |
| try: |
| previous = json.loads(marker.read_text(encoding="utf-8")) |
| if previous["config"] == expected: |
| frames = [Path(p) for p in previous["frames"]] |
| if not frames or not all(p.is_file() for p in frames): |
| frames = [] |
| except (KeyError, ValueError): |
| pass |
| if not frames: |
| for stale in directory.glob("frame_*.jpg"): |
| stale.unlink() |
| fps = quota / max(duration, 0.1) |
| |
| |
| command = ["ffmpeg", "-y", "-loglevel", "error", "-threads", "1", "-i", str(source), |
| "-vf", f"fps={fps:.6f},scale='min({width},iw)':-2", "-frames:v", str(quota), |
| "-q:v", "3", str(directory / "frame_%03d.jpg")] |
| subprocess.run(command, check=True, capture_output=True, timeout=900) |
| frames = sorted(directory.glob("frame_*.jpg")) |
| if not frames: |
| raise RuntimeError(f"ffmpeg generated no frames from {source}") |
| marker.write_text(json.dumps({"config": expected, "frames": [str(p) for p in frames]}), encoding="utf-8") |
| all_clips.append((label, frames)) |
| return all_clips, quotas |
|
|
|
|
| class RateLimiter: |
| def __init__(self, requests_per_second): |
| self.interval = 1 / max(requests_per_second, 0.01) |
| self.last = 0.0 |
| self.lock = threading.Lock() |
|
|
| def wait(self): |
| with self.lock: |
| delay = self.interval - (time.monotonic() - self.last) |
| if delay > 0: |
| time.sleep(delay) |
| self.last = time.monotonic() |
|
|
|
|
| class Client: |
| def __init__(self, base_url, model, api_key, thinking, max_tokens, max_tokens_cap, rps): |
| self.url = base_url.rstrip("/") + "/chat/completions" |
| self.model, self.api_key, self.thinking = model, api_key, thinking |
| self.max_tokens, self.max_tokens_cap = max_tokens, max_tokens_cap |
| self.limiter = RateLimiter(rps) |
|
|
| def ask(self, prompt, clips): |
| content = [{"type": "text", "text": prompt}] |
| for label, frames in clips: |
| content.append({"type": "text", "text": f"--- {label} ---"}) |
| for path in frames: |
| data = base64.b64encode(path.read_bytes()).decode("ascii") |
| content.append({"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + data}}) |
| body = {"model": self.model, "messages": [{"role": "user", "content": content}], |
| "temperature": 0.0} |
| if self.thinking != "auto": |
| body["chat_template_kwargs"] = {"enable_thinking": self.thinking == "true"} |
| attempts = [] |
| budget = self.max_tokens |
| while True: |
| body["max_tokens"] = budget |
| payload = json.dumps(body).encode("utf-8") |
| last = None |
| result = None |
| for request_attempt in range(4): |
| self.limiter.wait() |
| request = urllib.request.Request( |
| self.url, data=payload, method="POST", |
| headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}) |
| try: |
| with urllib.request.urlopen(request, timeout=900) as response: |
| result = json.load(response) |
| break |
| except urllib.error.HTTPError as exc: |
| detail = exc.read(1000).decode("utf-8", "replace") |
| last = f"HTTP {exc.code}: {detail}" |
| if exc.code not in (429, 500, 502, 503, 504): |
| break |
| except (urllib.error.URLError, ValueError) as exc: |
| last = f"{type(exc).__name__}: {exc}" |
| if request_attempt < 3: |
| time.sleep(min(30, 2 ** (request_attempt + 1))) |
| if result is None: |
| if attempts: |
| return {"error": f"Request failed after truncated response: {last}", "attempts": attempts} |
| raise RuntimeError(f"Model request failed: {last}") |
| choice = result["choices"][0] |
| item = {"message": choice["message"], "finish_reason": choice.get("finish_reason"), |
| "usage": result.get("usage"), "max_tokens": budget} |
| attempts.append(item) |
| if item["finish_reason"] != "length": |
| return {**item, "attempts": attempts, |
| "error": None if item["finish_reason"] == "stop" |
| else f"Unverified finish_reason={item['finish_reason']!r}"} |
| if budget >= self.max_tokens_cap: |
| return {**item, "attempts": attempts, |
| "error": f"Output truncated at max_tokens_cap={self.max_tokens_cap}"} |
| budget = min(self.max_tokens_cap, budget * 2) |
|
|
|
|
| class FloodgateClient: |
| def __init__(self, root, model, max_tokens, rps): |
| sys.path.insert(0, str(root / "model_evaluation_harness" / "code")) |
| from floodgate import Floodgate, RateLimiter |
|
|
| self.client = Floodgate(limiter=RateLimiter(rps)) |
| self.model, self.max_tokens = model, max_tokens |
|
|
| def ask(self, prompt, clips): |
| parts = [{"text": prompt}] |
| for label, frames in clips: |
| parts.append({"text": f"--- {label} ---"}) |
| for path in frames: |
| parts.append({"inlineData": {"mimeType": "image/jpeg", |
| "data": base64.b64encode(path.read_bytes()).decode("ascii")}}) |
| raw = self.client.generate(self.model, parts, max_tokens=self.max_tokens, |
| timeout=600, attempts=4, temperature=0.0) |
| return {"message": {"content": raw, "reasoning_content": None}, |
| "finish_reason": None, "usage": None, "max_tokens": self.max_tokens, |
| "attempts": [], "error": None} |
|
|
|
|
| def prompt_for(question, qid, dataset): |
| shown, back = shuffled_view(question["options"], qid) |
| n = len(question["answer"]) |
| letters = sorted(shown) |
| template = SINGLE_VIDEO_PROMPT if dataset.startswith("single_") else MULTI_VIDEO_PROMPT |
| prompt = template.format(question=question["question"], options="\n".join(f"{letter}. {shown[letter]}" for letter in letters), |
| n=n, plural="s" if n > 1 else "", example=", ".join(f'"{letter}"' for letter in letters[:n])) |
| return prompt, letters, back |
|
|
|
|
| def check_run_config(path, config): |
| if path.is_file(): |
| previous = json.loads(path.read_text(encoding="utf-8")) |
| if previous != config: |
| raise ValueError(f"Run configuration changed; choose another --run-id: {path}") |
| else: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8") |
|
|
|
|
| def run(args, dataset, root, work): |
| corpus_path, questions = load_questions(root, dataset) |
| if args.limit: |
| questions = questions[args.skip:args.skip + args.limit] |
| elif args.skip: |
| questions = questions[args.skip:] |
| run_dir = work / "runs" / args.run_id |
| prompt_template = SINGLE_VIDEO_PROMPT if dataset.startswith("single_") else MULTI_VIDEO_PROMPT |
| config = {"version": VERSION, "dataset": dataset, "corpus_sha256": file_hash(corpus_path), |
| "prompt_sha256": hashlib.sha256(prompt_template.encode()).hexdigest(), "model": args.model, |
| "backend": args.backend, |
| "thinking": args.thinking, "max_tokens": args.max_tokens, |
| "max_tokens_cap": args.max_tokens_cap, "frames_per_question": args.frames, |
| "min_frames_per_clip": args.min_frames, "max_width": args.max_width, |
| "frame_extractor": "ffmpeg fps=k/duration; scale=min(max_width,iw):-2", "temperature": 0.0} |
| if args.command == "run": |
| check_run_config(run_dir / f"{dataset}.config.json", config) |
| outfile = run_dir / f"{dataset}.jsonl" |
| done = set() |
| if outfile.is_file(): |
| for record in jsonl(outfile): |
| if not record.get("error"): |
| done.add(record["question_id"]) |
| questions = [q for q in questions if question_id(q, dataset) not in done] |
| if args.command == "run" and args.backend == "openai" and not args.base_url: |
| raise ValueError("--base-url is required for run") |
| client = None |
| if args.command == "run": |
| if args.backend == "floodgate": |
| if args.thinking != "auto": |
| raise ValueError("Floodgate backend does not support --thinking true/false") |
| client = FloodgateClient(root, args.model, args.max_tokens, args.rps) |
| else: |
| client = Client(args.base_url, args.model, args.api_key, args.thinking, |
| args.max_tokens, args.max_tokens_cap, args.rps) |
| resolver = MediaResolver(root, Path(args.single_clips).expanduser(), work / "cache" / "media") |
| prepared = [] |
| try: |
| for question in questions: |
| qid = question_id(question, dataset) |
| try: |
| clips = resolver.clips(dataset, question) |
| frames, quotas = extract_question_frames(dataset, qid, clips, work / "cache" / "frames", |
| args.frames, args.min_frames, args.max_width) |
| prepared.append((question, frames, quotas)) |
| if args.command == "prepare": |
| print(f"PREPARED {dataset} {qid} clips={len(frames)} frames={sum(len(f) for _, f in frames)} quotas={quotas}") |
| except Exception as exc: |
| prepared.append((question, exc, [])) |
| print(f"MEDIA_ERROR {dataset} {qid} {type(exc).__name__}: {exc}", flush=True) |
| finally: |
| resolver.close() |
| if args.command == "prepare": |
| print(f"PREPARE_DONE dataset={dataset} questions={len(questions)} ok={sum(not isinstance(f, Exception) for _, f, _ in prepared)}") |
| return |
|
|
| def evaluate(item): |
| question, frames, quotas = item |
| qid = question_id(question, dataset) |
| if isinstance(frames, Exception): |
| return {"question_id": qid, "dataset": dataset, "error": f"media:{type(frames).__name__}: {frames}"} |
| prompt, letters, back = prompt_for(question, qid, dataset) |
| started = time.time() |
| try: |
| response = client.ask(prompt, frames) |
| message = response.get("message") or {} |
| raw = message.get("content") or "" |
| inline_reasoning, answer_text = split_reasoning(raw) |
| reasoning = message.get("reasoning_content") or message.get("reasoning") or inline_reasoning |
| thinking_required = args.thinking == "true" or "thinking" in args.model.lower() |
| trace_present = bool(reasoning) or "Thinking Process:" in raw |
| base = {"question_id": qid, "dataset": dataset, "unit": question.get("unit"), |
| "model": args.model, "thinking": args.thinking, |
| "raw_message": message, "raw": raw, "reasoning_content": reasoning, |
| "thinking_trace_required": thinking_required, |
| "thinking_trace_present": trace_present, |
| "finish_reason": response.get("finish_reason"), "usage": response.get("usage"), |
| "max_tokens_used": response.get("max_tokens"), "attempts": response.get("attempts"), |
| "latency_s": round(time.time() - started, 1)} |
| if response.get("error"): |
| return {**base, "error": response["error"]} |
| if "<think>" in raw and "</think>" not in raw: |
| return {**base, "error": "Unclosed thinking trace; final answer unavailable"} |
| if thinking_required and not trace_present: |
| return {**base, "error": "Thinking trace missing from model response"} |
| displayed, parse_error = parse_answer(answer_text, letters) |
| if parse_error: |
| return {**base, "error": f"No parseable final answer: {parse_error}"} |
| prediction = sorted({back[x] for x in displayed if x in back}) |
| gold = sorted(question["answer"]) |
| return {**base, "question_type": question.get("question_type"), "n_select": len(gold), |
| "n_options": len(question["options"]), "n_clips": len(frames), |
| "n_frames": sum(len(f) for _, f in frames), "frame_quotas": quotas, |
| "pred": prediction, "gold": gold, |
| "exact": prediction == gold, "overlap": len(set(prediction) & set(gold)) / max(len(gold), 1), |
| "n_pred": len(prediction)} |
| except Exception as exc: |
| return {"question_id": qid, "dataset": dataset, "model": args.model, |
| "thinking": args.thinking, "error": f"{type(exc).__name__}: {str(exc)[:400]}"} |
|
|
| counts = collections.Counter() |
| outfile.parent.mkdir(parents=True, exist_ok=True) |
| with open(outfile, "a", encoding="utf-8") as output, ThreadPoolExecutor(max_workers=args.workers) as pool: |
| for future in as_completed([pool.submit(evaluate, item) for item in prepared]): |
| record = future.result() |
| output.write(json.dumps(record, ensure_ascii=False) + "\n") |
| output.flush() |
| counts["error" if record.get("error") else "ok"] += 1 |
| if sum(counts.values()) % 10 == 0: |
| print(f"PROGRESS {dataset} {sum(counts.values())}/{len(prepared)} ok={counts['ok']} error={counts['error']}", flush=True) |
| print(f"RUN_DONE dataset={dataset} ok={counts['ok']} error={counts['error']} output={outfile}") |
|
|
|
|
| def question_groups(questions, dataset): |
| groups = {"overall": questions} |
| if dataset == "mixed_1487": |
| groups["multi_video_531"] = [q for q in questions if q.get("unit") in MULTI_UNITS] |
| units = sorted({q.get("unit") for q in questions if q.get("unit")}) |
| if len(units) > 1: |
| for unit in units: |
| groups[unit] = [q for q in questions if q.get("unit") == unit] |
| return groups |
|
|
|
|
| def summarize(members, results, dataset): |
| """Score a question group. Primary metrics use every question as the denominator: |
| failed (error) and missing (never run) questions count as wrong.""" |
| total = len(members) |
| valid, failed = [], 0 |
| for q in members: |
| row = results.get(question_id(q, dataset)) |
| if row is None: |
| continue |
| if not row.get("error") and "exact" in row: |
| valid.append(row) |
| else: |
| failed += 1 |
| exact = sum(r["exact"] for r in valid) |
| pct = lambda x, n: 100 * x / n if n else 0.0 |
| return {"total": total, "completed": len(valid), "failed": failed, |
| "missing": total - len(valid) - failed, "exact": exact, |
| "exact_pct": pct(exact, total), "exact_completed_pct": pct(exact, len(valid)), |
| "overlap_pct": pct(sum(r["overlap"] for r in valid), total), |
| "wellformed_pct": pct(sum(r["n_pred"] == r["n_select"] for r in valid), total)} |
|
|
|
|
| def load_results(root, work, run_id, dataset): |
| """Return the latest record per question, warning if the corpus changed since the run.""" |
| run_dir = work / "runs" / run_id |
| path = run_dir / f"{dataset}.jsonl" |
| if not path.is_file(): |
| return None, None |
| config_path = run_dir / f"{dataset}.config.json" |
| config = json.loads(config_path.read_text(encoding="utf-8")) if config_path.is_file() else {} |
| corpus_path = root / DATASETS[dataset] |
| if config.get("corpus_sha256") and config["corpus_sha256"] != file_hash(corpus_path): |
| print(f"WARNING {run_id} {dataset}: corpus_sha256 differs from current {corpus_path}", file=sys.stderr) |
| return {row["question_id"]: row for row in jsonl(path)}, config |
|
|
|
|
| def score(root, work, run_id, dataset): |
| _, questions = load_questions(root, dataset) |
| results, _ = load_results(root, work, run_id, dataset) |
| if results is None: |
| print(f"NO_RESULTS {dataset} {work / 'runs' / run_id / f'{dataset}.jsonl'}") |
| return |
| overall = summarize(questions, results, dataset) |
| print(f"SCORE {dataset} completed={overall['completed']}/{overall['total']} " |
| f"failed={overall['failed']} missing={overall['missing']}") |
| if overall["missing"]: |
| print(f" PARTIAL RUN: {overall['missing']} questions have no result; this is not a full-run score") |
| for name, members in question_groups(questions, dataset).items(): |
| s = summarize(members, results, dataset) |
| if s["total"]: |
| print(f" {name}: exact={s['exact']}/{s['total']} ({s['exact_pct']:.2f}%) " |
| f"[completed-only {s['exact']}/{s['completed']} ({s['exact_completed_pct']:.2f}%)] " |
| f"overlap={s['overlap_pct']:.2f}% wellformed={s['wellformed_pct']:.2f}% " |
| f"failed={s['failed']} missing={s['missing']}") |
|
|
|
|
| def compare(root, work, datasets): |
| """Show coverage and scores across recorded model/mode runs (failures count as wrong).""" |
| all_questions = {name: load_questions(root, name)[1] for name in datasets} |
| print("run_id\tmodel\tthinking\tdataset\tgroup\ttotal\tcompleted\tfailed\tmissing\t" |
| "exact\texact_pct\texact_completed_pct\toverlap_pct\twellformed_pct") |
| for run_dir in sorted((work / "runs").glob("*")): |
| if not run_dir.is_dir(): |
| continue |
| for dataset in datasets: |
| if not (run_dir / f"{dataset}.config.json").is_file(): |
| continue |
| results, config = load_results(root, work, run_dir.name, dataset) |
| if results is None: |
| continue |
| for group, members in question_groups(all_questions[dataset], dataset).items(): |
| s = summarize(members, results, dataset) |
| print(f"{run_dir.name}\t{config['model']}\t{config['thinking']}\t{dataset}\t{group}\t" |
| f"{s['total']}\t{s['completed']}\t{s['failed']}\t{s['missing']}\t{s['exact']}\t" |
| f"{s['exact_pct']:.2f}\t{s['exact_completed_pct']:.2f}\t{s['overlap_pct']:.2f}\t" |
| f"{s['wellformed_pct']:.2f}") |
|
|
|
|
| def inventory(root, single_clips, datasets): |
| for dataset in datasets: |
| _, questions = load_questions(root, dataset) |
| units = collections.Counter(q.get("unit") for q in questions) |
| choices = collections.Counter(len(q["answer"]) for q in questions) |
| print(f"{dataset}: questions={len(questions)} units={dict(units)} answer_count={dict(choices)}") |
| if dataset.startswith("single_"): |
| missing = [q["id"] for q in questions if not (single_clips / f"{q['id']}.mp4").is_file()] |
| print(f" media={len(questions)-len(missing)}/{len(questions)} missing={missing[:10]}") |
| else: |
| bundles = collections.Counter(q["bundle"] for q in questions) |
| missing = [b for b in bundles if not (root / "annotation_bundles" / f"{b}.tar").is_file()] |
| print(f" bundles={dict(bundles)} missing={missing}") |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("command", choices=["inventory", "prepare", "run", "score", "compare"]) |
| parser.add_argument("--dataset", choices=[*DATASETS, "both"], default="both") |
| parser.add_argument("--root", default="~/datasets/RunningBench") |
| parser.add_argument("--single-clips", default="~/datasets/seg600_verification/videoclips") |
| parser.add_argument("--work-dir", default="~/datasets/RunningBench/unified_eval/work") |
| parser.add_argument("--run-id", default="qwen3vl8b-instruct-v1") |
| parser.add_argument("--model", default="Qwen/Qwen3-VL-8B-Instruct") |
| parser.add_argument("--backend", choices=["openai", "floodgate"], default="openai") |
| parser.add_argument("--base-url", default=None) |
| parser.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY", "EMPTY")) |
| parser.add_argument("--thinking", choices=["auto", "true", "false"], default="auto") |
| parser.add_argument("--max-tokens", type=int, default=2048) |
| parser.add_argument("--max-tokens-cap", type=int, default=32768) |
| parser.add_argument("--frames", type=int, default=64) |
| parser.add_argument("--min-frames", type=int, default=4) |
| parser.add_argument("--max-width", type=int, default=480) |
| parser.add_argument("--workers", type=int, default=2) |
| parser.add_argument("--rps", type=float, default=0.4) |
| parser.add_argument("--skip", type=int, default=0) |
| parser.add_argument("--limit", type=int, default=0) |
| args = parser.parse_args() |
| if args.max_tokens < 1 or args.max_tokens_cap < args.max_tokens: |
| parser.error("--max-tokens-cap must be >= positive --max-tokens") |
| root = Path(args.root).expanduser() |
| work = Path(args.work_dir).expanduser() |
| selected = ["single_698", "mixed_1487"] if args.dataset == "both" else [args.dataset] |
| if args.command == "inventory": |
| inventory(root, Path(args.single_clips).expanduser(), selected) |
| elif args.command == "score": |
| for dataset in selected: |
| score(root, work, args.run_id, dataset) |
| elif args.command == "compare": |
| compare(root, work, selected) |
| else: |
| for dataset in selected: |
| run(args, dataset, root, work) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
