#!/usr/bin/env python3 from __future__ import annotations import argparse import ctypes import gc import json import os import re if not (os.environ.get("FORCE_QWENVL_VIDEO_READER") or "").strip(): os.environ["FORCE_QWENVL_VIDEO_READER"] = "torchvision" if not (os.environ.get("AV_LOG_LEVEL") or "").strip(): os.environ["AV_LOG_LEVEL"] = "quiet" import site import tempfile import shutil from pathlib import Path from statistics import mean, median from typing import Any, Dict, List, Optional _npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib" _npp_so = _npp_lib / "libnppicc.so.12" if _npp_so.is_file(): ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL) import torch from tqdm import tqdm DEFAULT_OUTPUT_DIR = Path("./eval_results/vggsoundsync") _openai_client = None GPT_JUDGE_SYSTEM = """\ You are a structured-output extractor. The user will give you a model's free-text \ response about audio-video synchronization. Extract the following fields and return \ ONLY valid JSON (no markdown, no explanation): {"synced": , "direction": "none"|"delay"|"early", "offset_sec": } Rules: - synced: true if the model says audio and video are synchronized, false otherwise. - direction: "delay" means audio comes AFTER the visual event; "early" means audio \ comes BEFORE the visual event; "none" if synced is true. - offset_sec: estimated time gap in seconds. 0.0 if synced. - If you cannot determine a field, use the default (true / "none" / 0.0). """ def _get_openai_client(api_key: Optional[str] = None): global _openai_client if _openai_client is not None: return _openai_client key = api_key or os.environ.get("OPENAI_API_KEY") if not key: return None from openai import OpenAI _openai_client = OpenAI(api_key=key) return _openai_client def gpt_extract_prediction(raw_output: str, api_key: Optional[str] = None, model: str = "gpt-5.4") -> Optional[Dict[str, Any]]: client = _get_openai_client(api_key) if client is None: return None try: resp = client.chat.completions.create( model=model, messages=[ {"role": "system", "content": GPT_JUDGE_SYSTEM}, {"role": "user", "content": raw_output}, ], temperature=0.0, max_completion_tokens=200, ) text = resp.choices[0].message.content.strip() for pat in [ re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL), re.compile(r"(\{.*?\})", re.DOTALL), ]: m = pat.search(text) if m: obj = json.loads(m.group(1)) synced = obj.get("synced") if isinstance(synced, str): synced = synced.lower() in ("true", "yes", "1") direction = str(obj.get("direction", "none")).lower().strip() if direction not in ("delay", "early", "none"): direction = "none" return { "pred_synced": bool(synced), "pred_direction": direction, "pred_offset_sec": float(obj.get("offset_sec", 0.0)), "parse_method": "gpt_judge", } except Exception as exc: print(f" [gpt-judge] API error: {exc}", flush=True) return None MCQ_PROMPT = """\ Watch this video and listen to its audio carefully. Determine the synchronization status between the audio and video tracks. Select the best answer: A) The audio and video are synchronized. B) The audio is delayed (comes after the visual event). C) The audio is early (comes before the visual event). Answer with only the letter (A, B, or C).""" MCQ_PROMPT_SHUFFLED = """\ Watch this video and listen to its audio carefully. Determine the synchronization status between the audio and video tracks. Select the best answer: A) The audio is early (comes before the visual event). B) The audio and video are synchronized. C) The audio is delayed (comes after the visual event). Answer with only the letter (A, B, or C).""" FREETEXT_PROMPT = """\ Watch this video and listen to its audio carefully. \ Determine whether the audio and video tracks are synchronized. \ If they are not synchronized, identify the direction of the offset \ (audio delayed or audio early relative to video) and estimate the offset in seconds. \ Explain your reasoning.""" def parse_args() -> argparse.Namespace: p = argparse.ArgumentParser(description="Evaluate on VGG-Sound Sync (out-of-domain sync).") p.add_argument("--base-model", type=str, required=True) p.add_argument("--adapter", type=str, default=None) p.add_argument("--test-jsonl", type=Path, required=True) p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR) p.add_argument("--mode", choices=["mcq", "freetext"], default="mcq") p.add_argument("--max-samples", type=int, default=-1) p.add_argument("--max-new-tokens", type=int, default=64) p.add_argument("--temperature", type=float, default=0.0) p.add_argument("--label", type=str, default=None) p.add_argument("--gpt-judge", action="store_true", default=False) p.add_argument("--openai-api-key", type=str, default=None) p.add_argument("--gpt-model", type=str, default="gpt-5.4") p.add_argument("--shuffle-mcq", action="store_true", default=False) p.add_argument("--vllm", action="store_true", default=False) p.add_argument("--tp", type=int, default=None) p.add_argument("--batch-size", type=int, default=16) p.add_argument("--gpu-memory-utilization", type=float, default=0.90) p.add_argument("--max-model-len", type=int, default=65536) return p.parse_args() def load_test_data(path: Path, max_samples: int) -> List[Dict[str, Any]]: base = path.parent.resolve() data = [] with open(path) as f: for line in f: line = line.strip() if not line: continue obj = json.loads(line) for key in ("video_path", "audio_path"): if key not in obj or not obj[key]: continue p = Path(obj[key]) if not p.is_absolute(): obj[key] = str((base / p).resolve()) data.append(obj) if max_samples > 0: data = data[:max_samples] return data SYSTEM_PROMPT = ( "You are Qwen, a virtual human developed by the Qwen Team, Alibaba " "Group, capable of perceiving auditory and visual inputs, as well as " "generating text and speech." ) def preprocess_video_for_vllm(video_path: str): from qwen_omni_utils import process_mm_info import numpy as np messages = [{ "role": "user", "content": [ {"type": "video", "video": video_path, "fps": 2.0, "max_frames": 128}, {"type": "text", "text": "placeholder"}, ], }] audios, images, videos = process_mm_info(messages, use_audio_in_video=True) video_tensor = videos[0] return (video_tensor * 255).byte().numpy() def preprocess_audio_for_vllm(audio_path: str, target_sr: int = 16000): import numpy as np import wave with wave.open(audio_path, "rb") as w: sr = w.getframerate() n = w.getnframes() raw = w.readframes(n) x = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0 if sr != target_sr: duration = len(x) / sr new_len = int(duration * target_sr) x = np.interp( np.linspace(0, len(x) - 1, new_len), np.arange(len(x)), x, ) return x, target_sr def build_vllm_prompt(question: str, base_model: str, include_audio: bool = True) -> str: from omni_model_loading import vllm_user_mm_prefix mm = vllm_user_mm_prefix(base_model, include_audio=include_audio) return ( f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n" f"<|im_start|>user\n" f"{mm}" f"{question}<|im_end|>\n" f"<|im_start|>assistant\n" ) def load_model(base_model: str, adapter: Optional[str]): from omni_model_loading import load_qwen_omni_model model, processor, _ = load_qwen_omni_model(base_model, adapter) return model, processor def run_inference(model, processor, video_path: str, audio_path: str, prompt: str, max_new_tokens: int, temperature: float) -> str: from qwen_omni_utils import process_mm_info tmp_dir = tempfile.mkdtemp(prefix="eval_vggsync_") masked_video = os.path.join(tmp_dir, "clip.mp4") masked_audio = os.path.join(tmp_dir, "clip.wav") os.symlink(os.path.abspath(video_path), masked_video) os.symlink(os.path.abspath(audio_path), masked_audio) conversation = [{ "role": "user", "content": [ {"type": "video", "video": masked_video}, {"type": "audio", "audio": masked_audio}, {"type": "text", "text": prompt}, ], }] text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False) audios, images, videos = process_mm_info(conversation, use_audio_in_video=True) inputs = processor( text=text, audio=audios, images=images, videos=videos, return_tensors="pt", padding=True, use_audio_in_video=True, ) model_dtype = next(model.parameters()).dtype converted = {} for k, v in inputs.items(): if hasattr(v, "to"): v = v.to(model.device) if torch.is_floating_point(v): v = v.to(model_dtype) converted[k] = v inputs = converted from omni_model_loading import is_omni_thinker_model is_thinker = is_omni_thinker_model(model) if is_thinker: gen_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": temperature > 0} else: gen_kwargs = { "thinker_max_new_tokens": max_new_tokens, "use_audio_in_video": True, "return_audio": False, "do_sample": temperature > 0, } if temperature > 0: gen_kwargs["temperature"] = temperature gen_kwargs["top_p"] = 0.9 with torch.inference_mode(): output_ids = model.generate(**inputs, **gen_kwargs) if isinstance(output_ids, tuple): output_ids = output_ids[0] prompt_len = inputs["input_ids"].shape[1] response = processor.batch_decode( output_ids[:, prompt_len:], skip_special_tokens=True, )[0].strip() shutil.rmtree(tmp_dir, ignore_errors=True) return response def extract_mcq_answer(text: str, answer_map: Optional[Dict[str, str]] = None) -> Dict[str, Any]: text = text.strip().upper() m = re.search(r"[ABC]", text) letter = m[0] if m else "" if answer_map is None: answer_map = {"A": "synced", "B": "delay", "C": "early"} key_to_pred = { "synced": {"pred_synced": True, "pred_direction": "none"}, "delay": {"pred_synced": False, "pred_direction": "delay"}, "early": {"pred_synced": False, "pred_direction": "early"}, } if letter in answer_map and answer_map[letter] in key_to_pred: return {**key_to_pred[answer_map[letter]], "pred_offset_sec": 0.0, "pred_letter": letter, "parse_method": "mcq"} return {"pred_synced": True, "pred_direction": "none", "pred_offset_sec": 0.0, "pred_letter": "", "parse_method": "mcq_failed"} def extract_freetext_prediction(text: str) -> Dict[str, Any]: text_stripped = text.strip() for pattern in [ re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL), re.compile(r"(\{[^{}]*\"synced\"[^{}]*\})", re.DOTALL), re.compile(r"(\{.*?\})", re.DOTALL), ]: m = pattern.search(text_stripped) if m: try: obj = json.loads(m.group(1)) synced = obj.get("synced") if isinstance(synced, str): synced = synced.lower() in ("true", "yes", "1") direction = str(obj.get("direction", "none")).lower().strip() if direction not in ("delay", "early", "none"): direction = "none" return { "pred_synced": bool(synced), "pred_direction": direction, "pred_offset_sec": float(obj.get("offset_sec", 0.0)), "parse_method": "json", } except (json.JSONDecodeError, ValueError, TypeError): continue text_lower = text_stripped.lower() synced = None direction = "none" offset = 0.0 desync_kws = ["not synchronized", "not aligned", "desync", "mismatch", "not in sync", "out of sync", "not well aligned"] sync_kws = ["synchronized", "well aligned", "well-aligned", "in sync", "closely aligned", "matches closely"] if any(kw in text_lower for kw in desync_kws): synced = False elif any(kw in text_lower for kw in sync_kws): synced = True if synced is False: delay_kws = ["audio delayed", "audio lags", "audio comes after", "sound comes after", "audio is delayed", "sound follows"] early_kws = ["audio early", "audio leads", "audio comes before", "sound comes before", "audio precedes", "audio is early"] if any(kw in text_lower for kw in delay_kws): direction = "delay" elif any(kw in text_lower for kw in early_kws): direction = "early" offset_match = re.search( r"(?:gap|offset|mismatch|differ\w*)\s*(?:of\s+)?(?:about\s+|roughly\s+|approximately\s+)?" r"([\d]+\.?\d*)\s*s", text_lower) if offset_match: offset = float(offset_match.group(1)) if synced is None: synced = True return { "pred_synced": synced, "pred_direction": direction, "pred_offset_sec": offset, "parse_method": "regex_fallback", } DIFFICULTY_ORDER = ["synced", "hard", "medium", "easy", "very_easy"] def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]: total = len(results) if total == 0: return {} sync_correct = sum(1 for r in results if r["pred_synced"] == r["gt_synced"]) sync_acc = sync_correct / total def _label(r, prefix): if r[f"{prefix}synced"]: return "synced" return r[f"{prefix}direction"] three_class_correct = sum(1 for r in results if _label(r, "pred_") == _label(r, "gt_")) three_class_acc = three_class_correct / total desync = [r for r in results if not r["gt_synced"]] if desync: dir_correct = sum(1 for r in desync if r["pred_direction"] == r["gt_direction"]) dir_acc = dir_correct / len(desync) else: dir_acc = None per_difficulty = {} for d in DIFFICULTY_ORDER: subset = [r for r in results if r["difficulty"] == d] if not subset: continue if d == "synced": acc = sum(1 for r in subset if r["pred_synced"]) / len(subset) else: acc = sum(1 for r in subset if _label(r, "pred_") == _label(r, "gt_")) / len(subset) per_difficulty[d] = {"accuracy": round(acc, 4), "count": len(subset)} per_class: Dict[str, Dict] = {} classes = sorted(set(r.get("label", "") for r in results)) for cls in classes: subset = [r for r in results if r.get("label") == cls] if not subset: continue acc = sum(1 for r in subset if _label(r, "pred_") == _label(r, "gt_")) / len(subset) per_class[cls] = {"accuracy": round(acc, 4), "count": len(subset)} offset_errors = [] for r in desync: if not r["pred_synced"] and r["pred_offset_sec"] > 0: offset_errors.append(abs(r["pred_offset_sec"] - r["gt_offset_sec"])) parse_stats = {} for r in results: m = r.get("parse_method", "unknown") parse_stats[m] = parse_stats.get(m, 0) + 1 metrics = { "total_samples": total, "sync_desync_accuracy": round(sync_acc, 4), "three_class_accuracy": round(three_class_acc, 4), "direction_accuracy_on_desync": round(dir_acc, 4) if dir_acc is not None else None, "per_difficulty": per_difficulty, "per_class": per_class, "parse_stats": parse_stats, } if offset_errors: metrics["offset_mae_sec"] = round(mean(offset_errors), 4) metrics["offset_median_sec"] = round(median(offset_errors), 4) within_02 = sum(1 for e in offset_errors if e <= 0.2) within_05 = sum(1 for e in offset_errors if e <= 0.5) metrics["offset_within_0.2s"] = within_02 metrics["offset_within_0.5s"] = within_05 metrics["offset_evaluated_count"] = len(offset_errors) return metrics def print_summary(metrics: Dict[str, Any], label: str) -> None: print() print(f"{'=' * 65}") print(f" VGG-Sound Sync Eval: {label}") print(f"{'=' * 65}") print(f" Total samples: {metrics['total_samples']}") print(f" Sync/Desync Accuracy: {metrics['sync_desync_accuracy']:.1%}") print(f" 3-Class Accuracy: {metrics['three_class_accuracy']:.1%}") if metrics.get("direction_accuracy_on_desync") is not None: print(f" Direction Acc (desync): {metrics['direction_accuracy_on_desync']:.1%}") print(f" ─── Per Difficulty ───") for d in DIFFICULTY_ORDER: if d in metrics.get("per_difficulty", {}): info = metrics["per_difficulty"][d] print(f" {d:10s}: {info['accuracy']:.1%} ({info['count']} samples)") if metrics.get("offset_mae_sec") is not None: print(f" ─── Offset Estimation (freetext only) ───") print(f" MAE: {metrics['offset_mae_sec']:.3f}s") print(f" Median Error: {metrics['offset_median_sec']:.3f}s") print(f" Within 0.2s: {metrics['offset_within_0.2s']} / {metrics['offset_evaluated_count']}") print(f" Within 0.5s: {metrics['offset_within_0.5s']} / {metrics['offset_evaluated_count']}") print(f" ─── Parse Stats ───") for method, count in sorted(metrics.get("parse_stats", {}).items()): print(f" {method}: {count}") print(f"{'=' * 65}") def _extract_pred(raw_output: str, mode: str, gpt_judge: bool, openai_api_key: Optional[str], gpt_model: str, answer_map: Optional[Dict[str, str]] = None) -> Dict[str, Any]: if mode == "mcq": return extract_mcq_answer(raw_output, answer_map=answer_map) if gpt_judge and raw_output: gpt_pred = gpt_extract_prediction(raw_output, api_key=openai_api_key, model=gpt_model) if gpt_pred is not None: return gpt_pred return extract_freetext_prediction(raw_output) def _build_result(item: Dict, pred: Dict, raw_output: str, mode: str) -> Dict: result = { "uid": item["uid"], "ytid": item["ytid"], "label": item.get("label", ""), "difficulty": item["difficulty"], "gt_synced": item["gt_synced"], "gt_direction": item["gt_direction"], "gt_offset_sec": item["gt_offset_sec"], "pred_synced": pred["pred_synced"], "pred_direction": pred["pred_direction"], "pred_offset_sec": pred.get("pred_offset_sec", 0.0), "parse_method": pred["parse_method"], "raw_output": raw_output, } if mode == "mcq": result["pred_letter"] = pred.get("pred_letter", "") return result def _save_and_finalize(results_jsonl: Path, metrics_json: Path, summary_txt: Path, args, label: str): all_results = [] if results_jsonl.exists(): with open(results_jsonl) as f: for line in f: all_results.append(json.loads(line)) if not all_results: print("[warn] No results.") return metrics = compute_metrics(all_results) metrics["eval_config"] = { "base_model": args.base_model, "adapter": args.adapter, "mode": args.mode, "test_jsonl": str(args.test_jsonl), "max_new_tokens": args.max_new_tokens, "temperature": args.temperature, "vllm": args.vllm, } with open(metrics_json, "w", encoding="utf-8") as f: json.dump(metrics, f, indent=2, ensure_ascii=False) print_summary(metrics, label) with open(summary_txt, "w", encoding="utf-8") as f: import io, contextlib buf = io.StringIO() with contextlib.redirect_stdout(buf): print_summary(metrics, label) f.write(buf.getvalue()) print(f"\n[output] Results: {results_jsonl}") print(f"[output] Metrics: {metrics_json}") print(f"[output] Summary: {summary_txt}") def main() -> None: args = parse_args() label = args.label or (Path(args.adapter).name if args.adapter else Path(args.base_model).name) default_prompt = MCQ_PROMPT if args.mode == "mcq" else FREETEXT_PROMPT if args.gpt_judge and args.mode == "freetext": client = _get_openai_client(args.openai_api_key) if client is None: print("[ERROR] --gpt-judge requires OPENAI_API_KEY or --openai-api-key.") raise SystemExit(1) out_dir = args.output_dir / label out_dir.mkdir(parents=True, exist_ok=True) results_jsonl = out_dir / "eval_results.jsonl" metrics_json = out_dir / "metrics.json" summary_txt = out_dir / "summary.txt" test_data = load_test_data(args.test_jsonl, args.max_samples) print(f"[data] {len(test_data)} samples loaded (mode={args.mode})") processed = set() if results_jsonl.exists(): with open(results_jsonl) as f: for line in f: processed.add(json.loads(line)["uid"]) print(f"[resume] {len(processed)} already done") use_vllm = args.vllm if use_vllm: from vllm import LLM, SamplingParams tp = args.tp or torch.cuda.device_count() todo = [item for item in test_data if item["uid"] not in processed] uniq_v = list(dict.fromkeys(item["video_path"] for item in todo)) uniq_a = list(dict.fromkeys(item["audio_path"] for item in todo)) print( f"[vllm] Phase 1 — CPU preprocess: {len(uniq_v)} unique videos, {len(uniq_a)} unique audios " f"for {len(todo)} samples (GPUs idle until model load).", flush=True, ) preprocessed_v: Dict[str, Any] = {} preprocessed_a: Dict[str, Any] = {} failed_paths: set = set() for vp in tqdm(uniq_v, desc="Preprocess video", unit="file"): if vp in failed_paths: continue try: preprocessed_v[vp] = preprocess_video_for_vllm(vp) except Exception as e: failed_paths.add(vp) print(f" [skip] video preprocess error: {Path(vp).name}: {e}") for ap in tqdm(uniq_a, desc="Preprocess audio", unit="file"): if ap in failed_paths: continue try: preprocessed_a[ap] = preprocess_audio_for_vllm(ap) except Exception as e: failed_paths.add(ap) print(f" [skip] audio preprocess error: {Path(ap).name}: {e}") n_skip = sum(1 for item in todo if item["video_path"] in failed_paths or item["audio_path"] in failed_paths) if failed_paths: print(f"[vllm] Preprocess failed for {len(failed_paths)} path(s), " f"{n_skip} sample(s) will be skipped.") from omni_model_loading import cap_vllm_max_model_len vllm_max_len = cap_vllm_max_model_len(args.base_model, args.max_model_len) print(f"[vllm] Loading {args.base_model} with tp={tp} (max_model_len={vllm_max_len}) ...") llm = LLM( model=args.base_model, tensor_parallel_size=tp, max_model_len=vllm_max_len, max_num_seqs=4, limit_mm_per_prompt={"video": 1, "audio": 1}, gpu_memory_utilization=args.gpu_memory_utilization, dtype="bfloat16", trust_remote_code=True, ) sampling_params = SamplingParams( temperature=args.temperature if args.temperature > 0 else 0.0, top_p=0.9 if args.temperature > 0 else 1.0, max_tokens=args.max_new_tokens, ) vllm_todo = [item for item in todo if item["video_path"] not in failed_paths and item["audio_path"] not in failed_paths] fallback_items = [item for item in todo if item["video_path"] in failed_paths or item["audio_path"] in failed_paths] print(f"[vllm] {len(vllm_todo)} samples ready, {len(fallback_items)} deferred to fallback ...") for i, item in enumerate(vllm_todo): if item["uid"] in processed: continue item_prompt = item.get("mcq_prompt", default_prompt) if args.mode == "mcq" else default_prompt item_answer_map = item.get("mcq_answer_map") if args.mode == "mcq" else None inp = { "prompt": build_vllm_prompt(item_prompt, args.base_model, include_audio=True), "multi_modal_data": { "video": preprocessed_v[item["video_path"]], "audio": preprocessed_a[item["audio_path"]], }, } try: outputs = llm.generate([inp], sampling_params=sampling_params) raw_output = outputs[0].outputs[0].text.strip() except (ValueError, RuntimeError) as exc: print(f" [error] {item['uid']}: {exc}") raw_output = "" pred = _extract_pred(raw_output, args.mode, args.gpt_judge, args.openai_api_key, args.gpt_model, answer_map=item_answer_map) result = _build_result(item, pred, raw_output, args.mode) with open(results_jsonl, "a", encoding="utf-8") as f: f.write(json.dumps(result, ensure_ascii=False) + "\n") processed.add(item["uid"]) if (i + 1) % 100 == 0: print(f" [vllm] [{i + 1}/{len(vllm_todo)}] done") preprocessed_v.clear() preprocessed_a.clear() if fallback_items: print(f"[fallback] Running {len(fallback_items)} samples with transformers ...") del llm gc.collect() torch.cuda.empty_cache() model, processor = load_model(args.base_model, args.adapter) for item in tqdm(fallback_items, desc="Fallback", unit="q"): if item["uid"] in processed: continue item_prompt = item.get("mcq_prompt", default_prompt) if args.mode == "mcq" else default_prompt item_answer_map = item.get("mcq_answer_map") if args.mode == "mcq" else None try: raw_output = run_inference( model, processor, item["video_path"], item["audio_path"], item_prompt, args.max_new_tokens, args.temperature, ) except Exception as exc: import traceback print(f" [error] {item['uid']}: {exc}") traceback.print_exc() raw_output = "" pred = _extract_pred(raw_output, args.mode, args.gpt_judge, args.openai_api_key, args.gpt_model, answer_map=item_answer_map) result = _build_result(item, pred, raw_output, args.mode) with open(results_jsonl, "a", encoding="utf-8") as f: f.write(json.dumps(result, ensure_ascii=False) + "\n") processed.add(item["uid"]) gc.collect() torch.cuda.empty_cache() else: model, processor = load_model(args.base_model, args.adapter) for item in tqdm(test_data, desc="VGGSync", unit="q"): if item["uid"] in processed: continue if not os.path.exists(item["video_path"]): print(f" [skip] video not found: {item['video_path']}") continue if not os.path.exists(item["audio_path"]): print(f" [skip] audio not found: {item['audio_path']}") continue item_prompt = item.get("mcq_prompt", default_prompt) if args.mode == "mcq" else default_prompt item_answer_map = item.get("mcq_answer_map") if args.mode == "mcq" else None try: raw_output = run_inference( model, processor, item["video_path"], item["audio_path"], item_prompt, args.max_new_tokens, args.temperature, ) except Exception as exc: import traceback print(f" [error] {item['uid']}: {exc}") traceback.print_exc() raw_output = "" pred = _extract_pred(raw_output, args.mode, args.gpt_judge, args.openai_api_key, args.gpt_model, answer_map=item_answer_map) result = _build_result(item, pred, raw_output, args.mode) with open(results_jsonl, "a", encoding="utf-8") as f: f.write(json.dumps(result, ensure_ascii=False) + "\n") processed.add(item["uid"]) gc.collect() torch.cuda.empty_cache() _save_and_finalize(results_jsonl, metrics_json, summary_txt, args, label) if __name__ == "__main__": main()