| |
| from audio_llm_benchmark_shifted import main |
|
|
|
|
| if __name__ == "__main__": |
| main() |
| ''' |
| """ |
| Audio-LLM benchmark on shifted delay/early sets (126 videos from 63 source ids). |
| |
| Outputs align with previous stress-test style: |
| - delay_results.jsonl |
| - early_results.jsonl |
| - summary.json |
| - missing_or_errors.json |
| |
| And organized into four subfolders under output root: |
| - audio/ (extracted audio files) |
| - gemini/ (Gemini-only per-split results) |
| - qwen2/ (Qwen2-only per-split results) |
| - qwen3/ (Qwen3-only per-split results) |
| """ |
| |
| from __future__ import annotations |
| |
| import argparse |
| import csv |
| import json |
| import os |
| import re |
| import subprocess |
| import time |
| from pathlib import Path |
| from typing import Any, Dict, List, Optional, Tuple |
| |
| import librosa |
| import numpy as np |
| import torch |
| from tqdm import tqdm |
| from transformers import AutoModelForCausalLM, AutoProcessor |
| |
| try: |
| import google.generativeai as genai |
| except Exception: # pragma: no cover |
| genai = None |
| |
| |
| UNIVERSAL_PROMPT = ( |
| "Listen to this audio clip carefully. You are an expert in acoustic forensics. " |
| "Locate the EXACT timestamp (in seconds) of the loudest, most energetic PHYSICAL IMPACT sound " |
| "(e.g., body hitting ground, object breaking). Actively ignore background music, laughter, and speech. " |
| 'Output strictly in JSON format: {"audio_timestamp": 2.5, "sound_description": "brief description"}' |
| ) |
| |
| DEFAULT_SOURCE_CSV = Path( |
| "/home/ubuntu/video_source/result/gemini_video_oc_frame/gemini_validated_accept_lt1p0.csv" |
| ) |
| DEFAULT_DELAY_DIR = Path("/home/ubuntu/video_source/shifted/delay") |
| DEFAULT_EARLY_DIR = Path("/home/ubuntu/video_source/shifted/early") |
| DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/video_source/result/audio_llm_benchmark") |
| |
| DEFAULT_AUDIO_SR = 16000 |
| DEFAULT_AUDIO_FORMAT = "wav" |
| DEFAULT_SEED = 42 |
| DEFAULT_SAMPLE_SIZE = 0 # 0 = all rows |
| |
| GEMINI_MODEL = "gemini-3.1-pro-preview" |
| QWEN2_MODEL_ID = "Qwen/Qwen2-Audio-7B-Instruct" |
| QWEN3_MODEL_ID = "Qwen/Qwen3-Omni-30B-A3B-Instruct" |
| |
| GEMINI_FILE_READY_TIMEOUT_SECONDS = 120 |
| GEMINI_FILE_POLL_SECONDS = 2 |
| |
| |
| def parse_args() -> argparse.Namespace: |
| p = argparse.ArgumentParser(description="Benchmark Gemini/Qwen2/Qwen3 on shifted audio grounding.") |
| p.add_argument("--source-csv", type=Path, default=DEFAULT_SOURCE_CSV) |
| p.add_argument("--delay-dir", type=Path, default=DEFAULT_DELAY_DIR) |
| p.add_argument("--early-dir", type=Path, default=DEFAULT_EARLY_DIR) |
| p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR) |
| p.add_argument("--audio-sr", type=int, default=DEFAULT_AUDIO_SR) |
| p.add_argument("--audio-format", choices=["wav", "mp3"], default=DEFAULT_AUDIO_FORMAT) |
| p.add_argument("--sample-size", type=int, default=DEFAULT_SAMPLE_SIZE, help="0 means all rows in source CSV") |
| p.add_argument("--seed", type=int, default=DEFAULT_SEED) |
| p.add_argument("--delay-shift", type=float, default=2.0) |
| p.add_argument("--early-shift", type=float, default=-2.0) |
| p.add_argument("--disable-local-models", action="store_true") |
| p.add_argument("--overwrite-output", action="store_true") |
| return p.parse_args() |
| |
| |
| def ensure_ffmpeg() -> None: |
| subprocess.run( |
| ["ffmpeg", "-version"], |
| check=True, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| ) |
| |
| |
| def _extract_json_object(text: str) -> Dict[str, Any]: |
| text = text.strip() |
| fence_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL) |
| if fence_match: |
| return json.loads(fence_match.group(1)) |
| try: |
| return json.loads(text) |
| except json.JSONDecodeError: |
| pass |
| start = text.find("{") |
| end = text.rfind("}") |
| if start != -1 and end != -1 and end > start: |
| return json.loads(text[start : end + 1]) |
| raise ValueError("No valid JSON object found in model output.") |
| |
| |
| def _coerce_audio_result(data: Dict[str, Any]) -> Tuple[float, str]: |
| if "audio_timestamp" not in data or "sound_description" not in data: |
| raise ValueError(f"Missing keys in JSON output: {data}") |
| ts = float(data["audio_timestamp"]) |
| if not np.isfinite(ts): |
| raise ValueError(f"audio_timestamp is not finite: {ts}") |
| desc = str(data["sound_description"]).strip() |
| if not desc: |
| raise ValueError("sound_description is empty.") |
| return ts, desc |
| |
| |
| def append_jsonl(path: Path, payload: Dict[str, Any]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("a", encoding="utf-8") as f: |
| f.write(json.dumps(payload, ensure_ascii=False) + "\n") |
| |
| |
| def load_source_rows(path: Path, sample_size: int, seed: int) -> List[Tuple[str, float]]: |
| if not path.exists(): |
| raise FileNotFoundError(f"source CSV not found: {path}") |
| rows: List[Tuple[str, float]] = [] |
| with path.open("r", encoding="utf-8", newline="") as f: |
| reader = csv.DictReader(f) |
| fields = reader.fieldnames or [] |
| if "video_id" not in fields or "t_gemini" not in fields: |
| raise ValueError("source CSV must include columns: video_id, t_gemini") |
| for r in reader: |
| video_id = str(r.get("video_id", "")).strip() |
| if not video_id: |
| continue |
| try: |
| t_visual = float(r.get("t_gemini", "")) |
| except (TypeError, ValueError): |
| continue |
| rows.append((video_id, t_visual)) |
| if not rows: |
| raise ValueError("No valid rows parsed from source CSV.") |
| |
| if sample_size > 0 and len(rows) > sample_size: |
| rng = np.random.default_rng(seed) |
| idx = rng.choice(len(rows), size=sample_size, replace=False) |
| rows = [rows[int(i)] for i in idx] |
| rows.sort(key=lambda x: x[0]) |
| return rows |
| |
| |
| def index_by_filename(root: Path) -> Dict[str, Path]: |
| if not root.exists(): |
| raise FileNotFoundError(f"directory not found: {root}") |
| out: Dict[str, Path] = {} |
| for p in root.rglob("*.mp4"): |
| out.setdefault(p.name, p) |
| return out |
| |
| |
| def shifted_filename(video_id: str, split: str) -> str: |
| p = Path(video_id) |
| suffix = p.suffix if p.suffix else ".mp4" |
| stem = p.stem if p.suffix else p.name |
| if split == "delay": |
| return f"{stem}_delay2s{suffix}" |
| if split == "early": |
| return f"{stem}_early2s{suffix}" |
| raise ValueError(f"Unknown split: {split}") |
| |
| |
| def extract_audio_file(video_path: Path, dst_path: Path, sr: int, fmt: str) -> None: |
| dst_path.parent.mkdir(parents=True, exist_ok=True) |
| cmd = [ |
| "ffmpeg", |
| "-y", |
| "-i", |
| str(video_path), |
| "-vn", |
| "-ac", |
| "1", |
| "-ar", |
| str(sr), |
| ] |
| if fmt == "wav": |
| cmd += ["-c:a", "pcm_s16le"] |
| else: |
| cmd += ["-c:a", "libmp3lame", "-q:a", "2"] |
| cmd.append(str(dst_path)) |
| subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) |
| |
| |
| def wait_for_gemini_file_active(file_name: str) -> None: |
| deadline = time.time() + GEMINI_FILE_READY_TIMEOUT_SECONDS |
| while time.time() < deadline: |
| file_obj = genai.get_file(file_name) |
| state_obj = getattr(file_obj, "state", None) |
| state_name = str(getattr(state_obj, "name", state_obj)) |
| if state_name == "ACTIVE": |
| return |
| if state_name in {"FAILED", "CANCELLED"}: |
| raise RuntimeError(f"Gemini file processing failed: state={state_name}") |
| time.sleep(GEMINI_FILE_POLL_SECONDS) |
| raise TimeoutError("Gemini file did not become ACTIVE in time.") |
| |
| |
| def gemini_audio_grounding(audio_path: Path, gemini_api_key: str) -> Tuple[float, str]: |
| if genai is None: |
| raise RuntimeError("google-generativeai is not installed.") |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is missing.") |
| genai.configure(api_key=gemini_api_key) |
| model = genai.GenerativeModel(GEMINI_MODEL) |
| uploaded = genai.upload_file(path=str(audio_path)) |
| try: |
| wait_for_gemini_file_active(uploaded.name) |
| resp = model.generate_content([UNIVERSAL_PROMPT, uploaded]) |
| raw_text = getattr(resp, "text", "") or "" |
| if not raw_text: |
| raise ValueError("Gemini response text is empty.") |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| finally: |
| try: |
| genai.delete_file(uploaded.name) |
| except Exception: |
| pass |
| |
| |
| def load_qwen_model_and_processor(model_id: str) -> Tuple[Any, Any]: |
| processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True) |
| model = AutoModelForCausalLM.from_pretrained( |
| model_id, |
| torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, |
| device_map="auto" if torch.cuda.is_available() else None, |
| trust_remote_code=True, |
| ) |
| model.eval() |
| return model, processor |
| |
| |
| def _run_qwen_audio_chat(model: Any, processor: Any, audio_path: Path, prompt: str, label: str) -> str: |
| messages = [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "audio", "audio": str(audio_path)}, |
| {"type": "text", "text": prompt}, |
| ], |
| } |
| ] |
| try: |
| text_prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) |
| except Exception: |
| text_prompt = prompt |
| |
| audio_arr, sr = librosa.load(str(audio_path), sr=None, mono=True) |
| if audio_arr.size == 0: |
| raise RuntimeError(f"{label}: extracted audio is empty.") |
| |
| last_exc: Optional[Exception] = None |
| inputs = None |
| for kw in [ |
| {"text": [text_prompt], "audio": [audio_arr], "sampling_rate": sr}, |
| {"text": [text_prompt], "audios": [audio_arr], "sampling_rate": sr}, |
| ]: |
| try: |
| inputs = processor(return_tensors="pt", padding=True, **kw) |
| break |
| except Exception as exc: |
| last_exc = exc |
| if inputs is None: |
| raise RuntimeError(f"{label}: failed to build processor inputs: {last_exc}") |
| |
| dev = model.device if hasattr(model, "device") else torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| for k, v in list(inputs.items()): |
| if torch.is_tensor(v): |
| inputs[k] = v.to(dev) |
| |
| with torch.no_grad(): |
| output_ids = model.generate(**inputs, max_new_tokens=256, do_sample=False) |
| input_len = inputs["input_ids"].shape[1] if "input_ids" in inputs else 0 |
| gen_ids = output_ids[:, input_len:] if input_len > 0 else output_ids |
| return processor.batch_decode(gen_ids, skip_special_tokens=True)[0].strip() |
| |
| |
| def qwen2_audio_grounding(audio_path: Path, model: Any, processor: Any) -> Tuple[float, str]: |
| parsed = _extract_json_object(_run_qwen_audio_chat(model, processor, audio_path, UNIVERSAL_PROMPT, "Qwen2-Audio")) |
| return _coerce_audio_result(parsed) |
| |
| |
| def qwen3_audio_grounding(audio_path: Path, model: Any, processor: Any) -> Tuple[float, str]: |
| parsed = _extract_json_object(_run_qwen_audio_chat(model, processor, audio_path, UNIVERSAL_PROMPT, "Qwen3-Omni")) |
| return _coerce_audio_result(parsed) |
| |
| |
| def safe_call(fn, *args, **kwargs) -> Tuple[Optional[Tuple[float, str]], Optional[str]]: |
| try: |
| return fn(*args, **kwargs), None |
| except Exception as exc: |
| return None, str(exc) |
| |
| |
| def summarize_predictions(rows: List[Dict[str, Any]], key: str) -> Dict[str, Any]: |
| vals = [r.get(key) for r in rows] |
| with_pred = [v for v in vals if v is not None] |
| return { |
| "count": len(rows), |
| "with_prediction": len(with_pred), |
| "without_prediction": len(rows) - len(with_pred), |
| } |
| |
| |
| def main() -> None: |
| args = parse_args() |
| ensure_ffmpeg() |
| |
| gemini_api_key = os.getenv("GEMINI_API_KEY", "").strip() |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is required.") |
| |
| source_rows = load_source_rows(args.source_csv, args.sample_size, args.seed) |
| delay_index = index_by_filename(args.delay_dir) |
| early_index = index_by_filename(args.early_dir) |
| |
| out_root = args.output_dir |
| audio_dir = out_root / "audio" |
| gemini_dir = out_root / "gemini" |
| qwen2_dir = out_root / "qwen2" |
| qwen3_dir = out_root / "qwen3" |
| for d in [audio_dir, gemini_dir, qwen2_dir, qwen3_dir]: |
| d.mkdir(parents=True, exist_ok=True) |
| |
| delay_results_path = out_root / "delay_results.jsonl" |
| early_results_path = out_root / "early_results.jsonl" |
| missing_path = out_root / "missing_or_errors.json" |
| summary_path = out_root / "summary.json" |
| sampled_path = out_root / "sampled_10_from_gemini.csv" |
| |
| model_out = { |
| "gemini_delay": gemini_dir / "delay_results.jsonl", |
| "gemini_early": gemini_dir / "early_results.jsonl", |
| "qwen2_delay": qwen2_dir / "delay_results.jsonl", |
| "qwen2_early": qwen2_dir / "early_results.jsonl", |
| "qwen3_delay": qwen3_dir / "delay_results.jsonl", |
| "qwen3_early": qwen3_dir / "early_results.jsonl", |
| } |
| |
| if args.overwrite_output: |
| for p in [delay_results_path, early_results_path, missing_path, summary_path, sampled_path, *model_out.values()]: |
| if p.exists(): |
| p.unlink() |
| |
| qwen2_model = qwen2_processor = None |
| qwen3_model = qwen3_processor = None |
| if not args.disable_local_models: |
| try: |
| qwen2_model, qwen2_processor = load_qwen_model_and_processor(QWEN2_MODEL_ID) |
| except Exception: |
| qwen2_model = qwen2_processor = None |
| try: |
| qwen3_model, qwen3_processor = load_qwen_model_and_processor(QWEN3_MODEL_ID) |
| except Exception: |
| qwen3_model = qwen3_processor = None |
| |
| with sampled_path.open("w", encoding="utf-8", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=["video_id", "t_visual"]) |
| writer.writeheader() |
| for video_id, t_visual in source_rows: |
| writer.writerow({"video_id": video_id, "t_visual": round(t_visual, 3)}) |
| |
| delay_rows: List[Dict[str, Any]] = [] |
| early_rows: List[Dict[str, Any]] = [] |
| missing: List[Dict[str, Any]] = [] |
| |
| for video_id, t_visual in tqdm(source_rows, desc="Audio LLM Benchmark", unit="video"): |
| for split, shift, idx, combined_list, combined_path in [ |
| ("delay", args.delay_shift, delay_index, delay_rows, delay_results_path), |
| ("early", args.early_shift, early_index, early_rows, early_results_path), |
| ]: |
| shifted_name = shifted_filename(video_id, split) |
| video_path = idx.get(shifted_name) |
| if video_path is None: |
| missing.append({"split": split, "video_id": video_id, "reason": "file_not_found"}) |
| continue |
| |
| audio_path = audio_dir / split / f"{Path(video_id).stem}.{args.audio_format}" |
| try: |
| extract_audio_file(video_path, audio_path, args.audio_sr, args.audio_format) |
| except Exception as exc: |
| missing.append({"split": split, "video_id": video_id, "reason": f"audio_extract_failed: {exc}"}) |
| continue |
| |
| gemini_res, gemini_err = safe_call(gemini_audio_grounding, audio_path, gemini_api_key) |
| qwen2_res = qwen2_err = None |
| qwen3_res = qwen3_err = None |
| if qwen2_model is not None and qwen2_processor is not None: |
| qwen2_res, qwen2_err = safe_call(qwen2_audio_grounding, audio_path, qwen2_model, qwen2_processor) |
| if qwen3_model is not None and qwen3_processor is not None: |
| qwen3_res, qwen3_err = safe_call(qwen3_audio_grounding, audio_path, qwen3_model, qwen3_processor) |
| |
| if gemini_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"gemini_error: {gemini_err}"}) |
| if qwen2_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"qwen2_error: {qwen2_err}"}) |
| if qwen3_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"qwen3_error: {qwen3_err}"}) |
| |
| expected_t_audio = float(t_visual) + float(shift) |
| combined_row = { |
| "video_path": str(video_path), |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "gemini_t": round(gemini_res[0], 3) if gemini_res else None, |
| "qwen2_t": round(qwen2_res[0], 3) if qwen2_res else None, |
| "qwen3_t": round(qwen3_res[0], 3) if qwen3_res else None, |
| "gemini_desc": gemini_res[1] if gemini_res else None, |
| "qwen2_desc": qwen2_res[1] if qwen2_res else None, |
| "qwen3_desc": qwen3_res[1] if qwen3_res else None, |
| "audio_path": str(audio_path), |
| } |
| append_jsonl(combined_path, combined_row) |
| combined_list.append(combined_row) |
| |
| append_jsonl( |
| model_out[f"gemini_{split}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(gemini_res[0], 3) if gemini_res else None, |
| "sound_description": gemini_res[1] if gemini_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| append_jsonl( |
| model_out[f"qwen2_{split}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(qwen2_res[0], 3) if qwen2_res else None, |
| "sound_description": qwen2_res[1] if qwen2_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| append_jsonl( |
| model_out[f"qwen3_{split}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(qwen3_res[0], 3) if qwen3_res else None, |
| "sound_description": qwen3_res[1] if qwen3_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| |
| with missing_path.open("w", encoding="utf-8") as f: |
| json.dump(missing, f, ensure_ascii=False, indent=2) |
| |
| summary = { |
| "source_csv": str(args.source_csv), |
| "sample_size": len(source_rows), |
| "seed": args.seed, |
| "delay_shift": args.delay_shift, |
| "early_shift": args.early_shift, |
| "delay_summary": { |
| "count": len(delay_rows), |
| "gemini": summarize_predictions(delay_rows, "gemini_t"), |
| "qwen2": summarize_predictions(delay_rows, "qwen2_t"), |
| "qwen3": summarize_predictions(delay_rows, "qwen3_t"), |
| }, |
| "early_summary": { |
| "count": len(early_rows), |
| "gemini": summarize_predictions(early_rows, "gemini_t"), |
| "qwen2": summarize_predictions(early_rows, "qwen2_t"), |
| "qwen3": summarize_predictions(early_rows, "qwen3_t"), |
| }, |
| "missing_or_errors_count": len(missing), |
| "outputs": { |
| "delay_jsonl": str(delay_results_path), |
| "early_jsonl": str(early_results_path), |
| "missing_or_errors_json": str(missing_path), |
| "sampled_csv": str(sampled_path), |
| "audio_dir": str(audio_dir), |
| "gemini_dir": str(gemini_dir), |
| "qwen2_dir": str(qwen2_dir), |
| "qwen3_dir": str(qwen3_dir), |
| }, |
| } |
| with summary_path.open("w", encoding="utf-8") as f: |
| json.dump(summary, f, ensure_ascii=False, indent=2) |
| |
| print("========== Audio LLM Benchmark Summary ==========") |
| print(f"Sampled source videos: {len(source_rows)}") |
| print(f"Delay evaluated rows: {len(delay_rows)}") |
| print(f"Early evaluated rows: {len(early_rows)}") |
| print(f"Missing/errors: {len(missing)}") |
| print(f"Summary JSON: {summary_path}") |
| print("================================================") |
| |
| |
| if __name__ == "__main__": |
| main() |
| #!/usr/bin/env python3 |
| """ |
| Audio-LLM benchmark on shifted delay/early sets (126 videos from 63 source ids). |
| |
| Outputs are aligned with previous stress-test style: |
| - delay_results.jsonl |
| - early_results.jsonl |
| - summary.json |
| - missing_or_errors.json |
| |
| And results are organized under four subfolders in output root: |
| - audio/ (extracted wav files) |
| - gemini/ (model-only jsonl) |
| - qwen2/ (model-only jsonl) |
| - qwen3/ (model-only jsonl) |
| """ |
| |
| from __future__ import annotations |
| |
| import argparse |
| import csv |
| import json |
| import os |
| import re |
| import subprocess |
| import time |
| from pathlib import Path |
| from statistics import mean |
| from typing import Any, Dict, List, Optional, Tuple |
| |
| import librosa |
| import numpy as np |
| import torch |
| from tqdm import tqdm |
| from transformers import AutoModelForCausalLM, AutoProcessor |
| |
| try: |
| import google.generativeai as genai |
| except Exception: # pragma: no cover |
| genai = None |
| |
| |
| UNIVERSAL_PROMPT = ( |
| "Listen to this audio clip carefully. You are an expert in acoustic forensics. " |
| "Locate the EXACT timestamp (in seconds) of the loudest, most energetic PHYSICAL IMPACT sound " |
| "(e.g., body hitting ground, object breaking). Actively ignore background music, laughter, and speech. " |
| 'Output strictly in JSON format: {"audio_timestamp": 2.5, "sound_description": "brief description"}' |
| ) |
| |
| DEFAULT_SOURCE_CSV = Path( |
| "/home/ubuntu/video_source/result/gemini_video_oc_frame/gemini_validated_accept_lt1p0.csv" |
| ) |
| DEFAULT_DELAY_DIR = Path("/home/ubuntu/video_source/shifted/delay") |
| DEFAULT_EARLY_DIR = Path("/home/ubuntu/video_source/shifted/early") |
| DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/video_source/result/audio_llm_benchmark") |
| |
| DEFAULT_AUDIO_SR = 16000 |
| DEFAULT_AUDIO_FORMAT = "wav" |
| DEFAULT_SEED = 42 |
| DEFAULT_SAMPLE_SIZE = 0 # 0 means all |
| |
| GEMINI_MODEL = "gemini-3.1-pro-preview" |
| QWEN2_MODEL_ID = "Qwen/Qwen2-Audio-7B-Instruct" |
| QWEN3_MODEL_ID = "Qwen/Qwen3-Omni-30B-A3B-Instruct" |
| |
| GEMINI_FILE_READY_TIMEOUT_SECONDS = 120 |
| GEMINI_FILE_POLL_SECONDS = 2 |
| |
| |
| def parse_args() -> argparse.Namespace: |
| p = argparse.ArgumentParser(description="Benchmark Gemini/Qwen2/Qwen3 on shifted audio grounding.") |
| p.add_argument("--source-csv", type=Path, default=DEFAULT_SOURCE_CSV) |
| p.add_argument("--delay-dir", type=Path, default=DEFAULT_DELAY_DIR) |
| p.add_argument("--early-dir", type=Path, default=DEFAULT_EARLY_DIR) |
| p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR) |
| p.add_argument("--audio-sr", type=int, default=DEFAULT_AUDIO_SR) |
| p.add_argument("--audio-format", choices=["wav", "mp3"], default=DEFAULT_AUDIO_FORMAT) |
| p.add_argument("--sample-size", type=int, default=DEFAULT_SAMPLE_SIZE, help="0 means all rows in source-csv") |
| p.add_argument("--seed", type=int, default=DEFAULT_SEED) |
| p.add_argument("--delay-shift", type=float, default=2.0) |
| p.add_argument("--early-shift", type=float, default=-2.0) |
| p.add_argument("--disable-local-models", action="store_true") |
| p.add_argument("--overwrite-output", action="store_true") |
| return p.parse_args() |
| |
| |
| def ensure_ffmpeg() -> None: |
| subprocess.run( |
| ["ffmpeg", "-version"], |
| check=True, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| ) |
| |
| |
| def _extract_json_object(text: str) -> Dict[str, Any]: |
| text = text.strip() |
| fence_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL) |
| if fence_match: |
| return json.loads(fence_match.group(1)) |
| try: |
| return json.loads(text) |
| except json.JSONDecodeError: |
| pass |
| start = text.find("{") |
| end = text.rfind("}") |
| if start != -1 and end != -1 and end > start: |
| return json.loads(text[start : end + 1]) |
| raise ValueError("No valid JSON object found in model output.") |
| |
| |
| def _coerce_audio_result(data: Dict[str, Any]) -> Tuple[float, str]: |
| if "audio_timestamp" not in data or "sound_description" not in data: |
| raise ValueError(f"Missing keys in JSON output: {data}") |
| ts = float(data["audio_timestamp"]) |
| if not np.isfinite(ts): |
| raise ValueError(f"audio_timestamp is not finite: {ts}") |
| desc = str(data["sound_description"]).strip() |
| if not desc: |
| raise ValueError("sound_description is empty.") |
| return ts, desc |
| |
| |
| def append_jsonl(path: Path, payload: Dict[str, Any]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("a", encoding="utf-8") as f: |
| f.write(json.dumps(payload, ensure_ascii=False) + "\n") |
| |
| |
| def load_source_rows(path: Path, sample_size: int, seed: int) -> List[Tuple[str, float]]: |
| if not path.exists(): |
| raise FileNotFoundError(f"source CSV not found: {path}") |
| |
| rows: List[Tuple[str, float]] = [] |
| with path.open("r", encoding="utf-8", newline="") as f: |
| reader = csv.DictReader(f) |
| fields = reader.fieldnames or [] |
| if "video_id" not in fields or "t_gemini" not in fields: |
| raise ValueError("source CSV must include columns: video_id, t_gemini") |
| for r in reader: |
| video_id = str(r.get("video_id", "")).strip() |
| if not video_id: |
| continue |
| try: |
| t_visual = float(r.get("t_gemini", "")) |
| except (TypeError, ValueError): |
| continue |
| rows.append((video_id, t_visual)) |
| |
| if not rows: |
| raise ValueError("No valid rows parsed from source CSV.") |
| |
| if sample_size > 0 and len(rows) > sample_size: |
| rng = np.random.default_rng(seed) |
| idx = rng.choice(len(rows), size=sample_size, replace=False) |
| rows = [rows[int(i)] for i in idx] |
| rows.sort(key=lambda x: x[0]) |
| return rows |
| |
| |
| def index_by_filename(root: Path) -> Dict[str, Path]: |
| if not root.exists(): |
| raise FileNotFoundError(f"directory not found: {root}") |
| out: Dict[str, Path] = {} |
| for p in root.rglob("*.mp4"): |
| out.setdefault(p.name, p) |
| return out |
| |
| |
| def shifted_filename(video_id: str, split: str) -> str: |
| p = Path(video_id) |
| suffix = p.suffix if p.suffix else ".mp4" |
| stem = p.stem if p.suffix else p.name |
| if split == "delay": |
| return f"{stem}_delay2s{suffix}" |
| if split == "early": |
| return f"{stem}_early2s{suffix}" |
| raise ValueError(f"Unknown split: {split}") |
| |
| |
| def extract_audio_file(video_path: Path, dst_path: Path, sr: int, fmt: str) -> None: |
| dst_path.parent.mkdir(parents=True, exist_ok=True) |
| cmd = [ |
| "ffmpeg", |
| "-y", |
| "-i", |
| str(video_path), |
| "-vn", |
| "-ac", |
| "1", |
| "-ar", |
| str(sr), |
| ] |
| if fmt == "wav": |
| cmd += ["-c:a", "pcm_s16le"] |
| else: |
| cmd += ["-c:a", "libmp3lame", "-q:a", "2"] |
| cmd.append(str(dst_path)) |
| subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) |
| |
| |
| def wait_for_gemini_file_active(file_name: str) -> None: |
| deadline = time.time() + GEMINI_FILE_READY_TIMEOUT_SECONDS |
| while time.time() < deadline: |
| file_obj = genai.get_file(file_name) |
| state_obj = getattr(file_obj, "state", None) |
| state_name = str(getattr(state_obj, "name", state_obj)) |
| if state_name == "ACTIVE": |
| return |
| if state_name in {"FAILED", "CANCELLED"}: |
| raise RuntimeError(f"Gemini file processing failed: state={state_name}") |
| time.sleep(GEMINI_FILE_POLL_SECONDS) |
| raise TimeoutError("Gemini file did not become ACTIVE in time.") |
| |
| |
| def gemini_audio_grounding(audio_path: Path, gemini_api_key: str) -> Tuple[float, str]: |
| if genai is None: |
| raise RuntimeError("google-generativeai is not installed.") |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is missing.") |
| |
| genai.configure(api_key=gemini_api_key) |
| model = genai.GenerativeModel(GEMINI_MODEL) |
| uploaded = genai.upload_file(path=str(audio_path)) |
| try: |
| wait_for_gemini_file_active(uploaded.name) |
| resp = model.generate_content([UNIVERSAL_PROMPT, uploaded]) |
| raw_text = getattr(resp, "text", "") or "" |
| if not raw_text: |
| raise ValueError("Gemini response text is empty.") |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| finally: |
| try: |
| genai.delete_file(uploaded.name) |
| except Exception: |
| pass |
| |
| |
| def load_qwen_model_and_processor(model_id: str) -> Tuple[Any, Any]: |
| processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True) |
| model = AutoModelForCausalLM.from_pretrained( |
| model_id, |
| torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, |
| device_map="auto" if torch.cuda.is_available() else None, |
| trust_remote_code=True, |
| ) |
| model.eval() |
| return model, processor |
| |
| |
| def _run_qwen_audio_chat(model: Any, processor: Any, audio_path: Path, prompt: str, label: str) -> str: |
| messages = [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "audio", "audio": str(audio_path)}, |
| {"type": "text", "text": prompt}, |
| ], |
| } |
| ] |
| try: |
| text_prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) |
| except Exception: |
| text_prompt = prompt |
| |
| audio_arr, sr = librosa.load(str(audio_path), sr=None, mono=True) |
| if audio_arr.size == 0: |
| raise RuntimeError(f"{label}: extracted audio is empty.") |
| |
| last_exc: Optional[Exception] = None |
| candidate_kwargs = [ |
| {"text": [text_prompt], "audio": [audio_arr], "sampling_rate": sr}, |
| {"text": [text_prompt], "audios": [audio_arr], "sampling_rate": sr}, |
| ] |
| inputs = None |
| for kw in candidate_kwargs: |
| try: |
| inputs = processor(return_tensors="pt", padding=True, **kw) |
| break |
| except Exception as exc: |
| last_exc = exc |
| if inputs is None: |
| raise RuntimeError(f"{label}: failed to build processor inputs: {last_exc}") |
| |
| dev = model.device if hasattr(model, "device") else torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| for k, v in list(inputs.items()): |
| if torch.is_tensor(v): |
| inputs[k] = v.to(dev) |
| |
| with torch.no_grad(): |
| output_ids = model.generate(**inputs, max_new_tokens=256, do_sample=False) |
| input_len = inputs["input_ids"].shape[1] if "input_ids" in inputs else 0 |
| gen_ids = output_ids[:, input_len:] if input_len > 0 else output_ids |
| text = processor.batch_decode(gen_ids, skip_special_tokens=True)[0].strip() |
| return text |
| |
| |
| def qwen2_audio_grounding(audio_path: Path, model: Any, processor: Any) -> Tuple[float, str]: |
| raw_text = _run_qwen_audio_chat(model, processor, audio_path, UNIVERSAL_PROMPT, "Qwen2-Audio") |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| |
| |
| def qwen3_audio_grounding(audio_path: Path, model: Any, processor: Any) -> Tuple[float, str]: |
| raw_text = _run_qwen_audio_chat(model, processor, audio_path, UNIVERSAL_PROMPT, "Qwen3-Omni") |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| |
| |
| def safe_call(fn, *args, **kwargs) -> Tuple[Optional[Tuple[float, str]], Optional[str]]: |
| try: |
| return fn(*args, **kwargs), None |
| except Exception as exc: |
| return None, str(exc) |
| |
| |
| def summarize_errors(rows: List[Dict[str, Any]], model_key: str) -> Dict[str, Any]: |
| vals = [r.get(model_key) for r in rows] |
| with_pred = [float(v) for v in vals if v is not None] |
| return { |
| "count": len(rows), |
| "with_prediction": len(with_pred), |
| "without_prediction": len(rows) - len(with_pred), |
| } |
| |
| |
| def main() -> None: |
| args = parse_args() |
| ensure_ffmpeg() |
| |
| gemini_api_key = os.getenv("GEMINI_API_KEY", "").strip() |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is required.") |
| |
| rows = load_source_rows(args.source_csv, args.sample_size, args.seed) |
| delay_index = index_by_filename(args.delay_dir) |
| early_index = index_by_filename(args.early_dir) |
| |
| out_root = args.output_dir |
| audio_dir = out_root / "audio" |
| gemini_dir = out_root / "gemini" |
| qwen2_dir = out_root / "qwen2" |
| qwen3_dir = out_root / "qwen3" |
| for d in [audio_dir, gemini_dir, qwen2_dir, qwen3_dir]: |
| d.mkdir(parents=True, exist_ok=True) |
| |
| delay_results_path = out_root / "delay_results.jsonl" |
| early_results_path = out_root / "early_results.jsonl" |
| missing_path = out_root / "missing_or_errors.json" |
| summary_path = out_root / "summary.json" |
| sampled_path = out_root / "sampled_10_from_gemini.csv" |
| |
| model_out = { |
| "gemini_delay": gemini_dir / "delay_results.jsonl", |
| "gemini_early": gemini_dir / "early_results.jsonl", |
| "qwen2_delay": qwen2_dir / "delay_results.jsonl", |
| "qwen2_early": qwen2_dir / "early_results.jsonl", |
| "qwen3_delay": qwen3_dir / "delay_results.jsonl", |
| "qwen3_early": qwen3_dir / "early_results.jsonl", |
| } |
| |
| if args.overwrite_output: |
| for p in [delay_results_path, early_results_path, missing_path, summary_path, sampled_path, *model_out.values()]: |
| if p.exists(): |
| p.unlink() |
| |
| qwen2_model = qwen2_processor = None |
| qwen3_model = qwen3_processor = None |
| if not args.disable_local_models: |
| try: |
| qwen2_model, qwen2_processor = load_qwen_model_and_processor(QWEN2_MODEL_ID) |
| except Exception: |
| qwen2_model = qwen2_processor = None |
| try: |
| qwen3_model, qwen3_processor = load_qwen_model_and_processor(QWEN3_MODEL_ID) |
| except Exception: |
| qwen3_model = qwen3_processor = None |
| |
| delay_rows: List[Dict[str, Any]] = [] |
| early_rows: List[Dict[str, Any]] = [] |
| missing: List[Dict[str, Any]] = [] |
| |
| with sampled_path.open("w", encoding="utf-8", newline="") as f: |
| writer = csv.DictWriter(f, fieldnames=["video_id", "t_visual"]) |
| writer.writeheader() |
| for video_id, t_visual in rows: |
| writer.writerow({"video_id": video_id, "t_visual": round(t_visual, 3)}) |
| |
| for video_id, t_visual in tqdm(rows, desc="Audio LLM Benchmark", unit="video"): |
| for split, shift, idx, out_path, combined_rows, model_suffix in [ |
| ("delay", args.delay_shift, delay_index, delay_results_path, delay_rows, "delay"), |
| ("early", args.early_shift, early_index, early_results_path, early_rows, "early"), |
| ]: |
| shifted_name = shifted_filename(video_id, split) |
| video_path = idx.get(shifted_name) |
| if video_path is None: |
| missing.append({"split": split, "video_id": video_id, "reason": "file_not_found"}) |
| continue |
| |
| audio_path = audio_dir / split / f"{Path(video_id).stem}.{args.audio_format}" |
| try: |
| extract_audio_file(video_path, audio_path, args.audio_sr, args.audio_format) |
| except Exception as exc: |
| missing.append({"split": split, "video_id": video_id, "reason": f"audio_extract_failed: {exc}"}) |
| continue |
| |
| gemini_res, gemini_err = safe_call(gemini_audio_grounding, audio_path, gemini_api_key) |
| qwen2_res = qwen2_err = None |
| qwen3_res = qwen3_err = None |
| |
| if qwen2_model is not None and qwen2_processor is not None: |
| qwen2_res, qwen2_err = safe_call(qwen2_audio_grounding, audio_path, qwen2_model, qwen2_processor) |
| if qwen3_model is not None and qwen3_processor is not None: |
| qwen3_res, qwen3_err = safe_call(qwen3_audio_grounding, audio_path, qwen3_model, qwen3_processor) |
| |
| if gemini_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"gemini_error: {gemini_err}"}) |
| if qwen2_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"qwen2_error: {qwen2_err}"}) |
| if qwen3_err: |
| missing.append({"split": split, "video_id": video_id, "reason": f"qwen3_error: {qwen3_err}"}) |
| |
| expected_t_audio = float(t_visual) + float(shift) |
| row = { |
| "video_path": str(video_path), |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "gemini_t": round(gemini_res[0], 3) if gemini_res else None, |
| "qwen2_t": round(qwen2_res[0], 3) if qwen2_res else None, |
| "qwen3_t": round(qwen3_res[0], 3) if qwen3_res else None, |
| "gemini_desc": gemini_res[1] if gemini_res else None, |
| "qwen2_desc": qwen2_res[1] if qwen2_res else None, |
| "qwen3_desc": qwen3_res[1] if qwen3_res else None, |
| "audio_path": str(audio_path), |
| } |
| append_jsonl(out_path, row) |
| combined_rows.append(row) |
| |
| # Per-model jsonl outputs under dedicated subfolders. |
| append_jsonl( |
| model_out[f"gemini_{model_suffix}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(gemini_res[0], 3) if gemini_res else None, |
| "sound_description": gemini_res[1] if gemini_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| append_jsonl( |
| model_out[f"qwen2_{model_suffix}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(qwen2_res[0], 3) if qwen2_res else None, |
| "sound_description": qwen2_res[1] if qwen2_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| append_jsonl( |
| model_out[f"qwen3_{model_suffix}"], |
| { |
| "video_id": video_path.name, |
| "source_video_id": video_id, |
| "t_visual": float(t_visual), |
| "shift_amount": float(shift), |
| "expected_t_audio": expected_t_audio, |
| "detected_t_audio": round(qwen3_res[0], 3) if qwen3_res else None, |
| "sound_description": qwen3_res[1] if qwen3_res else None, |
| "audio_path": str(audio_path), |
| }, |
| ) |
| |
| with missing_path.open("w", encoding="utf-8") as f: |
| json.dump(missing, f, ensure_ascii=False, indent=2) |
| |
| summary = { |
| "source_csv": str(args.source_csv), |
| "sample_size": len(rows), |
| "seed": args.seed, |
| "delay_shift": args.delay_shift, |
| "early_shift": args.early_shift, |
| "delay_summary": { |
| "gemini": summarize_errors(delay_rows, "gemini_t"), |
| "qwen2": summarize_errors(delay_rows, "qwen2_t"), |
| "qwen3": summarize_errors(delay_rows, "qwen3_t"), |
| "count": len(delay_rows), |
| }, |
| "early_summary": { |
| "gemini": summarize_errors(early_rows, "gemini_t"), |
| "qwen2": summarize_errors(early_rows, "qwen2_t"), |
| "qwen3": summarize_errors(early_rows, "qwen3_t"), |
| "count": len(early_rows), |
| }, |
| "missing_or_errors_count": len(missing), |
| "outputs": { |
| "delay_jsonl": str(delay_results_path), |
| "early_jsonl": str(early_results_path), |
| "missing_or_errors_json": str(missing_path), |
| "sampled_csv": str(sampled_path), |
| "audio_dir": str(audio_dir), |
| "gemini_dir": str(gemini_dir), |
| "qwen2_dir": str(qwen2_dir), |
| "qwen3_dir": str(qwen3_dir), |
| }, |
| } |
| with summary_path.open("w", encoding="utf-8") as f: |
| json.dump(summary, f, ensure_ascii=False, indent=2) |
| |
| print("========== Audio LLM Benchmark Summary ==========") |
| print(f"Sampled source videos: {len(rows)}") |
| print(f"Delay evaluated rows: {len(delay_rows)}") |
| print(f"Early evaluated rows: {len(early_rows)}") |
| print(f"Missing/errors: {len(missing)}") |
| print(f"Summary: {summary_path}") |
| print("================================================") |
| |
| |
| if __name__ == "__main__": |
| main() |
| #!/usr/bin/env python3 |
| """ |
| Audio-LLM benchmark for physical-impact timestamp grounding. |
| |
| Models: |
| - Gemini 3.1 Pro (google-generativeai, API) |
| - Qwen2-Audio-7B-Instruct (local transformers) |
| - Qwen3-Omni-30B-A3B-Instruct (local transformers) |
| """ |
| |
| from __future__ import annotations |
| |
| import argparse |
| import json |
| import os |
| import re |
| import subprocess |
| import tempfile |
| import time |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any, Dict, List, Optional, Tuple |
| |
| import librosa |
| import numpy as np |
| import torch |
| from tqdm import tqdm |
| from transformers import AutoModelForCausalLM, AutoProcessor |
| |
| try: |
| import google.generativeai as genai |
| except Exception: # pragma: no cover |
| genai = None |
| |
| |
| UNIVERSAL_PROMPT = ( |
| "Listen to this audio clip carefully. You are an expert in acoustic forensics. " |
| "Locate the EXACT timestamp (in seconds) of the loudest, most energetic PHYSICAL IMPACT sound " |
| "(e.g., body hitting ground, object breaking). Actively ignore background music, laughter, and speech. " |
| 'Output strictly in JSON format: {"audio_timestamp": 2.5, "sound_description": "brief description"}' |
| ) |
| |
| DEFAULT_INPUT_DIR = Path("/home/ubuntu/video_source/shifted/delay") |
| DEFAULT_OUTPUT_JSONL = Path("/home/ubuntu/video_source/result/audio_llm_benchmark.jsonl") |
| DEFAULT_MAX_VIDEOS = 0 |
| DEFAULT_AUDIO_SR = 16000 |
| DEFAULT_AUDIO_FORMAT = "wav" |
| DEFAULT_SEED = 42 |
| |
| GEMINI_MODEL = "gemini-3.1-pro-preview" |
| QWEN2_MODEL_ID = "Qwen/Qwen2-Audio-7B-Instruct" |
| QWEN3_MODEL_ID = "Qwen/Qwen3-Omni-30B-A3B-Instruct" |
| |
| GEMINI_FILE_READY_TIMEOUT_SECONDS = 120 |
| GEMINI_FILE_POLL_SECONDS = 2 |
| |
| |
| @dataclass |
| class AudioResult: |
| audio_timestamp: float |
| sound_description: str |
| |
| |
| def parse_args() -> argparse.Namespace: |
| p = argparse.ArgumentParser(description="Benchmark Gemini/Qwen2/Qwen3 on audio grounding.") |
| p.add_argument("--input-dir", type=Path, default=DEFAULT_INPUT_DIR, help="Folder of videos (.mp4)") |
| p.add_argument("--output-jsonl", type=Path, default=DEFAULT_OUTPUT_JSONL, help="Benchmark output JSONL") |
| p.add_argument("--audio-sr", type=int, default=DEFAULT_AUDIO_SR, help="Extracted audio sample rate") |
| p.add_argument( |
| "--audio-format", |
| choices=["wav", "mp3"], |
| default=DEFAULT_AUDIO_FORMAT, |
| help="Temporary extracted audio format", |
| ) |
| p.add_argument("--max-videos", type=int, default=DEFAULT_MAX_VIDEOS, help="0 means all videos") |
| p.add_argument("--seed", type=int, default=DEFAULT_SEED, help="Random seed for selection") |
| p.add_argument("--overwrite-output", action="store_true", help="Delete existing output JSONL before run") |
| p.add_argument( |
| "--save-extracted-audio-dir", |
| type=Path, |
| default=None, |
| help="If set, keep extracted audio files in this directory for inspection", |
| ) |
| p.add_argument( |
| "--disable-local-models", |
| action="store_true", |
| help="Only run Gemini (skip Qwen2/Qwen3 loading)", |
| ) |
| return p.parse_args() |
| |
| |
| def ensure_ffmpeg() -> None: |
| subprocess.run( |
| ["ffmpeg", "-version"], |
| check=True, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| ) |
| |
| |
| def _extract_json_object(text: str) -> Dict[str, Any]: |
| text = text.strip() |
| fence_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL) |
| if fence_match: |
| return json.loads(fence_match.group(1)) |
| try: |
| return json.loads(text) |
| except json.JSONDecodeError: |
| pass |
| start = text.find("{") |
| end = text.rfind("}") |
| if start != -1 and end != -1 and end > start: |
| return json.loads(text[start : end + 1]) |
| raise ValueError("No valid JSON object found in model output.") |
| |
| |
| def _coerce_audio_result(data: Dict[str, Any]) -> AudioResult: |
| if "audio_timestamp" not in data or "sound_description" not in data: |
| raise ValueError(f"Missing keys in JSON output: {data}") |
| ts = float(data["audio_timestamp"]) |
| if not np.isfinite(ts): |
| raise ValueError(f"audio_timestamp is not finite: {ts}") |
| desc = str(data["sound_description"]).strip() |
| if not desc: |
| raise ValueError("sound_description is empty.") |
| return AudioResult(audio_timestamp=ts, sound_description=desc) |
| |
| |
| def append_jsonl(path: Path, payload: Dict[str, Any]) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("a", encoding="utf-8") as f: |
| f.write(json.dumps(payload, ensure_ascii=False) + "\n") |
| |
| |
| def extract_audio_file(video_path: Path, sr: int, fmt: str, save_dir: Optional[Path]) -> Path: |
| suffix = f".{fmt}" |
| if save_dir is not None: |
| save_dir.mkdir(parents=True, exist_ok=True) |
| safe_name = f"{video_path.stem}.{fmt}" |
| out_path = save_dir / safe_name |
| else: |
| tmp = tempfile.NamedTemporaryFile(prefix="bench_audio_", suffix=suffix, delete=False) |
| out_path = Path(tmp.name) |
| tmp.close() |
| |
| cmd = [ |
| "ffmpeg", |
| "-y", |
| "-i", |
| str(video_path), |
| "-vn", |
| "-ac", |
| "1", |
| "-ar", |
| str(sr), |
| ] |
| if fmt == "wav": |
| cmd += ["-c:a", "pcm_s16le"] |
| else: |
| cmd += ["-c:a", "libmp3lame", "-q:a", "2"] |
| cmd.append(str(out_path)) |
| subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) |
| return out_path |
| |
| |
| def wait_for_gemini_file_active(file_name: str) -> None: |
| deadline = time.time() + GEMINI_FILE_READY_TIMEOUT_SECONDS |
| while time.time() < deadline: |
| file_obj = genai.get_file(file_name) |
| state_obj = getattr(file_obj, "state", None) |
| state_name = str(getattr(state_obj, "name", state_obj)) |
| if state_name == "ACTIVE": |
| return |
| if state_name in {"FAILED", "CANCELLED"}: |
| raise RuntimeError(f"Gemini file processing failed: state={state_name}") |
| time.sleep(GEMINI_FILE_POLL_SECONDS) |
| raise TimeoutError("Gemini file did not become ACTIVE in time.") |
| |
| |
| def gemini_audio_grounding(audio_path: Path, gemini_api_key: str) -> AudioResult: |
| if genai is None: |
| raise RuntimeError("google-generativeai is not installed.") |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is missing.") |
| genai.configure(api_key=gemini_api_key) |
| model = genai.GenerativeModel(GEMINI_MODEL) |
| uploaded = genai.upload_file(path=str(audio_path)) |
| try: |
| wait_for_gemini_file_active(uploaded.name) |
| resp = model.generate_content([UNIVERSAL_PROMPT, uploaded]) |
| raw_text = getattr(resp, "text", "") or "" |
| if not raw_text: |
| raise ValueError("Gemini response text is empty.") |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| finally: |
| try: |
| genai.delete_file(uploaded.name) |
| except Exception: |
| pass |
| |
| |
| def load_qwen_model_and_processor(model_id: str) -> Tuple[Any, Any]: |
| """ |
| Best-effort universal loader for Qwen audio models with remote code. |
| """ |
| processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True) |
| model = AutoModelForCausalLM.from_pretrained( |
| model_id, |
| torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32, |
| device_map="auto" if torch.cuda.is_available() else None, |
| trust_remote_code=True, |
| ) |
| model.eval() |
| return model, processor |
| |
| |
| def _run_qwen_audio_chat( |
| model: Any, |
| processor: Any, |
| audio_path: Path, |
| prompt: str, |
| model_label: str, |
| ) -> str: |
| """ |
| Generic chat-template path used by both Qwen2-Audio and Qwen3-Omni. |
| |
| This intentionally keeps robust fallbacks because Qwen audio model |
| templates differ across transformers/model revisions. |
| """ |
| # 1) Build multimodal chat message. |
| messages = [ |
| { |
| "role": "user", |
| "content": [ |
| {"type": "audio", "audio": str(audio_path)}, |
| {"type": "text", "text": prompt}, |
| ], |
| } |
| ] |
| |
| # 2) Render chat text by processor template (if available). |
| try: |
| text_prompt = processor.apply_chat_template( |
| messages, |
| tokenize=False, |
| add_generation_prompt=True, |
| ) |
| except Exception: |
| text_prompt = prompt |
| |
| # 3) Load audio as waveform for processor input. |
| audio_arr, sr = librosa.load(str(audio_path), sr=None, mono=True) |
| if audio_arr.size == 0: |
| raise RuntimeError(f"{model_label}: extracted audio is empty.") |
| |
| # 4) Try common processor signatures across versions. |
| last_exc: Optional[Exception] = None |
| candidate_kwargs = [ |
| {"text": [text_prompt], "audio": [audio_arr], "sampling_rate": sr}, |
| {"text": [text_prompt], "audios": [audio_arr], "sampling_rate": sr}, |
| ] |
| |
| for kw in candidate_kwargs: |
| try: |
| inputs = processor(return_tensors="pt", padding=True, **kw) |
| break |
| except Exception as exc: |
| last_exc = exc |
| else: |
| raise RuntimeError(f"{model_label}: failed to build processor inputs: {last_exc}") |
| |
| # Move tensor inputs to model device when possible. |
| if hasattr(model, "device"): |
| dev = model.device |
| else: |
| dev = torch.device("cuda" if torch.cuda.is_available() else "cpu") |
| for k, v in list(inputs.items()): |
| if torch.is_tensor(v): |
| inputs[k] = v.to(dev) |
| |
| with torch.no_grad(): |
| output_ids = model.generate(**inputs, max_new_tokens=256, do_sample=False) |
| |
| # Decode only newly generated tokens when possible. |
| input_len = inputs["input_ids"].shape[1] if "input_ids" in inputs else 0 |
| gen_ids = output_ids[:, input_len:] if input_len > 0 else output_ids |
| text = processor.batch_decode(gen_ids, skip_special_tokens=True)[0].strip() |
| return text |
| |
| |
| def qwen2_audio_grounding(audio_path: Path, model: Any, processor: Any) -> AudioResult: |
| raw_text = _run_qwen_audio_chat( |
| model=model, |
| processor=processor, |
| audio_path=audio_path, |
| prompt=UNIVERSAL_PROMPT, |
| model_label="Qwen2-Audio", |
| ) |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| |
| |
| def qwen3_omni_grounding(audio_path: Path, model: Any, processor: Any) -> AudioResult: |
| raw_text = _run_qwen_audio_chat( |
| model=model, |
| processor=processor, |
| audio_path=audio_path, |
| prompt=UNIVERSAL_PROMPT, |
| model_label="Qwen3-Omni", |
| ) |
| parsed = _extract_json_object(raw_text) |
| return _coerce_audio_result(parsed) |
| |
| |
| def safe_call(fn, *args, **kwargs) -> Optional[AudioResult]: |
| try: |
| return fn(*args, **kwargs) |
| except Exception: |
| return None |
| |
| |
| def select_videos(input_dir: Path, max_videos: int, seed: int) -> List[Path]: |
| if not input_dir.exists(): |
| raise FileNotFoundError(f"Input folder not found: {input_dir}") |
| videos = sorted(input_dir.rglob("*.mp4")) |
| if not videos: |
| raise FileNotFoundError(f"No mp4 files found under: {input_dir}") |
| if max_videos and len(videos) > max_videos: |
| rng = np.random.default_rng(seed) |
| idx = rng.choice(len(videos), size=max_videos, replace=False) |
| videos = sorted([videos[int(i)] for i in idx], key=lambda p: p.name) |
| return videos |
| |
| |
| def main() -> None: |
| args = parse_args() |
| ensure_ffmpeg() |
| |
| gemini_api_key = os.getenv("GEMINI_API_KEY", "").strip() |
| if not gemini_api_key: |
| raise RuntimeError("GEMINI_API_KEY is required.") |
| |
| if args.overwrite_output and args.output_jsonl.exists(): |
| args.output_jsonl.unlink() |
| |
| videos = select_videos(args.input_dir, args.max_videos, args.seed) |
| |
| qwen2_model = qwen2_processor = None |
| qwen3_model = qwen3_processor = None |
| if not args.disable_local_models: |
| try: |
| qwen2_model, qwen2_processor = load_qwen_model_and_processor(QWEN2_MODEL_ID) |
| except Exception: |
| qwen2_model = qwen2_processor = None |
| try: |
| qwen3_model, qwen3_processor = load_qwen_model_and_processor(QWEN3_MODEL_ID) |
| except Exception: |
| qwen3_model = qwen3_processor = None |
| |
| for video_path in tqdm(videos, desc="Audio LLM Benchmark", unit="video"): |
| audio_path = None |
| try: |
| audio_path = extract_audio_file( |
| video_path, |
| sr=args.audio_sr, |
| fmt=args.audio_format, |
| save_dir=args.save_extracted_audio_dir, |
| ) |
| |
| gemini_res = safe_call(gemini_audio_grounding, audio_path, gemini_api_key) |
| |
| qwen2_res = None |
| if qwen2_model is not None and qwen2_processor is not None: |
| qwen2_res = safe_call(qwen2_audio_grounding, audio_path, qwen2_model, qwen2_processor) |
| |
| qwen3_res = None |
| if qwen3_model is not None and qwen3_processor is not None: |
| qwen3_res = safe_call(qwen3_omni_grounding, audio_path, qwen3_model, qwen3_processor) |
| |
| row = { |
| "video": video_path.name, |
| "gemini_t": round(gemini_res.audio_timestamp, 3) if gemini_res else None, |
| "qwen2_t": round(qwen2_res.audio_timestamp, 3) if qwen2_res else None, |
| "qwen3_t": round(qwen3_res.audio_timestamp, 3) if qwen3_res else None, |
| "gemini_desc": gemini_res.sound_description if gemini_res else None, |
| "qwen2_desc": qwen2_res.sound_description if qwen2_res else None, |
| "qwen3_desc": qwen3_res.sound_description if qwen3_res else None, |
| } |
| append_jsonl(args.output_jsonl, row) |
| finally: |
| if ( |
| audio_path is not None |
| and audio_path.exists() |
| and args.save_extracted_audio_dir is None |
| ): |
| audio_path.unlink(missing_ok=True) |
| |
| print(f"Done. Results written to: {args.output_jsonl}") |
| |
| |
| if __name__ == "__main__": |
| main() |
| ''' |
|
|
