diff --git a/data_gen/av_mcqa_pipeline/01_select_finevideo.py b/data_gen/av_mcqa_pipeline/01_select_finevideo.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c25e0e52cb86bce7e62a52f429afdc89f2e23c3
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/01_select_finevideo.py
@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Step 1: Select FineVideo videos for AV-MCQA generation, then download
+the missing ones from Hugging Face.
+
+Selection rules:
+  - source pool: filtered_candidates_all_passing.jsonl (4616 entries)
+  - EXCLUDE videos already used in existing local cache (1000 in
+    filtered_candidates.jsonl), so new generation gets *new* videos
+  - mean audioVisualCorrelation per scene >= MIN_MEAN_AVC
+  - duration in [MIN_DURATION, MAX_DURATION]
+  - balanced across content_parent_category (max MAX_PER_CATEGORY each)
+  - target ~TOTAL_TARGET videos
+
+Download missing videos via streaming the FineVideo HF dataset, saving:
+  - /opt/dlami/nvme/finevideo_av_mcqa/videos/finevideo_{idx:06d}.mp4
+  - /opt/dlami/nvme/finevideo_av_mcqa/audio/finevideo_{idx:06d}.wav  (extracted via ffmpeg)
+
+Output: /opt/dlami/nvme/av_mcqa/01_selected_videos.jsonl  (one selected video per line)
+"""
+
+import json
+import os
+import subprocess
+from collections import defaultdict
+from pathlib import Path
+
+CANDIDATES_ALL = "/opt/dlami/nvme/finevideo/filtered_candidates_all_passing.jsonl"
+CANDIDATES_LOCAL = "/opt/dlami/nvme/finevideo/filtered_candidates.jsonl"  # exclude these (already used)
+
+NEW_VIDEO_DIR = "/opt/dlami/nvme/finevideo_av_mcqa/videos"
+NEW_AUDIO_DIR = "/opt/dlami/nvme/finevideo_av_mcqa/audio"
+OUTPUT_FILE = "/opt/dlami/nvme/av_mcqa/01_selected_videos.jsonl"
+
+MIN_MEAN_AVC = 0.85
+MIN_DURATION = 30
+MAX_DURATION = 180
+MAX_PER_CATEGORY = 100
+TOTAL_TARGET = 800
+
+
+def fname(idx: int) -> str:
+    return f"finevideo_{idx:06d}"
+
+
+def select_targets() -> list[dict]:
+    """Pick target videos by filtering metadata only (no downloads yet)."""
+    all_pool = []
+    with open(CANDIDATES_ALL) as f:
+        for line in f:
+            all_pool.append(json.loads(line))
+
+    already_local_idx = set()
+    with open(CANDIDATES_LOCAL) as f:
+        for line in f:
+            already_local_idx.add(json.loads(line)["finevideo_idx"])
+
+    print(f"Pool: {len(all_pool)} (all_passing), excluding {len(already_local_idx)} already-used local")
+
+    fresh = [v for v in all_pool if v["finevideo_idx"] not in already_local_idx]
+    print(f"Fresh candidates (not yet locally used): {len(fresh)}")
+
+    selected = []
+    for v in fresh:
+        d = v["duration_seconds"]
+        if d < MIN_DURATION or d > MAX_DURATION:
+            continue
+        avcs = [s["audioVisualCorrelation"] for s in v["scenes"]
+                if "audioVisualCorrelation" in s
+                and 0.0 <= s["audioVisualCorrelation"] <= 1.0]
+        if not avcs:
+            continue
+        m = sum(avcs) / len(avcs)
+        if m < MIN_MEAN_AVC:
+            continue
+        v["_mean_avc"] = m
+        selected.append(v)
+
+    print(f"After AVC/duration filter: {len(selected)}")
+
+    # Balance per category
+    by_cat = defaultdict(list)
+    for v in selected:
+        by_cat[v.get("content_parent_category", "Unknown")].append(v)
+    for cat in by_cat:
+        by_cat[cat].sort(key=lambda x: -x["_mean_avc"])
+
+    print("\nPer-category counts (after AVC filter):")
+    for cat in sorted(by_cat):
+        print(f"  {cat:30s} {len(by_cat[cat])}")
+
+    balanced = []
+    for cat, vs in by_cat.items():
+        balanced.extend(vs[:MAX_PER_CATEGORY])
+    balanced.sort(key=lambda x: -x["_mean_avc"])
+    balanced = balanced[:TOTAL_TARGET]
+
+    print(f"\nFinal selection: {len(balanced)} videos")
+    final_cat = defaultdict(int)
+    for v in balanced:
+        final_cat[v["content_parent_category"]] += 1
+    for cat, n in sorted(final_cat.items(), key=lambda x: -x[1]):
+        print(f"  {cat:30s} {n}")
+
+    return balanced
+
+
+def extract_audio(mp4_path: str, wav_path: str) -> bool:
+    """ffmpeg: extract audio to mono 16k wav."""
+    try:
+        subprocess.run(
+            ["ffmpeg", "-y", "-loglevel", "error",
+             "-i", mp4_path, "-vn",
+             "-ac", "1", "-ar", "16000", wav_path],
+            check=True,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def download_videos(targets: list[dict]) -> list[dict]:
+    """Stream the FineVideo HF dataset and save matching mp4 + extract wav."""
+    os.makedirs(NEW_VIDEO_DIR, exist_ok=True)
+    os.makedirs(NEW_AUDIO_DIR, exist_ok=True)
+
+    target_map = {v["finevideo_idx"]: v for v in targets}
+
+    # Skip if already downloaded
+    remaining = {}
+    ready = []
+    for idx, v in target_map.items():
+        mp4_path = os.path.join(NEW_VIDEO_DIR, f"{fname(idx)}.mp4")
+        wav_path = os.path.join(NEW_AUDIO_DIR, f"{fname(idx)}.wav")
+        if os.path.exists(mp4_path) and os.path.exists(wav_path):
+            v["_video_path"] = mp4_path
+            v["_audio_path"] = wav_path
+            v["_filename"] = fname(idx)
+            ready.append(v)
+        else:
+            remaining[idx] = v
+
+    print(f"\nAlready downloaded: {len(ready)}")
+    print(f"To download: {len(remaining)}")
+
+    if not remaining:
+        return ready
+
+    # Stream the HF dataset; pick out matching indices.
+    # NOTE: streaming through a multi-TB dataset to find sparse targets
+    # can be slow. If you run this often, consider sharded downloads.
+    from datasets import load_dataset
+
+    ds = load_dataset("HuggingFaceFV/finevideo", split="train", streaming=True)
+
+    saved = 0
+    target_idx_set = set(remaining)
+    for i, sample in enumerate(ds):
+        if i not in target_idx_set:
+            continue
+
+        try:
+            mp4_bytes = sample["mp4"]
+            mp4_path = os.path.join(NEW_VIDEO_DIR, f"{fname(i)}.mp4")
+            with open(mp4_path, "wb") as f:
+                f.write(mp4_bytes)
+
+            wav_path = os.path.join(NEW_AUDIO_DIR, f"{fname(i)}.wav")
+            if not extract_audio(mp4_path, wav_path):
+                # video has no audio? skip
+                os.remove(mp4_path)
+                continue
+
+            v = remaining[i]
+            v["_video_path"] = mp4_path
+            v["_audio_path"] = wav_path
+            v["_filename"] = fname(i)
+            ready.append(v)
+            saved += 1
+            target_idx_set.discard(i)
+
+            if saved % 20 == 0:
+                print(f"  downloaded {saved}/{len(remaining)} (last idx={i})")
+
+            if not target_idx_set:
+                break
+        except Exception as e:
+            print(f"  download failed idx={i}: {e}")
+
+    print(f"\nDownloaded {saved} new videos")
+    if target_idx_set:
+        print(f"WARN: {len(target_idx_set)} targets not found in stream "
+              f"(dataset may be sharded differently)")
+    return ready
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    targets = select_targets()
+
+    ready = download_videos(targets)
+    print(f"\nTotal ready (downloaded + with audio): {len(ready)}")
+
+    with open(OUTPUT_FILE, "w") as f:
+        for v in ready:
+            slim = {
+                "finevideo_idx": v["finevideo_idx"],
+                "filename": v["_filename"],
+                "video_path": v["_video_path"],
+                "audio_path": v["_audio_path"],
+                "duration_seconds": v["duration_seconds"],
+                "mean_avc": round(v["_mean_avc"], 3),
+                "content_parent_category": v["content_parent_category"],
+                "content_fine_category": v["content_fine_category"],
+                "youtube_title": v.get("youtube_title", ""),
+                "scenes": v["scenes"],
+            }
+            f.write(json.dumps(slim, ensure_ascii=False) + "\n")
+    print(f"\nWrote {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/01b_select_local_finevideo.py b/data_gen/av_mcqa_pipeline/01b_select_local_finevideo.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec2dc641baa23bbc799edcdd2f2cbfc69d46978b
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/01b_select_local_finevideo.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+Step 1b: Select the 1000 LOCAL FineVideo videos (already downloaded,
+already used in finevideo_dpo) for additional AV-MCQA generation.
+
+These videos already have long-description DPO pairs, but AV-MCQA is a
+completely different format (short 4-choice questions requiring audio),
+so reusing the same videos is fine.
+
+Output: /opt/dlami/nvme/av_mcqa/01b_selected_local_videos.jsonl
+"""
+
+import json
+import os
+
+CANDIDATES_LOCAL = "/opt/dlami/nvme/finevideo/filtered_candidates.jsonl"
+VIDEO_DIR = "/opt/dlami/nvme/finevideo/videos"
+AUDIO_DIR = "/opt/dlami/nvme/finevideo/audio"
+OUTPUT_FILE = "/opt/dlami/nvme/av_mcqa/01b_selected_local_videos.jsonl"
+
+
+def fname(idx: int) -> str:
+    return f"finevideo_{idx:06d}"
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    candidates = []
+    with open(CANDIDATES_LOCAL) as f:
+        for line in f:
+            candidates.append(json.loads(line))
+    print(f"Local candidates: {len(candidates)}")
+
+    ready = []
+    for v in candidates:
+        fn = fname(v["finevideo_idx"])
+        mp4 = os.path.join(VIDEO_DIR, f"{fn}.mp4")
+        wav = os.path.join(AUDIO_DIR, f"{fn}.wav")
+        if not os.path.exists(mp4) or not os.path.exists(wav):
+            continue
+
+        avcs = [s["audioVisualCorrelation"] for s in v["scenes"]
+                if "audioVisualCorrelation" in s
+                and 0.0 <= s["audioVisualCorrelation"] <= 1.0]
+        mean_avc = sum(avcs) / len(avcs) if avcs else 0.0
+
+        ready.append({
+            "finevideo_idx": v["finevideo_idx"],
+            "filename": fn,
+            "video_path": mp4,
+            "audio_path": wav,
+            "duration_seconds": v["duration_seconds"],
+            "mean_avc": round(mean_avc, 3),
+            "content_parent_category": v.get("content_parent_category", "Unknown"),
+            "content_fine_category": v.get("content_fine_category", "Unknown"),
+            "youtube_title": v.get("youtube_title", ""),
+            "scenes": v["scenes"],
+        })
+
+    print(f"Videos with mp4+wav: {len(ready)}")
+
+    with open(OUTPUT_FILE, "w") as f:
+        for v in ready:
+            f.write(json.dumps(v, ensure_ascii=False) + "\n")
+    print(f"Wrote {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/02_gemini_generate_av_mcqa.py b/data_gen/av_mcqa_pipeline/02_gemini_generate_av_mcqa.py
new file mode 100644
index 0000000000000000000000000000000000000000..196f10d6e62b2e24036a6ef4a5d4e6e95e4f4349
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/02_gemini_generate_av_mcqa.py
@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+Step 2: For each selected FineVideo video, ask a video-capable model
+(audio + visual) to generate Daily-Omni-style AV-MCQAs.
+
+Backends, in priority order:
+  1. Gemini direct API (google-genai), with up to 3 keys rotating.
+     - GOOGLE_API_KEY_1 / GOOGLE_API_KEY_2 / GOOGLE_API_KEY_3
+     - or fallback to GOOGLE_API_KEY (single)
+  2. OpenRouter (openai-compatible), used when ALL Gemini keys hit
+     quota / rate-limit / 5xx.
+     - OPENROUTER_API_KEY
+     - default model: google/gemini-2.5-pro (overridable)
+
+Output JSONL per video. Resumable.
+
+Usage:
+    export GOOGLE_API_KEY_1=...
+    export GOOGLE_API_KEY_2=...
+    export GOOGLE_API_KEY_3=...
+    export OPENROUTER_API_KEY=...
+    python 02_gemini_generate_av_mcqa.py
+"""
+
+import os
+import json
+import time
+import base64
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+INPUT_FILE = os.environ.get("AV_MCQA_INPUT", "/opt/dlami/nvme/av_mcqa/01_selected_videos.jsonl")
+OUTPUT_FILE = os.environ.get("AV_MCQA_OUTPUT", "/opt/dlami/nvme/av_mcqa/02_gemini_generated.jsonl")
+
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-3.1-pro-preview")
+OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "google/gemini-3.1-pro-preview")
+
+MAX_WORKERS = 6
+QUESTIONS_PER_VIDEO = 3
+
+GEN_PROMPT = """You are designing multiple-choice questions for a video benchmark that tests audio-visual reasoning.
+
+Watch and listen to the attached video carefully. Then generate exactly {N} multiple-choice questions of the following types (vary across types if possible):
+
+1. AV Event Alignment: "What visual element appeared when [audio event]?" or "Which audio event matches [visual event]?"
+2. Event Sequence: chronological order of audio-visual events.
+3. Context Understanding: what audio + visual elements coexist at a moment.
+4. Inference: based on what you see AND hear, infer purpose, emotion, intent, or relationship.
+5. Reasoning: causal reasoning combining audio and visual evidence.
+6. Comparative: contrast two AV elements or moments.
+
+STRICT REQUIREMENTS for each question:
+- Must REQUIRE both audio AND video to answer correctly. A model with only video frames (no audio) MUST NOT be able to answer.
+- 4 plausible options (A/B/C/D). Distractors must be semantically close, not silly.
+- Provide the correct letter and a brief evidence note ("audio: ..., visual: ...").
+- Avoid yes/no questions and trivia answerable from title alone.
+
+Return STRICT JSON, no prose:
+{{
+  "qa_pairs": [
+    {{
+      "type": "AV Event Alignment",
+      "question": "...",
+      "options": {{"A": "...", "B": "...", "C": "...", "D": "..."}},
+      "answer": "B",
+      "audio_evidence": "around 0:12, the speaker says X",
+      "visual_evidence": "at the same moment, Y appears on screen"
+    }}
+  ]
+}}
+"""
+
+
+# =============================================================================
+# Backend pool: round-robin over Gemini keys, fallback to OpenRouter
+# =============================================================================
+
+class GeminiBackend:
+    """One Gemini key wrapper. Marks itself disabled on quota error."""
+
+    def __init__(self, api_key: str, label: str):
+        self.label = label
+        self.api_key = api_key
+        self.disabled = False
+        self.disabled_reason = ""
+        self._client = None
+        self._lock = threading.Lock()
+
+    def client(self):
+        if self._client is None:
+            from google import genai
+            self._client = genai.Client(api_key=self.api_key)
+        return self._client
+
+    def call(self, video_path: str, prompt_text: str) -> dict:
+        from google.genai import types
+        c = self.client()
+        uploaded = c.files.upload(file=video_path)
+        for _ in range(60):
+            f = c.files.get(name=uploaded.name)
+            if f.state.name == "ACTIVE":
+                uploaded = f
+                break
+            time.sleep(1)
+
+        try:
+            resp = c.models.generate_content(
+                model=GEMINI_MODEL,
+                contents=[uploaded, prompt_text],
+                config=types.GenerateContentConfig(
+                    temperature=0.4,
+                    response_mime_type="application/json",
+                ),
+            )
+            return json.loads(resp.text)
+        finally:
+            try:
+                c.files.delete(name=uploaded.name)
+            except Exception:
+                pass
+
+
+class OpenRouterBackend:
+    """OpenRouter Gemini fallback. Sends video as inline file (URL or base64)."""
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self._client = None
+
+    def client(self):
+        if self._client is None:
+            from openai import OpenAI
+            self._client = OpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=self.api_key,
+                default_headers={
+                    "HTTP-Referer": "https://localhost",
+                    "X-Title": "av-mcqa-pipeline",
+                },
+            )
+        return self._client
+
+    def call(self, video_path: str, prompt_text: str) -> dict:
+        c = self.client()
+        with open(video_path, "rb") as f:
+            data = f.read()
+        b64 = base64.b64encode(data).decode("utf-8")
+
+        # OpenRouter Gemini supports file_data via inputs
+        # Format: input as "file" type with data URL
+        resp = c.chat.completions.create(
+            model=OPENROUTER_MODEL,
+            messages=[{
+                "role": "user",
+                "content": [
+                    {"type": "file",
+                     "file": {"file_data": f"data:video/mp4;base64,{b64}",
+                              "filename": os.path.basename(video_path)}},
+                    {"type": "text", "text": prompt_text},
+                ],
+            }],
+            response_format={"type": "json_object"},
+            temperature=0.4,
+        )
+        text = resp.choices[0].message.content or "{}"
+        return json.loads(text)
+
+
+class BackendPool:
+    """Try Gemini keys round-robin; fall back to OpenRouter when all dead."""
+
+    QUOTA_KEYWORDS = ("quota", "rate", "exhaust", "429", "RESOURCE_EXHAUSTED",
+                      "exceeded", "limit")
+
+    def __init__(self):
+        self.gemini_backends: list[GeminiBackend] = []
+        for i in (1, 2, 3):
+            k = os.environ.get(f"GOOGLE_API_KEY_{i}")
+            if k:
+                self.gemini_backends.append(GeminiBackend(k, f"gemini_{i}"))
+        if not self.gemini_backends:
+            k = os.environ.get("GOOGLE_API_KEY")
+            if k:
+                self.gemini_backends.append(GeminiBackend(k, "gemini_default"))
+
+        or_key = os.environ.get("OPENROUTER_API_KEY")
+        self.openrouter = OpenRouterBackend(or_key) if or_key else None
+
+        if not self.gemini_backends and not self.openrouter:
+            raise RuntimeError(
+                "No API keys found. Set GOOGLE_API_KEY_1/2/3 or GOOGLE_API_KEY, "
+                "and/or OPENROUTER_API_KEY."
+            )
+
+        self._next = 0
+        self._lock = threading.Lock()
+        print(f"Backends initialized: gemini={len(self.gemini_backends)}, "
+              f"openrouter={'yes' if self.openrouter else 'no'}")
+
+    def _is_quota_error(self, err: Exception) -> bool:
+        s = str(err).lower()
+        return any(k.lower() in s for k in self.QUOTA_KEYWORDS)
+
+    def _next_alive_gemini(self) -> GeminiBackend | None:
+        with self._lock:
+            n = len(self.gemini_backends)
+            for _ in range(n):
+                b = self.gemini_backends[self._next % n]
+                self._next += 1
+                if not b.disabled:
+                    return b
+            return None
+
+    def call(self, video_path: str, prompt_text: str) -> dict:
+        # Try alive Gemini keys
+        last_err = None
+        for _ in range(len(self.gemini_backends) + 1):
+            b = self._next_alive_gemini()
+            if b is None:
+                break
+            try:
+                return b.call(video_path, prompt_text)
+            except Exception as e:
+                last_err = e
+                if self._is_quota_error(e):
+                    b.disabled = True
+                    b.disabled_reason = str(e)[:200]
+                    print(f"  [{b.label}] disabled (quota): {b.disabled_reason}")
+                    continue
+                else:
+                    # Non-quota error: try next backend, but don't disable this key
+                    print(f"  [{b.label}] transient error: {e}")
+                    continue
+
+        # All Gemini exhausted -> OpenRouter
+        if self.openrouter:
+            for attempt in range(3):
+                try:
+                    return self.openrouter.call(video_path, prompt_text)
+                except Exception as e:
+                    last_err = e
+                    if attempt < 2:
+                        time.sleep(2 ** (attempt + 1))
+
+        raise RuntimeError(f"All backends failed; last error: {last_err}")
+
+
+# =============================================================================
+# Driver
+# =============================================================================
+
+def load_done() -> set:
+    done = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE) as f:
+            for line in f:
+                try:
+                    done.add(json.loads(line)["finevideo_idx"])
+                except Exception:
+                    pass
+    return done
+
+
+def process_one(pool: BackendPool, video_meta: dict) -> dict:
+    idx = video_meta["finevideo_idx"]
+    prompt = GEN_PROMPT.format(N=QUESTIONS_PER_VIDEO)
+    try:
+        data = pool.call(video_meta["video_path"], prompt)
+        qa_pairs = data.get("qa_pairs", [])
+        return {
+            "finevideo_idx": idx,
+            "filename": video_meta["filename"],
+            "video_path": video_meta["video_path"],
+            "audio_path": video_meta["audio_path"],
+            "duration_seconds": video_meta["duration_seconds"],
+            "mean_avc": video_meta["mean_avc"],
+            "content_parent_category": video_meta["content_parent_category"],
+            "content_fine_category": video_meta["content_fine_category"],
+            "qa_pairs": qa_pairs,
+        }
+    except Exception as e:
+        return {"finevideo_idx": idx, "error": str(e)}
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    pool = BackendPool()
+
+    videos = []
+    with open(INPUT_FILE) as f:
+        for line in f:
+            videos.append(json.loads(line))
+    print(f"Input videos: {len(videos)}")
+
+    done = load_done()
+    todo = [v for v in videos if v["finevideo_idx"] not in done]
+    print(f"Resuming: {len(done)} done, {len(todo)} todo")
+    if not todo:
+        return
+
+    success = errors = 0
+    with open(OUTPUT_FILE, "a") as out_f:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+            futs = {ex.submit(process_one, pool, v): v for v in todo}
+            for i, fut in enumerate(as_completed(futs), 1):
+                rec = fut.result()
+                if "error" in rec:
+                    errors += 1
+                    print(f"  [{i}/{len(todo)}] ERROR idx={rec['finevideo_idx']}: {rec['error'][:200]}")
+                else:
+                    success += 1
+                    out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                    out_f.flush()
+                if i % 20 == 0:
+                    print(f"  [{i}/{len(todo)}] success={success} errors={errors}")
+
+    print(f"\nDone. success={success} errors={errors}")
+    print(f"Output: {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/02b_openrouter_generate_local.py b/data_gen/av_mcqa_pipeline/02b_openrouter_generate_local.py
new file mode 100644
index 0000000000000000000000000000000000000000..da71398cd6ed00f42fd8d00cff93230688b01df1
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/02b_openrouter_generate_local.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Step 2b: Generate AV-MCQA for local 1000 FineVideo videos using
+OpenRouter only (Gemini quota exhausted).
+
+Reads: /opt/dlami/nvme/av_mcqa/01b_selected_local_videos.jsonl
+Writes: /opt/dlami/nvme/av_mcqa/02b_gemini_generated_local.jsonl
+
+Usage:
+    export OPENROUTER_API_KEY=...
+    python 02b_openrouter_generate_local.py
+"""
+
+import os
+import json
+import time
+import base64
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "google/gemini-3.1-pro-preview")
+
+INPUT_FILE = "/opt/dlami/nvme/av_mcqa/01b_selected_local_videos.jsonl"
+OUTPUT_FILE = "/opt/dlami/nvme/av_mcqa/02b_gemini_generated_local.jsonl"
+
+MAX_WORKERS = 6
+QUESTIONS_PER_VIDEO = 3
+
+GEN_PROMPT = """You are designing multiple-choice questions for a video benchmark that tests audio-visual reasoning.
+
+Watch and listen to the attached video carefully. Then generate exactly {N} multiple-choice questions of the following types (vary across types if possible):
+
+1. AV Event Alignment: "What visual element appeared when [audio event]?" or "Which audio event matches [visual event]?"
+2. Event Sequence: chronological order of audio-visual events.
+3. Context Understanding: what audio + visual elements coexist at a moment.
+4. Inference: based on what you see AND hear, infer purpose, emotion, intent, or relationship.
+5. Reasoning: causal reasoning combining audio and visual evidence.
+6. Comparative: contrast two AV elements or moments.
+
+STRICT REQUIREMENTS for each question:
+- Must REQUIRE both audio AND video to answer correctly. A model with only video frames (no audio) MUST NOT be able to answer.
+- 4 plausible options (A/B/C/D). Distractors must be semantically close, not silly.
+- Provide the correct letter and a brief evidence note ("audio: ..., visual: ...").
+- Avoid yes/no questions and trivia answerable from title alone.
+
+Return STRICT JSON, no prose:
+{{
+  "qa_pairs": [
+    {{
+      "type": "AV Event Alignment",
+      "question": "...",
+      "options": {{"A": "...", "B": "...", "C": "...", "D": "..."}},
+      "answer": "B",
+      "audio_evidence": "around 0:12, the speaker says X",
+      "visual_evidence": "at the same moment, Y appears on screen"
+    }}
+  ]
+}}
+"""
+
+
+def load_done() -> set:
+    done = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE) as f:
+            for line in f:
+                try:
+                    done.add(json.loads(line)["finevideo_idx"])
+                except Exception:
+                    pass
+    return done
+
+
+def get_client():
+    from openai import OpenAI
+    return OpenAI(
+        base_url="https://openrouter.ai/api/v1",
+        api_key=os.environ["OPENROUTER_API_KEY"],
+        default_headers={
+            "HTTP-Referer": "https://localhost",
+            "X-Title": "av-mcqa-pipeline",
+        },
+    )
+
+
+def call_openrouter(client, video_path: str, prompt_text: str) -> dict:
+    with open(video_path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode("utf-8")
+
+    resp = client.chat.completions.create(
+        model=OPENROUTER_MODEL,
+        messages=[{
+            "role": "user",
+            "content": [
+                {"type": "file",
+                 "file": {"file_data": f"data:video/mp4;base64,{b64}",
+                          "filename": os.path.basename(video_path)}},
+                {"type": "text", "text": prompt_text},
+            ],
+        }],
+        response_format={"type": "json_object"},
+        temperature=0.4,
+    )
+    text = resp.choices[0].message.content or "{}"
+    return json.loads(text)
+
+
+def process_one(client, video_meta: dict) -> dict:
+    idx = video_meta["finevideo_idx"]
+    prompt = GEN_PROMPT.format(N=QUESTIONS_PER_VIDEO)
+    for attempt in range(3):
+        try:
+            data = call_openrouter(client, video_meta["video_path"], prompt)
+            qa_pairs = data.get("qa_pairs", [])
+            return {
+                "finevideo_idx": idx,
+                "filename": video_meta["filename"],
+                "video_path": video_meta["video_path"],
+                "audio_path": video_meta["audio_path"],
+                "duration_seconds": video_meta["duration_seconds"],
+                "mean_avc": video_meta["mean_avc"],
+                "content_parent_category": video_meta["content_parent_category"],
+                "content_fine_category": video_meta["content_fine_category"],
+                "qa_pairs": qa_pairs,
+            }
+        except Exception as e:
+            if attempt < 2:
+                time.sleep(2 ** (attempt + 1))
+            else:
+                return {"finevideo_idx": idx, "error": str(e)}
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    client = get_client()
+
+    videos = []
+    with open(INPUT_FILE) as f:
+        for line in f:
+            videos.append(json.loads(line))
+    print(f"Input videos: {len(videos)}")
+
+    done = load_done()
+    todo = [v for v in videos if v["finevideo_idx"] not in done]
+    print(f"Resuming: {len(done)} done, {len(todo)} todo")
+    if not todo:
+        print("All done.")
+        return
+
+    success = errors = 0
+    with open(OUTPUT_FILE, "a") as out_f:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+            futs = {ex.submit(process_one, client, v): v for v in todo}
+            for i, fut in enumerate(as_completed(futs), 1):
+                rec = fut.result()
+                if "error" in rec:
+                    errors += 1
+                    print(f"  [{i}/{len(todo)}] ERROR idx={rec['finevideo_idx']}: {rec['error'][:200]}")
+                else:
+                    success += 1
+                    out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                    out_f.flush()
+                if i % 20 == 0:
+                    print(f"  [{i}/{len(todo)}] success={success} errors={errors}")
+
+    print(f"\nDone. success={success} errors={errors}")
+    print(f"Output: {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/03_gpt5_video_only_filter.py b/data_gen/av_mcqa_pipeline/03_gpt5_video_only_filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..f426b9cfb8ae45d7dceda4fa21176191254d3f26
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/03_gpt5_video_only_filter.py
@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Step 3: For each Gemini-generated MCQA, give GPT-5.4 the same question
+plus VIDEO FRAMES ONLY (no audio). If GPT picks the correct answer with
+high confidence, the question is answerable without audio -> drop it.
+
+Surviving questions are guaranteed to require audio + visual jointly.
+
+Usage:
+    export OPENAI_API_KEY="sk-..."
+    python 03_gpt5_video_only_filter.py
+"""
+
+import json
+import os
+import re
+import time
+import base64
+import io
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+import av
+import numpy as np
+from openai import OpenAI
+
+INPUT_FILE = "/opt/dlami/nvme/av_mcqa/02_gemini_generated.jsonl"
+OUTPUT_FILE = "/opt/dlami/nvme/av_mcqa/03_filtered_must_audio.jsonl"
+
+MODEL = "gpt-5.4-2026-03-05"
+MAX_WORKERS = 8
+NUM_FRAMES = 12
+ANSWER_RE = re.compile(r"\b([A-D])\b")
+
+
+client = OpenAI()
+
+
+def extract_frames(video_path: str, num_frames: int) -> list[bytes]:
+    container = av.open(video_path)
+    stream = next(s for s in container.streams if s.type == "video")
+    total = stream.frames or 300
+    indices = set(np.linspace(0, total - 1, num_frames).astype(int).tolist())
+    frames = []
+    for i, frame in enumerate(container.decode(stream)):
+        if i in indices:
+            buf = io.BytesIO()
+            frame.to_image().save(buf, format="JPEG", quality=80)
+            frames.append(buf.getvalue())
+        if len(frames) >= num_frames:
+            break
+    container.close()
+    return frames
+
+
+def gpt_video_only_answer(video_path: str, question: str, options: dict) -> str:
+    """Send frames + question, get a single-letter answer."""
+    frames = extract_frames(video_path, NUM_FRAMES)
+    image_msgs = []
+    for f in frames:
+        b64 = base64.b64encode(f).decode("utf-8")
+        image_msgs.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}", "detail": "low"},
+        })
+
+    options_text = "\n".join(f"{k}. {v}" for k, v in options.items())
+    user_text = (
+        f"You are watching a silent video (no audio). "
+        f"Below are evenly-spaced frames. Answer the multiple-choice question by responding with only the letter A, B, C, or D.\n\n"
+        f"Question: {question}\n\n"
+        f"Options:\n{options_text}\n\n"
+        f"Answer with a single letter:"
+    )
+
+    resp = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": "You answer multiple-choice questions by responding with only one letter."},
+            {"role": "user", "content": [{"type": "text", "text": user_text}, *image_msgs]},
+        ],
+        max_completion_tokens=4,
+        temperature=0.0,
+    )
+    raw = (resp.choices[0].message.content or "").strip().upper()
+    m = ANSWER_RE.search(raw)
+    return m.group(1) if m else ""
+
+
+def process_video_record(rec: dict) -> dict:
+    """Filter qa_pairs of one video; keep only those GPT (video-only) gets WRONG."""
+    survived = []
+    for qa in rec.get("qa_pairs", []):
+        question = qa.get("question", "")
+        options = qa.get("options", {})
+        correct = qa.get("answer", "")
+        if not (question and options and correct):
+            continue
+
+        try:
+            for attempt in range(3):
+                try:
+                    pred = gpt_video_only_answer(rec["video_path"], question, options)
+                    break
+                except Exception as e:
+                    if attempt < 2:
+                        time.sleep(2 ** (attempt + 1))
+                    else:
+                        raise
+        except Exception as e:
+            qa["_filter_error"] = str(e)
+            continue
+
+        qa["_video_only_pred"] = pred
+        # KEEP only if GPT (video-only) is wrong -> question genuinely needs audio
+        if pred != correct:
+            survived.append(qa)
+
+    rec["qa_pairs"] = survived
+    return rec
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    records = []
+    with open(INPUT_FILE) as f:
+        for line in f:
+            records.append(json.loads(line))
+    print(f"Input video records: {len(records)}")
+
+    # Resume
+    done_idx = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE) as f:
+            for line in f:
+                try:
+                    done_idx.add(json.loads(line)["finevideo_idx"])
+                except Exception:
+                    pass
+    todo = [r for r in records if r["finevideo_idx"] not in done_idx]
+    print(f"Resuming: {len(done_idx)} done, {len(todo)} todo")
+    if not todo:
+        print("All done.")
+        return
+
+    total_in = 0
+    total_out = 0
+    with open(OUTPUT_FILE, "a") as out_f:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+            futures = {ex.submit(process_video_record, r): r for r in todo}
+            for i, fut in enumerate(as_completed(futures), 1):
+                rec = fut.result()
+                in_n = sum(1 for q in rec.get("qa_pairs", []) if "question" in q) + sum(
+                    1 for q in rec.get("qa_pairs", []) if q.get("_filter_error")
+                )  # not exact but indicative
+                out_n = len(rec["qa_pairs"])
+                total_in += len(rec.get("qa_pairs", [])) if False else 0  # not used
+                total_out += out_n
+                out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                out_f.flush()
+                if i % 20 == 0:
+                    print(f"  [{i}/{len(todo)}] surviving qa total so far: {total_out}")
+
+    print(f"\nDone. Surviving qa pairs: {total_out}")
+    print(f"Output: {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/03b_gpt5_filter_local.py b/data_gen/av_mcqa_pipeline/03b_gpt5_filter_local.py
new file mode 100644
index 0000000000000000000000000000000000000000..232dde9fe639bdbffd2cb6b9daf943e5f526b3ec
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/03b_gpt5_filter_local.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Step 3b: GPT-5.4 video-only filter for the local 1000 FineVideo batch.
+Same logic as 03_gpt5_video_only_filter.py but reads/writes different files.
+
+Reads: /opt/dlami/nvme/av_mcqa/02b_gemini_generated_local.jsonl
+Writes: /opt/dlami/nvme/av_mcqa/03b_filtered_must_audio_local.jsonl
+"""
+
+import json
+import os
+import re
+import time
+import base64
+import io
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import av
+import numpy as np
+from openai import OpenAI
+
+INPUT_FILE = "/opt/dlami/nvme/av_mcqa/02b_gemini_generated_local.jsonl"
+OUTPUT_FILE = "/opt/dlami/nvme/av_mcqa/03b_filtered_must_audio_local.jsonl"
+
+MODEL = "gpt-5.4-2026-03-05"
+MAX_WORKERS = 8
+NUM_FRAMES = 12
+ANSWER_RE = re.compile(r"\b([A-D])\b")
+
+client = OpenAI()
+
+
+def extract_frames(video_path: str, num_frames: int) -> list[bytes]:
+    container = av.open(video_path)
+    stream = next(s for s in container.streams if s.type == "video")
+    total = stream.frames or 300
+    indices = set(np.linspace(0, total - 1, num_frames).astype(int).tolist())
+    frames = []
+    for i, frame in enumerate(container.decode(stream)):
+        if i in indices:
+            buf = io.BytesIO()
+            frame.to_image().save(buf, format="JPEG", quality=80)
+            frames.append(buf.getvalue())
+        if len(frames) >= num_frames:
+            break
+    container.close()
+    return frames
+
+
+def gpt_video_only_answer(video_path: str, question: str, options: dict) -> str:
+    frames = extract_frames(video_path, NUM_FRAMES)
+    image_msgs = []
+    for f in frames:
+        b64 = base64.b64encode(f).decode("utf-8")
+        image_msgs.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}", "detail": "low"},
+        })
+
+    options_text = "\n".join(f"{k}. {v}" for k, v in options.items())
+    user_text = (
+        f"You are watching a silent video (no audio). "
+        f"Below are evenly-spaced frames. Answer the multiple-choice question by responding with only the letter A, B, C, or D.\n\n"
+        f"Question: {question}\n\n"
+        f"Options:\n{options_text}\n\n"
+        f"Answer with a single letter:"
+    )
+
+    resp = client.chat.completions.create(
+        model=MODEL,
+        messages=[
+            {"role": "system", "content": "You answer multiple-choice questions by responding with only one letter."},
+            {"role": "user", "content": [{"type": "text", "text": user_text}, *image_msgs]},
+        ],
+        max_completion_tokens=4,
+        temperature=0.0,
+    )
+    raw = (resp.choices[0].message.content or "").strip().upper()
+    m = ANSWER_RE.search(raw)
+    return m.group(1) if m else ""
+
+
+def process_video_record(rec: dict) -> dict:
+    survived = []
+    for qa in rec.get("qa_pairs", []):
+        question = qa.get("question", "")
+        options = qa.get("options", {})
+        correct = qa.get("answer", "")
+        if not (question and options and correct):
+            continue
+        try:
+            for attempt in range(3):
+                try:
+                    pred = gpt_video_only_answer(rec["video_path"], question, options)
+                    break
+                except Exception as e:
+                    if attempt < 2:
+                        time.sleep(2 ** (attempt + 1))
+                    else:
+                        raise
+        except Exception as e:
+            continue
+        qa["_video_only_pred"] = pred
+        if pred != correct:
+            survived.append(qa)
+    rec["qa_pairs"] = survived
+    return rec
+
+
+def main():
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+
+    records = []
+    with open(INPUT_FILE) as f:
+        for line in f:
+            records.append(json.loads(line))
+    print(f"Input video records: {len(records)}")
+
+    done_idx = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE) as f:
+            for line in f:
+                try:
+                    done_idx.add(json.loads(line)["finevideo_idx"])
+                except Exception:
+                    pass
+    todo = [r for r in records if r["finevideo_idx"] not in done_idx]
+    print(f"Resuming: {len(done_idx)} done, {len(todo)} todo")
+    if not todo:
+        print("All done.")
+        return
+
+    total_out = 0
+    with open(OUTPUT_FILE, "a") as out_f:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+            futures = {ex.submit(process_video_record, r): r for r in todo}
+            for i, fut in enumerate(as_completed(futures), 1):
+                rec = fut.result()
+                total_out += len(rec["qa_pairs"])
+                out_f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                out_f.flush()
+                if i % 20 == 0:
+                    print(f"  [{i}/{len(todo)}] surviving qa total so far: {total_out}")
+
+    print(f"\nDone. Surviving qa pairs: {total_out}")
+    print(f"Output: {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/04_assemble_dpo.py b/data_gen/av_mcqa_pipeline/04_assemble_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..225c4f4f66ecf81957af0a0a0a11df1b67d6478e
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/04_assemble_dpo.py
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""
+Step 4: Convert filtered AV-MCQAs into LlamaFactory DPO format.
+
+For each surviving QA:
+  chosen   = correct option (letter + full text)
+  rejected = randomly picked wrong option (letter + full text)
+"""
+
+import json
+import os
+import random
+from collections import Counter
+
+random.seed(42)
+
+INPUT_FILES = [
+    "/opt/dlami/nvme/av_mcqa/03_filtered_must_audio.jsonl",       # batch 1: 767 new videos
+    "/opt/dlami/nvme/av_mcqa/03b_filtered_must_audio_local.jsonl", # batch 2: 1000 local videos
+]
+OUTPUT_FILE = "/home/ubuntu/LlamaFactory/data/dpo_finevideo_av_mcqa.json"
+
+
+def make_text(letter: str, options: dict) -> str:
+    return f"{letter}. {options.get(letter, '').strip()}"
+
+
+def main():
+    records = []
+    for input_file in INPUT_FILES:
+        if not os.path.exists(input_file):
+            print(f"Skipping (not found): {input_file}")
+            continue
+        with open(input_file) as f:
+            for line in f:
+                records.append(json.loads(line))
+        print(f"Loaded {input_file}")
+
+    dpo = []
+    type_counter = Counter()
+    cat_counter = Counter()
+    for rec in records:
+        v_path = rec["video_path"]
+        a_path = rec["audio_path"]
+        cat = rec.get("content_parent_category", "Unknown")
+        for qa in rec.get("qa_pairs", []):
+            q = qa.get("question", "").strip()
+            opts = qa.get("options", {})
+            correct = qa.get("answer", "").strip()
+            if not (q and len(opts) >= 4 and correct in opts):
+                continue
+            wrong = [k for k in opts if k != correct]
+            if not wrong:
+                continue
+            rej = random.choice(wrong)
+
+            options_text = "\n".join(f"{k}. {opts[k]}" for k in sorted(opts))
+            user_content = (
+                f"<video><audio>{q}\n{options_text}\n"
+                f"Please provide your answer by stating the letter followed by the full option."
+            )
+
+            dpo.append({
+                "messages": [{"role": "user", "content": user_content}],
+                "chosen":   {"role": "assistant", "content": make_text(correct, opts)},
+                "rejected": {"role": "assistant", "content": make_text(rej, opts)},
+                "videos": [v_path],
+                "audios": [a_path],
+            })
+            type_counter[qa.get("type", "Unknown")] += 1
+            cat_counter[cat] += 1
+
+    random.shuffle(dpo)
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(dpo, f, ensure_ascii=False, indent=1)
+
+    print(f"Wrote {len(dpo)} DPO pairs -> {OUTPUT_FILE}")
+    print("\nQuestion type distribution:")
+    for t, n in type_counter.most_common():
+        print(f"  {t:30s} {n}")
+    print("\nVideo category distribution:")
+    for c, n in cat_counter.most_common():
+        print(f"  {c:30s} {n}")
+
+    # Reminder to register
+    print("\nNext: register in dataset_info.json with key 'dpo_finevideo_av_mcqa'.")
+    print("It uses both videos and audios fields.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/05_rewrite_chosen_longform.py b/data_gen/av_mcqa_pipeline/05_rewrite_chosen_longform.py
new file mode 100644
index 0000000000000000000000000000000000000000..954da855d018a056c0f43f891e8d219fefb5a6af
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/05_rewrite_chosen_longform.py
@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+Rewrite AV-MCQA DPO chosen from short "B. xxx" format to long descriptive
+format matching SFT/finevideo style.
+
+Uses Gemini's audio_evidence + visual_evidence fields to construct a
+chosen answer that:
+  1. Contains the correct MCQA letter + option text
+  2. Explains why using timestamp + audio + visual reasoning
+  3. Matches the long-form descriptive style the SFT model prefers
+
+Output: dpo_finevideo_av_mcqa_longform.json
+"""
+
+import json
+import os
+import random
+from collections import Counter
+
+random.seed(42)
+
+INPUT_FILES = [
+    "/opt/dlami/nvme/av_mcqa/03_filtered_must_audio.jsonl",
+    "/opt/dlami/nvme/av_mcqa/03b_filtered_must_audio_local.jsonl",
+]
+OUTPUT_FILE = "/home/ubuntu/LlamaFactory/data/dpo_finevideo_av_mcqa_longform.json"
+
+
+def build_chosen_longform(qa: dict) -> str:
+    """Construct long-form chosen from MCQA + evidence fields."""
+    letter = qa["answer"]
+    opt_text = qa["options"].get(letter, "").strip()
+    audio_ev = qa.get("audio_evidence", "").strip()
+    visual_ev = qa.get("visual_evidence", "").strip()
+
+    parts = []
+    # Audio-visual reasoning in natural prose
+    if audio_ev and visual_ev:
+        parts.append(f"In the video, {audio_ev.rstrip('.')}; at the same moment in the visual, {visual_ev.rstrip('.')}.")
+    elif audio_ev:
+        parts.append(f"In the audio, {audio_ev.rstrip('.')}.")
+    elif visual_ev:
+        parts.append(f"Visually, {visual_ev.rstrip('.')}.")
+    parts.append(f"Therefore the correct answer is {letter}. {opt_text}.")
+
+    return " ".join(parts)
+
+
+def build_rejected_longform(qa: dict, rej_letter: str) -> str:
+    """Construct a plausible wrong long-form answer using the SAME audio/visual
+    evidence but leading to the wrong conclusion. This is the cleanest DPO
+    signal: identical reasoning prefix, different final answer. No fabricated
+    evidence (prevents teaching hallucination), same length as chosen."""
+    rej_text = qa["options"].get(rej_letter, "").strip()
+    audio_ev = qa.get("audio_evidence", "").strip()
+    visual_ev = qa.get("visual_evidence", "").strip()
+
+    parts = []
+    if audio_ev and visual_ev:
+        parts.append(f"In the video, {audio_ev.rstrip('.')}; at the same moment in the visual, {visual_ev.rstrip('.')}.")
+    elif audio_ev:
+        parts.append(f"In the audio, {audio_ev.rstrip('.')}.")
+    elif visual_ev:
+        parts.append(f"Visually, {visual_ev.rstrip('.')}.")
+    parts.append(f"Based on this, the answer is {rej_letter}. {rej_text}.")
+
+    return " ".join(parts)
+
+
+def main():
+    records = []
+    for fp in INPUT_FILES:
+        if not os.path.exists(fp):
+            print(f"skip missing: {fp}")
+            continue
+        with open(fp) as f:
+            for line in f:
+                records.append(json.loads(line))
+        print(f"loaded {fp}")
+
+    dpo = []
+    type_counter = Counter()
+    dropped_missing_evidence = 0
+    for rec in records:
+        v_path = rec["video_path"]
+        a_path = rec["audio_path"]
+        for qa in rec.get("qa_pairs", []):
+            q = qa.get("question", "").strip()
+            opts = qa.get("options", {})
+            correct = qa.get("answer", "").strip()
+            if not (q and len(opts) >= 4 and correct in opts):
+                continue
+
+            # Require at least some evidence to justify long-form rewrite
+            if not (qa.get("audio_evidence") or qa.get("visual_evidence")):
+                dropped_missing_evidence += 1
+                continue
+
+            wrong = [k for k in opts if k != correct]
+            if not wrong:
+                continue
+            rej = random.choice(wrong)
+
+            chosen_text = build_chosen_longform(qa)
+            rejected_text = build_rejected_longform(qa, rej)
+
+            options_text = "\n".join(f"{k}. {opts[k]}" for k in sorted(opts))
+            user_content = (
+                f"<video><audio>{q}\n{options_text}\n"
+                f"Please provide your answer by stating the letter followed by the full option, "
+                f"with a brief explanation grounded in the audio and visual cues."
+            )
+
+            dpo.append({
+                "messages": [{"role": "user", "content": user_content}],
+                "chosen":   {"role": "assistant", "content": chosen_text},
+                "rejected": {"role": "assistant", "content": rejected_text},
+                "videos": [v_path],
+                "audios": [a_path],
+            })
+            type_counter[qa.get("type", "Unknown")] += 1
+
+    random.shuffle(dpo)
+    os.makedirs(os.path.dirname(OUTPUT_FILE), exist_ok=True)
+    with open(OUTPUT_FILE, "w") as f:
+        json.dump(dpo, f, ensure_ascii=False, indent=1)
+
+    print(f"\nWrote {len(dpo)} long-form DPO pairs -> {OUTPUT_FILE}")
+    print(f"Dropped (no evidence): {dropped_missing_evidence}")
+    print("\nQuestion type distribution:")
+    for t, n in type_counter.most_common():
+        print(f"  {t:30s} {n}")
+
+    # Show a sample
+    if dpo:
+        s = dpo[0]
+        print("\n=== Sample ===")
+        print(f"USER: {s['messages'][0]['content'][:200]}")
+        print(f"CHOSEN: {s['chosen']['content']}")
+        print(f"REJECTED: {s['rejected']['content']}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/av_mcqa_pipeline/README.md b/data_gen/av_mcqa_pipeline/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7a5c47ea4853a5c88117532427356a1f4823091
--- /dev/null
+++ b/data_gen/av_mcqa_pipeline/README.md
@@ -0,0 +1,109 @@
+# AV-MCQA DPO data pipeline (FineVideo + Gemini + GPT-5.4)
+
+Goal: generate audio-visual MCQA DPO pairs targeted at WorldSense / Daily-Omni
+style benchmarks. Each surviving question is guaranteed to require BOTH audio
+and video to answer correctly.
+
+## Pipeline (4 stages)
+
+1. **`01_select_finevideo.py`**
+   Pool: `filtered_candidates_all_passing.jsonl` (4616 entries with full
+   metadata including `audioVisualCorrelation` per scene). EXCLUDE the 1000
+   already-used local videos (in `filtered_candidates.jsonl`) so we get *new*
+   videos. Filter: `mean AVC >= 0.85`, duration `[30, 180]s`, balance per
+   `content_parent_category` (cap 100/cat, target ~800).
+   Then download missing videos via HF streaming
+   (`HuggingFaceFV/finevideo`), saving mp4 + extracted wav to
+   `/opt/dlami/nvme/finevideo_av_mcqa/{videos,audio}/`.
+   Output: `/opt/dlami/nvme/av_mcqa/01_selected_videos.jsonl`
+
+2. **`02_gemini_generate_av_mcqa.py`**
+   Upload each mp4 (audio+video) to Gemini. Ask for 3 MCQAs per video,
+   spanning Daily-Omni's 6 question types (AV Event Alignment, Event Sequence,
+   Context Understanding, Inference, Reasoning, Comparative). Each MCQA has
+   4 options and a marked correct letter.
+
+   **Backend pool**:
+   - up to 3 Gemini direct keys: `GOOGLE_API_KEY_1`, `GOOGLE_API_KEY_2`,
+     `GOOGLE_API_KEY_3` (round-robin; a key is auto-disabled when it hits
+     quota / rate-limit / RESOURCE_EXHAUSTED).
+   - fallback to OpenRouter when ALL Gemini keys are exhausted:
+     `OPENROUTER_API_KEY`, default model `google/gemini-2.5-pro`
+     (override with `OPENROUTER_MODEL=...`).
+   - default Gemini model `gemini-3-flash` (override with `GEMINI_MODEL=...`,
+     e.g. `gemini-2.5-flash` or `gemini-2.5-pro`).
+
+   Output: `/opt/dlami/nvme/av_mcqa/02_gemini_generated.jsonl`
+
+3. **`03_gpt5_video_only_filter.py`**
+   For each MCQA, send VIDEO FRAMES ONLY (no audio) to GPT-5.4. If GPT picks
+   the correct answer, the question is answerable without audio -> drop.
+   Surviving questions truly need audio.
+   Output: `/opt/dlami/nvme/av_mcqa/03_filtered_must_audio.jsonl`
+   Env: `OPENAI_API_KEY`
+
+4. **`04_assemble_dpo.py`**
+   Convert surviving MCQAs to LlamaFactory DPO format. `chosen` = correct
+   option (letter + full text); `rejected` = randomly chosen wrong option.
+   Each entry includes both `videos` and `audios` paths.
+   Output: `/home/ubuntu/LlamaFactory/data/dpo_finevideo_av_mcqa.json`
+
+## Run
+
+```bash
+conda activate video
+
+export GOOGLE_API_KEY_1=...
+export GOOGLE_API_KEY_2=...
+export GOOGLE_API_KEY_3=...
+export OPENROUTER_API_KEY=...     # fallback
+export OPENAI_API_KEY=sk-...      # for step 3 (GPT-5.4 video-only filter)
+
+cd /home/ubuntu/code-202604_v2/data_gen/av_mcqa_pipeline
+python 01_select_finevideo.py            # selects + downloads new videos via HF streaming
+python 02_gemini_generate_av_mcqa.py     # multi-key + OpenRouter fallback
+python 03_gpt5_video_only_filter.py
+python 04_assemble_dpo.py
+```
+
+All steps write JSONL line-by-line and resume on rerun.
+
+## Register dataset (after step 4)
+
+Append to `LlamaFactory/data/dataset_info.json`:
+
+```json
+"dpo_finevideo_av_mcqa": {
+  "file_name": "dpo_finevideo_av_mcqa.json",
+  "formatting": "sharegpt",
+  "ranking": true,
+  "columns": {
+    "messages": "messages",
+    "chosen": "chosen",
+    "rejected": "rejected",
+    "videos": "videos",
+    "audios": "audios"
+  },
+  "tags": {
+    "role_tag": "role",
+    "content_tag": "content",
+    "user_tag": "user",
+    "assistant_tag": "assistant"
+  }
+}
+```
+
+## Cost rough estimate
+
+- Step 2 (Gemini 3 Flash, ~800 videos × 1 call):   ~$25-60
+- Step 3 (GPT-5.4 with 12 frames × ~2400 questions): ~$30-80
+- Step 4: free
+
+Total: roughly **$60-150**, finishing in a few hours.
+
+## Tunables
+
+- `MIN_MEAN_AVC` in step 1 (default 0.85): higher = stricter AV-correlated videos
+- `QUESTIONS_PER_VIDEO` in step 2 (default 3): more = more candidates, more $$$
+- Survival rate in step 3 will likely be 30-60%; if too low, lower MIN_MEAN_AVC
+  in step 1 or refine the Gemini prompt to emphasize "must need audio".
diff --git a/data_gen/build_dpo_dataset.py b/data_gen/build_dpo_dataset.py
new file mode 100644
index 0000000000000000000000000000000000000000..91db7b97007f6051905a9e4574182ea94ec7878f
--- /dev/null
+++ b/data_gen/build_dpo_dataset.py
@@ -0,0 +1,431 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import random
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from openai import AsyncOpenAI
+
+
+PROMPT_CHOICES = [
+    "Are the audio and video tracks synchronized in this video?",
+    "Identify the exact timing of the visual impact and its corresponding sound. Do they align?",
+    "Is there any noticeable audio delay or temporal manipulation in this clip?",
+]
+
+RESPONSE_KEYS = [
+    "resp_sample1_correct",
+    "resp_sample1_hallucinated",
+    "resp_sample2_correct",
+    "resp_sample2_hallucinated",
+    "resp_sample3_correct",
+    "resp_sample3_hallucinated",
+]
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Build KTO preference dataset from original + shifted videos with GPT-5.4 text generation."
+    )
+    p.add_argument(
+        "--labels-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/gemini_label_result/timestamps_results_normalized.jsonl"),
+    )
+    p.add_argument(
+        "--shift-meta-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/random_shift_video/shift_metadata.jsonl"),
+    )
+    p.add_argument(
+        "--output-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/kto_training_data.jsonl"),
+    )
+    p.add_argument("--model", type=str, default="gpt-5.4")
+    p.add_argument("--max-concurrency", type=int, default=8)
+    p.add_argument("--max-retries", type=int, default=5)
+    p.add_argument("--base-backoff-sec", type=float, default=2.0)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--ffprobe-timeout-sec", type=int, default=30)
+    return p.parse_args()
+
+
+def read_jsonl(path: Path) -> List[Dict[str, Any]]:
+    out: List[Dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            s = line.strip()
+            if not s:
+                continue
+            out.append(json.loads(s))
+    return out
+
+
+def append_jsonl(path: Path, row: 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(row, ensure_ascii=False) + "\n")
+
+
+def original_rel_from_label_row(row: Dict[str, Any]) -> str:
+    # Convert absolute original path to relative path under /home/ubuntu/video_source/original.
+    video_path = Path(str(row["video_path"]))
+    parts = list(video_path.parts)
+    if "original" in parts:
+        idx = parts.index("original")
+        return str(Path(*parts[idx + 1 :]))
+    return str(video_path.name)
+
+
+def build_annotations_map(rows: List[Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    out: Dict[str, Dict[str, Any]] = {}
+    for r in rows:
+        rel = original_rel_from_label_row(r)
+        out[rel] = r
+    return out
+
+
+def build_shift_map(rows: List[Dict[str, Any]]) -> Dict[str, Dict[str, Dict[str, Any]]]:
+    out: Dict[str, Dict[str, Dict[str, Any]]] = defaultdict(dict)
+    for r in rows:
+        orig = str(r.get("original_video", "")).strip()
+        direction = str(r.get("shift_direction", "")).strip()
+        if not orig or direction not in {"delayed", "early"}:
+            continue
+        # Keep first occurrence to avoid duplicates in metadata.
+        if direction not in out[orig]:
+            out[orig][direction] = r
+    return out
+
+
+async def ffprobe_duration_seconds(video_path: str, timeout_sec: int) -> float:
+    proc = await asyncio.create_subprocess_exec(
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        video_path,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=float(timeout_sec))
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise RuntimeError(f"ffprobe timeout: {video_path}")
+    if proc.returncode != 0:
+        raise RuntimeError(f"ffprobe failed for {video_path}: {(stderr or b'').decode(errors='ignore')[-200:]}")
+    txt = (stdout or b"").decode().strip()
+    return float(txt)
+
+
+def make_system_prompt() -> str:
+    return (
+        "You generate ONLY JSON. Return EXACTLY six string fields and no extras: "
+        + ", ".join(RESPONSE_KEYS)
+        + ". "
+        "Do not perform arithmetic beyond using provided facts. Python already computed all numbers. "
+        "Important style rule: the three clips are anonymous. "
+        "Never infer or mention dataset labels/split names/source names or paths. "
+        "Do not use words such as original, delayed, early, manipulated, shifted."
+    )
+
+
+def make_user_payload(facts: Dict[str, Any]) -> str:
+    return (
+        "Facts (ground truth computed by Python):\n"
+        + json.dumps(facts, ensure_ascii=False, indent=2)
+        + "\n\nInstruction:\n"
+        "Return a JSON object with exactly these 6 string values:\n"
+        "1) resp_sample1_correct: confirms synchronization for sample_1. Integrate event_v and event_a. "
+        "If sample1_gap <= 0.4s, explicitly mention negligible natural tolerance of sample1_gap.\n"
+        "2) resp_sample1_hallucinated: incorrectly claims a noticeable mismatch for sample_1.\n"
+        "3) resp_sample2_correct: expert explanation for sample_2, integrate event_v/event_a, "
+        "must cite t_visual and t_audio_sample2, and use natural estimation language with sample2_gap.\n"
+        "4) resp_sample2_hallucinated: incorrectly claims sample_2 is perfectly synchronized at t_visual.\n"
+        "5) resp_sample3_correct: expert explanation for sample_3, integrate event_v/event_a, "
+        "must cite t_visual and t_audio_sample3, and use natural estimation language with sample3_gap.\n"
+        "6) resp_sample3_hallucinated: incorrectly claims sample_3 is perfectly synchronized.\n"
+        "Hard constraint: clip labels are anonymous. Do not use words such as original/delayed/early/manipulated.\n"
+        "All six values must be concise, natural, and label-neutral."
+    )
+
+
+async def call_llm_with_backoff(
+    client: AsyncOpenAI,
+    model: str,
+    facts: Dict[str, Any],
+    max_retries: int,
+    base_backoff_sec: float,
+) -> Dict[str, str]:
+    system_prompt = make_system_prompt()
+    user_prompt = make_user_payload(facts)
+
+    last_exc: Optional[Exception] = None
+    for attempt in range(1, max_retries + 1):
+        try:
+            resp = await client.chat.completions.create(
+                model=model,
+                response_format={"type": "json_object"},
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+            )
+            txt = (resp.choices[0].message.content or "").strip()
+            obj = json.loads(txt)
+            missing = [k for k in RESPONSE_KEYS if k not in obj or not isinstance(obj[k], str)]
+            if missing:
+                raise ValueError(f"Missing/invalid response keys: {missing}")
+            return {k: obj[k] for k in RESPONSE_KEYS}
+        except Exception as exc:
+            last_exc = exc
+            if attempt == max_retries:
+                break
+            wait_s = base_backoff_sec * (2 ** (attempt - 1))
+            await asyncio.sleep(wait_s)
+    raise RuntimeError(f"LLM generation failed after retries: {last_exc}")
+
+
+def build_existing_completion_state(
+    output_jsonl: Path,
+    shifted_to_original: Dict[str, str],
+) -> Dict[str, Set[str]]:
+    """
+    Returns mapping: original_rel -> set of row types already written {"orig","delayed","early"}.
+    """
+    state: Dict[str, Set[str]] = defaultdict(set)
+    if not output_jsonl.exists():
+        return state
+    with output_jsonl.open("r", encoding="utf-8") as f:
+        for line in f:
+            s = line.strip()
+            if not s:
+                continue
+            try:
+                row = json.loads(s)
+            except json.JSONDecodeError:
+                continue
+            video = str(row.get("video", "")).strip()
+            if not video:
+                continue
+            # Infer row type and original key.
+            if video in shifted_to_original:
+                orig = shifted_to_original[video]
+                if "_delay_" in Path(video).name:
+                    state[orig].add("delayed")
+                elif "_early_" in Path(video).name:
+                    state[orig].add("early")
+            else:
+                # Treat as original row if it looks like an original relative path.
+                state[video].add("orig")
+    return state
+
+
+async def process_one_original(
+    original_rel: str,
+    ann_row: Dict[str, Any],
+    shift_row_delayed: Dict[str, Any],
+    shift_row_early: Dict[str, Any],
+    args: argparse.Namespace,
+    client: AsyncOpenAI,
+    sem: asyncio.Semaphore,
+    write_lock: asyncio.Lock,
+    completion_state: Dict[str, Set[str]],
+    prompt_rng: random.Random,
+    counters: Dict[str, int],
+) -> None:
+    existing_types = completion_state.get(original_rel, set())
+    if existing_types == {"orig", "delayed", "early"}:
+        counters["skipped_completed"] += 1
+        return
+
+    async with sem:
+        original_video_path = str(ann_row["video_path"])
+        video_duration = await ffprobe_duration_seconds(original_video_path, args.ffprobe_timeout_sec)
+
+        t_visual = float(ann_row["t_visual"])
+        t_audio = float(ann_row["t_audio"])
+        event_v = str(ann_row.get("event_description", "")).strip()
+        event_a = str(ann_row.get("sound_description", "")).strip()
+        delayed_shift_seconds = float(shift_row_delayed["exact_shift_seconds"])
+        early_shift_seconds = float(shift_row_early["exact_shift_seconds"])
+
+        original_delta = abs(t_visual - t_audio)
+        t_audio_delayed = min(t_audio + delayed_shift_seconds, video_duration)
+        t_audio_early = max(t_audio - early_shift_seconds, 0.0)
+        true_delayed_gap = round(abs(t_audio_delayed - t_visual), 2)
+        true_early_gap = round(abs(t_audio_early - t_visual), 2)
+
+        facts = {
+            "video_duration": round(video_duration, 3),
+            "t_visual": round(t_visual, 3),
+            "t_audio_sample1": round(t_audio, 3),
+            "event_v": event_v,
+            "event_a": event_a,
+            "shift_seconds_sample2": round(delayed_shift_seconds, 6),
+            "shift_seconds_sample3": round(early_shift_seconds, 6),
+            "t_audio_sample2": round(t_audio_delayed, 3),
+            "t_audio_sample3": round(t_audio_early, 3),
+            "sample1_gap": round(original_delta, 3),
+            "sample2_gap": true_delayed_gap,
+            "sample3_gap": true_early_gap,
+        }
+
+        texts = await call_llm_with_backoff(
+            client=client,
+            model=args.model,
+            facts=facts,
+            max_retries=args.max_retries,
+            base_backoff_sec=args.base_backoff_sec,
+        )
+
+        selected_prompt = prompt_rng.choice(PROMPT_CHOICES)
+        rows = [
+            {
+                "video": original_rel,
+                "prompt": selected_prompt,
+                "chosen": texts["resp_sample1_correct"],
+                "rejected": texts["resp_sample1_hallucinated"],
+            },
+            {
+                "video": str(shift_row_delayed["shifted_video_path"]),
+                "prompt": selected_prompt,
+                "chosen": texts["resp_sample2_correct"],
+                "rejected": texts["resp_sample2_hallucinated"],
+            },
+            {
+                "video": str(shift_row_early["shifted_video_path"]),
+                "prompt": selected_prompt,
+                "chosen": texts["resp_sample3_correct"],
+                "rejected": texts["resp_sample3_hallucinated"],
+            },
+        ]
+
+        missing_rows: List[Dict[str, Any]] = []
+        if "orig" not in existing_types:
+            missing_rows.append(rows[0])
+        if "delayed" not in existing_types:
+            missing_rows.append(rows[1])
+        if "early" not in existing_types:
+            missing_rows.append(rows[2])
+
+        async with write_lock:
+            for r in missing_rows:
+                append_jsonl(args.output_jsonl, r)
+            completion_state[original_rel] = {"orig", "delayed", "early"}
+
+        counters["processed_originals"] += 1
+        counters["written_rows"] += len(missing_rows)
+
+
+async def main_async() -> None:
+    args = parse_args()
+    random.seed(args.seed)
+
+    if not os.getenv("OPENAI_API_KEY"):
+        raise RuntimeError("OPENAI_API_KEY is required.")
+    client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+
+    labels = read_jsonl(args.labels_jsonl)
+    shift_meta = read_jsonl(args.shift_meta_jsonl)
+    ann_map = build_annotations_map(labels)
+    shift_map = build_shift_map(shift_meta)
+
+    # Build reverse map for resume detection from existing output rows.
+    shifted_to_original: Dict[str, str] = {}
+    for orig, both in shift_map.items():
+        for direction in ("delayed", "early"):
+            item = both.get(direction)
+            if item:
+                shifted_to_original[str(item["shifted_video_path"])] = orig
+
+    completion_state = build_existing_completion_state(args.output_jsonl, shifted_to_original)
+
+    # Process only originals present in labels (1420) and that are included in shift set (1589 superset).
+    candidates: List[Tuple[str, Dict[str, Any], Dict[str, Any], Dict[str, Any]]] = []
+    missing_shift = 0
+    for original_rel, ann_row in ann_map.items():
+        sides = shift_map.get(original_rel, {})
+        delayed = sides.get("delayed")
+        early = sides.get("early")
+        if delayed is None or early is None:
+            missing_shift += 1
+            continue
+        candidates.append((original_rel, ann_row, delayed, early))
+    candidates.sort(key=lambda x: x[0])
+
+    sem = asyncio.Semaphore(max(1, args.max_concurrency))
+    write_lock = asyncio.Lock()
+    prompt_rng = random.Random(args.seed)
+    counters = {
+        "processed_originals": 0,
+        "written_rows": 0,
+        "skipped_completed": 0,
+        "failed_originals": 0,
+    }
+
+    async def runner(item: Tuple[str, Dict[str, Any], Dict[str, Any], Dict[str, Any]]) -> None:
+        orig, ann, drow, erow = item
+        try:
+            await process_one_original(
+                original_rel=orig,
+                ann_row=ann,
+                shift_row_delayed=drow,
+                shift_row_early=erow,
+                args=args,
+                client=client,
+                sem=sem,
+                write_lock=write_lock,
+                completion_state=completion_state,
+                prompt_rng=prompt_rng,
+                counters=counters,
+            )
+        except Exception as exc:
+            counters["failed_originals"] += 1
+            print(f"[error] {orig}: {exc}")
+
+    tasks = [asyncio.create_task(runner(it)) for it in candidates]
+    for i, t in enumerate(asyncio.as_completed(tasks), start=1):
+        await t
+        if i % 50 == 0:
+            print(
+                f"[progress] done={i}/{len(candidates)} "
+                f"processed={counters['processed_originals']} "
+                f"written_rows={counters['written_rows']} "
+                f"skipped={counters['skipped_completed']} "
+                f"failed={counters['failed_originals']}"
+            )
+
+    print("========== KTO Build Summary ==========")
+    print(f"Labels rows                      : {len(labels)}")
+    print(f"Unique labeled originals         : {len(ann_map)}")
+    print(f"Unique shifted originals         : {len(shift_map)}")
+    print(f"Labeled but missing shift pairs  : {missing_shift}")
+    print(f"Candidate originals              : {len(candidates)}")
+    print(f"Processed originals              : {counters['processed_originals']}")
+    print(f"Skipped completed originals      : {counters['skipped_completed']}")
+    print(f"Failed originals                 : {counters['failed_originals']}")
+    print(f"Rows appended to output          : {counters['written_rows']}")
+    print(f"Output JSONL                     : {args.output_jsonl}")
+    print("=======================================")
+
+
+def main() -> None:
+    asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/data_gen/convert_mcqa_to_dpo.py b/data_gen/convert_mcqa_to_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdc0c21adb2282256a07229d5958befad3b30872
--- /dev/null
+++ b/data_gen/convert_mcqa_to_dpo.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Convert LLaVA-Video-178K MCQA data to LlamaFactory DPO format.
+
+For each QA pair:
+  chosen  = correct answer (letter + full option text)
+  rejected = randomly picked wrong option (letter + full option text)
+
+Output: single JSON file ready for LlamaFactory DPO training.
+"""
+
+import json, os, re, random, sys
+from pathlib import Path
+
+random.seed(42)
+
+BASE = "/opt/dlami/nvme/datasets/LLaVA-Video-178K-subset"
+
+MC_FILES = [
+    ("0_30_s_academic_v0_1",   "0_30_s_academic_mc_v0_1_qa_processed.json"),
+    ("30_60_s_academic_v0_1",  "30_60_s_academic_mc_v0_1_qa_processed.json"),
+    ("1_2_m_academic_v0_1",    "1_2_m_academic_mc_v0_1_qa_processed.json"),
+    ("2_3_m_academic_v0_1",    "2_3_m_academic_mc_v0_1_qa_processed.json"),
+    ("0_30_s_perceptiontest",  "0_30_s_perceptiontest_mc_qa_processed.json"),
+    ("30_60_s_perceptiontest", "30_60_s_perceptiontest_mc_qa_processed.json"),
+]
+
+OPTION_RE = re.compile(r"^([A-F])\.\s*(.+)", re.MULTILINE)
+
+
+def parse_options(question_text: str) -> dict[str, str]:
+    """Extract {letter: full_text} from the question body."""
+    opts = {}
+    for m in OPTION_RE.finditer(question_text):
+        opts[m.group(1)] = m.group(2).strip()
+    return opts
+
+
+def parse_answer_letter(answer_text: str) -> str:
+    """Extract the answer letter from gpt value like 'B.' or 'D. Light pink.'"""
+    answer_text = answer_text.strip()
+    m = re.match(r"^([A-F])", answer_text)
+    return m.group(1) if m else ""
+
+
+def make_full_answer(letter: str, options: dict[str, str]) -> str:
+    """Return 'X. full text' format."""
+    text = options.get(letter, "")
+    if text:
+        return f"{letter}. {text}"
+    return f"{letter}."
+
+
+def convert():
+    dpo_records = []
+    stats = {"total_qa": 0, "skipped_no_options": 0, "skipped_no_answer": 0}
+
+    for subdir, fname in MC_FILES:
+        fpath = os.path.join(BASE, subdir, fname)
+        data = json.load(open(fpath))
+
+        for entry in data:
+            video_rel = entry["video"]  # e.g. perception_test/videos/video_2779.mp4
+            video_abs = os.path.join(BASE, subdir, video_rel)
+
+            if not os.path.exists(video_abs):
+                continue
+
+            convs = entry["conversations"]
+            for i in range(0, len(convs) - 1, 2):
+                q_text = convs[i]["value"]      # human question with <image> tag and options
+                a_text = convs[i + 1]["value"]  # gpt answer
+
+                stats["total_qa"] += 1
+
+                options = parse_options(q_text)
+                if len(options) < 2:
+                    stats["skipped_no_options"] += 1
+                    continue
+
+                correct_letter = parse_answer_letter(a_text)
+                if not correct_letter or correct_letter not in options:
+                    stats["skipped_no_answer"] += 1
+                    continue
+
+                wrong_letters = [k for k in options if k != correct_letter]
+                rejected_letter = random.choice(wrong_letters)
+
+                chosen_text = make_full_answer(correct_letter, options)
+                rejected_text = make_full_answer(rejected_letter, options)
+
+                # Replace <image> with <video>; ensure exactly one <video> token
+                # (LLaVA only adds <image> on the first turn of each entry; later turns
+                # inherit the video implicitly. Since we split each turn into its own
+                # DPO record, every record needs its own <video> token.)
+                user_content = q_text.replace("<image>", "<video>")
+                if "<video>" not in user_content:
+                    user_content = "<video>" + user_content
+
+                record = {
+                    "messages": [
+                        {"role": "user", "content": user_content}
+                    ],
+                    "chosen": {"role": "assistant", "content": chosen_text},
+                    "rejected": {"role": "assistant", "content": rejected_text},
+                    "videos": [video_abs],
+                }
+                dpo_records.append(record)
+
+    out_path = "/home/ubuntu/LlamaFactory/data/dpo_llava_academic_perceptiontest_mcqa.json"
+    with open(out_path, "w") as f:
+        json.dump(dpo_records, f, ensure_ascii=False, indent=1)
+
+    print(f"Written {len(dpo_records)} DPO pairs to {out_path}")
+    print(f"Stats: {stats}")
+
+
+if __name__ == "__main__":
+    convert()
diff --git a/data_gen/export_disagreement_to_csv.py b/data_gen/export_disagreement_to_csv.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c3cdafb080f11cb682800f833aeeda2e936800e
--- /dev/null
+++ b/data_gen/export_disagreement_to_csv.py
@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+import argparse
+import csv
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Export model timestamp disagreements from JSONL to CSV."
+    )
+    parser.add_argument(
+        "--input",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/result/visual_timestamps_compare.jsonl"),
+        help="Path to visual_timestamps_compare.jsonl",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/result/visual_timestamps_compare_review.csv"),
+        help="Output CSV path",
+    )
+    parser.add_argument(
+        "--min-spread",
+        type=float,
+        default=0.8,
+        help="Export rows where max timestamp spread >= this value",
+    )
+    parser.add_argument(
+        "--top-k",
+        type=int,
+        default=0,
+        help="If >0, export only top-K most disagreed rows after filtering",
+    )
+    parser.add_argument(
+        "--filter-mode",
+        choices=[
+            "spread",
+            "gemini_claude",
+            "gemini_gpt5_1",
+            "outlier_consensus",
+            "gemini_validated",
+            "gemini_need_review",
+        ],
+        default="spread",
+        help="Filtering rule to apply",
+    )
+    parser.add_argument(
+        "--min-diff",
+        type=float,
+        default=0.8,
+        help="Minimum absolute difference for gemini_* filter modes",
+    )
+    parser.add_argument(
+        "--outlier-threshold",
+        type=float,
+        default=3.0,
+        help="Outlier threshold for outlier_consensus mode",
+    )
+    parser.add_argument(
+        "--pair-agree-threshold",
+        type=float,
+        default=0.6,
+        help="Agreement threshold for kept model pair in outlier_consensus mode",
+    )
+    parser.add_argument(
+        "--gemini-agree-threshold",
+        type=float,
+        default=1.0,
+        help="For gemini_* modes: accept if OpenAI or Claude differs from Gemini by less than this threshold",
+    )
+    return parser.parse_args()
+
+
+def load_jsonl(path: Path) -> List[Dict[str, Any]]:
+    data: List[Dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            s = line.strip()
+            if not s:
+                continue
+            try:
+                obj = json.loads(s)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSONL at line {line_no}: {exc}") from exc
+            if not isinstance(obj, dict):
+                raise ValueError(f"Line {line_no} is not a JSON object.")
+            data.append(obj)
+    return data
+
+
+def _to_float_or_none(value: Any) -> Optional[float]:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _abs_diff(a: Optional[float], b: Optional[float]) -> Optional[float]:
+    if a is None or b is None:
+        return None
+    return abs(a - b)
+
+
+def _round_or_none(v: Optional[float], digits: int = 3) -> Optional[float]:
+    if v is None:
+        return None
+    return round(float(v), digits)
+
+
+def _compute_consensus(values: List[float]) -> float:
+    s = sorted(values)
+    n = len(s)
+    if n % 2 == 1:
+        return s[n // 2]
+    return (s[n // 2 - 1] + s[n // 2]) / 2.0
+
+
+def build_row(item: Dict[str, Any]) -> Dict[str, Any]:
+    t_gemini = _to_float_or_none(item.get("t_gemini"))
+    t_gpt5_1 = _to_float_or_none(item.get("t_gpt5_1"))
+    t_claude = _to_float_or_none(item.get("t_claude"))
+
+    available = [x for x in [t_gemini, t_gpt5_1, t_claude] if x is not None]
+    if available:
+        t_min = min(available)
+        t_max = max(available)
+        spread = t_max - t_min
+        consensus = _compute_consensus(available)
+    else:
+        t_min = None
+        t_max = None
+        spread = None
+        consensus = None
+
+    missing_count = int(t_gemini is None) + int(t_gpt5_1 is None) + int(t_claude is None)
+    pair_count = int(t_gemini is not None and t_gpt5_1 is not None) + int(
+        t_gemini is not None and t_claude is not None
+    ) + int(t_gpt5_1 is not None and t_claude is not None)
+
+    diff_gemini_gpt5_1 = _abs_diff(t_gemini, t_gpt5_1)
+    diff_gemini_claude = _abs_diff(t_gemini, t_claude)
+    diff_gpt5_1_claude = _abs_diff(t_gpt5_1, t_claude)
+
+    return {
+        "video_id": item.get("video_id", ""),
+        "t_gemini": _round_or_none(t_gemini),
+        "t_gpt5_1": _round_or_none(t_gpt5_1),
+        "t_claude": _round_or_none(t_claude),
+        "diff_gemini_gpt5_1": _round_or_none(diff_gemini_gpt5_1),
+        "diff_gemini_claude": _round_or_none(diff_gemini_claude),
+        "diff_gpt5_1_claude": _round_or_none(diff_gpt5_1_claude),
+        "spread_max_min": _round_or_none(spread),
+        "t_min": _round_or_none(t_min),
+        "t_max": _round_or_none(t_max),
+        "consensus_median": _round_or_none(consensus),
+        "models_available": len(available),
+        "pairwise_available": pair_count,
+        "missing_models": missing_count,
+        "event_description": item.get("event_description", ""),
+        "manual_note": "",
+        "manual_label": "",
+    }
+
+
+def classify_outlier_consensus(
+    row: Dict[str, Any],
+    outlier_threshold: float,
+    pair_agree_threshold: float,
+) -> Optional[Dict[str, Any]]:
+    tg = row.get("t_gemini")
+    to = row.get("t_gpt5_1")
+    tc = row.get("t_claude")
+    if tg is None or to is None or tc is None:
+        return None
+
+    d_go = abs(float(tg) - float(to))
+    d_gc = abs(float(tg) - float(tc))
+    d_oc = abs(float(to) - float(tc))
+
+    outlier_model = ""
+    kept_models = ""
+    kept_diff: Optional[float] = None
+    final_t_visual: Optional[float] = None
+
+    if d_go > outlier_threshold and d_gc > outlier_threshold:
+        outlier_model = "gemini"
+        kept_models = "gpt5_1+claude"
+        kept_diff = d_oc
+        final_t_visual = (float(to) + float(tc)) / 2.0
+    elif d_go > outlier_threshold and d_oc > outlier_threshold:
+        outlier_model = "gpt5_1"
+        kept_models = "gemini+claude"
+        kept_diff = d_gc
+        final_t_visual = (float(tg) + float(tc)) / 2.0
+    elif d_gc > outlier_threshold and d_oc > outlier_threshold:
+        outlier_model = "claude"
+        kept_models = "gemini+gpt5_1"
+        kept_diff = d_go
+        final_t_visual = (float(tg) + float(to)) / 2.0
+    else:
+        return None
+
+    if kept_diff is None or kept_diff >= pair_agree_threshold:
+        return None
+
+    out = dict(row)
+    out["outlier_model"] = outlier_model
+    out["kept_models"] = kept_models
+    out["kept_pair_diff"] = _round_or_none(kept_diff)
+    out["final_t_visual"] = _round_or_none(final_t_visual)
+    out["rule"] = (
+        f"outlier>{outlier_threshold}s and kept_pair<{pair_agree_threshold}s"
+    )
+    return out
+
+
+def main() -> None:
+    args = parse_args()
+    if not args.input.exists():
+        raise FileNotFoundError(f"Input file not found: {args.input}")
+
+    items = load_jsonl(args.input)
+    rows = [build_row(item) for item in items]
+
+    filtered: List[Dict[str, Any]] = []
+    for row in rows:
+        if args.filter_mode == "spread":
+            spread = row.get("spread_max_min")
+            if spread is not None and float(spread) >= args.min_spread:
+                filtered.append(row)
+        elif args.filter_mode == "gemini_claude":
+            diff = row.get("diff_gemini_claude")
+            if diff is not None and float(diff) > args.min_diff:
+                filtered.append(row)
+        elif args.filter_mode == "gemini_gpt5_1":
+            diff = row.get("diff_gemini_gpt5_1")
+            if diff is not None and float(diff) > args.min_diff:
+                filtered.append(row)
+        elif args.filter_mode == "outlier_consensus":
+            accepted = classify_outlier_consensus(
+                row=row,
+                outlier_threshold=args.outlier_threshold,
+                pair_agree_threshold=args.pair_agree_threshold,
+            )
+            if accepted is not None:
+                filtered.append(accepted)
+        elif args.filter_mode in {"gemini_validated", "gemini_need_review"}:
+            d_go = row.get("diff_gemini_gpt5_1")
+            d_gc = row.get("diff_gemini_claude")
+            validated = (
+                (d_go is not None and float(d_go) < args.gemini_agree_threshold)
+                or (d_gc is not None and float(d_gc) < args.gemini_agree_threshold)
+            )
+            if args.filter_mode == "gemini_validated" and validated:
+                filtered.append(row)
+            if args.filter_mode == "gemini_need_review" and not validated:
+                filtered.append(row)
+
+    if args.filter_mode == "spread":
+        sort_key = "spread_max_min"
+    elif args.filter_mode == "gemini_claude":
+        sort_key = "diff_gemini_claude"
+    elif args.filter_mode == "gemini_gpt5_1":
+        sort_key = "diff_gemini_gpt5_1"
+    elif args.filter_mode == "gemini_validated":
+        sort_key = "spread_max_min"
+    elif args.filter_mode == "gemini_need_review":
+        sort_key = "spread_max_min"
+    else:
+        sort_key = "kept_pair_diff"
+    filtered.sort(key=lambda r: (r.get(sort_key) or -1, r["video_id"]), reverse=True)
+    if args.top_k > 0:
+        filtered = filtered[: args.top_k]
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    with args.output.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(
+            f,
+            fieldnames=[
+                "video_id",
+                "t_gemini",
+                "t_gpt5_1",
+                "t_claude",
+                "diff_gemini_gpt5_1",
+                "diff_gemini_claude",
+                "diff_gpt5_1_claude",
+                "spread_max_min",
+                "t_min",
+                "t_max",
+                "consensus_median",
+                "models_available",
+                "pairwise_available",
+                "missing_models",
+                "event_description",
+                "manual_note",
+                "manual_label",
+                "outlier_model",
+                "kept_models",
+                "kept_pair_diff",
+                "final_t_visual",
+                "rule",
+            ],
+        )
+        writer.writeheader()
+        writer.writerows(filtered)
+
+    print(f"Input rows: {len(items)}")
+    if args.filter_mode == "spread":
+        print(f"Rows with spread >= {args.min_spread}: {len(filtered)}")
+    elif args.filter_mode == "gemini_claude":
+        print(f"Rows with |t_gemini - t_claude| > {args.min_diff}: {len(filtered)}")
+    elif args.filter_mode == "gemini_gpt5_1":
+        print(f"Rows with |t_gemini - t_gpt5_1| > {args.min_diff}: {len(filtered)}")
+    elif args.filter_mode == "gemini_validated":
+        print(
+            "Accepted rows with Gemini validation rule: "
+            f"{len(filtered)} (|Gemini-OpenAI| < {args.gemini_agree_threshold} OR "
+            f"|Gemini-Claude| < {args.gemini_agree_threshold})"
+        )
+    elif args.filter_mode == "gemini_need_review":
+        print(
+            "Need-review rows with Gemini validation rule: "
+            f"{len(filtered)} (neither OpenAI nor Claude within {args.gemini_agree_threshold}s of Gemini)"
+        )
+    else:
+        print(
+            "Accepted rows with outlier-consensus rule: "
+            f"{len(filtered)} (outlier>{args.outlier_threshold}, kept_pair<{args.pair_agree_threshold})"
+        )
+    if args.top_k > 0:
+        print(f"Top-K limit applied: {args.top_k}")
+    print(f"CSV written to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/export_frame_selection_to_csv.py b/data_gen/export_frame_selection_to_csv.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ce863bae2e488a6be3a5bddc13a2065d7c284a0
--- /dev/null
+++ b/data_gen/export_frame_selection_to_csv.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+import argparse
+import csv
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+DEFAULT_INPUT = Path("/home/ubuntu/video_source/result/frame_selection_compare.jsonl")
+DEFAULT_OUTPUT = Path("/home/ubuntu/video_source/result/frame_selection_compare.csv")
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Convert frame_selection_compare.jsonl to readable CSV.")
+    p.add_argument("--input", type=Path, default=DEFAULT_INPUT, help="Input JSONL path")
+    p.add_argument("--output", type=Path, default=DEFAULT_OUTPUT, help="Output CSV path")
+    p.add_argument(
+        "--sort-by",
+        choices=["spread", "video_id"],
+        default="spread",
+        help="Sort output by disagreement spread or by video_id",
+    )
+    p.add_argument(
+        "--min-spread",
+        type=float,
+        default=0.0,
+        help="If >0, keep only rows where max time spread >= min-spread seconds",
+    )
+    return p.parse_args()
+
+
+def load_jsonl(path: Path) -> List[Dict[str, Any]]:
+    if not path.exists():
+        raise FileNotFoundError(f"Input JSONL not found: {path}")
+    rows: List[Dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            s = line.strip()
+            if not s:
+                continue
+            try:
+                obj = json.loads(s)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON at line {line_no}: {exc}") from exc
+            if not isinstance(obj, dict):
+                raise ValueError(f"Line {line_no} is not a JSON object.")
+            rows.append(obj)
+    return rows
+
+
+def to_float_or_none(v: Any) -> Optional[float]:
+    if v is None:
+        return None
+    try:
+        return float(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def to_int_or_none(v: Any) -> Optional[int]:
+    if v is None:
+        return None
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def abs_diff(a: Optional[float], b: Optional[float]) -> Optional[float]:
+    if a is None or b is None:
+        return None
+    return abs(a - b)
+
+
+def r3(v: Optional[float]) -> Optional[float]:
+    if v is None:
+        return None
+    return round(float(v), 3)
+
+
+def build_row(item: Dict[str, Any]) -> Dict[str, Any]:
+    t_g = to_float_or_none(item.get("t_gemini"))
+    t_o = to_float_or_none(item.get("t_openai"))
+    t_c = to_float_or_none(item.get("t_claude"))
+
+    fi_g = to_int_or_none(item.get("gemini_frame_index"))
+    fi_o = to_int_or_none(item.get("openai_frame_index"))
+    fi_c = to_int_or_none(item.get("claude_frame_index"))
+
+    available = [t for t in [t_g, t_o, t_c] if t is not None]
+    spread = (max(available) - min(available)) if available else None
+
+    return {
+        "video_id": item.get("video_id", ""),
+        "sampled_fps": to_float_or_none(item.get("sampled_fps")),
+        "num_sampled_frames": to_int_or_none(item.get("num_sampled_frames")),
+        "gemini_frame_index": fi_g,
+        "openai_frame_index": fi_o,
+        "claude_frame_index": fi_c,
+        "t_gemini": r3(t_g),
+        "t_openai": r3(t_o),
+        "t_claude": r3(t_c),
+        "diff_gemini_openai": r3(abs_diff(t_g, t_o)),
+        "diff_gemini_claude": r3(abs_diff(t_g, t_c)),
+        "diff_openai_claude": r3(abs_diff(t_o, t_c)),
+        "spread_max_min": r3(spread),
+        "models_available": len(available),
+        "missing_models": int(t_g is None) + int(t_o is None) + int(t_c is None),
+        "event_desc_gemini": item.get("event_desc_gemini"),
+        "event_desc_openai": item.get("event_desc_openai"),
+        "event_desc_claude": item.get("event_desc_claude"),
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    raw = load_jsonl(args.input)
+    rows = [build_row(x) for x in raw]
+
+    if args.min_spread > 0:
+        rows = [r for r in rows if r.get("spread_max_min") is not None and float(r["spread_max_min"]) >= args.min_spread]
+
+    if args.sort_by == "spread":
+        rows.sort(key=lambda r: (r.get("spread_max_min") or -1.0, r.get("video_id", "")), reverse=True)
+    else:
+        rows.sort(key=lambda r: str(r.get("video_id", "")))
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    fieldnames = [
+        "video_id",
+        "sampled_fps",
+        "num_sampled_frames",
+        "gemini_frame_index",
+        "openai_frame_index",
+        "claude_frame_index",
+        "t_gemini",
+        "t_openai",
+        "t_claude",
+        "diff_gemini_openai",
+        "diff_gemini_claude",
+        "diff_openai_claude",
+        "spread_max_min",
+        "models_available",
+        "missing_models",
+        "event_desc_gemini",
+        "event_desc_openai",
+        "event_desc_claude",
+    ]
+    with args.output.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+    print(f"Input rows: {len(raw)}")
+    print(f"Exported rows: {len(rows)}")
+    print(f"CSV written to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/gemini_annotator_multikey.py b/data_gen/gemini_annotator_multikey.py
new file mode 100644
index 0000000000000000000000000000000000000000..2dab2dcc7ba5491a8c8f13c21a9fe044f53eecdf
--- /dev/null
+++ b/data_gen/gemini_annotator_multikey.py
@@ -0,0 +1,778 @@
+#!/usr/bin/env python3
+"""
+Production-grade multi-key Gemini annotator with OpenRouter fallback.
+
+Core features:
+1) Dual-pass annotation per video:
+   - Pass 1: visual impact timestamp -> t_visual
+   - Pass 2: audio impact timestamp  -> t_audio
+2) Append-only checkpointing via JSONL (resume-safe).
+3) Thread-safe native Gemini API key rotation on quota/rate errors.
+4) Automatic OpenRouter fallback when all native keys are exhausted.
+5) Concurrency with bounded workers and robust failure isolation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import logging
+import os
+import re
+import threading
+import time
+from concurrent.futures import Future, ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple
+
+import numpy as np
+from google import genai
+from google.genai import types as genai_types
+from openai import OpenAI
+
+
+VIDEO_EXTS = {".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"}
+
+VISUAL_PROMPT = """You are an expert in physics and video forensics.
+Analyze this video and find the exact timestamp (seconds) of the single highest-energy physical impact event.
+
+Rules:
+- Return strictly JSON only.
+- "t_visual" must be a number in seconds.
+- If uncertain, still return your best estimate.
+
+Output format:
+{
+  "t_visual": 2.5,
+  "event_description": "brief description of the visual impact"
+}
+"""
+
+AUDIO_PROMPT = """You are an expert in acoustic forensics.
+Analyze this video and find the exact timestamp (seconds) of the loudest physical impact sound.
+
+Rules:
+- Return strictly JSON only.
+- "t_audio" must be a number in seconds.
+- Ignore speech/background music unless it is the physical impact itself.
+- If uncertain, still return your best estimate.
+
+Output format:
+{
+  "t_audio": 2.6,
+  "sound_description": "brief description of the impact sound"
+}
+"""
+
+
+@dataclass
+class AnnotationResult:
+    video_relpath: str
+    video_name: str
+    video_path: str
+    t_visual: float
+    t_audio: float
+    event_description: str
+    sound_description: str
+    provider: str
+    model: str
+    native_key_label: Optional[str]
+    elapsed_sec: float
+    created_at: float
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "video_relpath": self.video_relpath,
+            "video_name": self.video_name,
+            "video_path": self.video_path,
+            "t_visual": round(float(self.t_visual), 6),
+            "t_audio": round(float(self.t_audio), 6),
+            "event_description": self.event_description,
+            "sound_description": self.sound_description,
+            "provider": self.provider,
+            "model": self.model,
+            "native_key_label": self.native_key_label,
+            "elapsed_sec": round(float(self.elapsed_sec), 3),
+            "created_at": self.created_at,
+        }
+
+
+class NativeKeyManager:
+    """Thread-safe native Gemini key rotation manager."""
+
+    def __init__(self, keys: Sequence[Tuple[str, str]]):
+        filtered = [(label, key.strip()) for label, key in keys if key and key.strip()]
+        if not filtered:
+            raise ValueError("At least one native Gemini API key is required.")
+        self._keys: List[Tuple[str, str]] = list(filtered)
+        self._lock = threading.Lock()
+        self._active_idx = 0
+        self._quota_exhausted_labels: Set[str] = set()
+
+    def get_active(self) -> Optional[Tuple[str, str]]:
+        with self._lock:
+            for _ in range(len(self._keys)):
+                label, key = self._keys[self._active_idx]
+                if label not in self._quota_exhausted_labels:
+                    return label, key
+                self._active_idx = (self._active_idx + 1) % len(self._keys)
+            return None
+
+    def mark_quota_and_rotate(self, label: str) -> bool:
+        """
+        Mark a key as quota exhausted and rotate to next available key.
+        Returns True if all native keys are exhausted after this update.
+        """
+        with self._lock:
+            self._quota_exhausted_labels.add(label)
+            if self._keys:
+                self._active_idx = (self._active_idx + 1) % len(self._keys)
+            return len(self._quota_exhausted_labels) >= len(self._keys)
+
+    def all_exhausted(self) -> bool:
+        with self._lock:
+            return len(self._quota_exhausted_labels) >= len(self._keys)
+
+    def status_snapshot(self) -> Dict[str, Any]:
+        with self._lock:
+            active = self._keys[self._active_idx][0] if self._keys else None
+            return {
+                "active_key_label": active,
+                "quota_exhausted_labels": sorted(self._quota_exhausted_labels),
+                "total_native_keys": len(self._keys),
+            }
+
+
+def setup_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s | %(levelname)s | %(threadName)s | %(message)s",
+    )
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Dual-pass Gemini annotator with multi-key rotation and OpenRouter fallback."
+    )
+    p.add_argument(
+        "--video-dir",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/original/uag_oops"),
+        help="Root directory containing input videos.",
+    )
+    p.add_argument(
+        "--results-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/result/timestamps_results.jsonl"),
+        help="Append-only output JSONL for successful results.",
+    )
+    p.add_argument(
+        "--failed-log",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/result/failed_videos.log"),
+        help="Append-only failure log file.",
+    )
+    p.add_argument(
+        "--native-model",
+        type=str,
+        default="gemini-3.1-pro-preview",
+        help="Native Gemini model id for google-genai SDK.",
+    )
+    p.add_argument(
+        "--openrouter-model",
+        type=str,
+        default="google/gemini-2.5-pro",
+        help="OpenRouter model id (OpenAI-compatible endpoint).",
+    )
+    p.add_argument(
+        "--openrouter-base-url",
+        type=str,
+        default="https://openrouter.ai/api/v1",
+        help="OpenRouter OpenAI-compatible base URL.",
+    )
+    p.add_argument(
+        "--max-workers",
+        type=int,
+        default=4,
+        help="Number of concurrent workers (recommended 3-5).",
+    )
+    p.add_argument(
+        "--max-retries-per-video",
+        type=int,
+        default=3,
+        help="Retries for non-quota transient failures per provider.",
+    )
+    p.add_argument(
+        "--file-ready-timeout-sec",
+        type=int,
+        default=300,
+        help="Max seconds waiting for uploaded Gemini file to become ACTIVE.",
+    )
+    p.add_argument(
+        "--retry-base-sec",
+        type=float,
+        default=2.0,
+        help="Base seconds for exponential retry backoff.",
+    )
+    p.add_argument(
+        "--native-request-timeout-sec",
+        type=int,
+        default=120,
+        help="Per-request timeout (seconds) for native Gemini generate calls.",
+    )
+    p.add_argument(
+        "--openrouter-request-timeout-sec",
+        type=int,
+        default=120,
+        help="Per-request timeout (seconds) for OpenRouter API calls.",
+    )
+    p.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable debug logging.",
+    )
+    p.add_argument(
+        "--progress-interval-sec",
+        type=float,
+        default=10.0,
+        help="Seconds between heartbeat progress logs.",
+    )
+    return p.parse_args()
+
+
+def discover_videos(root: Path) -> List[Path]:
+    if not root.exists():
+        raise FileNotFoundError(f"Video directory not found: {root}")
+    vids: List[Path] = []
+    for p in root.rglob("*"):
+        if p.is_file() and p.suffix.lower() in VIDEO_EXTS:
+            vids.append(p)
+    vids.sort()
+    if not vids:
+        raise FileNotFoundError(f"No videos found under: {root}")
+    return vids
+
+
+def load_processed_set(results_jsonl: Path) -> Set[str]:
+    processed: Set[str] = set()
+    if not results_jsonl.exists():
+        return processed
+    with results_jsonl.open("r", encoding="utf-8") as f:
+        for line in f:
+            s = line.strip()
+            if not s:
+                continue
+            try:
+                obj = json.loads(s)
+            except json.JSONDecodeError:
+                continue
+            rel = str(obj.get("video_relpath", "")).strip()
+            name = str(obj.get("video_name", "")).strip()
+            if rel:
+                processed.add(rel)
+            elif name:
+                processed.add(name)
+    return processed
+
+
+def append_jsonl_threadsafe(path: Path, row: Dict[str, Any], lock: threading.Lock) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    encoded = json.dumps(row, ensure_ascii=False)
+    with lock:
+        with path.open("a", encoding="utf-8") as f:
+            f.write(encoded + "\n")
+
+
+def append_failure_threadsafe(path: Path, text: str, lock: threading.Lock) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with lock:
+        with path.open("a", encoding="utf-8") as f:
+            f.write(text + "\n")
+
+
+def extract_json_object(text: str) -> Dict[str, Any]:
+    text = (text or "").strip()
+    fence_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, flags=re.DOTALL)
+    if fence_match:
+        return json.loads(fence_match.group(1))
+    try:
+        obj = json.loads(text)
+        if isinstance(obj, dict):
+            return obj
+    except json.JSONDecodeError:
+        pass
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        obj = json.loads(text[start : end + 1])
+        if isinstance(obj, dict):
+            return obj
+    raise ValueError("No valid JSON object found in model output.")
+
+
+def coerce_visual(data: Dict[str, Any]) -> Tuple[float, str]:
+    if "t_visual" not in data:
+        raise ValueError(f"Missing t_visual in visual output: {data}")
+    ts = float(data["t_visual"])
+    if not np.isfinite(ts):
+        raise ValueError(f"t_visual is not finite: {ts}")
+    desc = str(data.get("event_description", "")).strip()
+    if not desc:
+        desc = "unspecified visual impact"
+    return ts, desc
+
+
+def coerce_audio(data: Dict[str, Any]) -> Tuple[float, str]:
+    if "t_audio" not in data:
+        raise ValueError(f"Missing t_audio in audio output: {data}")
+    ts = float(data["t_audio"])
+    if not np.isfinite(ts):
+        raise ValueError(f"t_audio is not finite: {ts}")
+    desc = str(data.get("sound_description", "")).strip()
+    if not desc:
+        desc = "unspecified impact sound"
+    return ts, desc
+
+
+def is_quota_error(exc: Exception) -> bool:
+    msg = str(exc).upper()
+    keys = [
+        "429",
+        "TOO MANY REQUESTS",
+        "RESOURCE_EXHAUSTED",
+        "RATE LIMIT",
+        "QUOTA",
+        "EXCEEDED",
+    ]
+    return any(k in msg for k in keys)
+
+
+def is_retryable_error(exc: Exception) -> bool:
+    msg = str(exc).upper()
+    transient = [
+        "500",
+        "502",
+        "503",
+        "504",
+        "UNAVAILABLE",
+        "TIMEOUT",
+        "CONNECTION",
+        "DEADLINE",
+    ]
+    return any(k in msg for k in transient)
+
+
+def wait_until_native_file_active(
+    client: genai.Client, file_name: str, timeout_sec: int, poll_sec: float = 2.0
+) -> None:
+    deadline = time.time() + timeout_sec
+    while time.time() < deadline:
+        meta = client.files.get(name=file_name)
+        state = getattr(getattr(meta, "state", None), "name", None) or str(getattr(meta, "state", ""))
+        state = str(state).upper()
+        if state == "ACTIVE":
+            return
+        if state in {"FAILED", "CANCELLED"}:
+            raise RuntimeError(f"Native Gemini file processing failed. state={state}, file={file_name}")
+        time.sleep(poll_sec)
+    raise TimeoutError(f"Timed out waiting for file ACTIVE: {file_name}")
+
+
+def _mime_from_suffix(path: Path) -> str:
+    ext = path.suffix.lower()
+    mapping = {
+        ".mp4": "video/mp4",
+        ".mov": "video/quicktime",
+        ".mkv": "video/x-matroska",
+        ".avi": "video/x-msvideo",
+        ".webm": "video/webm",
+        ".m4v": "video/x-m4v",
+    }
+    return mapping.get(ext, "video/mp4")
+
+
+def run_native_dual_pass(
+    video_path: Path,
+    api_key: str,
+    model: str,
+    file_ready_timeout_sec: int,
+    request_timeout_sec: int,
+) -> Tuple[float, str, float, str]:
+    # google-genai HttpOptions.timeout expects milliseconds.
+    timeout_ms = max(int(request_timeout_sec * 1000), 1000)
+    client = genai.Client(
+        api_key=api_key,
+        http_options=genai_types.HttpOptions(timeout=timeout_ms),
+    )
+    uploaded = client.files.upload(file=str(video_path))
+    uploaded_name = getattr(uploaded, "name", None)
+    uploaded_uri = getattr(uploaded, "uri", None)
+    mime_type = _mime_from_suffix(video_path)
+
+    if not uploaded_name:
+        raise RuntimeError("Native upload returned no file name.")
+    if not uploaded_uri:
+        raise RuntimeError("Native upload returned no file URI.")
+
+    try:
+        wait_until_native_file_active(client, uploaded_name, timeout_sec=file_ready_timeout_sec)
+
+        video_part = {"file_data": {"file_uri": uploaded_uri, "mime_type": mime_type}}
+
+        logging.info("PASS1_VISUAL start | %s", video_path.name)
+        resp_visual = client.models.generate_content(
+            model=model,
+            contents=[VISUAL_PROMPT, video_part],
+        )
+        logging.info("PASS1_VISUAL done  | %s", video_path.name)
+        raw_visual = (getattr(resp_visual, "text", "") or "").strip()
+        visual_obj = extract_json_object(raw_visual)
+        t_visual, event_desc = coerce_visual(visual_obj)
+
+        logging.info("PASS2_AUDIO start  | %s", video_path.name)
+        resp_audio = client.models.generate_content(
+            model=model,
+            contents=[AUDIO_PROMPT, video_part],
+        )
+        logging.info("PASS2_AUDIO done   | %s", video_path.name)
+        raw_audio = (getattr(resp_audio, "text", "") or "").strip()
+        audio_obj = extract_json_object(raw_audio)
+        t_audio, sound_desc = coerce_audio(audio_obj)
+        return t_visual, event_desc, t_audio, sound_desc
+    finally:
+        try:
+            client.files.delete(name=uploaded_name)
+        except Exception as exc:
+            logging.warning("Failed to delete uploaded native file %s: %s", uploaded_name, exc)
+
+
+def encode_video_data_url(video_path: Path) -> str:
+    mime = _mime_from_suffix(video_path)
+    raw = video_path.read_bytes()
+    b64 = base64.b64encode(raw).decode("utf-8")
+    return f"data:{mime};base64,{b64}"
+
+
+def run_openrouter_dual_pass(
+    video_path: Path,
+    api_key: str,
+    model: str,
+    base_url: str,
+    request_timeout_sec: int,
+) -> Tuple[float, str, float, str]:
+    client = OpenAI(
+        api_key=api_key,
+        base_url=base_url,
+        timeout=float(request_timeout_sec),
+    )
+    video_data_url = encode_video_data_url(video_path)
+
+    visual_content: List[Dict[str, Any]] = [
+        {"type": "input_text", "text": VISUAL_PROMPT},
+        {"type": "input_video", "video_url": video_data_url},
+    ]
+    logging.info("PASS1_VISUAL start | %s (openrouter)", video_path.name)
+    visual_resp = client.responses.create(
+        model=model,
+        input=[{"role": "user", "content": visual_content}],
+    )
+    logging.info("PASS1_VISUAL done  | %s (openrouter)", video_path.name)
+    visual_text = (getattr(visual_resp, "output_text", "") or "").strip()
+    visual_obj = extract_json_object(visual_text)
+    t_visual, event_desc = coerce_visual(visual_obj)
+
+    audio_content: List[Dict[str, Any]] = [
+        {"type": "input_text", "text": AUDIO_PROMPT},
+        {"type": "input_video", "video_url": video_data_url},
+    ]
+    logging.info("PASS2_AUDIO start  | %s (openrouter)", video_path.name)
+    audio_resp = client.responses.create(
+        model=model,
+        input=[{"role": "user", "content": audio_content}],
+    )
+    logging.info("PASS2_AUDIO done   | %s (openrouter)", video_path.name)
+    audio_text = (getattr(audio_resp, "output_text", "") or "").strip()
+    audio_obj = extract_json_object(audio_text)
+    t_audio, sound_desc = coerce_audio(audio_obj)
+    return t_visual, event_desc, t_audio, sound_desc
+
+
+def annotate_one_video(
+    video_path: Path,
+    video_relpath: str,
+    key_manager: NativeKeyManager,
+    args: argparse.Namespace,
+    openrouter_key: Optional[str],
+) -> AnnotationResult:
+    started = time.time()
+
+    # Native path with rotation.
+    native_attempt = 0
+    while native_attempt < args.max_retries_per_video:
+        native_active = key_manager.get_active()
+        if native_active is None:
+            break
+
+        label, key = native_active
+        try:
+            t_visual, event_desc, t_audio, sound_desc = run_native_dual_pass(
+                video_path=video_path,
+                api_key=key,
+                model=args.native_model,
+                file_ready_timeout_sec=args.file_ready_timeout_sec,
+                request_timeout_sec=args.native_request_timeout_sec,
+            )
+            return AnnotationResult(
+                video_relpath=video_relpath,
+                video_name=video_path.name,
+                video_path=str(video_path),
+                t_visual=t_visual,
+                t_audio=t_audio,
+                event_description=event_desc,
+                sound_description=sound_desc,
+                provider="native_gemini",
+                model=args.native_model,
+                native_key_label=label,
+                elapsed_sec=time.time() - started,
+                created_at=time.time(),
+            )
+        except Exception as exc:
+            if is_quota_error(exc):
+                all_exhausted = key_manager.mark_quota_and_rotate(label)
+                logging.warning(
+                    "Quota/rate hit on native key=%s for %s. exhausted_all=%s err=%s",
+                    label,
+                    video_relpath,
+                    all_exhausted,
+                    exc,
+                )
+                if all_exhausted:
+                    break
+                continue
+
+            native_attempt += 1
+            if native_attempt >= args.max_retries_per_video:
+                logging.error(
+                    "Native non-quota error exhausted retries for %s: %s",
+                    video_relpath,
+                    exc,
+                )
+                break
+            sleep_s = args.retry_base_sec * (2 ** (native_attempt - 1))
+            logging.warning(
+                "Native transient error for %s (attempt %d/%d). sleeping %.1fs. err=%s",
+                video_relpath,
+                native_attempt,
+                args.max_retries_per_video,
+                sleep_s,
+                exc,
+            )
+            time.sleep(sleep_s)
+
+    # Fallback path.
+    if not openrouter_key:
+        raise RuntimeError("Native keys unavailable/exhausted and OPENROUTER_API_KEY is missing.")
+
+    fallback_attempt = 0
+    while fallback_attempt < args.max_retries_per_video:
+        try:
+            t_visual, event_desc, t_audio, sound_desc = run_openrouter_dual_pass(
+                video_path=video_path,
+                api_key=openrouter_key,
+                model=args.openrouter_model,
+                base_url=args.openrouter_base_url,
+                request_timeout_sec=args.openrouter_request_timeout_sec,
+            )
+            return AnnotationResult(
+                video_relpath=video_relpath,
+                video_name=video_path.name,
+                video_path=str(video_path),
+                t_visual=t_visual,
+                t_audio=t_audio,
+                event_description=event_desc,
+                sound_description=sound_desc,
+                provider="openrouter",
+                model=args.openrouter_model,
+                native_key_label=None,
+                elapsed_sec=time.time() - started,
+                created_at=time.time(),
+            )
+        except Exception as exc:
+            fallback_attempt += 1
+            if fallback_attempt >= args.max_retries_per_video:
+                raise RuntimeError(f"OpenRouter fallback failed after retries: {exc}") from exc
+            sleep_s = args.retry_base_sec * (2 ** (fallback_attempt - 1))
+            logging.warning(
+                "OpenRouter error for %s (attempt %d/%d). sleeping %.1fs. err=%s",
+                video_relpath,
+                fallback_attempt,
+                args.max_retries_per_video,
+                sleep_s,
+                exc,
+            )
+            time.sleep(sleep_s)
+
+    raise RuntimeError("Unexpected annotation loop exit.")
+
+
+def main() -> None:
+    args = parse_args()
+    setup_logging(args.verbose)
+
+    # Read keys from environment.
+    native_keys = [
+        ("MINE", os.getenv("GEMINI_API_KEY_MINE", "").strip()),
+        ("A", os.getenv("GEMINI_API_KEY_A", "").strip()),
+        ("B", os.getenv("GEMINI_API_KEY_B", "").strip()),
+    ]
+    openrouter_key = os.getenv("OPENROUTER_API_KEY", "").strip() or None
+
+    key_manager = NativeKeyManager(native_keys)
+    snapshot = key_manager.status_snapshot()
+    logging.info("Native key pool initialized: %s", snapshot)
+    logging.info("OpenRouter fallback configured: %s", bool(openrouter_key))
+
+    all_videos = discover_videos(args.video_dir)
+    processed_set = load_processed_set(args.results_jsonl)
+
+    pending: List[Tuple[Path, str]] = []
+    for video in all_videos:
+        rel = str(video.relative_to(args.video_dir))
+        if rel in processed_set or video.name in processed_set:
+            continue
+        pending.append((video, rel))
+
+    logging.info("Total videos discovered: %d", len(all_videos))
+    logging.info("Already processed (checkpoint): %d", len(all_videos) - len(pending))
+    logging.info("Pending videos: %d", len(pending))
+    if not pending:
+        logging.info("Nothing to process. Exiting.")
+        return
+
+    jsonl_lock = threading.Lock()
+    fail_lock = threading.Lock()
+    counters_lock = threading.Lock()
+    counters = {"ok": 0, "failed": 0, "started": 0}
+    total_pending = len(pending)
+    progress_stop = threading.Event()
+    last_completion_ts = [time.time()]
+    last_progress_log_ts = [0.0]
+    last_snapshot = [(-1, -1, -1, -1)]
+
+    def progress_heartbeat() -> None:
+        while not progress_stop.wait(max(1.0, args.progress_interval_sec)):
+            with counters_lock:
+                ok = counters["ok"]
+                failed = counters["failed"]
+                started_n = counters["started"]
+            done = ok + failed
+            in_flight = max(0, started_n - done)
+            elapsed = max(time.time() - started_at, 1e-6)
+            rate = done / elapsed
+            remaining = max(0, total_pending - done)
+            eta_sec = (remaining / rate) if rate > 0 else None
+            eta_text = f"{eta_sec/60.0:.1f}m" if eta_sec is not None else "N/A"
+            now = time.time()
+            stagnant_sec = now - last_completion_ts[0]
+            snapshot = (done, ok, failed, in_flight)
+
+            # Avoid noisy repeated logs when nothing changes:
+            # - always log when progress state changes
+            # - otherwise log once per minute as heartbeat
+            should_log = False
+            if snapshot != last_snapshot[0]:
+                should_log = True
+            elif now - last_progress_log_ts[0] >= 60.0:
+                should_log = True
+
+            if should_log:
+                logging.info(
+                    "PROGRESS done=%d/%d ok=%d failed=%d in_flight=%d rate=%.3f vids/s eta=%s stagnant=%.0fs",
+                    done,
+                    total_pending,
+                    ok,
+                    failed,
+                    in_flight,
+                    rate,
+                    eta_text,
+                    stagnant_sec,
+                )
+                last_snapshot[0] = snapshot
+                last_progress_log_ts[0] = now
+
+    def worker(video_item: Tuple[int, Path, str]) -> Tuple[str, Optional[AnnotationResult], Optional[str]]:
+        idx, vpath, rel = video_item
+        with counters_lock:
+            counters["started"] += 1
+        logging.info("START [%d/%d] %s", idx, total_pending, rel)
+        try:
+            res = annotate_one_video(
+                video_path=vpath,
+                video_relpath=rel,
+                key_manager=key_manager,
+                args=args,
+                openrouter_key=openrouter_key,
+            )
+            return rel, res, None
+        except Exception as exc:
+            return rel, None, str(exc)
+
+    futures: List[Future] = []
+    started_at = time.time()
+    progress_thread = threading.Thread(
+        target=progress_heartbeat,
+        name="progress-heartbeat",
+        daemon=True,
+    )
+    progress_thread.start()
+    with ThreadPoolExecutor(max_workers=max(1, args.max_workers)) as ex:
+        for idx, item in enumerate(pending, start=1):
+            vpath, rel = item
+            payload = (idx, vpath, rel)
+            futures.append(ex.submit(worker, payload))
+
+        for fut in as_completed(futures):
+            rel, res, err = fut.result()
+            if res is not None:
+                append_jsonl_threadsafe(args.results_jsonl, res.to_dict(), jsonl_lock)
+                with counters_lock:
+                    counters["ok"] += 1
+                    done = counters["ok"] + counters["failed"]
+                    last_completion_ts[0] = time.time()
+                logging.info(
+                    "DONE [%d/%d] %s | provider=%s | t_visual=%.3f | t_audio=%.3f",
+                    done,
+                    len(pending),
+                    rel,
+                    res.provider,
+                    res.t_visual,
+                    res.t_audio,
+                )
+            else:
+                fail_line = f"{time.time():.0f}\t{rel}\t{err}"
+                append_failure_threadsafe(args.failed_log, fail_line, fail_lock)
+                with counters_lock:
+                    counters["failed"] += 1
+                    done = counters["ok"] + counters["failed"]
+                    last_completion_ts[0] = time.time()
+                logging.error("FAIL [%d/%d] %s | %s", done, len(pending), rel, err)
+
+    progress_stop.set()
+    progress_thread.join(timeout=1.0)
+
+    elapsed = time.time() - started_at
+    logging.info("=========== RUN SUMMARY ===========")
+    logging.info("Processed success: %d", counters["ok"])
+    logging.info("Processed failed : %d", counters["failed"])
+    logging.info("Elapsed seconds  : %.1f", elapsed)
+    logging.info("Results JSONL    : %s", args.results_jsonl.resolve())
+    logging.info("Failed log       : %s", args.failed_log.resolve())
+    logging.info("===================================")
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/data_gen/generate_activitynet_chosen.py b/data_gen/generate_activitynet_chosen.py
new file mode 100644
index 0000000000000000000000000000000000000000..05b1805a846f911069402e40276114e19571b38b
--- /dev/null
+++ b/data_gen/generate_activitynet_chosen.py
@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Generate chosen responses for ActivityNet DPO data using GPT-5.4.
+Usage:
+    export OPENAI_API_KEY="sk-..."
+    python generate_activitynet_chosen.py
+"""
+
+import json
+import os
+import sys
+import base64
+import time
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import av
+import numpy as np
+from openai import OpenAI
+
+# === Config ===
+VIDEO_DIR = "/opt/dlami/nvme/sharegpt_activitynet_raw/activitynet/videos"
+DPO_SOURCE = "/opt/dlami/nvme/sharegpt_instructions/video_instruction/train/dpo/sft_dpo_17k.jsonl"
+OUTPUT_FILE = "/opt/dlami/nvme/activitynet_gpt_chosen.jsonl"
+NUM_FRAMES = 10
+MAX_WORKERS = 8  # parallel API calls
+MODEL = "gpt-5.4-2026-03-05"
+
+client = OpenAI()
+
+
+def extract_frames(video_path: str, num_frames: int = 10) -> list[bytes]:
+    """Extract evenly-spaced frames from video, return as JPEG bytes."""
+    container = av.open(video_path)
+    stream = next(s for s in container.streams if s.type == "video")
+    total_frames = stream.frames
+    if total_frames == 0:
+        total_frames = 300  # fallback
+
+    indices = np.linspace(0, total_frames - 1, num_frames).astype(int)
+    frames = []
+    for i, frame in enumerate(container.decode(stream)):
+        if i in indices:
+            img = frame.to_image()
+            import io
+            buf = io.BytesIO()
+            img.save(buf, format="JPEG", quality=85)
+            frames.append(buf.getvalue())
+        if len(frames) >= num_frames:
+            break
+
+    container.close()
+    return frames
+
+
+def generate_chosen(video_id: str, prompt: str) -> dict:
+    """Call GPT-5.4 with video frames + question, return chosen response."""
+    video_path = os.path.join(VIDEO_DIR, f"{video_id}.mp4")
+    if not os.path.exists(video_path):
+        return {"video": video_id, "error": f"video not found: {video_path}"}
+
+    try:
+        frames = extract_frames(video_path, NUM_FRAMES)
+    except Exception as e:
+        return {"video": video_id, "error": f"frame extraction failed: {e}"}
+
+    image_messages = []
+    for i, frame_bytes in enumerate(frames):
+        b64 = base64.b64encode(frame_bytes).decode("utf-8")
+        image_messages.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}", "detail": "low"}
+        })
+
+    system_prompt = (
+        "You are watching a video. The following images are evenly-spaced frames extracted from the video. "
+        "Answer the question based on what you observe in these frames. "
+        "Be specific, accurate, and detailed. Describe visual details you actually see. "
+        "Do not hallucinate or guess about things not visible in the frames."
+    )
+
+    user_content = [
+        {"type": "text", "text": f"These are {len(frames)} frames from a video:"},
+        *image_messages,
+        {"type": "text", "text": f"\nQuestion: {prompt}\n\nPlease provide a detailed and accurate answer."},
+    ]
+
+    for attempt in range(3):
+        try:
+            response = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_content},
+                ],
+                max_completion_tokens=512,
+                temperature=0.3,
+            )
+            answer = response.choices[0].message.content.strip()
+            return {
+                "video": video_id,
+                "prompt": prompt,
+                "chosen_gpt": answer,
+                "tokens_used": response.usage.total_tokens if response.usage else 0,
+            }
+        except Exception as e:
+            if attempt < 2:
+                time.sleep(2 ** (attempt + 1))
+            else:
+                return {"video": video_id, "error": f"API failed after 3 retries: {e}"}
+
+
+def main():
+    # Load ActivityNet DPO entries
+    activitynet = []
+    with open(DPO_SOURCE) as f:
+        for line in f:
+            d = json.loads(line)
+            if d.get("video", "").startswith("v_"):
+                activitynet.append(d)
+
+    print(f"ActivityNet DPO entries: {len(activitynet)}")
+
+    # Resume from existing output
+    done_ids = set()
+    if os.path.exists(OUTPUT_FILE):
+        with open(OUTPUT_FILE) as f:
+            for line in f:
+                d = json.loads(line)
+                done_ids.add(f"{d['video']}_{d.get('prompt', '')[:50]}")
+        print(f"Resuming: {len(done_ids)} already done")
+
+    todo = []
+    for d in activitynet:
+        key = f"{d['video']}_{d['prompt'][:50]}"
+        if key not in done_ids:
+            todo.append(d)
+
+    print(f"To process: {len(todo)}")
+    if not todo:
+        print("All done!")
+        return
+
+    # Process with thread pool
+    total_tokens = 0
+    success = 0
+    errors = 0
+
+    with open(OUTPUT_FILE, "a") as out_f:
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            futures = {
+                executor.submit(generate_chosen, d["video"], d["prompt"]): d
+                for d in todo
+            }
+
+            for i, future in enumerate(as_completed(futures), 1):
+                result = future.result()
+
+                if "error" in result:
+                    errors += 1
+                    print(f"  [{i}/{len(todo)}] ERROR {result['video']}: {result['error']}")
+                else:
+                    success += 1
+                    total_tokens += result.get("tokens_used", 0)
+                    out_f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                    out_f.flush()
+
+                if i % 100 == 0:
+                    print(f"  [{i}/{len(todo)}] success={success}, errors={errors}, tokens={total_tokens:,}")
+
+    print(f"\nDone! success={success}, errors={errors}, total_tokens={total_tokens:,}")
+    print(f"Output: {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/generate_activitynet_rejected.py b/data_gen/generate_activitynet_rejected.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e61d719c15792a7ef2c849cabd95bf902b279a6
--- /dev/null
+++ b/data_gen/generate_activitynet_rejected.py
@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+"""
+Generate rejected responses for ActivityNet DPO using the SFT base model.
+8-GPU parallel inference for maximum speed.
+
+Usage:
+    # Stage 1: Generate rejected (8 GPU parallel)
+    python generate_activitynet_rejected.py --stage 1
+
+    # Stage 2: Assemble final DPO json
+    python generate_activitynet_rejected.py --stage 2
+
+    # Both
+    python generate_activitynet_rejected.py --stage all
+"""
+
+import argparse
+import json
+import os
+import logging
+import multiprocessing as mp
+from pathlib import Path
+
+import torch
+from tqdm import tqdm
+
+LOG = logging.getLogger("activitynet_rejected")
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(process)d] %(message)s")
+
+VIDEO_DIR = "/opt/dlami/nvme/sharegpt_activitynet_raw/activitynet/videos"
+AUDIO_DIR = "/opt/dlami/nvme/sharegpt_activitynet_audio"
+GPT_CHOSEN_FILE = "/opt/dlami/nvme/activitynet_gpt_chosen.jsonl"
+RAW_REJECTED_DIR = "/opt/dlami/nvme/activitynet_rejected_shards"
+FINAL_OUTPUT = "/home/ubuntu/LlamaFactory/data/dpo_activitynet_gpt_chosen.json"
+
+SFT_MODEL_PATH = "Rakancorle11/qwen3omni_full_sft_revised_thinker_key"
+VANILLA_MODEL_PATH = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+NUM_GPUS = len(os.environ.get("CUDA_VISIBLE_DEVICES", "0,1,2,3,4,5,6,7").split(","))
+
+
+def worker_fn(gpu_id: int, shard: list[dict], model_path: str, output_dir: str, model_type: str):
+    """Each worker loads model on one GPU and processes its shard."""
+    visible_gpus = os.environ.get("CUDA_VISIBLE_DEVICES", "0,1,2,3,4,5,6,7").split(",")
+    os.environ["CUDA_VISIBLE_DEVICES"] = visible_gpus[gpu_id]
+
+    from transformers import AutoConfig, AutoProcessor, Qwen3OmniMoeForConditionalGeneration
+    from qwen_omni_utils import process_mm_info
+
+    LOG.info("GPU %d: loading model %s (type=%s), shard size=%d", gpu_id, model_path, model_type, len(shard))
+    processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
+
+    config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
+    detected_type = getattr(config, "model_type", "")
+
+    if detected_type == "qwen3_omni_moe_thinker":
+        from transformers import Qwen3OmniMoeThinkerConfig, Qwen3OmniMoeThinkerForConditionalGeneration
+        thinker_config = Qwen3OmniMoeThinkerConfig.from_pretrained(model_path)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            model_path, config=thinker_config, torch_dtype=torch.bfloat16,
+            device_map="auto", attn_implementation="sdpa",
+        )
+        is_thinker = True
+    else:
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            model_path, config=config, torch_dtype=torch.bfloat16,
+            device_map="auto", attn_implementation="sdpa",
+        )
+        if hasattr(model, "disable_talker"):
+            model.disable_talker()
+        is_thinker = False
+    model.eval()
+
+    output_file = os.path.join(output_dir, f"shard_{gpu_id}.jsonl")
+
+    # Resume support
+    done_keys = set()
+    if os.path.exists(output_file):
+        with open(output_file) as f:
+            for line in f:
+                d = json.loads(line)
+                done_keys.add(f"{d['video']}_{d['prompt'][:50]}")
+        LOG.info("GPU %d: resuming, %d already done", gpu_id, len(done_keys))
+
+    todo = [d for d in shard if f"{d['video']}_{d['prompt'][:50]}" not in done_keys]
+    LOG.info("GPU %d: %d to process", gpu_id, len(todo))
+
+    with open(output_file, "a") as out_f:
+        for i, d in enumerate(todo):
+            video_path = os.path.join(VIDEO_DIR, f"{d['video']}.mp4")
+            audio_path = os.path.join(AUDIO_DIR, f"{d['video']}.wav")
+
+            if not os.path.exists(video_path):
+                continue
+
+            try:
+                messages = [
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "video", "video": video_path},
+                            *(
+                                [{"type": "audio", "audio": audio_path}]
+                                if os.path.exists(audio_path)
+                                else []
+                            ),
+                            {"type": "text", "text": d["prompt"]},
+                        ],
+                    },
+                ]
+
+                text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+                audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+                inputs = processor(
+                    text=[text], audio=audios, images=images, videos=videos,
+                    return_tensors="pt", padding=True,
+                )
+
+                model_dtype = next(model.parameters()).dtype
+                for k, v in list(inputs.items()):
+                    if hasattr(v, "to"):
+                        v = v.to(model.device)
+                        if torch.is_floating_point(v):
+                            v = v.to(model_dtype)
+                        inputs[k] = v
+
+                is_thinker_model = is_thinker
+                with torch.no_grad():
+                    if is_thinker_model:
+                        gen_kwargs = {
+                            "max_new_tokens": 512,
+                            "do_sample": True,
+                            "temperature": 0.7,
+                            "top_p": 0.9,
+                        }
+                    else:
+                        gen_kwargs = {
+                            "thinker_max_new_tokens": 512,
+                            "return_audio": False,
+                            "use_audio_in_video": False,
+                            "do_sample": True,
+                            "temperature": 0.7,
+                            "top_p": 0.9,
+                        }
+                    output_ids = model.generate(**inputs, **gen_kwargs)
+
+                if isinstance(output_ids, tuple):
+                    output_ids = output_ids[0]
+
+                input_len = inputs["input_ids"].shape[-1]
+                response = processor.decode(output_ids[0][input_len:], skip_special_tokens=True).strip()
+
+                result = {
+                    "video": d["video"],
+                    "prompt": d["prompt"],
+                    "rejected_base": response,
+                }
+                out_f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                out_f.flush()
+
+            except Exception as e:
+                LOG.error("GPU %d: failed %s: %s", gpu_id, d["video"], e)
+                continue
+
+            if (i + 1) % 50 == 0:
+                LOG.info("GPU %d: %d/%d done", gpu_id, i + 1, len(todo))
+
+    LOG.info("GPU %d: finished", gpu_id)
+
+
+def stage1_generate_rejected(model_type: str):
+    """Split data across 8 GPUs and run in parallel."""
+    if model_type == "sft":
+        model_path = SFT_MODEL_PATH
+        output_dir = RAW_REJECTED_DIR + "_sft"
+    else:
+        model_path = VANILLA_MODEL_PATH
+        output_dir = RAW_REJECTED_DIR + "_vanilla"
+
+    os.makedirs(output_dir, exist_ok=True)
+
+    gpt_data = []
+    with open(GPT_CHOSEN_FILE) as f:
+        for line in f:
+            d = json.loads(line)
+            if "error" not in d:
+                gpt_data.append(d)
+
+    LOG.info("[%s] Total entries: %d, splitting across %d GPUs", model_type, len(gpt_data), NUM_GPUS)
+
+    # Split into shards
+    shards = [[] for _ in range(NUM_GPUS)]
+    for i, d in enumerate(gpt_data):
+        shards[i % NUM_GPUS].append(d)
+
+    for i, s in enumerate(shards):
+        LOG.info("  GPU %d: %d entries", i, len(s))
+
+    # Launch workers
+    processes = []
+    mp.set_start_method("spawn", force=True)
+    for gpu_id in range(NUM_GPUS):
+        p = mp.Process(target=worker_fn, args=(gpu_id, shards[gpu_id], model_path, output_dir, model_type))
+        p.start()
+        processes.append(p)
+
+    for p in processes:
+        p.join()
+
+    LOG.info("All workers finished")
+
+
+def stage2_assemble(model_type: str):
+    """Merge shard outputs + GPT chosen into final DPO data."""
+    if model_type == "sft":
+        rejected_dir = RAW_REJECTED_DIR + "_sft"
+        output_file = FINAL_OUTPUT.replace(".json", "_sft.json")
+        dataset_name = "dpo_activitynet_gpt_chosen_sft"
+    else:
+        rejected_dir = RAW_REJECTED_DIR + "_vanilla"
+        output_file = FINAL_OUTPUT.replace(".json", "_vanilla.json")
+        dataset_name = "dpo_activitynet_gpt_chosen_vanilla"
+    # Load GPT chosen
+    gpt_map = {}
+    with open(GPT_CHOSEN_FILE) as f:
+        for line in f:
+            d = json.loads(line)
+            if "error" not in d:
+                key = f"{d['video']}_{d['prompt']}"
+                gpt_map[key] = d["chosen_gpt"]
+
+    # Load all rejected shards
+    rej_map = {}
+    for shard_file in sorted(Path(rejected_dir).glob("shard_*.jsonl")):
+        with open(shard_file) as f:
+            for line in f:
+                d = json.loads(line)
+                key = f"{d['video']}_{d['prompt']}"
+                rej_map[key] = d["rejected_base"]
+
+    overlap_keys = set(gpt_map) & set(rej_map)
+    LOG.info("GPT chosen: %d, Base rejected: %d, Overlap: %d", len(gpt_map), len(rej_map), len(overlap_keys))
+
+    results = []
+    skipped_similar = 0
+
+    for key in overlap_keys:
+        chosen = gpt_map[key]
+        rejected = rej_map[key]
+
+        c_words = set(chosen.lower().split())
+        r_words = set(rejected.lower().split())
+        word_overlap = len(c_words & r_words) / len(c_words | r_words) if c_words | r_words else 0
+        if word_overlap > 0.7:
+            skipped_similar += 1
+            continue
+
+        # Find video_id and prompt from key
+        # key format: "v_xxxxx-Scene-NNN_prompt text"
+        # Find the original entry to get clean video_id and prompt
+        pass
+
+    # Simpler: iterate GPT chosen file
+    results = []
+    skipped_similar = 0
+    skipped_no_rejected = 0
+
+    with open(GPT_CHOSEN_FILE) as f:
+        for line in f:
+            d = json.loads(line)
+            if "error" in d:
+                continue
+
+            key = f"{d['video']}_{d['prompt']}"
+            if key not in rej_map:
+                skipped_no_rejected += 1
+                continue
+
+            chosen = d["chosen_gpt"]
+            rejected = rej_map[key]
+
+            c_words = set(chosen.lower().split())
+            r_words = set(rejected.lower().split())
+            word_overlap = len(c_words & r_words) / len(c_words | r_words) if c_words | r_words else 0
+            if word_overlap > 0.7:
+                skipped_similar += 1
+                continue
+
+            video_path = os.path.join(VIDEO_DIR, f"{d['video']}.mp4")
+            audio_path = os.path.join(AUDIO_DIR, f"{d['video']}.wav")
+
+            results.append({
+                "messages": [{"role": "user", "content": f"<video><audio>{d['prompt']}"}],
+                "chosen": {"role": "assistant", "content": chosen},
+                "rejected": {"role": "assistant", "content": rejected},
+                "videos": [video_path],
+                "audios": [audio_path] if os.path.exists(audio_path) else [],
+            })
+
+    with open(output_file, "w") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False)
+
+    LOG.info("Final DPO data: %d entries -> %s", len(results), output_file)
+    LOG.info("Skipped (too similar): %d", skipped_similar)
+    LOG.info("Skipped (no rejected): %d", skipped_no_rejected)
+
+    # Register in dataset_info.json
+    info_path = "/home/ubuntu/LlamaFactory/data/dataset_info.json"
+    info = json.load(open(info_path))
+    info[dataset_name] = {
+        "file_name": os.path.basename(output_file),
+        "formatting": "sharegpt",
+        "ranking": True,
+        "columns": {
+            "messages": "messages",
+            "chosen": "chosen",
+            "rejected": "rejected",
+            "videos": "videos",
+            "audios": "audios"
+        },
+        "tags": {
+            "role_tag": "role",
+            "content_tag": "content",
+            "user_tag": "user",
+            "assistant_tag": "assistant"
+        }
+    }
+    with open(info_path, "w") as f:
+        json.dump(info, f, indent=2, ensure_ascii=False)
+    LOG.info("Registered %s in dataset_info.json", dataset_name)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--stage", choices=["1", "2", "all"], default="all")
+    parser.add_argument("--model", choices=["sft", "vanilla", "both"], default="both",
+                        help="Which model to use for rejected generation")
+    args = parser.parse_args()
+
+    models = ["sft", "vanilla"] if args.model == "both" else [args.model]
+
+    for model_type in models:
+        LOG.info("===== Processing with %s model =====", model_type)
+        if args.stage in ("1", "all"):
+            stage1_generate_rejected(model_type)
+        if args.stage in ("2", "all"):
+            stage2_assemble(model_type)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/generate_onpolicy_dpo.py b/data_gen/generate_onpolicy_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..eeff1f0dad37fffd3bdf372d5d4668574ff18f4c
--- /dev/null
+++ b/data_gen/generate_onpolicy_dpo.py
@@ -0,0 +1,478 @@
+#!/usr/bin/env python3
+"""
+On-policy DPO data augmentation pipeline.
+
+Three stages:
+  Stage 1: Load SFT-trained Qwen3-Omni, run inference on training videos
+           to collect model responses. Output: raw_responses.jsonl
+  Stage 2: Use GPT-5.4 as judge to evaluate each model response against
+           ground truth label (synced / delay Xs / early Xs).
+           Output: judged_responses.jsonl
+  Stage 3: Filter wrong responses as rejected, pair with ground truth chosen,
+           merge with existing DPO data. Output: dpo_video_train_onpolicy.json
+
+Usage:
+  python generate_onpolicy_dpo.py --stage 1  # run inference (GPU needed)
+  python generate_onpolicy_dpo.py --stage 2  # run LLM judge (OPENAI_API_KEY needed)
+  python generate_onpolicy_dpo.py --stage 3  # filter & merge
+  python generate_onpolicy_dpo.py --stage all # run all stages
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import logging
+import os
+import re
+import time
+from pathlib import Path
+
+import torch
+from tqdm import tqdm
+
+LOG = logging.getLogger("onpolicy_dpo")
+
+# ── Paths ──
+DATA_ROOT = Path("/home/ubuntu/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+INPUT_JSONL = DATA_ROOT / "kto_training_data_v2_train.jsonl"
+EXISTING_DPO = Path("/home/ubuntu/LlamaFactory/data/dpo_video_train_with_audio.json")
+RAW_RESPONSES = DATA_ROOT / "onpolicy_raw_responses.jsonl"
+JUDGED_RESPONSES = DATA_ROOT / "onpolicy_judged_responses.jsonl"
+OUTPUT_DPO = Path("/home/ubuntu/LlamaFactory/data/dpo_video_train_onpolicy.json")
+EXTRACTED_AUDIO_ROOT = DATA_ROOT / "extracted_audio"
+
+# Use the checkpoint that is known to include the correct audio-capable model.
+SFT_MODEL_PATH = "/opt/dlami/nvme/LlamaFactory/saves/Qwen3-Omni-Instruct/full/qwen3omni_full_sft_with_audio"
+
+
+def resolve_video_path(video_field: str) -> str:
+    """Resolve relative video paths to absolute paths."""
+    if os.path.isabs(video_field):
+        return video_field
+    return str(ORIGINAL_ROOT / video_field)
+
+
+def get_audio_path(video_path: str) -> str:
+    """Derive extracted .wav path from a video path."""
+    rel = os.path.relpath(video_path, str(DATA_ROOT))
+    audio_rel = os.path.splitext(rel)[0] + ".wav"
+    return str(EXTRACTED_AUDIO_ROOT / audio_rel)
+
+
+def parse_ground_truth_label(video_path: str) -> dict:
+    """Extract sync label from video file path."""
+    if "/original/" in video_path:
+        return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+    m = re.search(r"_(delay|early)_([\d.]+)s\.", video_path)
+    if m:
+        return {"is_synced": False, "direction": m.group(1), "offset_sec": float(m.group(2))}
+    return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+
+
+def read_input_data() -> list[dict]:
+    """Read kto_training_data_v2_train.jsonl, resolve paths."""
+    data = []
+    with open(INPUT_JSONL) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            obj["video"] = resolve_video_path(obj["video"])
+            data.append(obj)
+    return data
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 1: Inference
+# ═══════════════════════════════════════════════════════════════
+
+def load_sft_model():
+    import json as _json
+
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    LOG.info("Loading processor from %s", SFT_MODEL_PATH)
+    processor = AutoProcessor.from_pretrained(SFT_MODEL_PATH)
+
+    LOG.info("Loading model from %s", SFT_MODEL_PATH)
+    cfg_path = Path(SFT_MODEL_PATH) / "config.json"
+    with open(cfg_path, "r") as f:
+        cfg_dict = _json.load(f)
+    model_type = cfg_dict.get("model_type")
+
+    # `qwen3omni_full_sft_with_audio` uses `model_type=qwen3_omni_moe_thinker`,
+    # which AutoConfig can't always map in older Transformers.
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(SFT_MODEL_PATH)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            SFT_MODEL_PATH,
+            config=config,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(SFT_MODEL_PATH)
+        # Do not override `enable_audio_output` here.
+        # Forcing it changes internal module prefixes and may cause weights
+        # to not load correctly (leading to garbage text).
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            SFT_MODEL_PATH,
+            config=config,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+    model.eval()
+    return model, processor
+
+
+def run_inference_single(model, processor, video_path: str, audio_path: str,
+                         question: str, temperature: float, max_new_tokens: int) -> str:
+    from qwen_omni_utils import process_mm_info
+
+    from llamafactory.data.mm_plugin import get_mm_plugin
+
+    plugin = get_mm_plugin(
+        "qwen2_omni",
+        image_token="<|image_pad|>",
+        video_token="<|video_pad|>",
+        audio_token="<|audio_pad|>",
+    )
+    messages_mm = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": video_path},
+                {"type": "audio", "audio": audio_path},
+                {"type": "text", "text": question},
+            ],
+        },
+    ]
+    messages_for_template = plugin.process_messages(
+        [{"role": "user", "content": f"<video><audio>\n{question}"}],
+        images=[],
+        videos=[video_path],
+        audios=[audio_path],
+        processor=processor,
+    )
+    text = processor.apply_chat_template(
+        messages_for_template, tokenize=False, add_generation_prompt=True
+    )
+    audios, images, videos = process_mm_info(messages_mm, use_audio_in_video=False)
+    inputs = processor(
+        text=[text], audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True,
+    )
+    # Model is loaded in bfloat16; processor typically returns float32 for
+    # image/video/audio features. Cast floating inputs to match model dtype.
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+
+    if isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration):
+        gen_kwargs = {
+            "max_new_tokens": max_new_tokens,
+            "do_sample": temperature > 0,
+        }
+        if temperature > 0:
+            gen_kwargs["temperature"] = temperature
+            gen_kwargs["top_p"] = 0.9
+    else:
+        gen_kwargs = {
+            "thinker_max_new_tokens": max_new_tokens,
+            "use_audio_in_video": False,
+            "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)
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(output_ids[:, prompt_len:], skip_special_tokens=True)[0].strip()
+    return response
+
+
+def stage1_inference(args):
+    LOG.info("=== Stage 1: Inference ===")
+
+    data = read_input_data()
+    LOG.info("Loaded %d samples from %s", len(data), INPUT_JSONL)
+
+    processed = set()
+    processed_count = 0
+    if RAW_RESPONSES.exists():
+        with open(RAW_RESPONSES) as f:
+            for line in f:
+                obj = json.loads(line)
+                # Only treat a video as processed when we actually generated at least one response.
+                if obj.get("responses"):
+                    ok = any((isinstance(r, dict) and r.get("response")) for r in obj.get("responses", []))
+                    if ok:
+                        processed.add(obj["video"])
+        LOG.info("Resuming: %d already processed", len(processed))
+
+    model, processor = load_sft_model()
+
+    for item in tqdm(data, desc="Inference"):
+        video_path = item["video"]
+        if video_path in processed:
+            continue
+
+        audio_path = get_audio_path(video_path)
+        if not os.path.exists(audio_path):
+            LOG.warning("Audio not found: %s, skipping", audio_path)
+            continue
+
+        question = item["prompt"]
+        ground_truth = item["chosen"]
+        label = parse_ground_truth_label(video_path)
+
+        responses = []
+        for temp in args.temperatures:
+            try:
+                resp = run_inference_single(
+                    model, processor, video_path, audio_path,
+                    question, temperature=temp, max_new_tokens=args.max_new_tokens,
+                )
+                responses.append({"temperature": temp, "response": resp})
+            except Exception as e:
+                LOG.warning("Failed on %s (temp=%.1f): %s", video_path, temp, e)
+
+            gc.collect()
+            torch.cuda.empty_cache()
+
+        out = {
+            "video": video_path,
+            "audio": audio_path,
+            "question": question,
+            "ground_truth": ground_truth,
+            "label": label,
+            "responses": responses,
+        }
+        with open(RAW_RESPONSES, "a") as f:
+            f.write(json.dumps(out, ensure_ascii=False) + "\n")
+        if responses:
+            processed.add(video_path)
+            processed_count += 1
+            if args.max_samples > 0 and processed_count >= args.max_samples:
+                break
+
+    LOG.info("Stage 1 done. Wrote %s", RAW_RESPONSES)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 2: LLM Judge (GPT-5.4)
+# ═══════════════════════════════════════════════════════════════
+
+OFFSET_TOL_SEC = 1.0
+
+JUDGE_PROMPT = """\
+You are evaluating a model's response about audio-video synchronization.
+
+## Ground truth about this video:
+- Synchronized: {is_synced}
+- If not synchronized — direction: {direction}, offset: {offset_sec}s
+
+## Model's response:
+\"\"\"{response}\"\"\"
+
+## Task:
+Determine if the model's response is CORRECT or INCORRECT.
+
+A response is CORRECT if:
+1. For synced videos: model says it's synchronized/aligned (minor tolerance claims are OK)
+2. For not-synced videos: model says it's NOT synchronized AND gets the direction right (delay vs early).
+   Additionally, if the model mentions/estimates the audio-video gap (numeric or clearly implied), it should be within ±{offset_tol_sec}s of the true offset.
+
+A response is INCORRECT if:
+1. For synced videos: model says it's not synchronized or claims a significant gap
+2. For not-synced videos: model says it's synchronized, or gets the direction wrong
+   OR (if the model provides a gap estimate) the absolute gap error is > {offset_tol_sec}s.
+
+Output ONLY a JSON object, no markdown fences:
+{{"correct": true or false, "reason": "brief explanation"}}"""
+
+
+def judge_with_openai(response: str, label: dict, client) -> dict:
+    prompt = JUDGE_PROMPT.format(
+        is_synced=label["is_synced"],
+        direction=label.get("direction") or "N/A",
+        offset_sec=label.get("offset_sec", 0),
+        offset_tol_sec=OFFSET_TOL_SEC,
+        response=response,
+    )
+
+    result = client.chat.completions.create(
+        model="gpt-5.4",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0,
+        max_tokens=200,
+    )
+
+    text = result.choices[0].message.content.strip()
+    text = re.sub(r"^```json\s*", "", text)
+    text = re.sub(r"\s*```$", "", text)
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        LOG.warning("Failed to parse judge output: %s", text)
+        return {"correct": None, "reason": text}
+
+
+def stage2_judge(args):
+    LOG.info("=== Stage 2: LLM Judge (GPT-5.4) ===")
+
+    from openai import OpenAI
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Set OPENAI_API_KEY environment variable")
+    client = OpenAI(api_key=api_key)
+
+    raw_data = []
+    with open(RAW_RESPONSES) as f:
+        for line in f:
+            raw_data.append(json.loads(line))
+    LOG.info("Loaded %d raw response records", len(raw_data))
+
+    already_judged = set()
+    if JUDGED_RESPONSES.exists():
+        with open(JUDGED_RESPONSES) as f:
+            for line in f:
+                obj = json.loads(line)
+                already_judged.add((obj["video"], obj["response"][:80]))
+        LOG.info("Resuming: %d already judged", len(already_judged))
+
+    for record in tqdm(raw_data, desc="Judging"):
+        label = record["label"]
+        for resp_obj in record["responses"]:
+            resp_text = resp_obj["response"]
+            key = (record["video"], resp_text[:80])
+            if key in already_judged:
+                continue
+
+            try:
+                verdict = judge_with_openai(resp_text, label, client)
+            except Exception as e:
+                LOG.warning("Judge failed for %s: %s", record["video"], e)
+                time.sleep(2)
+                continue
+
+            out = {
+                "video": record["video"],
+                "audio": record["audio"],
+                "question": record["question"],
+                "ground_truth": record["ground_truth"],
+                "label": label,
+                "response": resp_text,
+                "temperature": resp_obj["temperature"],
+                "judge": verdict,
+            }
+            with open(JUDGED_RESPONSES, "a") as f:
+                f.write(json.dumps(out, ensure_ascii=False) + "\n")
+            already_judged.add(key)
+
+            time.sleep(0.05)
+
+    LOG.info("Stage 2 done. Wrote %s", JUDGED_RESPONSES)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 3: Filter & Merge
+# ═══════════════════════════════════════════════════════════════
+
+def stage3_merge(args):
+    LOG.info("=== Stage 3: Filter & Merge ===")
+
+    judged = []
+    with open(JUDGED_RESPONSES) as f:
+        for line in f:
+            judged.append(json.loads(line))
+    LOG.info("Loaded %d judged records", len(judged))
+
+    new_pairs = []
+    seen = set()
+    for record in judged:
+        verdict = record.get("judge", {})
+        if verdict.get("correct") is not False:
+            continue
+
+        dedup_key = (record["video"], record["response"][:80])
+        if dedup_key in seen:
+            continue
+        seen.add(dedup_key)
+
+        pair = {
+            "messages": [
+                {"role": "user", "content": "<video><audio>" + record["question"]}
+            ],
+            "chosen": {"role": "assistant", "content": record["ground_truth"]},
+            "rejected": {"role": "assistant", "content": record["response"]},
+            "videos": [record["video"]],
+            "audios": [record["audio"]],
+        }
+        new_pairs.append(pair)
+
+    LOG.info("New on-policy DPO pairs: %d (from %d judged)", len(new_pairs), len(judged))
+
+    with open(EXISTING_DPO) as f:
+        existing = json.load(f)
+    LOG.info("Existing DPO pairs: %d", len(existing))
+
+    merged = existing + new_pairs
+    LOG.info("Merged total: %d pairs", len(merged))
+
+    with open(OUTPUT_DPO, "w") as f:
+        json.dump(merged, f, indent=2, ensure_ascii=False)
+    LOG.info("Wrote %s", OUTPUT_DPO)
+
+
+# ═══════════════════════════════════════════════════════════════
+
+def main():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
+
+    parser = argparse.ArgumentParser(description="On-policy DPO data augmentation")
+    parser.add_argument("--stage", type=str, default="all", choices=["1", "2", "3", "all"])
+    parser.add_argument("--temperatures", type=float, nargs="+", default=[0.0, 0.7, 1.0],
+                        help="Sampling temperatures for stage 1. Multiple = more responses per video.")
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument(
+        "--max-samples",
+        type=int,
+        default=-1,
+        help="Stage 1 only: max number of videos to process (-1 means all).",
+    )
+    args = parser.parse_args()
+
+    if args.stage in ("1", "all"):
+        stage1_inference(args)
+    if args.stage in ("2", "all"):
+        stage2_judge(args)
+    if args.stage in ("3", "all"):
+        stage3_merge(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/multi_model_frame_selection_compare.py b/data_gen/multi_model_frame_selection_compare.py
new file mode 100644
index 0000000000000000000000000000000000000000..0cad9f7a6af16def4c30385db2bac9a9268ded93
--- /dev/null
+++ b/data_gen/multi_model_frame_selection_compare.py
@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""
+Fair multi-model visual grounding by single-stage frame selection.
+
+Core idea:
+- Extract the SAME sampled frames from each muted video.
+- Ask Gemini / OpenAI / Claude to choose the best impact frame index.
+- Convert frame index to timestamp in code (timestamp = frame_index / sampled_fps).
+"""
+
+import argparse
+import base64
+import json
+import logging
+import os
+import random
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import cv2
+from tqdm import tqdm
+
+try:
+    import google.generativeai as genai
+except Exception:  # pragma: no cover
+    genai = None
+
+try:
+    from openai import OpenAI
+except Exception:  # pragma: no cover
+    OpenAI = None
+
+try:
+    import anthropic
+except Exception:  # pragma: no cover
+    anthropic = None
+
+
+MUTED_DIR = Path("/home/ubuntu/video_source/muted_original")
+OUTPUT_JSONL = Path("/home/ubuntu/video_source/result/frame_selection_compare.jsonl")
+
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+OPENAI_MODEL = "gpt-5.1"
+CLAUDE_MODEL = "claude-sonnet-4-6"
+
+SAMPLED_FPS = 4.0
+MAX_VIDEOS = 100
+RANDOM_SEED = 40
+MAX_FRAMES_PER_VIDEO = 240
+
+
+def build_prompt(num_frames: int) -> str:
+    return f"""You are an expert in physics and video forensics.
+You will receive an ordered sequence of frames from one muted video.
+Your task: choose the SINGLE frame that shows the MAXIMUM PHYSICAL IMPACT
+(hard collision, hardest fall contact, strongest crash moment).
+
+Important:
+1) Output must be strictly JSON.
+2) The frame index must be an integer in [0, {num_frames - 1}].
+3) Pick only one best frame.
+
+Return exactly:
+{{
+  "best_frame_index": 12,
+  "event_description": "brief description of the impact"
+}}"""
+
+
+@dataclass
+class FrameSelectionResult:
+    best_frame_index: int
+    event_description: str
+
+
+@dataclass
+class SampledFrame:
+    sampled_index: int
+    jpeg_bytes: bytes
+    jpeg_b64: str
+
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+    )
+
+
+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_selection(data: Dict[str, Any], num_frames: int) -> FrameSelectionResult:
+    if "best_frame_index" not in data or "event_description" not in data:
+        raise ValueError(f"Missing required keys: {data}")
+    idx = int(data["best_frame_index"])
+    if idx < 0 or idx >= num_frames:
+        raise ValueError(f"best_frame_index out of range: {idx} / {num_frames}")
+    desc = str(data["event_description"]).strip()
+    if not desc:
+        raise ValueError("event_description is empty.")
+    return FrameSelectionResult(best_frame_index=idx, event_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 sample_video_frames(video_path: Path, sampled_fps: float, max_frames: int) -> List[SampledFrame]:
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise RuntimeError(f"Could not open video: {video_path}")
+
+    source_fps = cap.get(cv2.CAP_PROP_FPS)
+    if not source_fps or source_fps <= 0:
+        source_fps = 30.0
+
+    frame_interval = max(int(round(source_fps / sampled_fps)), 1)
+    frames: List[SampledFrame] = []
+    frame_idx = 0
+    sampled_idx = 0
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        if frame_idx % frame_interval == 0:
+            ok_enc, buffer = cv2.imencode(".jpg", frame)
+            if ok_enc:
+                jpeg_bytes = buffer.tobytes()
+                frames.append(
+                    SampledFrame(
+                        sampled_index=sampled_idx,
+                        jpeg_bytes=jpeg_bytes,
+                        jpeg_b64=base64.b64encode(jpeg_bytes).decode("utf-8"),
+                    )
+                )
+                sampled_idx += 1
+                if len(frames) >= max_frames:
+                    break
+        frame_idx += 1
+    cap.release()
+
+    if not frames:
+        raise RuntimeError(f"No frames sampled from video: {video_path}")
+    return frames
+
+
+def query_gemini(frames: List[SampledFrame], api_key: str) -> FrameSelectionResult:
+    if genai is None:
+        raise RuntimeError("google.generativeai package is not installed.")
+    if not api_key:
+        raise RuntimeError("GEMINI_API_KEY is missing.")
+
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel(GEMINI_MODEL)
+
+    content: List[Any] = [build_prompt(len(frames))]
+    for frame in frames:
+        content.append(f"Frame index: {frame.sampled_index}")
+        content.append({"mime_type": "image/jpeg", "data": frame.jpeg_bytes})
+
+    resp = model.generate_content(content)
+    raw_text = getattr(resp, "text", "") or ""
+    parsed = _extract_json_object(raw_text)
+    return _coerce_selection(parsed, len(frames))
+
+
+def query_openai(frames: List[SampledFrame], api_key: str) -> FrameSelectionResult:
+    if OpenAI is None:
+        raise RuntimeError("openai package is not installed.")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is missing.")
+
+    client = OpenAI(api_key=api_key)
+    content: List[Dict[str, Any]] = [{"type": "input_text", "text": build_prompt(len(frames))}]
+    for frame in frames:
+        content.append({"type": "input_text", "text": f"Frame index: {frame.sampled_index}"})
+        content.append(
+            {
+                "type": "input_image",
+                "image_url": f"data:image/jpeg;base64,{frame.jpeg_b64}",
+            }
+        )
+
+    response = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role": "user", "content": content}],
+    )
+    raw_text = getattr(response, "output_text", "") or ""
+    parsed = _extract_json_object(raw_text)
+    return _coerce_selection(parsed, len(frames))
+
+
+def query_claude(frames: List[SampledFrame], api_key: str) -> FrameSelectionResult:
+    if anthropic is None:
+        raise RuntimeError("anthropic package is not installed.")
+    if not api_key:
+        raise RuntimeError("ANTHROPIC_API_KEY is missing.")
+
+    client = anthropic.Anthropic(api_key=api_key)
+    content: List[Dict[str, Any]] = [{"type": "text", "text": build_prompt(len(frames))}]
+    for frame in frames:
+        content.append({"type": "text", "text": f"Frame index: {frame.sampled_index}"})
+        content.append(
+            {
+                "type": "image",
+                "source": {
+                    "type": "base64",
+                    "media_type": "image/jpeg",
+                    "data": frame.jpeg_b64,
+                },
+            }
+        )
+
+    response = client.messages.create(
+        model=CLAUDE_MODEL,
+        max_tokens=300,
+        messages=[{"role": "user", "content": content}],
+    )
+
+    chunks = []
+    for block in getattr(response, "content", []):
+        if getattr(block, "type", None) == "text":
+            chunks.append(getattr(block, "text", ""))
+    raw_text = "\n".join(chunks).strip()
+    parsed = _extract_json_object(raw_text)
+    return _coerce_selection(parsed, len(frames))
+
+
+def safe_query(query_fn, frames: List[SampledFrame], api_key: str, model_name: str) -> Optional[FrameSelectionResult]:
+    try:
+        return query_fn(frames, api_key)
+    except Exception as exc:
+        logging.error("%s failed: %s", model_name, exc)
+        return None
+
+
+def idx_to_timestamp(best_frame_index: Optional[int], sampled_fps: float) -> Optional[float]:
+    if best_frame_index is None:
+        return None
+    return round(float(best_frame_index) / sampled_fps, 3)
+
+
+def process_one_video(video_path: Path, gemini_key: str, openai_key: str, anthropic_key: str) -> Dict[str, Any]:
+    frames = sample_video_frames(video_path, sampled_fps=SAMPLED_FPS, max_frames=MAX_FRAMES_PER_VIDEO)
+
+    gemini_res = safe_query(query_gemini, frames, gemini_key, "Gemini")
+    openai_res = safe_query(query_openai, frames, openai_key, "OpenAI")
+    claude_res = safe_query(query_claude, frames, anthropic_key, "Claude")
+
+    row = {
+        "video_id": video_path.name,
+        "sampled_fps": SAMPLED_FPS,
+        "num_sampled_frames": len(frames),
+        "gemini_frame_index": gemini_res.best_frame_index if gemini_res else None,
+        "openai_frame_index": openai_res.best_frame_index if openai_res else None,
+        "claude_frame_index": claude_res.best_frame_index if claude_res else None,
+        "t_gemini": idx_to_timestamp(gemini_res.best_frame_index if gemini_res else None, SAMPLED_FPS),
+        "t_openai": idx_to_timestamp(openai_res.best_frame_index if openai_res else None, SAMPLED_FPS),
+        "t_claude": idx_to_timestamp(claude_res.best_frame_index if claude_res else None, SAMPLED_FPS),
+        "event_desc_gemini": gemini_res.event_description if gemini_res else None,
+        "event_desc_openai": openai_res.event_description if openai_res else None,
+        "event_desc_claude": claude_res.event_description if claude_res else None,
+    }
+    return row
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Fair 3-model frame-selection comparison.")
+    parser.add_argument("--muted-dir", type=Path, default=MUTED_DIR, help="Muted videos folder")
+    parser.add_argument("--output-jsonl", type=Path, default=OUTPUT_JSONL, help="Output JSONL file")
+    parser.add_argument("--sampled-fps", type=float, default=SAMPLED_FPS, help="Frame sampling FPS")
+    parser.add_argument("--max-videos", type=int, default=MAX_VIDEOS, help="How many videos to run")
+    parser.add_argument("--max-frames", type=int, default=MAX_FRAMES_PER_VIDEO, help="Max sampled frames per video")
+    parser.add_argument("--seed", type=int, default=RANDOM_SEED, help="Random seed for video selection")
+    parser.add_argument("--overwrite-output", action="store_true", help="Delete previous output file before running")
+    return parser.parse_args()
+
+
+def main() -> None:
+    global SAMPLED_FPS, MAX_FRAMES_PER_VIDEO
+    setup_logging()
+    args = parse_args()
+    SAMPLED_FPS = args.sampled_fps
+    MAX_FRAMES_PER_VIDEO = args.max_frames
+
+    gemini_key = os.getenv("GEMINI_API_KEY", "").strip()
+    openai_key = os.getenv("OPENAI_API_KEY", "").strip()
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY", "").strip()
+
+    if not args.muted_dir.exists():
+        raise FileNotFoundError(f"Muted folder not found: {args.muted_dir}")
+
+    videos = sorted(args.muted_dir.rglob("*.mp4"))
+    if not videos:
+        raise FileNotFoundError(f"No mp4 found in: {args.muted_dir}")
+
+    rng = random.Random(args.seed)
+    if len(videos) > args.max_videos:
+        videos = rng.sample(videos, args.max_videos)
+        videos.sort()
+
+    if args.overwrite_output and args.output_jsonl.exists():
+        args.output_jsonl.unlink()
+
+    logging.info("Videos selected: %d", len(videos))
+    logging.info("sampled_fps=%.2f | max_frames=%d", SAMPLED_FPS, MAX_FRAMES_PER_VIDEO)
+    logging.info("Output: %s", args.output_jsonl)
+
+    for video_path in tqdm(videos, desc="Frame Selection Compare", unit="video"):
+        row = process_one_video(video_path, gemini_key, openai_key, anthropic_key)
+        append_jsonl(args.output_jsonl, row)
+
+    logging.info("Done.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data_gen/multi_model_visual_grounding.py b/data_gen/multi_model_visual_grounding.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4571431e0e73ce35efcaf79e741d11867494436
--- /dev/null
+++ b/data_gen/multi_model_visual_grounding.py
@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+import base64
+import json
+import logging
+import os
+import random
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import cv2
+from tqdm import tqdm
+
+try:
+    import google.generativeai as genai
+except Exception:  # pragma: no cover - optional dependency
+    genai = None
+
+try:
+    from openai import OpenAI
+except Exception:  # pragma: no cover - optional dependency
+    OpenAI = None
+
+try:
+    import anthropic
+except Exception:  # pragma: no cover - optional dependency
+    anthropic = None
+
+
+ORIGINAL_DIR = Path("/home/ubuntu/video_source/original/uag_oops")
+MUTED_DIR = Path("/home/ubuntu/video_source/muted_original")
+OUTPUT_JSONL = Path("/home/ubuntu/video_source/muted_original/visual_timestamps_compare.jsonl")
+
+VISUAL_PROMPT = """You are an expert in physics and video forensics. Carefully analyze this muted video to find the exact moment a high-energy physical event occurs (e.g., a hard fall, a collision, something breaking).
+You must output strictly in JSON format with the following keys:
+{
+  "visual_timestamp": 2.5,
+  "event_description": "Brief description of the impact"
+}"""
+
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+OPENAI_MODEL = "gpt-5.1"
+CLAUDE_MODEL = "claude-sonnet-4-6"
+SAMPLE_SIZE = 100
+RANDOM_SEED = 42
+
+MAX_RETRIES = 2
+RETRY_BASE_SECONDS = 2.0
+GEMINI_FILE_READY_TIMEOUT_SECONDS = 120
+GEMINI_FILE_POLL_SECONDS = 2
+OPENAI_TARGET_FPS = 1.0
+CLAUDE_TARGET_FPS = 1.0
+
+
+@dataclass
+class VisualResult:
+    visual_timestamp: float
+    event_description: str
+
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+    )
+
+
+def ensure_ffmpeg() -> None:
+    subprocess.run(
+        ["ffmpeg", "-version"],
+        check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+
+def with_retries(fn, *args, **kwargs):
+    last_exc: Optional[Exception] = None
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            return fn(*args, **kwargs)
+        except Exception as exc:  # pragma: no cover - network and API variability
+            last_exc = exc
+            if attempt < MAX_RETRIES:
+                wait_s = RETRY_BASE_SECONDS * (2 ** (attempt - 1))
+                logging.warning(
+                    "Attempt %s/%s failed: %s. Retrying in %.1fs...",
+                    attempt,
+                    MAX_RETRIES,
+                    exc,
+                    wait_s,
+                )
+                time.sleep(wait_s)
+    raise RuntimeError(f"All retry attempts failed. Last error: {last_exc}")
+
+
+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_visual_result(data: Dict[str, Any]) -> VisualResult:
+    ts = float(data["visual_timestamp"])
+    desc = str(data["event_description"]).strip()
+    if not desc:
+        raise ValueError("event_description is empty.")
+    return VisualResult(visual_timestamp=ts, event_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_muted_video(input_video: Path, output_video: Path) -> None:
+    output_video.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(input_video),
+        "-an",
+        "-c:v",
+        "copy",
+        str(output_video),
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def prepare_muted_videos(original_dir: Path, muted_dir: Path) -> List[Path]:
+    if not original_dir.exists():
+        raise FileNotFoundError(f"Original folder not found: {original_dir}")
+
+    originals = sorted(original_dir.rglob("*.mp4"))
+    if not originals:
+        raise FileNotFoundError(f"No .mp4 files found under: {original_dir}")
+
+    muted_dir.mkdir(parents=True, exist_ok=True)
+    muted_paths: List[Path] = []
+
+    for src in originals:
+        rel = src.relative_to(original_dir)
+        dst = muted_dir / rel
+        if not dst.exists():
+            logging.info("Muting: %s -> %s", src, dst)
+            extract_muted_video(src, dst)
+        else:
+            logging.info("Muted exists, skip: %s", dst)
+        muted_paths.append(dst)
+    return muted_paths
+
+
+def video_frames_to_base64_jpegs(video_path: Path, target_fps: float) -> List[str]:
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise RuntimeError(f"Could not open video: {video_path}")
+
+    source_fps = cap.get(cv2.CAP_PROP_FPS)
+    if not source_fps or source_fps <= 0:
+        source_fps = 30.0
+    frame_interval = max(int(round(source_fps / target_fps)), 1)
+
+    frames_b64: List[str] = []
+    frame_idx = 0
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        if frame_idx % frame_interval == 0:
+            ok_enc, buffer = cv2.imencode(".jpg", frame)
+            if ok_enc:
+                frames_b64.append(base64.b64encode(buffer.tobytes()).decode("utf-8"))
+        frame_idx += 1
+
+    cap.release()
+    if not frames_b64:
+        raise RuntimeError(f"No frames extracted from: {video_path}")
+    return frames_b64
+
+
+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 not ACTIVE before timeout.")
+
+
+def query_gemini_visual(muted_video: Path, api_key: str) -> VisualResult:
+    """
+    Placeholder section for Gemini API call.
+    Replace internals as needed for your account/project config.
+    """
+    if genai is None:
+        raise RuntimeError("google.generativeai is not installed.")
+    if not api_key:
+        raise RuntimeError("GEMINI_API_KEY is missing.")
+
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel(GEMINI_MODEL)
+    uploaded = genai.upload_file(path=str(muted_video))
+    try:
+        wait_for_gemini_file_active(uploaded.name)
+        resp = model.generate_content([VISUAL_PROMPT, uploaded])
+        raw_text = getattr(resp, "text", "") or ""
+        data = _extract_json_object(raw_text)
+        return _coerce_visual_result(data)
+    finally:
+        try:
+            genai.delete_file(uploaded.name)
+        except Exception:
+            logging.warning("Failed to delete Gemini upload: %s", uploaded.name)
+
+
+def query_openai_visual(muted_video: Path, api_key: str) -> VisualResult:
+    """
+    Placeholder section for OpenAI API call (GPT-5.1).
+    Replace internals if your OpenAI account expects another multimodal format.
+    """
+    if OpenAI is None:
+        raise RuntimeError("openai package is not installed.")
+    if not api_key:
+        raise RuntimeError("OPENAI_API_KEY is missing.")
+
+    client = OpenAI(api_key=api_key)
+    image_b64_list = video_frames_to_base64_jpegs(muted_video, target_fps=OPENAI_TARGET_FPS)
+    content: List[Dict[str, Any]] = [{"type": "input_text", "text": VISUAL_PROMPT}]
+    for b64_img in image_b64_list:
+        content.append(
+            {
+                "type": "input_image",
+                "image_url": f"data:image/jpeg;base64,{b64_img}",
+            }
+        )
+
+    response = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role": "user", "content": content}],
+    )
+    raw_text = getattr(response, "output_text", "") or ""
+    data = _extract_json_object(raw_text)
+    return _coerce_visual_result(data)
+
+
+def query_claude_visual(muted_video: Path, api_key: str) -> VisualResult:
+    """
+    Placeholder section for Anthropic API call (Claude Sonnet 4.6).
+    Current implementation samples video frames and sends them as image blocks.
+    """
+    if anthropic is None:
+        raise RuntimeError("anthropic package is not installed.")
+    if not api_key:
+        raise RuntimeError("ANTHROPIC_API_KEY is missing.")
+
+    client = anthropic.Anthropic(api_key=api_key)
+    image_b64_list = video_frames_to_base64_jpegs(muted_video, target_fps=CLAUDE_TARGET_FPS)
+
+    content: List[Dict[str, Any]] = [{"type": "text", "text": VISUAL_PROMPT}]
+    for b64_img in image_b64_list:
+        content.append(
+            {
+                "type": "image",
+                "source": {
+                    "type": "base64",
+                    "media_type": "image/jpeg",
+                    "data": b64_img,
+                },
+            }
+        )
+
+    response = client.messages.create(
+        model=CLAUDE_MODEL,
+        max_tokens=300,
+        messages=[{"role": "user", "content": content}],
+    )
+
+    chunks = []
+    for block in getattr(response, "content", []):
+        if getattr(block, "type", None) == "text":
+            chunks.append(getattr(block, "text", ""))
+    raw_text = "\n".join(chunks).strip()
+    data = _extract_json_object(raw_text)
+    return _coerce_visual_result(data)
+
+
+def safe_query(query_fn, muted_video: Path, api_key: str, model_name: str) -> Optional[VisualResult]:
+    try:
+        return with_retries(query_fn, muted_video, api_key)
+    except Exception as exc:
+        logging.error("%s failed for %s: %s", model_name, muted_video.name, exc)
+        return None
+
+
+def choose_event_description(
+    gemini_result: Optional[VisualResult],
+    openai_result: Optional[VisualResult],
+    claude_result: Optional[VisualResult],
+) -> Optional[str]:
+    if gemini_result:
+        return gemini_result.event_description
+    if openai_result:
+        return openai_result.event_description
+    if claude_result:
+        return claude_result.event_description
+    return None
+
+
+def process_video(muted_video: Path, gemini_key: str, openai_key: str, anthropic_key: str) -> Dict[str, Any]:
+    logging.info("Processing muted video: %s", muted_video.name)
+
+    gemini_result = safe_query(query_gemini_visual, muted_video, gemini_key, "Gemini")
+    openai_result = safe_query(query_openai_visual, muted_video, openai_key, "OpenAI")
+    claude_result = safe_query(query_claude_visual, muted_video, anthropic_key, "Claude")
+
+    row = {
+        "video_id": muted_video.name,
+        "t_gemini": round(gemini_result.visual_timestamp, 3) if gemini_result else None,
+        "t_gpt5_1": round(openai_result.visual_timestamp, 3) if openai_result else None,
+        "t_claude": round(claude_result.visual_timestamp, 3) if claude_result else None,
+        "event_description": choose_event_description(gemini_result, openai_result, claude_result),
+    }
+    return row
+
+
+def main() -> None:
+    setup_logging()
+    ensure_ffmpeg()
+
+    gemini_key = os.getenv("GEMINI_API_KEY", "").strip()
+    openai_key = os.getenv("OPENAI_API_KEY", "").strip()
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY", "").strip()
+
+    muted_paths = prepare_muted_videos(ORIGINAL_DIR, MUTED_DIR)
+    logging.info("Total muted videos ready: %d", len(muted_paths))
+
+    all_videos = sorted(muted_paths)
+    rng = random.Random(RANDOM_SEED)
+    if len(all_videos) <= SAMPLE_SIZE:
+        selected_videos = all_videos
+    else:
+        selected_videos = rng.sample(all_videos, SAMPLE_SIZE)
+        selected_videos.sort()
+    logging.info(
+        "Testing %d videos (random sample size=%d, seed=%d).",
+        len(selected_videos),
+        SAMPLE_SIZE,
+        RANDOM_SEED,
+    )
+
+    for video in tqdm(selected_videos, desc="Visual Grounding", unit="video"):
+        row = process_video(video, gemini_key, openai_key, anthropic_key)
+        append_jsonl(OUTPUT_JSONL, row)
+        logging.info("Saved row: %s", row)
+
+    logging.info("Done. Output JSONL: %s", OUTPUT_JSONL.resolve())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/compute_videomme_metrics_from_jsonl.py b/eval/compute_videomme_metrics_from_jsonl.py
new file mode 100644
index 0000000000000000000000000000000000000000..c59703d6cecce07617c2b27b1b0f38b418d8f160
--- /dev/null
+++ b/eval/compute_videomme_metrics_from_jsonl.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Recompute Video-MME metrics from eval_results.jsonl (same schema as eval_videomme.py).
+
+Example:
+  python compute_videomme_metrics_from_jsonl.py \\
+    --jsonl /home/ubuntu/video_source/eval_results/videomme/vmme_vanilla/eval_results.jsonl \\
+    --out /home/ubuntu/video_source/eval_results/videomme/vmme_vanilla/metrics.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+VIDEO_TYPES = ["short", "medium", "long"]
+CATEGORIES = [
+    "Knowledge",
+    "Film & Television",
+    "Sports Competition",
+    "Artistic Performance",
+    "Life Record",
+    "Multilingual",
+]
+TASK_CATEGORIES = [
+    "Temporal Perception",
+    "Spatial Perception",
+    "Attribute Perception",
+    "Action Recognition",
+    "Object Recognition",
+    "OCR Problems",
+    "Counting Problem",
+    "Temporal Reasoning",
+    "Spatial Reasoning",
+    "Action Reasoning",
+    "Object Reasoning",
+    "Information Synopsis",
+]
+
+
+def load_results(path: Path) -> List[Dict[str, Any]]:
+    rows = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    return rows
+
+
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(
+        1 for r in results if str(r.get("pred_answer", "")).upper() == str(r["gt_answer"]).upper()
+    )
+    overall_acc = correct / total
+
+    def acc_for(items: List[Dict[str, Any]]) -> float | None:
+        if not items:
+            return None
+        c = sum(
+            1
+            for r in items
+            if str(r.get("pred_answer", "")).upper() == str(r["gt_answer"]).upper()
+        )
+        return round(c / len(items), 4)
+
+    per_duration: Dict[str, Any] = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r.get("duration") == vt]
+        if subset:
+            per_duration[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_domain: Dict[str, Any] = {}
+    for cat in CATEGORIES:
+        subset = [r for r in results if r.get("domain") == cat]
+        if subset:
+            per_domain[cat] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task: Dict[str, Any] = {}
+    for task in TASK_CATEGORIES:
+        subset = [r for r in results if r.get("task_type") == task]
+        if subset:
+            per_task[task] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_duration": per_duration,
+        "per_domain": per_domain,
+        "per_task_type": per_task,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print("=" * 65)
+    print(f"  Video-MME Summary: {label}")
+    print("=" * 65)
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+    print("  --- Per Duration ---")
+    for vt in VIDEO_TYPES:
+        if vt in metrics["per_duration"]:
+            d = metrics["per_duration"][vt]
+            print(f"    {vt:8s}:  {d['accuracy']:.1%}  ({d['count']} questions)")
+    print("  --- Per Domain ---")
+    for cat in CATEGORIES:
+        if cat in metrics["per_domain"]:
+            d = metrics["per_domain"][cat]
+            print(f"    {cat:25s}: {d['accuracy']:.1%}  ({d['count']})")
+    print("  --- Per Task Type ---")
+    for task in TASK_CATEGORIES:
+        if task in metrics["per_task_type"]:
+            d = metrics["per_task_type"][task]
+            print(f"    {task:25s}: {d['accuracy']:.1%}  ({d['count']})")
+    print("=" * 65)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument(
+        "--jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/eval_results/videomme/vmme_vanilla/eval_results.jsonl"),
+    )
+    p.add_argument(
+        "--out",
+        type=Path,
+        default=None,
+        help="Write metrics JSON here (default: <jsonl_dir>/metrics.json)",
+    )
+    p.add_argument("--label", type=str, default="from_jsonl")
+    p.add_argument("--base-model", type=str, default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument(
+        "--video-dir",
+        type=str,
+        default="/opt/dlami/nvme/videomme/data/data",
+    )
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    args = p.parse_args()
+
+    out_path = args.out or (args.jsonl.parent / "metrics.json")
+
+    results = load_results(args.jsonl)
+    metrics = compute_metrics(results)
+    if not metrics:
+        print("[warn] No rows in jsonl.")
+        return
+
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": args.video_dir,
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+        "source_jsonl": str(args.jsonl.resolve()),
+    }
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+
+    print_summary(metrics, args.label)
+    print(f"\n[written] {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/download_lvbench.py b/eval/download_lvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c44b9e46c2a351ae1519b7d6662a6fb939be3d8
--- /dev/null
+++ b/eval/download_lvbench.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Download LVBench videos from Hugging Face (lmms-lab/LVBench).
+
+Downloads chunked zip files and extracts them.
+
+Usage:
+    python download_lvbench.py
+    python download_lvbench.py --output-dir /path/to/lvbench
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "lmms-lab/LVBench"
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/lvbench")
+
+VIDEO_ZIPS = [f"video_chunks/videos_chunk_{i:03d}.zip" for i in range(1, 15)]
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Download LVBench from Hugging Face.")
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT)
+    return p.parse_args()
+
+
+def download_and_extract(repo_file: str, extract_to: Path, label: str) -> None:
+    extract_to.mkdir(parents=True, exist_ok=True)
+    print(f"  Downloading {label}: {repo_file} ...")
+    local_zip = hf_hub_download(
+        repo_id=REPO_ID, filename=repo_file, repo_type="dataset",
+    )
+    print(f"  Extracting to {extract_to} ...")
+    with zipfile.ZipFile(local_zip, "r") as zf:
+        zf.extractall(extract_to)
+    print(f"  Done: {repo_file}")
+
+
+def main() -> None:
+    args = parse_args()
+    out_dir = args.output_dir
+
+    existing = sum(1 for f in out_dir.iterdir() if f.suffix == ".mp4") if out_dir.exists() else 0
+    if existing >= 100:
+        print(f"[skip] Already have {existing} videos in {out_dir}")
+    else:
+        print(f"Downloading {len(VIDEO_ZIPS)} video chunks...")
+        for i, zf in enumerate(VIDEO_ZIPS, 1):
+            download_and_extract(zf, out_dir, f"chunk {i}/{len(VIDEO_ZIPS)}")
+
+    video_count = sum(1 for f in out_dir.iterdir() if f.suffix == ".mp4") if out_dir.exists() else 0
+    print(f"\nDone. Total videos on disk: {video_count}")
+    print(f"  Videos: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/download_videomme.py b/eval/download_videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3a28f5b7e9208629484c79e0129052c7849b71a
--- /dev/null
+++ b/eval/download_videomme.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Download Video-MME videos from Hugging Face (lmms-lab/Video-MME).
+
+Downloads chunked zip files and extracts them.
+
+Usage:
+    python download_videomme.py
+    python download_videomme.py --output-dir /path/to/videomme
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "lmms-lab/Video-MME"
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/videomme")
+
+VIDEO_ZIPS = [f"videos_chunked_{i:02d}.zip" for i in range(1, 21)]
+SUBTITLE_ZIP = "subtitle.zip"
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Download Video-MME from Hugging Face.")
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT)
+    p.add_argument("--skip-subtitles", action="store_true")
+    return p.parse_args()
+
+
+def download_and_extract(repo_file: str, extract_to: Path, label: str) -> None:
+    extract_to.mkdir(parents=True, exist_ok=True)
+    print(f"  Downloading {label}: {repo_file} ...")
+    local_zip = hf_hub_download(
+        repo_id=REPO_ID, filename=repo_file, repo_type="dataset",
+    )
+    print(f"  Extracting to {extract_to} ...")
+    with zipfile.ZipFile(local_zip, "r") as zf:
+        zf.extractall(extract_to)
+    print(f"  Done: {repo_file}")
+
+
+def main() -> None:
+    args = parse_args()
+    data_dir = args.output_dir / "data"
+    sub_dir = args.output_dir / "subtitle"
+
+    existing = sum(1 for f in data_dir.iterdir() if f.suffix in (".mp4", ".MP4", ".mkv")) if data_dir.exists() else 0
+    if existing >= 900:
+        print(f"[skip] Already have {existing} videos in {data_dir}")
+    else:
+        print(f"[1/2] Downloading {len(VIDEO_ZIPS)} video chunks...")
+        for i, zf in enumerate(VIDEO_ZIPS, 1):
+            download_and_extract(zf, data_dir, f"chunk {i}/{len(VIDEO_ZIPS)}")
+
+    if args.skip_subtitles:
+        print("[skip] Subtitle download skipped (--skip-subtitles)")
+    else:
+        existing_subs = sum(1 for f in sub_dir.iterdir() if f.suffix == ".srt") if sub_dir.exists() else 0
+        if existing_subs >= 800:
+            print(f"[skip] Already have {existing_subs} subtitles in {sub_dir}")
+        else:
+            print("[2/2] Downloading subtitles...")
+            download_and_extract(SUBTITLE_ZIP, sub_dir, "subtitles")
+
+    video_count = sum(1 for f in data_dir.iterdir() if f.suffix in (".mp4", ".MP4", ".mkv")) if data_dir.exists() else 0
+    print(f"\nDone. Total videos on disk: {video_count}")
+    print(f"  Videos: {data_dir}")
+    print(f"  Subtitles: {sub_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/eval_dpo_sync.py b/eval/eval_dpo_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a611c51d14bdbef0bd0315f10d5c62c33296ae8
--- /dev/null
+++ b/eval/eval_dpo_sync.py
@@ -0,0 +1,841 @@
+#!/usr/bin/env python3
+"""
+Automated evaluation script for audio-video sync DPO models.
+
+Workflow:
+  1. Load test set (kto_training_data_v2_test.jsonl)
+  2. Parse ground truth from video filenames (synced / delay Xs / early Xs)
+  3. Run model inference with a structured JSON prompt
+  4. Extract predictions: JSON parse -> GPT-5.4 judge (optional) -> regex fallback
+  5. Compute metrics: Sync/Desync Accuracy, Direction Accuracy, Offset MAE
+  6. Output a summary table + per-sample JSONL for analysis
+
+Usage:
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/Qwen3-Omni-Instruct/dpo/qwen3omni_dpo_lora_with_audio_v4_data_8632
+
+  # With GPT-5.4 judge fallback:
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/.../adapter \
+    --gpt-judge --openai-api-key sk-xxx
+
+  # Evaluate base model without adapter (SFT baseline):
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo
+
+  # Evaluate vanilla Qwen3-Omni (no SFT, no DPO):
+  python eval_dpo_sync.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import time
+from pathlib import Path
+from statistics import mean, median
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# GPT-5.4 judge helper
+# ---------------------------------------------------------------------------
+_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": <bool>, "direction": "none"|"delay"|"early", "offset_sec": <float>, "t_v": <float or null>, "t_a": <float or null>, "explanation": "<one sentence>"}
+
+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.
+- t_v: the timestamp (in seconds) the model attributes to the VISUAL event. null if not mentioned.
+- t_a: the timestamp (in seconds) the model attributes to the AUDIO event. null if not mentioned.
+- If you cannot determine a field, use the default (true / "none" / 0.0 / null / "").
+"""
+
+
+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]]:
+    """Call GPT to parse raw model output into structured prediction."""
+    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"
+                t_v_raw = obj.get("t_v")
+                t_a_raw = obj.get("t_a")
+                pred_t_v = float(t_v_raw) if t_v_raw is not None else None
+                pred_t_a = float(t_a_raw) if t_a_raw is not None else None
+                return {
+                    "pred_synced": bool(synced),
+                    "pred_direction": direction,
+                    "pred_offset_sec": float(obj.get("offset_sec", 0.0)),
+                    "pred_t_v": pred_t_v,
+                    "pred_t_a": pred_t_a,
+                    "pred_explanation": str(obj.get("explanation", "")),
+                    "parse_method": "gpt_judge",
+                }
+    except Exception as exc:
+        print(f"  [gpt-judge] API error: {exc}", flush=True)
+    return None
+
+DATA_ROOT = Path("/opt/dlami/nvme/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+AUDIO_ROOT = DATA_ROOT / "extracted_audio" / "original"
+
+
+def set_data_root(root: Path) -> None:
+    """Point path resolution at a new server layout (original/, random_shift_video/, extracted_audio/)."""
+    global DATA_ROOT, ORIGINAL_ROOT, AUDIO_ROOT
+    DATA_ROOT = root.resolve()
+    ORIGINAL_ROOT = DATA_ROOT / "original"
+    AUDIO_ROOT = DATA_ROOT / "extracted_audio" / "original"
+
+EVAL_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 DPO sync model on test set.")
+    p.add_argument("--base-model", type=str,
+                    default="Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo")
+    p.add_argument("--adapter", type=str, default=None,
+                    help="Path to LoRA adapter. If omitted, evaluates base model only.")
+    p.add_argument(
+        "--data-root",
+        type=Path,
+        default=Path("/opt/dlami/nvme/video_source"),
+        help="Directory containing original/, random_shift_video/, extracted_audio/ (video+audio for sync eval).",
+    )
+    p.add_argument(
+        "--test-jsonl",
+        type=Path,
+        default=None,
+        help="Test JSONL (default: <data-root>/kto_training_data_v2_test.jsonl).",
+    )
+    p.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Eval output root (default: /home/ubuntu/eval_results/sync).",
+    )
+    p.add_argument("--max-samples", type=int, default=-1,
+                    help="Limit number of test samples (-1 = all).")
+    p.add_argument("--max-new-tokens", type=int, default=256)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--label", type=str, default=None,
+                    help="Label for this eval run (used in output filenames).")
+    p.add_argument("--gpt-judge", action="store_true", default=False,
+                    help="Use GPT-5.4 as fallback parser when JSON extraction fails.")
+    p.add_argument("--openai-api-key", type=str, default=None,
+                    help="OpenAI API key. Falls back to OPENAI_API_KEY env var.")
+    p.add_argument("--gpt-model", type=str, default="gpt-5.4",
+                    help="OpenAI model to use for GPT judge (default: gpt-5.4).")
+    return p.parse_args()
+
+
+def parse_ground_truth(video_field: str) -> Dict[str, Any]:
+    """Extract ground truth sync label from video filename."""
+    m_delay = re.search(r"_delay_([\d.]+)s\.mp4", video_field)
+    m_early = re.search(r"_early_([\d.]+)s\.mp4", video_field)
+    if m_delay:
+        return {"synced": False, "direction": "delay", "offset_sec": float(m_delay.group(1))}
+    elif m_early:
+        return {"synced": False, "direction": "early", "offset_sec": float(m_early.group(1))}
+    else:
+        return {"synced": True, "direction": "none", "offset_sec": 0.0}
+
+
+def resolve_video_path(video_field: str) -> str:
+    if os.path.isabs(video_field) and os.path.exists(video_field):
+        return video_field
+    candidate_dirs = [
+        ORIGINAL_ROOT / "uag_oops",
+        DATA_ROOT / "random_shift_video" / "delay",
+        DATA_ROOT / "random_shift_video" / "early",
+        ORIGINAL_ROOT,
+    ]
+    for d in candidate_dirs:
+        c = d / video_field
+        if c.exists():
+            return str(c)
+    return str(ORIGINAL_ROOT / "uag_oops" / video_field)
+
+
+def resolve_audio_path(video_path: str) -> str:
+    video_p = Path(video_path)
+    try:
+        rel = video_p.relative_to(DATA_ROOT)
+    except ValueError:
+        rel = Path(video_p.name)
+    audio_path = DATA_ROOT / "extracted_audio" / rel.with_suffix(".wav")
+    if audio_path.exists():
+        return str(audio_path)
+    base_stem = re.sub(r"_(delay|early)_[\d.]+s$", "", video_p.stem)
+    fallback = DATA_ROOT / "extracted_audio" / "original" / "uag_oops" / (base_stem + ".wav")
+    if fallback.exists():
+        return str(fallback)
+    return str(audio_path)
+
+
+def extract_timestamps(text: str) -> Tuple[Optional[float], Optional[float]]:
+    """Extract (t_visual, t_audio) from text using 'at/around/about Xs' pattern.
+    
+    If >= 2 timestamps found, first is t_v, second is t_a.
+    If exactly 1 timestamp found (common for synced samples), treat as both t_v and t_a.
+    """
+    text_lower = text.lower()
+    all_times = [(m.start(), float(m.group(1)))
+                 for m in re.finditer(r"(?:at|around|about)\s+([\d]+\.?\d*)\s*s", text_lower)]
+    if len(all_times) >= 2:
+        return (all_times[0][1], all_times[1][1])
+    if len(all_times) == 1:
+        return (all_times[0][1], all_times[0][1])
+    return (None, None)
+
+
+def load_test_data(path: Path, max_samples: int) -> List[Dict[str, Any]]:
+    data = []
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            video_path = resolve_video_path(obj["video"])
+            audio_path = resolve_audio_path(video_path)
+            gt = parse_ground_truth(obj["video"])
+            gt_t_v, gt_t_a = extract_timestamps(obj.get("chosen", ""))
+            data.append({
+                "video": obj["video"],
+                "video_path": video_path,
+                "audio_path": audio_path,
+                "prompt": obj["prompt"],
+                "chosen": obj["chosen"],
+                "rejected": obj["rejected"],
+                "gt_synced": gt["synced"],
+                "gt_direction": gt["direction"],
+                "gt_offset_sec": gt["offset_sec"],
+                "gt_t_v": gt_t_v,
+                "gt_t_a": gt_t_a,
+            })
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+def extract_prediction(text: str) -> Dict[str, Any]:
+    """Extract structured prediction from model output text."""
+    text = text.strip()
+
+    # Try JSON extraction
+    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)
+        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"
+                offset = float(obj.get("offset_sec", 0.0))
+                explanation = str(obj.get("explanation", ""))
+                t_v_raw = obj.get("t_v")
+                t_a_raw = obj.get("t_a")
+                return {
+                    "pred_synced": bool(synced),
+                    "pred_direction": direction,
+                    "pred_offset_sec": offset,
+                    "pred_t_v": float(t_v_raw) if t_v_raw is not None else None,
+                    "pred_t_a": float(t_a_raw) if t_a_raw is not None else None,
+                    "pred_explanation": explanation,
+                    "parse_method": "json",
+                }
+            except (json.JSONDecodeError, ValueError, TypeError):
+                continue
+
+    # Fallback: structured extraction from free text
+    text_lower = text.lower()
+    synced = None
+    direction = "none"
+    offset = 0.0
+
+    pred_t_v, pred_t_a = extract_timestamps(text)
+
+    # Step 1: Determine sync vs desync
+    desync_kws = [
+        "not synchronized", "not aligned", "desync", "mismatch", "misalign",
+        "not in sync", "out of sync", "clearly not", "not well aligned",
+        "are not aligned", "audio and visual event are clearly not",
+    ]
+    sync_kws = [
+        "synchronized", "well aligned", "well-aligned", "in sync",
+        "appear synchronized", "appears synchronized", "closely aligned",
+        "audio and video are 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:
+        # Step 2a: Try explicit direction keywords
+        delay_kws = ["audio delayed", "audio lags", "audio comes after", "sound comes after",
+                     "sound is heard later", "audio is delayed", "sound follows"]
+        early_kws = ["audio early", "audio leads", "audio comes before", "sound comes before",
+                     "audio precedes", "sound is heard before", "sound 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"
+
+        # Step 2b: If no explicit keyword, use extracted timestamps to infer direction
+        if direction == "none" and pred_t_v is not None and pred_t_a is not None and pred_t_v != pred_t_a:
+            if pred_t_a > pred_t_v:
+                direction = "delay"
+            else:
+                direction = "early"
+            offset = abs(pred_t_a - pred_t_v)
+
+        # Step 2c: Extract offset from gap/separation mentions if not yet found
+        if offset == 0.0:
+            offset_match = re.search(
+                r"(?:gap|separation|offset|mismatch|differ\w*)\s*(?:of\s+)?(?:about\s+|roughly\s+|approximately\s+)?"
+                r"([\d]+\.?\d*)\s*s",
+                text_lower,
+            )
+            if not offset_match:
+                offset_match = re.search(
+                    r"(?:about\s+|roughly\s+|approximately\s+)?([\d]+\.?\d*)\s*s\s*"
+                    r"(?:gap|separation|offset|mismatch|differ)",
+                    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,
+        "pred_t_v": pred_t_v,
+        "pred_t_a": pred_t_a,
+        "pred_explanation": "",
+        "parse_method": "regex_fallback",
+    }
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+        import tempfile, shutil
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = any(t.startswith("model.layers.") for t in target_modules) and model_type != "qwen3_omni_moe_thinker"
+
+        if needs_remap:
+            print("[load] Adapter was trained on thinker-only model; remapping keys to full model...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace("base_model.model.model.layers.", "base_model.model.thinker.model.layers.")
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, audio_path: str,
+                  max_new_tokens: int, temperature: float) -> str:
+    from qwen_omni_utils import process_mm_info
+    import tempfile
+
+    tmp_dir = tempfile.mkdtemp(prefix="eval_masked_")
+    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": EVAL_PROMPT},
+            ],
+        }
+    ]
+
+    text = processor.apply_chat_template(
+        conversation, add_generation_prompt=True, tokenize=False,
+    )
+    audios, images, videos = process_mm_info(conversation, use_audio_in_video=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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)
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    import shutil
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    return response
+
+
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Compute all evaluation metrics."""
+    total = len(results)
+    if total == 0:
+        return {}
+
+    # 1. Sync/Desync binary accuracy
+    sync_correct = sum(1 for r in results if r["pred_synced"] == r["gt_synced"])
+    sync_acc = sync_correct / total
+
+    # 2. Direction accuracy (on desync samples only)
+    desync_samples = [r for r in results if not r["gt_synced"]]
+    if desync_samples:
+        dir_correct = sum(1 for r in desync_samples if r["pred_direction"] == r["gt_direction"])
+        dir_acc = dir_correct / len(desync_samples)
+    else:
+        dir_acc = None
+
+    # 3. Full 3-class accuracy (synced / delay / early)
+    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
+
+    # 4. Offset MAE (on desync samples where model also predicts desync)
+    offset_errors = []
+    for r in desync_samples:
+        if not r["pred_synced"] and r["pred_offset_sec"] > 0:
+            offset_errors.append(abs(r["pred_offset_sec"] - r["gt_offset_sec"]))
+    offset_mae = mean(offset_errors) if offset_errors else None
+    offset_median = median(offset_errors) if offset_errors else None
+
+    # 5. Per-category breakdown
+    synced_samples = [r for r in results if r["gt_synced"]]
+    delay_samples = [r for r in results if r["gt_direction"] == "delay"]
+    early_samples = [r for r in results if r["gt_direction"] == "early"]
+
+    synced_acc = (sum(1 for r in synced_samples if r["pred_synced"]) / len(synced_samples)) if synced_samples else None
+    delay_acc = (sum(1 for r in delay_samples if not r["pred_synced"] and r["pred_direction"] == "delay") / len(delay_samples)) if delay_samples else None
+    early_acc = (sum(1 for r in early_samples if not r["pred_synced"] and r["pred_direction"] == "early") / len(early_samples)) if early_samples else None
+
+    # 6. Tolerance-based offset accuracy
+    within_05 = sum(1 for e in offset_errors if e <= 0.5) if offset_errors else 0
+    within_10 = sum(1 for e in offset_errors if e <= 1.0) if offset_errors else 0
+
+    # 7. Parse method stats
+    json_parsed = sum(1 for r in results if r.get("parse_method") == "json")
+    regex_parsed = sum(1 for r in results if r.get("parse_method") == "regex_fallback")
+    gpt_parsed = sum(1 for r in results if r.get("parse_method") == "gpt_judge")
+
+    # 8. Timestamp MAE (t_v and t_a separately)
+    tv_errors = []
+    ta_errors = []
+    for r in results:
+        gt_tv = r.get("gt_t_v")
+        gt_ta = r.get("gt_t_a")
+        pred_tv = r.get("pred_t_v")
+        pred_ta = r.get("pred_t_a")
+        if gt_tv is not None and pred_tv is not None:
+            tv_errors.append(abs(pred_tv - gt_tv))
+        if gt_ta is not None and pred_ta is not None:
+            ta_errors.append(abs(pred_ta - gt_ta))
+    tv_mae = round(mean(tv_errors), 4) if tv_errors else None
+    ta_mae = round(mean(ta_errors), 4) if ta_errors else None
+    tv_median = round(median(tv_errors), 4) if tv_errors else None
+    ta_median = round(median(ta_errors), 4) if ta_errors else None
+
+    return {
+        "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_category": {
+            "synced_accuracy": round(synced_acc, 4) if synced_acc is not None else None,
+            "delay_accuracy": round(delay_acc, 4) if delay_acc is not None else None,
+            "early_accuracy": round(early_acc, 4) if early_acc is not None else None,
+            "synced_count": len(synced_samples),
+            "delay_count": len(delay_samples),
+            "early_count": len(early_samples),
+        },
+        "offset_mae_sec": round(offset_mae, 4) if offset_mae is not None else None,
+        "offset_median_sec": round(offset_median, 4) if offset_median is not None else None,
+        "offset_within_0.5s": within_05,
+        "offset_within_1.0s": within_10,
+        "offset_evaluated_count": len(offset_errors),
+        "timestamp_tv_mae_sec": tv_mae,
+        "timestamp_ta_mae_sec": ta_mae,
+        "timestamp_tv_median_sec": tv_median,
+        "timestamp_ta_median_sec": ta_median,
+        "timestamp_evaluated_tv": len(tv_errors),
+        "timestamp_evaluated_ta": len(ta_errors),
+        "parse_stats": {"json": json_parsed, "regex_fallback": regex_parsed, "gpt_judge": gpt_parsed},
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 60}")
+    print(f"  Eval Summary: {label}")
+    print(f"{'=' * 60}")
+    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["direction_accuracy_on_desync"] is not None:
+        print(f"  Direction Acc (desync):    {metrics['direction_accuracy_on_desync']:.1%}")
+    print(f"  ─── Per Category ───")
+    pc = metrics["per_category"]
+    if pc["synced_accuracy"] is not None:
+        print(f"    Synced correct:         {pc['synced_accuracy']:.1%}  ({pc['synced_count']} samples)")
+    if pc["delay_accuracy"] is not None:
+        print(f"    Delay correct:          {pc['delay_accuracy']:.1%}  ({pc['delay_count']} samples)")
+    if pc["early_accuracy"] is not None:
+        print(f"    Early correct:          {pc['early_accuracy']:.1%}  ({pc['early_count']} samples)")
+    print(f"  ─── Offset Estimation ───")
+    if metrics["offset_mae_sec"] is not None:
+        print(f"    MAE:                    {metrics['offset_mae_sec']:.3f}s")
+        print(f"    Median Error:           {metrics['offset_median_sec']:.3f}s")
+        print(f"    Within 0.5s:            {metrics['offset_within_0.5s']} / {metrics['offset_evaluated_count']}")
+        print(f"    Within 1.0s:            {metrics['offset_within_1.0s']} / {metrics['offset_evaluated_count']}")
+    else:
+        print(f"    (no valid offset predictions)")
+    print(f"  ─── Timestamp Estimation ───")
+    if metrics.get("timestamp_tv_mae_sec") is not None:
+        print(f"    t_v MAE:                {metrics['timestamp_tv_mae_sec']:.3f}s  ({metrics['timestamp_evaluated_tv']} samples)")
+        print(f"    t_v Median Error:       {metrics['timestamp_tv_median_sec']:.3f}s")
+    else:
+        print(f"    t_v: (no valid pairs)")
+    if metrics.get("timestamp_ta_mae_sec") is not None:
+        print(f"    t_a MAE:                {metrics['timestamp_ta_mae_sec']:.3f}s  ({metrics['timestamp_evaluated_ta']} samples)")
+        print(f"    t_a Median Error:       {metrics['timestamp_ta_median_sec']:.3f}s")
+    else:
+        print(f"    t_a: (no valid pairs)")
+    print(f"  ─── Parse Stats ───")
+    ps = metrics["parse_stats"]
+    print(f"    JSON parsed:            {ps['json']}")
+    print(f"    GPT judge:              {ps.get('gpt_judge', 0)}")
+    print(f"    Regex fallback:         {ps['regex_fallback']}")
+    print(f"{'=' * 60}")
+
+
+def main() -> None:
+    args = parse_args()
+    set_data_root(args.data_root)
+    test_jsonl = args.test_jsonl or (DATA_ROOT / "kto_training_data_v2_test.jsonl")
+    output_dir = args.output_dir or Path("/home/ubuntu/eval_results/sync")
+
+    if args.gpt_judge:
+        client = _get_openai_client(args.openai_api_key)
+        if client is None:
+            print("[ERROR] --gpt-judge requires OPENAI_API_KEY env var or --openai-api-key argument.")
+            raise SystemExit(1)
+        try:
+            test_resp = client.chat.completions.create(
+                model=args.gpt_model,
+                messages=[{"role": "user", "content": "Say OK"}],
+                max_completion_tokens=5,
+            )
+            print(f"[gpt-judge] API verified. Model: {args.gpt_model}")
+        except Exception as exc:
+            print(f"[ERROR] GPT API check failed: {exc}")
+            raise SystemExit(1)
+
+    label = args.label or (Path(args.adapter).name if args.adapter else Path(args.base_model).name)
+
+    out_dir = 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"
+
+    # Load data
+    test_data = load_test_data(test_jsonl, args.max_samples)
+    print(f"[data] Loaded {len(test_data)} test samples")
+
+    # Resume support
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["video"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    # Load model
+    model, processor = load_model(args.base_model, args.adapter)
+
+    # Inference loop
+    for item in tqdm(test_data, desc="Evaluating", unit="sample"):
+        if item["video"] in processed:
+            continue
+
+        if not os.path.exists(item["video_path"]):
+            print(f"  [skip] Video not found: {item['video_path']}")
+            continue
+
+        try:
+            raw_output = run_inference(
+                model, processor, item["video_path"], item["audio_path"],
+                args.max_new_tokens, args.temperature,
+            )
+        except Exception as exc:
+            import traceback
+            print(f"  [error] {item['video']}: {exc}")
+            traceback.print_exc()
+            raw_output = ""
+
+        if args.gpt_judge and raw_output:
+            gpt_pred = gpt_extract_prediction(
+                raw_output, api_key=args.openai_api_key, model=args.gpt_model,
+            )
+            if gpt_pred is not None:
+                pred = gpt_pred
+            else:
+                pred = extract_prediction(raw_output)
+        else:
+            pred = extract_prediction(raw_output)
+
+        result = {
+            "video": item["video"],
+            "video_path": item["video_path"],
+            "gt_synced": item["gt_synced"],
+            "gt_direction": item["gt_direction"],
+            "gt_offset_sec": item["gt_offset_sec"],
+            "gt_t_v": item["gt_t_v"],
+            "gt_t_a": item["gt_t_a"],
+            "pred_synced": pred["pred_synced"],
+            "pred_direction": pred["pred_direction"],
+            "pred_offset_sec": pred["pred_offset_sec"],
+            "pred_t_v": pred.get("pred_t_v"),
+            "pred_t_a": pred.get("pred_t_a"),
+            "pred_explanation": pred["pred_explanation"],
+            "parse_method": pred["parse_method"],
+            "raw_output": raw_output,
+        }
+
+        with open(results_jsonl, "a", encoding="utf-8") as f:
+            f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+        processed.add(item["video"])
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    # Load all results and compute metrics
+    all_results = []
+    with open(results_jsonl) as f:
+        for line in f:
+            all_results.append(json.loads(line))
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "data_root": str(args.data_root),
+        "test_jsonl": str(test_jsonl),
+        "total_test_samples": len(test_data),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+        "gpt_judge": args.gpt_judge,
+        "gpt_model": args.gpt_model if args.gpt_judge else None,
+    }
+
+    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 JSONL: {results_jsonl}")
+    print(f"[output] Metrics JSON:  {metrics_json}")
+    print(f"[output] Summary:       {summary_txt}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/eval_lvbench.py b/eval/eval_lvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ba703492cf8989b23d5d77dc58c9d27babe62e8
--- /dev/null
+++ b/eval/eval_lvbench.py
@@ -0,0 +1,647 @@
+#!/usr/bin/env python3
+"""
+Evaluate Qwen3-Omni models on the LVBench benchmark.
+
+LVBench: 1549 multiple-choice questions over 103 long videos.
+Metrics: accuracy (overall, per video type).
+
+Usage:
+  python eval_lvbench.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+    --video-dir /opt/dlami/nvme/lvbench \
+    --max-samples 30 --label vanilla_qwen3omni
+
+  python eval_lvbench.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/.../adapter \
+    --label dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/lvbench")
+DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/eval_results/lvbench")
+
+VIDEO_TYPES = ["cartoon", "documentary", "live", "selfmedia", "sport", "tv"]
+
+MCQ_PROMPT = (
+    "Select the best answer to the following multiple-choice question "
+    "based on the video. Respond with only the letter (A, B, C, or D) "
+    "of the correct option.\n"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Evaluate on LVBench benchmark.")
+    p.add_argument("--base-model", type=str,
+                    default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    p.add_argument("--max-samples", type=int, default=-1)
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--label", type=str, default=None)
+    p.add_argument("--vllm", action="store_true", default=False,
+                    help="Use vLLM offline batch inference instead of transformers (much faster).")
+    p.add_argument("--tp", type=int, default=None,
+                    help="Tensor parallel size for vLLM (default: all visible GPUs).")
+    p.add_argument("--batch-size", type=int, default=16,
+                    help="Batch size for vLLM generate().")
+    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()
+
+
+# ---------------------------------------------------------------------------
+# Model loading — identical to eval_videomme.py / eval_dpo_sync.py
+# ---------------------------------------------------------------------------
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = _json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = (
+            any(t.startswith("model.layers.") for t in target_modules)
+            and model_type != "qwen3_omni_moe_thinker"
+        )
+
+        if needs_remap:
+            print("[load] Adapter trained on thinker-only; remapping keys...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace(
+                                "base_model.model.model.layers.",
+                                "base_model.model.thinker.model.layers.",
+                            )
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+# ---------------------------------------------------------------------------
+# Inference
+# ---------------------------------------------------------------------------
+def run_inference(model, processor, video_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_lvb_")
+    masked_video = os.path.join(tmp_dir, "clip.mp4")
+    os.symlink(os.path.abspath(video_path), masked_video)
+
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": masked_video},
+                {"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=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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 preprocess_video_for_vllm(video_path: str):
+    """Extract video frames using qwen_omni_utils, return numpy array for vLLM.
+    Caps at 128 frames to stay within vLLM encoder cache (62720 tokens).
+    """
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "nframes": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    return video_np
+
+
+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 build_vllm_prompt(question: str) -> str:
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"<|vision_start|><|video_pad|><|vision_end|>"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    """Extract a single letter A/B/C/D from model output."""
+    text = text.strip()
+    prefixes = [
+        "The best answer is", "The correct answer is",
+        "The answer is", "The answer", "Best answer:", "Best option:",
+    ]
+    for prefix in prefixes:
+        text = text.replace(prefix, "")
+
+    if len(text.split()) > 10 and not re.search(r"[ABCD]", text):
+        return ""
+    m = re.search(r"[ABCD]", text)
+    return m[0] if m else ""
+
+
+# ---------------------------------------------------------------------------
+# Dataset loading
+# ---------------------------------------------------------------------------
+def load_lvbench(video_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    from datasets import load_dataset
+    ds = load_dataset("lmms-lab/LVBench", split="train")
+    data = []
+    skipped = 0
+    for row in ds:
+        vid = row["key"]
+        video_path = video_dir / f"{vid}.mp4"
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        prompt = MCQ_PROMPT + row["question"] + "\nThe best answer is:"
+
+        data.append({
+            "uid": row["uid"],
+            "video_id": vid,
+            "video_path": str(video_path),
+            "video_type": row["type"],
+            "question_type": row["question_type"],
+            "question": row["question"],
+            "gt_answer": row["answer"],
+            "time_reference": row.get("time_reference", ""),
+            "prompt": prompt,
+        })
+    if skipped:
+        print(f"[data] Skipped {skipped} questions (video not found)")
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Metrics
+# ---------------------------------------------------------------------------
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(1 for r in results if r["pred_answer"].upper() == r["gt_answer"].upper())
+    overall_acc = correct / total
+
+    def acc_for(items):
+        if not items:
+            return None
+        c = sum(1 for r in items if r["pred_answer"].upper() == r["gt_answer"].upper())
+        return round(c / len(items), 4)
+
+    per_type = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r["video_type"] == vt]
+        if subset:
+            per_type[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    q_types = set()
+    for r in results:
+        if isinstance(r.get("question_type"), list):
+            q_types.update(r["question_type"])
+        elif r.get("question_type"):
+            q_types.add(r["question_type"])
+
+    per_qtype = {}
+    for qt in sorted(q_types):
+        subset = [r for r in results if qt in (r.get("question_type", [])
+                  if isinstance(r.get("question_type"), list) else [r.get("question_type")])]
+        if subset:
+            per_qtype[qt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_video_type": per_type,
+        "per_question_type": per_qtype,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  LVBench Summary: {label}")
+    print(f"{'=' * 65}")
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+
+    print(f"  ─── Per Video Type ───")
+    for vt in VIDEO_TYPES:
+        if vt in metrics.get("per_video_type", {}):
+            d = metrics["per_video_type"][vt]
+            print(f"    {vt:15s}: {d['accuracy']:.1%}  ({d['count']} questions)")
+
+    print(f"  ─── Per Question Type ───")
+    for qt, d in sorted(metrics.get("per_question_type", {}).items()):
+        print(f"    {qt:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> None:
+    args = parse_args()
+    label = args.label or (
+        Path(args.adapter).name if args.adapter
+        else Path(args.base_model).name
+    )
+
+    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"
+
+    print("[data] Loading LVBench dataset...")
+    test_data = load_lvbench(args.video_dir, args.max_samples)
+    print(f"[data] {len(test_data)} questions ready for evaluation")
+
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["uid"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    use_vllm = args.vllm
+    model = processor = llm = None
+    vllm_preprocess_stats: Dict[str, int] | None = None
+
+    if use_vllm:
+        from vllm import LLM, SamplingParams
+        tp = args.tp or torch.cuda.device_count()
+        model_path = args.base_model
+        print(f"[vllm] Loading {model_path} with tp={tp} ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=args.max_model_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 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,
+        )
+
+        print("[vllm] Preprocessing videos ...")
+        todo = [item for item in test_data if item["uid"] not in processed]
+        preprocessed = {}
+        preprocess_failed_paths: set[str] = set()
+
+        for i, item in enumerate(todo):
+            vp = item["video_path"]
+            if vp in preprocessed or vp in preprocess_failed_paths:
+                continue
+            try:
+                preprocessed[vp] = preprocess_video_for_vllm(vp)
+            except Exception as e:
+                preprocess_failed_paths.add(vp)
+                print(f"  [skip] preprocess error: {Path(vp).name}: {e}")
+            if (i + 1) % 50 == 0:
+                print(f"  Preprocessed {i+1}/{len(todo)} ...")
+
+        n_pp_skip = sum(1 for item in todo if item["video_path"] in preprocess_failed_paths)
+        if preprocess_failed_paths:
+            print(
+                f"[vllm] Preprocess failed for {len(preprocess_failed_paths)} video(s), "
+                f"{n_pp_skip} question(s) will not use vLLM (run continues)."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        vllm_todo = [item for item in todo if item["video_path"] in preprocessed]
+        fallback_items = []
+        print(f"[vllm] {len(vllm_todo)} questions ready, running inference ...")
+
+        for i, item in enumerate(vllm_todo):
+            if item["uid"] in processed:
+                continue
+            inp = {
+                "prompt": build_vllm_prompt(item["prompt"]),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            try:
+                outputs = llm.generate([inp], sampling_params=sampling_params)
+                raw_output = outputs[0].outputs[0].text.strip()
+                pred = extract_answer(raw_output)
+                result = {
+                    "uid": item["uid"],
+                    "video_id": item["video_id"],
+                    "video_type": item["video_type"],
+                    "question_type": item["question_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["uid"])
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" in str(exc):
+                    print(f"  [too long] {item['uid']} -> fallback")
+                    fallback_items.append(item)
+                else:
+                    raise
+
+            if (i + 1) % 50 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] done, {len(fallback_items)} deferred")
+
+        preprocessed.clear()
+
+        vllm_results = []
+        if results_jsonl.exists():
+            with open(results_jsonl) as f:
+                for line in f:
+                    vllm_results.append(json.loads(line))
+        if vllm_results:
+            vllm_metrics = compute_metrics(vllm_results)
+            vllm_metrics_path = out_dir / "metrics_vllm.json"
+            with open(vllm_metrics_path, "w", encoding="utf-8") as f:
+                json.dump(vllm_metrics, f, indent=2, ensure_ascii=False)
+            print(f"[vllm] Intermediate metrics saved to {vllm_metrics_path}")
+            print_summary(vllm_metrics, label + " (vllm only)")
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} long-video questions 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
+                try:
+                    raw_output = run_inference(
+                        model, processor, item["video_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_answer(raw_output)
+                result = {
+                    "uid": item["uid"],
+                    "video_id": item["video_id"],
+                    "video_type": item["video_type"],
+                    "question_type": item["question_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                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:
+        print("[model] Loading model...")
+        model, processor = load_model(args.base_model, args.adapter)
+
+        for item in tqdm(test_data, desc="LVBench", unit="q"):
+            if item["uid"] in processed:
+                continue
+
+            try:
+                raw_output = run_inference(
+                    model, processor, item["video_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_answer(raw_output)
+
+            result = {
+                "uid": item["uid"],
+                "video_id": item["video_id"],
+                "video_type": item["video_type"],
+                "question_type": item["question_type"],
+                "gt_answer": item["gt_answer"],
+                "pred_answer": pred,
+                "correct": pred.upper() == item["gt_answer"].upper(),
+                "raw_output": raw_output,
+            }
+
+            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()
+
+    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 to compute metrics from.")
+        return
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": str(args.video_dir),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+    }
+    if vllm_preprocess_stats is not None:
+        metrics["eval_config"]["vllm_preprocess_skips"] = vllm_preprocess_stats
+
+    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}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/eval/eval_videomme.py b/eval/eval_videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..f92fac97edbc50b8acde792c385aeb860a050e18
--- /dev/null
+++ b/eval/eval_videomme.py
@@ -0,0 +1,679 @@
+#!/usr/bin/env python3
+"""
+Evaluate Qwen3-Omni models on the Video-MME benchmark.
+
+Video-MME: 2700 multiple-choice questions over 900 YouTube videos.
+Metrics: accuracy (overall, per-duration, per-domain, per-task-type).
+
+Usage:
+  python eval_videomme.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+    --video-dir /opt/dlami/nvme/videomme/data/data \
+    --max-samples 30 --label vanilla_qwen3omni
+
+  python eval_videomme.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/.../adapter \
+    --label dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/videomme/data/data")
+DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/eval_results/videomme")
+
+VIDEO_TYPES = ["short", "medium", "long"]
+CATEGORIES = [
+    "Knowledge", "Film & Television", "Sports Competition",
+    "Artistic Performance", "Life Record", "Multilingual",
+]
+TASK_CATEGORIES = [
+    "Temporal Perception", "Spatial Perception", "Attribute Perception",
+    "Action Recognition", "Object Recognition", "OCR Problems",
+    "Counting Problem", "Temporal Reasoning", "Spatial Reasoning",
+    "Action Reasoning", "Object Reasoning", "Information Synopsis",
+]
+
+MCQ_PROMPT = (
+    "Select the best answer to the following multiple-choice question "
+    "based on the video. Respond with only the letter (A, B, C, or D) "
+    "of the correct option.\n"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Evaluate on Video-MME benchmark.")
+    p.add_argument("--base-model", type=str,
+                    default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    p.add_argument("--max-samples", type=int, default=-1)
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--label", type=str, default=None)
+    p.add_argument("--vllm", action="store_true", default=False,
+                    help="Use vLLM offline batch inference instead of transformers (much faster).")
+    p.add_argument("--tp", type=int, default=None,
+                    help="Tensor parallel size for vLLM (default: all visible GPUs).")
+    p.add_argument("--batch-size", type=int, default=32,
+                    help="Batch size for vLLM generate().")
+    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()
+
+
+# ---------------------------------------------------------------------------
+# Model loading — reused from eval_dpo_sync.py
+# ---------------------------------------------------------------------------
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = _json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = (
+            any(t.startswith("model.layers.") for t in target_modules)
+            and model_type != "qwen3_omni_moe_thinker"
+        )
+
+        if needs_remap:
+            print("[load] Adapter trained on thinker-only; remapping keys...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace(
+                                "base_model.model.model.layers.",
+                                "base_model.model.thinker.model.layers.",
+                            )
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+# ---------------------------------------------------------------------------
+# Inference
+# ---------------------------------------------------------------------------
+def run_inference(model, processor, video_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_vmme_")
+    masked_video = os.path.join(tmp_dir, "clip.mp4")
+    os.symlink(os.path.abspath(video_path), masked_video)
+
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": masked_video},
+                {"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=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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 preprocess_video_for_vllm(video_path: str):
+    """Extract video frames using qwen_omni_utils, return numpy array for vLLM.
+    Caps at 128 frames to stay within vLLM encoder cache (62720 tokens).
+    """
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "nframes": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    return video_np
+
+
+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 build_vllm_prompt(question: str) -> str:
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"<|vision_start|><|video_pad|><|vision_end|>"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    """Extract a single letter A/B/C/D from model output."""
+    text = text.strip()
+    prefixes = [
+        "The best answer is", "The correct answer is",
+        "The answer is", "The answer", "Best answer:", "Best option:",
+    ]
+    for prefix in prefixes:
+        text = text.replace(prefix, "")
+
+    if len(text.split()) > 10 and not re.search(r"[ABCD]", text):
+        return ""
+    m = re.search(r"[ABCD]", text)
+    return m[0] if m else ""
+
+
+# ---------------------------------------------------------------------------
+# Dataset loading
+# ---------------------------------------------------------------------------
+def load_videomme(video_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    from datasets import load_dataset
+    ds = load_dataset("lmms-lab/Video-MME", split="test")
+    data = []
+    skipped = 0
+    for row in ds:
+        vid = row["videoID"]
+        video_path = video_dir / f"{vid}.mp4"
+        if not video_path.exists():
+            for ext in [".MP4", ".mkv"]:
+                alt = video_dir / f"{vid}{ext}"
+                if alt.exists():
+                    video_path = alt
+                    break
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        options_text = "\n".join(row["options"])
+        prompt = MCQ_PROMPT + row["question"] + "\n" + options_text + "\nThe best answer is:"
+
+        data.append({
+            "question_id": row["question_id"],
+            "video_id": vid,
+            "video_path": str(video_path),
+            "duration": row["duration"],
+            "domain": row["domain"],
+            "sub_category": row["sub_category"],
+            "task_type": row["task_type"],
+            "question": row["question"],
+            "options": row["options"],
+            "gt_answer": row["answer"],
+            "prompt": prompt,
+        })
+    if skipped:
+        print(f"[data] Skipped {skipped} questions (video not found)")
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Metrics
+# ---------------------------------------------------------------------------
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(1 for r in results if r["pred_answer"].upper() == r["gt_answer"].upper())
+    overall_acc = correct / total
+
+    def acc_for(items):
+        if not items:
+            return None
+        c = sum(1 for r in items if r["pred_answer"].upper() == r["gt_answer"].upper())
+        return round(c / len(items), 4)
+
+    per_duration = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r["duration"] == vt]
+        if subset:
+            per_duration[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_domain = {}
+    for cat in CATEGORIES:
+        subset = [r for r in results if r["domain"] == cat]
+        if subset:
+            per_domain[cat] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task = {}
+    for task in TASK_CATEGORIES:
+        subset = [r for r in results if r["task_type"] == task]
+        if subset:
+            per_task[task] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_duration": per_duration,
+        "per_domain": per_domain,
+        "per_task_type": per_task,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  Video-MME Summary: {label}")
+    print(f"{'=' * 65}")
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+
+    print(f"  ─── Per Duration ───")
+    for vt in VIDEO_TYPES:
+        if vt in metrics["per_duration"]:
+            d = metrics["per_duration"][vt]
+            print(f"    {vt:8s}:  {d['accuracy']:.1%}  ({d['count']} questions)")
+
+    print(f"  ─── Per Domain ───")
+    for cat in CATEGORIES:
+        if cat in metrics["per_domain"]:
+            d = metrics["per_domain"][cat]
+            print(f"    {cat:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Task Type ───")
+    for task in TASK_CATEGORIES:
+        if task in metrics["per_task_type"]:
+            d = metrics["per_task_type"][task]
+            print(f"    {task:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> None:
+    args = parse_args()
+    label = args.label or (
+        Path(args.adapter).name if args.adapter
+        else Path(args.base_model).name
+    )
+
+    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"
+
+    print("[data] Loading Video-MME dataset...")
+    test_data = load_videomme(args.video_dir, args.max_samples)
+    print(f"[data] {len(test_data)} questions ready for evaluation")
+
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["question_id"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    use_vllm = args.vllm
+    model = processor = llm = None
+    vllm_preprocess_stats: Dict[str, int] | None = None
+
+    if use_vllm:
+        from vllm import LLM, SamplingParams
+        tp = args.tp or torch.cuda.device_count()
+        model_path = args.base_model
+        print(f"[vllm] Loading {model_path} with tp={tp} ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=args.max_model_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 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,
+        )
+
+        print("[vllm] Preprocessing videos ...")
+        todo = [item for item in test_data if item["question_id"] not in processed]
+        preprocessed = {}
+        preprocess_failed_paths: set[str] = set()
+
+        for i, item in enumerate(todo):
+            vp = item["video_path"]
+            if vp in preprocessed or vp in preprocess_failed_paths:
+                continue
+            try:
+                preprocessed[vp] = preprocess_video_for_vllm(vp)
+            except Exception as e:
+                preprocess_failed_paths.add(vp)
+                print(f"  [skip] preprocess error: {Path(vp).name}: {e}")
+            if (i + 1) % 100 == 0:
+                print(f"  Preprocessed {i+1}/{len(todo)} ...")
+
+        n_pp_skip = sum(1 for item in todo if item["video_path"] in preprocess_failed_paths)
+        if preprocess_failed_paths:
+            print(
+                f"[vllm] Preprocess failed for {len(preprocess_failed_paths)} video(s), "
+                f"{n_pp_skip} question(s) will not use vLLM (run continues)."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        vllm_todo = [item for item in todo if item["video_path"] in preprocessed]
+        fallback_items = []
+        print(f"[vllm] {len(vllm_todo)} questions ready, running inference ...")
+
+        for i, item in enumerate(vllm_todo):
+            if item["question_id"] in processed:
+                continue
+            inp = {
+                "prompt": build_vllm_prompt(item["prompt"]),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            try:
+                outputs = llm.generate([inp], sampling_params=sampling_params)
+                raw_output = outputs[0].outputs[0].text.strip()
+                pred = extract_answer(raw_output)
+                result = {
+                    "question_id": item["question_id"],
+                    "video_id": item["video_id"],
+                    "duration": item["duration"],
+                    "domain": item["domain"],
+                    "sub_category": item["sub_category"],
+                    "task_type": item["task_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["question_id"])
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" in str(exc):
+                    print(f"  [too long] {item['question_id']} -> fallback")
+                    fallback_items.append(item)
+                else:
+                    raise
+
+            if (i + 1) % 100 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] done, {len(fallback_items)} deferred")
+
+        preprocessed.clear()
+
+        vllm_results = []
+        if results_jsonl.exists():
+            with open(results_jsonl) as f:
+                for line in f:
+                    vllm_results.append(json.loads(line))
+        if vllm_results:
+            vllm_metrics = compute_metrics(vllm_results)
+            vllm_metrics_path = out_dir / "metrics_vllm.json"
+            with open(vllm_metrics_path, "w", encoding="utf-8") as f:
+                json.dump(vllm_metrics, f, indent=2, ensure_ascii=False)
+            print(f"[vllm] Intermediate metrics saved to {vllm_metrics_path}")
+            print_summary(vllm_metrics, label + " (vllm only)")
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} long-video questions 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["question_id"] in processed:
+                    continue
+                try:
+                    raw_output = run_inference(
+                        model, processor, item["video_path"], item["prompt"],
+                        args.max_new_tokens, args.temperature,
+                    )
+                except Exception as exc:
+                    import traceback
+                    print(f"  [error] {item['question_id']}: {exc}")
+                    traceback.print_exc()
+                    raw_output = ""
+
+                pred = extract_answer(raw_output)
+                result = {
+                    "question_id": item["question_id"],
+                    "video_id": item["video_id"],
+                    "duration": item["duration"],
+                    "domain": item["domain"],
+                    "sub_category": item["sub_category"],
+                    "task_type": item["task_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["question_id"])
+                gc.collect()
+                torch.cuda.empty_cache()
+
+    else:
+        print("[model] Loading model...")
+        model, processor = load_model(args.base_model, args.adapter)
+
+        for item in tqdm(test_data, desc="Video-MME", unit="q"):
+            if item["question_id"] in processed:
+                continue
+
+            try:
+                raw_output = run_inference(
+                    model, processor, item["video_path"], item["prompt"],
+                    args.max_new_tokens, args.temperature,
+                )
+            except Exception as exc:
+                import traceback
+                print(f"  [error] {item['question_id']}: {exc}")
+                traceback.print_exc()
+                raw_output = ""
+
+            pred = extract_answer(raw_output)
+
+            result = {
+                "question_id": item["question_id"],
+                "video_id": item["video_id"],
+                "duration": item["duration"],
+                "domain": item["domain"],
+                "sub_category": item["sub_category"],
+                "task_type": item["task_type"],
+                "gt_answer": item["gt_answer"],
+                "pred_answer": pred,
+                "correct": pred.upper() == item["gt_answer"].upper(),
+                "raw_output": raw_output,
+            }
+
+            with open(results_jsonl, "a", encoding="utf-8") as f:
+                f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+            processed.add(item["question_id"])
+            gc.collect()
+            torch.cuda.empty_cache()
+
+    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 to compute metrics from.")
+        return
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": str(args.video_dir),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+    }
+    if vllm_preprocess_stats is not None:
+        metrics["eval_config"]["vllm_preprocess_skips"] = vllm_preprocess_stats
+
+    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}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/finevideo/download_finevideo_subset.py b/finevideo/download_finevideo_subset.py
new file mode 100644
index 0000000000000000000000000000000000000000..61a3298f1c9e4e390513e9f4c6f228f9659b813f
--- /dev/null
+++ b/finevideo/download_finevideo_subset.py
@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""
+Download only the filtered FineVideo subset (videos) from HuggingFace.
+
+Reads the candidate JSONL from filter_finevideo.py, then streams FineVideo
+and saves only matching videos to disk.
+
+**Resume:** Re-run the **same command** after Ctrl+C: already-downloaded, non-empty
+``finevideo_*.mp4`` files are skipped; only missing targets are streamed again.
+Writes are atomic (``*.mp4.part`` then rename) so interrupted downloads are not mistaken
+for complete files.
+
+With --max-videos N and more than N candidates in the file, subsampling uses the same
+stratified_sample as filter_finevideo.py (by content_parent_category, seed-controlled).
+
+Usage:
+  python download_finevideo_subset.py
+  python download_finevideo_subset.py --candidates /opt/dlami/nvme/finevideo/filtered_candidates.jsonl
+  python download_finevideo_subset.py --max-videos 5000
+  python download_finevideo_subset.py --max-videos 500 --no-stratify   # first N in file order
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+from pathlib import Path
+
+from tqdm import tqdm
+
+# Same order-of-magnitude as filter_finevideo (full train split)
+FINEVIDEO_ROW_ESTIMATE = 43_751
+
+
+def _stratified_sample(candidates: list[dict], target: int, seed: int) -> list[dict]:
+    """Same logic as filter_finevideo.stratified_sample (by content_parent_category)."""
+    if target <= 0 or len(candidates) <= target:
+        return candidates
+
+    rng = random.Random(seed)
+    by_cat: dict[str, list[dict]] = {}
+    for c in candidates:
+        cat = c.get("content_parent_category", "Other")
+        by_cat.setdefault(cat, []).append(c)
+
+    per_cat = max(1, target // len(by_cat))
+    selected: list[dict] = []
+    remainder: list[dict] = []
+    for cat, items in by_cat.items():
+        rng.shuffle(items)
+        selected.extend(items[:per_cat])
+        remainder.extend(items[per_cat:])
+
+    if len(selected) < target:
+        rng.shuffle(remainder)
+        selected.extend(remainder[: target - len(selected)])
+
+    return selected[:target]
+
+DEFAULT_CANDIDATES = Path("/opt/dlami/nvme/finevideo/filtered_candidates.jsonl")
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/finevideo/videos")
+
+
+def _video_path(video_dir: Path, idx: int) -> Path:
+    return video_dir / f"finevideo_{idx:06d}.mp4"
+
+
+def _part_path(video_path: Path) -> Path:
+    return video_path.parent / f"{video_path.stem}.mp4.part"
+
+
+def _is_complete_mp4(path: Path, min_bytes: int) -> bool:
+    try:
+        return path.is_file() and path.stat().st_size >= min_bytes
+    except OSError:
+        return False
+
+
+def _stems_complete_on_disk(video_dir: Path, min_bytes: int) -> set[str]:
+    """Stems finevideo_XXXXXX with a non-empty (>= min_bytes) mp4."""
+    stems: set[str] = set()
+    for p in video_dir.glob("finevideo_*.mp4"):
+        if _is_complete_mp4(p, min_bytes):
+            stems.add(p.stem)
+    return stems
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Download filtered FineVideo videos.")
+    p.add_argument("--candidates", type=Path, default=DEFAULT_CANDIDATES)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--max-videos", type=int, default=0,
+                   help="Cap downloads. If the file has more candidates, subsample to N: by default "
+                   "**stratified by content_parent_category** (same as filter_finevideo). "
+                   "0 = use every line in the file.")
+    p.add_argument("--seed", type=int, default=42, help="RNG seed for stratified --max-videos.")
+    p.add_argument(
+        "--no-stratify",
+        action="store_true",
+        help="With --max-videos, take the first N unique candidates in JSONL order instead of stratified sampling.",
+    )
+    p.add_argument("--no-tqdm", action="store_true", help="Disable progress bar while streaming the dataset.")
+    p.add_argument(
+        "--min-mp4-bytes",
+        type=int,
+        default=1024,
+        help="Treat existing mp4 as downloaded only if size >= this (avoids empty/corrupt stubs).",
+    )
+    p.add_argument(
+        "--force-redownload",
+        action="store_true",
+        help="Ignore existing mp4 files and overwrite (default: skip complete files = resume).",
+    )
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.video_dir.mkdir(parents=True, exist_ok=True)
+
+    candidates: list[dict] = []
+    with open(args.candidates, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                candidates.append(json.loads(line))
+
+    # Dedupe by finevideo_idx, keep first occurrence (JSONL order).
+    seen_idx: set[int] = set()
+    uniq: list[dict] = []
+    for c in candidates:
+        idx = c["finevideo_idx"]
+        if idx in seen_idx:
+            continue
+        seen_idx.add(idx)
+        uniq.append(c)
+    candidates = uniq
+
+    n_in = len(candidates)
+    if args.max_videos > 0 and n_in > args.max_videos:
+        if args.no_stratify:
+            candidates = candidates[: args.max_videos]
+            print(f"[sample] First {args.max_videos} candidates in file order (of {n_in} unique).")
+        else:
+            candidates = _stratified_sample(candidates, args.max_videos, args.seed)
+            print(
+                f"[sample] Stratified subsample {len(candidates)} from {n_in} unique "
+                f"(content_parent_category, seed={args.seed})."
+            )
+
+    target_indices = {c["finevideo_idx"] for c in candidates}
+
+    if args.force_redownload:
+        complete_stems: set[str] = set()
+    else:
+        complete_stems = _stems_complete_on_disk(args.video_dir, args.min_mp4_bytes)
+
+    needed_indices = {
+        idx for idx in target_indices
+        if args.force_redownload or f"finevideo_{idx:06d}" not in complete_stems
+    }
+    n_have = len(target_indices) - len(needed_indices)
+
+    if not needed_indices:
+        print(f"[skip] All {len(target_indices)} target videos already complete in {args.video_dir} "
+              f"(>= {args.min_mp4_bytes} bytes each).")
+        return
+
+    print(
+        f"[resume] {n_have} of {len(target_indices)} targets already on disk (complete); "
+        f"{len(needed_indices)} left to fetch."
+    )
+    print("[download] Streaming dataset until those indices are filled ...")
+    print(
+        "[note] Streaming is sequential (row 0,1,2,...); there is no random access to finevideo_idx. "
+        f"The tqdm total ~{FINEVIDEO_ROW_ESTIMATE} counts rows scanned through the train split, "
+        f"not how many files you download. Only {len(needed_indices)} mp4(s) will be written; "
+        "if your indices are near the end you still must stream up to those rows."
+    )
+
+    from datasets import load_dataset
+
+    ds = load_dataset("HuggingFaceFV/finevideo", split="train", streaming=True)
+
+    row_iter = ds
+    pbar = None
+    if not args.no_tqdm:
+        pbar = tqdm(
+            ds,
+            total=FINEVIDEO_ROW_ESTIMATE,
+            desc="Scan rows (sequential)",
+            unit="row",
+            dynamic_ncols=True,
+        )
+        row_iter = pbar
+
+    downloaded = 0
+    skipped_existing = 0
+    n_need_start = len(needed_indices)
+    for idx, sample in enumerate(row_iter):
+        if pbar is not None and (idx % 4000 == 0 or idx in needed_indices):
+            pbar.set_postfix_str(
+                f"row={idx} new_files={downloaded}/{n_need_start} todo_idx={len(needed_indices)}"
+            )
+
+        if idx not in needed_indices:
+            continue
+
+        video_path = _video_path(args.video_dir, idx)
+
+        if not args.force_redownload and _is_complete_mp4(video_path, args.min_mp4_bytes):
+            skipped_existing += 1
+            needed_indices.discard(idx)
+            if not needed_indices:
+                break
+            continue
+
+        mp4_data = sample.get("mp4")
+        if mp4_data is None:
+            print(f"  [warn] idx={idx} has no mp4 data, skipping.")
+            needed_indices.discard(idx)
+            if not needed_indices:
+                break
+            continue
+
+        part_path = _part_path(video_path)
+        try:
+            part_path.unlink(missing_ok=True)
+            with open(part_path, "wb") as f:
+                f.write(mp4_data)
+            os.replace(part_path, video_path)
+        except Exception:
+            part_path.unlink(missing_ok=True)
+            raise
+
+        downloaded += 1
+        needed_indices.discard(idx)
+
+        if pbar is None and downloaded % 100 == 0:
+            print(f"  Downloaded {downloaded} / {n_need_start} ...")
+
+        if not needed_indices:
+            break
+
+    print(f"\n[done] Downloaded {downloaded} new videos to {args.video_dir}")
+    print(f"  Already on disk: {skipped_existing}")
+    total_on_disk = sum(1 for _ in args.video_dir.glob("*.mp4"))
+    print(f"  Total videos on disk: {total_on_disk}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/finevideo/extract_audio_finevideo.py b/finevideo/extract_audio_finevideo.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f4293efc2450e830a179a67c39cafa4cc746659
--- /dev/null
+++ b/finevideo/extract_audio_finevideo.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""
+Extract audio (.wav) from downloaded FineVideo .mp4 files using ffmpeg.
+
+Usage:
+  python extract_audio_finevideo.py
+  python extract_audio_finevideo.py --video-dir /opt/dlami/nvme/finevideo/videos --audio-dir /opt/dlami/nvme/finevideo/audio
+  python extract_audio_finevideo.py --sample-rate 16000
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/finevideo/videos")
+DEFAULT_AUDIO_DIR = Path("/opt/dlami/nvme/finevideo/audio")
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Extract audio from FineVideo mp4s.")
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--audio-dir", type=Path, default=DEFAULT_AUDIO_DIR)
+    p.add_argument("--sample-rate", type=int, default=16000)
+    p.add_argument("--workers", type=int, default=8)
+    return p.parse_args()
+
+
+def extract_one(mp4: Path, wav: Path, sr: int) -> tuple[str, bool, str]:
+    if wav.exists():
+        return (mp4.name, True, "exists")
+    try:
+        subprocess.run(
+            [
+                "ffmpeg", "-y", "-i", str(mp4),
+                "-vn", "-acodec", "pcm_s16le",
+                "-ar", str(sr), "-ac", "1",
+                str(wav),
+            ],
+            capture_output=True, timeout=120,
+            check=True,
+        )
+        return (mp4.name, True, "ok")
+    except subprocess.CalledProcessError as e:
+        return (mp4.name, False, e.stderr.decode(errors="replace")[:200])
+    except subprocess.TimeoutExpired:
+        return (mp4.name, False, "timeout")
+
+
+def main() -> None:
+    args = parse_args()
+    args.audio_dir.mkdir(parents=True, exist_ok=True)
+
+    mp4s = sorted(args.video_dir.glob("*.mp4"))
+    if not mp4s:
+        print(f"[warn] No .mp4 files found in {args.video_dir}")
+        return
+
+    existing = sum(1 for mp4 in mp4s if (args.audio_dir / mp4.with_suffix(".wav").name).exists())
+    todo = [(mp4, args.audio_dir / mp4.with_suffix(".wav").name) for mp4 in mp4s
+            if not (args.audio_dir / mp4.with_suffix(".wav").name).exists()]
+
+    print(f"[extract] {len(mp4s)} videos, {existing} already extracted, {len(todo)} to process")
+
+    if not todo:
+        print("[skip] All audio already extracted.")
+        return
+
+    ok = 0
+    fail = 0
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {
+            pool.submit(extract_one, mp4, wav, args.sample_rate): mp4.name
+            for mp4, wav in todo
+        }
+        for i, future in enumerate(as_completed(futures), 1):
+            name, success, msg = future.result()
+            if success:
+                ok += 1
+            else:
+                fail += 1
+                print(f"  [fail] {name}: {msg}")
+            if i % 500 == 0:
+                print(f"  Processed {i}/{len(todo)} (ok={ok}, fail={fail})")
+
+    print(f"\n[done] Extracted {ok} new, {fail} failed, {existing} pre-existing")
+    total = sum(1 for _ in args.audio_dir.glob("*.wav"))
+    print(f"  Total .wav on disk: {total}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/finevideo/filter_finevideo.py b/finevideo/filter_finevideo.py
new file mode 100644
index 0000000000000000000000000000000000000000..3502c7e69691802d0e8756d3351ea72d0ead4e64
--- /dev/null
+++ b/finevideo/filter_finevideo.py
@@ -0,0 +1,431 @@
+#!/usr/bin/env python3
+"""
+Filter FineVideo metadata to select high-quality candidates for temporal grounding training.
+
+Streams or locally scans FineVideo parquet metadata (no video download), applies quality filters,
+and outputs a JSONL of selected video IDs + extracted metadata for downstream use.
+
+Speed: **default is streaming** (no full-dataset download; one sequential pass over ~44k rows).
+Use `--local-cache` only if you accept downloading/materializing the **entire** train split first
+(that step alone can take hours on a slow link); it can speed later **re-scans** if the cache
+is already on disk. `--num-proc` only applies with `--local-cache`.
+
+Checkpoint: by default each passing row is appended to <output_stem>_all_passing.jsonl as soon
+as it passes (flushed). That file holds **every** row that passes filters during the scan — it is
+**not** capped by --target-count until the scan ends (target-count only trims the final output
+after a full pass). Use --early-stop to stop scanning once you have enough passers.
+
+Filters:
+  - audioVisualCorrelation >= threshold in at least one scene
+  - duration_seconds between min and max
+  - >= min_scenes scenes with activities
+
+Usage:
+  python filter_finevideo.py
+  python filter_finevideo.py --min-avc 0.6 --max-duration 240 --target-count 8000
+  python filter_finevideo.py --output /opt/dlami/nvme/finevideo/filtered_candidates.jsonl
+  python filter_finevideo.py --target-count 1000 --early-stop
+  python filter_finevideo.py --sample-from /path/filtered_candidates_all_passing.jsonl
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+from collections import Counter
+from pathlib import Path
+
+from tqdm import tqdm
+
+# FineVideo dataset card: ~43,751 videos (used as tqdm total for streaming)
+FINEVIDEO_ROW_ESTIMATE = 43_751
+
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/finevideo/filtered_candidates.jsonl")
+
+
+def passing_checkpoint_path(output: Path) -> Path:
+    """Sidecar JSONL: every row that passes filters (before stratified sampling)."""
+    return output.parent / f"{output.stem}_all_passing.jsonl"
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Filter FineVideo for temporal grounding training.")
+    p.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+    p.add_argument("--min-avc", type=float, default=0.7,
+                   help="Minimum audioVisualCorrelation in at least one scene.")
+    p.add_argument("--min-duration", type=int, default=30)
+    p.add_argument("--max-duration", type=int, default=180)
+    p.add_argument("--min-scenes", type=int, default=4,
+                   help="Minimum number of scenes with activities.")
+    p.add_argument("--target-count", type=int, default=10000,
+                   help="Cap on final JSONL size: after a **full** dataset scan, stratified sample down "
+                   "to this many (0=keep all passing). Does not stop the scan early unless --early-stop.")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--no-tqdm", action="store_true", help="Disable progress bar.")
+    p.add_argument(
+        "--local-cache",
+        action="store_true",
+        help="Non-streaming load: downloads/materializes the FULL train split into the HF cache first "
+        "(can take many hours), then scans locally. Use only if that full download is acceptable "
+        "or the cache is already populated.",
+    )
+    p.add_argument(
+        "--no-checkpoint",
+        action="store_true",
+        help="Do not write incremental *_all_passing.jsonl (only write final output at end).",
+    )
+    p.add_argument(
+        "--checkpoint-flush-every",
+        type=int,
+        default=1,
+        help="Flush passing-checkpoint file every N rows (1 = durable; larger = faster).",
+    )
+    p.add_argument(
+        "--sample-from",
+        type=Path,
+        default=None,
+        help="Skip HuggingFace scan: load this JSONL, apply stratified sampling, write --output.",
+    )
+    p.add_argument(
+        "--num-proc",
+        type=int,
+        default=1,
+        help="Parallel workers for filter+extract (datasets.map). Only effective with --local-cache; "
+        "streaming stays single-threaded. Use 0 for all logical CPUs.",
+    )
+    p.add_argument(
+        "--early-stop",
+        action="store_true",
+        help="Stop as soon as --target-count rows have passed filters (streaming / single-threaded "
+        "scan only). *_all_passing.jsonl will have at most that many lines; skips full-dataset "
+        "stratified sampling (order follows dataset stream, not global category balance).",
+    )
+    args = p.parse_args()
+    if args.early_stop and args.target_count <= 0:
+        raise SystemExit("[error] --early-stop requires --target-count > 0")
+    return args
+
+
+def passes_filter(meta: dict, args: argparse.Namespace) -> bool:
+    duration = meta.get("duration_seconds", 0)
+    if not (args.min_duration <= duration <= args.max_duration):
+        return False
+
+    cm = meta.get("content_metadata")
+    if not cm or not isinstance(cm, dict):
+        return False
+
+    scenes = cm.get("scenes", [])
+    if not scenes:
+        return False
+
+    scenes_with_activities = sum(
+        1 for s in scenes
+        if s.get("activities") and len(s["activities"]) >= 1
+    )
+    if scenes_with_activities < args.min_scenes:
+        return False
+
+    max_avc = max(
+        (s.get("audioVisualCorrelation", 0.0) for s in scenes),
+        default=0.0,
+    )
+    if max_avc < args.min_avc:
+        return False
+
+    return True
+
+
+def extract_candidate(meta: dict, idx: int) -> dict:
+    """Extract the fields we need downstream from FineVideo metadata."""
+    cm = meta.get("content_metadata", {})
+    scenes = cm.get("scenes", [])
+
+    scene_summaries = []
+    for s in scenes:
+        avc = s.get("audioVisualCorrelation", 0.0)
+        activities = s.get("activities", [])
+        scene_summaries.append({
+            "sceneId": s.get("sceneId"),
+            "title": s.get("title", ""),
+            "start": s.get("timestamps", {}).get("start_timestamp"),
+            "end": s.get("timestamps", {}).get("end_timestamp"),
+            "audioVisualCorrelation": avc,
+            "activities": [
+                {
+                    "description": a.get("description", ""),
+                    "start": a.get("timestamp", {}).get("start_timestamp"),
+                    "end": a.get("timestamp", {}).get("end_timestamp"),
+                }
+                for a in activities
+            ],
+            "mood": s.get("mood", {}).get("description", ""),
+        })
+
+    tts = meta.get("timecoded_text_to_speech", [])
+    tts_summary = []
+    if isinstance(tts, list):
+        for seg in tts[:50]:
+            tts_summary.append({
+                "start": seg.get("start"),
+                "end": seg.get("end"),
+                "text": seg.get("text", ""),
+            })
+
+    return {
+        "finevideo_idx": idx,
+        "duration_seconds": meta.get("duration_seconds", 0),
+        "content_parent_category": meta.get("content_parent_category", ""),
+        "content_fine_category": meta.get("content_fine_category", ""),
+        "youtube_title": meta.get("youtube_title", ""),
+        "title": cm.get("title", ""),
+        "description": cm.get("description", ""),
+        "scenes": scene_summaries,
+        "timecoded_text_to_speech": tts_summary,
+        "qa": cm.get("qAndA", []),
+        "fps": cm.get("fps"),
+    }
+
+
+def _map_row_parallel(
+    example: dict,
+    idx: int,
+    *,
+    min_avc: float,
+    min_duration: int,
+    max_duration: int,
+    min_scenes: int,
+) -> dict:
+    """Top-level for multiprocessing; returns only _cand_jsonl (non-empty if passed)."""
+    ns = argparse.Namespace(
+        min_avc=min_avc,
+        min_duration=min_duration,
+        max_duration=max_duration,
+        min_scenes=min_scenes,
+    )
+    meta = example.get("json")
+    if not meta or not isinstance(meta, dict):
+        return {"_cand_jsonl": ""}
+    if not passes_filter(meta, ns):
+        return {"_cand_jsonl": ""}
+    cand = extract_candidate(meta, idx)
+    return {"_cand_jsonl": json.dumps(cand, ensure_ascii=False)}
+
+
+def _row_has_candidate(row: dict) -> bool:
+    return bool(row.get("_cand_jsonl"))
+
+
+def stratified_sample(candidates: list[dict], target: int, seed: int) -> list[dict]:
+    """Sample up to target candidates, stratified by content_parent_category."""
+    if target <= 0 or len(candidates) <= target:
+        return candidates
+
+    rng = random.Random(seed)
+    by_cat: dict[str, list[dict]] = {}
+    for c in candidates:
+        cat = c.get("content_parent_category", "Other")
+        by_cat.setdefault(cat, []).append(c)
+
+    per_cat = max(1, target // len(by_cat))
+    selected = []
+    remainder = []
+    for cat, items in by_cat.items():
+        rng.shuffle(items)
+        selected.extend(items[:per_cat])
+        remainder.extend(items[per_cat:])
+
+    if len(selected) < target:
+        rng.shuffle(remainder)
+        selected.extend(remainder[: target - len(selected)])
+
+    return selected[:target]
+
+
+def load_candidates_from_jsonl(path: Path) -> list[dict]:
+    rows: list[dict] = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    return rows
+
+
+def write_final_output(candidates: list[dict], output: Path) -> None:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with open(output, "w", encoding="utf-8") as f:
+        for c in candidates:
+            f.write(json.dumps(c, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    args = parse_args()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+
+    if args.sample_from is not None:
+        src = args.sample_from.expanduser().resolve()
+        if not src.is_file():
+            raise SystemExit(f"[error] --sample-from not found: {src}")
+        print(f"[sample-from] Loading {src} ...")
+        candidates = load_candidates_from_jsonl(src)
+        print(f"[sample-from] Loaded {len(candidates)} rows.")
+        if args.target_count > 0 and len(candidates) > args.target_count:
+            print(f"[sample] Stratified sampling {args.target_count} from {len(candidates)} ...")
+            candidates = stratified_sample(candidates, args.target_count, args.seed)
+        write_final_output(candidates, args.output)
+        print(f"\n[output] {len(candidates)} candidates written to {args.output}")
+        final_cats = Counter(c["content_parent_category"] for c in candidates)
+        print("  Category distribution:")
+        for cat, count in final_cats.most_common(20):
+            print(f"    {cat:30s}: {count}")
+        return
+
+    from datasets import load_dataset
+
+    ck_path = passing_checkpoint_path(args.output)
+    use_ck = not args.no_checkpoint
+    if use_ck:
+        print(f"[checkpoint] Passing rows -> {ck_path} (flush every {args.checkpoint_flush_every})")
+
+    print(f"[filter] min_avc={args.min_avc}, duration={args.min_duration}-{args.max_duration}s, "
+          f"min_scenes={args.min_scenes}")
+    num_proc = args.num_proc
+    if num_proc == 0:
+        num_proc = max(1, os.cpu_count() or 1)
+
+    if not args.local_cache and num_proc > 1:
+        print("[filter] --num-proc > 1 ignored in streaming mode (parallel map needs --local-cache).")
+        num_proc = 1
+
+    if args.early_stop and args.local_cache and num_proc > 1:
+        raise SystemExit(
+            "[error] --early-stop needs a sequential scan; use default streaming, or "
+            "--local-cache with --num-proc 1 (not parallel map)."
+        )
+
+    if args.local_cache:
+        print("[filter] Mode: local HF cache — full split download/materialization runs FIRST (can be very slow).")
+        ds = load_dataset("HuggingFaceFV/finevideo", split="train", streaming=False)
+        n_est = len(ds)
+    else:
+        print(f"[filter] Mode: streaming (~{FINEVIDEO_ROW_ESTIMATE} rows; network-bound, typical ~20–90+ min).")
+        ds = load_dataset("HuggingFaceFV/finevideo", split="train", streaming=True)
+        n_est = FINEVIDEO_ROW_ESTIMATE
+
+    if args.early_stop:
+        print(f"[filter] --early-stop: will stop after {args.target_count} passing rows (no full scan).")
+
+    candidates: list[dict] = []
+    total = 0
+    passed = 0
+    cat_counter: Counter = Counter()
+    ck_f = None
+    since_flush = 0
+
+    if use_ck:
+        ck_f = open(ck_path, "w", encoding="utf-8")
+
+    try:
+        if args.local_cache and num_proc > 1:
+            # Parallel CPU path: map writes an Arrow cache; checkpoint lines are flushed after map+filter.
+            print(f"[filter] Parallel map num_proc={num_proc} (HF datasets multiprocessing).")
+            if use_ck:
+                print("[checkpoint] Sidecar is written after parallel pass (not row-by-row during map).")
+            fn_kw = {
+                "min_avc": args.min_avc,
+                "min_duration": args.min_duration,
+                "max_duration": args.max_duration,
+                "min_scenes": args.min_scenes,
+            }
+            cols = list(ds.column_names)
+            ds_m = ds.map(
+                _map_row_parallel,
+                with_indices=True,
+                num_proc=num_proc,
+                fn_kwargs=fn_kw,
+                remove_columns=cols,
+                desc="FineVideo filter+extract",
+            )
+            ds_f = ds_m.filter(_row_has_candidate, num_proc=num_proc)
+            total = n_est
+            passed = len(ds_f)
+            it = ds_f
+            if not args.no_tqdm:
+                it = tqdm(ds_f, total=passed, desc="Write passing rows", unit="row", dynamic_ncols=True)
+            for row in it:
+                line = row["_cand_jsonl"]
+                cand = json.loads(line)
+                cat_counter[cand["content_parent_category"]] += 1
+                if args.no_checkpoint:
+                    candidates.append(cand)
+                else:
+                    assert ck_f is not None
+                    ck_f.write(line + "\n")
+                    since_flush += 1
+                    if since_flush >= args.checkpoint_flush_every:
+                        ck_f.flush()
+                        since_flush = 0
+        else:
+            base_iter = ds
+            if not args.no_tqdm:
+                base_iter = tqdm(
+                    ds,
+                    total=n_est,
+                    desc="FineVideo scan",
+                    unit="row",
+                    dynamic_ncols=True,
+                )
+
+            for idx, sample in enumerate(base_iter):
+                total += 1
+                meta = sample.get("json")
+                if not meta or not isinstance(meta, dict):
+                    continue
+
+                if passes_filter(meta, args):
+                    passed += 1
+                    cand = extract_candidate(meta, idx)
+                    if args.no_checkpoint:
+                        candidates.append(cand)
+                    else:
+                        assert ck_f is not None
+                        ck_f.write(json.dumps(cand, ensure_ascii=False) + "\n")
+                        since_flush += 1
+                        if since_flush >= args.checkpoint_flush_every:
+                            ck_f.flush()
+                            since_flush = 0
+                    cat_counter[cand["content_parent_category"]] += 1
+                    if args.early_stop and passed >= args.target_count:
+                        break
+    finally:
+        if ck_f is not None:
+            ck_f.flush()
+            ck_f.close()
+
+    print(f"[filter] Scanned {total} total, {passed} passed filters.")
+
+    if use_ck:
+        print(f"[checkpoint] Closing sidecar ({passed} lines). Loading for sampling ...")
+        candidates = load_candidates_from_jsonl(ck_path)
+
+    if args.target_count > 0 and len(candidates) > args.target_count:
+        print(f"[sample] Stratified sampling {args.target_count} from {len(candidates)} ...")
+        candidates = stratified_sample(candidates, args.target_count, args.seed)
+
+    write_final_output(candidates, args.output)
+
+    print(f"\n[output] {len(candidates)} candidates written to {args.output}")
+    if use_ck:
+        print(f"[checkpoint] Full passing list still at {ck_path} (delete if you only need final subset).")
+    print("  Category distribution:")
+    final_cats = Counter(c["content_parent_category"] for c in candidates)
+    for cat, count in final_cats.most_common(20):
+        print(f"    {cat:30s}: {count}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/finevideo/generate_finevideo_dpo.py b/finevideo/generate_finevideo_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..906e726bc48da7fd1e9397ec0ccd217397731cf9
--- /dev/null
+++ b/finevideo/generate_finevideo_dpo.py
@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+Generate DPO preference pairs from FineVideo SFT data.
+
+Takes the SFT QA pairs (finevideo_sft.jsonl) and creates DPO training data
+where:
+  - chosen  = the correct temporal grounding answer (from SFT)
+  - rejected = a plausible but WRONG answer generated by one of 4 strategies
+
+Rejection strategies (applied round-robin to keep distribution balanced):
+  1. TIMESTAMP_SHIFT: Shift all timestamps in the answer by a random offset
+  2. EVENT_SWAP: Attribute audio to the wrong visual event (swap scene references)
+  3. VIDEO_ONLY: Rewrite to ignore audio entirely (visual-only answer)
+  4. FALSE_ALIGNMENT: Claim sync/match when the answer describes a mismatch, or vice versa
+
+Strategies 1-2 use rule-based text manipulation.
+Strategies 3-4 use an LLM (GPT/Gemini text-only) to rewrite the answer.
+
+Usage:
+  python generate_finevideo_dpo.py
+  python generate_finevideo_dpo.py --sft-input /opt/dlami/nvme/finevideo/finevideo_sft.jsonl
+  python generate_finevideo_dpo.py --strategy all --api-key sk-...
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import threading
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Optional
+
+DEFAULT_SFT_INPUT = Path("/opt/dlami/nvme/finevideo/finevideo_sft.jsonl")
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/finevideo/finevideo_dpo.json")
+
+STRATEGIES = ["timestamp_shift", "event_swap", "video_only", "false_alignment"]
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Generate DPO data from FineVideo SFT.")
+    p.add_argument("--sft-input", type=Path, default=DEFAULT_SFT_INPUT)
+    p.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+    p.add_argument("--strategy", choices=STRATEGIES + ["all"], default="all",
+                   help="Rejection strategy (default: round-robin all).")
+    p.add_argument("--api-key", type=str, default=None,
+                   help="API key for LLM-based strategies (video_only, false_alignment). "
+                        "Falls back to OPENAI_API_KEY. Without a key, rule-based fallback is used.")
+    p.add_argument("--api-base", type=str, default=None,
+                   help="Custom base URL for OpenAI-compatible API (e.g. http://14.103.68.46/v1).")
+    p.add_argument("--model", type=str, default="gpt-5-mini")
+    p.add_argument("--workers", type=int, default=4)
+    p.add_argument("--seed", type=int, default=42)
+    return p.parse_args()
+
+
+# ── Strategy 1: Timestamp shift ─────────────────────────────────────────────
+def reject_timestamp_shift(answer: str, rng: random.Random) -> str:
+    """Shift all timestamps in the answer by a random offset."""
+    shift = rng.choice([-15, -10, -8, -5, 5, 8, 10, 15, 20, 25])
+
+    def shift_mmss(m: re.Match) -> str:
+        mins = int(m.group(1))
+        secs = int(m.group(2))
+        total = max(0, mins * 60 + secs + shift)
+        new_m, new_s = divmod(total, 60)
+        return f"{new_m}:{new_s:02d}"
+
+    def shift_secs(m: re.Match) -> str:
+        val = float(m.group(1))
+        new_val = max(0.0, val + shift)
+        if new_val == int(new_val):
+            return f"{int(new_val)}s"
+        return f"{new_val:.1f}s"
+
+    result = re.sub(r"(\d+):(\d{2})", shift_mmss, answer)
+    result = re.sub(r"(\d+\.?\d*)\s*s(?:econds?)?", shift_secs, result)
+
+    if result == answer:
+        result = f"Around the {abs(shift)}-second mark, " + answer[0].lower() + answer[1:]
+
+    return result
+
+
+# ── Strategy 2: Event swap ──────────────────────────────────────────────────
+def reject_event_swap(answer: str, rng: random.Random) -> str:
+    """Swap audio and visual event descriptions to create a misalignment."""
+    audio_kws = ["hear", "sound", "audio", "noise", "listen", "clap", "music",
+                 "speak", "voice", "bang", "crash", "thud"]
+    visual_kws = ["see", "show", "visual", "appear", "watch", "camera",
+                  "scene", "display", "view", "look"]
+
+    sentences = re.split(r'(?<=[.!?])\s+', answer)
+    if len(sentences) < 2:
+        return answer.replace("audio", "visual").replace("hear", "see") + \
+               " The timing does not align with the actual events."
+
+    audio_sents = [s for s in sentences if any(k in s.lower() for k in audio_kws)]
+    visual_sents = [s for s in sentences if any(k in s.lower() for k in visual_kws)]
+
+    if audio_sents and visual_sents:
+        swapped = list(sentences)
+        ai = sentences.index(audio_sents[0])
+        vi = sentences.index(visual_sents[0])
+        swapped[ai], swapped[vi] = swapped[vi], swapped[ai]
+        return " ".join(swapped)
+
+    rng.shuffle(sentences)
+    return " ".join(sentences)
+
+
+# ── Strategy 3: Video-only (LLM rewrite) ────────────────────────────────────
+VIDEO_ONLY_PROMPT = """\
+Rewrite the following answer so that it ONLY describes what is VISIBLE in the \
+video, completely removing all audio references. Replace any mentions of sounds, \
+music, speech, or hearing with visual-only descriptions. Keep timestamps but \
+change audio events to generic visual descriptions.
+
+Original answer: {answer}
+
+Return ONLY the rewritten answer, nothing else."""
+
+
+def reject_video_only_llm(answer: str, api_key: str, model: str, base_url: str | None = None) -> Optional[str]:
+    from openai import OpenAI
+    client = OpenAI(api_key=api_key, **({"base_url": base_url} if base_url else {}))
+    resp = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": VIDEO_ONLY_PROMPT.format(answer=answer)}],
+        temperature=0.7,
+        max_tokens=512,
+    )
+    return resp.choices[0].message.content.strip()
+
+
+def reject_video_only_rule(answer: str, rng: random.Random) -> str:
+    """Fallback rule-based: strip audio references."""
+    replacements = [
+        (r"\bhear\b", "see"), (r"\bheard\b", "seen"), (r"\bhearing\b", "seeing"),
+        (r"\bsound\b", "movement"), (r"\bsounds\b", "movements"),
+        (r"\bnoise\b", "motion"), (r"\baudio\b", "visual"),
+        (r"\blistening\b", "watching"), (r"\blisten\b", "watch"),
+        (r"\bclapping\b", "gesturing"), (r"\bmusic\b", "activity"),
+        (r"\bspeech\b", "gestures"), (r"\bvoice\b", "figure"),
+    ]
+    result = answer
+    for pat, repl in replacements:
+        result = re.sub(pat, repl, result, flags=re.IGNORECASE)
+    return result
+
+
+# ── Strategy 4: False alignment (LLM rewrite) ──────────────────────────────
+FALSE_ALIGN_PROMPT = """\
+The following answer describes audio-visual alignment in a video. \
+Rewrite it to give the OPPOSITE conclusion about alignment:
+- If it says events are aligned/synced, rewrite to say they are misaligned.
+- If it says events don't match, rewrite to say they match perfectly.
+- Keep the same timestamps and event descriptions but flip the alignment judgment.
+
+Original answer: {answer}
+
+Return ONLY the rewritten answer, nothing else."""
+
+
+def reject_false_alignment_llm(answer: str, api_key: str, model: str, base_url: str | None = None) -> Optional[str]:
+    from openai import OpenAI
+    client = OpenAI(api_key=api_key, **({"base_url": base_url} if base_url else {}))
+    resp = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": FALSE_ALIGN_PROMPT.format(answer=answer)}],
+        temperature=0.7,
+        max_tokens=512,
+    )
+    return resp.choices[0].message.content.strip()
+
+
+def reject_false_alignment_rule(answer: str, rng: random.Random) -> str:
+    """Fallback: negate alignment language."""
+    negations = [
+        ("matches", "does not match"), ("confirms", "contradicts"),
+        ("aligned", "misaligned"), ("synchronized", "out of sync"),
+        ("corresponds", "does not correspond"), ("coincides", "does not coincide"),
+        ("consistent", "inconsistent"),
+    ]
+    result = answer
+    applied = False
+    for pos, neg in negations:
+        if pos in result.lower():
+            result = re.sub(re.escape(pos), neg, result, count=1, flags=re.IGNORECASE)
+            applied = True
+            break
+    if not applied:
+        result = "The audio and visual events do not align here. " + result
+    return result
+
+
+def generate_rejection(
+    answer: str,
+    strategy: str,
+    rng: random.Random,
+    api_key: Optional[str],
+    model: str,
+    base_url: str | None = None,
+) -> tuple[str, str]:
+    """Generate a rejected answer. Returns (rejected_text, strategy_used)."""
+    if strategy == "timestamp_shift":
+        return reject_timestamp_shift(answer, rng), strategy
+    elif strategy == "event_swap":
+        return reject_event_swap(answer, rng), strategy
+    elif strategy == "video_only":
+        if api_key:
+            try:
+                r = reject_video_only_llm(answer, api_key, model, base_url)
+                if r:
+                    return r, strategy
+            except Exception:
+                pass
+        return reject_video_only_rule(answer, rng), strategy + "_rule"
+    elif strategy == "false_alignment":
+        if api_key:
+            try:
+                r = reject_false_alignment_llm(answer, api_key, model, base_url)
+                if r:
+                    return r, strategy
+            except Exception:
+                pass
+        return reject_false_alignment_rule(answer, rng), strategy + "_rule"
+    else:
+        return reject_timestamp_shift(answer, rng), "timestamp_shift"
+
+
+_write_lock = threading.Lock()
+
+
+def main() -> None:
+    args = parse_args()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+
+    api_key = args.api_key or os.environ.get("OPENAI_API_KEY")
+
+    sft_entries = []
+    with open(args.sft_input, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                sft_entries.append(json.loads(line))
+
+    print(f"[dpo] Loaded {len(sft_entries)} SFT entries from {args.sft_input}")
+
+    if args.strategy == "all":
+        strategies = STRATEGIES
+    else:
+        strategies = [args.strategy]
+
+    rng = random.Random(args.seed)
+    dpo_entries = []
+    errors = 0
+
+    for i, entry in enumerate(sft_entries):
+        msgs = entry.get("messages", [])
+        if len(msgs) < 2:
+            errors += 1
+            continue
+
+        question = msgs[0].get("content", "")
+        chosen_answer = msgs[1].get("content", "")
+        if not chosen_answer:
+            errors += 1
+            continue
+
+        strategy = strategies[i % len(strategies)]
+        rejected_answer, strat_used = generate_rejection(
+            chosen_answer, strategy, rng, api_key, args.model, args.api_base,
+        )
+
+        dpo_entry = {
+            "messages": [{"role": "user", "content": question}],
+            "chosen": {"role": "assistant", "content": chosen_answer},
+            "rejected": {"role": "assistant", "content": rejected_answer},
+            "videos": entry.get("videos", []),
+            "audios": entry.get("audios", []),
+        }
+        dpo_entries.append(dpo_entry)
+
+        if (i + 1) % 1000 == 0:
+            print(f"  [{i+1}/{len(sft_entries)}] generated {len(dpo_entries)} DPO pairs")
+
+    print(f"[dpo] Generated {len(dpo_entries)} DPO pairs ({errors} skipped)")
+
+    with open(args.output, "w", encoding="utf-8") as f:
+        json.dump(dpo_entries, f, indent=2, ensure_ascii=False)
+
+    print(f"[output] {args.output} ({len(dpo_entries)} entries)")
+
+    strat_dist = {}
+    for i, entry in enumerate(sft_entries):
+        if i < len(dpo_entries):
+            s = strategies[i % len(strategies)]
+            strat_dist[s] = strat_dist.get(s, 0) + 1
+    print(f"  Strategy distribution: {strat_dist}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/finevideo/generate_finevideo_sft.py b/finevideo/generate_finevideo_sft.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6c64440f8c1d0536ac25e427afc3e30b85016f1
--- /dev/null
+++ b/finevideo/generate_finevideo_sft.py
@@ -0,0 +1,606 @@
+#!/usr/bin/env python3
+"""
+Generate SFT training data for dense temporal grounding from FineVideo.
+
+Gemini watches + listens to each video and generates 3 QA pairs (one per type).
+Within each type, Gemini varies the phrasing naturally — no two questions
+are asked in the same way.
+
+QA types:
+  DESCRIBE: "Describe what you see and hear segment by segment"
+            (Gemini enriches the simple metadata descriptions into detailed
+             audio-visual narratives with timestamps)
+  LOCATE:   "At what point / When do you hear [sound]?"
+            (sound identified by Gemini from actually listening to the video)
+  ATTRIBUTE: "What is making the [sound] at [timestamp]?"
+            (connect an audio event to its visual source)
+
+Input:  filtered_candidates.jsonl + downloaded .mp4 files
+Output: finevideo_sft.jsonl (LlamaFactory SFT format, append-only, resume-safe)
+
+Usage:
+  export GEMINI_API_KEY=...
+  python generate_finevideo_sft.py
+  python generate_finevideo_sft.py --max-samples 500 --workers 4
+  python generate_finevideo_sft.py --model gemini-2.5-pro
+  python generate_finevideo_sft.py --api-key KEY1,KEY2,KEY3
+  python generate_finevideo_sft.py --api-key KEY1 --api-key KEY2 --api-key KEY3
+
+Multi-key: pass comma-separated keys or repeat --api-key. When a key hits its rate
+limit (429/ResourceExhausted), the script rotates to the next key. When ALL keys are
+exhausted it stops gracefully (resume-safe: re-run with new keys to continue).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import re
+import threading
+import time
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+DEFAULT_CANDIDATES = Path("/opt/dlami/nvme/finevideo/filtered_candidates.jsonl")
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/finevideo/videos")
+DEFAULT_AUDIO_DIR = Path("/opt/dlami/nvme/finevideo/audio")
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/finevideo/finevideo_sft.jsonl")
+
+SYSTEM_PROMPT = """\
+You are an expert multimodal annotator. You will watch and listen to a video, \
+then generate training data for an AI model that must learn to understand \
+BOTH audio and visual content together.
+
+You must actually perceive the video — describe real sounds you hear (speech, \
+music, impacts, ambient noise, machinery, nature, etc.) and real visual events \
+you see. Be specific about timestamps. Never fabricate content.
+"""
+
+QA_GENERATION_PROMPT = """\
+Watch and LISTEN to this video carefully. Pay attention to ALL sounds — not just \
+speech, but also environmental sounds, music, impacts, machinery, animals, etc.
+
+Reference metadata (scene boundaries and basic descriptions):
+{metadata_text}
+
+This video has {n_scenes} distinct scenes with activities. Your job: generate \
+EXACTLY {n_total} question-answer pairs as a JSON array, using VARIED and NATURAL \
+phrasing — do NOT repeat the same question template across pairs.
+
+Breakdown:
+- 1 DESCRIBE pair (covers the full video)
+- {n_locate} LOCATE pairs (each about a DIFFERENT sound at a DIFFERENT time)
+- {n_attribute} ATTRIBUTE pairs (each about a DIFFERENT sound source at a DIFFERENT time)
+
+=== TYPE 1: DESCRIBE (1 pair) ===
+Ask the viewer to describe what they see AND hear across the video (or a portion). \
+The answer should be a RICH, DETAILED segment-by-segment narration with timestamps, \
+covering both visual actions and audio content (speech, sounds, music).
+
+Go far beyond the simple metadata descriptions — be specific about:
+- What exact sounds are present (not just "someone talks", but what they say, \
+  their tone, accent, background sounds)
+- Visual details the metadata didn't capture
+- How audio and visual elements interact moment by moment
+
+Example question phrasings (vary these, never repeat):
+- "Walk me through what happens in this video, describing both what you see and hear."
+- "Give a detailed audio-visual breakdown of this clip."
+- "Describe the sequence of events, including all sounds and visuals, with timestamps."
+
+=== TYPE 2: LOCATE ({n_locate} pairs) ===
+Ask WHEN a specific sound or audio event occurs. You must pick a real sound you \
+actually hear in the video. The answer gives the timestamp and describes what is \
+happening visually at that moment.
+
+IMPORTANT: each LOCATE pair must be about a DIFFERENT audio event from a DIFFERENT \
+part of the video. Spread them across the timeline.
+
+Example question phrasings (vary these):
+- "At what point in the video do you hear [specific sound]?"
+- "When does the [sound/voice/music] first appear?"
+- "Can you identify the moment when [audio event] happens?"
+- "Around what timestamp do you notice [sound]?"
+
+=== TYPE 3: ATTRIBUTE ({n_attribute} pairs) ===
+Ask what visual element is PRODUCING a specific sound at a specific time. \
+The answer identifies the sound source by connecting audio to visual evidence.
+
+IMPORTANT: each ATTRIBUTE pair must be about a DIFFERENT sound source at a DIFFERENT \
+timestamp. Cover different scenes.
+
+Example question phrasings (vary these):
+- "What is causing the [sound] heard around [time]?"
+- "At [time], there's a [sound] — what in the scene is responsible?"
+- "Can you identify the source of the [sound] at [time]?"
+- "What object or person is making the [sound] near [time]?"
+
+=== OUTPUT FORMAT ===
+Return ONLY a valid JSON array, nothing else. Example for {n_total} pairs:
+[
+  {{"type": "DESCRIBE", "question": "...", "answer": "..."}},
+  {{"type": "LOCATE", "question": "...", "answer": "..."}},
+  ...
+  {{"type": "ATTRIBUTE", "question": "...", "answer": "..."}}
+]
+
+Rules:
+- Answers must be DETAILED (3-8 sentences for DESCRIBE, 2-4 for LOCATE/ATTRIBUTE)
+- Use approximate timestamps naturally ("around 0:45", "at roughly 1:20")
+- Describe REAL audio you hear — never guess or copy metadata blindly
+- Every answer must reference both what is SEEN and what is HEARD
+- Do NOT duplicate events — each pair covers a DISTINCT moment/sound
+"""
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Generate FineVideo SFT data via Gemini.")
+    p.add_argument("--candidates", type=Path, default=DEFAULT_CANDIDATES)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--audio-dir", type=Path, default=DEFAULT_AUDIO_DIR)
+    p.add_argument("--output", type=Path, default=DEFAULT_OUTPUT)
+    p.add_argument("--max-samples", type=int, default=500)
+    p.add_argument("--workers", type=int, default=4)
+    p.add_argument("--api-key", type=str, default=None, action="append",
+                   help="API key(s). Repeat for multiple keys, or pass comma-separated. "
+                   "Falls back to GEMINI_API_KEY (or OPENROUTER_API_KEY with --openrouter).")
+    p.add_argument("--model", type=str, default="gemini-3.1-pro-preview")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--retry", type=int, default=3,
+                   help="Retries per video on transient errors (default 3).")
+    p.add_argument("--skip-errors-from", type=Path, default=None,
+                   help="Path to a *_errors.jsonl from a previous run; skip those finevideo_idx.")
+    p.add_argument(
+        "--openrouter",
+        action="store_true",
+        help="Use OpenRouter (OpenAI-compatible) instead of native Gemini API. "
+        "Video is sent as base64 data URL. Model names like google/gemini-2.5-pro-preview.",
+    )
+    p.add_argument(
+        "--api-base",
+        type=str,
+        default="https://openrouter.ai/api/v1",
+        help="Base URL for OpenAI-compatible API (used with --openrouter).",
+    )
+    return p.parse_args()
+
+
+def build_metadata_text(candidate: dict) -> str:
+    lines = [
+        f"Title: {candidate.get('title') or candidate.get('youtube_title', '')}",
+        f"Duration: {candidate.get('duration_seconds', '?')}s",
+        f"Category: {candidate.get('content_parent_category', '')} / {candidate.get('content_fine_category', '')}",
+        "",
+    ]
+
+    for s in candidate.get("scenes", []):
+        start = s.get("start", "?")
+        end = s.get("end", "?")
+        lines.append(f"[{start} - {end}] Scene: {s.get('title', '')}")
+        for a in s.get("activities", []):
+            lines.append(f"  Activity: {a.get('description', '')} "
+                         f"[{a.get('start', '?')} - {a.get('end', '?')}]")
+
+    tts = candidate.get("timecoded_text_to_speech", [])
+    if tts:
+        lines.append("")
+        lines.append("Speech transcript:")
+        for seg in tts[:20]:
+            lines.append(f"  [{seg.get('start', '?')} - {seg.get('end', '?')}] "
+                         f"{seg.get('text', '')}")
+        if len(tts) > 20:
+            lines.append(f"  ... ({len(tts) - 20} more)")
+
+    return "\n".join(lines)
+
+
+def parse_qa_response(text: str) -> list[dict]:
+    for pat in [
+        re.compile(r"```(?:json)?\s*(\[.*?\])\s*```", re.DOTALL),
+        re.compile(r"(\[\s*\{.*\}\s*\])", re.DOTALL),
+    ]:
+        m = pat.search(text)
+        if m:
+            try:
+                arr = json.loads(m.group(1))
+                if isinstance(arr, list) and all(
+                    isinstance(x, dict) and "question" in x and "answer" in x
+                    for x in arr
+                ):
+                    return arr
+            except (json.JSONDecodeError, TypeError):
+                continue
+    return []
+
+
+def call_gemini(video_path: str, prompt: str, api_key: str, model: str) -> str:
+    from google import genai
+    from google.genai import types as genai_types
+
+    client = genai.Client(api_key=api_key)
+
+    video_file = client.files.upload(file=video_path)
+    while video_file.state.name == "PROCESSING":
+        time.sleep(2)
+        video_file = client.files.get(name=video_file.name)
+    if video_file.state.name == "FAILED":
+        raise RuntimeError(f"Gemini file processing failed: {video_file.state}")
+
+    response = client.models.generate_content(
+        model=model,
+        contents=[
+            genai_types.Content(
+                role="user",
+                parts=[
+                    genai_types.Part.from_uri(
+                        file_uri=video_file.uri,
+                        mime_type=video_file.mime_type,
+                    ),
+                    genai_types.Part.from_text(text=prompt),
+                ],
+            )
+        ],
+        config=genai_types.GenerateContentConfig(
+            system_instruction=SYSTEM_PROMPT,
+            temperature=0.5,
+            max_output_tokens=4000,
+        ),
+    )
+    try:
+        client.files.delete(name=video_file.name)
+    except Exception:
+        pass
+    return response.text
+
+
+def call_openrouter(
+    video_path: str, prompt: str, api_key: str, model: str, api_base: str,
+) -> str:
+    import base64
+    from openai import OpenAI
+
+    with open(video_path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode()
+    data_url = f"data:video/mp4;base64,{b64}"
+
+    client = OpenAI(api_key=api_key, base_url=api_base)
+    resp = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "video_url", "video_url": {"url": data_url}},
+                    {"type": "text", "text": prompt},
+                ],
+            },
+        ],
+        temperature=0.5,
+        max_tokens=4000,
+    )
+    return resp.choices[0].message.content
+
+
+def process_one(
+    candidate: dict,
+    video_dir: Path,
+    audio_dir: Path,
+    key_rotator: KeyRotator,
+    model: str,
+    max_retry: int,
+    use_openrouter: bool = False,
+    api_base: str = "",
+) -> tuple[list[dict] | None, str]:
+    """Returns (entries_or_None, error_reason). error_reason is '' on success."""
+    idx = candidate["finevideo_idx"]
+    video_path = video_dir / f"finevideo_{idx:06d}.mp4"
+    audio_path = audio_dir / f"finevideo_{idx:06d}.wav"
+
+    if not video_path.exists():
+        return None, f"video_not_found: {video_path}"
+
+    scenes = candidate.get("scenes", [])
+    n_scenes = sum(1 for s in scenes if s.get("activities"))
+    n_locate = 2
+    n_attribute = 2
+    n_total = 1 + n_locate + n_attribute
+
+    metadata_text = build_metadata_text(candidate)
+    prompt = QA_GENERATION_PROMPT.format(
+        metadata_text=metadata_text,
+        n_scenes=n_scenes,
+        n_locate=n_locate,
+        n_attribute=n_attribute,
+        n_total=n_total,
+    )
+
+    qa_pairs = []
+    last_error = ""
+    for attempt in range(1 + max_retry):
+        try:
+            api_key = key_rotator.get()
+        except AllKeysExhausted:
+            raise
+        try:
+            if use_openrouter:
+                raw = call_openrouter(str(video_path), prompt, api_key, model, api_base)
+            else:
+                raw = call_gemini(str(video_path), prompt, api_key, model)
+            qa_pairs = parse_qa_response(raw)
+            if qa_pairs:
+                break
+            last_error = f"parse_fail: model returned text but no valid QA JSON (len={len(raw)})"
+            if attempt < max_retry:
+                time.sleep(2)
+        except AllKeysExhausted:
+            raise
+        except Exception as e:
+            last_error = f"{type(e).__name__}: {e}"
+            if KeyRotator.is_rate_limit(e):
+                key_rotator.mark_exhausted(api_key)
+                if key_rotator.alive == 0:
+                    raise AllKeysExhausted("All API keys exhausted (rate-limited).")
+                continue
+            if attempt < max_retry:
+                time.sleep(3 * (attempt + 1))
+            else:
+                print(f"  [error] idx={idx}: {last_error}")
+                return None, last_error
+
+    if not qa_pairs:
+        print(f"  [parse_fail] idx={idx}: {last_error}")
+        return None, last_error
+
+    results = []
+    for qa in qa_pairs:
+        entry = {
+            "messages": [
+                {"role": "user", "content": f"<video><audio>{qa['question']}"},
+                {"role": "assistant", "content": qa["answer"]},
+            ],
+            "videos": [str(video_path)],
+            "audios": [str(audio_path)] if audio_path.exists() else [],
+            "_meta": {
+                "finevideo_idx": idx,
+                "qa_type": qa.get("type", "?"),
+                "category": candidate.get("content_parent_category", ""),
+            },
+        }
+        results.append(entry)
+
+    return results, ""
+
+
+_write_lock = threading.Lock()
+
+
+class AllKeysExhausted(Exception):
+    """Raised when every API key has hit its rate limit."""
+
+
+class KeyRotator:
+    """Thread-safe round-robin over API keys; marks keys exhausted on 429."""
+
+    def __init__(self, keys: list[str]):
+        self._keys = list(keys)
+        self._exhausted: set[int] = set()
+        self._idx = 0
+        self._lock = threading.Lock()
+
+    @property
+    def total(self) -> int:
+        return len(self._keys)
+
+    @property
+    def alive(self) -> int:
+        with self._lock:
+            return len(self._keys) - len(self._exhausted)
+
+    def get(self) -> str:
+        with self._lock:
+            if len(self._exhausted) >= len(self._keys):
+                raise AllKeysExhausted("All API keys exhausted (rate-limited).")
+            for _ in range(len(self._keys)):
+                i = self._idx % len(self._keys)
+                self._idx += 1
+                if i not in self._exhausted:
+                    return self._keys[i]
+            raise AllKeysExhausted("All API keys exhausted (rate-limited).")
+
+    def mark_exhausted(self, key: str) -> None:
+        with self._lock:
+            for i, k in enumerate(self._keys):
+                if k == key:
+                    if i not in self._exhausted:
+                        self._exhausted.add(i)
+                        remaining = len(self._keys) - len(self._exhausted)
+                        masked = key[:6] + "..." + key[-4:]
+                        print(f"  [key-exhausted] {masked} rate-limited; {remaining} key(s) remaining.")
+                    break
+
+    @staticmethod
+    def is_rate_limit(exc: Exception) -> bool:
+        msg = str(exc).lower()
+        if "429" in msg or "resource_exhausted" in msg or "resourceexhausted" in msg:
+            return True
+        if "quota" in msg and ("exceeded" in msg or "limit" in msg):
+            return True
+        return False
+
+
+def _error_log_path(output: Path) -> Path:
+    return output.parent / f"{output.stem}_errors.jsonl"
+
+
+def append_results(output: Path, entries: list[dict]) -> None:
+    with _write_lock:
+        with open(output, "a", encoding="utf-8") as f:
+            for e in entries:
+                f.write(json.dumps(e, ensure_ascii=False) + "\n")
+
+
+def append_error(error_log: Path, idx: int, reason: str, detail: str) -> None:
+    with _write_lock:
+        with open(error_log, "a", encoding="utf-8") as f:
+            f.write(json.dumps({
+                "finevideo_idx": idx,
+                "reason": reason,
+                "detail": detail[:500],
+            }, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    args = parse_args()
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+
+    # Collect API keys: --api-key can be repeated and/or comma-separated.
+    raw_keys: list[str] = []
+    if args.api_key:
+        for k in args.api_key:
+            raw_keys.extend(part.strip() for part in k.split(",") if part.strip())
+    if not raw_keys:
+        env_var = "OPENROUTER_API_KEY" if args.openrouter else "GEMINI_API_KEY"
+        env_key = os.environ.get(env_var, "").strip()
+        if env_key:
+            raw_keys.extend(part.strip() for part in env_key.split(",") if part.strip())
+    if not raw_keys:
+        hint = "--api-key or $OPENROUTER_API_KEY" if args.openrouter else "--api-key or $GEMINI_API_KEY"
+        print(f"[error] No API key. Set {hint}")
+        raise SystemExit(1)
+    provider = "OpenRouter" if args.openrouter else "Gemini"
+    print(f"[keys] {len(raw_keys)} API key(s) loaded ({provider}).")
+    key_rotator = KeyRotator(raw_keys)
+
+    candidates = []
+    with open(args.candidates, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                candidates.append(json.loads(line))
+
+    # Only process candidates whose video is actually on disk (i.e. the subset
+    # chosen by download_finevideo_subset.py's stratified sampling).
+    before = len(candidates)
+    candidates = [
+        c for c in candidates
+        if (args.video_dir / f"finevideo_{c['finevideo_idx']:06d}.mp4").exists()
+    ]
+    print(f"[candidates] {before} in file, {len(candidates)} have downloaded mp4 -> processing all of them.")
+    if args.max_samples > 0 and len(candidates) > args.max_samples:
+        rng = random.Random(args.seed)
+        rng.shuffle(candidates)
+        candidates = candidates[:args.max_samples]
+        print(f"[candidates] Capped to --max-samples {args.max_samples}")
+
+    processed_ids: set[int] = set()
+    if args.output.exists():
+        with open(args.output, encoding="utf-8") as f:
+            for line in f:
+                try:
+                    fid = json.loads(line).get("_meta", {}).get("finevideo_idx")
+                    if fid is not None:
+                        processed_ids.add(fid)
+                except json.JSONDecodeError:
+                    pass
+        print(f"[resume] {len(processed_ids)} videos already in output (will skip)")
+
+    skip_ids: set[int] = set()
+    if args.skip_errors_from and args.skip_errors_from.exists():
+        with open(args.skip_errors_from, encoding="utf-8") as f:
+            for line in f:
+                try:
+                    fid = json.loads(line).get("finevideo_idx")
+                    if fid is not None:
+                        skip_ids.add(fid)
+                except json.JSONDecodeError:
+                    pass
+        print(f"[skip-errors] {len(skip_ids)} videos marked as known failures (will skip)")
+
+    todo = [c for c in candidates
+            if c["finevideo_idx"] not in processed_ids
+            and c["finevideo_idx"] not in skip_ids]
+    print(f"[sft] {len(todo)} videos to process "
+          f"(model={args.model}, workers={args.workers})")
+
+    if not todo:
+        print("[skip] All candidates already processed.")
+        return
+
+    total_qa = 0
+    errors = 0
+    all_exhausted = False
+    error_log = _error_log_path(args.output)
+
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {
+            pool.submit(
+                process_one, c, args.video_dir, args.audio_dir,
+                key_rotator, args.model, args.retry,
+                args.openrouter, args.api_base,
+            ): c["finevideo_idx"]
+            for c in todo
+        }
+        for i, future in enumerate(as_completed(futures), 1):
+            fid = futures[future]
+            try:
+                entries, err_reason = future.result()
+                if entries:
+                    append_results(args.output, entries)
+                    total_qa += len(entries)
+                else:
+                    errors += 1
+                    append_error(error_log, fid, err_reason, "")
+            except AllKeysExhausted:
+                all_exhausted = True
+                print(f"\n[stop] All {key_rotator.total} API key(s) hit rate limit. "
+                      "Stopping gracefully (progress is saved).")
+                pool.shutdown(wait=False, cancel_futures=True)
+                break
+            except Exception as exc:
+                errors += 1
+                print(f"  [exception] idx={fid}: {exc}")
+                append_error(error_log, fid, "exception", str(exc))
+
+            if i % 20 == 0:
+                print(f"  [{i}/{len(todo)}] {total_qa} QA pairs, {errors} errors, "
+                      f"keys alive: {key_rotator.alive}/{key_rotator.total}")
+
+    total_lines = sum(1 for _ in open(args.output)) if args.output.exists() else 0
+    print(f"\n[done] {total_qa} new QA pairs ({errors} errors)")
+    print(f"  Total entries in file: {total_lines}")
+
+    type_counts: dict[str, int] = {}
+    if args.output.exists():
+        with open(args.output) as f:
+            for line in f:
+                try:
+                    qt = json.loads(line).get("_meta", {}).get("qa_type", "?")
+                    type_counts[qt] = type_counts.get(qt, 0) + 1
+                except json.JSONDecodeError:
+                    pass
+    print(f"  Type distribution: {type_counts}")
+
+    if errors > 0 and error_log.exists():
+        reason_counts: dict[str, int] = {}
+        with open(error_log) as f:
+            for line in f:
+                try:
+                    r = json.loads(line).get("reason", "unknown")
+                    tag = r.split(":")[0].strip()
+                    reason_counts[tag] = reason_counts.get(tag, 0) + 1
+                except (json.JSONDecodeError, AttributeError):
+                    pass
+        print(f"  Error breakdown: {reason_counts}")
+        print(f"  Full error log: {error_log}")
+        print(f"  To skip known failures next run: --skip-errors-from {error_log}")
+
+    if all_exhausted:
+        print("\n[hint] Re-run the SAME command with new/additional --api-key to continue "
+              "(resume picks up where it left off).")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/COMMANDS.md b/hf_upload/COMMANDS.md
new file mode 100644
index 0000000000000000000000000000000000000000..db67173a598fa07535f696b6e91280b9695197e3
--- /dev/null
+++ b/hf_upload/COMMANDS.md
@@ -0,0 +1,168 @@
+# Commands (you run these yourself)
+
+Assume you cloned the repo and ran `bash setup_env.sh` (installs Anaconda under `~/anaconda3` if conda is missing, then creates the env). On first login after install, run `source ~/anaconda3/etc/profile.d/conda.sh` before `conda activate`.
+
+```bash
+conda activate video   # or whatever CONDA_ENV you used
+
+export REPO_ROOT="$(pwd)"   # top of CleverHans-Evaluation clone
+export SCRIPTS="${REPO_ROOT}/scripts"
+export SYNC_TEST="${REPO_ROOT}/data/kto_training_data_v2_test.jsonl"
+
+# Layout (fixed across your machines):
+#   Data (videos, merged weights, sync media) → fast disk
+#   Eval JSONL / metrics / summaries        → ubuntu home
+export WORK_ROOT="${WORK_ROOT:-/opt/dlami/nvme}"
+export EVAL_ROOT="${EVAL_ROOT:-/home/ubuntu/eval_results}"
+
+export VIDEOMME_DIR="${WORK_ROOT}/videomme"
+export VIDEOMME_VIDEOS="${WORK_ROOT}/videomme/data/data"
+export LVBENCH_VIDEOS="${WORK_ROOT}/lvbench"
+export MERGED_DIR="${WORK_ROOT}/merged_models"
+export DATA_ROOT="${WORK_ROOT}/video_source"
+
+# vLLM: Qwen3-Omni audio encoder has 20 heads — use tp that divides 20 (e.g. 4, not 8).
+export TP="${TP:-4}"
+export GPUS="${GPUS:-0,1,2,3}"
+```
+
+## 1) Download all data (once per machine)
+
+```bash
+bash setup_data.sh
+# Downloads Video-MME, LVBench, sync videos + audio to /opt/dlami/nvme.
+# Or override: WORK_ROOT=/my/disk bash setup_data.sh
+```
+
+Or download individually:
+
+```bash
+python "${SCRIPTS}/download_videomme.py" --output-dir "${VIDEOMME_DIR}"
+python "${SCRIPTS}/download_lvbench.py" --output-dir "${LVBENCH_VIDEOS}"
+```
+
+## 2) Merge DPO LoRA → full model
+
+Base for merge:
+
+```bash
+export BASE_SFT="Rakancorle11/qwen3omni_full_sft_revised_thinker_key"
+```
+
+```bash
+mkdir -p "${MERGED_DIR}"
+
+python "${SCRIPTS}/merge_adapter.py" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v2_8632 \
+  --output "${MERGED_DIR}/dpo_v2_8632"
+
+python "${SCRIPTS}/merge_adapter.py" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v3_8632 \
+  --output "${MERGED_DIR}/dpo_v3_8632"
+
+python "${SCRIPTS}/merge_adapter.py" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v4_8632 \
+  --output "${MERGED_DIR}/dpo_v4_8632"
+
+python "${SCRIPTS}/merge_adapter.py" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v5_12075 \
+  --output "${MERGED_DIR}/dpo_v5_12075"
+```
+
+## 3) Video-MME — pick model + label
+
+**vLLM (fast)** — `--base-model` must be a **merged** full checkpoint path or a full model id:
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_videomme.py" \
+  --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+  --video-dir "${VIDEOMME_VIDEOS}" \
+  --output-dir "${EVAL_ROOT}/videomme" \
+  --vllm --tp "${TP}" \
+  --max-samples -1 --label vmme_vanilla
+```
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_videomme.py" \
+  --base-model "${BASE_SFT}" \
+  --video-dir "${VIDEOMME_VIDEOS}" \
+  --output-dir "${EVAL_ROOT}/videomme" \
+  --vllm --tp "${TP}" \
+  --max-samples -1 --label vmme_full_sft
+```
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_videomme.py" \
+  --base-model "${MERGED_DIR}/dpo_v4_8632" \
+  --video-dir "${VIDEOMME_VIDEOS}" \
+  --output-dir "${EVAL_ROOT}/videomme" \
+  --vllm --tp "${TP}" \
+  --max-samples -1 --label vmme_dpo_v4_8632
+```
+
+**Transformers only** (no `--vllm`):
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_videomme.py" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v4_8632 \
+  --video-dir "${VIDEOMME_VIDEOS}" \
+  --output-dir "${EVAL_ROOT}/videomme" \
+  --max-samples -1 --label vmme_dpo_v4_adapter
+```
+
+## 4) LVBench — same pattern
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_lvbench.py" \
+  --base-model "${MERGED_DIR}/dpo_v4_8632" \
+  --video-dir "${LVBENCH_VIDEOS}" \
+  --output-dir "${EVAL_ROOT}/lvbench" \
+  --vllm --tp "${TP}" \
+  --max-samples -1 --label lvb_dpo_v4_8632
+```
+
+## 5) In-domain sync — transformers (`--data-root` + `--test-jsonl`)
+
+```bash
+CUDA_VISIBLE_DEVICES="${GPUS}" python "${SCRIPTS}/eval_dpo_sync.py" \
+  --data-root "${DATA_ROOT}" \
+  --base-model "${BASE_SFT}" \
+  --adapter Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v4_8632 \
+  --test-jsonl "${SYNC_TEST}" \
+  --output-dir "${EVAL_ROOT}/sync" \
+  --label sync_dpo_v4_8632
+```
+
+Omit `--video-dir` / `--output-dir` on Video-MME & LVBench if you keep the same layout (scripts default to nvme videos + `/home/ubuntu/eval_results/...`). Omit `--test-jsonl` if you copied the test file to `${DATA_ROOT}/kto_training_data_v2_test.jsonl`; omit `--output-dir` on sync to use `/home/ubuntu/eval_results/sync`.
+
+Optional GPT judge for parsing:
+
+```bash
+export OPENAI_API_KEY=sk-...
+python "${SCRIPTS}/eval_dpo_sync.py" \
+  --data-root "${DATA_ROOT}" \
+  --base-model "${BASE_SFT}" \
+  --test-jsonl "${SYNC_TEST}" \
+  --output-dir "${EVAL_ROOT}/sync" \
+  --label sync_full_sft \
+  --gpt-judge
+```
+
+## 6) Recompute Video-MME metrics from `eval_results.jsonl`
+
+```bash
+python "${SCRIPTS}/compute_videomme_metrics_from_jsonl.py" \
+  --jsonl "${EVAL_ROOT}/videomme/vmme_vanilla/eval_results.jsonl" \
+  --out "${EVAL_ROOT}/videomme/vmme_vanilla/metrics.json"
+```
+
+Results for each run live under:
+
+- `${EVAL_ROOT}/videomme/<label>/`
+- `${EVAL_ROOT}/lvbench/<label>/`
+- `${EVAL_ROOT}/sync/<label>/`
diff --git a/hf_upload/README.md b/hf_upload/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6b81a8daec2ce10c70867190594ef2add0d60f2f
--- /dev/null
+++ b/hf_upload/README.md
@@ -0,0 +1,80 @@
+---
+license: apache-2.0
+language:
+  - en
+tags:
+  - evaluation
+  - video
+  - multimodal
+---
+
+# CleverHans-Evaluation
+
+Scripts and a small in-domain test set to evaluate Qwen3-Omni variants on **Video-MME**, **LVBench**, and **audio–video sync** (custom JSONL).
+
+## What’s in the repo
+
+| Path | Purpose |
+|------|---------|
+| `setup_env.sh` | Installs **Anaconda** if conda is missing, then creates `video` (or `CONDA_ENV`) and pip-installs eval deps |
+| `setup_data.sh` | Downloads **all** eval data: Video-MME, LVBench, and sync eval videos + audio (to `/opt/dlami/nvme`) |
+| `COMMANDS.md` | Copy-paste commands: data download, merge, eval per model/dataset |
+| `data/kto_training_data_v2_test.jsonl` | In-domain sync test (426 lines) |
+| `scripts/*.py` | Download, merge, eval, metrics helpers |
+
+## Quick start
+
+```bash
+git clone https://huggingface.co/Rakancorle11/CleverHans-Evaluation
+cd CleverHans-Evaluation
+
+huggingface-cli login   # if needed for gated models
+
+chmod +x setup_env.sh setup_data.sh
+bash setup_env.sh       # on a machine with no conda: downloads Anaconda to ~/anaconda3 first
+source ~/anaconda3/etc/profile.d/conda.sh   # if this is your first shell after install
+conda activate video
+
+bash setup_data.sh      # downloads Video-MME, LVBench, sync videos + audio to /opt/dlami/nvme
+
+# Then follow COMMANDS.md — you choose which model on which benchmark.
+```
+
+**Fresh OS notes:** install `wget` before running (`sudo apt install -y wget`). System **ffmpeg** is recommended (`sudo apt install -y ffmpeg`). Override `INSTALL_DIR` / `ANACONDA_VERSION` / `CUDA_INDEX_URL` via environment variables if needed (see comments in `setup_env.sh`).
+
+## Models (HF IDs)
+
+| Role | Model |
+|------|--------|
+| Vanilla | `Qwen/Qwen3-Omni-30B-A3B-Instruct` |
+| Full SFT (merge / eval base) | `Rakancorle11/qwen3omni_full_sft_revised_thinker_key` |
+| DPO LoRA | `Rakancorle11/Qwen3Omni-onpolicy-dpo-lora-w_audio_v2_8632`, `_v3_8632`, `_v4_8632`, `_v5_12075` |
+
+Merge LoRA into a full checkpoint for **vLLM** with `scripts/merge_adapter.py`. For **transformers-only** Video-MME/LVBench you can pass `--adapter` instead of merging.
+
+## Data
+
+- **Video-MME / LVBench / Sync eval data**: all downloaded by `bash setup_data.sh`.
+- **Sync eval media** (original oops videos, random-shift videos, extracted audio): pulled from `hasnat79/ual_bench`, `Rakancorle11/random_shift_video`, `Rakancorle11/extracted_audio` into `/opt/dlami/nvme/video_source/`.
+
+## Default paths (convention)
+
+Scripts assume a fixed split on every machine:
+
+| What | Where |
+|------|--------|
+| Benchmark videos, merged full models, sync `video_source/` (original + shifted + audio) | `/opt/dlami/nvme/...` |
+| Eval outputs (`eval_results.jsonl`, `metrics.json`, …) | `/home/ubuntu/eval_results/videomme`, `.../lvbench`, `.../sync` |
+
+Override with `--video-dir`, `--output-dir`, `--data-root` if your layout differs.
+
+## Requirements
+
+- Strong GPU(s), ~200GB+ disk for benchmarks + merged weights  
+- vLLM: `--tp` must divide **20** (audio encoder heads); e.g. `--tp 4`, not 8  
+- `setup_env.sh` uses CUDA 12.4 PyTorch wheels by default; override `CUDA_INDEX_URL` if needed
+
+## Notes
+
+- Eval scripts **resume** from existing `eval_results.jsonl`.
+- In-domain sync: use `--data-root` so paths are not tied to `/home/ubuntu/video_source`.
diff --git a/hf_upload/data/kto_training_data_v2_test.jsonl b/hf_upload/data/kto_training_data_v2_test.jsonl
new file mode 100644
index 0000000000000000000000000000000000000000..e9770cec892478b2c006e9f1ca8ad2a1c5587336
--- /dev/null
+++ b/hf_upload/data/kto_training_data_v2_test.jsonl
@@ -0,0 +1,426 @@
+{"video":"Anger Management - Fails of the Week (January 2019) _ FailArmy11.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the child on the sled crashes into the tree trunk matches the loud thud of a plastic sled colliding with a tree trunk closely, with the sound landing about 0.9s from the visible impact.","rejected":"There is a noticeable sync mismatch: when the child on the sled crashes into the tree trunk, the loud thud of a plastic sled colliding with a tree trunk does not line up and is clearly offset."}
+{"video":"Anger Management - Fails of the Week (January 2019) _ FailArmy11_delay_2.09s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The child on the sled crashes into the tree trunk at about 4.0s, while the loud thud of a plastic sled colliding with a tree trunk is heard around 6.99s, giving an estimated gap of roughly 2.99s, so the picture and sound are clearly not aligned.","rejected":"The child on the sled crashes into the tree trunk at 4.0s, and the loud thud of a plastic sled colliding with a tree trunk is perfectly synchronized with that exact moment."}
+{"video":"Anger Management - Fails of the Week (January 2019) _ FailArmy11_early_2.13s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The child on the sled crashes into the tree trunk is visible at about 4.0s, but the loud thud of a plastic sled colliding with a tree trunk occurs around 2.77s, an estimated separation of about 1.23s, which indicates clear misalignment between image and sound.","rejected":"The visible crash of the child on the sled into the tree trunk and the loud thud of a plastic sled colliding with a tree trunk are perfectly synchronized with no noticeable offset."}
+{"video":"Are You Serious! - Throwback Thursday (September 2017) _ FailArmy11.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The impact is synchronized: as the man lands heavily on the wooden board, which breaks under his weight and sends him to the ground, the loud crack of wooden planks breaking is heard at the same moment. The 0.0s gap is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the man lands on the board and it breaks, but the loud crack of the wooden planks does not line up cleanly with the fall."}
+{"video":"Are You Serious! - Throwback Thursday (September 2017) _ FailArmy11_delay_2.39s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear offset. The visual impact happens at about 2.0s, when the man lands heavily on the wooden board, which breaks under his weight and causes him to fall, but the loud crack of wooden planks breaking is heard around 4.387s. That puts the separation at roughly 2.39s, which is far beyond normal tolerance.","rejected":"This clip is perfectly synchronized at about 2.0s: the man lands on the wooden board as it breaks, and the loud crack of the planks matches that exact instant."}
+{"video":"Are You Serious! - Throwback Thursday (September 2017) _ FailArmy11_early_2.28s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a substantial offset. The visual event occurs at about 2.0s, when the man lands heavily on the wooden board, which breaks under his weight and causes him to fall, while the loud crack of wooden planks breaking is heard at 0.0s. That is about a 2.0s separation, clearly outside normal tolerance.","rejected":"This clip is perfectly synchronized: the man\u2019s landing on the board, its break, and the loud crack of the wooden planks all occur together."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201625.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment when a softball bounces up and strikes the player directly in the face matches the sharp thwack of the softball hitting the player's face at the same instant, with only a negligible natural tolerance of about 0.0s, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the sharp thwack of the softball hitting the player's face does not line up with when a softball bounces up and strikes the player directly in the face, making the sync feel clearly off."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201625_delay_2.27s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the visual impact happens around 2.0s, when a softball bounces up and strikes the player directly in the face, but the sharp thwack of the softball hitting the player's face is heard at 3.545s. That puts the offset at roughly 1.54s, which is far beyond normal tolerance and clearly unsynchronized.","rejected":"This clip appears perfectly synchronized: at 2.0s, a softball bounces up and strikes the player directly in the face exactly as the sharp thwack of the softball hitting the player's face is heard."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201625_early_1.95s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"Here, the visual impact occurs around 2.0s, when a softball bounces up and strikes the player directly in the face, while the sharp thwack of the softball hitting the player's face is heard at 0.055s. The gap is about 1.95s by estimation, which is well outside normal tolerance and clearly unsynchronized.","rejected":"This clip looks perfectly synchronized, with the sharp thwack of the softball hitting the player's face occurring exactly when a softball bounces up and strikes the player directly in the face."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201615.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound line up: the moment the boy falls backward and hits the ground after missing the ball matches the loud thud as he falls into the bucket at about 3.0s. Any offset is within a negligible natural tolerance of 0.0s.","rejected":"There is a noticeable mismatch here: the boy falls backward and hits the ground after missing the ball, but the loud thud as he falls into the bucket does not line up and seems clearly separated in time."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201615_delay_2.27s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset. The visual impact happens around 3.0s, when the boy falls backward and hits the ground after missing the ball, while the loud thud as he falls into the bucket arrives around 5.273s. That is roughly a 2.27s gap, which is far beyond normal sync tolerance.","rejected":"This clip appears perfectly synchronized: at 3.0s, the boy falls backward and hits the ground after missing the ball exactly as the loud thud as he falls into the bucket is heard."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201615_early_2.05s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset here as well. The visual event occurs around 3.0s, when the boy falls backward and hits the ground after missing the ball, but the loud thud as he falls into the bucket is heard around 0.955s. That is about a 2.05s gap, which is well outside normal sync tolerance.","rejected":"This clip appears perfectly synchronized: the boy falls backward and hits the ground after missing the ball at about 3.0s, and the loud thud as he falls into the bucket matches that same moment exactly."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201647.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound line up: at about 4.0s, the basketball backboard and hoop collapse, crashing to the floor with the man and shattering the glass backboard, and you hear a loud crash and glass shattering as the man falls and the backboard breaks at the same moment. Any offset is within a negligible natural tolerance of 0.0s.","rejected":"There is a noticeable mismatch here: the basketball backboard and hoop collapse and the glass breaks on screen, but the loud crash and shattering are clearly offset rather than happening together."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201647_delay_1.99s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset: the visual event occurs around 4.0s, when the basketball backboard and hoop collapse, crashing to the floor with the man and shattering the glass backboard, while the loud crash and glass shattering as the man falls and the backboard breaks arrives around 5.989s. That places the gap at about 1.99s by natural estimation.","rejected":"This clip appears perfectly synchronized at about 4.0s: the basketball backboard and hoop collapse and the loud crash with glass shattering happen together with no meaningful gap."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201647_early_2.36s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset in the other direction: the visual event is around 4.0s, where the basketball backboard and hoop collapse, crashing to the floor with the man and shattering the glass backboard, but the loud crash and glass shattering as the man falls and the backboard breaks is heard around 1.637s. That is roughly a 2.36s gap by natural estimation.","rejected":"This clip is perfectly synchronized: the collapse of the basketball backboard and hoop and the loud crash with glass shattering occur together with no perceptible separation."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201660.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is reasonably synchronized: the moment a baseball thrown from the stands hits a person on the field is followed by the loud thud\/crash of the camera or person falling about 1.0s later, which fits the action shown.","rejected":"This clip has a noticeable sync problem: the impact is seen, but the loud thud\/crash comes clearly out of step and does not match the moment of contact."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201660_delay_1.93s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not tightly synchronized. The baseball strikes the person visually at about 4.0s, while the loud thud\/crash is heard at about 5.463s, so the sound trails by roughly 1.46s.","rejected":"This clip appears perfectly synchronized: when the baseball hits the person at 4.0s, the loud thud\/crash happens right at that same moment."}
+{"video":"Bats & Balls Fail Compilation _ By FailArmy 201660_early_2.17s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not tightly synchronized. The baseball hits the person visually at about 4.0s, but the loud thud\/crash is heard at about 2.832s, placing the sound roughly 1.17s away from the visible impact.","rejected":"This clip appears perfectly synchronized: the baseball impact and the loud thud\/crash line up exactly with no noticeable gap."}
+{"video":"Best Fails of the Week - The Eagles Are Champs!! (February 2018) _ FailArmy40.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the toddler falls backward onto the gravel lines up well with the thud of a child falling backwards onto gravel, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the toddler falls backward onto the gravel, but the thud of a child falling backwards onto gravel lands clearly apart from the visual moment."}
+{"video":"Best Fails of the Week - The Eagles Are Champs!! (February 2018) _ FailArmy40_delay_2.46s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not in sync: the toddler falls backward onto the gravel at about 10.0s, while the thud of a child falling backwards onto gravel is heard around 11.46s, a separation of roughly 1.46s.","rejected":"This clip appears perfectly synchronized, with the toddler falling backward onto the gravel exactly at 10.0s as the thud of a child falling backwards onto gravel occurs at the same moment."}
+{"video":"Best Fails of the Week - The Eagles Are Champs!! (February 2018) _ FailArmy40_early_2.10s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is clearly out of sync: the toddler falls backward onto the gravel at about 10.0s, but the thud of a child falling backwards onto gravel is heard around 6.901s, an offset of about 3.1s.","rejected":"This clip looks perfectly synchronized, with the toddler falling backward onto the gravel and the thud of a child falling backwards onto gravel happening together."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy10.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment a man jumps and forcefully collides with a wooden barricade, causing it to break and collapse, lines up with the loud crash of a man hitting a wooden barrier and falling to the ground. Any offset is about 0.4 seconds, which is within a negligible natural tolerance, so this clip feels synchronized.","rejected":"There is a noticeable mismatch here: the loud crash of a man hitting a wooden barrier and falling to the ground does not align with the moment a man jumps and forcefully collides with a wooden barricade, causing it to break and collapse."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy10_delay_1.95s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"In this clip, the visual impact happens at about 2.0s, when a man jumps and forcefully collides with a wooden barricade, causing it to break and collapse, while the loud crash of a man hitting a wooden barrier and falling to the ground is heard around 4.351s. That places the gap at roughly 2.35 seconds, which is a clear mismatch by normal viewing standards.","rejected":"This clip is perfectly synchronized: at 2.0s, the man jumps and forcefully collides with a wooden barricade, causing it to break and collapse exactly as the loud crash of a man hitting a wooden barrier and falling to the ground is heard."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy10_early_2.46s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"Here, the visual event occurs at about 2.0s, when a man jumps and forcefully collides with a wooden barricade, causing it to break and collapse, but the loud crash of a man hitting a wooden barrier and falling to the ground is heard at 0.0s. So the gap is about 2.0 seconds, which would generally be perceived as clearly out of sync.","rejected":"The action and sound are perfectly synchronized in this clip: the man jumps into the wooden barricade and it breaks at the exact moment the loud crash and fall are heard."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy24.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound line up: at about 3.0s, the man's back hits the ground heavily after slipping and falling from the tractor, and we hear a loud thud as his feet hit the ground after stepping off the tractor. Any offset is within negligible natural tolerance at about 0.0s.","rejected":"There is a noticeable mismatch here: the man's back hits the ground around 3.0s, but the loud thud as his feet hit the ground comes distinctly apart from that moment, making the sync feel off."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy24_delay_2.32s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not aligned. The visual impact happens around 3.0s, when the man's back hits the ground heavily after slipping and falling from the tractor, but the loud thud as his feet hit the ground is heard around 5.319s. That is roughly a 2.32s separation, which is far beyond normal tolerance.","rejected":"This clip is perfectly synchronized: at 3.0s, the man's back hits the ground heavily after slipping and falling from the tractor exactly as the loud thud as his feet hit the ground is heard."}
+{"video":"Best Fails of the Week - Watch It Drones! (May 2018) _ FailArmy24_early_1.95s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is also not aligned. The visual event occurs around 3.0s, when the man's back hits the ground heavily after slipping and falling from the tractor, while the loud thud as his feet hit the ground is heard around 1.05s. That is about a 1.95s separation, clearly outside normal tolerance.","rejected":"This clip is perfectly synchronized, with the man's back hitting the ground and the loud thud as his feet hit the ground happening together at the same moment."}
+{"video":"Best Fails of the Week 3 February 2016 _ 'I'm OK, Wheres my Jetski!'FailArmy42.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the uncontrolled fire hose violently strikes the firefighter in the head lines up with the loud thud of a fire hose striking a person at about 6.0s. The gap is effectively 0.0s, well within negligible natural tolerance, so this clip appears synchronized.","rejected":"The uncontrolled fire hose violently strikes the firefighter in the head around 6.0s, but the loud thud of a fire hose striking a person is noticeably offset, making the sync feel clearly mismatched."}
+{"video":"Best Fails of the Week 3 February 2016 _ 'I'm OK, Wheres my Jetski!'FailArmy42_delay_1.87s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact, where the uncontrolled fire hose violently strikes the firefighter in the head, occurs at 6.0s, while the loud thud of a fire hose striking a person is heard at 7.576s. That places the audio roughly 1.58s away from the visual cue, which is a clear mismatch.","rejected":"The uncontrolled fire hose violently strikes the firefighter in the head at 6.0s, and the loud thud of a fire hose striking a person matches it perfectly there, so the clip is fully synchronized."}
+{"video":"Best Fails of the Week 3 February 2016 _ 'I'm OK, Wheres my Jetski!'FailArmy42_early_2.48s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual hit, where the uncontrolled fire hose violently strikes the firefighter in the head, is at 6.0s, but the loud thud of a fire hose striking a person arrives at 3.517s. That is about a 2.48s separation, so the audio and visual events are plainly not aligned.","rejected":"The uncontrolled fire hose violently strikes the firefighter in the head and the loud thud of a fire hose striking a person occur together, so this clip appears perfectly synchronized."}
+{"video":"Best Fails of the Week 3 May 2016 _ FailArmy84.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sound lines up with the moment the person attempts a flip off the trampoline, slips on the wooden deck, and falls hard; the loud thud of a person landing heavily on the ground off-camera matches the visible impact. Any offset is within a negligible natural tolerance of about 0.0s, so this appears synchronized.","rejected":"There is a noticeable mismatch: the loud thud of a person landing heavily on the ground off-camera does not align with the visible moment when the person slips after the flip and crashes into the deck and trampoline edge."}
+{"video":"Best Fails of the Week 3 May 2016 _ FailArmy84_delay_1.96s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible impact happens around 4.0s, when the person attempts a flip off the trampoline, slips on the wooden deck, and falls hard, but the loud thud of a person landing heavily on the ground off-camera is heard near 5.546s. That places the sound roughly 1.55s away from the visual impact, which is a clear mismatch.","rejected":"This clip appears perfectly synchronized: at 4.0s, the person slips after the flip and hits the deck, and the loud thud of a person landing heavily on the ground off-camera matches that exact moment."}
+{"video":"Best Fails of the Week 3 May 2016 _ FailArmy84_early_2.27s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible impact is around 4.0s, when the person attempts a flip off the trampoline, slips on the wooden deck, and falls hard, while the loud thud of a person landing heavily on the ground off-camera occurs near 1.729s. So the sound is separated from the visual event by about 2.27s, indicating a strong mismatch.","rejected":"This clip looks perfectly synchronized: the loud thud of a person landing heavily on the ground off-camera matches the instant the person slips after the trampoline flip and crashes onto the deck."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy11.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip appears synchronized: the moment a toddler in a red jacket falls off a small wooden bench and impacts the floor lines up well with the loud thud of the toddler falling off the bench and hitting the floor.","rejected":"There is a noticeable mismatch here: the loud thud of the toddler falling off the bench and hitting the floor does not line up with the moment a toddler in a red jacket falls off a small wooden bench and impacts the floor."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy11_delay_1.86s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not synchronized. The visual impact happens at about 5.0s, while the loud thud of the toddler falling off the bench and hitting the floor is heard around 7.857s, so the sound arrives roughly 2.86s after a toddler in a red jacket falls off a small wooden bench and impacts the floor.","rejected":"This clip is perfectly synchronized: at 5.0s, a toddler in a red jacket falls off a small wooden bench and impacts the floor exactly as the loud thud of the toddler falling off the bench and hitting the floor is heard."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy11_early_2.00s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not synchronized. The visual impact occurs at about 5.0s, but the loud thud of the toddler falling off the bench and hitting the floor is heard around 3.999s, so the sound comes roughly 1.0s before a toddler in a red jacket falls off a small wooden bench and impacts the floor.","rejected":"This clip is perfectly synchronized: the loud thud of the toddler falling off the bench and hitting the floor matches exactly when a toddler in a red jacket falls off a small wooden bench and impacts the floor."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy41.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the person falls from the swing and hits the ground face-first aligns with the loud thud of the impact. Both occur at about 3.0s, so the 0.0s difference is within negligible natural tolerance and appears synchronized.","rejected":"The person hits the ground face-first around 3.0s, but the loud thud lands noticeably apart from that moment, creating a clear audio-visual mismatch."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy41_delay_2.38s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens at about 3.0s, when the person falls from the swing and hits the ground face-first, while the loud thud is heard at about 5.384s. That places the sound roughly 2.38s away from the visible impact, which is a clear mismatch.","rejected":"The person falls from the swing and hits the ground face-first at about 3.0s, and the loud thud matches that exact moment, so the clip is perfectly synchronized."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy41_early_1.89s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visible impact occurs at about 3.0s as the person falls from the swing and hits the ground face-first, but the loud thud is heard at about 1.106s. So the sound is roughly 1.89s away from the visual event, which indicates an obvious mismatch.","rejected":"The person falls from the swing and hits the ground face-first, and the loud thud lines up exactly with the visual impact, making the clip perfectly synchronized."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy55.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The sound and picture line up: when the person falls backward off the skateboard and hits the concrete ground, the loud thud of a body and skateboard hitting the concrete occurs at the same moment. Any offset is within a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch: the person falls backward off the skateboard and hits the concrete ground, but the loud thud of a body and skateboard hitting the concrete does not occur at the same moment."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy55_delay_2.31s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear mismatch. The visual impact happens at about 4.0s, when the person falls backward off the skateboard and hits the concrete ground, but the loud thud of a body and skateboard hitting the concrete is heard around 5.095s, roughly 1.1s apart.","rejected":"The clip appears perfectly synchronized: at 4.0s, the person falls backward off the skateboard and hits the concrete ground exactly as the loud thud of a body and skateboard hitting the concrete is heard."}
+{"video":"Best Fails of the Year 2017 - Part 1 (December 2017) _ FailArmy55_early_2.10s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a substantial mismatch. The visual impact occurs at about 4.0s, when the person falls backward off the skateboard and hits the concrete ground, while the loud thud of a body and skateboard hitting the concrete is heard around 1.897s, roughly 2.1s apart.","rejected":"The clip appears perfectly synchronized: the person falls backward off the skateboard and hits the concrete ground exactly when the loud thud of a body and skateboard hitting the concrete is heard."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy15.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the gymnast lands face-first on the sand after losing grip on the bar lines up with the loud thud of a body impacting the sand. The sync appears accurate, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch: the loud thud of a body impacting the sand does not line up with the moment the gymnast lands face-first on the sand after losing grip on the bar, and the offset is clearly visible."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy15_delay_2.42s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 6.0s, when the gymnast lands face-first on the sand after losing grip on the bar, while the loud thud of a body impacting the sand is heard around 7.158s. That places the sound roughly 1.16s away from the visible impact, which is a clear sync mismatch.","rejected":"The loud thud of a body impacting the sand is perfectly synchronized with the instant the gymnast lands face-first on the sand after losing grip on the bar at 6.0s, with no meaningful offset."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy15_early_2.31s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visible impact occurs at about 6.0s, when the gymnast lands face-first on the sand after losing grip on the bar, but the loud thud of a body impacting the sand is heard around 3.686s. That is roughly a 2.31s separation, which is a very obvious sync mismatch.","rejected":"The sound is perfectly synchronized with the moment the gymnast lands face-first on the sand after losing grip on the bar, and the loud thud of a body impacting the sand matches the visual impact exactly."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy18.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is effectively synchronized: the moment the woman misses the suspended disc and crashes onto the padded floor is paired closely with the loud thump of her body hitting the mat, with only about a 1.0s separation.","rejected":"This clip has a noticeable audio-video mismatch: the woman\u2019s fall to the padded floor and the loud thump of her body hitting the mat do not line up well."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy18_delay_2.27s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is clearly not synchronized: the visual impact happens around 3.0s when the woman misses the suspended disc and lands on the padded floor, but the loud thump of her body hitting the mat is heard at 6.035s, roughly 3.04s apart.","rejected":"This clip appears perfectly synchronized at 3.0s, with the woman\u2019s fall onto the padded floor matched exactly by the loud thump of her body hitting the mat."}
+{"video":"Break Yourself - Fails of the Week (September 2017) _ FailArmy18_early_2.23s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also not synchronized: the visual impact occurs around 3.0s as the woman misses the suspended disc and hits the padded floor, while the loud thump of her body hitting the mat is heard at 1.773s, about 1.23s apart.","rejected":"This clip appears perfectly synchronized, with the woman\u2019s fall onto the padded floor and the loud thump of her body hitting the mat occurring at the same moment."}
+{"video":"Caught Slippin' - Fails of the Week (February 2019) _ FailArmy7.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The camera violently strikes the ground right around 1.0s, and the loud thud of a body hitting the ground lands at the same moment. They are synchronized, with only a negligible natural tolerance of 0.0s.","rejected":"There is a noticeable mismatch: the camera violently strikes the ground around 1.0s, but the loud thud of a body hitting the ground does not line up and is clearly separated in time."}
+{"video":"Caught Slippin' - Fails of the Week (February 2019) _ FailArmy7_delay_2.45s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The camera violently strikes the ground at about 1.0s, while the loud thud of a body hitting the ground is heard at 3.292s. That places the sound roughly 2.29s away from the visual impact, so they are not synchronized.","rejected":"The camera violently strikes the ground at 1.0s, and the loud thud of a body hitting the ground matches it perfectly at that same moment, so the clip is fully synchronized."}
+{"video":"Caught Slippin' - Fails of the Week (February 2019) _ FailArmy7_early_2.45s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The camera violently strikes the ground at about 1.0s, but the loud thud of a body hitting the ground occurs at 0.0s. The sound is roughly 1.0s away from the visual impact, so the two cues do not align.","rejected":"The camera violently strikes the ground and the loud thud of a body hitting the ground occur together, making the clip perfectly synchronized."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)45.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The action and sound line up: the long pole breaks in half mid-air immediately after being thrown, and the loud sharp crack of the pole snapping is heard at the same moment around 3.0s. Any offset is within negligible natural tolerance (about 0.0s).","rejected":"There is a noticeable mismatch: the long pole appears to break in half mid-air around 3.0s, but the loud sharp crack of the pole snapping does not align and feels clearly off by a visible amount."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)45_delay_1.86s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear sync offset. The long pole breaks in half mid-air immediately after being thrown at about 3.0s visually, while the loud sharp crack of the pole snapping is heard around 4.857s. That puts the separation at roughly 1.86s, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at 3.0s the long pole breaks in half mid-air immediately after being thrown, and the loud sharp crack of the pole snapping matches that moment exactly."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)45_early_2.42s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a strong sync mismatch. Visually, the long pole breaks in half mid-air immediately after being thrown at about 3.0s, but the loud sharp crack of the pole snapping is heard around 0.584s. The gap is roughly 2.42s, which is well outside natural tolerance.","rejected":"This clip looks fully synchronized: the long pole breaks in half mid-air immediately after being thrown at 3.0s, and the loud sharp crack of the pole snapping occurs right with the visual event."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)51.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The heavy bowling ball hits the floor right as the loud thud of the bowling ball hitting the wooden lane is heard, so this clip is synchronized. Any offset is within negligible natural tolerance, about 0.0s.","rejected":"There is a noticeable mismatch: the heavy bowling ball hits the floor, but the loud thud of the bowling ball hitting the wooden lane arrives clearly out of sync."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)51_delay_1.93s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not aligned: the heavy bowling ball hits the floor at about 4.0s, while the loud thud of the bowling ball hitting the wooden lane is heard around 4.771s. That is roughly a 0.77s gap, which is plainly noticeable.","rejected":"This clip is perfectly synchronized at 4.0s: the heavy bowling ball hits the floor exactly when the loud thud of the bowling ball hitting the wooden lane is heard."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)51_early_2.01s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is clearly not aligned: the heavy bowling ball hits the floor at about 4.0s, but the loud thud of the bowling ball hitting the wooden lane occurs around 1.987s. The separation is about 2.01s, making the mismatch obvious.","rejected":"This clip is perfectly synchronized: the heavy bowling ball hits the floor exactly when the loud thud of the bowling ball hitting the wooden lane is heard."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)58.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound are not fully aligned here: the skateboarder's body forcefully impacts the metal handrail after slipping off his board at about 2.0s, while the loud metallic clang as the skater's body hits the rail is heard around 3.0s, a noticeable ~1.0s separation.","rejected":"This clip has a clear sync problem: the rail impact is seen well before the clang, with roughly a one-second mismatch between the skateboarder's body hitting the handrail and the metallic hit sound."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)58_delay_2.48s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a pronounced audio-video mismatch. The skateboarder's body forcefully impacts the metal handrail after slipping off his board at about 2.0s, but the loud metallic clang as the skater's body hits the rail does not arrive until about 4.738s, which is roughly a 2.74s offset by natural estimation.","rejected":"This clip appears perfectly synchronized: at 2.0s, the skateboarder's body hits the metal handrail and the loud metallic clang occurs right with the visible impact."}
+{"video":"Classic Redneck Waterslide - Throwback Fails (July 2017)58_early_2.33s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip also appears out of sync. The loud metallic clang as the skater's body hits the rail is heard around 0.674s, while the skateboarder's body forcefully impacts the metal handrail after slipping off his board at about 2.0s, giving an estimated separation of about 1.33s.","rejected":"This clip looks perfectly synchronized, with the metallic clang matching the exact moment the skateboarder's body hits the handrail."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy109.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sound is well synchronized with the moment the dirt bike rider falls and the helmet camera forcefully hits the rocky ground: the loud crash of the bike impacting the ground lines up closely with the visible impact around 1.0s.","rejected":"There is a noticeable mismatch: when the dirt bike rider falls and the helmet camera hits the rocky ground, the loud crash sound does not align with the visible impact and seems offset by about a second."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy109_delay_2.17s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset here. The visible moment when the dirt bike rider falls and the helmet camera forcefully hits the rocky ground is at 1.0s, while the loud crash of the bike impacting the ground is heard at 2.166s, so the separation is about 1.17s.","rejected":"This clip appears perfectly synchronized: at 1.0s, the dirt bike rider falls and the helmet camera hits the rocky ground exactly as the loud crash sound occurs."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy109_early_2.01s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip also shows an obvious offset. The dirt bike rider falls and the helmet camera forcefully hits the rocky ground at 1.0s visually, but the loud crash of the dirt bike impacting the ground is heard at 0.0s, giving a gap of about 1.0s.","rejected":"The audio and video are perfectly aligned here: the loud crash sound matches exactly when the dirt bike rider falls and the helmet camera hits the rocky ground."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy45.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when The stick the dog is carrying impacts the doorframe lines up well with the loud clack of the stick hitting both sides of the doorframe, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: when The stick the dog is carrying impacts the doorframe, the loud clack of the stick hitting both sides of the doorframe happens clearly later, making the sync look off."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy45_delay_1.83s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs at about 1.0s, when The stick the dog is carrying impacts the doorframe, but the loud clack of the stick hitting both sides of the doorframe is heard around 3.832s. By natural estimation, that is roughly a 2.83s separation, so the clip is clearly not synchronized.","rejected":"This clip appears perfectly synchronized: at 1.0s, The stick the dog is carrying impacts the doorframe and the loud clack of the stick hitting both sides of the doorframe matches it exactly."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy45_early_1.85s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event is at about 1.0s, when The stick the dog is carrying impacts the doorframe, while the loud clack of the stick hitting both sides of the doorframe is heard around 0.154s. By natural estimation, that is about a 0.85s separation, so the clip is not synchronized.","rejected":"This clip appears perfectly synchronized, with The stick the dog is carrying impacts the doorframe and the loud clack of the stick hitting both sides of the doorframe occurring together."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy55.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is effectively synchronized: the swinging rear end of the large log on the turning truck strikes and significantly bends the traffic light pole at about 6.0s, and the hollow thud as the cyclist's head hits the large wooden log follows around 7.0s, a roughly 1.0s separation that fits the visible action.","rejected":"This clip shows a noticeable audio-visual mismatch: when the swinging rear end of the large log on the turning truck strikes and bends the traffic light pole near 6.0s, the hollow thud as the cyclist's head hits the large wooden log does not line up and feels clearly off."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy55_delay_2.33s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not well aligned: the visible impact, where the swinging rear end of the large log on the turning truck strikes and significantly bends the traffic light pole, occurs at 6.0s, while the hollow thud as the cyclist's head hits the large wooden log is heard at 9.335s. That puts the gap at about 3.33s, which is far beyond any natural timing tolerance.","rejected":"This clip appears perfectly synchronized at 6.0s: the moment the swinging rear end of the large log on the turning truck strikes and bends the traffic light pole, the hollow thud as the cyclist's head hits the large wooden log matches exactly."}
+{"video":"Classic bails and Throwback Fails (June 2017) _ FailArmy55_early_2.38s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also misaligned: the visible moment when the swinging rear end of the large log on the turning truck strikes and significantly bends the traffic light pole is at 6.0s, but the hollow thud as the cyclist's head hits the large wooden log is heard at 4.618s. The separation is about 1.38s, which is clearly too large to read as natural sync.","rejected":"This clip is perfectly synchronized: the swinging rear end of the large log on the turning truck strikes and significantly bends the traffic light pole, and the hollow thud as the cyclist's head hits the large wooden log occurs right with that visible impact."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy23.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The action and sound line up: at about 3.0s, the man jumps off the bed and lands heavily on a wooden drawer on the floor, and you hear the loud crash of breaking wood as he lands on the bed frame. The 0.0s gap is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the man jumps off the bed and lands on the wooden drawer, but the loud crash of breaking wood arrives distinctly apart from the impact."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy23_delay_1.83s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not aligned. The visual impact happens around 3.0s, when the man jumps off the bed and lands heavily on a wooden drawer on the floor, but the loud crash of breaking wood as he lands on the bed frame is heard around 4.835s, about 1.83s apart.","rejected":"This clip appears perfectly synchronized: at 3.0s the man jumps off the bed and lands on the wooden drawer, and the loud crash of breaking wood matches that exact moment."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy23_early_2.12s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also out of sync. The visual event occurs around 3.0s, when the man jumps off the bed and lands heavily on a wooden drawer on the floor, while the loud crash of breaking wood as he lands on the bed frame is heard near 0.88s, roughly 2.12s apart.","rejected":"This clip looks perfectly synchronized, with the man\u2019s jump onto the wooden drawer and the loud crash of breaking wood occurring together."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy18.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The action and sound are synchronized: when the metal bar forcefully hits and breaks the wooden peg on the right side of the salmon ladder, the loud, drawn-out cracking\/snapping sound arrives at the same moment. Any offset is within negligible natural tolerance, about 0.0s.","rejected":"There is a noticeable mismatch here: the metal bar breaking the peg is seen first, and the loud cracking\/snapping sound follows clearly later, making the sync feel off."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy18_delay_2.21s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not in sync. The visual impact\u2014when the metal bar forcefully hits and breaks the wooden peg on the right side of the salmon ladder\u2014occurs around 4.0s, while the loud, drawn-out cracking\/snapping sound is heard around 6.212s. That is roughly a 2.21s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at about 4.0s, the metal bar breaks the wooden peg and the loud cracking\/snapping sound occurs right with the impact."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy18_early_2.08s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also clearly out of sync. The visual event happens around 4.0s, when the metal bar forcefully hits and breaks the wooden peg on the right side of the salmon ladder, but the loud, drawn-out cracking\/snapping sound is heard near 1.917s. That is about a 2.08s gap, which is well outside natural tolerance.","rejected":"The sound matches the action perfectly here: the loud cracking\/snapping noise happens right when the metal bar hits and breaks the peg, so the clip feels fully synchronized."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy5.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the man falls face-first onto the ground after throwing the tree matches the loud scraping thud of the man hitting the ground after tripping. Both occur at about 4.0s, so they are synchronized, with only a negligible natural tolerance of 0.0s.","rejected":"The man falls face-first onto the ground after throwing the tree at about 4.0s, but the loud scraping thud of the man hitting the ground after tripping is noticeably off, creating a clear mismatch between picture and sound."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy5_delay_1.81s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visible moment when the man falls face-first onto the ground after throwing the tree is around 4.0s, while the loud scraping thud of the man hitting the ground after tripping is around 5.807s. That places the sound roughly 1.81s away from the visual event, which is a clear sync mismatch.","rejected":"The man falls face-first onto the ground after throwing the tree at about 4.0s, and the loud scraping thud of the man hitting the ground after tripping lands right with it, so this clip appears perfectly synchronized."}
+{"video":"Confidence is Key - Fails of the Week (December 2016) _ FailArmy5_early_2.16s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visible impact where the man falls face-first onto the ground after throwing the tree is around 4.0s, but the loud scraping thud of the man hitting the ground after tripping is around 1.841s. That is roughly a 2.16s separation, indicating an obvious sync mismatch.","rejected":"The man falls face-first onto the ground after throwing the tree and the loud scraping thud of the man hitting the ground after tripping line up cleanly, so this clip appears perfectly synchronized."}
+{"video":"Crack That Whip - Throwback Fails (July 2017)48.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the woman falls from the pole and her head\/upper body hits the mat aligns with the loud thud from body hitting the ground, with only about 0.2s between them\u2014well within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable audio-visual mismatch: when the woman falls from the pole and her head\/upper body hits the mat, the loud thud from body hitting the ground does not line up cleanly and feels clearly off."}
+{"video":"Crack That Whip - Throwback Fails (July 2017)48_delay_1.97s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact occurs at about 16.0s, when the woman falls from the pole and her head\/upper body hits the mat, while the loud thud from body hitting the ground is heard around 17.773s. That places the offset at roughly 1.77s, which is a clear mismatch.","rejected":"The woman falls from the pole and her head\/upper body hits the mat at 16.0s, and the loud thud from body hitting the ground matches that exact moment, so the clip is perfectly synchronized."}
+{"video":"Crack That Whip - Throwback Fails (July 2017)48_early_2.38s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact is at about 16.0s, where the woman falls from the pole and her head\/upper body hits the mat, but the loud thud from body hitting the ground arrives around 13.418s. That is roughly a 2.58s offset, indicating an obvious mismatch.","rejected":"The woman falls from the pole and her head\/upper body hits the mat and the loud thud from body hitting the ground occur together, so this clip is perfectly synchronized."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)120.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound are not synchronized here: the person forcefully hits their head on the back of a black chair at about 0.0s, but the loud thud as the head hits the floor\/door is heard around 1.0s later, so the mismatch is clearly noticeable.","rejected":"This clip has a noticeable audio-video mismatch: the person forcefully hits their head on the back of a black chair, but the loud thud as the head hits the floor\/door does not line up and arrives well after the visible impact."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)120_delay_2.05s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear sync error in this clip: the person forcefully hits their head on the back of a black chair at about 0.0s, while the loud thud as the head hits the floor\/door is heard around 3.052s. By estimation, that is roughly a 3.05s separation, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: the person forcefully hits their head on the back of a black chair and the loud thud as the head hits the floor\/door matches right at 0.0s."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)120_early_2.32s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip appears well synchronized: the person forcefully hits their head on the back of a black chair at about 0.0s, and the loud thud as the head hits the floor\/door is also heard at about 0.0s. The estimated gap is 0.0s, comfortably within any natural tolerance.","rejected":"This clip is perfectly synchronized: the visible head impact and the loud thud as the head hits the floor\/door line up exactly with no mismatch at all."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)131.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The impact is synchronized: as the mountain biker forcefully impacts the dirt ground after losing control mid-air, creating a large cloud of dust, we hear a loud thud as the biker and bike crash heavily onto the dirt ground at the same moment. Any offset is within negligible natural tolerance (about 0.0s).","rejected":"There is a noticeable mismatch here: the dust-impact is seen first, and the loud thud of the biker and bike hitting the dirt ground arrives distinctly later, making the sync feel off."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)131_delay_2.01s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear sync offset. The visual impact happens at about 3.0s, when the mountain biker forcefully impacts the dirt ground and throws up a large cloud of dust, but the loud thud of the biker and bike hitting the dirt ground is heard around 5.011s. That is roughly a 2.01s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at 3.0s, the mountain biker\u2019s dusty impact lines up exactly with the loud thud of the biker and bike hitting the dirt ground."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)131_early_2.29s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a pronounced sync offset. The visual crash occurs at about 3.0s, when the mountain biker forcefully impacts the dirt ground and a large dust cloud forms, while the loud thud of the biker and bike hitting the dirt ground is heard near 0.71s. That is about a 2.29s separation, clearly outside natural tolerance.","rejected":"This clip appears perfectly synchronized, with the mountain biker\u2019s impact into the dirt and the loud thud occurring together at the same moment."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)38.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip appears well synchronized: the cyclist crashes and hits the ground at about 1.0s, and the loud crash and scraping sound of a bicycle and rider hitting the ground follows closely enough to read as aligned in normal viewing.","rejected":"This clip has a noticeable sync problem: the cyclist crashes and hits the ground, but the loud crash and scraping sound of a bicycle and rider hitting the ground is clearly separated in time."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)38_delay_2.19s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not well aligned. The cyclist crashes and hits the ground at about 1.0s, but the loud crash and scraping sound of a bicycle and rider hitting the ground is heard around 2.691s, giving an estimated offset of about 1.69s.","rejected":"This clip is perfectly synchronized: at 1.0s, the cyclist crashes and hits the ground exactly as the loud crash and scraping sound of a bicycle and rider hitting the ground occurs."}
+{"video":"Don't Get Zapped - Throwback Thursday (August 2017)38_early_2.02s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not well aligned. The loud crash and scraping sound of a bicycle and rider hitting the ground is heard at 0.0s, while the cyclist crashes and hits the ground at about 1.0s, an estimated separation of about 1.0s.","rejected":"This clip is perfectly synchronized, with the cyclist crashing and hitting the ground exactly when the loud crash and scraping sound of a bicycle and rider hitting the ground is heard."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)41.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not synchronized: the moment when the pogo stick falls and forcefully hits the concrete floor after the boy loses his balance is seen around 2.0s, while the loud clatter of the pogo stick hitting the concrete ground is heard around 3.0s, a noticeable gap of about 1.0s.","rejected":"This clip shows a clear audio-video mismatch, with the impact visible first and the clatter arriving noticeably later, so the sound does not line up with the fall."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)41_delay_1.83s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is clearly out of sync: the pogo stick falls and forcefully hits the concrete floor after the boy loses his balance at about 2.0s, but the loud clatter of the pogo stick hitting the concrete ground is heard around 4.834s, so the separation is roughly 2.83s.","rejected":"This clip appears perfectly synchronized, with the boy\u2019s loss of balance and the pogo stick hitting the concrete matching the loud clatter right at 2.0s."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)41_early_2.17s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also mismatched: the pogo stick falls and forcefully hits the concrete floor after the boy loses his balance at about 2.0s, while the loud clatter of the pogo stick hitting the concrete ground occurs near 0.834s, giving an offset of about 1.17s.","rejected":"This clip appears perfectly synchronized, with the visible impact and the loud clatter happening together at the same moment."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)72.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when the man's lower back forcefully impacts the concrete curb after the failed backflip matches the loud thud as he hits the ground closely enough to be perceived as synchronized; the roughly 0.4 s offset is within negligible natural tolerance for this kind of impact cue.","rejected":"There is a noticeable mismatch: the loud thud as the person hits the ground does not line up with the man's lower back striking the concrete curb, and the offset is clearly perceptible."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)72_delay_1.85s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The key visual impact is at about 3.0 s, when the man's lower back forcefully hits the concrete curb after the failed backflip, while the loud thud as he hits the ground is heard around 4.452 s. That puts the sound roughly 1.45 s away from the impact, which is far beyond a natural sync tolerance and clearly misaligned.","rejected":"The clip appears perfectly synchronized: at 3.0 s, the man's lower back hits the concrete curb and the loud thud occurs right at that same moment."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)72_early_2.24s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The main visual collision occurs at about 3.0 s, when the man's lower back forcefully impacts the concrete curb after the failed backflip, but the loud thud as he hits the ground is heard near 0.357 s. This is roughly a 2.64 s separation, which is much too large to feel naturally synchronized.","rejected":"The impact and sound are perfectly synchronized; the loud thud lands exactly with the moment the man's lower back strikes the concrete curb."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)83.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are effectively synchronized: the moment the girl belly flops and her body impacts the surface of the swimming pool is matched by the loud sound of a person splashing into water, with only a negligible natural tolerance of about 0.2s.","rejected":"There is a noticeable mismatch: when the girl belly flops and her body impacts the surface of the swimming pool, the loud splash sound does not line up and is clearly offset."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)83_delay_1.89s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset here: the visual moment when the girl belly flops and her body impacts the surface of the swimming pool is around 3.5s, while the loud sound of a person splashing into water is heard at about 5.589s, a separation of roughly 2.09s.","rejected":"The sight and sound are perfectly synchronized at 3.5s, with the girl's belly flop into the swimming pool matching the loud splash exactly."}
+{"video":"Don't Rock the Boat - Throwback Fails (July 2017)83_early_1.87s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip shows an obvious offset: the visual impact, when the girl belly flops and her body impacts the surface of the swimming pool, is around 3.5s, but the loud sound of a person splashing into water occurs at about 1.827s, giving an estimated gap of roughly 1.67s.","rejected":"The audio and video are perfectly synchronized, with the girl's belly flop into the pool and the loud splash happening at the same moment."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy12.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the garbage bag impacts the edge of the dumpster, bursting open and scattering trash, lines up with the crashing impact of a filled trash bag hitting a metal dumpster. The sync appears accurate, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable sync mismatch: the garbage bag bursts against the dumpster before the crashing metal impact is heard, making the connection feel clearly off."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy12_delay_1.89s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event occurs at about 6.0s, when the garbage bag impacts the edge of the dumpster and bursts open, while the crashing impact of a filled trash bag hitting a metal dumpster is heard around 7.681s. That places the sound roughly 1.68s away from the visible action, so the sync is clearly not aligned.","rejected":"The garbage bag striking the dumpster and bursting open matches the crashing metal impact right at about 6.0s, so the clip appears perfectly synchronized."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy12_early_2.30s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event happens at about 6.0s, when the garbage bag impacts the edge of the dumpster and scatters trash, but the crashing impact of a filled trash bag hitting a metal dumpster is heard around 3.698s. That is roughly a 2.3s separation, which is far beyond normal tolerance and indicates obvious misalignment.","rejected":"The moment the garbage bag hits the dumpster and bursts open is matched exactly by the crashing impact sound, so the clip feels perfectly synchronized."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy16.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the cargo of the truck ahead strikes the low overpass and debris scatters across the highway lines up with the loud crashing and smashing sound of the roof hitting the overpass. The sync appears accurate, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable sync mismatch: the truck cargo hits the low overpass and debris scatters, but the loud crashing and smashing sound does not line up with that moment."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy16_delay_2.40s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 9.0s, when the cargo of the truck ahead strikes the low overpass and debris scatters across the highway, while the loud crashing and smashing sound is heard around 11.401s. That puts the audio roughly 2.4s apart from the visible event, so the sync is clearly off.","rejected":"The cargo striking the low overpass and the debris scattering are perfectly synchronized with the loud crashing and smashing sound right at 9.0s."}
+{"video":"Drop On In! - Fails of the Week (June 2018) _ FailArmy16_early_2.03s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event occurs at about 9.0s, when the cargo of the truck ahead strikes the low overpass and debris scatters, but the loud crashing and smashing sound is heard around 6.974s. That is roughly a 2.03s separation, which indicates a clear sync mismatch.","rejected":"The truck cargo hitting the low overpass and the debris scattering are perfectly synchronized with the loud crashing and smashing sound."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)19.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sight of a flying drone colliding with the fishing rods on the boat lines up with the loud crash of a drone hitting fishing rods, with the audio occurring about 1.0s from the visual impact.","rejected":"There is a noticeable mismatch: the flying drone collides with the fishing rods on the boat, but the loud crash of a drone hitting fishing rods does not line up and is clearly off by about a second."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)19_delay_2.29s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at about 3.0s, when a flying drone collides with the fishing rods on the boat, while the loud crash of a drone hitting fishing rods is heard around 5.806s. That places the sound roughly 2.81s from the visible collision, so they do not line up.","rejected":"The flying drone collides with the fishing rods on the boat at 3.0s, and the loud crash of a drone hitting fishing rods matches that exact moment, so this clip is perfectly synchronized."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)19_early_2.05s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual collision is around 3.0s, where a flying drone collides with the fishing rods on the boat, but the loud crash of a drone hitting fishing rods is heard near 1.947s. That is about a 1.05s separation, so the sound and impact are not aligned.","rejected":"The flying drone collides with the fishing rods on the boat and the loud crash of a drone hitting fishing rods occur together, making this clip perfectly synchronized."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)18.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound are reasonably aligned: as the undercarriage of the significantly lowered car forcefully scrapes and impacts the ground, halting its forward momentum, you hear the loud scraping and impact sound as the lowered car's undercarriage hits the ground while reversing, with only about a 0.5s separation.","rejected":"There is a clear noticeable mismatch here: the loud scraping and impact sound happens well away from the moment the car's undercarriage visibly scrapes and hits the ground."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)18_delay_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not aligned. The visual impact is at about 1.0s, when the undercarriage of the significantly lowered car forcefully scrapes and impacts the ground, halting its forward momentum, but the loud scraping and impact sound as the lowered car's undercarriage hits the ground while reversing arrives around 2.758s, a gap of roughly 1.76s.","rejected":"This clip is perfectly synchronized at 1.0s: the moment the car's undercarriage visibly scrapes the ground is exactly when the loud scraping and impact sound occurs."}
+{"video":"Expensive Fails - That's Going To Cost You! (July 2017)18_early_2.27s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is also not aligned. The visual contact occurs at about 1.0s, when the undercarriage of the significantly lowered car forcefully scrapes and impacts the ground, halting its forward momentum, while the loud scraping and impact sound as the lowered car's undercarriage hits the ground while reversing is heard at 0.0s, giving an estimated 1.0s gap.","rejected":"This clip is perfectly synchronized: the loud scraping and impact sound matches exactly with the visible moment the lowered car's undercarriage hits the ground."}
+{"video":"FailArmy After Dark - Does That Sheep Have Sunglasses  (Ep. 8)63.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The clip appears synchronized: the moment the tow-rope handle snaps back and hits the airborne wakeboarder in the face lines up with the loud splash and smack as the person hits the water. Any offset is within negligible natural tolerance, about 0.0s.","rejected":"There is a noticeable sync mismatch here: the tow-rope handle striking the rider\u2019s face and the loud splash\/smack do not line up, with the sound clearly separated from the visible impact."}
+{"video":"FailArmy After Dark - Does That Sheep Have Sunglasses  (Ep. 8)63_delay_2.46s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not in sync. The visible event occurs around 4.0s, when the tow-rope handle snaps back and strikes the airborne wakeboarder in the face, but the loud splash and smack as the person hits the water arrives around 6.463s, giving an estimated gap of about 2.46s.","rejected":"This clip looks perfectly synchronized at about 4.0s: the tow-rope handle hitting the wakeboarder\u2019s face matches the loud splash and smack right at that same moment."}
+{"video":"FailArmy After Dark - Does That Sheep Have Sunglasses  (Ep. 8)63_early_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not synchronized. The visible event is around 4.0s, when the tow-rope handle snaps back and hits the airborne wakeboarder in the face, while the loud splash and smack as the person hits the water is heard around 1.743s, for an estimated separation of about 2.26s.","rejected":"The audio and video are perfectly aligned here: the tow-rope handle striking the wakeboarder\u2019s face happens at the same time as the loud splash and smack, with no noticeable gap."}
+{"video":"FailArmy After Dark - Say It, Don't Spray It (Ep. 7)58.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is effectively synchronized: when the man sitting in the rolling chair collides head-on with the front of the parked red car, the loud smack\/thud from striking the car follows closely and feels aligned.","rejected":"There is a noticeable mismatch here: the loud smack\/thud from striking the car does not line up with the moment the man sitting in the rolling chair collides head-on with the front of the parked red car."}
+{"video":"FailArmy After Dark - Say It, Don't Spray It (Ep. 7)58_delay_2.36s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the visible impact occurs at about 6.0s, when the man sitting in the rolling chair collides head-on with the front of the parked red car, while the loud smack\/thud from striking the car lands around 7.367s. That puts the offset at roughly 1.37s, which is clearly perceptible.","rejected":"This clip appears perfectly synchronized: at 6.0s, the man sitting in the rolling chair collides head-on with the front of the parked red car and the loud smack\/thud from striking the car matches exactly."}
+{"video":"FailArmy After Dark - Say It, Don't Spray It (Ep. 7)58_early_2.38s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the visible collision is at about 6.0s, when the man sitting in the rolling chair collides head-on with the front of the parked red car, but the loud smack\/thud from striking the car is around 4.124s. So the gap is approximately 1.88s, an obvious mismatch by normal viewing standards.","rejected":"This clip is perfectly synchronized: the loud smack\/thud from striking the car occurs exactly with the moment the man sitting in the rolling chair collides head-on with the front of the parked red car."}
+{"video":"FailArmy After Dark - That's Going To Cost You  (Ep. 10)103.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The flip impact is in sync: the moment the person crashes into the safety netting and trampoline frame matches the loud smack as they hit the trampoline safety net and support pole. Any offset is within negligible natural tolerance, about 0.0s.","rejected":"There is a noticeable mismatch: the person crashes into the safety netting and trampoline frame, but the loud smack of hitting the trampoline safety net and support pole does not line up and is clearly separated in time."}
+{"video":"FailArmy After Dark - That's Going To Cost You  (Ep. 10)103_delay_2.33s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear mismatch here: the visual impact happens at about 3.0s when the person performing a flip crashes into the safety netting and trampoline frame, while the loud smack of hitting the trampoline safety net and support pole is heard around 5.334s. That is roughly a 2.33s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized at 3.0s: as the person performing a flip crashes into the safety netting and trampoline frame, the loud smack of hitting the trampoline safety net and support pole occurs at the same moment."}
+{"video":"FailArmy After Dark - That's Going To Cost You  (Ep. 10)103_early_1.99s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This one is also out of sync: the visual crash into the safety netting and trampoline frame is at about 3.0s, but the loud smack from hitting the trampoline safety net and support pole is heard near 1.011s. The separation is about 1.99s by estimation, which is plainly noticeable.","rejected":"This clip is perfectly synchronized: the person performing a flip crashes into the safety netting and trampoline frame exactly when the loud smack of hitting the trampoline safety net and support pole is heard."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)50.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The woman slips and falls hard into the bathtub, and the loud thud from a person falling back into a bathtub follows very closely. The sound is about 0.5s after the visible impact, which reads as effectively synchronized in this clip.","rejected":"The woman slips and falls into the bathtub, but the loud thud is noticeably out of sync and arrives well after the visible impact."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)50_delay_1.91s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"Here, the woman slips and falls hard into the bathtub at about 5.1s, while the loud thud from a person falling back into a bathtub is heard around 7.506s. That puts the sound roughly 2.41s after the visible fall, so the mismatch is clearly noticeable.","rejected":"The woman slips and falls hard into the bathtub at about 5.1s, and the loud thud happens right with the impact, so this clip is perfectly synchronized."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)50_early_2.11s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the woman slips and falls hard into the bathtub at about 5.1s, but the loud thud from a person falling back into a bathtub is heard around 3.485s. So the sound lands roughly 1.61s away from the visible fall, making the mismatch easy to hear.","rejected":"The woman slips and falls hard into the bathtub and the loud thud matches the impact exactly, so the audio and video are perfectly synchronized."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)97.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual moment when the person smashes the can forcefully onto the table aligns reasonably well with the short metallic thud of an aluminum can striking a person's forehead; the sound is about 0.6 s apart, which can still read as broadly in sync in a brief clip.","rejected":"There is a clear noticeable mismatch here: when the person smashes the can forcefully onto the table, the metallic thud of an aluminum can striking a person's forehead does not line up and feels obviously off."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)97_delay_1.94s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The key visual action occurs at about 3.0 s, when the person smashes the can forcefully onto the table, while the short metallic thud of an aluminum can striking a person's forehead lands at about 3.878 s. That puts the offset at roughly 0.88 s, which is large enough to be clearly perceptible rather than naturally aligned.","rejected":"This clip is perfectly synchronized at 3.0 s: the moment the person smashes the can forcefully onto the table matches exactly with the short metallic thud of an aluminum can striking a person's forehead."}
+{"video":"FailArmy After Dark - That's Got to Sting (Ep. 6)97_early_2.40s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact is around 3.0 s, when the person smashes the can forcefully onto the table, but the short metallic thud of an aluminum can striking a person's forehead occurs at 0.0 s. An estimated 3.0 s separation is far too large to seem naturally matched, so the audio-visual correspondence is clearly broken.","rejected":"This clip is perfectly synchronized: the short metallic thud of an aluminum can striking a person's forehead matches the instant the person smashes the can forcefully onto the table with no noticeable offset."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy113.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are close but not fully synchronized: when the man and the broken lamp post hit the ground, the loud metallic crash as the broken lamppost hits the stone base follows by about 0.5 seconds, which is noticeable.","rejected":"There is a clear mismatch here: the man and the broken lamp post hit the ground well before the loud metallic crash as the broken lamppost hits the stone base, making the offset obvious."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy113_delay_1.85s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset in this clip. The visual impact moment\u0014when the man and the broken lamp post hit the ground\u0014is around 6.0s, while the loud metallic crash as the broken lamppost hits the stone base is heard around 8.353s, so the gap is roughly 2.35 seconds.","rejected":"This clip appears perfectly synchronized: at 6.0s, the man and the broken lamp post hit the ground exactly as the loud metallic crash as the broken lamppost hits the stone base is heard."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy113_early_2.32s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also noticeably out of sync. The man and the broken lamp post hit the ground at about 6.0s, but the loud metallic crash as the broken lamppost hits the stone base occurs around 4.18s, giving an estimated gap of about 1.82 seconds.","rejected":"The sound matches the action perfectly here: the loud metallic crash as the broken lamppost hits the stone base happens right when the man and the broken lamp post hit the ground."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy149.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip appears reasonably synchronized: the moment a glass of milk is forcefully splashed onto the man's face is followed closely by the loud clattering sound as the camera is dropped or bumped, with about a 1.0s separation that can still read as plausibly aligned in context.","rejected":"This clip shows a noticeable sync problem: when a glass of milk is forcefully splashed onto the man's face, the loud clattering sound as the camera is dropped or bumped arrives clearly too far from the visible impact."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy149_delay_1.98s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not well aligned: the visual event at 8.0s, where a glass of milk is forcefully splashed onto the man's face, does not match the loud clattering sound as the camera is dropped or bumped until 10.976s, a gap of about 2.98s by natural estimation.","rejected":"This clip appears perfectly synchronized at 8.0s: as a glass of milk is forcefully splashed onto the man's face, the loud clattering sound as the camera is dropped or bumped matches exactly at that same moment."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy149_early_2.38s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also misaligned: the visible moment at 8.0s when a glass of milk is forcefully splashed onto the man's face does not line up with the loud clattering sound as the camera is dropped or bumped, which occurs at 6.616s, roughly 1.38s apart by natural estimation.","rejected":"This clip appears perfectly synchronized: the instant a glass of milk is forcefully splashed onto the man's face, the loud clattering sound as the camera is dropped or bumped occurs at the exact same time."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy194.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the man crashes headfirst into the wall after swinging from the rope aligns well with the loud thud as the person falls and hits the floor mat. The picture cue is around 2.0s and the sound is about 2.1s, a negligible natural tolerance of 0.1s, so this appears synchronized.","rejected":"There is a noticeable mismatch here: the man crashes headfirst into the wall after swinging from the rope, but the loud thud as the person falls and hits the floor mat lands distinctly apart from the visible impact."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy194_delay_2.47s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"Here, the man crashes headfirst into the wall after swinging from the rope at about 2.0s, while the loud thud as the person falls and hits the floor mat is at 3.762s. That is roughly a 1.76s separation, which is clearly not synchronized.","rejected":"The man crashes headfirst into the wall after swinging from the rope right at 2.0s, and the loud thud as the person falls and hits the floor mat matches that same moment perfectly, so this is fully synchronized."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy194_early_2.33s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"In this clip, the man crashes headfirst into the wall after swinging from the rope at about 2.0s, but the loud thud as the person falls and hits the floor mat is at 0.0s. That is about a 2.0s separation, so the audio and visual events do not line up.","rejected":"The man crashes headfirst into the wall after swinging from the rope and the loud thud as the person falls and hits the floor mat occur together, so this clip is perfectly synchronized."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy219.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are not fully synchronized: the parasailer crashes into the shallow water and sand at about 4.0s, while the sound of a body hitting the water and creating a large splash arrives around 3.0s, leaving roughly a 1.0s mismatch.","rejected":"The parasailer crashes into the shallow water and sand at about 4.0s, but the sound of a body hitting the water and creating a large splash is noticeably off, making the mismatch obvious throughout the moment."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy219_delay_2.33s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"Here the parasailer crashes into the shallow water and sand at 4.0s, while the sound of a body hitting the water and creating a large splash is heard at 5.327s, so the audio trails the visual by about 1.33s.","rejected":"The parasailer crashes into the shallow water and sand at 4.0s, and the sound of a body hitting the water and creating a large splash lines up perfectly at that same moment."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy219_early_2.36s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"In this clip, the parasailer crashes into the shallow water and sand at 4.0s, but the sound of a body hitting the water and creating a large splash is heard near 0.637s, which is roughly a 3.36s separation and clearly not aligned.","rejected":"The parasailer crashes into the shallow water and sand and the sound of a body hitting the water and creating a large splash match perfectly with no noticeable timing difference."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy221.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the man falls and forcefully hits the ground after being lifted by the parasail lines up well with the loud thud of a body hitting the ground, with only about a 0.6 s separation, so it feels reasonably synchronized.","rejected":"There is a noticeable mismatch: the man falls and forcefully hits the ground after being lifted by the parasail, but the loud thud of a body hitting the ground does not line up and feels clearly offset."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy221_delay_2.21s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 5.0 s, when the man falls and forcefully hits the ground after being lifted by the parasail, while the loud thud of a body hitting the ground is heard around 6.061 s. That is roughly a 1.06 s separation, which is large enough to be clearly noticeable.","rejected":"The man falls and forcefully hits the ground after being lifted by the parasail exactly as the loud thud of a body hitting the ground occurs at 5.0 s, so the sync appears perfect."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy221_early_1.93s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact occurs at about 5.0 s, when the man falls and forcefully hits the ground after being lifted by the parasail, but the loud thud of a body hitting the ground is heard around 2.474 s. This is roughly a 2.53 s separation, making the mismatch very obvious.","rejected":"The man falls and forcefully hits the ground after being lifted by the parasail at the same moment the loud thud of a body hitting the ground is heard, so the synchronization appears perfect."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy239.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is well synchronized: the moment the man and the grill simultaneously crash into the ground after falling down the stairs lines up closely with the loud metallic crash and clattering as the heavy grill falls and hits the ground, with only about a 1.0s offset by estimation.","rejected":"This clip shows a noticeable sync mismatch: the man and the grill hit the ground, but the loud metallic crash and clattering arrives clearly out of step with the impact."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy239_delay_2.16s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the visual impact occurs at about 2.0s, while the loud metallic crash and clattering is heard at about 3.157s. So when the man and the grill simultaneously crash into the ground after falling down the stairs, the sound follows by roughly 1.16s, which is a clearly perceptible offset.","rejected":"This clip is perfectly synchronized: at 2.0s, the man and the grill hit the ground exactly as the loud metallic crash and clattering is heard."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy239_early_2.32s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the loud metallic crash and clattering is heard at about 0.0s, while the visual moment when the man and the grill simultaneously crash into the ground after falling down the stairs occurs at about 2.0s. By estimation, that is roughly a 2.0s separation, making the offset very obvious.","rejected":"This clip is perfectly synchronized: the man and the grill hit the ground at the exact moment the loud metallic crash and clattering is heard."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy41.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound line up well: as the object, after being struck by the fan blades, flies forward and directly impacts the camera, you hear the loud, sharp sound of a plastic bag hitting spinning fan blades at nearly the same moment, with about a 1.0 s offset noted here.","rejected":"There is a noticeable mismatch here: the object, after being struck by the fan blades, flies forward and directly impacts the camera, but the loud, sharp sound of a plastic bag hitting spinning fan blades does not line up with that moment."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy41_delay_2.19s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip shows a clear mismatch. The visual impact happens around 4.0 s, when the object, after being struck by the fan blades, flies forward and directly impacts the camera, while the loud, sharp sound of a plastic bag hitting spinning fan blades is heard at 4.638 s, roughly 0.64 s apart.","rejected":"This clip appears perfectly synchronized: at 4.0 s, the object, after being struck by the fan blades, flies forward and directly impacts the camera exactly as the loud, sharp sound of a plastic bag hitting spinning fan blades is heard."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy41_early_2.44s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip has an obvious mismatch. The visual event occurs around 4.0 s, when the object, after being struck by the fan blades, flies forward and directly impacts the camera, but the loud, sharp sound of a plastic bag hitting spinning fan blades comes at 0.564 s, about 3.44 s away.","rejected":"This clip appears perfectly synchronized: the object, after being struck by the fan blades, flies forward and directly impacts the camera at the same instant as the loud, sharp sound of a plastic bag hitting spinning fan blades."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy58.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment a soccer ball directly strikes a person in the face and they fall backward lines up well with the loud smack of the ball hitting the face. The timing difference is only about 0.1s, which is within negligible natural tolerance and would generally be perceived as synchronized.","rejected":"The ball-to-face impact and the loud smack do not line up well here; the sound arrives noticeably apart from the moment the person is hit, creating a clear mismatch."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy58_delay_2.24s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens at about 1.0s, when the soccer ball directly strikes the person in the face and they fall backward, but the loud smack of the ball hitting the face is heard around 3.161s. That puts the separation at roughly 2.16s, which is a very obvious mismatch.","rejected":"The loud smack matches the instant the soccer ball hits the person's face at about 1.0s, so the audio and visual are perfectly synchronized."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy58_early_2.16s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact occurs at about 1.0s, when the soccer ball directly strikes the person in the face and they fall backward, while the loud smack of the ball hitting the face is heard at 0.0s. That is about a 1.0s separation, which would be clearly noticeable as a mismatch.","rejected":"The loud smack occurs exactly with the moment the soccer ball hits the person's face, so the clip appears perfectly synchronized."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy84.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The wooden object crashes down, causing maximum impact and scattering debris, and the loud crash of falling furniture lands essentially together. The gap is only about 0.1 s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"The wooden object crashes down and debris scatters, but the loud crash of falling furniture arrives noticeably apart from the impact, creating a clear sync mismatch."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy84_delay_1.84s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"When the wooden object crashes down, causing maximum impact and scattering debris, the key visual moment is around 2.0 s, while the loud crash of falling furniture is heard around 3.942 s. That puts the separation at roughly 1.94 s, which is a clear audiovisual mismatch.","rejected":"The wooden object crashes down right at 2.0 s, and the loud crash of falling furniture matches that impact perfectly, so this clip is fully synchronized."}
+{"video":"FailArmy Playlist - Inflatables and Big Ballers (March 2019) _ FailArmy84_early_2.16s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The wooden object crashes down, causing maximum impact and scattering debris, at about 2.0 s visually, but the loud crash of falling furniture is heard at 0.0 s. That is roughly a 2.0 s separation, indicating an obvious audiovisual mismatch.","rejected":"The loud crash of falling furniture lines up perfectly with the moment the wooden object crashes down and debris scatters, so this clip is perfectly synchronized."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy6.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when the dog falls through the hole in the table and hits the wooden deck below lines up well with the thump of the dog landing on the wooden deck. The timing is very close, with only a negligible natural tolerance of about 0.2s.","rejected":"The dog falls through the hole in the table and hits the wooden deck below, but the thump of the dog landing on the wooden deck is noticeably out of sync and does not match the impact moment."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy6_delay_2.15s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at about 2.0s, when the dog falls through the hole in the table and hits the wooden deck below, while the thump of the dog landing on the wooden deck is heard around 3.951s. That puts the offset at roughly 1.95s, which is a clear mismatch.","rejected":"The dog falls through the hole in the table and hits the wooden deck below exactly as the thump of the dog landing on the wooden deck is heard at 2.0s, so the clip appears perfectly synchronized."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy6_early_2.11s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs at about 2.0s, when the dog falls through the hole in the table and hits the wooden deck below, but the thump of the dog landing on the wooden deck is heard at 0.0s. That is roughly a 2.0s separation, so the sound and impact clearly do not line up.","rejected":"The dog falls through the hole in the table and hits the wooden deck below at the same moment the thump of the dog landing on the wooden deck is heard, so this clip is perfectly synchronized."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy34.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the person falls backwards and heavily impacts the ground lines up with the loud thud as the person falls and hits the ground. Both occur at about 3.0s, so the gap is effectively 0.0s, well within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the person falls backwards and heavily impacts the ground around 3.0s, but the loud thud as the person falls and hits the ground seems offset enough to be clearly out of sync."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy34_delay_1.89s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens at about 3.0s, when the person falls backwards and heavily impacts the ground, while the loud thud as the person falls and hits the ground is heard at about 4.895s. That places the audio roughly 1.89s away from the visual event, which is a clear sync mismatch.","rejected":"The person falls backwards and heavily impacts the ground at about 3.0s, and the loud thud as the person falls and hits the ground matches it perfectly at the same moment, so this clip is fully synchronized."}
+{"video":"FailFactory - Derpy Dogs (March 2019) _ FailArmy34_early_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The person falls backwards and heavily impacts the ground at about 3.0s, but the loud thud as the person falls and hits the ground is heard around 0.743s. So the sound is roughly 2.26s away from the visual event, indicating a clear sync mismatch.","rejected":"The visual fall and ground impact at about 3.0s are matched perfectly by the loud thud as the person falls and hits the ground, so this clip appears fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)121.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sight of the pull-up bar detaching from the doorframe and the person falling to the floor matches the loud thud of the impact very closely. The timing difference is only about 0.3s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the pull-up bar detaches and the person hits the floor well apart from the loud thud, making the clip seem clearly out of sync."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)121_delay_1.99s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact occurs around 2.8s, when the pull-up bar detaches from the doorframe and the person falls to the floor, but the loud thud of the floor impact is heard around 4.488s. That puts the offset at roughly 1.69s, which is a clear mismatch.","rejected":"The pull-up bar detaches and the person hits the floor right at 2.8s, and the loud thud aligns perfectly with that moment, so this clip is fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)121_early_2.21s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event happens around 2.8s, as the pull-up bar detaches from the doorframe and the person falls and hits the floor, while the loud thud is heard near 0.286s. That is roughly a 2.51s separation, indicating a strong mismatch between picture and sound.","rejected":"The moment the pull-up bar detaches and the person hits the floor is perfectly matched by the loud thud, so this clip appears completely synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)37.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when the barbell and the person balancing on it fall onto the person on the bench matches the loud crash and thud at about 10.0s, so this clip is synchronized. The 0.0s gap is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the heavy chest impact is seen around 10.0s, but the loud crash and thud seem offset enough to make the sync feel clearly off."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)37_delay_2.39s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at 10.0s, when the barbell and the person balancing on it fall onto the person on the bench, while the loud crash and thud land at 10.685s. That puts the sound roughly 0.69s away from the picture, which is a clear sync mismatch.","rejected":"The barbell falling onto the person on the bench and the loud crash and thud line up perfectly at 10.0s, so this clip appears fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)37_early_2.01s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact occurs at 10.0s, when the barbell and the person balancing on it fall onto the person on the bench, but the loud crash and thud arrive at 7.991s. That is about a 2.01s separation, which is an obvious sync mismatch.","rejected":"The moment of the barbell and person falling onto the bench matches the loud crash and thud exactly, so this clip is perfectly synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)55.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound are reasonably well aligned: when the man lands with both feet on top of the stack of weight plates, the loud thud from his feet landing comes at nearly the same moment, with only about a 0.6 s gap.","rejected":"There is a noticeable mismatch: the man lands with both feet on top of the stack of weight plates, but the loud thud from his feet landing is clearly offset and does not line up with the impact."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)55_delay_2.34s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The sync is clearly off here. The visual landing\u2014when the man lands with both feet on top of the stack of weight plates\u2014occurs at about 3.0 s, while the loud thud from his feet landing is heard at about 3.475 s, an estimated gap of roughly 0.48 s.","rejected":"This clip appears perfectly synchronized at 3.0 s: the moment the man lands with both feet on top of the stack of weight plates, the loud thud from his feet landing matches exactly."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)55_early_1.82s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The audio and video are plainly misaligned. The visual moment when the man lands with both feet on top of the stack of weight plates is around 3.0 s, but the loud thud from his feet landing is heard around 0.584 s, giving an estimated separation of about 2.42 s.","rejected":"This clip is perfectly synchronized: the loud thud from the man's feet landing happens exactly when he lands with both feet on top of the stack of weight plates."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)5.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the unbalanced barbell rapidly falls and crashes heavily onto the man and the bench, the loud metallic crash of the barbell hitting the safety rack is heard at the same time, around 6.0s. Any offset is within a negligible natural tolerance of about 0.0s, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the unbalanced barbell rapidly falls and crashes heavily onto the man and the bench, but the loud metallic crash of the barbell hitting the safety rack does not line up and is clearly separated in time."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)5_delay_1.90s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The key visual impact happens at about 6.0s, when the unbalanced barbell rapidly falls and crashes heavily onto the man and the bench, while the loud metallic crash of the barbell hitting the safety rack is heard around 7.905s. That puts the audio roughly 1.9s away from the visual event, so this clip is not synchronized.","rejected":"The unbalanced barbell rapidly falls and crashes heavily onto the man and the bench at about 6.0s, and the loud metallic crash of the barbell hitting the safety rack matches it perfectly there, so this clip is fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)5_early_1.90s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs at about 6.0s, when the unbalanced barbell rapidly falls and crashes heavily onto the man and the bench, but the loud metallic crash of the barbell hitting the safety rack is heard around 4.104s. That is roughly a 1.9s separation, indicating the clip is not synchronized.","rejected":"The unbalanced barbell rapidly falls and crashes heavily onto the man and the bench and the loud metallic crash of the barbell hitting the safety rack occur in perfect sync, so this clip appears fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)68.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the wooden support holding the bar breaks and the man falls lines up with the loud crash of the pull-up bar detaching and hitting the wooden frame. The sync is effectively exact, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch: the wooden support breaks and the man falls, but the loud crash of the bar hitting the wooden frame happens distinctly apart from that moment."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)68_delay_2.24s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual event occurs at about 7.0s, when the wooden support holding the bar breaks and the man falls, while the loud crash of the pull-up bar detaching and striking the wooden frame is heard around 9.242s. That places the audio roughly 2.24s away from the visual cue, which is a clear sync offset by normal viewing standards.","rejected":"The wooden support breaks and the man falls right at about 7.0s, and the loud crash of the pull-up bar hitting the wooden frame matches that instant perfectly, so this clip appears fully synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)68_early_1.96s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual cue is around 7.0s, where the wooden support holding the bar breaks and the man falls, whereas the loud crash of the pull-up bar detaching and hitting the wooden frame is heard near 5.04s. By estimation, that is about a 1.96s separation, which is clearly outside normal sync tolerance.","rejected":"The wooden support breaks, the man falls, and the loud crash of the bar hitting the wooden frame all occur together, so the clip appears perfectly synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)72.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The loud thud of a person falling and hitting the floor lines up with the moment the person and the loose pull-up bar simultaneously strike the floor. The timing difference is only about 0.1 s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the loud thud of a person falling and hitting the floor does not align with the moment the person and the loose pull-up bar simultaneously strike the floor, making the clip seem out of sync."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)72_delay_2.19s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The key visual event is when the person and the loose pull-up bar simultaneously strike the floor, which occurs at about 4.0 s. The corresponding loud thud of a person falling and hitting the floor is heard at about 3.904 s. That puts the gap at roughly 0.1 s, a very small offset that still falls within natural sync tolerance.","rejected":"The loud thud of a person falling and hitting the floor matches exactly when the person and the loose pull-up bar simultaneously strike the floor at 4.0 s, so the clip is perfectly synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)72_early_2.47s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The person and the loose pull-up bar simultaneously strike the floor at about 4.0 s, but the loud thud of a person falling and hitting the floor is heard around 1.632 s. That is an estimated gap of about 2.37 s, which is a clear and substantial audio-visual mismatch.","rejected":"The loud thud of a person falling and hitting the floor occurs right when the person and the loose pull-up bar simultaneously strike the floor, so this clip is perfectly synchronized."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)88.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The impact is synchronized: the moment the breakdancer's hand strikes the mat with significant force, concluding the rotation and absorbing momentum, matches the loud thud of his body forcefully hitting the floor mat. The gap is 0.0s, well within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the hand strike and body impact are seen first, and the loud thud arrives clearly later, making the sync feel off."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)88_delay_2.08s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The sync is off by about 2.08s: the visual impact happens around 3.0s, when the breakdancer's hand strikes the mat with significant force at the end of the rotation, but the loud thud of his body forcefully hitting the floor mat is heard around 5.08s.","rejected":"This clip appears perfectly synchronized at 3.0s, with the hand strike on the mat and the loud thud landing together without any perceptible gap."}
+{"video":"FailFactory - No Pain, No Gain (Workout Fails)88_early_2.20s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The sync is off by roughly 2.2s: the visual impact occurs around 3.0s, when the breakdancer's hand strikes the mat with significant force to absorb momentum, while the loud thud of his body forcefully hitting the floor mat is heard around 0.803s.","rejected":"This clip appears perfectly synchronized, with the mat strike and the loud thud occurring together at the same moment."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy38.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not synchronized: the moment when the falling phone impacts the surface of the water, creating a splash, is seen at about 3.5s, while the splash sound as the phone hits the water is heard around 4.3s, leaving a clear gap of about 0.8s.","rejected":"There is a noticeable mismatch here: the falling phone impacts the surface of the water, creating a splash, but the splash sound as the phone hits the water does not line up and is clearly separated in time."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy38_delay_2.44s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a large audio-visual mismatch. The falling phone impacts the surface of the water, creating a splash, at about 3.5s visually, but the splash sound as the phone hits the water is only heard near 6.631s, so the separation is roughly 3.13s by natural estimation.","rejected":"This clip appears perfectly synchronized: the falling phone impacts the surface of the water, creating a splash, and the splash sound as the phone hits the water occurs right at 3.5s with no noticeable offset."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy38_early_2.03s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also out of sync. The falling phone impacts the surface of the water, creating a splash, at about 3.5s on screen, while the splash sound as the phone hits the water is heard around 2.275s, giving an estimated gap of about 1.23s.","rejected":"This clip appears perfectly synchronized, with the falling phone impacts the surface of the water, creating a splash, matching the splash sound as the phone hits the water at the same moment."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy82.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The canoe capsizes and both people hit the water right as the loud splash and thud are heard, so this clip is effectively synchronized; the timing difference is only about 0.1s, which is within negligible natural tolerance.","rejected":"The canoe capsizing and the loud splash\/thud do not line up here; there is a noticeable mismatch, with the sound arriving clearly apart from the moment both people fall into the water."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy82_delay_2.17s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The key visual event is at 4.0s, when the canoe capsizes and both individuals fall into the water, while the matching loud splash and thud are heard at 6.069s. That places the audio roughly 2.07s away from the visual cue, so this clip is clearly not synchronized.","rejected":"The canoe capsizes at 4.0s and the loud splash\/thud matches that exact moment, so this clip is perfectly synchronized."}
+{"video":"Fails You Missed - Not the Bees (April 2018) _ Failarmy82_early_1.92s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The main visual action occurs at 4.0s, when the canoe capsizes and both people fall into the water, but the corresponding loud splash and thud are heard at 1.982s. That is about a 2.02s separation, so the audio and visual events are plainly not aligned.","rejected":"The loud splash and thud align exactly with the canoe capsizing, so this clip is perfectly synchronized."}
+{"video":"Fails of the Month - Failing into Summer like... (May 2017)31.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the bird jumps up and forcefully strikes the man with its wings and body, the loud slapping sound from the bird's wings hitting the person lands essentially together, so this clip comes across as synchronized.","rejected":"There is a noticeable audio-video mismatch here: when the bird jumps up and forcefully strikes the man with its wings and body, the loud slapping sound from the bird's wings hitting the person does not line up well."}
+{"video":"Fails of the Month - Failing into Summer like... (May 2017)31_delay_1.94s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"Around 4.0s, the bird jumps up and forcefully strikes the man with its wings and body, while the loud slapping sound from the bird's wings hitting the person is heard at about 4.945s. That puts the gap at roughly 0.94s, which is clearly perceptible rather than a natural sync tolerance.","rejected":"At 4.0s, the bird jumps up and forcefully strikes the man with its wings and body and the loud slapping sound from the bird's wings hitting the person matches it perfectly, so this clip is fully synchronized."}
+{"video":"Fails of the Month - Failing into Summer like... (May 2017)31_early_2.06s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"At 4.0s, the bird jumps up and forcefully strikes the man with its wings and body, but the loud slapping sound from the bird's wings hitting the person occurs near 0.938s. That is a gap of about 3.06s, an obvious separation between picture and sound.","rejected":"The bird jumps up and forcefully strikes the man with its wings and body exactly when the loud slapping sound from the bird's wings hitting the person is heard, so the clip appears perfectly synchronized."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy21.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The impact is effectively synchronized: when the person hits the water surface, creating a massive splash, the loud splash as the people fall and hit the water follows closely enough to read as matched in normal viewing.","rejected":"There is a noticeable sync mismatch here: the loud splash does not line up with the moment the person hits the water and creates the massive splash."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy21_delay_1.97s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset. The key visual impact happens at about 2.0s, when the person hits the water surface and creates a massive splash, but the loud splash as the people fall and hit the water is heard around 4.975s, roughly a 2.97s separation.","rejected":"This clip appears perfectly synchronized at 2.0s, with the loud splash matching exactly when the person hits the water and creates the massive splash."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy21_early_1.83s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is also an evident offset in this clip. The main visual impact occurs near 2.0s, when the person hits the water surface and creates a massive splash, while the loud splash as the people fall and hit the water is heard around 1.174s, about 0.83s apart by estimation.","rejected":"This clip looks perfectly synchronized, with the loud splash lining up exactly with the moment the person hits the water and creates the massive splash."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy20.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are close enough to read as synchronized: as the dancing couple falls to the floor when the man loses balance during the dip, the loud thud of a couple falling onto a hard floor lands at nearly the same moment, with only about a 0.9 s gap.","rejected":"There is a noticeable mismatch here: the dancing couple hits the floor, but the loud thud of a couple falling onto a hard floor arrives clearly apart from the impact rather than together."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy20_delay_2.30s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip shows a clear offset. The visual impact happens at about 5.0 s, when the dancing couple falls to the floor as the man loses his balance during a dip, while the loud thud of a couple falling onto a hard floor is heard around 6.398 s, so the separation is roughly 1.4 s.","rejected":"This clip is perfectly synchronized at 5.0 s: the moment the dancing couple falls to the floor during the dip, the loud thud of a couple falling onto a hard floor matches exactly with no offset."}
+{"video":"Fails of the Month - Failure In Full Force (January 2017) _ FailArmy20_early_2.03s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip also has an obvious offset. The visible fall happens at about 5.0 s, when the dancing couple collapses to the floor after the man loses balance during the dip, but the loud thud of a couple falling onto a hard floor is heard near 2.075 s, giving a gap of about 2.93 s.","rejected":"This clip is perfectly synchronized: the dancing couple\u2019s fall to the floor and the loud thud of a couple falling onto a hard floor occur together with no perceptible timing difference."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy42.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment a person is pulled violently by a kite and slams face-first into the sand dune lines up well with the loud thud of the crash. The timing difference is about 0.3s, which is within negligible natural tolerance, so this appears synchronized.","rejected":"The person slamming face-first into the sand dune does not match the loud thud well; there is a noticeable mismatch between the visible impact and the sound."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy42_delay_2.46s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visible impact happens around 13.0s, while the loud thud is heard at 13.271s. As the person is pulled violently by a kite and slams face-first into the sand dune, the sound lands about 0.27s later by natural estimation, which is still consistent with sync.","rejected":"The person being pulled by the kite and slamming into the sand dune is perfectly synchronized with the loud thud right at 13.0s."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy42_early_2.42s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visible slam occurs around 13.0s, but the loud thud is heard at 10.277s. When the person is pulled violently by a kite and slams face-first into the sand dune, the sound arrives roughly 2.72s away by natural estimation, so this is clearly not in sync.","rejected":"The person crashing face-first into the sand dune is perfectly synchronized with the loud thud, with no meaningful timing offset."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy45.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual moment where an unseen object heavily impacts the metal roof, causing sudden deformation, lines up with the loud thunderclap\/crack following the lightning flash. The offset is only about 0.1s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"The roof-impact visual and the thunderclap\/crack do not align well here; there is a noticeable mismatch between the visible deformation and the sound, so the clip appears out of sync."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy45_delay_2.06s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible roof impact occurs at about 4.0s, while the loud thunderclap\/crack is heard around 6.163s. That places the sound roughly 2.16s away from the visual event, so the impact deformation and the crack clearly do not coincide in this clip.","rejected":"The unseen object hitting the metal roof and the loud thunderclap\/crack occur right together at about 4.0s, so this clip is perfectly synchronized."}
+{"video":"Fails of the Week - Insult to Injury (January 2017) _ FailArmy45_early_2.06s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible roof impact is at about 4.0s, but the loud thunderclap\/crack is heard around 2.037s. That is roughly a 1.96s separation, so the sound and the visible deformation are clearly not aligned in this clip.","rejected":"The roof deformation from the heavy impact and the loud thunderclap\/crack happen at the same moment, so this clip is perfectly synchronized."}
+{"video":"Fails of the Week - Let's Do This Thing! (April 2017)8.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The dirt bike and its three riders crash onto the landing ramp at about 6.0s, and the loud crash and scraping sound as the motorcycle and riders hit the landing ramp is heard at about 5.9s. That ~0.1s offset is within negligible natural tolerance, so this clip appears synchronized.","rejected":"The dirt bike and its three riders crash onto the landing ramp around 6.0s, but the loud crash and scraping sound as the motorcycle and riders hit the landing ramp is noticeably out of step, creating a clear sync mismatch."}
+{"video":"Fails of the Week - Let's Do This Thing! (April 2017)8_delay_1.91s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The dirt bike and its three riders crash onto the landing ramp is visible at 6.0s, while the loud crash and scraping sound as the motorcycle and riders hit the landing ramp comes in around 7.813s. That is roughly a 1.81s separation, which is a clear audiovisual mismatch.","rejected":"The dirt bike and its three riders crash onto the landing ramp at 6.0s, and the loud crash and scraping sound as the motorcycle and riders hit the landing ramp matches it perfectly at the same moment, so the clip is fully synchronized."}
+{"video":"Fails of the Week - Let's Do This Thing! (April 2017)8_early_2.02s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The dirt bike and its three riders crash onto the landing ramp appears at 6.0s, but the loud crash and scraping sound as the motorcycle and riders hit the landing ramp is heard around 3.876s. That is about a 2.12s separation, indicating an obvious sync mismatch.","rejected":"The dirt bike and its three riders crash onto the landing ramp and the loud crash and scraping sound as the motorcycle and riders hit the landing ramp line up exactly, so this clip appears perfectly synchronized."}
+{"video":"Fails of the Week 4 September 2016 _ FailArmy41.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment a man falls flat on his chest and stomach onto the concrete floor after jumping off a table lines up well with the sound of a man falling and hitting the ground. The impact is essentially in sync, with only about a 1.0s gap by rough estimate.","rejected":"The picture and sound do not line up here: the man hits the concrete floor, but the sound of a man falling and hitting the ground comes noticeably later, creating a clear mismatch."}
+{"video":"Fails of the Week 4 September 2016 _ FailArmy41_delay_2.23s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens at about 18.0s, when a man falls flat on his chest and stomach onto the concrete floor after jumping off a table, while the sound of a man falling and hitting the ground is heard around 21.228s. That places the audio roughly 3.23s away from the visible impact, which is a clear mismatch by normal sync standards.","rejected":"The sound is perfectly synchronized with the visible impact at 18.0s: as the man falls flat onto the concrete floor after jumping off a table, the sound of a man falling and hitting the ground occurs at the same instant."}
+{"video":"Fails of the Week 4 September 2016 _ FailArmy41_early_2.16s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visible impact occurs at about 18.0s, when a man falls flat on his chest and stomach onto the concrete floor after jumping off a table, whereas the sound of a man falling and hitting the ground is heard around 16.84s. So the two are separated by roughly 1.16s, which would generally be perceived as out of sync.","rejected":"The moment the man falls flat onto the concrete floor after jumping off a table is perfectly matched by the sound of a man falling and hitting the ground, with no noticeable timing difference."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201617.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound are effectively in sync: the man falls backward off the skateboard and slams onto the hard floor just as the loud crashing thud of him hitting the floor and shelf is heard. The gap is only about 0.3 seconds, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the man falls backward off the skateboard and hits the hard floor, but the loud crashing thud of him hitting the floor and shelf comes clearly out of step with the impact."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201617_delay_2.36s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear sync offset here. The visual impact happens around 4.0s, when the man falls backward off the skateboard and forcefully hits the hard floor, while the loud crashing thud of him hitting the floor and shelf is heard around 6.659s. That is roughly a 2.66-second separation, which is plainly noticeable.","rejected":"This clip appears perfectly synchronized at about 4.0s: the man falls backward off the skateboard and hits the hard floor exactly as the loud crashing thud of him hitting the floor and shelf is heard."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201617_early_1.92s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip also shows a noticeable sync issue. The visual impact occurs around 4.0s, when the man falls backward off the skateboard and his body hits the hard floor, but the loud crashing thud of him hitting the floor and shelf is heard around 2.377s. That is about a 1.62-second separation, so the mismatch is easy to detect.","rejected":"The picture and sound are perfectly synchronized: the man falls backward off the skateboard and slams onto the hard floor at the exact moment the loud crashing thud of him hitting the floor and shelf is heard."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201656.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not synchronized: the adult man loses his balance while swinging the boy and falls backward onto the young girl at about 5.0s, but the loud, heavy thud as he hits the hardwood floor is heard around 6.0s, leaving about a 1.0s gap.","rejected":"There is a noticeable mismatch here: the impact is seen when the man falls backward onto the girl, but the heavy thud does not line up and is clearly offset from the visible landing."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201656_delay_2.20s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is clearly out of sync. The adult man loses his balance while swinging the boy and falls backward onto the young girl at about t=5.0s, while the loud, heavy thud lands around t=8.198s, so the audio trails the visible impact by roughly 3.2s.","rejected":"This one appears perfectly synchronized at about 5.0s: as the man falls backward onto the girl, the loud thud occurs right with the visible impact."}
+{"video":"Father's Day Fails _ 'Dad Fails' By FailArmy 201656_early_2.02s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also out of sync. The adult man loses his balance while swinging the boy and falls backward onto the young girl at about t=5.0s, but the loud, heavy thud is heard around t=3.984s, so the sound arrives roughly 1.02s away from the visible impact.","rejected":"This clip appears perfectly synchronized: the moment the man falls backward onto the girl, the heavy thud matches the visual impact exactly."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy20.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is reasonably synchronized: the moment the boy falls from his attempted swing and lands heavily on his back on the grass is accompanied by a loud thud of a person falling onto a wooden deck, with the sound landing close enough to read as matched.","rejected":"There is a noticeable mismatch here: the boy falls from his attempted swing and lands on the grass, but the loud thud arrives clearly out of step with the impact."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy20_delay_1.96s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not well aligned. The visual impact happens at about 3.0s, when the boy falls from his attempted swing and lands heavily on his back on the grass, while the loud thud of a person falling onto a wooden deck is heard around 4.538s, giving an estimated separation of about 1.54s.","rejected":"This clip appears perfectly synchronized at 3.0s: the boy\u2019s fall onto the grass matches the loud thud exactly at the moment of impact."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy20_early_2.13s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also misaligned. The boy falls from his attempted swing and lands heavily on his back on the grass at about 3.0s, but the loud thud of a person falling onto a wooden deck is heard around 1.666s, an estimated gap of about 1.33s.","rejected":"This clip appears perfectly synchronized: the boy\u2019s impact on the grass and the loud thud occur together with no noticeable gap."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy47.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when the second child falls from the playground structure and hits the ground lines up with the loud thud of a child falling and hitting the ground at about 12.0s. The gap is 0.0s, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the second child falls from the playground structure and hits the ground around 12.0s, but the loud thud of a child falling and hitting the ground does not line up and seems clearly offset."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy47_delay_1.87s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The second child falls from the playground structure and hits the ground at about 12.0s visually, while the loud thud of a child falling and hitting the ground is heard at about 13.87s. That puts the offset at roughly 1.87s, which is clearly perceptible.","rejected":"The second child falls from the playground structure and hits the ground at 12.0s, and the loud thud of a child falling and hitting the ground matches perfectly at the same moment, so this clip appears fully synchronized."}
+{"video":"Funny Kid Fails (February 2016) _ FailArmy47_early_1.92s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The second child falls from the playground structure and hits the ground at about 12.0s visually, but the loud thud of a child falling and hitting the ground occurs at about 10.077s. The difference is roughly 1.92s, making the mismatch obvious.","rejected":"The second child falls from the playground structure and hits the ground and the loud thud of a child falling and hitting the ground occur together, so the clip appears perfectly synchronized."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201621.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound are effectively synchronized: as the man falls forward off the hoverboard and crashes into the desks out of frame, the loud crash of falling and hitting the cabinet lands essentially together, with only a negligible natural tolerance of about 0.2s.","rejected":"There is a noticeable mismatch: the man falls forward off the hoverboard and crashes into the desks out of frame, but the loud crash of falling and hitting the cabinet comes clearly out of sync."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201621_delay_2.37s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not fully aligned. The visual impact is around t=5.0s when the man falls forward off the hoverboard and crashes into the desks out of frame, while the loud crash of falling and hitting the cabinet is heard at about t=4.363s, giving an estimated gap of roughly 0.64s.","rejected":"This clip is perfectly synchronized at t=5.0s: the man falls forward off the hoverboard and crashes into the desks out of frame exactly as the loud crash of falling and hitting the cabinet is heard."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201621_early_2.37s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a clear mismatch. The visual impact is around t=5.0s when the man falls forward off the hoverboard and crashes into the desks out of frame, but the loud crash of falling and hitting the cabinet arrives at about t=2.428s, an estimated separation of roughly 2.57s.","rejected":"The picture and sound are perfectly synchronized: the man falls forward off the hoverboard and crashes into the desks out of frame exactly when the loud crash of falling and hitting the cabinet is heard."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201647.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the girl head impacts the floor headfirst lines up with the loud thud of a doll hitting a gymnastics mat at about 3.0s, so the clip appears synchronized. Any offset is within a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch here: the loud thud of a doll hitting a gymnastics mat does not line up with the girl head impacting the floor headfirst, and the separation is clearly visible and audible."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201647_delay_2.17s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The girl head impacts the floor headfirst at about 3.0s visually, while the loud thud of a doll hitting a gymnastics mat is heard at about 3.762s. That puts the gap at roughly 0.76s, which is large enough to be clearly out of sync.","rejected":"The clip looks perfectly synchronized: the girl head impacts the floor headfirst and the loud thud of a doll hitting a gymnastics mat occur together right around 3.0s."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 201647_early_2.38s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The girl head impacts the floor headfirst at about 3.0s visually, but the loud thud of a doll hitting a gymnastics mat arrives around 0.621s. That is roughly a 2.38s gap, so the audio and video are plainly not synchronized.","rejected":"This clip appears perfectly synchronized, with the loud thud of a doll hitting a gymnastics mat matching the instant the girl head impacts the floor headfirst."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 20168.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the little girl falls off the stage and hits the floor is closely matched with the loud thump as she hits the floor. The audio is about 0.3s from the visual, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the little girl falls off the stage and hits the floor, but the loud thump lands distinctly apart from that moment, making the sync feel off."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 20168_delay_2.35s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 1.0s, when the little girl falls off the stage and hits the floor, while the corresponding loud thump is heard at about 3.553s. That puts the separation at roughly 2.55s, which is far too large to be perceived as synchronized.","rejected":"The little girl falls off the stage and hits the floor at about 1.0s, and the loud thump matches that exact moment perfectly, so the clip is fully synchronized."}
+{"video":"Funny School Fails Compilation _ 'School's Out' By FailArmy 20168_early_2.09s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event occurs at about 1.0s, when the little girl falls off the stage and hits the floor, but the loud thump is heard at about 0.0s. With an offset of roughly 1.0s, the sound and picture are clearly not synchronized.","rejected":"The loud thump aligns perfectly with the moment the little girl falls off the stage and hits the floor, so this clip appears fully synchronized."}
+{"video":"Funny Tourist Fails (June 2017) _ FailArmy38.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The impact moment where a suddenly thrown object or stick strikes the person's extended leg lines up well enough with the loud thud of the person falling and hitting the ground, so this clip appears synchronized overall.","rejected":"There is a noticeable audio-video mismatch here: the loud thud of the person falling and hitting the ground does not align with the moment a suddenly thrown object or stick strikes the person's extended leg."}
+{"video":"Funny Tourist Fails (June 2017) _ FailArmy38_delay_2.14s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear mismatch: the visual event at about 7.0s, when a suddenly thrown object or stick strikes the person's extended leg, does not line up with the loud thud of the person falling and hitting the ground, which is heard around 8.138s\u2014roughly a 1.14s separation.","rejected":"This clip is perfectly synchronized at about 7.0s: the loud thud of the person falling and hitting the ground matches exactly when a suddenly thrown object or stick strikes the person's extended leg."}
+{"video":"Funny Tourist Fails (June 2017) _ FailArmy38_early_2.11s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is plainly out of sync: the visual event occurs near 7.0s, when a suddenly thrown object or stick strikes the person's extended leg, but the loud thud of the person falling and hitting the ground is heard around 3.89s, giving an estimated gap of about 3.11s.","rejected":"The sound is perfectly synchronized with the picture here, with the loud thud of the person falling and hitting the ground matching exactly when a suddenly thrown object or stick strikes the person's extended leg."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)35.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not perfectly synchronized: the picture shows the person crashing violently onto the floor and furniture at about 4.0s, while the loud crash and clatter is heard around 3.0s, a noticeable ~1.0s separation.","rejected":"There is a clear sync problem here: the loud crash and clatter does not line up with the moment the person crashes violently onto the floor and furniture, and the offset is plainly noticeable."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)35_delay_2.20s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip has a clear AV offset. The visual impact happens at about 4.0s, when the person crashes violently onto the floor and into the furniture, but the loud crash and clatter is heard around 5.198s. That is roughly a 1.2s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at 4.0s the person crashes into the floor and furniture, and the loud crash and clatter lands right with that impact."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)35_early_2.08s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip also shows a strong mismatch. The visual impact is at about 4.0s, where the person crashes violently onto the floor and furniture, while the loud crash and clatter arrives near 0.92s. That is approximately a 3.08s separation, so the sound and picture are clearly not aligned.","rejected":"This clip looks perfectly synchronized, with the loud crash and clatter matching the exact instant the person crashes onto the floor and furniture."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)43.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is not synchronized: the person trips on their fallen shorts and falls face-first onto the white platform at about 3.0s, while the loud thud from body hitting the backdrop lands around 3.9s, a noticeable ~0.9s separation.","rejected":"This clip has a clear sync problem, with the impact and thud noticeably apart by about 0.9s."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)43_delay_2.28s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is clearly out of sync: the person trips on their fallen shorts and falls face-first onto the white platform at about t=3.0s, but the loud thud from body hitting the backdrop is heard at about t=5.094s. That puts the sound roughly 2.09s away from the visual impact, which is far beyond normal alignment tolerance.","rejected":"This clip appears perfectly synchronized, with the fall impact and thud both landing right around t=3.0s."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)43_early_1.89s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is also out of sync: the person trips on their fallen shorts and falls face-first onto the white platform at about t=3.0s, while the loud thud from body hitting the backdrop arrives at about t=2.007s. So the sound is roughly 0.99s offset from the visible impact, which is plainly noticeable.","rejected":"This clip appears perfectly synchronized, with the visible fall and the thud matching exactly."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)48.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound line up: at about 3.0s, the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, and the loud thud as the person crashes into the garage door occurs at the same moment. Any offset is within negligible natural tolerance (0.0s).","rejected":"There is a noticeable mismatch: when the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, the loud thud as the person crashes into the garage door does not line up and is clearly separated in time."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)48_delay_1.81s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear sync offset here: the visual impact happens at about 3.0s, when the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, but the loud thud as the person crashes into the garage door is heard around 4.813s. That is roughly a 1.81s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at 3.0s, the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, and the loud thud as the person crashes into the garage door matches that exact moment."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)48_early_2.05s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also out of sync: the visual impact is at about 3.0s, where the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, while the loud thud as the person crashes into the garage door is heard around 0.951s. That is roughly a 2.05s gap, clearly outside normal tolerance.","rejected":"The audio and video are perfectly synchronized here: when the man violently crashes back-first into the closed garage door after losing balance on the pogo stick, the loud thud as the person crashes into the garage door occurs right at the same instant."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)55.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound line up: as the boy slips while climbing down and his shirt catches on the fence spike, the loud metallic clang lands right with that abrupt halt. The timing difference is essentially negligible, well within a natural tolerance of 0.0s.","rejected":"There is a noticeable sync mismatch here: the loud metallic clang does not land with the moment the boy slips, catches on the fence spike, and is abruptly halted by the fence."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)55_delay_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear offset. The key visual impact happens at about 11.0s, when the boy slips while climbing down and his shirt catches on the fence spike, but the loud metallic clang is heard at 12.761s. That puts the gap at roughly 1.76s, which is plainly outside normal sync tolerance.","rejected":"The clip appears perfectly synchronized: at 11.0s, the moment the boy slips, catches on the fence spike, and is halted matches the loud metallic clang exactly."}
+{"video":"Get Out Of The Way!! - FailArmy After Dark (Ep. 12)55_early_2.30s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is also out of sync. The main visual impact is around 11.0s, where the boy slips while climbing down and his shirt catches on the fence spike, but the loud metallic clang arrives at 8.698s. That is about a 2.3s separation, which is far beyond natural tolerance.","rejected":"The picture and sound are perfectly aligned, with the loud metallic clang matching exactly when the boy slips, catches on the fence spike, and is abruptly stopped."}
+{"video":"Grandmas vs Grandpas - FailArmy Versus (December 2017) _ FailArmy11.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual moment when the man falls forward and forcefully hits the bowling lane face-first lines up with the loud thud of a bowling ball hitting a person's head at about 4.0\u20134.1s. The ~0.1s offset is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the man falls forward and forcefully hits the bowling lane face-first, but the loud thud of a bowling ball hitting a person's head lands distinctly apart in time, making the sync look off."}
+{"video":"Grandmas vs Grandpas - FailArmy Versus (December 2017) _ FailArmy11_delay_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The key visual action occurs at 4.0s, when the man falls forward and forcefully hits the bowling lane face-first, while the loud thud of a bowling ball hitting a person's head is heard at 5.408s. That puts the separation at roughly 1.41s, which is far beyond normal tolerance and indicates the picture and sound do not align.","rejected":"The man falls forward and forcefully hits the bowling lane face-first at 4.0s, and the loud thud of a bowling ball hitting a person's head matches that exact instant, so the clip is perfectly synchronized."}
+{"video":"Grandmas vs Grandpas - FailArmy Versus (December 2017) _ FailArmy11_early_2.49s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact is at 4.0s, when the man falls forward and forcefully hits the bowling lane face-first, but the loud thud of a bowling ball hitting a person's head occurs around 1.606s. That is about a 2.39s separation, clearly outside any natural tolerance, so the audio and visual events are not synchronized.","rejected":"The loud thud of a bowling ball hitting a person's head occurs exactly with the moment the man falls forward and forcefully hits the bowling lane face-first, so this clip is perfectly synchronized."}
+{"video":"Guess it's Time to Leave - Throwback Thursday (October 2017) _ FailArmy81.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the falling shovel handle strikes the man directly on the forehead lines up with the loud thud of the man falling onto the stairs at about 1.0s, with only a negligible natural tolerance of 0.0s, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the falling shovel handle strikes the man directly on the forehead around 1.0s, but the loud thud of the man falling onto the stairs seems offset enough to make the clip feel out of sync."}
+{"video":"Guess it's Time to Leave - Throwback Thursday (October 2017) _ FailArmy81_delay_2.20s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens at about 1.0s, when the falling shovel handle strikes the man directly on the forehead, while the loud thud of the man falling onto the stairs is heard at about 3.196s. That is roughly a 2.2s separation, which is far beyond normal tolerance, so the clip is not synchronized.","rejected":"The falling shovel handle strikes the man directly on the forehead at about 1.0s, and the loud thud of the man falling onto the stairs matches that same moment perfectly, so this clip is fully synchronized."}
+{"video":"Guess it's Time to Leave - Throwback Thursday (October 2017) _ FailArmy81_early_1.99s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual event occurs at about 1.0s, when the falling shovel handle strikes the man directly on the forehead, but the loud thud of the man falling onto the stairs is heard right at 0.0s. That puts the gap at roughly 1.0s, which is clearly outside normal tolerance, so the clip is not synchronized.","rejected":"The falling shovel handle strikes the man directly on the forehead and the loud thud of the man falling onto the stairs occur together, so this clip appears perfectly synchronized."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy28.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual moment when the woman falls from a high wall and her body impacts the hard pavement below lines up with the loud smack or thud as the person's body impacts the asphalt. Both occur at about 6.0s, so the 0.0s gap is well within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the woman falls from a high wall and hits the hard pavement below at about 6.0s, but the loud smack or thud as the person's body impacts the asphalt does not line up and is clearly offset."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy28_delay_1.85s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The impact is not aligned here: the woman falls from a high wall and her body hits the hard pavement at 6.0s, while the loud smack or thud as the person's body impacts the asphalt is heard around 7.854s. That is roughly a 1.85s separation, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: the woman falls from a high wall and impacts the hard pavement at 6.0s, and the loud smack or thud as the person's body impacts the asphalt matches that moment exactly."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy28_early_2.01s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This one is also not aligned. The woman falls from a high wall and her body impacts the hard pavement at 6.0s, but the loud smack or thud as the person's body impacts the asphalt occurs around 3.991s. The difference is about 2.01s, clearly outside natural sync tolerance.","rejected":"This clip looks perfectly synchronized, with the woman falling from a high wall and hitting the hard pavement at the same moment as the loud smack or thud as the person's body impacts the asphalt."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy4.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound are effectively in sync: when the skier faceplants into the snow after losing balance on the jump, the loud, dull thud of a body impacting the snow follows within a negligible natural tolerance of about 0.3s.","rejected":"There is a noticeable sync mismatch here: the skier faceplants into the snow, but the loud, dull thud arrives clearly out of step rather than matching the impact."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy4_delay_2.46s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear sync offset in this clip: the skier faceplants into the snow at about 2.0s, while the loud, dull thud of the body hitting the snow is heard around 4.763s, so the gap is roughly 2.76s.","rejected":"This clip appears perfectly synchronized at 2.0s, with the skier\u2019s faceplant and the loud, dull thud lining up exactly."}
+{"video":"Hardcore, Parkour! - Fan Submissions (May 2018) _ FailArmy4_early_2.37s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also plainly out of sync: the loud, dull thud of a body impacting the snow is heard right at 0.0s, while the skier faceplants into the snow at about 2.0s, giving an estimated separation of about 2.0s.","rejected":"The audio and video are perfectly synchronized here, with the skier\u2019s faceplant and the impact thud happening at the same moment."}
+{"video":"Hopeless Romantic - Fails of the Week (October 2018) _ FailArmy34.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the garbage truck's mechanical arm forcefully drops the trash can back onto the street lines up with the mechanical clank as the arm grabs the trash can. The sync is effectively exact, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch: the garbage truck's mechanical arm forcefully drops the trash can back onto the street, but the mechanical clank as the arm grabs the trash can does not line up and is clearly offset."}
+{"video":"Hopeless Romantic - Fails of the Week (October 2018) _ FailArmy34_delay_2.25s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual cue occurs at 11.0s, when the garbage truck's mechanical arm forcefully drops the trash can back onto the street, while the mechanical clank as the arm grabs the trash can is heard at 13.245s. That puts the offset at about 2.25s, which is clearly beyond normal sync tolerance.","rejected":"The garbage truck's mechanical arm forcefully drops the trash can back onto the street at 11.0s, and the mechanical clank as the arm grabs the trash can matches it perfectly at the same moment, so this clip is fully synchronized."}
+{"video":"Hopeless Romantic - Fails of the Week (October 2018) _ FailArmy34_early_1.90s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event is at 11.0s, where the garbage truck's mechanical arm forcefully drops the trash can back onto the street, but the mechanical clank as the arm grabs the trash can is heard at 9.096s. That's roughly a 1.9s offset, which is a clear sync mismatch rather than normal variation.","rejected":"The garbage truck's mechanical arm forcefully drops the trash can back onto the street and the mechanical clank as the arm grabs the trash can occur together with perfect synchronization, with no meaningful offset."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy4.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the person falls heavily to the ground as the folding chair completely collapses under their weight lines up with the loud crash of the chair breaking and the person falling backward at about 4.0s. The timing gap is 0.0s, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the person falls and the chair gives way around 4.0s, but the loud crash and backward fall sound seem offset enough to be clearly out of sync."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy4_delay_2.40s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at about 4.0s, when the person falls heavily to the ground as the folding chair completely collapses under their weight, while the loud crash of the chair breaking and the person falling backward is heard around 6.4s. That puts the offset at roughly 2.4s, which is a clear mismatch.","rejected":"The person hitting the ground and the folding chair collapsing match the loud crash right at about 4.0s, so this clip appears perfectly synchronized."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy4_early_2.29s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs near 4.0s, where the person falls heavily to the ground as the folding chair completely collapses under their weight, but the loud crash of the chair breaking and the person falling backward is heard around 1.714s. This is roughly a 2.29s offset, indicating a clear mismatch.","rejected":"The chair collapse, the person falling backward, and the loud crash all line up cleanly at about 4.0s, so this clip appears perfectly synchronized."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy14.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the large cat forcefully pushes through the narrow cat door and the door violently swings open matches the loud thud of the cat bursting through the flap and hitting the floor. The timing is effectively in sync, with only about 0.1s difference, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the cat crashing through the narrow door is seen first, and the loud thud of it bursting through and hitting the floor comes clearly later."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy14_delay_2.26s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens around 1.0s, when the large cat forcefully pushes through the narrow cat door and the whole door swings open, while the loud thud of the cat bursting through the flap and hitting the floor is heard around 3.362s. That puts the separation at roughly 2.36s, which is a clear mismatch.","rejected":"The large cat forcing through the narrow cat door and the loud thud of it bursting through and hitting the floor line up perfectly at 1.0s, so this clip is fully synchronized."}
+{"video":"I Am Stuck In This Car! - Fails You Missed #16 _ FailArmy14_early_2.00s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs around 1.0s, as the large cat forcefully pushes through the narrow cat door and the door abruptly swings open, but the loud thud of the cat bursting through the flap and hitting the floor is heard at 0.0s. So the sound leads by about 1.0s, which is an obvious mismatch.","rejected":"The cat forcing its body through the narrow cat door and the loud thud of it bursting through and hitting the floor are perfectly synchronized, with no meaningful timing difference."}
+{"video":"I Made It! - Fails of the Week (October 2017) _ FailArmy33.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment when two men fall backwards off a picnic table and hit the ground lines up well with the loud crash of them falling onto the table and ground. The sound is about 1.0 second from the visible impact, so this clip reads as reasonably synchronized overall.","rejected":"There is a noticeable mismatch here: the loud crash of two men falling onto the picnic table and ground does not line up with the moment the two men visibly fall backwards off the table and hit the ground."}
+{"video":"I Made It! - Fails of the Week (October 2017) _ FailArmy33_delay_2.00s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible impact happens at about 4.0s, while the loud crash is heard around 5.003s. That puts the gap at roughly 1.0 second, so when the two men fall backwards off the picnic table and hit the ground, the audio does not align closely with the seen impact.","rejected":"The clip appears perfectly synchronized: at 4.0s, the two men falling backwards off the picnic table and hitting the ground matches exactly with the loud crash."}
+{"video":"I Made It! - Fails of the Week (October 2017) _ FailArmy33_early_2.26s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visible fall and ground impact occur at about 4.0s, but the loud crash is heard near 0.74s. That is roughly a 3.26 second gap, so the sound is clearly not aligned with the moment the two men fall backwards off the picnic table and hit the ground.","rejected":"This clip appears perfectly synchronized, with the loud crash matching the exact moment the two men fall backwards off the picnic table and hit the ground."}
+{"video":"It's All Down Hill From Here - Throwback Fails (August 2017)24.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is effectively in sync: the moment the boy crashes into the ramp aligns closely with the loud crash and thud as the person and scooter impact the ground, with only about a 0.5s separation that can fall within natural perceptual tolerance.","rejected":"This clip shows a noticeable mismatch: the boy crashes into the ramp, but the loud crash and thud as the person and scooter impact the ground happen clearly out of step."}
+{"video":"It's All Down Hill From Here - Throwback Fails (August 2017)24_delay_2.09s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not well aligned: the boy crashes into the ramp at about 4.0s, while the loud crash and thud as the person and scooter impact the ground are heard around 5.589s, giving an estimated gap of about 1.59s.","rejected":"This clip appears perfectly synchronized at 4.0s, with the boy crashing into the ramp exactly as the loud crash and thud as the person and scooter impact the ground are heard."}
+{"video":"It's All Down Hill From Here - Throwback Fails (August 2017)24_early_2.44s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is clearly out of sync: the loud crash and thud as the person and scooter impact the ground are heard around 1.056s, whereas the boy crashes into the ramp at about 4.0s, for an estimated separation of about 2.94s.","rejected":"This clip appears perfectly synchronized, with the boy crashing into the ramp exactly when the loud crash and thud as the person and scooter impact the ground are heard."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)15.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual of the person being violently yanked off their feet by the parachute\/kite lines and slamming onto the grass lines up with the distinct thud of them hitting the grassy ground at about 1.0s. The gap is 0.0s, which is fully synchronized and within negligible natural tolerance.","rejected":"There is a noticeable sync issue here: the thud of the person hitting the grass does not align with the moment they are violently yanked off their feet and slam down, with the sound seeming offset by around a second."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)15_delay_2.15s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The key visual impact happens at about 1.0s, when the person is violently yanked off their feet by the parachute\/kite lines and slams onto the grass, but the distinct thud of them hitting the grassy ground is heard around 3.15s. That places the audio roughly 2.15s away from the visual event, which is a clear mismatch.","rejected":"This clip appears perfectly synchronized: at about 1.0s, the person is violently yanked off their feet and hits the grass exactly as the distinct thud is heard, with no meaningful separation between picture and sound."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)15_early_2.02s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs at about 1.0s, when the person is violently yanked off their feet by the parachute\/kite lines and forcefully slams onto the grass, while the distinct thud of them hitting the grassy ground is heard at 0.0s. So the sound is about 1.0s away from the pictured impact, which indicates an obvious mismatch.","rejected":"The action and sound are perfectly aligned here: the moment the person is yanked off their feet and slams onto the grass matches the thud precisely, so there is no sync problem."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)211.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The action and sound line up: the man falls and impacts the ground face-first right as the thud of the dizzy man falling and hitting the ground is heard. Any offset is within a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch here: the man falls and impacts the ground face-first, but the thud of the dizzy man falling and hitting the ground is clearly separated in time."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)211_delay_2.20s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear timing mismatch: the man falls and impacts the ground face-first at about 4.0s, while the thud of the dizzy man falling and hitting the ground is heard around 5.277s. That puts the gap at roughly 1.28s.","rejected":"This clip is perfectly synchronized at 4.0s, with the man falling face-first and the thud of the dizzy man hitting the ground occurring together."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)211_early_2.43s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a strong mismatch: the thud of the dizzy man falling and hitting the ground is heard at about 1.569s, while the man falls and impacts the ground face-first at about 4.0s. The separation is roughly 2.43s.","rejected":"This clip is perfectly synchronized, with the man falling face-first and the thud of the dizzy man hitting the ground happening at the same moment."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)26.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sound lines up well with the moment the man falls over the hammock and his body violently impacts the ground face-first: the loud thud of a body hitting the dirt ground follows by about 0.1s, which is within negligible natural tolerance and still feels synchronized.","rejected":"There is a noticeable mismatch: when the man falls over the hammock and hits the ground face-first, the loud thud of a body hitting the dirt ground is clearly separated enough to feel out of sync."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)26_delay_2.23s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not aligned. The visual impact happens at about 2.0s, when the man falls over the hammock and his body violently impacts the ground face-first, but the loud thud of a body hitting the dirt ground is heard around 4.233s, roughly 2.23s away, so the mismatch is obvious.","rejected":"This clip is perfectly synchronized at 2.0s: the man falls over the hammock and hits the ground face-first exactly as the loud thud of a body hitting the dirt ground is heard."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)26_early_1.89s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also not aligned. The visual impact is at about 2.0s, when the man falls over the hammock and his body violently impacts the ground face-first, while the loud thud of a body hitting the dirt ground occurs around 0.206s, about 1.79s away, making the separation easy to notice.","rejected":"This clip is perfectly synchronized: the man falls over the hammock and impacts the ground face-first at the same moment the loud thud of a body hitting the dirt ground is heard."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)75.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the person in the red shirt falls through the desks and hits the ground lines up with the loud crash of a person falling backwards in a chair and hitting the floor, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the person in the red shirt falls through the desks and hits the ground, but the loud crash of a person falling backwards in a chair and hitting the floor does not line up and is clearly offset."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)75_delay_2.09s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact occurs at about 1.0s, when the person in the red shirt falls through the desks and hits the ground, while the loud crash of a person falling backwards in a chair and hitting the floor is heard around 2.087s. That puts the gap at roughly 1.09s, which is clearly beyond normal sync tolerance.","rejected":"This clip is perfectly synchronized at 1.0s: the person in the red shirt falls through the desks and hits the ground exactly as the loud crash of a person falling backwards in a chair and hitting the floor is heard."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)75_early_2.42s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The person in the red shirt falls through the desks and hits the ground at about 1.0s, but the loud crash of a person falling backwards in a chair and hitting the floor is heard at 0.0s. So the gap is roughly 1.0s, indicating a clear audio-video mismatch.","rejected":"This clip is perfectly synchronized: the loud crash of a person falling backwards in a chair and hitting the floor matches the moment the person in the red shirt falls through the desks and hits the ground."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)74.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The sound lines up reasonably well with the moment a person crashes down heavily, causing desks to slide violently and bumping into other students; the loud crash as the person and chairs fall onto the desks follows by about 0.6 seconds, which can still read as broadly synchronized in a short chaotic scene.","rejected":"There is a clear mismatch here: the loud crash as the person and chairs fall onto the desks is noticeably separated from the moment the person crashes down heavily and desks slide, so the audio and video do not feel aligned."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)74_delay_1.89s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a pronounced offset: the visible impact begins at about 0.0s, when a person crashes down heavily, causing desks to slide violently and bumping into other students, but the loud crash as the person and chairs fall onto the desks is heard around 2.489s. That is roughly a 2.49-second gap, so the sound is clearly not synchronized with the pictured event.","rejected":"Everything appears perfectly synchronized at 0.0s: as the person crashes down heavily and desks slide into other students, the loud crash of the person and chairs falling onto the desks happens right at the same moment."}
+{"video":"Let's Get It!! - FailArmy After Dark (ep. 2)74_early_2.21s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This one is tightly aligned: the visible action starts at about 0.0s, with a person crashing down heavily and desks sliding violently into other students, and the loud crash as the person and chairs fall onto the desks is also at 0.0s. The estimated gap is essentially 0.0 seconds, so it appears fully synchronized.","rejected":"The clip is perfectly synchronized, with the loud crash matching the visible fall exactly and no timing issues at all."}
+{"video":"Let's Get Tropical - Beach Fails10.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The action and sound are effectively in sync: a man attempts a backflip but under-rotates, landing face-first in the sand, and the heavy, muffled thud of the impact follows essentially together. The roughly 0.2s offset is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the man\u2019s failed backflip and face-first landing in the sand happen well before the heavy, muffled thud, so the sound does not line up with the impact."}
+{"video":"Let's Get Tropical - Beach Fails10_delay_2.24s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear mismatch here. The visual impact\u2014when a man attempts a backflip but under-rotates, landing face-first in the sand\u2014occurs at about 6.0s, while the heavy, muffled thud of the body hitting the sand is heard around 8.445s. That places the gap at roughly 2.44s, which is far beyond normal sync tolerance.","rejected":"This clip appears perfectly synchronized: at 6.0s, the man\u2019s failed backflip and face-first landing in the sand align exactly with the heavy, muffled thud of the impact."}
+{"video":"Let's Get Tropical - Beach Fails10_early_2.17s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also noticeably out of sync. The visual moment where a man attempts a backflip but under-rotates, landing face-first in the sand, is at about 6.0s, but the heavy, muffled thud is heard around 4.034s. That is roughly a 1.97s separation, clearly outside natural sync variation.","rejected":"This clip appears perfectly synchronized, with the man\u2019s failed backflip and face-first landing matching the heavy, muffled thud exactly."}
+{"video":"Let's Get Tropical - Beach Fails7.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The boy lands flat on his back in the sand after jumping off a swing right as the dull thud of a person landing hard on the sand is heard, around 3.0s. The gap is essentially 0.0s, well within a negligible natural tolerance.","rejected":"There is a noticeable mismatch: the boy lands flat on his back in the sand around 3.0s, but the dull thud of a person landing hard on the sand does not line up and is clearly offset."}
+{"video":"Let's Get Tropical - Beach Fails7_delay_2.16s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at about 3.0s, when the boy lands flat on his back in the sand after jumping off a swing, while the dull thud of a person landing hard on the sand is heard at about 5.156s. That puts the offset at roughly 2.16s, which is plainly noticeable.","rejected":"The boy lands flat on his back in the sand after jumping off a swing at 3.0s, and the dull thud of a person landing hard on the sand matches that exact moment, so this clip is perfectly synchronized."}
+{"video":"Let's Get Tropical - Beach Fails7_early_2.02s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact occurs at about 3.0s, when the boy lands flat on his back in the sand after jumping off a swing, but the dull thud of a person landing hard on the sand is heard around 0.979s. The offset is about 2.02s by estimation, making the mismatch obvious.","rejected":"The boy lands flat on his back in the sand after jumping off a swing and the dull thud of a person landing hard on the sand occur together at the same moment, so this clip is perfectly synchronized."}
+{"video":"Mom's Going To Be Mad - Throwback Fails (June 2017) _ FailArmy90.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud, the sound of body hitting the dirt ground lands essentially together with the picture. The gap is only about 0.2s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: when the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud, the sound of body hitting the dirt ground does not line up well with the visual and feels clearly off."}
+{"video":"Mom's Going To Be Mad - Throwback Fails (June 2017) _ FailArmy90_delay_2.28s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The key visual impact happens at about 3.0s, when the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud, but the sound of body hitting the dirt ground is heard around 4.99s. That puts the separation at roughly 1.99s, which is a clear mismatch.","rejected":"This clip is perfectly synchronized: at 3.0s, the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud, and the sound of body hitting the dirt ground matches that exact moment."}
+{"video":"Mom's Going To Be Mad - Throwback Fails (June 2017) _ FailArmy90_early_2.20s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact is at about 3.0s, where the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud, while the sound of body hitting the dirt ground occurs near 1.005s. With an estimated gap of about 2.0s, the audio and visual are clearly not aligned.","rejected":"This clip appears perfectly synchronized: the sound of body hitting the dirt ground matches the instant the skateboarder falls forward and their upper body violently impacts the dirt ground, creating a large dust cloud."}
+{"video":"Ninja Fails - Sweep The Leg! (March 2017) _ FailArmy30.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound line up: the person falls backwards into the flooded water and the large splash is heard right as the impact is seen. The loud splash and body impact coincide with the visual moment, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch: the person is seen falling into the flooded water, but the loud splash and impact do not line up and are clearly offset from the visual impact."}
+{"video":"Ninja Fails - Sweep The Leg! (March 2017) _ FailArmy30_delay_2.12s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear offset here. The visual impact happens at about 4.0s, when the person falls backwards into the flooded water and creates a large splash, but the loud splash and body impact are heard around 6.119s. That is roughly a 2.12s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at 4.0s, the person hits the flooded water and the loud splash and impact occur exactly at the same moment."}
+{"video":"Ninja Fails - Sweep The Leg! (March 2017) _ FailArmy30_early_2.33s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This one also shows a clear offset. The visual impact is at about 4.0s, where the person falls backwards into the flooded water and makes a large splash, while the loud splash and body impact are heard around 1.669s. That is about a 2.33s difference, which is well outside natural sync tolerance.","rejected":"This clip appears perfectly synchronized: the person\u2019s fall into the flooded water and the loud splash and impact happen together with no visible or audible gap."}
+{"video":"Off The Heezy - Fails of the Week (August 2018)35.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The large crash is synchronized: the moment the barbell hits the floor and block, causing the weights to bounce erratically, lines up with the loud crash of a barbell dropping on the floor at about 6.0s. The 0.0s gap is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the barbell impact and bouncing are seen around 6.0s, but the loud crash seems to occur at a different moment, making the clip feel out of sync."}
+{"video":"Off The Heezy - Fails of the Week (August 2018)35_delay_1.82s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset. The visual impact at about 6.0s\u2014when the barbell hits the floor and block and the weights bounce erratically\u2014does not line up with the loud crash of a barbell dropping on the floor, which is heard around 7.823s. That is roughly a 1.82s gap, which is far beyond normal tolerance.","rejected":"This clip appears perfectly synchronized: at about 6.0s, the barbell hits the floor and block, the weights bounce erratically, and the loud crash occurs right at the same moment."}
+{"video":"Off The Heezy - Fails of the Week (August 2018)35_early_1.82s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset. The visual impact happens at about 6.0s, when the barbell hits the floor and block and the weights bounce erratically, but the loud crash of a barbell dropping on the floor is heard around 4.179s. That is roughly a 1.82s gap, well outside normal tolerance.","rejected":"This clip appears perfectly synchronized: the loud crash matches the instant the barbell hits the floor and block and the weights bounce erratically at about 6.0s."}
+{"video":"On The Job Fails - I Need A New Job (October 2017) _ FailArmy31.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the forklift backs into the pallet of goods on the left, producing a visible impact and slight camera shake, the loud crash of a forklift colliding with warehouse shelving follows very closely, so this clip appears synchronized overall.","rejected":"There is a noticeable audio-visual mismatch here: the forklift hits the pallet on the left and the camera shakes, but the loud crash arrives clearly out of step with the impact."}
+{"video":"On The Job Fails - I Need A New Job (October 2017) _ FailArmy31_delay_1.94s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"In this clip, the visible impact happens at about 4.0s when the forklift backs into the pallet of goods on the left and the camera shakes, while the loud crash of a forklift colliding with warehouse shelving is heard around 6.44s. That puts the gap at roughly 2.44s, which is far beyond normal sync tolerance, so the sound does not line up with the action.","rejected":"This clip is perfectly synchronized at 4.0s: as the forklift backs into the pallet on the left and the camera shakes, the loud crash matches the impact exactly."}
+{"video":"On The Job Fails - I Need A New Job (October 2017) _ FailArmy31_early_2.04s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"Here, the forklift backs into the pallet of goods on the left at about 4.0s, causing the visible impact and camera shake, but the loud crash of a forklift colliding with warehouse shelving is heard around 2.462s. The sound leads the visible contact by about 1.54s, which is well outside natural sync tolerance.","rejected":"This clip is perfectly synchronized: the loud crash occurs exactly with the moment the forklift backs into the pallet on the left and the camera shake begins."}
+{"video":"Sister Fails _ Funny Sisters Fail Compilation By FailArmy 201640.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip appears reasonably synchronized: the person on the left side of the seesaw falls back down and impacts the seat with a visible jolt, and the loud metallic clatter of the seesaw hitting the ground follows close enough to read as the same impact.","rejected":"This clip has a noticeable sync mismatch: the loud metallic clatter of the seesaw hitting the ground is clearly separated from when the person on the left side of the seesaw falls back down and impacts the seat."}
+{"video":"Sister Fails _ Funny Sisters Fail Compilation By FailArmy 201640_delay_2.30s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a clear timing mismatch. The visible moment is around 2.0s, when the person on the left side of the seesaw falls back down and impacts the seat with a visible jolt, but the loud metallic clatter of the seesaw hitting the ground lands near 3.237s, about 1.24s apart by estimation.","rejected":"This clip looks perfectly synchronized at about 2.0s: the person on the left side of the seesaw hits the seat and the loud metallic clatter of the seesaw hitting the ground occurs right at that same moment."}
+{"video":"Sister Fails _ Funny Sisters Fail Compilation By FailArmy 201640_early_2.26s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip also has an obvious timing mismatch. The visual impact happens around 2.0s, when the person on the left side of the seesaw falls back down and jolts the seat, while the loud metallic clatter of the seesaw hitting the ground is heard near 0.34s, roughly 1.66s away.","rejected":"This clip is perfectly synchronized: the loud metallic clatter of the seesaw hitting the ground matches exactly when the person on the left side of the seesaw falls back down and impacts the seat."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy16.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual moment when a large mass of snow slides off the roof of a camper trailer and forcefuly hits the ground and side of the camper lines up with the sound of a large heavy mass of snow crashing and collapsing down onto a vehicle. The sync is effectively exact, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable sync mismatch: the snow impact is seen first, and the crashing sound of the heavy snow hitting the vehicle follows distinctly later."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy16_delay_2.23s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The key visual event occurs at about 2.0s, when a large mass of snow slides off the roof of a camper trailer and forcefuly hits the ground and side of the camper, while the corresponding audio is heard at about 4.229s as the sound of a large heavy mass of snow crashing and collapsing down onto a vehicle. That puts the offset at roughly 2.23s, which is a clear mismatch by normal sync standards.","rejected":"The moment the snow slides off the camper and slams down is perfectly synchronized with the crashing sound right at 2.0s, with no meaningful gap between picture and audio."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy16_early_2.17s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The main visual action happens at about 2.0s, when a large mass of snow slides off the roof of a camper trailer and forcefuly hits the ground and side of the camper, but the related audio is already present at about 0.0s as the sound of a large heavy mass of snow crashing and collapsing down onto a vehicle. The separation is roughly 2.0s, which is a plainly noticeable sync error.","rejected":"The snow collapse and impact on the camper are perfectly synchronized with the heavy crashing audio, with both matching cleanly and no visible timing issue."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy27.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound read as synchronized: as the sled hits an unforeseen bump or obstacle, causing a high-energy sudden stop that forcefully launches the rider into the air, the loud clack from the sled hitting the jump lands right with that action.","rejected":"There is a noticeable mismatch here: the loud clack from the sled hitting the jump does not line up with the moment the sled hits the obstacle and throws the rider upward."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy27_delay_1.83s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is still a clear mismatch. The visible impact is around 1.0s, but the loud clack from the sled hitting the jump arrives around 1.832s, so by natural estimation the sound trails the moment when the sled hits the bump and forcefully launches the rider by about 0.83s.","rejected":"This clip looks perfectly synchronized at 1.0s: the loud clack from the sled hitting the jump matches exactly when the sled hits the bump and sends the rider into the air."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy27_early_2.28s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This one also shows a clear mismatch. The key visual moment is around 1.0s, while the loud clack from the sled hitting the jump is at 0.0s, so by natural estimation the sound comes about 1.0s away from the instant the sled hits the obstacle and forcefully launches the rider.","rejected":"This clip is perfectly synchronized: the loud clack from the sled hitting the jump lines up exactly with the moment the sled hits the bump and throws the rider upward."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy29.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment when two people, after being launched from a snow tube, hit the ground violently lines up with the loud thud as they impact the snow. Both occur at about 3.0s, so the 0.0s gap is within negligible natural tolerance and the clip appears synchronized.","rejected":"There is a noticeable mismatch: the loud thud as the individuals impact the snow does not align with the moment the two people hit the ground after being launched from the snow tube, making the sync visibly off."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy29_delay_1.87s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 3.0s, when two people, after being launched from a snow tube, hit the ground violently, but the loud thud as they impact the snow is heard around 4.869s. That is roughly a 1.87s separation, which is a clear audio-visual mismatch.","rejected":"The clip appears perfectly synchronized: at 3.0s, the two people hit the ground after being launched from the snow tube and the loud thud lands right with that moment."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy29_early_1.87s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual event occurs near 3.0s, when two people, after being launched from a snow tube, hit the ground violently, while the loud thud as they impact the snow arrives around 1.135s. This is approximately a 1.87s separation, so the sound and picture are clearly not aligned.","rejected":"The clip is perfectly synchronized, with the loud thud matching exactly when the two people hit the ground after being launched from the snow tube."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy45.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The clip appears reasonably synchronized: as a boy in a yellow jacket runs head-first into a snowman and falls backward, the dull thump when he hits the snowman lands close enough to the visible contact to feel aligned.","rejected":"There is a noticeable sync mismatch: the boy in a yellow jacket runs head-first into a snowman and falls backward, but the dull thump arrives clearly apart from the moment of impact."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy45_delay_1.83s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear sync offset here: the visual impact happens at about 4.0s, while the dull thump is heard around 5.228s, so when the boy in a yellow jacket runs head-first into a snowman and falls backward, the sound trails the contact by roughly 1.23s.","rejected":"This clip looks perfectly synchronized: at 4.0s, the boy in a yellow jacket runs head-first into a snowman and falls backward exactly as the dull thump is heard."}
+{"video":"Snow Day Fails - It's Cold Out There! (January 2018) _ FailArmy45_early_1.99s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip also shows an obvious sync problem: the visual impact is at about 4.0s, but the dull thump is heard near 1.409s, so when the boy in a yellow jacket runs head-first into a snowman and falls backward, the sound is separated from the contact by roughly 2.59s.","rejected":"This clip is perfectly synchronized, with the dull thump matching the instant the boy in a yellow jacket runs head-first into a snowman and falls backward."}
+{"video":"Sticks and Stones (July 2018) _ FailArmy6.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visuals and audio are effectively synchronized: as a speeding rally car crashes violently into a pile of debris where spectators are seated, sending people and materials flying, the loud crash of a car hitting a pile of debris follows at nearly the same moment, with only a negligible natural tolerance of about 0.2 s.","rejected":"There is a noticeable mismatch: the loud crash of the car hitting the pile of debris does not line up with the moment the speeding rally car slams into the debris and sends people and materials flying."}
+{"video":"Sticks and Stones (July 2018) _ FailArmy6_delay_2.31s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is clearly out of sync: the visual impact occurs around 2.0 s, when the speeding rally car crashes violently into the pile of debris and sends people and materials flying, but the loud crash of the car hitting the pile of debris is heard at about 4.508 s, giving an estimated gap of roughly 2.51 s.","rejected":"This clip appears perfectly synchronized at 2.0 s: the loud crash of the car hitting the pile of debris matches exactly when the speeding rally car crashes into the debris and sends people and materials flying."}
+{"video":"Sticks and Stones (July 2018) _ FailArmy6_early_1.93s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is also out of sync: the visual crash happens around 2.0 s, as the speeding rally car crashes violently into the pile of debris where spectators are seated, while the loud crash of the car hitting a pile of debris is heard near 0.274 s, for an estimated separation of about 1.73 s.","rejected":"The sound is perfectly synchronized with the picture here: the loud crash of the car hitting the pile of debris occurs exactly when the speeding rally car crashes into the debris and sends people and materials flying."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy18.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment the kayaker impacts the water at the base of the waterfall after free-falling matches the sound of the kayak hitting the water at the bottom of the waterfall. Both occur at about 2.0s, with a negligible natural tolerance of 0.0s, so this clip appears synchronized.","rejected":"There is a noticeable mismatch here: the kayaker impacts the water at the base of the waterfall after free-falling, but the sound of the kayak hitting the water at the bottom of the waterfall does not line up and seems offset by a clear amount."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy18_delay_2.01s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual cue is at 2.0s, when the kayaker impacts the water at the base of the waterfall after free-falling, while the sound of the kayak hitting the water at the bottom of the waterfall is heard at about 4.005s. That puts the gap at roughly 2.01s, which is a clear mismatch.","rejected":"This clip looks perfectly synchronized: at 2.0s, the kayaker impacts the water at the base of the waterfall after free-falling and the sound of the kayak hitting the water at the bottom of the waterfall occurs right with it."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy18_early_1.93s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual event is at 2.0s, where the kayaker impacts the water at the base of the waterfall after free-falling, but the sound of the kayak hitting the water at the bottom of the waterfall is heard at about 0.074s. That is roughly a 1.93s gap, so the audio and visual event do not align.","rejected":"This clip appears perfectly synchronized: the kayaker impacts the water at the base of the waterfall after free-falling and the sound of the kayak hitting the water at the bottom of the waterfall matches that moment exactly."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy23.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The small white boat collides with the side of the larger vessel at about 14.0s, and the loud crash of a boat impacting another vessel is heard at the same moment. This is synchronized, with only a negligible natural tolerance of 0.0s.","rejected":"The small white boat collides with the larger vessel around 14.0s, but the loud crash is noticeably offset, so the picture and sound do not line up well."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy23_delay_2.32s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The small white boat collides with the side of the larger vessel at about 14.0s, while the loud crash of a boat impacting another vessel is heard near 16.319s. That puts the sound roughly 2.32s away from the visible impact, which is a clear mismatch.","rejected":"The small white boat collides with the side of the larger vessel at about 14.0s, and the loud crash lands right there as well, so this clip is perfectly synchronized."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy23_early_2.16s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The small white boat collides with the side of the larger vessel at about 14.0s, while the loud crash of a boat impacting another vessel is heard near 11.843s. That is about a 2.16s separation from the visible impact, so the audio and video are clearly not aligned.","rejected":"The small white boat collides with the side of the larger vessel at about 14.0s, and the loud crash matches that instant exactly, making the clip perfectly synchronized."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy4.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is essentially in sync: the unicyclist loses balance and falls, violently impacting the ground and tumbling down the trail, and the loud clattering crash of the unicycle hitting the rocks after dropping off the ledge lands almost together, with only about a 0.5 s gap.","rejected":"There is a noticeable sync mismatch here: the unicyclist\u2019s fall and ground impact happen well apart from the loud clattering crash of the unicycle on the rocks, making the offset obvious."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy4_delay_1.92s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is not well aligned. The visual event occurs around 3.0 s, when the unicyclist loses balance and falls, violently impacting the ground and tumbling down the trail, while the loud clattering crash of the unicycle hitting the rocks after dropping off the ledge is heard around 4.421 s. That is roughly a 1.42 s separation, which is clearly perceptible.","rejected":"This clip appears perfectly synchronized at about 3.0 s: the unicyclist\u2019s fall and the loud clattering crash of the unicycle on the rocks happen together with no meaningful separation."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy4_early_2.44s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is strongly misaligned. The visual event is around 3.0 s, where the unicyclist loses balance and falls, violently impacting the ground and tumbling down the trail, but the loud clattering crash of the unicycle hitting the rocks after dropping off the ledge is heard near 0.062 s. That is about a 2.94 s separation, an obviously large mismatch.","rejected":"This clip is perfectly synchronized: the unicyclist\u2019s fall, impact, and tumble match the loud clattering crash of the unicycle on the rocks with no noticeable offset."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy95.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The impact is synchronized: at about 4.0s, the gymnast hits the crash mat forcefully with his body and the loud thump as he lands flat on his back on the mats occurs at the same moment. The 0.0s gap is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: when the gymnast hits the crash mat forcefully with his body, the loud thump as he lands flat on his back on the mats does not line up and is clearly separated in time."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy95_delay_1.91s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset here: the visual impact happens around 4.0s, when the gymnast hits the crash mat forcefully with his body, while the loud thump as he lands flat on his back on the mats is heard around 5.91s. That is roughly a 1.91s separation, which is far beyond normal tolerance.","rejected":"This one is perfectly synchronized at about 4.0s: the gymnast hits the crash mat forcefully with his body and the loud thump as he lands flat on his back on the mats matches exactly at that moment."}
+{"video":"That's A Sideways Wheelie! - Throwback Thursday (August 2017) _ FailArmy95_early_2.29s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is also a substantial offset here: the visual impact is around 4.0s, when the gymnast hits the crash mat forcefully with his body, but the loud thump as he lands flat on his back on the mats is heard around 1.715s. That is about a 2.29s separation, well outside normal tolerance.","rejected":"This clip is perfectly synchronized: the moment the gymnast hits the crash mat forcefully with his body, the loud thump as he lands flat on his back on the mats occurs exactly together."}
+{"video":"The Master Swordsmen - Fails You Missed #17 _ FailArmy74.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The violent bite that tears off the vehicle\u2019s front bumper and triggers rapid camera shake lines up with the loud snapping and cracking sound at about 1.0s; with a measured gap of 0.0s, this is fully synchronized and within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the loud snapping and cracking sound does not coincide with the alligator\u2019s violent bite and bumper tear, making the sync clearly off."}
+{"video":"The Master Swordsmen - Fails You Missed #17 _ FailArmy74_delay_2.01s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The key visual event occurs at about 1.0s, when the alligator violently bites and tears off part of the vehicle\u2019s front bumper with rapid camera shake, while the loud snapping and cracking sound is heard at about 3.012s. That puts the offset at roughly 2.01s, which is a clear mismatch by normal viewing standards.","rejected":"The violent bite, bumper tear, camera shake, and the loud snapping and cracking sound all happen together at about 1.0s, so this clip is perfectly synchronized."}
+{"video":"The Master Swordsmen - Fails You Missed #17 _ FailArmy74_early_1.92s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual action happens at about 1.0s, where the alligator violently bites and rips off part of the vehicle\u2019s front bumper with rapid camera shake, but the loud snapping and cracking sound starts at about 0.0s. That is roughly a 1.0s gap, which is plainly noticeable and indicates the audio and visual events do not align.","rejected":"The loud snapping and cracking sound matches the alligator\u2019s violent bite and bumper tear exactly, so the clip appears perfectly synchronized."}
+{"video":"The Wheels Are Coming Off! - Throwback Fails (December 2017) _ FailArmy26.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The impact moment is synchronized: the person hits the ground heavily after falling from the swung tree branch right as the loud splat or thud is heard. Both occur at about 3.0s, with a negligible 0.0s tolerance well within natural sync variation.","rejected":"There is a noticeable mismatch here: the person hits the ground heavily after falling from the swung tree branch, but the loud splat or thud lands clearly apart from the visual impact rather than together."}
+{"video":"The Wheels Are Coming Off! - Throwback Fails (December 2017) _ FailArmy26_delay_2.09s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not aligned. The person hits the ground heavily after falling from the swung tree branch at about 3.0s visually, while the loud splat or thud arrives around 3.71s in the audio, giving an estimated gap of about 0.71s.","rejected":"This clip appears perfectly synchronized at 3.0s: the person hits the ground heavily after falling from the swung tree branch exactly when the loud splat or thud is heard."}
+{"video":"The Wheels Are Coming Off! - Throwback Fails (December 2017) _ FailArmy26_early_2.14s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip shows a clear mismatch. The person hits the ground heavily after falling from the swung tree branch at about 3.0s visually, but the loud splat or thud is heard around 0.858s, for an estimated separation of about 2.14s.","rejected":"This clip appears perfectly synchronized, with the person hitting the ground heavily after falling from the swung tree branch exactly as the loud splat or thud is heard."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy27.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is reasonably well synchronized: the moment the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area is followed by the loud metallic clatter of the bike impacting the surrounding structure after the fall at about 1.0s later, which fits the action naturally.","rejected":"This clip has a noticeable sync problem: the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area, but the loud metallic clatter of the bike impacting the surrounding structure after the fall arrives clearly out of step."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy27_delay_2.46s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is clearly out of sync: the visual crash happens around 5.0s, when the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area, but the loud metallic clatter of the bike impacting the surrounding structure after the fall is heard around 8.463s, about 3.46s apart.","rejected":"This clip appears perfectly synchronized at 5.0s: as the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area, the loud metallic clatter of the bike impacting the surrounding structure after the fall matches exactly."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy27_early_1.87s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is somewhat misaligned: the visual impact occurs around 5.0s, when the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area, while the loud metallic clatter of the bike impacting the surrounding structure after the fall is heard around 4.13s, roughly 0.87s apart.","rejected":"This clip is perfectly synchronized: the BMX rider and bike completely miss the foam pit and crash violently into the metal railing and structure beyond the landing area exactly as the loud metallic clatter of the bike impacting the surrounding structure after the fall is heard."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy53.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the snowmobile crashes directly into a tree alongside the snowy path matches the loud crash and snapping branches as the snowmobile collides with trees. Both occur at about 8.0s, so the 0.0s offset is within negligible natural tolerance and looks synchronized.","rejected":"There is a noticeable mismatch: the snowmobile hits the tree on screen, but the loud crash and snapping branches arrive clearly apart in time rather than together."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy53_delay_1.91s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 8.0s, when the snowmobile crashes directly into a tree alongside the snowy path, while the loud crash and snapping branches as the snowmobile collides with trees are heard at about 9.907s. That places the audio roughly 1.91s away from the visible impact, which is a clear mismatch.","rejected":"The snowmobile striking the tree and the loud crash with snapping branches line up perfectly at about 8.0s, so this clip appears fully synchronized."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy53_early_2.49s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visible crash into the tree occurs at about 8.0s, but the loud crash and snapping branches as the snowmobile collides with trees are heard around 5.514s. That puts the sound about 2.49s away from the visual event, so the sync is clearly off.","rejected":"The moment the snowmobile crashes into the tree is perfectly matched by the loud crash and snapping branches, with no meaningful offset between picture and sound."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy83.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the main section of the ceiling collapses and crashes directly onto the desk and the person sitting in the background lines up with the loud crash of the ceiling collapsing onto the desk at about 6.0s. The gap is effectively 0.0s, well within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the ceiling collapse onto the desk and the person is seen around 6.0s, but the loud crash does not seem to line up and feels clearly offset."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy83_delay_2.11s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The main section of the ceiling collapses and crashes directly onto the desk and the person sitting in the background at about 6.0s, while the loud crash of the ceiling collapsing onto the desk is heard around 8.11s. That is roughly a 2.11s separation, which is far beyond normal tolerance, so the picture and sound do not align.","rejected":"The ceiling collapse onto the desk and the person in the background is perfectly synchronized with the loud crash at 6.0s, with no meaningful separation between picture and sound."}
+{"video":"Throwback Fails - Backflip Belly Flops Optional! (December 2017) _ FailArmy83_early_2.38s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The main section of the ceiling collapses and crashes directly onto the desk and the person sitting in the background is visible at about 6.0s, but the loud crash of the ceiling collapsing onto the desk is heard around 3.62s. That puts the gap at about 2.38s, which is clearly outside natural tolerance, so the audio and visual event are not aligned.","rejected":"This clip is perfectly synchronized: the ceiling collapse onto the desk and the person coincides exactly with the loud crash, with no visible or audible timing gap."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy14.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the man falls off the hoverboard and hits the floor lines up closely with the loud thud of him landing on the wooden floor. The gap is only 0.4s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: the man falls off the hoverboard and hits the floor, but the loud thud of him landing on the wooden floor happens clearly out of sync."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy14_delay_2.39s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens at about 3.0s, when the man falls off the hoverboard and hits the floor, while the loud thud of him landing on the wooden floor is heard at about 4.993s. That is roughly a 1.99s separation, so the audio and visual events do not line up.","rejected":"The man falls off the hoverboard and hits the floor at 3.0s, and the loud thud aligns perfectly there as well, so this clip is fully synchronized."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy14_early_2.26s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual fall happens at about 3.0s, when the man falls off the hoverboard and hits the floor, but the loud thud of him landing on the wooden floor is heard around 0.337s. That is about a 2.66s difference, so the sound and picture are clearly not aligned.","rejected":"The man falls off the hoverboard and hits the floor, and the loud thud of him landing on the wooden floor matches it perfectly, so this clip is synchronized."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy61.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are reasonably aligned: when the kayak capsizes and the second person hits the water with a big splash, the loud splash with the censor beep follows closely enough to feel in sync.","rejected":"There is a noticeable sync problem here: the kayak capsizes and the second person splashes into the water, but the loud splash with the censor beep lands clearly apart from that moment."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy61_delay_2.49s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset. The visual peak is around 4.8s, when the kayak capsizes and the second person is plunged into the water with a significant splash, but the corresponding audio event\u2014the loud splash partially masked by a censor beep\u2014arrives around 6.494s, roughly 1.69s apart by natural estimation.","rejected":"This clip is perfectly synchronized at about 4.8s: the kayak capsizes, the second person hits the water, and the loud splash with the censor beep matches that instant exactly."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy61_early_1.84s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a strong mismatch. The key visual moment is near 4.8s, when the kayak capsizes and the second person falls into the water with a large splash, while the matching audio splash partly covered by a censor beep is heard around 2.164s, about 2.64s apart by natural estimation.","rejected":"This one is perfectly synchronized: the kayak capsizes, the second person splashes into the water, and the loud splash with the censor beep lines up exactly with the action."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy55.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The picture and sound are effectively in sync: as the man's face hits the side of the minivan after falling forward off the fence, the audio of a man falling over a fence and hitting the ground lands about 1.0s apart, which fits the action closely enough in context.","rejected":"There is a noticeable sync problem here: the man's face hits the side of the minivan after falling forward off the fence, but the sound of a man falling over a fence and hitting the ground is clearly offset and does not match the impact."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy55_delay_2.42s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear sync offset: the visual moment is around 6.0s, when the man's face hits the side of the minivan after falling forward off the fence, while the corresponding audio of a man falling over a fence and hitting the ground is around 7.424s. By estimation, that is about a 1.42s gap, which is plainly noticeable.","rejected":"This clip appears perfectly synchronized at 6.0s, with the man's face hitting the side of the minivan after falling forward off the fence exactly matching the sound of a man falling over a fence and hitting the ground."}
+{"video":"Throwback Fails - Carriage Carnage (April 2018) _ FailArmy55_early_2.21s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a strong sync mismatch: the visual event occurs around 6.0s, when the man's face hits the side of the minivan after falling forward off the fence, but the audio of a man falling over a fence and hitting the ground is around 2.785s. Roughly speaking, that is a 3.21s separation, so the disconnect is obvious.","rejected":"This clip is perfectly synchronized, with the man's face hitting the side of the minivan after falling forward off the fence lining up exactly with the sound of a man falling over a fence and hitting the ground."}
+{"video":"Throwback Fails - Everybody Sing!! (February 2018) _ FailArmy35.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound line up: at about 6.0s, the man forcefully flops and crashes into the hard interior surface of the boat after climbing out of the water, and the loud physical impact as the boat hits the rocks or an oar strikes the boat is heard at the same moment. Any offset is within a negligible natural tolerance of 0.0s.","rejected":"There is a noticeable sync mismatch: the man forcefully flops and crashes into the hard interior surface of the boat around 6.0s, but the loud physical impact is heard distinctly apart from that moment."}
+{"video":"Throwback Fails - Everybody Sing!! (February 2018) _ FailArmy35_delay_2.30s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear sync offset here: the visible action occurs around 6.0s, when the man forcefully flops and crashes into the hard interior surface of the boat after climbing out of the water, while the loud physical impact as the boat hits the rocks or an oar strikes the boat is heard around 8.303s. That is roughly a 2.3s gap, which is far beyond natural tolerance.","rejected":"The moment is perfectly synchronized at about 6.0s: as the man forcefully flops and crashes into the hard interior surface of the boat, the loud physical impact is heard exactly with the motion."}
+{"video":"Throwback Fails - Everybody Sing!! (February 2018) _ FailArmy35_early_1.90s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip also shows a substantial sync offset: the visible crash happens around 6.0s, when the man forcefully flops and crashes into the hard interior surface of the boat after climbing out of the water, but the loud physical impact as the boat hits the rocks or an oar strikes the boat is heard around 4.101s. The gap is about 1.9s, clearly outside normal tolerance.","rejected":"The sound is perfectly synchronized with the visible crash: at about 6.0s, the man forcefully flops into the boat and the loud physical impact matches that exact instant."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy10.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The moment the woman is dropped and hits the grass after being carried lines up well with the dull thud as the two people fall onto the soft grassy ground, so this clip appears synchronized overall.","rejected":"There is a noticeable mismatch here: the woman hits the grass after being carried, but the dull thud of the fall lands clearly apart from that visual moment."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy10_delay_2.17s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not aligned: the woman is dropped and hits the grass at about 3.0s, while the dull thud as the two people fall onto the soft grassy ground is heard around 4.169s, giving an estimated separation of about 1.17s.","rejected":"This clip appears perfectly synchronized at 3.0s, with the woman hitting the grass exactly as the dull thud is heard."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy10_early_2.16s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is clearly not aligned: the woman is dropped and hits the grass at about 3.0s, but the dull thud as the two people fall onto the soft grassy ground is heard at 0.0s, an estimated gap of about 3.0s.","rejected":"This clip appears perfectly synchronized, with the woman hitting the grass exactly when the dull thud is heard."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy42.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The impact looks synchronized: the moment the man lands hard on his head and upper back after missing the blue padded mat lines up with the loud thud as he falls onto the blue mat. The timing difference is only about 0.2s, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch: the man lands hard on his head and upper back after missing the blue padded mat, but the loud thud as he falls onto the blue mat does not line up and is clearly offset."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy42_delay_2.23s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear mismatch here. The visual impact\u0014when the man lands hard on his head and upper back after failing to complete a backflip and missing the blue padded mat\u0014occurs at about 2.9s, while the loud thud as the man falls onto the blue mat is heard around 4.934s, an estimated gap of about 2.03s.","rejected":"This clip appears perfectly synchronized: at about 2.9s, the man lands hard on his head and upper back after missing the blue padded mat exactly as the loud thud as he falls onto the blue mat is heard."}
+{"video":"Throwback Fails - Jump Around! (March 2018) _ FailArmy42_early_2.26s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a strong mismatch. The visual impact\u0014the man landing hard on his head and upper back after failing to complete a backflip and missing the blue padded mat\u0014is around 2.9s, but the loud thud as the man falls onto the blue mat is heard near 0.437s, giving an estimated separation of about 2.46s.","rejected":"This clip appears perfectly synchronized: the man lands hard on his head and upper back after missing the blue padded mat at the exact moment the loud thud as he falls onto the blue mat is heard."}
+{"video":"Throwback Fails - Saved It! (January 2018) _ FailArmy37.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is reasonably well synchronized: when the skateboarder fails the trick and lands forcefully crotch-first onto the metal railing, the loud crash of the person and skateboard hitting the concrete stairs follows closely enough to read as aligned overall.","rejected":"This clip has a noticeable audio-visual mismatch: the skateboarder fails the trick and lands on the metal railing, but the loud crash of the person and skateboard hitting the concrete stairs does not line up well with the impact."}
+{"video":"Throwback Fails - Saved It! (January 2018) _ FailArmy37_delay_2.11s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear mismatch here: the visual impact happens at about 2.0s, when the skateboarder fails the trick and lands forcefully crotch-first onto the metal railing, while the loud crash of the person and skateboard hitting the concrete stairs arrives around 4.708s. That is roughly a 2.71s separation, which is far too large to feel synchronized.","rejected":"This clip is perfectly synchronized at 2.0s: the moment the skateboarder fails the trick and lands on the metal railing matches exactly with the loud crash of the person and skateboard hitting the concrete stairs."}
+{"video":"Throwback Fails - Saved It! (January 2018) _ FailArmy37_early_2.44s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip is also clearly out of sync: the visual impact is around 2.0s, where the skateboarder fails the trick and lands forcefully crotch-first onto the metal railing, but the loud crash of the person and skateboard hitting the concrete stairs occurs near 0.159s. That is about a 1.84s offset, which is plainly noticeable.","rejected":"This clip is perfectly synchronized: the skateboarder\u2019s failed trick and forceful landing on the metal railing line up exactly with the loud crash of the person and skateboard hitting the concrete stairs."}
+{"video":"Throwback Fails - That's one greedy cat!12.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The shark violently thrashes and bumps the camera after being speared at about 5.0s, and the unspecified impact sound lands at the same moment around 5.0s. This is effectively synchronized, with only a negligible natural tolerance of 0.0s.","rejected":"The shark violently thrashes and bumps the camera near 5.0s, but the unspecified impact sound is noticeably off, creating a clear mismatch rather than lining up with the visible hit."}
+{"video":"Throwback Fails - That's one greedy cat!12_delay_2.01s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The shark violently thrashes and bumps the camera after being speared at about 5.0s, while the unspecified impact sound is heard around 7.011s. That puts the audio roughly 2.01s away from the visible impact, so it is clearly not synchronized.","rejected":"The shark violently thrashes and bumps the camera at about 5.0s, and the unspecified impact sound matches it perfectly there, so the clip is fully synchronized."}
+{"video":"Throwback Fails - That's one greedy cat!12_early_1.94s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The shark violently thrashes and bumps the camera after being speared at about 5.0s, but the unspecified impact sound arrives around 3.058s. So the sound is roughly 1.94s away from the visual event, which indicates clear misalignment.","rejected":"The shark violently thrashes and bumps the camera at about 5.0s, and the unspecified impact sound lines up exactly with that moment, making the clip perfectly synchronized."}
+{"video":"Throwback Fails - That's one greedy cat!28.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The picture and sound are essentially in sync: as the shopping cart tips over after hitting the curb and crashes onto the pavement, causing the person inside to fall, you hear the loud crash of the cart hitting the curb and tipping over at nearly the same moment, with only about a 0.6s gap.","rejected":"There is a noticeable mismatch: the loud crash of the shopping cart hitting the curb and tipping over does not line up with the moment the cart tips over and crashes onto the pavement, so the sound and picture feel clearly out of sync."}
+{"video":"Throwback Fails - That's one greedy cat!28_delay_2.23s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"There is a clear offset here: the visual impact happens around 4.0s, when the shopping cart tips over after hitting the curb and crashes onto the pavement, but the loud crash of the cart hitting the curb and tipping over is heard around 5.63s, roughly 1.63s apart by estimation.","rejected":"This clip appears perfectly synchronized at 4.0s: the moment the shopping cart tips over and crashes onto the pavement matches exactly with the loud crash of the cart hitting the curb and tipping over."}
+{"video":"Throwback Fails - That's one greedy cat!28_early_2.35s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This one also shows an obvious offset: the key visual moment is around 4.0s, when the shopping cart tips over after hitting the curb and crashes onto the pavement, while the loud crash of the cart hitting the curb and tipping over is heard around 1.053s, a separation of about 2.95s by estimation.","rejected":"The sound is perfectly synchronized with the picture: the loud crash of the shopping cart hitting the curb and tipping over matches exactly with the moment the cart tips over and crashes onto the pavement."}
+{"video":"Throwback Fails - That's one greedy cat!77.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The moment an object hits and shatters the glass light fixture attached to the ceiling fan is accompanied by a loud crash followed by breaking glass\/plastic at nearly the same time. The offset is only about 0.4s, which is within negligible natural tolerance, so this clip appears effectively synchronized.","rejected":"There is a noticeable mismatch here: the object hits and shatters the glass light fixture on the ceiling fan, but the loud crash and breaking-glass sound arrive clearly out of step, making the clip seem poorly synchronized."}
+{"video":"Throwback Fails - That's one greedy cat!77_delay_2.02s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visual impact happens around 0.8s, when an object hits and shatters the glass light fixture attached to the ceiling fan, while the loud crash followed by breaking glass\/plastic is heard around 2.425s. That puts the gap at roughly 1.62s, which is a clear mismatch rather than natural sync variation.","rejected":"This clip is perfectly synchronized at about 0.8s: as the object hits and shatters the glass light fixture attached to the ceiling fan, the loud crash and breaking-glass sound occur right on cue."}
+{"video":"Throwback Fails - That's one greedy cat!77_early_2.24s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The visible shattering of the glass light fixture on the ceiling fan occurs around 0.8s, but the loud crash followed by breaking glass\/plastic starts at 0.0s. With an estimated gap of about 0.8s, the audio and visual events do not line up naturally.","rejected":"This clip appears perfectly synchronized, with the loud crash and breaking-glass sound matching the moment the object hits and shatters the glass light fixture attached to the ceiling fan."}
+{"video":"Throwback Fails - That's one greedy cat!71.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visuals and sound are essentially in sync: as a dark car from the right T-bones a black SUV in the intersection, causing the SUV to roll and a large dust cloud, the loud crash sound of a vehicle colliding with a building follows at nearly the same moment. The gap is about 0.2s, which is within negligible natural tolerance.","rejected":"There is a noticeable sync mismatch: the loud crash sound of a vehicle colliding with a building does not line up well with the moment the dark car T-bones the black SUV and it rolls over in the intersection."}
+{"video":"Throwback Fails - That's one greedy cat!71_delay_2.14s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear sync offset. The main visual impact happens around 4.0s, when a dark car from the right T-bones a black SUV in the intersection, causing it to roll and kick up a large dust cloud, while the loud crash sound of a vehicle colliding with a building is heard around 6.339s. That places the separation at roughly 2.34s, which is far beyond normal tolerance.","rejected":"The clip appears perfectly synchronized at 4.0s: the loud crash sound of a vehicle colliding with a building matches exactly when the dark car T-bones the black SUV and the rollover begins."}
+{"video":"Throwback Fails - That's one greedy cat!71_early_1.93s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is not well synchronized. The visual collision is around 4.0s, where a dark car from the right T-bones a black SUV in the intersection and the SUV rolls as dust blooms outward, but the loud crash sound of a vehicle colliding with a building is heard around 2.27s. That is roughly a 1.73s separation, which is clearly outside normal tolerance.","rejected":"The audio and video are perfectly synchronized: the loud crash sound of a vehicle colliding with a building occurs exactly with the moment the dark car strikes the black SUV and the rollover starts."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy34.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The hang glider violently crashes into dense bushes, and the loud crunching and snapping sounds as the hang glider crashes into bushes follow closely enough to read as synchronized overall.","rejected":"The hang glider violently crashes into dense bushes, but the loud crunching and snapping sounds as the hang glider crashes into bushes arrive noticeably out of step, making the sync feel clearly off."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy34_delay_2.35s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The hang glider violently crashes into dense bushes at about 5.0s, while the loud crunching and snapping sounds as the hang glider crashes into bushes are heard around 6.352s. That is roughly a 1.35s separation, which is a clear sync mismatch.","rejected":"The hang glider violently crashes into dense bushes at 5.0s, and the loud crunching and snapping sounds as the hang glider crashes into bushes line up perfectly there, so the clip appears fully synchronized."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy34_early_2.32s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The hang glider violently crashes into dense bushes at about 5.0s, but the loud crunching and snapping sounds as the hang glider crashes into bushes occur near 1.675s. That is roughly a 3.32s separation, which is an obvious sync mismatch.","rejected":"The hang glider violently crashes into dense bushes and the loud crunching and snapping sounds as the hang glider crashes into bushes match perfectly, so the clip appears fully synchronized."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy33.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound are essentially in sync: as the boy falls backward off the spinning hoverboard and crashes hard onto the wooden floor, the loud thud as he crashes backwards into the wooden cabinet lands almost together, with only about 0.1s between them, which is within negligible natural tolerance.","rejected":"There is a noticeable mismatch here: the boy falls backward off the spinning hoverboard and hits the floor, but the loud thud as he crashes backwards into the wooden cabinet arrives clearly out of sync."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy33_delay_2.43s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a small but perceptible offset: the visible moment when the boy falls backward off the spinning hoverboard and crashes hard onto the wooden floor is around 3.0s, while the loud thud as he crashes backwards into the wooden cabinet is around 3.303s, so the sound trails by roughly 0.3s.","rejected":"This one appears perfectly synchronized at 3.0s: the boy falls backward off the spinning hoverboard and the loud thud as he crashes backwards into the wooden cabinet happens exactly with the impact."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy33_early_2.38s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This one shows a clear synchronization problem: the visible crash, when the boy falls backward off the spinning hoverboard and slams onto the wooden floor, is around 3.0s, but the loud thud as he crashes backwards into the wooden cabinet is around 0.519s, putting them apart by roughly 2.48s.","rejected":"The audio and picture are perfectly synchronized here: as the boy falls backward off the spinning hoverboard and crashes, the loud thud as he crashes backwards into the wooden cabinet matches the impact exactly."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy42.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The bodybuilder lands face-first on the stage floor after attempting a flip, and the loud thud of a body landing hard on the stage floor follows essentially at the same moment. The timing difference is only about 0.1s, which is within negligible natural tolerance, so this clip appears synchronized.","rejected":"The bodybuilder lands face-first on the stage floor after attempting a flip, but the loud thud of a body landing hard on the stage floor is noticeably out of step, making the mismatch obvious."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy42_delay_2.31s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The bodybuilder lands face-first on the stage floor after attempting a flip at about 4.0s, while the loud thud of a body landing hard on the stage floor is heard around 6.208s. That puts the offset at roughly 2.21s, so the picture and sound are clearly not aligned.","rejected":"The bodybuilder lands face-first on the stage floor after attempting a flip at 4.0s, and the loud thud of a body landing hard on the stage floor matches it perfectly at that same moment, so the clip is fully synchronized."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy42_early_2.20s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The bodybuilder lands face-first on the stage floor after attempting a flip at about 4.0s, but the loud thud of a body landing hard on the stage floor occurs around 1.699s. That's roughly a 2.3s separation, indicating a clear lack of alignment between the visual event and the sound.","rejected":"The bodybuilder lands face-first on the stage floor after attempting a flip and the loud thud of a body landing hard on the stage floor occurs right with it, so this clip appears perfectly synchronized."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy52.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is well synchronized: the moment the child falls and his helmet impacts the concrete curb lines up closely with the loud clack of the boy hitting the ground with his helmet and scooter, with about a 1.0s gap between the visual cue and the sound.","rejected":"There is a noticeable sync mismatch here: the child falls and his helmet impacts the concrete curb, but the loud clack of the boy hitting the ground with his helmet and scooter happens clearly out of step with the action."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy52_delay_2.35s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"In this clip, the key visual event occurs at about 2.0s, when the child falls and his helmet impacts the concrete curb, while the corresponding loud clack of the boy hitting the ground with his helmet and scooter is heard around 3.35s. That puts the offset at roughly 1.35s, which is clearly noticeable.","rejected":"This clip appears perfectly synchronized: at 2.0s, the child falls and his helmet impacts the concrete curb exactly as the loud clack of the boy hitting the ground with his helmet and scooter is heard."}
+{"video":"Throwback Fails - When Enough Is Enough! (February 2018) _ FailArmy52_early_1.96s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"In this clip, the child falls and his helmet impacts the concrete curb at about 2.0s visually, but the loud clack of the boy hitting the ground with his helmet and scooter is already present at 0.0s. That is an estimated 2.0s separation, making the mismatch very obvious.","rejected":"This clip is perfectly synchronized, with the child falling and his helmet impacting the concrete curb exactly together with the loud clack of the boy hitting the ground with his helmet and scooter."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy15.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sound and picture line up: as the man lands heavily on his back and shoulder on the hard concrete floor after catching his foot and flipping over the yellow railing, the loud physical impact of him hitting the yellow metal railing is heard at the same moment, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable audio-video mismatch here: the loud physical impact of the person hitting the yellow metal railing does not align with the moment the man lands heavily on his back and shoulder on the hard concrete floor after flipping over the yellow railing."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy15_delay_2.06s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a clear offset. The visual event is around 4.0s, when the man lands heavily on his back and shoulder on the hard concrete floor after catching his foot and flipping over the yellow railing, but the loud physical impact of the person hitting the yellow metal railing is heard around 6.065s, roughly 2.06s apart.","rejected":"The audio is perfectly synchronized with the picture at 4.0s: the loud physical impact of the person hitting the yellow metal railing matches exactly when the man lands heavily on his back and shoulder on the hard concrete floor after catching his foot and flipping over the yellow railing."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy15_early_1.92s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is also out of sync. The visual event occurs around 4.0s, when the man lands heavily on his back and shoulder on the hard concrete floor after catching his foot and flipping over the yellow railing, while the loud physical impact of the person hitting the yellow metal railing is heard around 2.081s, a difference of about 1.92s.","rejected":"The soundtrack is perfectly synchronized: the loud physical impact of the person hitting the yellow metal railing occurs exactly with the moment the man lands heavily on his back and shoulder on the hard concrete floor after catching his foot and flipping over the yellow railing."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy26.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The person crashes headfirst into the red mat at about 2.0s, and the loud thud of a person hitting a red gymnastics mat is heard at the same moment. The sync appears accurate, with only a negligible natural tolerance of 0.0s.","rejected":"The person crashes headfirst into the red mat around 2.0s, but the loud thud of a person hitting a red gymnastics mat comes noticeably apart from the impact, making the sync look off."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy26_delay_1.95s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact, where the person crashes headfirst into the red mat, occurs at 2.0s, while the loud thud of a person hitting a red gymnastics mat is heard at 3.214s. That places the sound roughly 1.21s away from the visible contact, which is a clear mismatch by normal sync standards.","rejected":"The person crashes headfirst into the red mat at 2.0s, and the loud thud of a person hitting a red gymnastics mat lines up perfectly there as well, so the clip is fully synchronized."}
+{"video":"Treadmill Terror - Fails of the Week (November 2018) _ FailArmy26_early_1.91s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The person crashes headfirst into the red mat at 2.0s, but the loud thud of a person hitting a red gymnastics mat is heard at 0.095s. That puts the sound about 1.91s away from the visible impact, which is an obvious sync error.","rejected":"The person crashes headfirst into the red mat and the loud thud of a person hitting a red gymnastics mat occur together, so this clip appears perfectly synchronized."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'17.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The impact moment is well aligned: the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, and the loud thud of a body hitting the ground follows at nearly the same time. The gap is only about 0.1s, which is within negligible natural tolerance, so this clip feels synchronized.","rejected":"There is a noticeable sync problem here: the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, but the loud thud of a body hitting the ground is clearly separated in time, making the mismatch obvious."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'17_delay_2.08s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip shows a clear offset. The visual impact happens around 0.5s, when the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, but the loud thud of a body hitting the ground does not arrive until about 2.676s. That is roughly a 2.18s gap, which is far too large to feel naturally aligned.","rejected":"This clip appears perfectly synchronized at about 0.5s: the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, and the loud thud of a body hitting the ground lands right with that visual beat."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'17_early_2.48s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip also feels misaligned. The key visual event occurs around 0.5s, when the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, yet the loud thud of a body hitting the ground is heard at 0.0s. That is about a 0.5s separation, which is large enough to be perceptually noticeable.","rejected":"Everything lines up cleanly here: the person's body forcefully impacts the hard concrete upper ledge, abruptly halting their upward jump momentum, and the loud thud of a body hitting the ground is perfectly synchronized with the visible impact."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'45.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment the person's body slams back-first into the sand after failing to land the flip on their feet lines up with the heavy thud of their back hitting the sand at about 3.0s. The gap is effectively 0.0s, well within negligible natural tolerance.","rejected":"There is a noticeable mismatch: when the person's body slams back-first into the sand after the failed flip, the heavy thud of their back hitting the sand does not line up and is clearly off by a visible amount."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'45_delay_2.17s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact happens around 3.0s, when the person's body slams back-first into the sand after failing to land the flip on their feet, but the heavy thud of their back hitting the sand is heard around 5.169s. That puts the offset at about 2.17s, which is a clear mismatch.","rejected":"The person's body slamming back-first into the sand and the heavy thud of their back hitting the sand are perfectly synchronized at about 3.0s, with no meaningful gap between picture and sound."}
+{"video":"Ultimate Parkour Fails Compilation Part 2 by FailArmy _ 'You Are The King Of Bails, Man.'45_early_2.48s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The visual impact occurs around 3.0s, when the person's body slams back-first into the sand after failing to land the flip on their feet, while the heavy thud of their back hitting the sand is heard around 0.518s. This is roughly a 2.48s offset, so the audio and visual event are clearly not aligned.","rejected":"The person's body slamming back-first into the sand and the heavy thud of their back hitting the sand are perfectly synchronized, with the sound matching the visible impact exactly."}
+{"video":"We're Back! Fails of the Week (May 2019) _ FailArmy14.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The person falls and impacts the water surface, creating a splash, and the loud crack of a wooden branch snapping and breaking occur together at about 0.0s; the 0.0s offset is within negligible natural tolerance, so this clip appears synchronized.","rejected":"There is a noticeable mismatch: when the person falls and impacts the water surface, creating a splash, the loud crack of a wooden branch snapping and breaking arrives clearly apart from the visual moment."}
+{"video":"We're Back! Fails of the Week (May 2019) _ FailArmy14_delay_2.44s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual cue is at 0.0s, when the person falls and impacts the water surface, creating a splash, while the loud crack of a wooden branch snapping and breaking is heard at about 2.443s. That puts the separation at roughly 2.44s, which is far beyond normal tolerance and indicates clear audiovisual misalignment.","rejected":"The person falls and impacts the water surface, creating a splash, exactly as the loud crack of a wooden branch snapping and breaking is heard at 0.0s, so this clip is perfectly synchronized."}
+{"video":"We're Back! Fails of the Week (May 2019) _ FailArmy14_early_2.04s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event is at 0.0s and the loud crack of a wooden branch snapping and breaking is also at 0.0s. As the person falls and impacts the water surface, creating a splash, the estimated gap is about 0.0s, which is comfortably within normal tolerance and reads as synchronized.","rejected":"The person falls and impacts the water surface, creating a splash, at the exact same instant as the loud crack of a wooden branch snapping and breaking, making this clip perfectly synchronized."}
+{"video":"Wheelie Gone Wrong - Fails of the Week (May 2018) _ FailArmy7.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The man landing forcefully on the wooden steps after jumping off the deck lines up with the loud crash of him falling onto the wooden steps, so this clip appears synchronized. The gap is 0.0s, which is within negligible natural tolerance.","rejected":"The man landing forcefully on the wooden steps after jumping off the deck does not quite match the loud crash of him falling onto the wooden steps; there is a noticeable mismatch between picture and sound."}
+{"video":"Wheelie Gone Wrong - Fails of the Week (May 2018) _ FailArmy7_delay_2.24s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"Here, the visual impact occurs at about 4.0s, when the man lands forcefully on the wooden steps after jumping off the deck, but the loud crash of him falling onto the wooden steps is heard around 5.8s. That puts the offset at roughly 1.8s, which is clearly not synchronized.","rejected":"This clip looks perfectly synchronized: at 4.0s, the man landing forcefully on the wooden steps after jumping off the deck matches the loud crash of him falling onto the wooden steps exactly."}
+{"video":"Wheelie Gone Wrong - Fails of the Week (May 2018) _ FailArmy7_early_2.32s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"In this clip, the visual impact is around 4.0s, showing the man landing forcefully on the wooden steps after jumping off the deck, while the loud crash of him falling onto the wooden steps is heard near 1.684s. That is roughly a 2.32s separation, so the audio and video are clearly not synchronized.","rejected":"This clip appears perfectly synchronized, with the man landing forcefully on the wooden steps after jumping off the deck matching the loud crash of him falling onto the wooden steps exactly."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy38.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"The moment Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face lines up closely with the slap\/thump of the man hitting the water bottle, so this clip reads as synchronized.","rejected":"There is a noticeable mismatch here: Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face, but the slap\/thump of the man hitting the water bottle is clearly offset from that moment."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy38_delay_1.82s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip shows a clear offset: the visual moment when Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face is at about 4.0s, while the slap\/thump of the man hitting the water bottle is heard around 6.816s, giving an estimated gap of about 2.82s.","rejected":"This clip appears perfectly synchronized: at 4.0s, Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face exactly as the slap\/thump of the man hitting the water bottle is heard."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy38_early_2.37s.mp4","prompt":"Is there any noticeable audio delay or temporal manipulation in this clip?","chosen":"This clip also has an evident offset: Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face at about 4.0s, but the slap\/thump of the man hitting the water bottle comes around 2.635s, for an estimated separation of about 1.37s.","rejected":"This clip looks perfectly synchronized, with Water unexpectedly shoots out from the squeezed bottle and hits the woman in the face matching the slap\/thump of the man hitting the water bottle at the same instant."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy42.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The sound of wave crashing onto the boy lines up closely with the moment a small wave crashes into the boy, knocking him off balance and face-first into the shallow water. The offset is about 0.5 seconds, so it still feels broadly in sync.","rejected":"There is a noticeable mismatch: the wave-crash sound does not line up with the moment the small wave knocks the boy off balance and into the shallow water."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy42_delay_2.43s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual impact happens at about 2.0s, when a small wave crashes into the boy and knocks him off balance into the shallow water, while the sound of wave crashing onto the boy is heard around 3.934s. That puts the gap at roughly 1.93 seconds, which is clearly not synchronized.","rejected":"The wave-crash sound is perfectly synchronized with the visible moment at 2.0s when the small wave hits the boy and knocks him into the shallow water."}
+{"video":"Whip It, Whip It Real Good - Fails of the Month (November 2017) _ FailArmy42_early_1.92s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The visual event occurs at about 2.0s, when a small wave crashes into the boy and knocks him off balance face-first into the shallow water, but the sound of wave crashing onto the boy is heard at 0.0s. With an estimated gap of about 2.0 seconds, the audio and video are clearly not aligned.","rejected":"The sound of wave crashing onto the boy is perfectly synchronized with the visible moment when the small wave knocks him off balance into the shallow water."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy11.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip appears reasonably well synchronized: the moment the man falls to the ground after the pull-up bar detaches lines up closely with the loud clack of the bar hitting him, followed by the rattling on the floor. The audio trails the visual by about 0.5 s, which is close enough to feel largely in sync.","rejected":"There is a noticeable sync mismatch here: the man falls after the pull-up bar detaches, but the loud clack and floor rattle happen clearly out of step, making the audio seem significantly offset from the action."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy11_delay_1.83s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip shows a clear sync offset. The visual event occurs at about 2.5 s, when the man falls after the pull-up bar detaches from the doorframe, but the corresponding audio is heard around 4.831 s: a loud clack as the bar hits him, followed by rattling on the floor. That is roughly a 2.33 s gap, which is plainly noticeable.","rejected":"This clip is perfectly synchronized at about 2.5 s: the man falls as the pull-up bar detaches, and the loud clack with the following rattle happens exactly at that same moment."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy11_early_1.88s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip also has an obvious sync offset. The visual event is at about 2.5 s, when the man falls after the pull-up bar detaches, while the audio arrives around 1.12 s: a loud clack as the bar hits him, followed by rattling on the floor. The gap is about 1.38 s, which is easy to notice.","rejected":"This clip is perfectly synchronized: the instant the man falls after the pull-up bar detaches matches exactly with the loud clack and the rattling noise, with no perceptible gap."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy34.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"The picture and sound are synchronized: when the woman falls forward and her face impacts the back of a chair after the resistance bands release from the door, the loud thud and crash land at the same moment, with only a negligible natural tolerance of about 0.0s.","rejected":"There is a noticeable mismatch here: the woman falls forward and hits the chair, but the loud thud and crash come distinctly out of step with the impact."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy34_delay_1.98s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"There is a clear offset. The visible impact happens around 6.0s, when the woman falls forward and her face impacts the back of a chair after the resistance bands release from the door, while the loud thud and crash arrive around 6.907s\u2014roughly 0.91s apart by natural estimation.","rejected":"This clip is perfectly synchronized at 6.0s: the woman\u2019s fall into the chair and the loud thud and crash occur together with no meaningful gap."}
+{"video":"Workout Fails - New Year, Same Me (January 2017) _ FailArmy34_early_2.28s.mp4","prompt":"Are the audio and video tracks synchronized in this video?","chosen":"This clip is plainly out of sync. The visible impact is around 6.0s, when the woman falls forward and her face impacts the back of a chair after the resistance bands release from the door, but the loud thud and crash are heard around 3.717s, a separation of about 2.28s by natural estimation.","rejected":"This clip is perfectly synchronized: the moment the woman falls forward into the chair matches the loud thud and crash exactly, with no visible or audible offset."}
+{"video":"You've Got Bad Friends - Friendship Fails (September 2018) _ FailArmy10.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"The action and sound line up: as a boy violently kicks another boy in the side of the head\/face while trying to knock a water bottle off his head, the loud slap\/impact as the foot hits the bottle occurs at the same moment. Any offset is within negligible natural tolerance (about 0.0s).","rejected":"There is a noticeable mismatch: the loud slap\/impact as the foot kicks the bottle does not line up with the moment a boy violently kicks another boy in the side of the head\/face while attempting to kick the bottle off his head."}
+{"video":"You've Got Bad Friends - Friendship Fails (September 2018) _ FailArmy10_delay_2.03s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"There is a small but visible offset. The visual action peaks around 4.0s, when a boy violently kicks another boy in the side of the head\/face while trying to kick a water bottle off his head, but the loud slap\/impact as the foot kicks the bottle is heard around 4.494s. That is roughly a 0.49s gap, which is enough to notice.","rejected":"The clip appears perfectly synchronized at 4.0s: the loud slap\/impact as the foot kicks the bottle matches exactly when a boy violently kicks another boy in the side of the head\/face while attempting to kick the bottle off his head."}
+{"video":"You've Got Bad Friends - Friendship Fails (September 2018) _ FailArmy10_early_2.36s.mp4","prompt":"Identify the exact timing of the visual impact and its corresponding sound. Do they align?","chosen":"This clip is clearly out of sync. The visible kick to the side of the head\/face while attempting to knock the water bottle off occurs around 4.0s, but the loud slap\/impact as the foot kicks the bottle is heard around 1.636s. That is about a 2.36s separation, which is very obvious.","rejected":"The audio is perfectly synchronized with the visual event: the loud slap\/impact as the foot kicks the bottle matches exactly when a boy violently kicks another boy in the side of the head\/face while trying to kick the bottle off his head."}
diff --git a/hf_upload/scripts/compute_videomme_metrics_from_jsonl.py b/hf_upload/scripts/compute_videomme_metrics_from_jsonl.py
new file mode 100644
index 0000000000000000000000000000000000000000..c59703d6cecce07617c2b27b1b0f38b418d8f160
--- /dev/null
+++ b/hf_upload/scripts/compute_videomme_metrics_from_jsonl.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Recompute Video-MME metrics from eval_results.jsonl (same schema as eval_videomme.py).
+
+Example:
+  python compute_videomme_metrics_from_jsonl.py \\
+    --jsonl /home/ubuntu/video_source/eval_results/videomme/vmme_vanilla/eval_results.jsonl \\
+    --out /home/ubuntu/video_source/eval_results/videomme/vmme_vanilla/metrics.json
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+VIDEO_TYPES = ["short", "medium", "long"]
+CATEGORIES = [
+    "Knowledge",
+    "Film & Television",
+    "Sports Competition",
+    "Artistic Performance",
+    "Life Record",
+    "Multilingual",
+]
+TASK_CATEGORIES = [
+    "Temporal Perception",
+    "Spatial Perception",
+    "Attribute Perception",
+    "Action Recognition",
+    "Object Recognition",
+    "OCR Problems",
+    "Counting Problem",
+    "Temporal Reasoning",
+    "Spatial Reasoning",
+    "Action Reasoning",
+    "Object Reasoning",
+    "Information Synopsis",
+]
+
+
+def load_results(path: Path) -> List[Dict[str, Any]]:
+    rows = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            rows.append(json.loads(line))
+    return rows
+
+
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(
+        1 for r in results if str(r.get("pred_answer", "")).upper() == str(r["gt_answer"]).upper()
+    )
+    overall_acc = correct / total
+
+    def acc_for(items: List[Dict[str, Any]]) -> float | None:
+        if not items:
+            return None
+        c = sum(
+            1
+            for r in items
+            if str(r.get("pred_answer", "")).upper() == str(r["gt_answer"]).upper()
+        )
+        return round(c / len(items), 4)
+
+    per_duration: Dict[str, Any] = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r.get("duration") == vt]
+        if subset:
+            per_duration[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_domain: Dict[str, Any] = {}
+    for cat in CATEGORIES:
+        subset = [r for r in results if r.get("domain") == cat]
+        if subset:
+            per_domain[cat] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task: Dict[str, Any] = {}
+    for task in TASK_CATEGORIES:
+        subset = [r for r in results if r.get("task_type") == task]
+        if subset:
+            per_task[task] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_duration": per_duration,
+        "per_domain": per_domain,
+        "per_task_type": per_task,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print("=" * 65)
+    print(f"  Video-MME Summary: {label}")
+    print("=" * 65)
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+    print("  --- Per Duration ---")
+    for vt in VIDEO_TYPES:
+        if vt in metrics["per_duration"]:
+            d = metrics["per_duration"][vt]
+            print(f"    {vt:8s}:  {d['accuracy']:.1%}  ({d['count']} questions)")
+    print("  --- Per Domain ---")
+    for cat in CATEGORIES:
+        if cat in metrics["per_domain"]:
+            d = metrics["per_domain"][cat]
+            print(f"    {cat:25s}: {d['accuracy']:.1%}  ({d['count']})")
+    print("  --- Per Task Type ---")
+    for task in TASK_CATEGORIES:
+        if task in metrics["per_task_type"]:
+            d = metrics["per_task_type"][task]
+            print(f"    {task:25s}: {d['accuracy']:.1%}  ({d['count']})")
+    print("=" * 65)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument(
+        "--jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/eval_results/videomme/vmme_vanilla/eval_results.jsonl"),
+    )
+    p.add_argument(
+        "--out",
+        type=Path,
+        default=None,
+        help="Write metrics JSON here (default: <jsonl_dir>/metrics.json)",
+    )
+    p.add_argument("--label", type=str, default="from_jsonl")
+    p.add_argument("--base-model", type=str, default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument(
+        "--video-dir",
+        type=str,
+        default="/opt/dlami/nvme/videomme/data/data",
+    )
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    args = p.parse_args()
+
+    out_path = args.out or (args.jsonl.parent / "metrics.json")
+
+    results = load_results(args.jsonl)
+    metrics = compute_metrics(results)
+    if not metrics:
+        print("[warn] No rows in jsonl.")
+        return
+
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": args.video_dir,
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+        "source_jsonl": str(args.jsonl.resolve()),
+    }
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+
+    print_summary(metrics, args.label)
+    print(f"\n[written] {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/download_lvbench.py b/hf_upload/scripts/download_lvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c44b9e46c2a351ae1519b7d6662a6fb939be3d8
--- /dev/null
+++ b/hf_upload/scripts/download_lvbench.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Download LVBench videos from Hugging Face (lmms-lab/LVBench).
+
+Downloads chunked zip files and extracts them.
+
+Usage:
+    python download_lvbench.py
+    python download_lvbench.py --output-dir /path/to/lvbench
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "lmms-lab/LVBench"
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/lvbench")
+
+VIDEO_ZIPS = [f"video_chunks/videos_chunk_{i:03d}.zip" for i in range(1, 15)]
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Download LVBench from Hugging Face.")
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT)
+    return p.parse_args()
+
+
+def download_and_extract(repo_file: str, extract_to: Path, label: str) -> None:
+    extract_to.mkdir(parents=True, exist_ok=True)
+    print(f"  Downloading {label}: {repo_file} ...")
+    local_zip = hf_hub_download(
+        repo_id=REPO_ID, filename=repo_file, repo_type="dataset",
+    )
+    print(f"  Extracting to {extract_to} ...")
+    with zipfile.ZipFile(local_zip, "r") as zf:
+        zf.extractall(extract_to)
+    print(f"  Done: {repo_file}")
+
+
+def main() -> None:
+    args = parse_args()
+    out_dir = args.output_dir
+
+    existing = sum(1 for f in out_dir.iterdir() if f.suffix == ".mp4") if out_dir.exists() else 0
+    if existing >= 100:
+        print(f"[skip] Already have {existing} videos in {out_dir}")
+    else:
+        print(f"Downloading {len(VIDEO_ZIPS)} video chunks...")
+        for i, zf in enumerate(VIDEO_ZIPS, 1):
+            download_and_extract(zf, out_dir, f"chunk {i}/{len(VIDEO_ZIPS)}")
+
+    video_count = sum(1 for f in out_dir.iterdir() if f.suffix == ".mp4") if out_dir.exists() else 0
+    print(f"\nDone. Total videos on disk: {video_count}")
+    print(f"  Videos: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/download_videomme.py b/hf_upload/scripts/download_videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3a28f5b7e9208629484c79e0129052c7849b71a
--- /dev/null
+++ b/hf_upload/scripts/download_videomme.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+Download Video-MME videos from Hugging Face (lmms-lab/Video-MME).
+
+Downloads chunked zip files and extracts them.
+
+Usage:
+    python download_videomme.py
+    python download_videomme.py --output-dir /path/to/videomme
+"""
+
+from __future__ import annotations
+
+import argparse
+import zipfile
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+
+REPO_ID = "lmms-lab/Video-MME"
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/videomme")
+
+VIDEO_ZIPS = [f"videos_chunked_{i:02d}.zip" for i in range(1, 21)]
+SUBTITLE_ZIP = "subtitle.zip"
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Download Video-MME from Hugging Face.")
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT)
+    p.add_argument("--skip-subtitles", action="store_true")
+    return p.parse_args()
+
+
+def download_and_extract(repo_file: str, extract_to: Path, label: str) -> None:
+    extract_to.mkdir(parents=True, exist_ok=True)
+    print(f"  Downloading {label}: {repo_file} ...")
+    local_zip = hf_hub_download(
+        repo_id=REPO_ID, filename=repo_file, repo_type="dataset",
+    )
+    print(f"  Extracting to {extract_to} ...")
+    with zipfile.ZipFile(local_zip, "r") as zf:
+        zf.extractall(extract_to)
+    print(f"  Done: {repo_file}")
+
+
+def main() -> None:
+    args = parse_args()
+    data_dir = args.output_dir / "data"
+    sub_dir = args.output_dir / "subtitle"
+
+    existing = sum(1 for f in data_dir.iterdir() if f.suffix in (".mp4", ".MP4", ".mkv")) if data_dir.exists() else 0
+    if existing >= 900:
+        print(f"[skip] Already have {existing} videos in {data_dir}")
+    else:
+        print(f"[1/2] Downloading {len(VIDEO_ZIPS)} video chunks...")
+        for i, zf in enumerate(VIDEO_ZIPS, 1):
+            download_and_extract(zf, data_dir, f"chunk {i}/{len(VIDEO_ZIPS)}")
+
+    if args.skip_subtitles:
+        print("[skip] Subtitle download skipped (--skip-subtitles)")
+    else:
+        existing_subs = sum(1 for f in sub_dir.iterdir() if f.suffix == ".srt") if sub_dir.exists() else 0
+        if existing_subs >= 800:
+            print(f"[skip] Already have {existing_subs} subtitles in {sub_dir}")
+        else:
+            print("[2/2] Downloading subtitles...")
+            download_and_extract(SUBTITLE_ZIP, sub_dir, "subtitles")
+
+    video_count = sum(1 for f in data_dir.iterdir() if f.suffix in (".mp4", ".MP4", ".mkv")) if data_dir.exists() else 0
+    print(f"\nDone. Total videos on disk: {video_count}")
+    print(f"  Videos: {data_dir}")
+    print(f"  Subtitles: {sub_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/eval_dpo_sync.py b/hf_upload/scripts/eval_dpo_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a611c51d14bdbef0bd0315f10d5c62c33296ae8
--- /dev/null
+++ b/hf_upload/scripts/eval_dpo_sync.py
@@ -0,0 +1,841 @@
+#!/usr/bin/env python3
+"""
+Automated evaluation script for audio-video sync DPO models.
+
+Workflow:
+  1. Load test set (kto_training_data_v2_test.jsonl)
+  2. Parse ground truth from video filenames (synced / delay Xs / early Xs)
+  3. Run model inference with a structured JSON prompt
+  4. Extract predictions: JSON parse -> GPT-5.4 judge (optional) -> regex fallback
+  5. Compute metrics: Sync/Desync Accuracy, Direction Accuracy, Offset MAE
+  6. Output a summary table + per-sample JSONL for analysis
+
+Usage:
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/Qwen3-Omni-Instruct/dpo/qwen3omni_dpo_lora_with_audio_v4_data_8632
+
+  # With GPT-5.4 judge fallback:
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/.../adapter \
+    --gpt-judge --openai-api-key sk-xxx
+
+  # Evaluate base model without adapter (SFT baseline):
+  python eval_dpo_sync.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo
+
+  # Evaluate vanilla Qwen3-Omni (no SFT, no DPO):
+  python eval_dpo_sync.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import time
+from pathlib import Path
+from statistics import mean, median
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# GPT-5.4 judge helper
+# ---------------------------------------------------------------------------
+_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": <bool>, "direction": "none"|"delay"|"early", "offset_sec": <float>, "t_v": <float or null>, "t_a": <float or null>, "explanation": "<one sentence>"}
+
+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.
+- t_v: the timestamp (in seconds) the model attributes to the VISUAL event. null if not mentioned.
+- t_a: the timestamp (in seconds) the model attributes to the AUDIO event. null if not mentioned.
+- If you cannot determine a field, use the default (true / "none" / 0.0 / null / "").
+"""
+
+
+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]]:
+    """Call GPT to parse raw model output into structured prediction."""
+    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"
+                t_v_raw = obj.get("t_v")
+                t_a_raw = obj.get("t_a")
+                pred_t_v = float(t_v_raw) if t_v_raw is not None else None
+                pred_t_a = float(t_a_raw) if t_a_raw is not None else None
+                return {
+                    "pred_synced": bool(synced),
+                    "pred_direction": direction,
+                    "pred_offset_sec": float(obj.get("offset_sec", 0.0)),
+                    "pred_t_v": pred_t_v,
+                    "pred_t_a": pred_t_a,
+                    "pred_explanation": str(obj.get("explanation", "")),
+                    "parse_method": "gpt_judge",
+                }
+    except Exception as exc:
+        print(f"  [gpt-judge] API error: {exc}", flush=True)
+    return None
+
+DATA_ROOT = Path("/opt/dlami/nvme/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+AUDIO_ROOT = DATA_ROOT / "extracted_audio" / "original"
+
+
+def set_data_root(root: Path) -> None:
+    """Point path resolution at a new server layout (original/, random_shift_video/, extracted_audio/)."""
+    global DATA_ROOT, ORIGINAL_ROOT, AUDIO_ROOT
+    DATA_ROOT = root.resolve()
+    ORIGINAL_ROOT = DATA_ROOT / "original"
+    AUDIO_ROOT = DATA_ROOT / "extracted_audio" / "original"
+
+EVAL_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 DPO sync model on test set.")
+    p.add_argument("--base-model", type=str,
+                    default="Rakancorle11/qwen3omni_full_sft_with_audio_for_dpo")
+    p.add_argument("--adapter", type=str, default=None,
+                    help="Path to LoRA adapter. If omitted, evaluates base model only.")
+    p.add_argument(
+        "--data-root",
+        type=Path,
+        default=Path("/opt/dlami/nvme/video_source"),
+        help="Directory containing original/, random_shift_video/, extracted_audio/ (video+audio for sync eval).",
+    )
+    p.add_argument(
+        "--test-jsonl",
+        type=Path,
+        default=None,
+        help="Test JSONL (default: <data-root>/kto_training_data_v2_test.jsonl).",
+    )
+    p.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+        help="Eval output root (default: /home/ubuntu/eval_results/sync).",
+    )
+    p.add_argument("--max-samples", type=int, default=-1,
+                    help="Limit number of test samples (-1 = all).")
+    p.add_argument("--max-new-tokens", type=int, default=256)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--label", type=str, default=None,
+                    help="Label for this eval run (used in output filenames).")
+    p.add_argument("--gpt-judge", action="store_true", default=False,
+                    help="Use GPT-5.4 as fallback parser when JSON extraction fails.")
+    p.add_argument("--openai-api-key", type=str, default=None,
+                    help="OpenAI API key. Falls back to OPENAI_API_KEY env var.")
+    p.add_argument("--gpt-model", type=str, default="gpt-5.4",
+                    help="OpenAI model to use for GPT judge (default: gpt-5.4).")
+    return p.parse_args()
+
+
+def parse_ground_truth(video_field: str) -> Dict[str, Any]:
+    """Extract ground truth sync label from video filename."""
+    m_delay = re.search(r"_delay_([\d.]+)s\.mp4", video_field)
+    m_early = re.search(r"_early_([\d.]+)s\.mp4", video_field)
+    if m_delay:
+        return {"synced": False, "direction": "delay", "offset_sec": float(m_delay.group(1))}
+    elif m_early:
+        return {"synced": False, "direction": "early", "offset_sec": float(m_early.group(1))}
+    else:
+        return {"synced": True, "direction": "none", "offset_sec": 0.0}
+
+
+def resolve_video_path(video_field: str) -> str:
+    if os.path.isabs(video_field) and os.path.exists(video_field):
+        return video_field
+    candidate_dirs = [
+        ORIGINAL_ROOT / "uag_oops",
+        DATA_ROOT / "random_shift_video" / "delay",
+        DATA_ROOT / "random_shift_video" / "early",
+        ORIGINAL_ROOT,
+    ]
+    for d in candidate_dirs:
+        c = d / video_field
+        if c.exists():
+            return str(c)
+    return str(ORIGINAL_ROOT / "uag_oops" / video_field)
+
+
+def resolve_audio_path(video_path: str) -> str:
+    video_p = Path(video_path)
+    try:
+        rel = video_p.relative_to(DATA_ROOT)
+    except ValueError:
+        rel = Path(video_p.name)
+    audio_path = DATA_ROOT / "extracted_audio" / rel.with_suffix(".wav")
+    if audio_path.exists():
+        return str(audio_path)
+    base_stem = re.sub(r"_(delay|early)_[\d.]+s$", "", video_p.stem)
+    fallback = DATA_ROOT / "extracted_audio" / "original" / "uag_oops" / (base_stem + ".wav")
+    if fallback.exists():
+        return str(fallback)
+    return str(audio_path)
+
+
+def extract_timestamps(text: str) -> Tuple[Optional[float], Optional[float]]:
+    """Extract (t_visual, t_audio) from text using 'at/around/about Xs' pattern.
+    
+    If >= 2 timestamps found, first is t_v, second is t_a.
+    If exactly 1 timestamp found (common for synced samples), treat as both t_v and t_a.
+    """
+    text_lower = text.lower()
+    all_times = [(m.start(), float(m.group(1)))
+                 for m in re.finditer(r"(?:at|around|about)\s+([\d]+\.?\d*)\s*s", text_lower)]
+    if len(all_times) >= 2:
+        return (all_times[0][1], all_times[1][1])
+    if len(all_times) == 1:
+        return (all_times[0][1], all_times[0][1])
+    return (None, None)
+
+
+def load_test_data(path: Path, max_samples: int) -> List[Dict[str, Any]]:
+    data = []
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            video_path = resolve_video_path(obj["video"])
+            audio_path = resolve_audio_path(video_path)
+            gt = parse_ground_truth(obj["video"])
+            gt_t_v, gt_t_a = extract_timestamps(obj.get("chosen", ""))
+            data.append({
+                "video": obj["video"],
+                "video_path": video_path,
+                "audio_path": audio_path,
+                "prompt": obj["prompt"],
+                "chosen": obj["chosen"],
+                "rejected": obj["rejected"],
+                "gt_synced": gt["synced"],
+                "gt_direction": gt["direction"],
+                "gt_offset_sec": gt["offset_sec"],
+                "gt_t_v": gt_t_v,
+                "gt_t_a": gt_t_a,
+            })
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+def extract_prediction(text: str) -> Dict[str, Any]:
+    """Extract structured prediction from model output text."""
+    text = text.strip()
+
+    # Try JSON extraction
+    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)
+        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"
+                offset = float(obj.get("offset_sec", 0.0))
+                explanation = str(obj.get("explanation", ""))
+                t_v_raw = obj.get("t_v")
+                t_a_raw = obj.get("t_a")
+                return {
+                    "pred_synced": bool(synced),
+                    "pred_direction": direction,
+                    "pred_offset_sec": offset,
+                    "pred_t_v": float(t_v_raw) if t_v_raw is not None else None,
+                    "pred_t_a": float(t_a_raw) if t_a_raw is not None else None,
+                    "pred_explanation": explanation,
+                    "parse_method": "json",
+                }
+            except (json.JSONDecodeError, ValueError, TypeError):
+                continue
+
+    # Fallback: structured extraction from free text
+    text_lower = text.lower()
+    synced = None
+    direction = "none"
+    offset = 0.0
+
+    pred_t_v, pred_t_a = extract_timestamps(text)
+
+    # Step 1: Determine sync vs desync
+    desync_kws = [
+        "not synchronized", "not aligned", "desync", "mismatch", "misalign",
+        "not in sync", "out of sync", "clearly not", "not well aligned",
+        "are not aligned", "audio and visual event are clearly not",
+    ]
+    sync_kws = [
+        "synchronized", "well aligned", "well-aligned", "in sync",
+        "appear synchronized", "appears synchronized", "closely aligned",
+        "audio and video are 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:
+        # Step 2a: Try explicit direction keywords
+        delay_kws = ["audio delayed", "audio lags", "audio comes after", "sound comes after",
+                     "sound is heard later", "audio is delayed", "sound follows"]
+        early_kws = ["audio early", "audio leads", "audio comes before", "sound comes before",
+                     "audio precedes", "sound is heard before", "sound 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"
+
+        # Step 2b: If no explicit keyword, use extracted timestamps to infer direction
+        if direction == "none" and pred_t_v is not None and pred_t_a is not None and pred_t_v != pred_t_a:
+            if pred_t_a > pred_t_v:
+                direction = "delay"
+            else:
+                direction = "early"
+            offset = abs(pred_t_a - pred_t_v)
+
+        # Step 2c: Extract offset from gap/separation mentions if not yet found
+        if offset == 0.0:
+            offset_match = re.search(
+                r"(?:gap|separation|offset|mismatch|differ\w*)\s*(?:of\s+)?(?:about\s+|roughly\s+|approximately\s+)?"
+                r"([\d]+\.?\d*)\s*s",
+                text_lower,
+            )
+            if not offset_match:
+                offset_match = re.search(
+                    r"(?:about\s+|roughly\s+|approximately\s+)?([\d]+\.?\d*)\s*s\s*"
+                    r"(?:gap|separation|offset|mismatch|differ)",
+                    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,
+        "pred_t_v": pred_t_v,
+        "pred_t_a": pred_t_a,
+        "pred_explanation": "",
+        "parse_method": "regex_fallback",
+    }
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+        import tempfile, shutil
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = any(t.startswith("model.layers.") for t in target_modules) and model_type != "qwen3_omni_moe_thinker"
+
+        if needs_remap:
+            print("[load] Adapter was trained on thinker-only model; remapping keys to full model...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace("base_model.model.model.layers.", "base_model.model.thinker.model.layers.")
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, audio_path: str,
+                  max_new_tokens: int, temperature: float) -> str:
+    from qwen_omni_utils import process_mm_info
+    import tempfile
+
+    tmp_dir = tempfile.mkdtemp(prefix="eval_masked_")
+    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": EVAL_PROMPT},
+            ],
+        }
+    ]
+
+    text = processor.apply_chat_template(
+        conversation, add_generation_prompt=True, tokenize=False,
+    )
+    audios, images, videos = process_mm_info(conversation, use_audio_in_video=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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)
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    import shutil
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    return response
+
+
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Compute all evaluation metrics."""
+    total = len(results)
+    if total == 0:
+        return {}
+
+    # 1. Sync/Desync binary accuracy
+    sync_correct = sum(1 for r in results if r["pred_synced"] == r["gt_synced"])
+    sync_acc = sync_correct / total
+
+    # 2. Direction accuracy (on desync samples only)
+    desync_samples = [r for r in results if not r["gt_synced"]]
+    if desync_samples:
+        dir_correct = sum(1 for r in desync_samples if r["pred_direction"] == r["gt_direction"])
+        dir_acc = dir_correct / len(desync_samples)
+    else:
+        dir_acc = None
+
+    # 3. Full 3-class accuracy (synced / delay / early)
+    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
+
+    # 4. Offset MAE (on desync samples where model also predicts desync)
+    offset_errors = []
+    for r in desync_samples:
+        if not r["pred_synced"] and r["pred_offset_sec"] > 0:
+            offset_errors.append(abs(r["pred_offset_sec"] - r["gt_offset_sec"]))
+    offset_mae = mean(offset_errors) if offset_errors else None
+    offset_median = median(offset_errors) if offset_errors else None
+
+    # 5. Per-category breakdown
+    synced_samples = [r for r in results if r["gt_synced"]]
+    delay_samples = [r for r in results if r["gt_direction"] == "delay"]
+    early_samples = [r for r in results if r["gt_direction"] == "early"]
+
+    synced_acc = (sum(1 for r in synced_samples if r["pred_synced"]) / len(synced_samples)) if synced_samples else None
+    delay_acc = (sum(1 for r in delay_samples if not r["pred_synced"] and r["pred_direction"] == "delay") / len(delay_samples)) if delay_samples else None
+    early_acc = (sum(1 for r in early_samples if not r["pred_synced"] and r["pred_direction"] == "early") / len(early_samples)) if early_samples else None
+
+    # 6. Tolerance-based offset accuracy
+    within_05 = sum(1 for e in offset_errors if e <= 0.5) if offset_errors else 0
+    within_10 = sum(1 for e in offset_errors if e <= 1.0) if offset_errors else 0
+
+    # 7. Parse method stats
+    json_parsed = sum(1 for r in results if r.get("parse_method") == "json")
+    regex_parsed = sum(1 for r in results if r.get("parse_method") == "regex_fallback")
+    gpt_parsed = sum(1 for r in results if r.get("parse_method") == "gpt_judge")
+
+    # 8. Timestamp MAE (t_v and t_a separately)
+    tv_errors = []
+    ta_errors = []
+    for r in results:
+        gt_tv = r.get("gt_t_v")
+        gt_ta = r.get("gt_t_a")
+        pred_tv = r.get("pred_t_v")
+        pred_ta = r.get("pred_t_a")
+        if gt_tv is not None and pred_tv is not None:
+            tv_errors.append(abs(pred_tv - gt_tv))
+        if gt_ta is not None and pred_ta is not None:
+            ta_errors.append(abs(pred_ta - gt_ta))
+    tv_mae = round(mean(tv_errors), 4) if tv_errors else None
+    ta_mae = round(mean(ta_errors), 4) if ta_errors else None
+    tv_median = round(median(tv_errors), 4) if tv_errors else None
+    ta_median = round(median(ta_errors), 4) if ta_errors else None
+
+    return {
+        "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_category": {
+            "synced_accuracy": round(synced_acc, 4) if synced_acc is not None else None,
+            "delay_accuracy": round(delay_acc, 4) if delay_acc is not None else None,
+            "early_accuracy": round(early_acc, 4) if early_acc is not None else None,
+            "synced_count": len(synced_samples),
+            "delay_count": len(delay_samples),
+            "early_count": len(early_samples),
+        },
+        "offset_mae_sec": round(offset_mae, 4) if offset_mae is not None else None,
+        "offset_median_sec": round(offset_median, 4) if offset_median is not None else None,
+        "offset_within_0.5s": within_05,
+        "offset_within_1.0s": within_10,
+        "offset_evaluated_count": len(offset_errors),
+        "timestamp_tv_mae_sec": tv_mae,
+        "timestamp_ta_mae_sec": ta_mae,
+        "timestamp_tv_median_sec": tv_median,
+        "timestamp_ta_median_sec": ta_median,
+        "timestamp_evaluated_tv": len(tv_errors),
+        "timestamp_evaluated_ta": len(ta_errors),
+        "parse_stats": {"json": json_parsed, "regex_fallback": regex_parsed, "gpt_judge": gpt_parsed},
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 60}")
+    print(f"  Eval Summary: {label}")
+    print(f"{'=' * 60}")
+    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["direction_accuracy_on_desync"] is not None:
+        print(f"  Direction Acc (desync):    {metrics['direction_accuracy_on_desync']:.1%}")
+    print(f"  ─── Per Category ───")
+    pc = metrics["per_category"]
+    if pc["synced_accuracy"] is not None:
+        print(f"    Synced correct:         {pc['synced_accuracy']:.1%}  ({pc['synced_count']} samples)")
+    if pc["delay_accuracy"] is not None:
+        print(f"    Delay correct:          {pc['delay_accuracy']:.1%}  ({pc['delay_count']} samples)")
+    if pc["early_accuracy"] is not None:
+        print(f"    Early correct:          {pc['early_accuracy']:.1%}  ({pc['early_count']} samples)")
+    print(f"  ─── Offset Estimation ───")
+    if metrics["offset_mae_sec"] is not None:
+        print(f"    MAE:                    {metrics['offset_mae_sec']:.3f}s")
+        print(f"    Median Error:           {metrics['offset_median_sec']:.3f}s")
+        print(f"    Within 0.5s:            {metrics['offset_within_0.5s']} / {metrics['offset_evaluated_count']}")
+        print(f"    Within 1.0s:            {metrics['offset_within_1.0s']} / {metrics['offset_evaluated_count']}")
+    else:
+        print(f"    (no valid offset predictions)")
+    print(f"  ─── Timestamp Estimation ───")
+    if metrics.get("timestamp_tv_mae_sec") is not None:
+        print(f"    t_v MAE:                {metrics['timestamp_tv_mae_sec']:.3f}s  ({metrics['timestamp_evaluated_tv']} samples)")
+        print(f"    t_v Median Error:       {metrics['timestamp_tv_median_sec']:.3f}s")
+    else:
+        print(f"    t_v: (no valid pairs)")
+    if metrics.get("timestamp_ta_mae_sec") is not None:
+        print(f"    t_a MAE:                {metrics['timestamp_ta_mae_sec']:.3f}s  ({metrics['timestamp_evaluated_ta']} samples)")
+        print(f"    t_a Median Error:       {metrics['timestamp_ta_median_sec']:.3f}s")
+    else:
+        print(f"    t_a: (no valid pairs)")
+    print(f"  ─── Parse Stats ───")
+    ps = metrics["parse_stats"]
+    print(f"    JSON parsed:            {ps['json']}")
+    print(f"    GPT judge:              {ps.get('gpt_judge', 0)}")
+    print(f"    Regex fallback:         {ps['regex_fallback']}")
+    print(f"{'=' * 60}")
+
+
+def main() -> None:
+    args = parse_args()
+    set_data_root(args.data_root)
+    test_jsonl = args.test_jsonl or (DATA_ROOT / "kto_training_data_v2_test.jsonl")
+    output_dir = args.output_dir or Path("/home/ubuntu/eval_results/sync")
+
+    if args.gpt_judge:
+        client = _get_openai_client(args.openai_api_key)
+        if client is None:
+            print("[ERROR] --gpt-judge requires OPENAI_API_KEY env var or --openai-api-key argument.")
+            raise SystemExit(1)
+        try:
+            test_resp = client.chat.completions.create(
+                model=args.gpt_model,
+                messages=[{"role": "user", "content": "Say OK"}],
+                max_completion_tokens=5,
+            )
+            print(f"[gpt-judge] API verified. Model: {args.gpt_model}")
+        except Exception as exc:
+            print(f"[ERROR] GPT API check failed: {exc}")
+            raise SystemExit(1)
+
+    label = args.label or (Path(args.adapter).name if args.adapter else Path(args.base_model).name)
+
+    out_dir = 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"
+
+    # Load data
+    test_data = load_test_data(test_jsonl, args.max_samples)
+    print(f"[data] Loaded {len(test_data)} test samples")
+
+    # Resume support
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["video"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    # Load model
+    model, processor = load_model(args.base_model, args.adapter)
+
+    # Inference loop
+    for item in tqdm(test_data, desc="Evaluating", unit="sample"):
+        if item["video"] in processed:
+            continue
+
+        if not os.path.exists(item["video_path"]):
+            print(f"  [skip] Video not found: {item['video_path']}")
+            continue
+
+        try:
+            raw_output = run_inference(
+                model, processor, item["video_path"], item["audio_path"],
+                args.max_new_tokens, args.temperature,
+            )
+        except Exception as exc:
+            import traceback
+            print(f"  [error] {item['video']}: {exc}")
+            traceback.print_exc()
+            raw_output = ""
+
+        if args.gpt_judge and raw_output:
+            gpt_pred = gpt_extract_prediction(
+                raw_output, api_key=args.openai_api_key, model=args.gpt_model,
+            )
+            if gpt_pred is not None:
+                pred = gpt_pred
+            else:
+                pred = extract_prediction(raw_output)
+        else:
+            pred = extract_prediction(raw_output)
+
+        result = {
+            "video": item["video"],
+            "video_path": item["video_path"],
+            "gt_synced": item["gt_synced"],
+            "gt_direction": item["gt_direction"],
+            "gt_offset_sec": item["gt_offset_sec"],
+            "gt_t_v": item["gt_t_v"],
+            "gt_t_a": item["gt_t_a"],
+            "pred_synced": pred["pred_synced"],
+            "pred_direction": pred["pred_direction"],
+            "pred_offset_sec": pred["pred_offset_sec"],
+            "pred_t_v": pred.get("pred_t_v"),
+            "pred_t_a": pred.get("pred_t_a"),
+            "pred_explanation": pred["pred_explanation"],
+            "parse_method": pred["parse_method"],
+            "raw_output": raw_output,
+        }
+
+        with open(results_jsonl, "a", encoding="utf-8") as f:
+            f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+        processed.add(item["video"])
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    # Load all results and compute metrics
+    all_results = []
+    with open(results_jsonl) as f:
+        for line in f:
+            all_results.append(json.loads(line))
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "data_root": str(args.data_root),
+        "test_jsonl": str(test_jsonl),
+        "total_test_samples": len(test_data),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+        "gpt_judge": args.gpt_judge,
+        "gpt_model": args.gpt_model if args.gpt_judge else None,
+    }
+
+    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 JSONL: {results_jsonl}")
+    print(f"[output] Metrics JSON:  {metrics_json}")
+    print(f"[output] Summary:       {summary_txt}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/eval_lvbench.py b/hf_upload/scripts/eval_lvbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ba703492cf8989b23d5d77dc58c9d27babe62e8
--- /dev/null
+++ b/hf_upload/scripts/eval_lvbench.py
@@ -0,0 +1,647 @@
+#!/usr/bin/env python3
+"""
+Evaluate Qwen3-Omni models on the LVBench benchmark.
+
+LVBench: 1549 multiple-choice questions over 103 long videos.
+Metrics: accuracy (overall, per video type).
+
+Usage:
+  python eval_lvbench.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+    --video-dir /opt/dlami/nvme/lvbench \
+    --max-samples 30 --label vanilla_qwen3omni
+
+  python eval_lvbench.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/.../adapter \
+    --label dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/lvbench")
+DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/eval_results/lvbench")
+
+VIDEO_TYPES = ["cartoon", "documentary", "live", "selfmedia", "sport", "tv"]
+
+MCQ_PROMPT = (
+    "Select the best answer to the following multiple-choice question "
+    "based on the video. Respond with only the letter (A, B, C, or D) "
+    "of the correct option.\n"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Evaluate on LVBench benchmark.")
+    p.add_argument("--base-model", type=str,
+                    default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    p.add_argument("--max-samples", type=int, default=-1)
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--label", type=str, default=None)
+    p.add_argument("--vllm", action="store_true", default=False,
+                    help="Use vLLM offline batch inference instead of transformers (much faster).")
+    p.add_argument("--tp", type=int, default=None,
+                    help="Tensor parallel size for vLLM (default: all visible GPUs).")
+    p.add_argument("--batch-size", type=int, default=16,
+                    help="Batch size for vLLM generate().")
+    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()
+
+
+# ---------------------------------------------------------------------------
+# Model loading — identical to eval_videomme.py / eval_dpo_sync.py
+# ---------------------------------------------------------------------------
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = _json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = (
+            any(t.startswith("model.layers.") for t in target_modules)
+            and model_type != "qwen3_omni_moe_thinker"
+        )
+
+        if needs_remap:
+            print("[load] Adapter trained on thinker-only; remapping keys...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace(
+                                "base_model.model.model.layers.",
+                                "base_model.model.thinker.model.layers.",
+                            )
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+# ---------------------------------------------------------------------------
+# Inference
+# ---------------------------------------------------------------------------
+def run_inference(model, processor, video_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_lvb_")
+    masked_video = os.path.join(tmp_dir, "clip.mp4")
+    os.symlink(os.path.abspath(video_path), masked_video)
+
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": masked_video},
+                {"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=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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 preprocess_video_for_vllm(video_path: str):
+    """Extract video frames using qwen_omni_utils, return numpy array for vLLM.
+    Caps at 128 frames to stay within vLLM encoder cache (62720 tokens).
+    """
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "nframes": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    return video_np
+
+
+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 build_vllm_prompt(question: str) -> str:
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"<|vision_start|><|video_pad|><|vision_end|>"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    """Extract a single letter A/B/C/D from model output."""
+    text = text.strip()
+    prefixes = [
+        "The best answer is", "The correct answer is",
+        "The answer is", "The answer", "Best answer:", "Best option:",
+    ]
+    for prefix in prefixes:
+        text = text.replace(prefix, "")
+
+    if len(text.split()) > 10 and not re.search(r"[ABCD]", text):
+        return ""
+    m = re.search(r"[ABCD]", text)
+    return m[0] if m else ""
+
+
+# ---------------------------------------------------------------------------
+# Dataset loading
+# ---------------------------------------------------------------------------
+def load_lvbench(video_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    from datasets import load_dataset
+    ds = load_dataset("lmms-lab/LVBench", split="train")
+    data = []
+    skipped = 0
+    for row in ds:
+        vid = row["key"]
+        video_path = video_dir / f"{vid}.mp4"
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        prompt = MCQ_PROMPT + row["question"] + "\nThe best answer is:"
+
+        data.append({
+            "uid": row["uid"],
+            "video_id": vid,
+            "video_path": str(video_path),
+            "video_type": row["type"],
+            "question_type": row["question_type"],
+            "question": row["question"],
+            "gt_answer": row["answer"],
+            "time_reference": row.get("time_reference", ""),
+            "prompt": prompt,
+        })
+    if skipped:
+        print(f"[data] Skipped {skipped} questions (video not found)")
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Metrics
+# ---------------------------------------------------------------------------
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(1 for r in results if r["pred_answer"].upper() == r["gt_answer"].upper())
+    overall_acc = correct / total
+
+    def acc_for(items):
+        if not items:
+            return None
+        c = sum(1 for r in items if r["pred_answer"].upper() == r["gt_answer"].upper())
+        return round(c / len(items), 4)
+
+    per_type = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r["video_type"] == vt]
+        if subset:
+            per_type[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    q_types = set()
+    for r in results:
+        if isinstance(r.get("question_type"), list):
+            q_types.update(r["question_type"])
+        elif r.get("question_type"):
+            q_types.add(r["question_type"])
+
+    per_qtype = {}
+    for qt in sorted(q_types):
+        subset = [r for r in results if qt in (r.get("question_type", [])
+                  if isinstance(r.get("question_type"), list) else [r.get("question_type")])]
+        if subset:
+            per_qtype[qt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_video_type": per_type,
+        "per_question_type": per_qtype,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  LVBench Summary: {label}")
+    print(f"{'=' * 65}")
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+
+    print(f"  ─── Per Video Type ───")
+    for vt in VIDEO_TYPES:
+        if vt in metrics.get("per_video_type", {}):
+            d = metrics["per_video_type"][vt]
+            print(f"    {vt:15s}: {d['accuracy']:.1%}  ({d['count']} questions)")
+
+    print(f"  ─── Per Question Type ───")
+    for qt, d in sorted(metrics.get("per_question_type", {}).items()):
+        print(f"    {qt:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> None:
+    args = parse_args()
+    label = args.label or (
+        Path(args.adapter).name if args.adapter
+        else Path(args.base_model).name
+    )
+
+    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"
+
+    print("[data] Loading LVBench dataset...")
+    test_data = load_lvbench(args.video_dir, args.max_samples)
+    print(f"[data] {len(test_data)} questions ready for evaluation")
+
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["uid"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    use_vllm = args.vllm
+    model = processor = llm = None
+    vllm_preprocess_stats: Dict[str, int] | None = None
+
+    if use_vllm:
+        from vllm import LLM, SamplingParams
+        tp = args.tp or torch.cuda.device_count()
+        model_path = args.base_model
+        print(f"[vllm] Loading {model_path} with tp={tp} ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=args.max_model_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 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,
+        )
+
+        print("[vllm] Preprocessing videos ...")
+        todo = [item for item in test_data if item["uid"] not in processed]
+        preprocessed = {}
+        preprocess_failed_paths: set[str] = set()
+
+        for i, item in enumerate(todo):
+            vp = item["video_path"]
+            if vp in preprocessed or vp in preprocess_failed_paths:
+                continue
+            try:
+                preprocessed[vp] = preprocess_video_for_vllm(vp)
+            except Exception as e:
+                preprocess_failed_paths.add(vp)
+                print(f"  [skip] preprocess error: {Path(vp).name}: {e}")
+            if (i + 1) % 50 == 0:
+                print(f"  Preprocessed {i+1}/{len(todo)} ...")
+
+        n_pp_skip = sum(1 for item in todo if item["video_path"] in preprocess_failed_paths)
+        if preprocess_failed_paths:
+            print(
+                f"[vllm] Preprocess failed for {len(preprocess_failed_paths)} video(s), "
+                f"{n_pp_skip} question(s) will not use vLLM (run continues)."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        vllm_todo = [item for item in todo if item["video_path"] in preprocessed]
+        fallback_items = []
+        print(f"[vllm] {len(vllm_todo)} questions ready, running inference ...")
+
+        for i, item in enumerate(vllm_todo):
+            if item["uid"] in processed:
+                continue
+            inp = {
+                "prompt": build_vllm_prompt(item["prompt"]),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            try:
+                outputs = llm.generate([inp], sampling_params=sampling_params)
+                raw_output = outputs[0].outputs[0].text.strip()
+                pred = extract_answer(raw_output)
+                result = {
+                    "uid": item["uid"],
+                    "video_id": item["video_id"],
+                    "video_type": item["video_type"],
+                    "question_type": item["question_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["uid"])
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" in str(exc):
+                    print(f"  [too long] {item['uid']} -> fallback")
+                    fallback_items.append(item)
+                else:
+                    raise
+
+            if (i + 1) % 50 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] done, {len(fallback_items)} deferred")
+
+        preprocessed.clear()
+
+        vllm_results = []
+        if results_jsonl.exists():
+            with open(results_jsonl) as f:
+                for line in f:
+                    vllm_results.append(json.loads(line))
+        if vllm_results:
+            vllm_metrics = compute_metrics(vllm_results)
+            vllm_metrics_path = out_dir / "metrics_vllm.json"
+            with open(vllm_metrics_path, "w", encoding="utf-8") as f:
+                json.dump(vllm_metrics, f, indent=2, ensure_ascii=False)
+            print(f"[vllm] Intermediate metrics saved to {vllm_metrics_path}")
+            print_summary(vllm_metrics, label + " (vllm only)")
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} long-video questions 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
+                try:
+                    raw_output = run_inference(
+                        model, processor, item["video_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_answer(raw_output)
+                result = {
+                    "uid": item["uid"],
+                    "video_id": item["video_id"],
+                    "video_type": item["video_type"],
+                    "question_type": item["question_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                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:
+        print("[model] Loading model...")
+        model, processor = load_model(args.base_model, args.adapter)
+
+        for item in tqdm(test_data, desc="LVBench", unit="q"):
+            if item["uid"] in processed:
+                continue
+
+            try:
+                raw_output = run_inference(
+                    model, processor, item["video_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_answer(raw_output)
+
+            result = {
+                "uid": item["uid"],
+                "video_id": item["video_id"],
+                "video_type": item["video_type"],
+                "question_type": item["question_type"],
+                "gt_answer": item["gt_answer"],
+                "pred_answer": pred,
+                "correct": pred.upper() == item["gt_answer"].upper(),
+                "raw_output": raw_output,
+            }
+
+            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()
+
+    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 to compute metrics from.")
+        return
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": str(args.video_dir),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+    }
+    if vllm_preprocess_stats is not None:
+        metrics["eval_config"]["vllm_preprocess_skips"] = vllm_preprocess_stats
+
+    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}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/eval_videomme.py b/hf_upload/scripts/eval_videomme.py
new file mode 100644
index 0000000000000000000000000000000000000000..f92fac97edbc50b8acde792c385aeb860a050e18
--- /dev/null
+++ b/hf_upload/scripts/eval_videomme.py
@@ -0,0 +1,679 @@
+#!/usr/bin/env python3
+"""
+Evaluate Qwen3-Omni models on the Video-MME benchmark.
+
+Video-MME: 2700 multiple-choice questions over 900 YouTube videos.
+Metrics: accuracy (overall, per-duration, per-domain, per-task-type).
+
+Usage:
+  python eval_videomme.py \
+    --base-model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+    --video-dir /opt/dlami/nvme/videomme/data/data \
+    --max-samples 30 --label vanilla_qwen3omni
+
+  python eval_videomme.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/.../adapter \
+    --label dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import os
+import re
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("/opt/dlami/nvme/videomme/data/data")
+DEFAULT_OUTPUT_DIR = Path("/home/ubuntu/eval_results/videomme")
+
+VIDEO_TYPES = ["short", "medium", "long"]
+CATEGORIES = [
+    "Knowledge", "Film & Television", "Sports Competition",
+    "Artistic Performance", "Life Record", "Multilingual",
+]
+TASK_CATEGORIES = [
+    "Temporal Perception", "Spatial Perception", "Attribute Perception",
+    "Action Recognition", "Object Recognition", "OCR Problems",
+    "Counting Problem", "Temporal Reasoning", "Spatial Reasoning",
+    "Action Reasoning", "Object Reasoning", "Information Synopsis",
+]
+
+MCQ_PROMPT = (
+    "Select the best answer to the following multiple-choice question "
+    "based on the video. Respond with only the letter (A, B, C, or D) "
+    "of the correct option.\n"
+)
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Evaluate on Video-MME benchmark.")
+    p.add_argument("--base-model", type=str,
+                    default="Qwen/Qwen3-Omni-30B-A3B-Instruct")
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument("--video-dir", type=Path, default=DEFAULT_VIDEO_DIR)
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    p.add_argument("--max-samples", type=int, default=-1)
+    p.add_argument("--max-new-tokens", type=int, default=32)
+    p.add_argument("--temperature", type=float, default=0.0)
+    p.add_argument("--label", type=str, default=None)
+    p.add_argument("--vllm", action="store_true", default=False,
+                    help="Use vLLM offline batch inference instead of transformers (much faster).")
+    p.add_argument("--tp", type=int, default=None,
+                    help="Tensor parallel size for vLLM (default: all visible GPUs).")
+    p.add_argument("--batch-size", type=int, default=32,
+                    help="Batch size for vLLM generate().")
+    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()
+
+
+# ---------------------------------------------------------------------------
+# Model loading — reused from eval_dpo_sync.py
+# ---------------------------------------------------------------------------
+def load_model(base_model: str, adapter: Optional[str]):
+    import json as _json
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[load] Base model: {base_model}")
+    processor = AutoProcessor.from_pretrained(base_model, trust_remote_code=True)
+
+    model_path = Path(base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path, "r") as f:
+            model_type = _json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(base_model, "config.json")
+            with open(cached, "r") as f:
+                model_type = _json.load(f).get("model_type")
+        except Exception:
+            pass
+
+    print(f"[load] Detected model_type: {model_type}")
+
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+    else:
+        config = AutoConfig.from_pretrained(base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            base_model, config=config, torch_dtype=torch.bfloat16, device_map="auto",
+        )
+
+    if adapter:
+        from peft import PeftModel
+        from safetensors.torch import load_file, save_file
+
+        print(f"[load] Loading LoRA adapter: {adapter}")
+        adapter_cfg_path = Path(adapter) / "adapter_config.json"
+        with open(adapter_cfg_path) as f:
+            adapter_cfg = _json.loads(f.read())
+        target_modules = adapter_cfg.get("target_modules", [])
+        needs_remap = (
+            any(t.startswith("model.layers.") for t in target_modules)
+            and model_type != "qwen3_omni_moe_thinker"
+        )
+
+        if needs_remap:
+            print("[load] Adapter trained on thinker-only; remapping keys...")
+            tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+            for fn in Path(adapter).iterdir():
+                if fn.is_dir():
+                    continue
+                if fn.name == "adapter_config.json":
+                    new_targets = []
+                    for t in target_modules:
+                        if t.startswith("model.layers."):
+                            new_targets.append("thinker." + t)
+                        elif t[0].isdigit():
+                            new_targets.append("thinker.model.layers." + t)
+                        else:
+                            new_targets.append(t)
+                    adapter_cfg["target_modules"] = new_targets
+                    with open(tmp_dir / "adapter_config.json", "w") as f:
+                        json.dump(adapter_cfg, f, indent=2)
+                elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                    tensors = load_file(str(fn))
+                    remapped = {}
+                    for k, v in tensors.items():
+                        if ".model.layers." in k and ".thinker." not in k:
+                            new_k = k.replace(
+                                "base_model.model.model.layers.",
+                                "base_model.model.thinker.model.layers.",
+                            )
+                            remapped[new_k] = v
+                        else:
+                            remapped[k] = v
+                    save_file(remapped, str(tmp_dir / fn.name))
+                else:
+                    shutil.copy2(str(fn), str(tmp_dir / fn.name))
+            adapter = str(tmp_dir)
+
+        model = PeftModel.from_pretrained(model, adapter)
+        model = model.merge_and_unload()
+
+    if hasattr(model, "disable_talker"):
+        model.disable_talker()
+    model.eval()
+    print(f"[load] Model ready ({type(model).__name__}). Device: {model.device}")
+    return model, processor
+
+
+# ---------------------------------------------------------------------------
+# Inference
+# ---------------------------------------------------------------------------
+def run_inference(model, processor, video_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_vmme_")
+    masked_video = os.path.join(tmp_dir, "clip.mp4")
+    os.symlink(os.path.abspath(video_path), masked_video)
+
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": masked_video},
+                {"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=False)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=False,
+    )
+
+    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 transformers import Qwen3OmniMoeThinkerForConditionalGeneration
+    is_thinker = isinstance(model, Qwen3OmniMoeThinkerForConditionalGeneration)
+    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": False,
+            "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 preprocess_video_for_vllm(video_path: str):
+    """Extract video frames using qwen_omni_utils, return numpy array for vLLM.
+    Caps at 128 frames to stay within vLLM encoder cache (62720 tokens).
+    """
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "nframes": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    return video_np
+
+
+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 build_vllm_prompt(question: str) -> str:
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"<|vision_start|><|video_pad|><|vision_end|>"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    """Extract a single letter A/B/C/D from model output."""
+    text = text.strip()
+    prefixes = [
+        "The best answer is", "The correct answer is",
+        "The answer is", "The answer", "Best answer:", "Best option:",
+    ]
+    for prefix in prefixes:
+        text = text.replace(prefix, "")
+
+    if len(text.split()) > 10 and not re.search(r"[ABCD]", text):
+        return ""
+    m = re.search(r"[ABCD]", text)
+    return m[0] if m else ""
+
+
+# ---------------------------------------------------------------------------
+# Dataset loading
+# ---------------------------------------------------------------------------
+def load_videomme(video_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    from datasets import load_dataset
+    ds = load_dataset("lmms-lab/Video-MME", split="test")
+    data = []
+    skipped = 0
+    for row in ds:
+        vid = row["videoID"]
+        video_path = video_dir / f"{vid}.mp4"
+        if not video_path.exists():
+            for ext in [".MP4", ".mkv"]:
+                alt = video_dir / f"{vid}{ext}"
+                if alt.exists():
+                    video_path = alt
+                    break
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        options_text = "\n".join(row["options"])
+        prompt = MCQ_PROMPT + row["question"] + "\n" + options_text + "\nThe best answer is:"
+
+        data.append({
+            "question_id": row["question_id"],
+            "video_id": vid,
+            "video_path": str(video_path),
+            "duration": row["duration"],
+            "domain": row["domain"],
+            "sub_category": row["sub_category"],
+            "task_type": row["task_type"],
+            "question": row["question"],
+            "options": row["options"],
+            "gt_answer": row["answer"],
+            "prompt": prompt,
+        })
+    if skipped:
+        print(f"[data] Skipped {skipped} questions (video not found)")
+    if max_samples > 0:
+        data = data[:max_samples]
+    return data
+
+
+# ---------------------------------------------------------------------------
+# Metrics
+# ---------------------------------------------------------------------------
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    correct = sum(1 for r in results if r["pred_answer"].upper() == r["gt_answer"].upper())
+    overall_acc = correct / total
+
+    def acc_for(items):
+        if not items:
+            return None
+        c = sum(1 for r in items if r["pred_answer"].upper() == r["gt_answer"].upper())
+        return round(c / len(items), 4)
+
+    per_duration = {}
+    for vt in VIDEO_TYPES:
+        subset = [r for r in results if r["duration"] == vt]
+        if subset:
+            per_duration[vt] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_domain = {}
+    for cat in CATEGORIES:
+        subset = [r for r in results if r["domain"] == cat]
+        if subset:
+            per_domain[cat] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task = {}
+    for task in TASK_CATEGORIES:
+        subset = [r for r in results if r["task_type"] == task]
+        if subset:
+            per_task[task] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_duration": per_duration,
+        "per_domain": per_domain,
+        "per_task_type": per_task,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  Video-MME Summary: {label}")
+    print(f"{'=' * 65}")
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+
+    print(f"  ─── Per Duration ───")
+    for vt in VIDEO_TYPES:
+        if vt in metrics["per_duration"]:
+            d = metrics["per_duration"][vt]
+            print(f"    {vt:8s}:  {d['accuracy']:.1%}  ({d['count']} questions)")
+
+    print(f"  ─── Per Domain ───")
+    for cat in CATEGORIES:
+        if cat in metrics["per_domain"]:
+            d = metrics["per_domain"][cat]
+            print(f"    {cat:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Task Type ───")
+    for task in TASK_CATEGORIES:
+        if task in metrics["per_task_type"]:
+            d = metrics["per_task_type"][task]
+            print(f"    {task:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main() -> None:
+    args = parse_args()
+    label = args.label or (
+        Path(args.adapter).name if args.adapter
+        else Path(args.base_model).name
+    )
+
+    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"
+
+    print("[data] Loading Video-MME dataset...")
+    test_data = load_videomme(args.video_dir, args.max_samples)
+    print(f"[data] {len(test_data)} questions ready for evaluation")
+
+    processed = set()
+    if results_jsonl.exists():
+        with open(results_jsonl) as f:
+            for line in f:
+                obj = json.loads(line)
+                processed.add(obj["question_id"])
+        print(f"[resume] {len(processed)} already processed, skipping")
+
+    use_vllm = args.vllm
+    model = processor = llm = None
+    vllm_preprocess_stats: Dict[str, int] | None = None
+
+    if use_vllm:
+        from vllm import LLM, SamplingParams
+        tp = args.tp or torch.cuda.device_count()
+        model_path = args.base_model
+        print(f"[vllm] Loading {model_path} with tp={tp} ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=args.max_model_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 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,
+        )
+
+        print("[vllm] Preprocessing videos ...")
+        todo = [item for item in test_data if item["question_id"] not in processed]
+        preprocessed = {}
+        preprocess_failed_paths: set[str] = set()
+
+        for i, item in enumerate(todo):
+            vp = item["video_path"]
+            if vp in preprocessed or vp in preprocess_failed_paths:
+                continue
+            try:
+                preprocessed[vp] = preprocess_video_for_vllm(vp)
+            except Exception as e:
+                preprocess_failed_paths.add(vp)
+                print(f"  [skip] preprocess error: {Path(vp).name}: {e}")
+            if (i + 1) % 100 == 0:
+                print(f"  Preprocessed {i+1}/{len(todo)} ...")
+
+        n_pp_skip = sum(1 for item in todo if item["video_path"] in preprocess_failed_paths)
+        if preprocess_failed_paths:
+            print(
+                f"[vllm] Preprocess failed for {len(preprocess_failed_paths)} video(s), "
+                f"{n_pp_skip} question(s) will not use vLLM (run continues)."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        vllm_todo = [item for item in todo if item["video_path"] in preprocessed]
+        fallback_items = []
+        print(f"[vllm] {len(vllm_todo)} questions ready, running inference ...")
+
+        for i, item in enumerate(vllm_todo):
+            if item["question_id"] in processed:
+                continue
+            inp = {
+                "prompt": build_vllm_prompt(item["prompt"]),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            try:
+                outputs = llm.generate([inp], sampling_params=sampling_params)
+                raw_output = outputs[0].outputs[0].text.strip()
+                pred = extract_answer(raw_output)
+                result = {
+                    "question_id": item["question_id"],
+                    "video_id": item["video_id"],
+                    "duration": item["duration"],
+                    "domain": item["domain"],
+                    "sub_category": item["sub_category"],
+                    "task_type": item["task_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["question_id"])
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" in str(exc):
+                    print(f"  [too long] {item['question_id']} -> fallback")
+                    fallback_items.append(item)
+                else:
+                    raise
+
+            if (i + 1) % 100 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] done, {len(fallback_items)} deferred")
+
+        preprocessed.clear()
+
+        vllm_results = []
+        if results_jsonl.exists():
+            with open(results_jsonl) as f:
+                for line in f:
+                    vllm_results.append(json.loads(line))
+        if vllm_results:
+            vllm_metrics = compute_metrics(vllm_results)
+            vllm_metrics_path = out_dir / "metrics_vllm.json"
+            with open(vllm_metrics_path, "w", encoding="utf-8") as f:
+                json.dump(vllm_metrics, f, indent=2, ensure_ascii=False)
+            print(f"[vllm] Intermediate metrics saved to {vllm_metrics_path}")
+            print_summary(vllm_metrics, label + " (vllm only)")
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} long-video questions 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["question_id"] in processed:
+                    continue
+                try:
+                    raw_output = run_inference(
+                        model, processor, item["video_path"], item["prompt"],
+                        args.max_new_tokens, args.temperature,
+                    )
+                except Exception as exc:
+                    import traceback
+                    print(f"  [error] {item['question_id']}: {exc}")
+                    traceback.print_exc()
+                    raw_output = ""
+
+                pred = extract_answer(raw_output)
+                result = {
+                    "question_id": item["question_id"],
+                    "video_id": item["video_id"],
+                    "duration": item["duration"],
+                    "domain": item["domain"],
+                    "sub_category": item["sub_category"],
+                    "task_type": item["task_type"],
+                    "gt_answer": item["gt_answer"],
+                    "pred_answer": pred,
+                    "correct": pred.upper() == item["gt_answer"].upper(),
+                    "raw_output": raw_output,
+                }
+                with open(results_jsonl, "a", encoding="utf-8") as f:
+                    f.write(json.dumps(result, ensure_ascii=False) + "\n")
+                processed.add(item["question_id"])
+                gc.collect()
+                torch.cuda.empty_cache()
+
+    else:
+        print("[model] Loading model...")
+        model, processor = load_model(args.base_model, args.adapter)
+
+        for item in tqdm(test_data, desc="Video-MME", unit="q"):
+            if item["question_id"] in processed:
+                continue
+
+            try:
+                raw_output = run_inference(
+                    model, processor, item["video_path"], item["prompt"],
+                    args.max_new_tokens, args.temperature,
+                )
+            except Exception as exc:
+                import traceback
+                print(f"  [error] {item['question_id']}: {exc}")
+                traceback.print_exc()
+                raw_output = ""
+
+            pred = extract_answer(raw_output)
+
+            result = {
+                "question_id": item["question_id"],
+                "video_id": item["video_id"],
+                "duration": item["duration"],
+                "domain": item["domain"],
+                "sub_category": item["sub_category"],
+                "task_type": item["task_type"],
+                "gt_answer": item["gt_answer"],
+                "pred_answer": pred,
+                "correct": pred.upper() == item["gt_answer"].upper(),
+                "raw_output": raw_output,
+            }
+
+            with open(results_jsonl, "a", encoding="utf-8") as f:
+                f.write(json.dumps(result, ensure_ascii=False) + "\n")
+
+            processed.add(item["question_id"])
+            gc.collect()
+            torch.cuda.empty_cache()
+
+    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 to compute metrics from.")
+        return
+
+    metrics = compute_metrics(all_results)
+    metrics["eval_config"] = {
+        "base_model": args.base_model,
+        "adapter": args.adapter,
+        "video_dir": str(args.video_dir),
+        "max_new_tokens": args.max_new_tokens,
+        "temperature": args.temperature,
+    }
+    if vllm_preprocess_stats is not None:
+        metrics["eval_config"]["vllm_preprocess_skips"] = vllm_preprocess_stats
+
+    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}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/scripts/merge_adapter.py b/hf_upload/scripts/merge_adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea7e31a38f23e987aebedbef9c07e5ada06312a3
--- /dev/null
+++ b/hf_upload/scripts/merge_adapter.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Merge a LoRA adapter into the base Qwen3-Omni model and save full weights.
+
+Handles thinker-only adapter key remapping automatically.
+
+Usage:
+  python merge_adapter.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/Qwen3-Omni-Instruct/dpo/qwen3omni_dpo_lora_with_audio_v4_data_8632 \
+    --output /opt/dlami/nvme/merged_models/dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import tempfile
+from pathlib import Path
+
+import torch
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Merge LoRA adapter into base model.")
+    p.add_argument("--base-model", type=str, required=True)
+    p.add_argument("--adapter", type=str, required=True)
+    p.add_argument("--output", type=str, required=True)
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[1/5] Loading processor from {args.base_model} ...")
+    processor = AutoProcessor.from_pretrained(args.base_model, trust_remote_code=True)
+
+    model_path = Path(args.base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path) as f:
+            model_type = json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(args.base_model, "config.json")
+            with open(cached) as f:
+                model_type = json.load(f).get("model_type")
+        except Exception:
+            pass
+    print(f"  model_type: {model_type}")
+
+    print(f"[2/5] Loading base model ...")
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(args.base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            args.base_model, config=config, torch_dtype=torch.bfloat16, device_map="cpu",
+        )
+    else:
+        config = AutoConfig.from_pretrained(args.base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            args.base_model, config=config, torch_dtype=torch.bfloat16, device_map="cpu",
+        )
+
+    print(f"[3/5] Loading and remapping LoRA adapter: {args.adapter} ...")
+    from peft import PeftModel
+    from safetensors.torch import load_file, save_file
+
+    adapter_cfg_path = Path(args.adapter) / "adapter_config.json"
+    with open(adapter_cfg_path) as f:
+        adapter_cfg = json.load(f)
+    target_modules = adapter_cfg.get("target_modules", [])
+    needs_remap = (
+        any(t.startswith("model.layers.") for t in target_modules)
+        and model_type != "qwen3_omni_moe_thinker"
+    )
+
+    adapter_path = args.adapter
+    if needs_remap:
+        print("  Adapter was trained on thinker-only model; remapping keys...")
+        tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+        for fn in Path(args.adapter).iterdir():
+            if fn.is_dir():
+                continue
+            if fn.name == "adapter_config.json":
+                new_targets = []
+                for t in target_modules:
+                    if t.startswith("model.layers."):
+                        new_targets.append("thinker." + t)
+                    elif t[0].isdigit():
+                        new_targets.append("thinker.model.layers." + t)
+                    else:
+                        new_targets.append(t)
+                adapter_cfg["target_modules"] = new_targets
+                with open(tmp_dir / "adapter_config.json", "w") as f:
+                    json.dump(adapter_cfg, f, indent=2)
+            elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                tensors = load_file(str(fn))
+                remapped = {}
+                for k, v in tensors.items():
+                    if ".model.layers." in k and ".thinker." not in k:
+                        new_k = k.replace(
+                            "base_model.model.model.layers.",
+                            "base_model.model.thinker.model.layers.",
+                        )
+                        remapped[new_k] = v
+                    else:
+                        remapped[k] = v
+                save_file(remapped, str(tmp_dir / fn.name))
+            else:
+                shutil.copy2(str(fn), str(tmp_dir / fn.name))
+        adapter_path = str(tmp_dir)
+
+    model = PeftModel.from_pretrained(model, adapter_path)
+
+    print(f"[4/5] Merging and unloading LoRA weights ...")
+    model = model.merge_and_unload()
+
+    out_path = Path(args.output)
+    out_path.mkdir(parents=True, exist_ok=True)
+    print(f"[5/5] Saving merged model to {out_path} ...")
+    model.save_pretrained(out_path, safe_serialization=True)
+    processor.save_pretrained(out_path)
+
+    print(f"\nDone. Merged model saved to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hf_upload/setup_data.sh b/hf_upload/setup_data.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f942bee3e911b3cf5596483eb5a4e8b47c52385e
--- /dev/null
+++ b/hf_upload/setup_data.sh
@@ -0,0 +1,179 @@
+#!/usr/bin/env bash
+# Download all evaluation data to /opt/dlami/nvme (or WORK_ROOT).
+#
+# Downloads:
+#   1) Video-MME benchmark videos
+#   2) LVBench benchmark videos
+#   3) Sync eval: original oops videos, random-shift videos, extracted audio
+#   4) kto_training_data_v2_test.jsonl (sync eval test set, also in repo data/)
+#
+# Requires: conda env already set up (bash setup_env.sh first).
+#
+# Usage:
+#   bash setup_data.sh
+#   WORK_ROOT=/my/fast/disk bash setup_data.sh
+#
+set -euo pipefail
+
+WORK_ROOT="${WORK_ROOT:-/opt/dlami/nvme}"
+CONDA_ENV="${CONDA_ENV:-video}"
+INSTALL_DIR="${INSTALL_DIR:-${HOME}/anaconda3}"
+HF_CACHE="${HF_CACHE:-${HOME}/hf_datasets}"
+REPO_ROOT="$(cd "$(dirname "$0")" && pwd)"
+
+# Sync eval paths (align with eval_dpo_sync.py --data-root default)
+DATA_ROOT="${WORK_ROOT}/video_source"
+ORIGINAL_ROOT="${DATA_ROOT}/original"
+ORIGINAL_OOPS_DIR="${ORIGINAL_ROOT}/uag_oops"
+RANDOM_SHIFT_DIR="${DATA_ROOT}/random_shift_video"
+EXTRACTED_AUDIO_DIR="${DATA_ROOT}/extracted_audio"
+
+log() { echo -e "\n\033[1;36m>>> $*\033[0m"; }
+
+# ── Activate conda ──────────────────────────────────────────────────────────
+if [[ -f "${INSTALL_DIR}/etc/profile.d/conda.sh" ]]; then
+  source "${INSTALL_DIR}/etc/profile.d/conda.sh"
+elif command -v conda &>/dev/null; then
+  eval "$(conda shell.bash hook)"
+else
+  echo "Error: conda not found. Run setup_env.sh first."
+  exit 1
+fi
+conda activate "${CONDA_ENV}"
+
+# ── Detect HF CLI ───────────────────────────────────────────────────────────
+if command -v hf &>/dev/null; then
+  HF_CLI="hf"
+elif command -v huggingface-cli &>/dev/null; then
+  HF_CLI="huggingface-cli"
+else
+  echo "Error: neither 'hf' nor 'huggingface-cli' found. Run setup_env.sh first."
+  exit 1
+fi
+echo "Using HF CLI: ${HF_CLI}"
+
+# ── Helpers ─────────────────────────────────────────────────────────────────
+has_mp4_files() { compgen -G "$1/*.mp4" &>/dev/null; }
+has_wav_files() { find "$1" -name "*.wav" -print -quit 2>/dev/null | grep -q .; }
+
+flatten_mp4s() {
+  local dir="$1"
+  shopt -s globstar nullglob
+  for src in "${dir}"/**/*.mp4; do
+    [[ "$(dirname "$src")" != "${dir}" ]] && mv -n "$src" "${dir}/"
+  done
+  shopt -u globstar nullglob
+}
+
+###############################################################################
+# 1) Video-MME
+###############################################################################
+log "[1/5] Video-MME"
+VIDEOMME_DIR="${WORK_ROOT}/videomme"
+if [[ -d "${VIDEOMME_DIR}/data/data" ]] && has_mp4_files "${VIDEOMME_DIR}/data/data"; then
+  echo "  Already present at ${VIDEOMME_DIR}/data/data; skipping."
+else
+  python "${REPO_ROOT}/scripts/download_videomme.py" --output-dir "${VIDEOMME_DIR}"
+fi
+
+###############################################################################
+# 2) LVBench
+###############################################################################
+log "[2/5] LVBench"
+LVBENCH_DIR="${WORK_ROOT}/lvbench"
+if [[ -d "${LVBENCH_DIR}" ]] && has_mp4_files "${LVBENCH_DIR}"; then
+  echo "  Already present at ${LVBENCH_DIR}; skipping."
+else
+  python "${REPO_ROOT}/scripts/download_lvbench.py" --output-dir "${LVBENCH_DIR}"
+fi
+
+###############################################################################
+# 3) Original oops videos  (hasnat79/ual_bench → original/uag_oops/)
+###############################################################################
+log "[3/5] Original oops videos (sync eval)"
+mkdir -p "${ORIGINAL_ROOT}" "${HF_CACHE}/ual_bench"
+if has_mp4_files "${ORIGINAL_OOPS_DIR}"; then
+  echo "  Already present at ${ORIGINAL_OOPS_DIR}; skipping."
+else
+  "${HF_CLI}" download hasnat79/ual_bench \
+    --repo-type dataset \
+    --include "uag_oops.tar" \
+    --local-dir "${HF_CACHE}/ual_bench"
+  tar -xf "${HF_CACHE}/ual_bench/uag_oops.tar" -C "${ORIGINAL_ROOT}"
+fi
+
+###############################################################################
+# 4) Random-shift videos  (Rakancorle11/random_shift_video → random_shift_video/{delay,early}/)
+###############################################################################
+log "[4/5] Random-shift videos (sync eval)"
+mkdir -p "${RANDOM_SHIFT_DIR}" "${HF_CACHE}/random_shift_video"
+if has_mp4_files "${RANDOM_SHIFT_DIR}/delay" && has_mp4_files "${RANDOM_SHIFT_DIR}/early"; then
+  echo "  Already present; skipping."
+else
+  "${HF_CLI}" download Rakancorle11/random_shift_video \
+    --repo-type dataset \
+    --local-dir "${HF_CACHE}/random_shift_video"
+
+  mkdir -p "${RANDOM_SHIFT_DIR}/delay" "${RANDOM_SHIFT_DIR}/early"
+  tar -xzf "${HF_CACHE}/random_shift_video/delay.tar.gz" -C "${RANDOM_SHIFT_DIR}/delay"
+  tar -xzf "${HF_CACHE}/random_shift_video/early.tar.gz" -C "${RANDOM_SHIFT_DIR}/early"
+
+  if [[ -f "${HF_CACHE}/random_shift_video/metadata/shift_metadata.jsonl" ]]; then
+    cp "${HF_CACHE}/random_shift_video/metadata/shift_metadata.jsonl" "${RANDOM_SHIFT_DIR}/"
+  fi
+
+  flatten_mp4s "${RANDOM_SHIFT_DIR}/delay"
+  flatten_mp4s "${RANDOM_SHIFT_DIR}/early"
+fi
+
+###############################################################################
+# 5) Extracted audio WAVs  (Rakancorle11/extracted_audio → extracted_audio/)
+###############################################################################
+log "[5/5] Extracted audio (sync eval)"
+mkdir -p "${EXTRACTED_AUDIO_DIR}" "${HF_CACHE}/extracted_audio"
+if has_wav_files "${EXTRACTED_AUDIO_DIR}"; then
+  echo "  Already present; skipping."
+else
+  "${HF_CLI}" download Rakancorle11/extracted_audio \
+    --repo-type dataset \
+    --include "extracted_audio.tar.gz" \
+    --local-dir "${HF_CACHE}/extracted_audio"
+  tar -xzf "${HF_CACHE}/extracted_audio/extracted_audio.tar.gz" -C "${DATA_ROOT}"
+fi
+
+###############################################################################
+# Copy test JSONL into DATA_ROOT (so --test-jsonl can default)
+###############################################################################
+TEST_JSONL_SRC="${REPO_ROOT}/data/kto_training_data_v2_test.jsonl"
+TEST_JSONL_DST="${DATA_ROOT}/kto_training_data_v2_test.jsonl"
+if [[ -f "${TEST_JSONL_SRC}" ]] && [[ ! -f "${TEST_JSONL_DST}" ]]; then
+  cp "${TEST_JSONL_SRC}" "${TEST_JSONL_DST}"
+  echo "Copied test JSONL → ${TEST_JSONL_DST}"
+fi
+
+###############################################################################
+# Summary
+###############################################################################
+echo ""
+echo "========================================"
+echo "  Data setup complete"
+echo "========================================"
+echo "  Video-MME videos:     ${VIDEOMME_DIR}/data/data/"
+echo "  LVBench videos:       ${LVBENCH_DIR}/"
+echo "  Sync originals:       ${ORIGINAL_OOPS_DIR}/"
+echo "  Sync random_shift:    ${RANDOM_SHIFT_DIR}/{delay,early}/"
+echo "  Sync extracted_audio: ${EXTRACTED_AUDIO_DIR}/"
+echo "  Sync test JSONL:      ${TEST_JSONL_DST}"
+echo ""
+echo "  original mp4:         $(find "${ORIGINAL_OOPS_DIR}" -name '*.mp4' 2>/dev/null | wc -l)"
+echo "  random_shift delay:   $(find "${RANDOM_SHIFT_DIR}/delay" -name '*.mp4' 2>/dev/null | wc -l)"
+echo "  random_shift early:   $(find "${RANDOM_SHIFT_DIR}/early" -name '*.mp4' 2>/dev/null | wc -l)"
+echo "  extracted_audio wav:  $(find "${EXTRACTED_AUDIO_DIR}" -name '*.wav' 2>/dev/null | wc -l)"
+echo ""
+echo "FineVideo pipeline: run these manually (requires Gemini API keys):"
+echo "  python code-202604/finevideo/filter_finevideo.py --target-count 1000 --early-stop"
+echo "  python code-202604/finevideo/download_finevideo_subset.py --max-videos 500"
+echo "  python code-202604/finevideo/extract_audio_finevideo.py"
+echo "  python code-202604/finevideo/generate_finevideo_sft.py --api-key YOUR_KEY"
+echo "  python code-202604/finevideo/generate_finevideo_dpo.py"
+echo "========================================"
diff --git a/hf_upload/setup_env.sh b/hf_upload/setup_env.sh
new file mode 100644
index 0000000000000000000000000000000000000000..ba29b2a8ed2e21ec1444cdecf57da5cc2fd2856b
--- /dev/null
+++ b/hf_upload/setup_env.sh
@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# CleverHans-Evaluation — environment only (no data, no eval).
+#
+# On a machine *without* conda: downloads and installs Anaconda under INSTALL_DIR,
+# then creates CONDA_ENV and pip-installs eval dependencies (aligned with ~/set_up_env.sh).
+#
+# On a machine that already has conda: skips the installer and only creates/updates the env.
+#
+# Usage:
+#   bash setup_env.sh
+#   INSTALL_DIR=/opt/conda CONDA_ENV=cleverhans bash setup_env.sh
+#   CUDA_INDEX_URL=https://download.pytorch.org/whl/cu124 bash setup_env.sh
+#
+set -euo pipefail
+
+# ----- Config (override with env vars) -----
+CONDA_ENV="${CONDA_ENV:-video}"
+PYTHON_VER="${PYTHON_VER:-3.12}"
+INSTALL_DIR="${INSTALL_DIR:-${HOME}/anaconda3}"
+INSTALLER_PATH="${INSTALLER_PATH:-${HOME}/anaconda3_installer.sh}"
+
+ANACONDA_VERSION="${ANACONDA_VERSION:-Anaconda3-2025.12-2-Linux-x86_64.sh}"
+ANACONDA_URL="${ANACONDA_URL:-https://repo.anaconda.com/archive/${ANACONDA_VERSION}}"
+
+CUDA_INDEX_URL="${CUDA_INDEX_URL:-https://download.pytorch.org/whl/cu124}"
+# -------------------------------------------
+
+log() { echo "[setup_env] $*"; }
+
+log "Checking architecture..."
+ARCH="$(uname -m)"
+if [[ "${ARCH}" != "x86_64" ]]; then
+  echo "Error: this Anaconda installer path supports x86_64 only (found ${ARCH})."
+  echo "Install conda manually for your arch, then re-run this script."
+  exit 1
+fi
+
+bootstrap_conda() {
+  if command -v conda &>/dev/null; then
+    log "conda already on PATH: $(command -v conda)"
+    return 0
+  fi
+
+  if [[ -x "${INSTALL_DIR}/bin/conda" ]]; then
+    log "Using existing conda at ${INSTALL_DIR}"
+    # shellcheck source=/dev/null
+    source "${INSTALL_DIR}/etc/profile.d/conda.sh"
+    return 0
+  fi
+
+  log "No conda found. Downloading Anaconda installer..."
+  if ! command -v wget &>/dev/null; then
+    echo "Error: wget not found. Install wget (e.g. apt install wget) and retry."
+    exit 1
+  fi
+
+  wget -O "${INSTALLER_PATH}" "${ANACONDA_URL}"
+
+  log "Installing Anaconda to ${INSTALL_DIR} (batch mode)..."
+  bash "${INSTALLER_PATH}" -b -p "${INSTALL_DIR}"
+
+  # shellcheck source=/dev/null
+  source "${INSTALL_DIR}/etc/profile.d/conda.sh"
+
+  log "Initializing conda for bash (future shells)..."
+  "${INSTALL_DIR}/bin/conda" init bash >/dev/null 2>&1 || true
+
+  log "Anaconda installed. You can remove the installer: rm -f ${INSTALLER_PATH}"
+}
+
+bootstrap_conda
+
+# Ensure hook is available whether conda came from PATH or fresh install
+if ! command -v conda &>/dev/null; then
+  if [[ -f "${INSTALL_DIR}/etc/profile.d/conda.sh" ]]; then
+    # shellcheck source=/dev/null
+    source "${INSTALL_DIR}/etc/profile.d/conda.sh"
+  else
+    echo "Error: conda still not available after install."
+    exit 1
+  fi
+else
+  eval "$(conda shell.bash hook)"
+fi
+
+log "Accepting Anaconda channel Terms of Service (if supported by this conda)..."
+conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main 2>/dev/null || true
+conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r 2>/dev/null || true
+
+log "Creating conda environment: ${CONDA_ENV} (python=${PYTHON_VER})..."
+if conda env list | awk '{print $1}' | grep -Fxq "${CONDA_ENV}"; then
+  log "Environment '${CONDA_ENV}' already exists; activating."
+  conda activate "${CONDA_ENV}"
+else
+  conda create -n "${CONDA_ENV}" "python=${PYTHON_VER}" -y
+  conda activate "${CONDA_ENV}"
+fi
+
+log "Installing Python packages for Video-MME / LVBench / sync eval + vLLM..."
+python -m pip install --upgrade pip
+
+# GPU PyTorch (adjust CUDA_INDEX_URL if your driver needs another cu12x build)
+pip install torch torchvision torchaudio --index-url "${CUDA_INDEX_URL}"
+
+pip install transformers accelerate peft safetensors
+pip install -U "huggingface_hub[cli]"
+pip install datasets tqdm openai
+pip install qwen-omni-utils
+pip install soundfile librosa
+pip install google-genai
+# Helpful for video decode paths used by torch/qwen stack (optional but recommended)
+pip install decord opencv-python-headless
+pip install torchcodec || echo "[setup_env] Warning: torchcodec failed; decode may fall back to torchvision."
+
+pip install vllm
+
+log "Done."
+echo ""
+echo "  Active env:     ${CONDA_ENV}"
+echo "  Python:         $(command -v python)"
+echo "  Conda base:     ${INSTALL_DIR}"
+echo ""
+echo "Next: conda activate ${CONDA_ENV}"
+echo "      Then follow README.md and COMMANDS.md (data download + eval commands)."
+echo ""
+echo "Tip: install system ffmpeg if missing (Ubuntu: sudo apt install -y ffmpeg)."
diff --git a/merge_adapter.py b/merge_adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea7e31a38f23e987aebedbef9c07e5ada06312a3
--- /dev/null
+++ b/merge_adapter.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Merge a LoRA adapter into the base Qwen3-Omni model and save full weights.
+
+Handles thinker-only adapter key remapping automatically.
+
+Usage:
+  python merge_adapter.py \
+    --base-model Rakancorle11/qwen3omni_full_sft_revised_thinker_key \
+    --adapter /opt/dlami/nvme/LlamaFactory/saves/Qwen3-Omni-Instruct/dpo/qwen3omni_dpo_lora_with_audio_v4_data_8632 \
+    --output /opt/dlami/nvme/merged_models/dpo_v4_8632
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import tempfile
+from pathlib import Path
+
+import torch
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Merge LoRA adapter into base model.")
+    p.add_argument("--base-model", type=str, required=True)
+    p.add_argument("--adapter", type=str, required=True)
+    p.add_argument("--output", type=str, required=True)
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    from transformers import (
+        AutoConfig,
+        AutoProcessor,
+        Qwen3OmniMoeForConditionalGeneration,
+        Qwen3OmniMoeThinkerConfig,
+        Qwen3OmniMoeThinkerForConditionalGeneration,
+    )
+
+    print(f"[1/5] Loading processor from {args.base_model} ...")
+    processor = AutoProcessor.from_pretrained(args.base_model, trust_remote_code=True)
+
+    model_path = Path(args.base_model)
+    cfg_path = model_path / "config.json" if model_path.exists() else None
+    model_type = None
+    if cfg_path and cfg_path.exists():
+        with open(cfg_path) as f:
+            model_type = json.load(f).get("model_type")
+    if not model_type:
+        try:
+            from huggingface_hub import hf_hub_download
+            cached = hf_hub_download(args.base_model, "config.json")
+            with open(cached) as f:
+                model_type = json.load(f).get("model_type")
+        except Exception:
+            pass
+    print(f"  model_type: {model_type}")
+
+    print(f"[2/5] Loading base model ...")
+    if model_type == "qwen3_omni_moe_thinker":
+        config = Qwen3OmniMoeThinkerConfig.from_pretrained(args.base_model)
+        model = Qwen3OmniMoeThinkerForConditionalGeneration.from_pretrained(
+            args.base_model, config=config, torch_dtype=torch.bfloat16, device_map="cpu",
+        )
+    else:
+        config = AutoConfig.from_pretrained(args.base_model, trust_remote_code=True)
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            args.base_model, config=config, torch_dtype=torch.bfloat16, device_map="cpu",
+        )
+
+    print(f"[3/5] Loading and remapping LoRA adapter: {args.adapter} ...")
+    from peft import PeftModel
+    from safetensors.torch import load_file, save_file
+
+    adapter_cfg_path = Path(args.adapter) / "adapter_config.json"
+    with open(adapter_cfg_path) as f:
+        adapter_cfg = json.load(f)
+    target_modules = adapter_cfg.get("target_modules", [])
+    needs_remap = (
+        any(t.startswith("model.layers.") for t in target_modules)
+        and model_type != "qwen3_omni_moe_thinker"
+    )
+
+    adapter_path = args.adapter
+    if needs_remap:
+        print("  Adapter was trained on thinker-only model; remapping keys...")
+        tmp_dir = Path(tempfile.mkdtemp(prefix="adapter_remap_"))
+        for fn in Path(args.adapter).iterdir():
+            if fn.is_dir():
+                continue
+            if fn.name == "adapter_config.json":
+                new_targets = []
+                for t in target_modules:
+                    if t.startswith("model.layers."):
+                        new_targets.append("thinker." + t)
+                    elif t[0].isdigit():
+                        new_targets.append("thinker.model.layers." + t)
+                    else:
+                        new_targets.append(t)
+                adapter_cfg["target_modules"] = new_targets
+                with open(tmp_dir / "adapter_config.json", "w") as f:
+                    json.dump(adapter_cfg, f, indent=2)
+            elif fn.suffix == ".safetensors" and "adapter" in fn.name:
+                tensors = load_file(str(fn))
+                remapped = {}
+                for k, v in tensors.items():
+                    if ".model.layers." in k and ".thinker." not in k:
+                        new_k = k.replace(
+                            "base_model.model.model.layers.",
+                            "base_model.model.thinker.model.layers.",
+                        )
+                        remapped[new_k] = v
+                    else:
+                        remapped[k] = v
+                save_file(remapped, str(tmp_dir / fn.name))
+            else:
+                shutil.copy2(str(fn), str(tmp_dir / fn.name))
+        adapter_path = str(tmp_dir)
+
+    model = PeftModel.from_pretrained(model, adapter_path)
+
+    print(f"[4/5] Merging and unloading LoRA weights ...")
+    model = model.merge_and_unload()
+
+    out_path = Path(args.output)
+    out_path.mkdir(parents=True, exist_ok=True)
+    print(f"[5/5] Saving merged model to {out_path} ...")
+    model.save_pretrained(out_path, safe_serialization=True)
+    processor.save_pretrained(out_path)
+
+    print(f"\nDone. Merged model saved to: {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/run_qwen3omni_sync_diag_3prompts.sh b/run_qwen3omni_sync_diag_3prompts.sh
new file mode 100644
index 0000000000000000000000000000000000000000..b0acb21fdf65d5e2f7dc5aa783954d2803e42e9e
--- /dev/null
+++ b/run_qwen3omni_sync_diag_3prompts.sh
@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Usage:
+# bash /home/ubuntu/run_qwen_sync_diagnostics.sh \
+#   "/home/ubuntu/data_pair/34-5" \
+#   "34 Funny Kid Nominees - FailArmy Hall Of Fame (May 2017)5"
+#
+# It expects these 3 files in the folder:
+#   <base>.mp4
+#   <base>_early2s.mp4
+#   <base>_delay2s.mp4
+
+TARGET_DIR="${1:-/home/ubuntu/data_pair/34-5}"
+BASE_NAME="${2:-34 Funny Kid Nominees - FailArmy Hall Of Fame (May 2017)5}"
+OUT_DIR="${TARGET_DIR}/results_sync_eval"
+
+ORIG="${TARGET_DIR}/${BASE_NAME}.mp4"
+EARLY="${TARGET_DIR}/${BASE_NAME}_early2s.mp4"
+DELAY="${TARGET_DIR}/${BASE_NAME}_delay2s.mp4"
+
+mkdir -p "${OUT_DIR}"
+
+for f in "${ORIG}" "${EARLY}" "${DELAY}"; do
+  if [[ ! -f "${f}" ]]; then
+    echo "Missing file: ${f}"
+    exit 1
+  fi
+done
+
+read -r -d '' PROMPT_1 <<'EOF' || true
+You are evaluating audio-video temporal consistency.
+Task:
+1) Briefly describe key visual events in time order.
+2) Identify the most salient sound event and when it occurs.
+3) Judge whether audio is synchronized with visuals.
+4) If not synchronized, estimate signed offset in seconds:
+   - Positive offset => audio lags behind video.
+   - Negative offset => audio leads video.
+Return strictly in this format:
+SYNC_JUDGMENT: <synced|not_synced|uncertain>
+ESTIMATED_OFFSET_SECONDS: <number or unknown>
+EVIDENCE: <short explanation>
+EOF
+
+read -r -d '' PROMPT_2 <<'EOF' || true
+Check whether this video looks manipulated in audio timing.
+Focus on impact moments (falls, hits, collisions) and whether corresponding sounds align.
+Return strictly:
+MANIPULATION_SUSPECTED: <yes|no|uncertain>
+LIKELY_TYPE: <audio_early|audio_delay|none|unknown>
+ESTIMATED_SHIFT_SECONDS: <number or unknown>
+CONFIDENCE: <0-100>
+REASON: <one short paragraph>
+EOF
+
+read -r -d '' PROMPT_3 <<'EOF' || true
+Evaluate the audio-visual synchronization of this video. Choose ONLY ONE of the following options and provide a one-sentence justification:
+[A] Normal: Audio and video are perfectly synchronized.
+[B] Early Audio: The sound of the main event happens BEFORE the visual action.
+[C] Delayed Audio: The sound of the main event happens AFTER the visual action.
+
+Your choice:
+EOF
+
+run_one() {
+  local label="$1"
+  local video="$2"
+  local prompt_id="$3"
+  local prompt_text="$4"
+  local out_file="${OUT_DIR}/${label}_prompt${prompt_id}.txt"
+
+  python /home/ubuntu/test_qwen3omni_audio_video.py \
+    --video "${video}" \
+    --cases av \
+    --prompt "${prompt_text}" \
+    | tee "${out_file}"
+}
+
+echo "Running sync diagnostics into: ${OUT_DIR}"
+
+run_one "original" "${ORIG}" "1" "${PROMPT_1}"
+run_one "early2s"  "${EARLY}" "1" "${PROMPT_1}"
+run_one "delay2s"  "${DELAY}" "1" "${PROMPT_1}"
+
+run_one "original" "${ORIG}" "2" "${PROMPT_2}"
+run_one "early2s"  "${EARLY}" "2" "${PROMPT_2}"
+run_one "delay2s"  "${DELAY}" "2" "${PROMPT_2}"
+
+run_one "original" "${ORIG}" "3" "${PROMPT_3}"
+run_one "early2s"  "${EARLY}" "3" "${PROMPT_3}"
+run_one "delay2s"  "${DELAY}" "3" "${PROMPT_3}"
+
+echo "Done. Results in: ${OUT_DIR}"
diff --git a/sft_model_convert_and_onpolicy_dpo/convert_thinker_to_full.py b/sft_model_convert_and_onpolicy_dpo/convert_thinker_to_full.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b57e4144476b9eb79da3cca2074a4e953c90ebc
--- /dev/null
+++ b/sft_model_convert_and_onpolicy_dpo/convert_thinker_to_full.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""
+Convert a LlamaFactory SFT thinker-only checkpoint back into a full
+Qwen3OmniMoeForConditionalGeneration checkpoint that AutoModel, vLLM,
+and other tools can load directly.
+
+What it does:
+  1. Reads SFT thinker weights (keys like model.layers.xxx)
+  2. Adds 'thinker.' prefix to every key
+  3. Copies talker/code2wav weights from the vanilla model
+  4. Uses vanilla config/tokenizer/processor (model_type: qwen3_omni_moe)
+  5. Writes everything to a new output directory
+
+The original SFT checkpoint is NEVER modified.
+
+Usage:
+  python convert_thinker_to_full.py
+  python convert_thinker_to_full.py --output /path/to/output
+"""
+
+import argparse
+import json
+import os
+import shutil
+from collections import OrderedDict
+from pathlib import Path
+
+VANILLA = Path("/home/ubuntu/.cache/huggingface/hub/models--Qwen--Qwen3-Omni-30B-A3B-Instruct/snapshots/26291f793822fb6be9555850f06dfe95f2d7e695")
+SFT_THINKER = Path("/opt/dlami/nvme/qwen3omni_sft_thinker_backup")
+DEFAULT_OUTPUT = Path("/opt/dlami/nvme/qwen3omni_full_sft_converted")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert thinker checkpoint to full Qwen3OmniMoe")
+    parser.add_argument("--sft", type=Path, default=SFT_THINKER, help="SFT thinker checkpoint dir")
+    parser.add_argument("--vanilla", type=Path, default=VANILLA, help="Vanilla full model dir")
+    parser.add_argument("--output", type=Path, default=DEFAULT_OUTPUT, help="Output directory")
+    args = parser.parse_args()
+
+    from safetensors import safe_open
+    from safetensors.torch import save_file
+
+    out = args.output
+    out.mkdir(parents=True, exist_ok=True)
+    print(f"SFT thinker: {args.sft}")
+    print(f"Vanilla:     {args.vanilla}")
+    print(f"Output:      {out}")
+
+    # --- Step 1: Copy config/tokenizer/processor from vanilla ---
+    config_files = [
+        "config.json", "generation_config.json", "tokenizer.json",
+        "tokenizer_config.json", "processor_config.json",
+        "chat_template.jinja", "preprocessor_config.json",
+    ]
+    for fname in config_files:
+        src = args.vanilla / fname
+        if src.exists():
+            shutil.copy2(src, out / fname)
+            print(f"  Copied config: {fname}")
+
+    # --- Step 2: Load index files ---
+    sft_index = json.load(open(args.sft / "model.safetensors.index.json"))
+    vanilla_index = json.load(open(args.vanilla / "model.safetensors.index.json"))
+
+    sft_wm = sft_index["weight_map"]
+    vanilla_wm = vanilla_index["weight_map"]
+
+    sft_shards = sorted(set(sft_wm.values()))
+    vanilla_shards = sorted(set(vanilla_wm.values()))
+
+    print(f"\n  SFT: {len(sft_wm)} keys in {len(sft_shards)} shards")
+    print(f"  Vanilla: {len(vanilla_wm)} keys in {len(vanilla_shards)} shards")
+
+    # --- Step 3: Write SFT weights with thinker. prefix ---
+    new_weight_map = OrderedDict()
+    shard_counter = 1
+
+    for sft_shard in sft_shards:
+        new_shard_name = f"model-{shard_counter:05d}-of-99999.safetensors"
+        print(f"\n  Processing SFT shard: {sft_shard} -> {new_shard_name}")
+
+        tensors = OrderedDict()
+        with safe_open(args.sft / sft_shard, framework="pt", device="cpu") as f:
+            for key in f.keys():
+                new_key = f"thinker.{key}"
+                tensors[new_key] = f.get_tensor(key)
+                new_weight_map[new_key] = new_shard_name
+
+        save_file(tensors, out / new_shard_name)
+        size_gb = os.path.getsize(out / new_shard_name) / 1e9
+        print(f"    Wrote {len(tensors)} tensors ({size_gb:.1f} GB)")
+        del tensors
+        shard_counter += 1
+
+    # --- Step 4: Copy non-thinker weights from vanilla ---
+    non_thinker_keys = {k: v for k, v in vanilla_wm.items() if not k.startswith("thinker.")}
+    non_thinker_shards = sorted(set(non_thinker_keys.values()))
+
+    for vanilla_shard in non_thinker_shards:
+        keys_in_shard = [k for k, v in vanilla_wm.items() if v == vanilla_shard]
+        nt_keys = [k for k in keys_in_shard if not k.startswith("thinker.")]
+        t_keys = [k for k in keys_in_shard if k.startswith("thinker.")]
+
+        new_shard_name = f"model-{shard_counter:05d}-of-99999.safetensors"
+
+        if t_keys:
+            # Mixed shard: extract only non-thinker tensors
+            print(f"\n  Extracting non-thinker from mixed shard: {vanilla_shard} -> {new_shard_name}")
+            tensors = OrderedDict()
+            with safe_open(args.vanilla / vanilla_shard, framework="pt", device="cpu") as f:
+                for key in nt_keys:
+                    tensors[key] = f.get_tensor(key)
+                    new_weight_map[key] = new_shard_name
+            save_file(tensors, out / new_shard_name)
+            size_gb = os.path.getsize(out / new_shard_name) / 1e9
+            print(f"    Wrote {len(tensors)} tensors ({size_gb:.1f} GB)")
+            del tensors
+        else:
+            # Pure non-thinker shard: symlink
+            print(f"\n  Symlinking non-thinker shard: {vanilla_shard} -> {new_shard_name}")
+            os.symlink(args.vanilla / vanilla_shard, out / new_shard_name)
+            for key in nt_keys:
+                new_weight_map[key] = new_shard_name
+
+        shard_counter += 1
+
+    # --- Step 5: Fix shard count in filenames ---
+    total_shards = shard_counter - 1
+    final_weight_map = OrderedDict()
+    for key, shard_name in new_weight_map.items():
+        old_num = int(shard_name.split("-")[1])
+        new_name = f"model-{old_num:05d}-of-{total_shards:05d}.safetensors"
+        final_weight_map[key] = new_name
+
+    # Rename files
+    for i in range(1, total_shards + 1):
+        old_name = f"model-{i:05d}-of-99999.safetensors"
+        new_name = f"model-{i:05d}-of-{total_shards:05d}.safetensors"
+        old_path = out / old_name
+        new_path = out / new_name
+        if old_path.exists() or old_path.is_symlink():
+            old_path.rename(new_path)
+
+    # --- Step 6: Write index ---
+    new_index = {
+        "metadata": {"total_size": sum(
+            os.path.getsize(out / f) if not os.path.islink(out / f)
+            else os.path.getsize(os.readlink(out / f))
+            for f in set(final_weight_map.values())
+        )},
+        "weight_map": final_weight_map,
+    }
+    with open(out / "model.safetensors.index.json", "w") as f:
+        json.dump(new_index, f, indent=2)
+
+    print(f"\n  Index: {len(final_weight_map)} keys across {total_shards} shards")
+
+    # --- Step 7: Verify key counts ---
+    thinker_count = sum(1 for k in final_weight_map if k.startswith("thinker."))
+    talker_count = sum(1 for k in final_weight_map if k.startswith("talker."))
+    code2wav_count = sum(1 for k in final_weight_map if k.startswith("code2wav."))
+    print(f"  thinker: {thinker_count}  talker: {talker_count}  code2wav: {code2wav_count}")
+
+    vanilla_thinker = sum(1 for k in vanilla_wm if k.startswith("thinker."))
+    vanilla_talker = sum(1 for k in vanilla_wm if k.startswith("talker."))
+    vanilla_code2wav = sum(1 for k in vanilla_wm if k.startswith("code2wav."))
+
+    ok = True
+    if thinker_count != vanilla_thinker:
+        print(f"  WARNING: thinker count mismatch! expected {vanilla_thinker}, got {thinker_count}")
+        ok = False
+    if talker_count != vanilla_talker:
+        print(f"  WARNING: talker count mismatch! expected {vanilla_talker}, got {talker_count}")
+        ok = False
+    if code2wav_count != vanilla_code2wav:
+        print(f"  WARNING: code2wav count mismatch! expected {vanilla_code2wav}, got {code2wav_count}")
+        ok = False
+
+    if ok:
+        print("\n  All key counts match vanilla. Conversion successful!")
+    else:
+        print("\n  KEY COUNT MISMATCH - check output carefully!")
+
+    print(f"\nOutput directory: {out}")
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sft_model_convert_and_onpolicy_dpo/generate_onpolicy_dpo.py b/sft_model_convert_and_onpolicy_dpo/generate_onpolicy_dpo.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b2598dc0fe0e81a91d06cd25f6556f3e4721a37
--- /dev/null
+++ b/sft_model_convert_and_onpolicy_dpo/generate_onpolicy_dpo.py
@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+"""
+On-policy DPO data augmentation pipeline.
+
+Three stages:
+  Stage 1: Load SFT-trained Qwen3-Omni, run inference on training videos
+           to collect model responses. Output: raw_responses.jsonl
+  Stage 2: Use GPT-5.4 as judge to evaluate each model response against
+           ground truth label (synced / delay Xs / early Xs).
+           Output: judged_responses.jsonl
+  Stage 3: Filter wrong responses as rejected, pair with ground truth chosen,
+           merge with existing DPO data. Output: dpo_video_train_onpolicy.json
+
+Usage:
+  python generate_onpolicy_dpo.py --stage 1  # run inference (GPU needed)
+  python generate_onpolicy_dpo.py --stage 2  # run LLM judge (OPENAI_API_KEY needed)
+  python generate_onpolicy_dpo.py --stage 3  # filter & merge
+  python generate_onpolicy_dpo.py --stage all # run all stages
+"""
+
+from __future__ import annotations
+
+import argparse
+import gc
+import json
+import logging
+import os
+import re
+import time
+import traceback
+from pathlib import Path
+
+import torch
+from tqdm import tqdm
+
+LOG = logging.getLogger("onpolicy_dpo")
+
+# ── Paths ──
+DATA_ROOT = Path("/home/ubuntu/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+INPUT_JSONL = DATA_ROOT / "kto_training_data_v2_train.jsonl"
+EXISTING_DPO = Path("/home/ubuntu/LlamaFactory/data/dpo_video_train_with_audio.json")
+RAW_RESPONSES = DATA_ROOT / "onpolicy_raw_responses.jsonl"
+JUDGED_RESPONSES = DATA_ROOT / "onpolicy_judged_responses.jsonl"
+OUTPUT_DPO = Path("/home/ubuntu/LlamaFactory/data/dpo_video_train_onpolicy.json")
+EXTRACTED_AUDIO_ROOT = DATA_ROOT / "extracted_audio"
+
+VANILLA_MODEL = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+SFT_MODEL_PATH = "/opt/dlami/nvme/qwen3omni_full_sft_converted"
+
+
+def resolve_video_path(video_field: str) -> str:
+    if os.path.isabs(video_field):
+        return video_field
+    return str(ORIGINAL_ROOT / video_field)
+
+
+def get_audio_path(video_path: str) -> str:
+    rel = os.path.relpath(video_path, str(DATA_ROOT))
+    return str(EXTRACTED_AUDIO_ROOT / (os.path.splitext(rel)[0] + ".wav"))
+
+
+def parse_ground_truth_label(video_path: str) -> dict:
+    if "/original/" in video_path:
+        return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+    m = re.search(r"_(delay|early)_([\d.]+)s\.", video_path)
+    if m:
+        return {"is_synced": False, "direction": m.group(1), "offset_sec": float(m.group(2))}
+    return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+
+
+def read_input_data() -> list[dict]:
+    data = []
+    with open(INPUT_JSONL) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            obj["video"] = resolve_video_path(obj["video"])
+            data.append(obj)
+    return data
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 1: Inference
+# ═══════════════════════════════════════════════════════════════
+
+def load_model(model_choice: str):
+    """Returns (model, processor).
+
+    Both vanilla and SFT are full Qwen3OmniMoeForConditionalGeneration
+    (SFT was converted from thinker-only via convert_thinker_to_full.py).
+    """
+    from transformers import AutoProcessor, Qwen3OmniMoeForConditionalGeneration
+
+    model_path = VANILLA_MODEL if model_choice == "vanilla" else SFT_MODEL_PATH
+    LOG.info("Loading model: %s", model_path)
+    processor = AutoProcessor.from_pretrained(model_path)
+    model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+        model_path, torch_dtype=torch.bfloat16, device_map="auto",
+    )
+    model.eval()
+    return model, processor
+
+
+def run_inference(model, processor,
+                  video_path: str, audio_path: str, question: str,
+                  temperature: float, max_new_tokens: int) -> str:
+    """Single-sample inference using full Qwen3OmniMoeForConditionalGeneration."""
+    from qwen_omni_utils import process_mm_info
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": video_path},
+                {"type": "audio", "audio": audio_path},
+                {"type": "text", "text": question},
+            ],
+        },
+    ]
+
+    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+    inputs = processor(
+        text=[text], audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True,
+    )
+
+    model_dtype = next(model.parameters()).dtype
+    for k, v in list(inputs.items()):
+        if hasattr(v, "to"):
+            v = v.to(model.device)
+            if torch.is_floating_point(v):
+                v = v.to(model_dtype)
+            inputs[k] = v
+
+    do_sample = temperature > 0
+    gen_kwargs = {
+        "thinker_max_new_tokens": max_new_tokens,
+        "return_audio": False,
+        "use_audio_in_video": False,
+        "do_sample": do_sample,
+    }
+    if do_sample:
+        gen_kwargs["temperature"] = temperature
+        gen_kwargs["top_p"] = 0.9
+
+    with torch.inference_mode():
+        result = model.generate(**inputs, **gen_kwargs)
+
+    output_ids = result[0] if isinstance(result, tuple) else result
+    prompt_len = inputs["input_ids"].shape[1]
+    return processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True
+    )[0].strip()
+
+
+def stage1_inference(args):
+    LOG.info("=== Stage 1: Inference ===")
+    data = read_input_data()
+    LOG.info("Loaded %d samples from %s", len(data), INPUT_JSONL)
+
+    model, processor = load_model(args.model_choice)
+    LOG.info("Model loaded.")
+
+    processed = set()
+    processed_count = 0
+    if RAW_RESPONSES.exists():
+        with open(RAW_RESPONSES) as f:
+            for line in f:
+                obj = json.loads(line)
+                if obj.get("responses") and any(
+                    isinstance(r, dict) and r.get("response") for r in obj["responses"]
+                ):
+                    processed.add(obj["video"])
+        LOG.info("Resuming: %d already done", len(processed))
+
+    temperatures = args.temperatures
+
+    for item in tqdm(data, desc="Inference"):
+        video_path = item["video"]
+        if video_path in processed:
+            continue
+
+        audio_path = get_audio_path(video_path)
+        if not os.path.exists(audio_path):
+            LOG.warning("Audio not found, skipping: %s", audio_path)
+            continue
+
+        question = item["prompt"]
+        ground_truth = item["chosen"]
+        label = parse_ground_truth_label(video_path)
+
+        responses = []
+        for temp in temperatures:
+            try:
+                resp = run_inference(
+                    model, processor,
+                    video_path, audio_path, question,
+                    temperature=temp, max_new_tokens=args.max_new_tokens,
+                )
+                responses.append({"temperature": temp, "response": resp})
+            except Exception as e:
+                LOG.warning("Failed on %s (temp=%.1f):", video_path, temp)
+                traceback.print_exc()
+
+            gc.collect()
+            torch.cuda.empty_cache()
+
+        out = {
+            "video": video_path,
+            "audio": audio_path,
+            "question": question,
+            "ground_truth": ground_truth,
+            "label": label,
+            "responses": responses,
+        }
+        with open(RAW_RESPONSES, "a") as f:
+            f.write(json.dumps(out, ensure_ascii=False) + "\n")
+        if responses:
+            processed.add(video_path)
+            processed_count += 1
+            if args.max_samples > 0 and processed_count >= args.max_samples:
+                break
+
+    LOG.info("Stage 1 done. %d samples. Wrote %s", processed_count, RAW_RESPONSES)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 2: LLM Judge (GPT-5.4)
+# ═══════════════════════════════════════════════════════════════
+
+OFFSET_TOL_SEC = 1.0
+
+JUDGE_PROMPT = """\
+You are evaluating a model's response about audio-video synchronization.
+
+## Ground truth about this video:
+- Synchronized: {is_synced}
+- If not synchronized — direction: {direction}, offset: {offset_sec}s
+
+## Model's response:
+\"\"\"{response}\"\"\"
+
+## Task:
+Determine if the model's response is CORRECT or INCORRECT.
+
+A response is CORRECT if:
+1. For synced videos: model says it's synchronized/aligned (minor tolerance claims are OK)
+2. For not-synced videos: model says it's NOT synchronized AND gets the direction right (delay vs early).
+   Additionally, if the model mentions/estimates the audio-video gap (numeric or clearly implied), it should be within ±{offset_tol_sec}s of the true offset.
+
+A response is INCORRECT if:
+1. For synced videos: model says it's not synchronized or claims a significant gap
+2. For not-synced videos: model says it's synchronized, or gets the direction wrong
+   OR (if the model provides a gap estimate) the absolute gap error is > {offset_tol_sec}s.
+
+Output ONLY a JSON object, no markdown fences:
+{{"correct": true or false, "reason": "brief explanation"}}"""
+
+
+def judge_with_openai(response: str, label: dict, client) -> dict:
+    prompt = JUDGE_PROMPT.format(
+        is_synced=label["is_synced"],
+        direction=label.get("direction") or "N/A",
+        offset_sec=label.get("offset_sec", 0),
+        offset_tol_sec=OFFSET_TOL_SEC,
+        response=response,
+    )
+
+    result = client.chat.completions.create(
+        model="gpt-5.4",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0,
+        max_tokens=200,
+    )
+
+    text = result.choices[0].message.content.strip()
+    text = re.sub(r"^```json\s*", "", text)
+    text = re.sub(r"\s*```$", "", text)
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        LOG.warning("Failed to parse judge output: %s", text)
+        return {"correct": None, "reason": text}
+
+
+def stage2_judge(args):
+    LOG.info("=== Stage 2: LLM Judge (GPT-5.4) ===")
+
+    from openai import OpenAI
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("Set OPENAI_API_KEY environment variable")
+    client = OpenAI(api_key=api_key)
+
+    raw_data = []
+    with open(RAW_RESPONSES) as f:
+        for line in f:
+            raw_data.append(json.loads(line))
+    LOG.info("Loaded %d raw response records", len(raw_data))
+
+    already_judged = set()
+    if JUDGED_RESPONSES.exists():
+        with open(JUDGED_RESPONSES) as f:
+            for line in f:
+                obj = json.loads(line)
+                already_judged.add((obj["video"], obj["response"][:80]))
+        LOG.info("Resuming: %d already judged", len(already_judged))
+
+    for record in tqdm(raw_data, desc="Judging"):
+        label = record["label"]
+        for resp_obj in record["responses"]:
+            resp_text = resp_obj["response"]
+            key = (record["video"], resp_text[:80])
+            if key in already_judged:
+                continue
+
+            try:
+                verdict = judge_with_openai(resp_text, label, client)
+            except Exception as e:
+                LOG.warning("Judge failed for %s: %s", record["video"], e)
+                time.sleep(2)
+                continue
+
+            out = {
+                "video": record["video"],
+                "audio": record["audio"],
+                "question": record["question"],
+                "ground_truth": record["ground_truth"],
+                "label": label,
+                "response": resp_text,
+                "temperature": resp_obj["temperature"],
+                "judge": verdict,
+            }
+            with open(JUDGED_RESPONSES, "a") as f:
+                f.write(json.dumps(out, ensure_ascii=False) + "\n")
+            already_judged.add(key)
+
+            time.sleep(0.05)
+
+    LOG.info("Stage 2 done. Wrote %s", JUDGED_RESPONSES)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Stage 3: Filter & Merge
+# ═══════════════════════════════════════════════════════════════
+
+def stage3_merge(args):
+    LOG.info("=== Stage 3: Filter & Merge ===")
+
+    judged = []
+    with open(JUDGED_RESPONSES) as f:
+        for line in f:
+            judged.append(json.loads(line))
+    LOG.info("Loaded %d judged records", len(judged))
+
+    new_pairs = []
+    seen = set()
+    for record in judged:
+        verdict = record.get("judge", {})
+        if verdict.get("correct") is not False:
+            continue
+
+        dedup_key = (record["video"], record["response"][:80])
+        if dedup_key in seen:
+            continue
+        seen.add(dedup_key)
+
+        pair = {
+            "messages": [
+                {"role": "user", "content": "<video><audio>" + record["question"]}
+            ],
+            "chosen": {"role": "assistant", "content": record["ground_truth"]},
+            "rejected": {"role": "assistant", "content": record["response"]},
+            "videos": [record["video"]],
+            "audios": [record["audio"]],
+        }
+        new_pairs.append(pair)
+
+    LOG.info("New on-policy DPO pairs: %d (from %d judged)", len(new_pairs), len(judged))
+
+    with open(EXISTING_DPO) as f:
+        existing = json.load(f)
+    LOG.info("Existing DPO pairs: %d", len(existing))
+
+    merged = existing + new_pairs
+    LOG.info("Merged total: %d pairs", len(merged))
+
+    with open(OUTPUT_DPO, "w") as f:
+        json.dump(merged, f, indent=2, ensure_ascii=False)
+    LOG.info("Wrote %s", OUTPUT_DPO)
+
+
+# ═══════════════════════════════════════════════════════════════
+
+def main():
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
+
+    parser = argparse.ArgumentParser(description="On-policy DPO data augmentation")
+    parser.add_argument("--stage", type=str, default="all", choices=["1", "2", "3", "all"])
+    parser.add_argument("--model-choice", type=str, default="sft", choices=["vanilla", "sft"],
+                        help="Which model to use for stage 1 inference")
+    parser.add_argument("--temperatures", type=float, nargs="+", default=[0.3, 0.7, 1.0])
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument("--max-samples", type=int, default=-1,
+                        help="Stage 1 only: max videos to process (-1 = all)")
+    args = parser.parse_args()
+
+    if args.stage in ("1", "all"):
+        stage1_inference(args)
+    if args.stage in ("2", "all"):
+        stage2_judge(args)
+    if args.stage in ("3", "all"):
+        stage3_merge(args)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sft_model_convert_and_onpolicy_dpo/stage1_vllm.py b/sft_model_convert_and_onpolicy_dpo/stage1_vllm.py
new file mode 100644
index 0000000000000000000000000000000000000000..04a7308aa0a636aa81eec9621e311e6a7b6cefc2
--- /dev/null
+++ b/sft_model_convert_and_onpolicy_dpo/stage1_vllm.py
@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Stage 1 inference using vLLM for massive speedup.
+Output format identical to generate_onpolicy_dpo.py Stage 1.
+
+Uses qwen_omni_utils.process_mm_info() for video/audio preprocessing
+(same as run_onpolicy_inference.py / HF path) so frame sampling, resize,
+audio loading are identical. Only the generation engine differs (vLLM
+continuous batching vs HF sequential generate).
+
+Usage:
+  # SFT thinker checkpoint, all GPUs, all data:
+  python stage1_vllm.py
+
+  # Vanilla model, 3 samples only:
+  python stage1_vllm.py --model vanilla --max-samples 3
+
+  # Control tensor parallelism:
+  python stage1_vllm.py --tp 4 --batch-size 64
+
+After this finishes, run:
+  python generate_onpolicy_dpo.py --stage 2   # LLM judge
+  python generate_onpolicy_dpo.py --stage 3   # filter & merge
+"""
+
+import argparse
+import json
+import os
+import re
+from pathlib import Path
+
+import numpy as np
+
+DATA_ROOT = Path("/home/ubuntu/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+INPUT_JSONL = DATA_ROOT / "kto_training_data_v2_train.jsonl"
+AUDIO_ROOT = DATA_ROOT / "extracted_audio"
+OUTPUT_JSONL = DATA_ROOT / "onpolicy_raw_responses.jsonl"
+
+VANILLA_MODEL = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+SFT_MODEL_PATH = "Rakancorle11/qwen3omni_full_sft_revised_thinker_key"
+
+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 resolve_video(v: str) -> str:
+    return v if os.path.isabs(v) else str(ORIGINAL_ROOT / v)
+
+
+def get_audio(video_path: str) -> str:
+    rel = os.path.relpath(video_path, str(DATA_ROOT))
+    return str(AUDIO_ROOT / (os.path.splitext(rel)[0] + ".wav"))
+
+
+def parse_label(video_path: str) -> dict:
+    if "/original/" in video_path:
+        return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+    m = re.search(r"_(delay|early)_([\d.]+)s\.", video_path)
+    if m:
+        return {"is_synced": False, "direction": m.group(1), "offset_sec": float(m.group(2))}
+    return {"is_synced": True, "direction": None, "offset_sec": 0.0}
+
+
+def preprocess_sample(video_path: str, audio_path: str):
+    """
+    Use qwen_omni_utils.process_mm_info to extract video frames + audio
+    exactly the same way as run_onpolicy_inference.py / HF path.
+
+    Returns (video_np, audio_tuple) or raises on failure.
+    - video_np: np.ndarray shape (T, C, H, W) uint8
+    - audio_tuple: (np.ndarray, sample_rate)
+    """
+    from qwen_omni_utils import process_mm_info
+
+    messages = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "video", "video": video_path},
+                {"type": "audio", "audio": audio_path},
+                {"type": "text", "text": "placeholder"},
+            ],
+        },
+    ]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=False)
+
+    # videos is a list of torch.Tensor (T, C, H, W) float32 [0-1] range from
+    # qwen_omni_utils. vLLM expects np.ndarray uint8 (T, C, H, W) or (T, H, W, C).
+    # Convert to numpy, keeping (T, C, H, W) which is what vLLM's Qwen3-Omni
+    # processor expects (it does its own normalization).
+    video_tensor = videos[0]  # torch.Tensor (T, C, H, W), float [0, 1]
+    video_np = (video_tensor * 255).byte().numpy()  # uint8 (T, C, H, W)
+
+    # audios is a list of np.ndarray from process_audio_info.
+    # vLLM expects (np.ndarray, sample_rate). Qwen3-Omni audio encoder uses 16kHz.
+    audio_np = audios[0]  # np.ndarray float32
+    if hasattr(audio_np, "numpy"):
+        audio_np = audio_np.numpy()
+    audio_tuple = (audio_np, 16000)
+
+    return video_np, audio_tuple
+
+
+def build_prompt(question: str) -> str:
+    """Build raw prompt with placeholder tokens. vLLM expands pad tokens to correct count."""
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"<|vision_start|><|video_pad|><|vision_end|>"
+        f"<|audio_start|><|audio_pad|><|audio_end|>"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Stage 1 with vLLM")
+    parser.add_argument("--model", choices=["vanilla", "sft"], default="sft")
+    parser.add_argument("--tp", type=int, default=None,
+                        help="Tensor parallel size (default: all visible GPUs)")
+    parser.add_argument("--max-samples", type=int, default=-1)
+    parser.add_argument("--max-new-tokens", type=int, default=256)
+    parser.add_argument("--temperatures", type=float, nargs="+", default=[0.3, 0.7, 1.0])
+    parser.add_argument("--batch-size", type=int, default=64,
+                        help="How many prompts to submit per llm.generate() call")
+    parser.add_argument("--max-model-len", type=int, default=12800)
+    parser.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    args = parser.parse_args()
+
+    import torch
+    from vllm import LLM, SamplingParams
+
+    if args.tp is None:
+        args.tp = torch.cuda.device_count()
+
+    model_path = SFT_MODEL_PATH if args.model == "sft" else VANILLA_MODEL
+    print(f"Loading model: {model_path}  (tp={args.tp})")
+
+    llm = LLM(
+        model=model_path,
+        tensor_parallel_size=args.tp,
+        max_model_len=args.max_model_len,
+        max_num_seqs=args.batch_size,
+        limit_mm_per_prompt={"audio": 1, "video": 1},
+        gpu_memory_utilization=args.gpu_memory_utilization,
+        dtype="bfloat16",
+        trust_remote_code=True,
+    )
+
+    # Load input data
+    data = []
+    with open(INPUT_JSONL) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                obj = json.loads(line)
+                obj["video"] = resolve_video(obj["video"])
+                data.append(obj)
+    print(f"Loaded {len(data)} samples")
+
+    # Resume
+    processed = set()
+    if OUTPUT_JSONL.exists():
+        with open(OUTPUT_JSONL) as f:
+            for line in f:
+                obj = json.loads(line)
+                if obj.get("responses") and any(
+                    isinstance(r, dict) and r.get("response") for r in obj["responses"]
+                ):
+                    processed.add(obj["video"])
+        print(f"Resuming: {len(processed)} already done")
+
+    # Filter to unprocessed
+    todo = []
+    for item in data:
+        if item["video"] in processed:
+            continue
+        audio_path = get_audio(item["video"])
+        if not os.path.exists(audio_path):
+            continue
+        todo.append(item)
+    if args.max_samples > 0:
+        todo = todo[:args.max_samples]
+    print(f"To process: {len(todo)} samples")
+
+    # Pre-extract all video/audio features (same as HF path)
+    print("Pre-extracting video/audio features with qwen_omni_utils...")
+    preprocessed = {}
+    skipped = 0
+    for i, item in enumerate(todo):
+        video_path = item["video"]
+        audio_path = get_audio(video_path)
+        try:
+            video_np, audio_tuple = preprocess_sample(video_path, audio_path)
+            preprocessed[video_path] = (video_np, audio_tuple)
+        except Exception as e:
+            print(f"  [{i+1}/{len(todo)}] Skip (preprocess error): {video_path}: {e}")
+            skipped += 1
+    print(f"Preprocessed: {len(preprocessed)} ok, {skipped} skipped")
+
+    # Filter todo to only successfully preprocessed
+    todo = [item for item in todo if item["video"] in preprocessed]
+
+    for temp in args.temperatures:
+        sampling_params = SamplingParams(
+            temperature=temp if temp > 0 else 0.0,
+            top_p=0.9 if temp > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        for batch_start in range(0, len(todo), args.batch_size):
+            batch = todo[batch_start:batch_start + args.batch_size]
+            inputs_list = []
+
+            for item in batch:
+                video_np, audio_tuple = preprocessed[item["video"]]
+                inputs_list.append({
+                    "prompt": build_prompt(item["prompt"]),
+                    "multi_modal_data": {
+                        "video": video_np,
+                        "audio": audio_tuple,
+                    },
+                })
+
+            outputs = llm.generate(inputs_list, sampling_params=sampling_params)
+
+            for out_idx, item in enumerate(batch):
+                resp_text = outputs[out_idx].outputs[0].text.strip()
+
+                if temp == args.temperatures[0]:
+                    video_path = item["video"]
+                    record = {
+                        "video": video_path,
+                        "audio": get_audio(video_path),
+                        "question": item["prompt"],
+                        "ground_truth": item["chosen"],
+                        "label": parse_label(video_path),
+                        "responses": [{"temperature": temp, "response": resp_text}],
+                    }
+                    item["_record"] = record
+                else:
+                    if "_record" in item:
+                        item["_record"]["responses"].append(
+                            {"temperature": temp, "response": resp_text}
+                        )
+
+            done = batch_start + len(batch)
+            print(f"  temp={temp:.1f}  done={done}/{len(todo)}")
+
+    written = 0
+    with open(OUTPUT_JSONL, "a") as f:
+        for item in todo:
+            rec = item.get("_record")
+            if rec and rec["responses"]:
+                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                written += 1
+
+    # Free preprocessed data
+    preprocessed.clear()
+
+    print(f"Done. Wrote {written} records to {OUTPUT_JSONL}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/audio_llm_benchmark.py b/sync_research/audio_llm_benchmark.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fc3ba30f6d6b13620ffa7cecf07e667c0275a24
--- /dev/null
+++ b/sync_research/audio_llm_benchmark.py
@@ -0,0 +1,1463 @@
+#!/usr/bin/env python3
+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()
+'''
diff --git a/sync_research/audio_llm_benchmark_shifted.py b/sync_research/audio_llm_benchmark_shifted.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6fdfe6fad8ffe36f8204698d80b87d430e8e2bd
--- /dev/null
+++ b/sync_research/audio_llm_benchmark_shifted.py
@@ -0,0 +1,621 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ast
+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 (
+    AutoProcessor,
+    Qwen2AudioForConditionalGeneration,
+    Qwen3OmniMoeProcessor,
+    Qwen3OmniMoeForConditionalGeneration,
+)
+from qwen_omni_utils import process_mm_info
+
+try:
+    from google import genai as google_genai
+except Exception:  # pragma: no cover
+    google_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")
+
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+QWEN2_MODEL_ID = "Qwen/Qwen2-Audio-7B-Instruct"
+QWEN3_MODEL_ID = "Qwen/Qwen3-Omni-30B-A3B-Instruct"
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Shifted audio benchmark for Gemini/Qwen2/Qwen3.")
+    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=16000)
+    p.add_argument("--audio-format", choices=["wav", "mp3"], default="wav")
+    p.add_argument("--sample-size", type=int, default=0, help="0 = use all source rows")
+    p.add_argument("--seed", type=int, default=42)
+    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))
+
+    def _parse_json_like(candidate: str) -> Dict[str, Any]:
+        obj = json.loads(candidate)
+        if isinstance(obj, str):
+            obj = json.loads(obj)
+        if not isinstance(obj, dict):
+            raise ValueError("Parsed value is not a JSON object")
+        return obj
+
+    # strict JSON first
+    try:
+        return _parse_json_like(text)
+    except Exception:
+        pass
+
+    # common Qwen escaped JSON variant: {\"audio_timestamp\": \"2.50\", ...}
+    unescaped = text.replace('\\"', '"')
+    try:
+        return _parse_json_like(unescaped)
+    except Exception:
+        pass
+
+    # parse JSON object substring if model adds extra prose
+    start = text.find("{")
+    end = text.rfind("}")
+    if start != -1 and end != -1 and end > start:
+        snippet = text[start : end + 1]
+        for candidate in (snippet, snippet.replace('\\"', '"')):
+            try:
+                return _parse_json_like(candidate)
+            except Exception:
+                continue
+        # fallback: python-dict-like output with single quotes
+        try:
+            obj = ast.literal_eval(snippet)
+            if isinstance(obj, dict):
+                return obj
+        except Exception:
+            pass
+
+    raise ValueError(f"No valid JSON object found in model output: {text[:240]}")
+
+
+def _coerce_result(data: Dict[str, Any]) -> Tuple[float, str]:
+    ts = float(data["audio_timestamp"])
+    desc = str(data["sound_description"]).strip()
+    if not np.isfinite(ts):
+        raise ValueError(f"Invalid audio_timestamp: {ts}")
+    if not desc:
+        raise ValueError("sound_description is empty")
+    return ts, desc
+
+
+def append_jsonl(path: Path, row: 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(row, ensure_ascii=False) + "\n")
+
+
+def append_jsonl_line(path: Path, row: 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(row, 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}")
+    out: 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 video_id and 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
+            out.append((video_id, t_visual))
+    if not out:
+        raise ValueError("no valid rows in source csv")
+    if sample_size > 0 and len(out) > sample_size:
+        rng = np.random.default_rng(seed)
+        idx = rng.choice(len(out), size=sample_size, replace=False)
+        out = [out[int(i)] for i in idx]
+    out.sort(key=lambda x: x[0])
+    return out
+
+
+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, out_path: Path, sr: int, fmt: str) -> None:
+    out_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(out_path))
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def gemini_infer(audio_path: Path, api_key: str) -> Tuple[float, str]:
+    if google_genai is None:
+        raise RuntimeError("google-genai is not installed (pip install google-genai)")
+    if not api_key:
+        raise RuntimeError("GEMINI_API_KEY is missing")
+    client = google_genai.Client(api_key=api_key)
+    uploaded = client.files.upload(file=str(audio_path))
+    try:
+        last_exc: Optional[Exception] = None
+        for _ in range(8):
+            try:
+                resp = client.models.generate_content(
+                    model=GEMINI_MODEL,
+                    contents=[UNIVERSAL_PROMPT, uploaded],
+                )
+                raw = (getattr(resp, "text", "") or "").strip()
+                parsed = _extract_json_object(raw)
+                return _coerce_result(parsed)
+            except Exception as exc:  # transient "file not ready" is common
+                last_exc = exc
+                time.sleep(2)
+        raise RuntimeError(f"Gemini inference failed after retries: {last_exc}")
+    finally:
+        try:
+            client.files.delete(name=uploaded.name)
+        except Exception:
+            pass
+
+
+def load_qwen2(model_id: str) -> Tuple[Any, Any]:
+    processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+    model = Qwen2AudioForConditionalGeneration.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 load_qwen3(model_id: str) -> Tuple[Any, Any]:
+    processor = Qwen3OmniMoeProcessor.from_pretrained(model_id, trust_remote_code=True)
+    model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+        model_id,
+        dtype="auto",
+        device_map="auto" if torch.cuda.is_available() else None,
+        trust_remote_code=True,
+    )
+    # Official recommendation when only text output is needed.
+    model.disable_talker()
+    model.eval()
+    return model, processor
+
+
+def qwen_infer(audio_path: Path, model: Any, processor: Any, label: str) -> Tuple[float, str]:
+    messages = [
+        {
+            "role": "user",
+            "content": [{"type": "audio", "audio": str(audio_path)}, {"type": "text", "text": UNIVERSAL_PROMPT}],
+        }
+    ]
+    try:
+        text_prompt = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    except Exception:
+        text_prompt = UNIVERSAL_PROMPT
+
+    audio_arr, sr = librosa.load(str(audio_path), sr=None, mono=True)
+    if audio_arr.size == 0:
+        raise RuntimeError(f"{label}: empty audio")
+
+    inputs = None
+    last_exc: Optional[Exception] = 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}: processor input failed: {last_exc}")
+
+    dev = model.device if hasattr(model, "device") else torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model_dtype = getattr(model, "dtype", None)
+    if model_dtype is None:
+        try:
+            model_dtype = next(model.parameters()).dtype
+        except Exception:
+            model_dtype = None
+    for k, v in list(inputs.items()):
+        if torch.is_tensor(v):
+            tensor = v.to(dev)
+            # Qwen3-Omni expects floating features to match model dtype (e.g., bfloat16 on GPU).
+            if tensor.is_floating_point() and model_dtype is not None:
+                tensor = tensor.to(model_dtype)
+            inputs[k] = tensor
+
+    with torch.no_grad():
+        out_ids = model.generate(**inputs, max_new_tokens=256, do_sample=False)
+    in_len = inputs["input_ids"].shape[1] if "input_ids" in inputs else 0
+    gen_ids = out_ids[:, in_len:] if in_len > 0 else out_ids
+    raw = processor.batch_decode(gen_ids, skip_special_tokens=True)[0].strip()
+    parsed = _extract_json_object(raw)
+    return _coerce_result(parsed)
+
+
+def qwen3_infer(audio_path: Path, model: Any, processor: Any, label: str) -> Tuple[float, str]:
+    conversation = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "audio", "audio": str(audio_path)},
+                {"type": "text", "text": UNIVERSAL_PROMPT},
+            ],
+        }
+    ]
+    text = processor.apply_chat_template(conversation, add_generation_prompt=True, tokenize=False)
+    audios, images, videos = process_mm_info(conversation, use_audio_in_video=False)
+    inputs = processor(
+        text=text,
+        audio=audios,
+        images=images,
+        videos=videos,
+        return_tensors="pt",
+        padding=True,
+        use_audio_in_video=False,
+    )
+    inputs = inputs.to(model.device).to(model.dtype)
+    with torch.no_grad():
+        out_ids = model.generate(
+            **inputs,
+            return_audio=False,
+            use_audio_in_video=False,
+            max_new_tokens=256,
+            do_sample=False,
+        )
+    in_len = inputs["input_ids"].shape[1] if "input_ids" in inputs else 0
+    gen_ids = out_ids[:, in_len:] if in_len > 0 else out_ids
+    raw = processor.batch_decode(gen_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0].strip()
+    parsed = _extract_json_object(raw)
+    return _coerce_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(rows: List[Dict[str, Any]], key: str) -> Dict[str, Any]:
+    vals = [r.get(key) for r in rows]
+    ok = [v for v in vals if v is not None]
+    errors: List[float] = []
+    for r in rows:
+        pred = r.get(key)
+        exp = r.get("expected_t_audio")
+        if pred is None or exp is None:
+            continue
+        errors.append(abs(float(pred) - float(exp)))
+    errors_sorted = sorted(errors)
+    return {
+        "count": len(rows),
+        "with_prediction": len(ok),
+        "without_prediction": len(rows) - len(ok),
+        "mae_sec": round(mean(errors), 4) if errors else None,
+        "median_like_sec": round(errors_sorted[len(errors_sorted) // 2], 4) if errors_sorted else None,
+        "within_0_3_sec": sum(1 for e in errors if e <= 0.3),
+        "within_0_5_sec": sum(1 for e in errors if e <= 0.5),
+        "within_1_0_sec": sum(1 for e in errors if e <= 1.0),
+    }
+
+
+def main() -> None:
+    args = parse_args()
+    ensure_ffmpeg()
+
+    gemini_key = os.getenv("GEMINI_API_KEY", "").strip()
+    if not gemini_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)
+
+    root = args.output_dir
+    audio_dir = root / "audio"
+    gemini_dir = root / "gemini"
+    qwen2_dir = root / "qwen2"
+    qwen3_dir = root / "qwen3"
+    for d in [audio_dir, gemini_dir, qwen2_dir, qwen3_dir]:
+        d.mkdir(parents=True, exist_ok=True)
+
+    delay_out = root / "delay_results.jsonl"
+    early_out = root / "early_results.jsonl"
+    missing_out = root / "missing_or_errors.json"
+    missing_live_out = root / "missing_or_errors.jsonl"
+    summary_out = root / "summary.json"
+    sampled_out = root / "sampled_10_from_gemini.csv"
+
+    model_files = {
+        "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_out, early_out, missing_out, missing_live_out, summary_out, sampled_out, *model_files.values()]:
+            if p.exists():
+                p.unlink()
+
+    qwen2_model = qwen2_proc = None
+    qwen3_model = qwen3_proc = None
+    qwen2_init_error: Optional[str] = None
+    qwen3_init_error: Optional[str] = None
+    if not args.disable_local_models:
+        try:
+            qwen2_model, qwen2_proc = load_qwen2(QWEN2_MODEL_ID)
+            print(f"[init] loaded Qwen2: {QWEN2_MODEL_ID}")
+        except Exception as exc:
+            qwen2_model = qwen2_proc = None
+            qwen2_init_error = str(exc)
+            print(f"[init] failed to load Qwen2: {QWEN2_MODEL_ID} | {exc}")
+        try:
+            qwen3_model, qwen3_proc = load_qwen3(QWEN3_MODEL_ID)
+            print(f"[init] loaded Qwen3: {QWEN3_MODEL_ID}")
+        except Exception as exc:
+            qwen3_model = qwen3_proc = None
+            qwen3_init_error = str(exc)
+            print(f"[init] failed to load Qwen3: {QWEN3_MODEL_ID} | {exc}")
+    else:
+        print("[init] local models disabled; running Gemini only")
+
+    with sampled_out.open("w", encoding="utf-8", newline="") as f:
+        w = csv.DictWriter(f, fieldnames=["video_id", "t_visual"])
+        w.writeheader()
+        for video_id, t_visual in source_rows:
+            w.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, combined_path in [
+            ("delay", args.delay_shift, delay_index, delay_rows, delay_out),
+            ("early", args.early_shift, early_index, early_rows, early_out),
+        ]:
+            shifted_name = shifted_filename(video_id, split)
+            video_path = idx.get(shifted_name)
+            if video_path is None:
+                err_row = {"split": split, "video_id": video_id, "reason": "file_not_found"}
+                missing.append(err_row)
+                append_jsonl_line(missing_live_out, err_row)
+                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:
+                err_row = {"split": split, "video_id": video_id, "reason": f"audio_extract_failed: {exc}"}
+                missing.append(err_row)
+                append_jsonl_line(missing_live_out, err_row)
+                continue
+
+            gemini_res, gemini_err = safe_call(gemini_infer, audio_path, gemini_key)
+            qwen2_res = qwen2_err = None
+            qwen3_res = qwen3_err = None
+            if qwen2_model is not None and qwen2_proc is not None:
+                qwen2_res, qwen2_err = safe_call(qwen_infer, audio_path, qwen2_model, qwen2_proc, "Qwen2")
+            else:
+                qwen2_err = f"model_unavailable: {qwen2_init_error or 'load_failed_or_disabled'}"
+            if qwen3_model is not None and qwen3_proc is not None:
+                qwen3_res, qwen3_err = safe_call(qwen3_infer, audio_path, qwen3_model, qwen3_proc, "Qwen3")
+            else:
+                qwen3_err = f"model_unavailable: {qwen3_init_error or 'load_failed_or_disabled'}"
+
+            if gemini_err:
+                err_row = {"split": split, "video_id": video_id, "reason": f"gemini_error: {gemini_err}"}
+                missing.append(err_row)
+                append_jsonl_line(missing_live_out, err_row)
+            if qwen2_err:
+                err_row = {"split": split, "video_id": video_id, "reason": f"qwen2_error: {qwen2_err}"}
+                missing.append(err_row)
+                append_jsonl_line(missing_live_out, err_row)
+            if qwen3_err:
+                err_row = {"split": split, "video_id": video_id, "reason": f"qwen3_error: {qwen3_err}"}
+                missing.append(err_row)
+                append_jsonl_line(missing_live_out, err_row)
+
+            expected_t = float(t_visual) + float(shift)
+            gemini_abs_error = abs(gemini_res[0] - expected_t) if gemini_res else None
+            qwen2_abs_error = abs(qwen2_res[0] - expected_t) if qwen2_res else None
+            qwen3_abs_error = abs(qwen3_res[0] - expected_t) if qwen3_res else None
+            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,
+                "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_abs_error_sec": round(gemini_abs_error, 3) if gemini_abs_error is not None else None,
+                "qwen2_abs_error_sec": round(qwen2_abs_error, 3) if qwen2_abs_error is not None else None,
+                "qwen3_abs_error_sec": round(qwen3_abs_error, 3) if qwen3_abs_error is not None 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,
+                "gemini_error": gemini_err,
+                "qwen2_error": qwen2_err,
+                "qwen3_error": qwen3_err,
+                "audio_path": str(audio_path),
+            }
+            append_jsonl(combined_path, row)
+            combined.append(row)
+
+            append_jsonl(
+                model_files[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,
+                    "detected_t_audio": round(gemini_res[0], 3) if gemini_res else None,
+                    "abs_error_sec": round(gemini_abs_error, 3) if gemini_abs_error is not None else None,
+                    "sound_description": gemini_res[1] if gemini_res else None,
+                    "audio_path": str(audio_path),
+                },
+            )
+            append_jsonl(
+                model_files[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,
+                    "detected_t_audio": round(qwen2_res[0], 3) if qwen2_res else None,
+                    "abs_error_sec": round(qwen2_abs_error, 3) if qwen2_abs_error is not None else None,
+                    "sound_description": qwen2_res[1] if qwen2_res else None,
+                    "audio_path": str(audio_path),
+                },
+            )
+            append_jsonl(
+                model_files[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,
+                    "detected_t_audio": round(qwen3_res[0], 3) if qwen3_res else None,
+                    "abs_error_sec": round(qwen3_abs_error, 3) if qwen3_abs_error is not None else None,
+                    "sound_description": qwen3_res[1] if qwen3_res else None,
+                    "audio_path": str(audio_path),
+                },
+            )
+
+    with missing_out.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(delay_rows, "gemini_t"),
+            "qwen2": summarize(delay_rows, "qwen2_t"),
+            "qwen3": summarize(delay_rows, "qwen3_t"),
+        },
+        "early_summary": {
+            "count": len(early_rows),
+            "gemini": summarize(early_rows, "gemini_t"),
+            "qwen2": summarize(early_rows, "qwen2_t"),
+            "qwen3": summarize(early_rows, "qwen3_t"),
+        },
+        "missing_or_errors_count": len(missing),
+        "outputs": {
+            "delay_jsonl": str(delay_out),
+            "early_jsonl": str(early_out),
+            "missing_or_errors_json": str(missing_out),
+            "sampled_csv": str(sampled_out),
+            "audio_dir": str(audio_dir),
+            "gemini_dir": str(gemini_dir),
+            "qwen2_dir": str(qwen2_dir),
+            "qwen3_dir": str(qwen3_dir),
+        },
+    }
+    with summary_out.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_out}")
+    print("================================================")
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/sync_research/batch_shift_videos.py b/sync_research/batch_shift_videos.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee7e995b67ddd434cd9875bd6f5637dac2f6e9fb
--- /dev/null
+++ b/sync_research/batch_shift_videos.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+from pathlib import Path
+
+
+VIDEO_EXTS = {".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"}
+
+
+def run_cmd(cmd):
+    return subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def get_duration_seconds(video_path: Path) -> float:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        str(video_path),
+    ]
+    out = run_cmd(cmd).stdout.strip()
+    return float(out)
+
+
+def has_audio_stream(video_path: Path) -> bool:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "a:0",
+        "-show_entries",
+        "stream=index",
+        "-of",
+        "csv=p=0",
+        str(video_path),
+    ]
+    out = run_cmd(cmd).stdout.strip()
+    return bool(out)
+
+
+def make_delay_plus_2s(src: Path, dst: Path, duration: float):
+    # Delay audio by 2s; keep final duration unchanged.
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a:0",
+        "-c:v",
+        "copy",
+        "-af",
+        f"adelay=2000:all=1,atrim=0:{duration}",
+        "-c:a",
+        "aac",
+        str(dst),
+    ]
+    run_cmd(cmd)
+
+
+def make_advance_minus_2s(src: Path, dst: Path, duration: float):
+    # Advance audio by 2s; the last 2s become silence.
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a:0",
+        "-c:v",
+        "copy",
+        "-af",
+        f"atrim=start=2,asetpts=PTS-STARTPTS,apad=pad_dur=2,atrim=0:{duration}",
+        "-c:a",
+        "aac",
+        str(dst),
+    ]
+    run_cmd(cmd)
+
+
+def iter_videos(root: Path):
+    for dirpath, _, filenames in os.walk(root):
+        for name in filenames:
+            p = Path(dirpath) / name
+            if p.suffix.lower() in VIDEO_EXTS:
+                yield p
+
+
+def purge_directory(root: Path):
+    if not root.exists():
+        return
+    for dirpath, _, filenames in os.walk(root):
+        for name in filenames:
+            (Path(dirpath) / name).unlink()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate +2s delay and -2s advance audio versions for all videos."
+    )
+    parser.add_argument(
+        "--input-dir",
+        default="/home/ubuntu/uag_oops_data/uag_oops",
+        help="Source video directory.",
+    )
+    parser.add_argument(
+        "--out-delay-dir",
+        default="/home/ubuntu/uag_oops_data/delay",
+        help="Output directory for +2s delay versions.",
+    )
+    parser.add_argument(
+        "--out-advance-dir",
+        default="/home/ubuntu/uag_oops_data/early",
+        help="Output directory for -2s advance versions.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite output if file exists.",
+    )
+    parser.add_argument(
+        "--no-purge-output",
+        action="store_true",
+        help="Do not purge output directories before generation.",
+    )
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir)
+    out_delay_dir = Path(args.out_delay_dir)
+    out_advance_dir = Path(args.out_advance_dir)
+
+    if not input_dir.exists():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+
+    videos = sorted(iter_videos(input_dir))
+    if not videos:
+        print(f"No videos found in: {input_dir}")
+        return
+
+    out_delay_dir.mkdir(parents=True, exist_ok=True)
+    out_advance_dir.mkdir(parents=True, exist_ok=True)
+    purge_output = not args.no_purge_output
+    if purge_output:
+        print("Purging output directories first...")
+        purge_directory(out_delay_dir)
+        purge_directory(out_advance_dir)
+
+    print(f"Found {len(videos)} videos.")
+    skipped_no_audio = 0
+    processed = 0
+
+    for idx, src in enumerate(videos, start=1):
+        rel = src.relative_to(input_dir)
+        delay_name = f"{rel.stem}_delay2s{rel.suffix}"
+        advance_name = f"{rel.stem}_early2s{rel.suffix}"
+        dst_delay = out_delay_dir / rel.parent / delay_name
+        dst_advance = out_advance_dir / rel.parent / advance_name
+        dst_delay.parent.mkdir(parents=True, exist_ok=True)
+        dst_advance.parent.mkdir(parents=True, exist_ok=True)
+
+        if (not args.overwrite) and dst_delay.exists() and dst_advance.exists():
+            print(f"[{idx}/{len(videos)}] Skip existing: {rel}")
+            continue
+
+        if not has_audio_stream(src):
+            skipped_no_audio += 1
+            print(f"[{idx}/{len(videos)}] Skip no-audio: {rel}")
+            continue
+
+        duration = get_duration_seconds(src)
+        print(f"[{idx}/{len(videos)}] Processing: {rel}")
+        try:
+            if args.overwrite or not dst_delay.exists():
+                make_delay_plus_2s(src, dst_delay, duration)
+            if args.overwrite or not dst_advance.exists():
+                make_advance_minus_2s(src, dst_advance, duration)
+            processed += 1
+        except subprocess.CalledProcessError as exc:
+            print(f"  Failed: {rel}")
+            print(exc.stderr[-500:])
+
+    print("\nDone.")
+    print(f"Processed videos: {processed}")
+    print(f"Skipped no-audio: {skipped_no_audio}")
+    print(f"Delay output dir: {out_delay_dir}")
+    print(f"Advance output dir: {out_advance_dir}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/hpss_audio_stress_test.py b/sync_research/hpss_audio_stress_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7030c54ee26521dcde00d476e383b02f5860047
--- /dev/null
+++ b/sync_research/hpss_audio_stress_test.py
@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+"""
+HPSS Audio Stress Test on shifted datasets.
+
+Workflow:
+1) Read random samples from a CSV that contains `video_id` and `t_gemini`.
+2) For each sampled video_id, locate corresponding videos under delay/early folders.
+3) Run HPSS onset detection in [t_gemini - 3, t_gemini + 3].
+4) Compare with expected shifted audio timestamps:
+   - delay: t_gemini + 2.0
+   - early: t_gemini - 2.0
+5) Save detailed results and summary to an output folder.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import random
+from pathlib import Path
+from statistics import mean
+from typing import Any, Dict, List, Optional, Tuple
+
+import librosa
+import numpy as np
+
+
+WINDOW_SECONDS = 3.0
+CONTEXT_PAD_SECONDS = 0.6
+HOP_LENGTH = 512
+PEAK_PRE_MAX = 3
+PEAK_POST_MAX = 3
+PEAK_PRE_AVG = 3
+PEAK_POST_AVG = 5
+PEAK_DELTA = 0.5
+PEAK_WAIT = 10
+
+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/shifted_hpss_test")
+
+
+def detect_audio_hpss_peak(
+    shifted_video: Path,
+    t_visual: float,
+    window_seconds: float = WINDOW_SECONDS,
+) -> Optional[float]:
+    """
+    Detect the most likely impact audio timestamp near t_visual using HPSS + onset.
+
+    Steps:
+    1) Extract audio segment in [t_visual - window, t_visual + window]
+    2) Apply HPSS and keep percussive component
+    3) Compute onset strength
+    4) Peak pick onset envelope
+    5) If multiple peaks, choose peak with highest onset strength
+    6) Return absolute video timestamp, else None
+    """
+    seg_start = max(0.0, float(t_visual) - float(window_seconds))
+    seg_end = seg_start + 2.0 * float(window_seconds)
+
+    # Load a wider chunk to reduce artificial onset spikes at hard segment boundaries.
+    load_start = max(0.0, seg_start - CONTEXT_PAD_SECONDS)
+    load_duration = (seg_end - load_start) + CONTEXT_PAD_SECONDS
+
+    y, sr = librosa.load(
+        str(shifted_video),
+        sr=None,
+        mono=True,
+        offset=load_start,
+        duration=load_duration,
+    )
+    if y.size == 0:
+        return None
+
+    _, y_percussive = librosa.effects.hpss(y)
+    onset_env = librosa.onset.onset_strength(y=y_percussive, sr=sr, hop_length=HOP_LENGTH)
+    if onset_env.size == 0:
+        return None
+
+    peaks = librosa.util.peak_pick(
+        onset_env,
+        pre_max=PEAK_PRE_MAX,
+        post_max=PEAK_POST_MAX,
+        pre_avg=PEAK_PRE_AVG,
+        post_avg=PEAK_POST_AVG,
+        delta=PEAK_DELTA,
+        wait=PEAK_WAIT,
+    )
+    if len(peaks) == 0:
+        return None
+
+    peak_times_local = librosa.frames_to_time(peaks, sr=sr, hop_length=HOP_LENGTH)
+    peak_times_abs = load_start + peak_times_local
+
+    # Keep only peaks that fall inside the target test window [t_visual-3, t_visual+3].
+    in_window_mask = (peak_times_abs >= seg_start) & (peak_times_abs <= seg_end)
+    if not np.any(in_window_mask):
+        return None
+
+    peaks_in_window = peaks[in_window_mask]
+    strengths_in_window = onset_env[peaks_in_window]
+    best_idx = int(np.argmax(strengths_in_window))
+    best_peak_frame = int(peaks_in_window[best_idx])
+    best_peak_time_local = float(
+        librosa.frames_to_time(best_peak_frame, sr=sr, hop_length=HOP_LENGTH)
+    )
+    detected_t_audio = load_start + best_peak_time_local
+    return float(detected_t_audio)
+
+
+def evaluate_single_video(shifted_video: Path, t_visual: float, shift_amount: float) -> Dict[str, Any]:
+    expected_t_audio = float(t_visual) + float(shift_amount)
+    detected_t_audio = detect_audio_hpss_peak(shifted_video=shifted_video, t_visual=t_visual)
+
+    if detected_t_audio is None:
+        abs_error = None
+        detected_str = "None"
+        error_str = "None"
+    else:
+        abs_error = abs(detected_t_audio - expected_t_audio)
+        detected_str = f"{detected_t_audio:.3f}"
+        error_str = f"{abs_error:.3f}"
+
+    print(
+        f"Video: {shifted_video.name} | "
+        f"t_visual: {float(t_visual):.3f} | "
+        f"Detected Audio: {detected_str} | "
+        f"Expected Audio: {expected_t_audio:.3f} | "
+        f"Error: {error_str} sec"
+    )
+
+    return {
+        "video_path": str(shifted_video),
+        "video_id": shifted_video.name,
+        "t_visual": float(t_visual),
+        "shift_amount": float(shift_amount),
+        "expected_t_audio": expected_t_audio,
+        "detected_t_audio": detected_t_audio,
+        "abs_error_sec": abs_error,
+    }
+
+
+def read_candidates(csv_path: Path) -> List[Tuple[str, float]]:
+    if not csv_path.exists():
+        raise FileNotFoundError(f"CSV not found: {csv_path}")
+
+    rows: List[Tuple[str, float]] = []
+    with csv_path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        if "video_id" not in (reader.fieldnames or []) or "t_gemini" not in (reader.fieldnames or []):
+            raise ValueError("CSV must contain columns: video_id, t_gemini")
+
+        for item in reader:
+            video_id = str(item.get("video_id", "")).strip()
+            if not video_id:
+                continue
+            try:
+                t_gemini = float(item.get("t_gemini", ""))
+            except (TypeError, ValueError):
+                continue
+            rows.append((video_id, t_gemini))
+    if not rows:
+        raise ValueError(f"No valid rows found in CSV: {csv_path}")
+    return rows
+
+
+def index_by_filename(root: Path) -> Dict[str, Path]:
+    if not root.exists():
+        raise FileNotFoundError(f"Directory not found: {root}")
+    mapping: Dict[str, Path] = {}
+    duplicates: List[str] = []
+    for p in root.rglob("*.mp4"):
+        name = p.name
+        if name in mapping:
+            duplicates.append(name)
+            continue
+        mapping[name] = p
+    if duplicates:
+        print(f"Warning: duplicate filenames in {root}, using first occurrence for {len(duplicates)} entries.")
+    return mapping
+
+
+def shifted_filename_from_video_id(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 write_jsonl(path: Path, rows: List[Dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+def summarize_errors(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    errors = [float(r["abs_error_sec"]) for r in rows if r.get("abs_error_sec") is not None]
+    return {
+        "count": len(rows),
+        "with_detection": len(errors),
+        "without_detection": len(rows) - len(errors),
+        "mae_sec": round(mean(errors), 4) if errors else None,
+        "median_like_sec": round(sorted(errors)[len(errors) // 2], 4) if errors else None,
+        "within_0_3_sec": sum(1 for e in errors if e <= 0.3),
+        "within_0_5_sec": sum(1 for e in errors if e <= 0.5),
+        "within_1_0_sec": sum(1 for e in errors if e <= 1.0),
+    }
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Run HPSS stress test on random Gemini-accepted samples.")
+    parser.add_argument(
+        "--source-csv",
+        type=Path,
+        default=DEFAULT_SOURCE_CSV,
+        help="CSV containing at least video_id,t_gemini",
+    )
+    parser.add_argument(
+        "--delay-dir",
+        type=Path,
+        default=DEFAULT_DELAY_DIR,
+        help="Directory containing delay (+2s) shifted videos",
+    )
+    parser.add_argument(
+        "--early-dir",
+        type=Path,
+        default=DEFAULT_EARLY_DIR,
+        help="Directory containing early (-2s) shifted videos",
+    )
+    parser.add_argument(
+        "--sample-size",
+        type=int,
+        default=10,
+        help="How many random videos to evaluate from source CSV",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=DEFAULT_OUTPUT_DIR,
+        help="Output folder for detailed results and summary",
+    )
+    parser.add_argument(
+        "--delay-shift",
+        type=float,
+        default=2.0,
+        help="Expected shift amount for delay set",
+    )
+    parser.add_argument(
+        "--early-shift",
+        type=float,
+        default=-2.0,
+        help="Expected shift amount for early set",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    candidates = read_candidates(args.source_csv)
+    rng = random.Random(args.seed)
+    if len(candidates) <= args.sample_size:
+        sampled = candidates
+    else:
+        sampled = rng.sample(candidates, args.sample_size)
+    sampled.sort(key=lambda x: x[0])
+
+    delay_index = index_by_filename(args.delay_dir)
+    early_index = index_by_filename(args.early_dir)
+
+    delay_results: List[Dict[str, Any]] = []
+    early_results: List[Dict[str, Any]] = []
+    missing_rows: List[Dict[str, Any]] = []
+
+    print(f"Sampled {len(sampled)} videos from CSV: {args.source_csv}")
+    for video_id, t_gemini in sampled:
+        delay_path = delay_index.get(video_id)
+        early_path = early_index.get(video_id)
+        if delay_path is None:
+            delay_path = delay_index.get(shifted_filename_from_video_id(video_id, "delay"))
+        if early_path is None:
+            early_path = early_index.get(shifted_filename_from_video_id(video_id, "early"))
+
+        if delay_path is None:
+            missing_rows.append({"split": "delay", "video_id": video_id, "reason": "file_not_found"})
+        else:
+            try:
+                delay_results.append(evaluate_single_video(delay_path, t_gemini, args.delay_shift))
+            except Exception as exc:
+                missing_rows.append(
+                    {"split": "delay", "video_id": video_id, "reason": f"exception: {exc}"}
+                )
+
+        if early_path is None:
+            missing_rows.append({"split": "early", "video_id": video_id, "reason": "file_not_found"})
+        else:
+            try:
+                early_results.append(evaluate_single_video(early_path, t_gemini, args.early_shift))
+            except Exception as exc:
+                missing_rows.append(
+                    {"split": "early", "video_id": video_id, "reason": f"exception: {exc}"}
+                )
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    sampled_csv = args.output_dir / "sampled_10_from_gemini.csv"
+    with sampled_csv.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["video_id", "t_gemini"])
+        writer.writeheader()
+        for video_id, t_gemini in sampled:
+            writer.writerow({"video_id": video_id, "t_gemini": round(float(t_gemini), 3)})
+
+    delay_jsonl = args.output_dir / "delay_results.jsonl"
+    early_jsonl = args.output_dir / "early_results.jsonl"
+    write_jsonl(delay_jsonl, delay_results)
+    write_jsonl(early_jsonl, early_results)
+
+    missing_json = args.output_dir / "missing_or_errors.json"
+    with missing_json.open("w", encoding="utf-8") as f:
+        json.dump(missing_rows, f, ensure_ascii=False, indent=2)
+
+    summary = {
+        "source_csv": str(args.source_csv),
+        "sample_size": len(sampled),
+        "seed": args.seed,
+        "window_seconds": WINDOW_SECONDS,
+        "delay_shift": args.delay_shift,
+        "early_shift": args.early_shift,
+        "delay_summary": summarize_errors(delay_results),
+        "early_summary": summarize_errors(early_results),
+        "missing_or_errors_count": len(missing_rows),
+        "outputs": {
+            "sampled_csv": str(sampled_csv),
+            "delay_jsonl": str(delay_jsonl),
+            "early_jsonl": str(early_jsonl),
+            "missing_or_errors_json": str(missing_json),
+        },
+    }
+    summary_json = args.output_dir / "summary.json"
+    with summary_json.open("w", encoding="utf-8") as f:
+        json.dump(summary, f, ensure_ascii=False, indent=2)
+
+    print("========== HPSS Shifted Test Summary ==========")
+    print(f"Sampled videos: {len(sampled)}")
+    print(f"Delay evaluated: {len(delay_results)}")
+    print(f"Early evaluated: {len(early_results)}")
+    print(f"Missing/errors: {len(missing_rows)}")
+    print(f"Summary JSON: {summary_json}")
+    print("===============================================")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/main_gemini_openai_hpss.py b/sync_research/main_gemini_openai_hpss.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a6667f4b6aa095e735efcc6c6aba37016a440c6
--- /dev/null
+++ b/sync_research/main_gemini_openai_hpss.py
@@ -0,0 +1,466 @@
+#!/usr/bin/env python3
+import base64
+import json
+import logging
+import os
+import re
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import cv2
+import librosa
+import numpy as np
+import google.generativeai as genai
+from openai import OpenAI
+
+
+# =========================
+# Fill your API keys here (optional if using env vars)
+# =========================
+OPENAI_API_KEY = ""
+GEMINI_API_KEY = ""
+
+
+# =========================
+# Config
+# =========================
+INPUT_DIR = Path("/home/ubuntu/video/sample")
+OUTPUT_DIR = Path("/home/ubuntu/video/pilot_100_results/result5.4_prompt1")
+MUTED_DIR = Path("/home/ubuntu/video/pilot_100_results/muted_originals")
+VERIFIED_JSONL = OUTPUT_DIR / "verified_timestamps.jsonl"
+NEEDS_REVIEW_TXT = OUTPUT_DIR / "needs_review.txt"
+INVALID_AUDIO_TXT = OUTPUT_DIR / "invalid_audio.txt"
+VISUAL_CANDIDATES_JSON = OUTPUT_DIR / "visual_candidates.json"
+
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+OPENAI_MODEL = "gpt-5.4"
+# OPENAI_MODEL = "gpt-5.1-2025-11-13"
+# OPENAI_MODEL = "gpt-5.2-2025-12-11"
+
+MAX_RETRIES = 3
+RETRY_BASE_SECONDS = 2.0
+VISUAL_DIFF_THRESHOLD = 0.5
+VISUAL_WINDOW_SECONDS = 1.0
+GEMINI_FILE_READY_TIMEOUT_SECONDS = 120
+GEMINI_FILE_POLL_SECONDS = 2
+
+HOP_LENGTH = 512
+PEAK_PRE_MAX = 3
+PEAK_POST_MAX = 3
+PEAK_PRE_AVG = 3
+PEAK_POST_AVG = 5
+PEAK_DELTA = 0.5
+PEAK_WAIT = 10
+
+VISUAL_PROMPT = """You are an expert in physics and video forensics. Carefully analyze this muted video to find the exact moment a high-energy physical event occurs (e.g., a hard fall, a collision, something breaking).
+You must output strictly in JSON format with the following keys:
+{
+  "visual_timestamp": 2.5,
+  "event_description": "Brief description of the impact"
+}"""
+
+# VISUAL_PROMPT = """You are an expert in video forensics. Your task is to locate the timestamp of MAXIMUM PHYSICAL IMPACT (e.g., the precise fraction of a second a person hits the ground, two cars collide, or an object breaks).
+
+# CRITICAL INSTRUCTIONS:
+# 1. DO NOT report the time when the accident begins or when someone starts to lose balance.
+# 2. We strictly need the final collision frame that would generate a loud physical sound.
+# 3. If there are multiple impacts, report the timestamp of the hardest, most energetic one.
+
+# Output strictly in JSON format:
+# {
+#   "visual_timestamp": 2.5,
+#   "event_description": "Brief description of the impact"
+# }"""
+@dataclass
+class VisualResult:
+    visual_timestamp: float
+    event_description: str
+
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+    )
+
+
+def ensure_ffmpeg() -> None:
+    try:
+        subprocess.run(
+            ["ffmpeg", "-version"],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+    except Exception as exc:
+        raise RuntimeError("ffmpeg not found. Please install ffmpeg first.") from exc
+
+
+def validate_api_keys() -> None:
+    global OPENAI_API_KEY, GEMINI_API_KEY
+    # Prefer environment variables; fallback to hardcoded values.
+    OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", OPENAI_API_KEY).strip()
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", GEMINI_API_KEY).strip()
+
+    if not OPENAI_API_KEY or not GEMINI_API_KEY:
+        raise ValueError(
+            "Missing API keys. Set OPENAI_API_KEY and GEMINI_API_KEY via "
+            "environment variables (recommended) or at the top of main.py."
+        )
+
+
+def extract_muted_video(input_video: Path, output_video: Path) -> None:
+    output_video.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(input_video),
+        "-an",
+        "-c:v",
+        "copy",
+        str(output_video),
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def with_retries(fn, *args, **kwargs):
+    last_exc = None
+    for attempt in range(1, MAX_RETRIES + 1):
+        try:
+            return fn(*args, **kwargs)
+        except Exception as exc:
+            last_exc = exc
+            if attempt < MAX_RETRIES:
+                wait_s = RETRY_BASE_SECONDS * (2 ** (attempt - 1))
+                logging.warning(
+                    "Attempt %s/%s failed: %s. Retrying in %.1fs...",
+                    attempt,
+                    MAX_RETRIES,
+                    exc,
+                    wait_s,
+                )
+                time.sleep(wait_s)
+            else:
+                logging.warning(
+                    "Attempt %s/%s failed: %s. No retries left.",
+                    attempt,
+                    MAX_RETRIES,
+                    exc,
+                )
+    raise RuntimeError(f"All retry attempts failed. Last error: {last_exc}")
+
+
+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_visual_result(data: Dict[str, Any]) -> VisualResult:
+    if "visual_timestamp" not in data or "event_description" not in data:
+        raise ValueError(f"Missing required keys in JSON output: {data}")
+    ts = float(data["visual_timestamp"])
+    desc = str(data["event_description"]).strip()
+    if not np.isfinite(ts):
+        raise ValueError(f"visual_timestamp is not finite: {ts}")
+    if not desc:
+        raise ValueError("event_description is empty.")
+    return VisualResult(visual_timestamp=ts, event_description=desc)
+
+
+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(
+        f"Gemini file did not become ACTIVE within {GEMINI_FILE_READY_TIMEOUT_SECONDS}s."
+    )
+
+
+def gemini_visual_grounding(muted_video: Path) -> VisualResult:
+    genai.configure(api_key=GEMINI_API_KEY)
+    model = genai.GenerativeModel(GEMINI_MODEL)
+
+    uploaded = genai.upload_file(path=str(muted_video))
+    try:
+        wait_for_gemini_file_active(uploaded.name)
+        resp = model.generate_content([VISUAL_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_visual_result(parsed)
+    finally:
+        try:
+            genai.delete_file(uploaded.name)
+        except Exception:
+            logging.warning("Could not delete Gemini uploaded file: %s", uploaded.name)
+
+
+def video_frames_to_base64_jpegs(video_path: Path, target_fps: float = 1.0) -> List[str]:
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        raise RuntimeError(f"Could not open video: {video_path}")
+
+    source_fps = cap.get(cv2.CAP_PROP_FPS)
+    if not source_fps or source_fps <= 0:
+        source_fps = 30.0
+
+    frame_interval = max(int(round(source_fps / target_fps)), 1)
+
+    frames_b64: List[str] = []
+    frame_idx = 0
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        if frame_idx % frame_interval == 0:
+            ok_enc, buffer = cv2.imencode(".jpg", frame)
+            if ok_enc:
+                frames_b64.append(base64.b64encode(buffer.tobytes()).decode("utf-8"))
+        frame_idx += 1
+
+    cap.release()
+    if not frames_b64:
+        raise RuntimeError(f"No frames extracted from video: {video_path}")
+    return frames_b64
+
+
+def openai_visual_grounding(muted_video: Path, client: OpenAI) -> VisualResult:
+    image_b64_list = video_frames_to_base64_jpegs(muted_video, target_fps=1.0)
+    content: List[Dict[str, Any]] = [{"type": "input_text", "text": VISUAL_PROMPT}]
+
+    for b64_img in image_b64_list:
+        content.append(
+            {
+                "type": "input_image",
+                "image_url": f"data:image/jpeg;base64,{b64_img}",
+            }
+        )
+
+    response = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role": "user", "content": content}],
+    )
+    raw_text = getattr(response, "output_text", "") or ""
+    if not raw_text:
+        raise ValueError("OpenAI response text is empty.")
+
+    parsed = _extract_json_object(raw_text)
+    return _coerce_visual_result(parsed)
+
+
+def arbitrate_visual(
+    gemini_result: VisualResult,
+    openai_result: VisualResult,
+) -> Optional[Tuple[float, str]]:
+    diff = abs(gemini_result.visual_timestamp - openai_result.visual_timestamp)
+    if diff <= VISUAL_DIFF_THRESHOLD:
+        t_visual = (gemini_result.visual_timestamp + openai_result.visual_timestamp) / 2.0
+        event_desc = gemini_result.event_description
+        return t_visual, event_desc
+    return None
+
+
+def detect_audio_timestamp(video_path: Path, t_visual: float) -> Optional[float]:
+    seg_start = max(0.0, t_visual - VISUAL_WINDOW_SECONDS)
+    seg_duration = 2.0 * VISUAL_WINDOW_SECONDS
+
+    y, sr = librosa.load(
+        str(video_path),
+        sr=None,
+        mono=True,
+        offset=seg_start,
+        duration=seg_duration,
+    )
+    if y.size == 0:
+        return None
+
+    _, y_percussive = librosa.effects.hpss(y)
+    onset_env = librosa.onset.onset_strength(y=y_percussive, sr=sr, hop_length=HOP_LENGTH)
+
+    peaks = librosa.util.peak_pick(
+        onset_env,
+        pre_max=PEAK_PRE_MAX,
+        post_max=PEAK_POST_MAX,
+        pre_avg=PEAK_PRE_AVG,
+        post_avg=PEAK_POST_AVG,
+        delta=PEAK_DELTA,
+        wait=PEAK_WAIT,
+    )
+    if len(peaks) == 0:
+        return None
+
+    peak_times_local = librosa.frames_to_time(peaks, sr=sr, hop_length=HOP_LENGTH)
+    peak_times_abs = seg_start + peak_times_local
+    closest_idx = int(np.argmin(np.abs(peak_times_abs - t_visual)))
+    return float(peak_times_abs[closest_idx])
+
+
+def append_line(path: Path, text: str) -> None:
+    with path.open("a", encoding="utf-8") as f:
+        f.write(text + "\n")
+
+
+def append_jsonl(path: Path, payload: Dict[str, Any]) -> None:
+    with path.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def write_json(path: Path, payload: Any) -> None:
+    with path.open("w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+
+
+def process_video(video_path: Path, openai_client: OpenAI) -> Dict[str, Any]:
+    logging.info("Processing video: %s", video_path.name)
+    visual_record: Dict[str, Any] = {
+        "video_id": video_path.name,
+        "gemini_timestamp": None,
+        "openai_timestamp": None,
+        "difference_seconds": None,
+        "t_visual": None,
+        "event": None,
+        "status": "started",
+        "reason": None,
+    }
+
+    muted_path = MUTED_DIR / video_path.name
+    try:
+        extract_muted_video(video_path, muted_path)
+    except Exception as exc:
+        logging.error("Muted extraction failed for %s: %s", video_path.name, exc)
+        append_line(NEEDS_REVIEW_TXT, video_path.name)
+        visual_record["status"] = "needs_review"
+        visual_record["reason"] = f"muted_extraction_failed: {exc}"
+        return visual_record
+
+    try:
+        gemini_result = with_retries(gemini_visual_grounding, muted_path)
+        openai_result = with_retries(openai_visual_grounding, muted_path, openai_client)
+        visual_record["gemini_timestamp"] = round(float(gemini_result.visual_timestamp), 3)
+        visual_record["openai_timestamp"] = round(float(openai_result.visual_timestamp), 3)
+        visual_record["difference_seconds"] = round(
+            abs(gemini_result.visual_timestamp - openai_result.visual_timestamp), 3
+        )
+        logging.info(
+            "Visual candidates | Gemini: %.3f, OpenAI: %.3f",
+            gemini_result.visual_timestamp,
+            openai_result.visual_timestamp,
+        )
+    except Exception as exc:
+        logging.error("Visual grounding failed for %s: %s", video_path.name, exc)
+        append_line(NEEDS_REVIEW_TXT, video_path.name)
+        visual_record["status"] = "needs_review"
+        visual_record["reason"] = f"visual_grounding_failed: {exc}"
+        return visual_record
+
+    arbitration = arbitrate_visual(gemini_result, openai_result)
+    if arbitration is None:
+        logging.warning(
+            "Visual arbitration rejected %s (difference > %.2fs).",
+            video_path.name,
+            VISUAL_DIFF_THRESHOLD,
+        )
+        append_line(NEEDS_REVIEW_TXT, video_path.name)
+        visual_record["status"] = "needs_review"
+        visual_record["reason"] = "visual_arbitration_rejected"
+        return visual_record
+
+    t_visual, event_desc = arbitration
+    visual_record["t_visual"] = round(float(t_visual), 3)
+    visual_record["event"] = event_desc
+    logging.info("Accepted t_visual=%.3f | event=%s", t_visual, event_desc)
+
+    try:
+        t_audio = detect_audio_timestamp(video_path, t_visual)
+    except Exception as exc:
+        logging.error("Audio processing failed for %s: %s", video_path.name, exc)
+        append_line(INVALID_AUDIO_TXT, video_path.name)
+        visual_record["status"] = "invalid_audio"
+        visual_record["reason"] = f"audio_processing_failed: {exc}"
+        return visual_record
+
+    if t_audio is None:
+        logging.warning("No valid audio peaks for %s.", video_path.name)
+        append_line(INVALID_AUDIO_TXT, video_path.name)
+        visual_record["status"] = "invalid_audio"
+        visual_record["reason"] = "no_audio_peaks_found"
+        return visual_record
+
+    row = {
+        "video_id": video_path.name,
+        "event": event_desc,
+        "t_visual": round(float(t_visual), 3),
+        "t_audio": round(float(t_audio), 3),
+    }
+    append_jsonl(VERIFIED_JSONL, row)
+    logging.info("Saved verified sample: %s", row)
+    visual_record["status"] = "verified"
+    visual_record["reason"] = None
+    return visual_record
+
+
+def main() -> None:
+    setup_logging()
+    validate_api_keys()
+    ensure_ffmpeg()
+
+    if not INPUT_DIR.exists():
+        raise FileNotFoundError(f"Input folder not found: {INPUT_DIR}")
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    MUTED_DIR.mkdir(parents=True, exist_ok=True)
+
+    openai_client = OpenAI(api_key=OPENAI_API_KEY)
+    videos = sorted(INPUT_DIR.glob("*.mp4"))
+    if not videos:
+        logging.warning("No .mp4 files found in %s", INPUT_DIR)
+        return
+
+    visual_records: List[Dict[str, Any]] = []
+    logging.info("Found %d videos. Starting pipeline...", len(videos))
+    for idx, video in enumerate(videos, start=1):
+        logging.info("=== [%d/%d] %s ===", idx, len(videos), video.name)
+        visual_records.append(process_video(video, openai_client))
+
+    write_json(VISUAL_CANDIDATES_JSON, visual_records)
+
+    logging.info("Pipeline complete.")
+    logging.info("Verified output: %s", VERIFIED_JSONL.resolve())
+    logging.info("Needs review log: %s", NEEDS_REVIEW_TXT.resolve())
+    logging.info("Invalid audio log: %s", INVALID_AUDIO_TXT.resolve())
+    logging.info("Visual candidates json: %s", VISUAL_CANDIDATES_JSON.resolve())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/mute_all_oops_videos.py b/sync_research/mute_all_oops_videos.py
new file mode 100644
index 0000000000000000000000000000000000000000..64e1a53caacb266bb9c44290744bec26c4272703
--- /dev/null
+++ b/sync_research/mute_all_oops_videos.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+import logging
+import subprocess
+from pathlib import Path
+from typing import List, Tuple
+
+
+SOURCE_DIR = Path("/home/ubuntu/video_source/original/uag_oops")
+MUTED_DIR = Path("/home/ubuntu/video_source/muted_original")
+
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s | %(levelname)s | %(message)s",
+    )
+
+
+def ensure_ffmpeg() -> None:
+    subprocess.run(
+        ["ffmpeg", "-version"],
+        check=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+    )
+
+
+def mute_video(src: Path, dst: Path) -> None:
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-an",
+        "-c:v",
+        "copy",
+        str(dst),
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def collect_videos(root: Path) -> List[Path]:
+    return sorted(root.rglob("*.mp4"))
+
+
+def main() -> None:
+    setup_logging()
+    ensure_ffmpeg()
+
+    if not SOURCE_DIR.exists():
+        raise FileNotFoundError(f"Source folder not found: {SOURCE_DIR}")
+
+    source_videos = collect_videos(SOURCE_DIR)
+    if not source_videos:
+        raise FileNotFoundError(f"No .mp4 files found under: {SOURCE_DIR}")
+
+    converted_count = 0
+    skipped_count = 0
+    failed: List[Tuple[Path, str]] = []
+
+    for src in source_videos:
+        rel = src.relative_to(SOURCE_DIR)
+        dst = MUTED_DIR / rel
+        try:
+            if dst.exists():
+                skipped_count += 1
+                continue
+            mute_video(src, dst)
+            converted_count += 1
+        except Exception as exc:
+            failed.append((src, str(exc)))
+            logging.error("Failed to mute %s: %s", src, exc)
+
+    muted_videos = collect_videos(MUTED_DIR)
+    logging.info("========== Mute Summary ==========")
+    logging.info("Source videos found: %d", len(source_videos))
+    logging.info("Newly converted: %d", converted_count)
+    logging.info("Already existed (skipped): %d", skipped_count)
+    logging.info("Failed conversions: %d", len(failed))
+    logging.info("Total muted videos now: %d", len(muted_videos))
+    logging.info("Muted output dir: %s", MUTED_DIR.resolve())
+    logging.info("==================================")
+
+    if failed:
+        logging.info("Failed files:")
+        for src, err in failed:
+            logging.info("- %s | %s", src, err)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/select_random_videos.py b/sync_research/select_random_videos.py
new file mode 100644
index 0000000000000000000000000000000000000000..b42ae14768e3f927ee648aa6d51cc7fa69fbfe75
--- /dev/null
+++ b/sync_research/select_random_videos.py
@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+import argparse
+import random
+import shutil
+from pathlib import Path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Randomly select videos from source folder to destination folder."
+    )
+    parser.add_argument(
+        "--src",
+        type=Path,
+        default=Path("/home/ubuntu/video/uag_oops"),
+        help="Source folder containing videos.",
+    )
+    parser.add_argument(
+        "--dst",
+        type=Path,
+        default=Path("/home/ubuntu/video/sample"),
+        help="Destination folder to place selected videos.",
+    )
+    parser.add_argument(
+        "--count",
+        type=int,
+        default=100,
+        help="Number of videos to select.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=None,
+        help="Random seed for reproducible sampling.",
+    )
+    parser.add_argument(
+        "--move",
+        action="store_true",
+        help="Move files instead of copying.",
+    )
+    return parser.parse_args()
+
+
+def unique_target_path(dst_dir: Path, src_name: str) -> Path:
+    target = dst_dir / src_name
+    if not target.exists():
+        return target
+
+    stem = target.stem
+    suffix = target.suffix
+    index = 1
+    while True:
+        candidate = dst_dir / f"{stem}_{index}{suffix}"
+        if not candidate.exists():
+            return candidate
+        index += 1
+
+
+def main() -> None:
+    args = parse_args()
+
+    if not args.src.exists():
+        raise FileNotFoundError(f"Source folder not found: {args.src}")
+    if args.count <= 0:
+        raise ValueError("--count must be > 0")
+
+    args.dst.mkdir(parents=True, exist_ok=True)
+
+    videos = sorted(args.src.glob("*.mp4"))
+    total = len(videos)
+    if total == 0:
+        print(f"No .mp4 files found in: {args.src}")
+        return
+
+    n = min(args.count, total)
+    rng = random.Random(args.seed)
+    selected = rng.sample(videos, n)
+
+    op_name = "Moved" if args.move else "Copied"
+    print(f"Found {total} videos in {args.src}")
+    print(f"Selecting {n} videos -> {args.dst}")
+    if args.seed is not None:
+        print(f"Using seed: {args.seed}")
+
+    for i, src in enumerate(selected, start=1):
+        dst = unique_target_path(args.dst, src.name)
+        if args.move:
+            shutil.move(str(src), str(dst))
+        else:
+            shutil.copy2(src, dst)
+        print(f"[{i}/{n}] {op_name}: {src.name} -> {dst.name}")
+
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/shifted_clap_stress_test.py b/sync_research/shifted_clap_stress_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..c65fa43b12af367f1658f9a403bb20b8c7d4d70a
--- /dev/null
+++ b/sync_research/shifted_clap_stress_test.py
@@ -0,0 +1,509 @@
+#!/usr/bin/env python3
+"""
+Visual-Guided CLAP Audio Grounding on shifted datasets.
+
+Pipeline:
+1) Read video_id list from source CSV.
+2) For each selected video, run Gemini on the ORIGINAL full video and get:
+   - visual_timestamp
+   - expected_sound (3-5 words)
+3) Extract shifted audio to 48k wav.
+4) Run CLAP sliding window matching (0.5s window, 0.1s hop) against expected_sound.
+5) Pick max-similarity window as detected_t_audio.
+6) Evaluate delay/early splits and save outputs in HPSS-compatible result format.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import os
+import random
+import re
+import subprocess
+import tempfile
+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 ClapModel, ClapProcessor
+
+try:
+    import google.generativeai as genai
+except Exception:  # pragma: no cover
+    genai = None
+
+
+DEFAULT_SOURCE_CSV = Path(
+    "/home/ubuntu/video_source/result/gemini_video_oc_frame/gemini_validated_accept_lt1p0.csv"
+)
+DEFAULT_ORIGINAL_DIR = Path("/home/ubuntu/video_source/original/uag_oops")
+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/shift_clap_test")
+
+CLAP_MODEL_NAME = "laion/clap-htsat-unfused"
+GEMINI_MODEL = "gemini-3.1-pro-preview"
+GEMINI_VISUAL_SOUND_PROMPT = """You are an expert in physics and video forensics.
+Analyze this muted video to find the exact moment of MAXIMUM PHYSICAL IMPACT.
+Also infer the expected impact sound in 3-5 words.
+
+Based on the visual materials colliding (e.g., human body on snow, metal on concrete, falling into water), describe the expected sound in 3-5 words.
+
+Output strictly in JSON:
+{
+  "visual_timestamp": 2.5,
+  "expected_sound": "heavy dull thud"
+}"""
+
+WINDOW_SECONDS = 0.5
+HOP_SECONDS = 0.1
+AUDIO_SR = 48000
+BATCH_WINDOWS = 32
+GEMINI_FILE_READY_TIMEOUT_SECONDS = 120
+GEMINI_FILE_POLL_SECONDS = 2
+
+
+def read_candidates(csv_path: Path) -> List[str]:
+    if not csv_path.exists():
+        raise FileNotFoundError(f"CSV not found: {csv_path}")
+    rows: List[str] = []
+    with csv_path.open("r", encoding="utf-8", newline="") as f:
+        reader = csv.DictReader(f)
+        if "video_id" not in (reader.fieldnames or []):
+            raise ValueError("CSV must contain column: video_id")
+        for item in reader:
+            video_id = str(item.get("video_id", "")).strip()
+            if not video_id:
+                continue
+            rows.append(video_id)
+    if not rows:
+        raise ValueError(f"No valid rows found in CSV: {csv_path}")
+    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_from_video_id(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_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 Gemini output.")
+
+
+def wait_for_gemini_file_active(file_name: str) -> None:
+    import time
+
+    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(
+        f"Gemini file did not become ACTIVE within {GEMINI_FILE_READY_TIMEOUT_SECONDS}s."
+    )
+
+
+def ask_gemini_visual_and_sound(video_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(video_path))
+    try:
+        wait_for_gemini_file_active(uploaded.name)
+        resp = model.generate_content([GEMINI_VISUAL_SOUND_PROMPT, uploaded])
+        text = (getattr(resp, "text", "") or "").strip()
+        if not text:
+            raise RuntimeError("Gemini returned empty response.")
+        data = _extract_json_object(text)
+        t_visual = float(data["visual_timestamp"])
+        expected_sound = str(data["expected_sound"]).strip().strip('"').strip("'")
+        words = expected_sound.split()
+        if len(words) < 3:
+            expected_sound = "impact crash thud sound"
+        elif len(words) > 5:
+            expected_sound = " ".join(words[:5])
+        return t_visual, expected_sound
+    finally:
+        try:
+            genai.delete_file(uploaded.name)
+        except Exception:
+            pass
+
+
+def extract_audio_to_wav(video_path: Path, target_sr: int = AUDIO_SR) -> Path:
+    tmp = tempfile.NamedTemporaryFile(prefix="clap_audio_", suffix=".wav", delete=False)
+    tmp_path = Path(tmp.name)
+    tmp.close()
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(video_path),
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        str(target_sr),
+        str(tmp_path),
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    return tmp_path
+
+
+def _window_starts(total_samples: int, win_samples: int, hop_samples: int) -> List[int]:
+    if total_samples <= 0:
+        return []
+    if total_samples <= win_samples:
+        return [0]
+    return list(range(0, total_samples - win_samples + 1, hop_samples))
+
+
+def _as_embedding_tensor(x: Any, kind: str) -> torch.Tensor:
+    """
+    Make CLAP outputs robust across transformers versions.
+    """
+    if torch.is_tensor(x):
+        return x
+    if hasattr(x, "text_embeds") and x.text_embeds is not None:
+        return x.text_embeds
+    if hasattr(x, "audio_embeds") and x.audio_embeds is not None:
+        return x.audio_embeds
+    if hasattr(x, "pooler_output") and x.pooler_output is not None:
+        return x.pooler_output
+    if hasattr(x, "last_hidden_state") and x.last_hidden_state is not None:
+        lhs = x.last_hidden_state
+        if torch.is_tensor(lhs) and lhs.ndim >= 2:
+            return lhs[:, 0, ...]
+    raise RuntimeError(f"Could not extract {kind} embedding tensor from CLAP output type: {type(x)}")
+
+
+def clap_detect_peak_time(
+    wav_path: Path,
+    expected_sound: str,
+    clap_model: ClapModel,
+    clap_processor: ClapProcessor,
+    device: torch.device,
+    window_seconds: float = WINDOW_SECONDS,
+    hop_seconds: float = HOP_SECONDS,
+    sr: int = AUDIO_SR,
+) -> Optional[float]:
+    y, file_sr = librosa.load(str(wav_path), sr=sr, mono=True)
+    if y.size == 0:
+        return None
+
+    win = int(round(window_seconds * sr))
+    hop = max(int(round(hop_seconds * sr)), 1)
+    starts = _window_starts(len(y), win, hop)
+    if not starts:
+        return None
+
+    with torch.no_grad():
+        text_inputs = clap_processor(text=[expected_sound], return_tensors="pt", padding=True)
+        text_inputs = {k: v.to(device) for k, v in text_inputs.items()}
+        text_raw = clap_model.get_text_features(**text_inputs)
+        text_emb = _as_embedding_tensor(text_raw, kind="text")
+        text_emb = torch.nn.functional.normalize(text_emb, dim=-1)
+
+    best_score = None
+    best_start = None
+    for i in range(0, len(starts), BATCH_WINDOWS):
+        batch_starts = starts[i : i + BATCH_WINDOWS]
+        clips = [y[s : s + win] for s in batch_starts]
+        clips = [c if len(c) == win else np.pad(c, (0, win - len(c))) for c in clips]
+        with torch.no_grad():
+            audio_inputs = clap_processor(audio=clips, sampling_rate=sr, return_tensors="pt", padding=True)
+            audio_inputs = {k: v.to(device) for k, v in audio_inputs.items()}
+            audio_raw = clap_model.get_audio_features(**audio_inputs)
+            audio_emb = _as_embedding_tensor(audio_raw, kind="audio")
+            audio_emb = torch.nn.functional.normalize(audio_emb, dim=-1)
+            sims = torch.matmul(audio_emb, text_emb.T).squeeze(-1).detach().cpu().numpy()
+        idx_local = int(np.argmax(sims))
+        score = float(sims[idx_local])
+        if best_score is None or score > best_score:
+            best_score = score
+            best_start = batch_starts[idx_local]
+
+    if best_start is None:
+        return None
+    return float(best_start / sr)
+
+
+def evaluate_single_video(
+    shifted_video: Path,
+    t_visual: float,
+    shift_amount: float,
+    expected_sound: str,
+    clap_model: ClapModel,
+    clap_processor: ClapProcessor,
+    device: torch.device,
+) -> Dict[str, Any]:
+    expected_t_audio = float(t_visual) + float(shift_amount)
+    wav_path = None
+    detected_t_audio = None
+    try:
+        wav_path = extract_audio_to_wav(shifted_video, target_sr=AUDIO_SR)
+        detected_t_audio = clap_detect_peak_time(
+            wav_path=wav_path,
+            expected_sound=expected_sound,
+            clap_model=clap_model,
+            clap_processor=clap_processor,
+            device=device,
+        )
+    finally:
+        if wav_path is not None and wav_path.exists():
+            wav_path.unlink(missing_ok=True)
+
+    if detected_t_audio is None:
+        abs_error = None
+        detected_str = "None"
+        error_str = "None"
+    else:
+        abs_error = abs(detected_t_audio - expected_t_audio)
+        detected_str = f"{detected_t_audio:.3f}"
+        error_str = f"{abs_error:.3f}"
+
+    print(
+        f"{shifted_video.name} | t_visual: {float(t_visual):.3f} | "
+        f"Expected Sound: {expected_sound} | CLAP t_audio: {detected_str} | "
+        f"Expected Audio: {expected_t_audio:.3f} | Error: {error_str} sec"
+    )
+
+    return {
+        "video_path": str(shifted_video),
+        "video_id": shifted_video.name,
+        "t_visual": float(t_visual),
+        "shift_amount": float(shift_amount),
+        "expected_t_audio": expected_t_audio,
+        "detected_t_audio": detected_t_audio,
+        "abs_error_sec": abs_error,
+        "expected_sound": expected_sound,
+    }
+
+
+def summarize_errors(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    errors = [float(r["abs_error_sec"]) for r in rows if r.get("abs_error_sec") is not None]
+    return {
+        "count": len(rows),
+        "with_detection": len(errors),
+        "without_detection": len(rows) - len(errors),
+        "mae_sec": round(mean(errors), 4) if errors else None,
+        "median_like_sec": round(sorted(errors)[len(errors) // 2], 4) if errors else None,
+        "within_0_3_sec": sum(1 for e in errors if e <= 0.3),
+        "within_0_5_sec": sum(1 for e in errors if e <= 0.5),
+        "within_1_0_sec": sum(1 for e in errors if e <= 1.0),
+    }
+
+
+def write_jsonl(path: Path, rows: List[Dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="Run shifted CLAP stress test.")
+    p.add_argument("--source-csv", type=Path, default=DEFAULT_SOURCE_CSV)
+    p.add_argument("--original-dir", type=Path, default=DEFAULT_ORIGINAL_DIR)
+    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("--sample-size", type=int, default=63)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--output-dir", type=Path, default=DEFAULT_OUTPUT_DIR)
+    p.add_argument("--delay-shift", type=float, default=2.0)
+    p.add_argument("--early-shift", type=float, default=-2.0)
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    gemini_key = os.getenv("GEMINI_API_KEY", "").strip()
+    if not gemini_key:
+        raise RuntimeError("GEMINI_API_KEY is required for expected_sound generation.")
+
+    candidates = read_candidates(args.source_csv)
+    rng = random.Random(args.seed)
+    if args.sample_size <= 0:
+        sampled = list(candidates)
+    elif len(candidates) <= args.sample_size:
+        sampled = list(candidates)
+    else:
+        sampled = rng.sample(candidates, args.sample_size)
+    sampled.sort()
+
+    original_index = index_by_filename(args.original_dir)
+    delay_index = index_by_filename(args.delay_dir)
+    early_index = index_by_filename(args.early_dir)
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Using device: {device}")
+    clap_processor = ClapProcessor.from_pretrained(CLAP_MODEL_NAME)
+    clap_model = ClapModel.from_pretrained(CLAP_MODEL_NAME).to(device)
+    clap_model.eval()
+
+    delay_results: List[Dict[str, Any]] = []
+    early_results: List[Dict[str, Any]] = []
+    missing_rows: List[Dict[str, Any]] = []
+    gemini_meta_cache: Dict[str, Dict[str, Any]] = {}
+
+    for video_id in tqdm(sampled, desc="Shifted CLAP Test", unit="video"):
+        original_path = original_index.get(video_id)
+        delay_path = delay_index.get(shifted_filename_from_video_id(video_id, "delay"))
+        early_path = early_index.get(shifted_filename_from_video_id(video_id, "early"))
+
+        if original_path is None:
+            missing_rows.append({"split": "original", "video_id": video_id, "reason": "file_not_found"})
+            continue
+        if delay_path is None and early_path is None:
+            missing_rows.append({"split": "both", "video_id": video_id, "reason": "shifted_file_not_found"})
+            continue
+
+        try:
+            t_visual, expected_sound = ask_gemini_visual_and_sound(original_path, gemini_key)
+            gemini_meta_cache[video_id] = {
+                "t_visual": round(float(t_visual), 3),
+                "expected_sound": expected_sound,
+                "original_video_path": str(original_path),
+            }
+        except Exception as exc:
+            missing_rows.append({"split": "original", "video_id": video_id, "reason": f"gemini_error: {exc}"})
+            continue
+
+        if delay_path is None:
+            missing_rows.append({"split": "delay", "video_id": video_id, "reason": "file_not_found"})
+        else:
+            try:
+                delay_results.append(
+                    evaluate_single_video(
+                        shifted_video=delay_path,
+                        t_visual=t_visual,
+                        shift_amount=args.delay_shift,
+                        expected_sound=expected_sound,
+                        clap_model=clap_model,
+                        clap_processor=clap_processor,
+                        device=device,
+                    )
+                )
+            except Exception as exc:
+                missing_rows.append({"split": "delay", "video_id": video_id, "reason": f"exception: {exc}"})
+
+        if early_path is None:
+            missing_rows.append({"split": "early", "video_id": video_id, "reason": "file_not_found"})
+        else:
+            try:
+                early_results.append(
+                    evaluate_single_video(
+                        shifted_video=early_path,
+                        t_visual=t_visual,
+                        shift_amount=args.early_shift,
+                        expected_sound=expected_sound,
+                        clap_model=clap_model,
+                        clap_processor=clap_processor,
+                        device=device,
+                    )
+                )
+            except Exception as exc:
+                missing_rows.append({"split": "early", "video_id": video_id, "reason": f"exception: {exc}"})
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    sampled_csv = args.output_dir / "sampled_10_from_gemini.csv"
+    with sampled_csv.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(
+            f,
+            fieldnames=["video_id", "t_visual", "expected_sound", "original_video_path"],
+        )
+        writer.writeheader()
+        for video_id in sampled:
+            meta = gemini_meta_cache.get(video_id, {})
+            writer.writerow(
+                {
+                    "video_id": video_id,
+                    "t_visual": meta.get("t_visual", ""),
+                    "expected_sound": meta.get("expected_sound", ""),
+                    "original_video_path": meta.get("original_video_path", ""),
+                }
+            )
+
+    delay_jsonl = args.output_dir / "delay_results.jsonl"
+    early_jsonl = args.output_dir / "early_results.jsonl"
+    write_jsonl(delay_jsonl, delay_results)
+    write_jsonl(early_jsonl, early_results)
+
+    missing_json = args.output_dir / "missing_or_errors.json"
+    with missing_json.open("w", encoding="utf-8") as f:
+        json.dump(missing_rows, f, ensure_ascii=False, indent=2)
+
+    summary = {
+        "source_csv": str(args.source_csv),
+        "sample_size": len(sampled),
+        "seed": args.seed,
+        "window_seconds": 3.0,
+        "delay_shift": args.delay_shift,
+        "early_shift": args.early_shift,
+        "delay_summary": summarize_errors(delay_results),
+        "early_summary": summarize_errors(early_results),
+        "missing_or_errors_count": len(missing_rows),
+        "outputs": {
+            "sampled_csv": str(sampled_csv),
+            "delay_jsonl": str(delay_jsonl),
+            "early_jsonl": str(early_jsonl),
+            "missing_or_errors_json": str(missing_json),
+        },
+    }
+    summary_json = args.output_dir / "summary.json"
+    with summary_json.open("w", encoding="utf-8") as f:
+        json.dump(summary, f, ensure_ascii=False, indent=2)
+
+    print("========== Shifted CLAP Test Summary ==========")
+    print(f"Sampled videos: {len(sampled)}")
+    print(f"Delay evaluated: {len(delay_results)}")
+    print(f"Early evaluated: {len(early_results)}")
+    print(f"Missing/errors: {len(missing_rows)}")
+    print(f"Summary JSON: {summary_json}")
+    print("===============================================")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/sync_research/test_shift.py b/sync_research/test_shift.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c458336bb033bd6f4164298ce699475fa2de327
--- /dev/null
+++ b/sync_research/test_shift.py
@@ -0,0 +1,44 @@
+from moviepy import VideoFileClip, CompositeAudioClip
+
+def shift_audio(video_path, output_path, shift_seconds=2.0):
+    print(f"🎬 正在加载视频: {video_path}")
+    
+    # 加载视频和对应的音频
+    video = VideoFileClip(video_path)
+    audio = video.audio
+    
+    # 核心逻辑：让音频“时间错位”
+    # shift_seconds > 0: 音频延后（开头静音）
+    # shift_seconds < 0: 音频提前（结尾静音）
+    print(f"⏱️ 正在将音频平移 {shift_seconds} 秒...")
+    if shift_seconds >= 0:
+        shifted_audio = CompositeAudioClip([audio.with_start(shift_seconds)]).with_duration(video.duration)
+    else:
+        advance_seconds = abs(shift_seconds)
+        if advance_seconds >= video.duration:
+            shifted_audio = CompositeAudioClip([]).with_duration(video.duration)
+        else:
+            trimmed_audio = audio.subclipped(advance_seconds, video.duration)
+            shifted_audio = CompositeAudioClip([trimmed_audio.with_start(0)]).with_duration(video.duration)
+    
+    # 把错位的音频重新合成到视频上
+    final_video = video.with_audio(shifted_audio)
+    
+    # 导出被“下毒”的对抗样本
+    print(f"💾 正在导出对抗样本: {output_path}")
+    final_video.write_videofile(output_path, codec="libx264", audio_codec="aac")
+    print("✅ 搞定！CT-DPO 负样本生成成功！")
+
+# 示例1：音频往后 2 秒（开头静音）
+shift_audio(
+    "/home/ubuntu/uag_oops_data/uag_oops/34 Funny Kid Nominees - FailArmy Hall Of Fame (May 2017)9.mp4",
+    "/home/ubuntu/poisoned_output_delay2.mp4",
+    shift_seconds=2.0,
+)
+
+# 示例2：音频往前 2 秒（结尾静音）
+shift_audio(
+    "/home/ubuntu/uag_oops_data/uag_oops/34 Funny Kid Nominees - FailArmy Hall Of Fame (May 2017)9.mp4",
+    "/home/ubuntu/poisoned_output_early2.mp4",
+    shift_seconds=-2.0,
+)
\ No newline at end of file
diff --git a/sync_research/video_shifter.py b/sync_research/video_shifter.py
new file mode 100644
index 0000000000000000000000000000000000000000..b32f7f4b79bd6d3df6b6c9e428577680cda0fe25
--- /dev/null
+++ b/sync_research/video_shifter.py
@@ -0,0 +1,329 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import random
+import subprocess
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+from tqdm import tqdm
+
+
+VIDEO_EXTS = {".mp4", ".mov", ".mkv", ".avi", ".webm", ".m4v"}
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Generate delayed/early random-shifted videos using ffmpeg stream copy."
+    )
+    p.add_argument(
+        "--input-dir",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/original"),
+        help="Root directory containing original videos.",
+    )
+    p.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/random_shift_video"),
+        help="Output root. Script writes to delay/ and early/ subfolders.",
+    )
+    p.add_argument(
+        "--metadata-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/video_source/random_shift_video/shift_metadata.jsonl"),
+        help="Append-only metadata JSONL file.",
+    )
+    p.add_argument(
+        "--min-shift",
+        type=float,
+        default=1.80,
+        help="Minimum random shift seconds.",
+    )
+    p.add_argument(
+        "--max-shift",
+        type=float,
+        default=2.50,
+        help="Maximum random shift seconds.",
+    )
+    p.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for reproducibility.",
+    )
+    p.add_argument(
+        "--workers",
+        type=int,
+        default=os.cpu_count() or 4,
+        help="Max worker threads. Defaults to os.cpu_count().",
+    )
+    return p.parse_args()
+
+
+def run_cmd(cmd: List[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def discover_videos(root: Path) -> List[Path]:
+    if not root.exists():
+        raise FileNotFoundError(f"Input directory not found: {root}")
+    out: List[Path] = []
+    for p in root.rglob("*"):
+        if p.is_file() and p.suffix.lower() in VIDEO_EXTS:
+            out.append(p)
+    out.sort()
+    return out
+
+
+def has_audio_stream(video_path: Path) -> bool:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "a:0",
+        "-show_entries",
+        "stream=index",
+        "-of",
+        "csv=p=0",
+        str(video_path),
+    ]
+    out = run_cmd(cmd).stdout.strip()
+    return bool(out)
+
+
+def get_duration_seconds(video_path: Path) -> float:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        str(video_path),
+    ]
+    out = run_cmd(cmd).stdout.strip()
+    return float(out)
+
+
+def load_existing_records(path: Path) -> Set[Tuple[str, str]]:
+    """
+    Returns set of (original_video, shift_direction) that already have metadata records.
+    """
+    out: Set[Tuple[str, str]] = set()
+    if not path.exists():
+        return out
+    with path.open("r", encoding="utf-8") as f:
+        for line in f:
+            s = line.strip()
+            if not s:
+                continue
+            try:
+                row = json.loads(s)
+            except json.JSONDecodeError:
+                continue
+            original_video = str(row.get("original_video", "")).strip()
+            direction = str(row.get("shift_direction", "")).strip()
+            if original_video and direction in {"delayed", "early"}:
+                out.add((original_video, direction))
+    return out
+
+
+def append_metadata_threadsafe(path: Path, record: Dict, lock: threading.Lock) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with lock:
+        with path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def make_delayed_video(src: Path, dst: Path, shift_sec: float, duration: float) -> None:
+    # Delay audio by shift_sec and trim to keep original duration.
+    delay_ms = int(round(shift_sec * 1000))
+    af = f"adelay={delay_ms}:all=1,atrim=0:{duration:.6f}"
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a:0",
+        "-c:v",
+        "copy",
+        "-af",
+        af,
+        "-c:a",
+        "aac",
+        str(dst),
+    ]
+    run_cmd(cmd)
+
+
+def make_early_video(src: Path, dst: Path, shift_sec: float, duration: float) -> None:
+    # Advance audio by shift_sec; pad tail silence and keep original duration.
+    af = (
+        f"atrim=start={shift_sec:.6f},"
+        "asetpts=PTS-STARTPTS,"
+        f"apad=pad_dur={shift_sec:.6f},"
+        f"atrim=0:{duration:.6f}"
+    )
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(src),
+        "-map",
+        "0:v:0",
+        "-map",
+        "0:a:0",
+        "-c:v",
+        "copy",
+        "-af",
+        af,
+        "-c:a",
+        "aac",
+        str(dst),
+    ]
+    run_cmd(cmd)
+
+
+def build_output_path(
+    output_root: Path,
+    direction_folder: str,
+    rel_video: Path,
+    shift_tag: str,
+) -> Path:
+    base_dir = output_root / direction_folder / rel_video.parent
+    base_dir.mkdir(parents=True, exist_ok=True)
+    stem = rel_video.stem
+    suffix = rel_video.suffix if rel_video.suffix else ".mp4"
+    if direction_folder == "delay":
+        name = f"{stem}_delay_{shift_tag}s{suffix}"
+    else:
+        name = f"{stem}_early_{shift_tag}s{suffix}"
+    return base_dir / name
+
+
+def process_one_video(
+    src: Path,
+    input_root: Path,
+    output_root: Path,
+    metadata_path: Path,
+    existing_records: Set[Tuple[str, str]],
+    meta_lock: threading.Lock,
+    min_shift: float,
+    max_shift: float,
+    rng_seed: int,
+) -> Dict[str, int]:
+    rel = src.relative_to(input_root)
+    original_key = str(rel)
+
+    counters = {"generated": 0, "skipped": 0, "failed": 0, "no_audio": 0}
+    local_rng = random.Random(f"{rng_seed}:{original_key}")
+
+    try:
+        if not has_audio_stream(src):
+            counters["no_audio"] += 1
+            return counters
+        duration = get_duration_seconds(src)
+    except Exception:
+        counters["failed"] += 1
+        return counters
+
+    for direction, folder in [("delayed", "delay"), ("early", "early")]:
+        if (original_key, direction) in existing_records:
+            counters["skipped"] += 1
+            continue
+
+        shift_val = local_rng.uniform(min_shift, max_shift)
+        shift_tag = f"{shift_val:.2f}"
+        out_path = build_output_path(output_root, folder, rel, shift_tag)
+
+        if out_path.exists():
+            counters["skipped"] += 1
+            continue
+
+        try:
+            if direction == "delayed":
+                make_delayed_video(src, out_path, shift_val, duration)
+            else:
+                make_early_video(src, out_path, shift_val, duration)
+
+            record = {
+                "original_video": original_key,
+                "shifted_video_name": out_path.name,
+                "shifted_video_path": str(out_path),
+                "shift_direction": direction,
+                "exact_shift_seconds": round(float(shift_val), 6),
+            }
+            append_metadata_threadsafe(metadata_path, record, meta_lock)
+            counters["generated"] += 1
+        except Exception:
+            counters["failed"] += 1
+
+    return counters
+
+
+def main() -> None:
+    args = parse_args()
+    if args.min_shift <= 0 or args.max_shift <= 0 or args.min_shift > args.max_shift:
+        raise ValueError("Invalid shift range.")
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    (args.output_dir / "delay").mkdir(parents=True, exist_ok=True)
+    (args.output_dir / "early").mkdir(parents=True, exist_ok=True)
+
+    videos = discover_videos(args.input_dir)
+    if not videos:
+        print(f"No videos found under: {args.input_dir}")
+        return
+
+    existing_records = load_existing_records(args.metadata_jsonl)
+    meta_lock = threading.Lock()
+
+    totals = {"generated": 0, "skipped": 0, "failed": 0, "no_audio": 0}
+    futures = []
+    with ThreadPoolExecutor(max_workers=max(1, int(args.workers))) as ex:
+        for src in videos:
+            futures.append(
+                ex.submit(
+                    process_one_video,
+                    src,
+                    args.input_dir,
+                    args.output_dir,
+                    args.metadata_jsonl,
+                    existing_records,
+                    meta_lock,
+                    args.min_shift,
+                    args.max_shift,
+                    args.seed,
+                )
+            )
+
+        for fut in tqdm(as_completed(futures), total=len(futures), desc="Shifting videos", unit="video"):
+            res = fut.result()
+            for k in totals:
+                totals[k] += res.get(k, 0)
+
+    print("========== Shift Generation Summary ==========")
+    print(f"Input videos             : {len(videos)}")
+    print(f"Generated shifted videos : {totals['generated']}")
+    print(f"Skipped                  : {totals['skipped']}")
+    print(f"No-audio skipped         : {totals['no_audio']}")
+    print(f"Failed                   : {totals['failed']}")
+    print(f"Output root              : {args.output_dir}")
+    print(f"Metadata JSONL           : {args.metadata_jsonl}")
+    print("=============================================")
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/testing/test_gemini_video.py b/testing/test_gemini_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..71b8167da42c66f9bc21e76ae12a145a2c7691b7
--- /dev/null
+++ b/testing/test_gemini_video.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import sys
+import time
+
+from google import genai
+
+
+DEFAULT_PROMPT = (
+    "Please describe the exact sequence of events in this video. "
+    "Specifically, when does the loudest sound occur in relation to the visual impact?"
+)
+
+
+def wait_until_file_ready(client: genai.Client, file_name: str, timeout_sec: int = 300) -> None:
+    start = time.time()
+    while True:
+        f = client.files.get(name=file_name)
+        state = getattr(getattr(f, "state", None), "name", None) or str(getattr(f, "state", ""))
+
+        if state == "ACTIVE":
+            return
+        if state == "FAILED":
+            raise RuntimeError(f"File processing failed: {file_name}")
+        if time.time() - start > timeout_sec:
+            raise TimeoutError(f"Timed out waiting for file to become ACTIVE: {file_name}")
+
+        time.sleep(2)
+
+
+def analyze_one_video(client: genai.Client, model_name: str, video_path: str, prompt: str) -> str:
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+
+    uploaded = client.files.upload(file=video_path)
+    wait_until_file_ready(client, uploaded.name)
+
+    response = client.models.generate_content(
+        model=model_name,
+        contents=[uploaded, prompt],
+    )
+    return (response.text or "").strip()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Compare Gemini responses on two videos.")
+    parser.add_argument("--video-a", required=True, help="Path to first video (e.g., original).")
+    parser.add_argument("--video-b", required=True, help="Path to second video (e.g., volume=0).")
+    parser.add_argument("--label-a", default="original", help="Display label for video A.")
+    parser.add_argument("--label-b", default="volume0", help="Display label for video B.")
+    parser.add_argument("--model", default="gemini-3.1-pro", help="Gemini model name.")
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT, help="Prompt to send.")
+    args = parser.parse_args()
+
+    api_key = os.environ.get("GEMINI_API_KEY")
+    if not api_key:
+        print("Error: GEMINI_API_KEY is not set.", file=sys.stderr)
+        sys.exit(1)
+
+    client = genai.Client(api_key=api_key)
+
+    print(f"Model: {args.model}")
+    print(f"Prompt: {args.prompt}\n")
+
+    print(f"Analyzing {args.label_a}: {args.video_a}")
+    out_a = analyze_one_video(client, args.model, args.video_a, args.prompt)
+    print(f"\n===== {args.label_a} =====")
+    print(out_a if out_a else "<empty response>")
+
+    print(f"\nAnalyzing {args.label_b}: {args.video_b}")
+    out_b = analyze_one_video(client, args.model, args.video_b, args.prompt)
+    print(f"\n===== {args.label_b} =====")
+    print(out_b if out_b else "<empty response>")
+
+    print("\n===== Quick check =====")
+    print(
+        "- If timing/detail around loudest sound changes significantly between the two videos, "
+        "audio is likely being used.\n"
+        "- If responses are nearly identical, audio influence is weak or absent."
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/testing/test_gemini_video_audio.py b/testing/test_gemini_video_audio.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f824fd40928d9c422e762e47f449771406b2ea5
--- /dev/null
+++ b/testing/test_gemini_video_audio.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+from google import genai
+
+
+DEFAULT_PROMPT = (
+    "Please describe the exact sequence of events in this video. "
+    "Specifically, when does the loudest sound occur in relation to the visual impact?"
+)
+
+
+def run_cmd(cmd):
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+
+
+def make_video_only(input_video: Path, output_video: Path):
+    # Remove audio track to simulate visual-only input.
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(input_video),
+        "-map",
+        "0:v:0",
+        "-an",
+        "-c:v",
+        "copy",
+        str(output_video),
+    ]
+    run_cmd(cmd)
+
+
+def make_audio_only(input_video: Path, output_audio: Path):
+    # Extract mono wav audio for audio-only case.
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        str(input_video),
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        str(output_audio),
+    ]
+    run_cmd(cmd)
+
+
+def wait_until_active(client: genai.Client, file_name: str, timeout_sec: int = 300):
+    start = time.time()
+    while True:
+        meta = client.files.get(name=file_name)
+        state = getattr(getattr(meta, "state", None), "name", None) or str(getattr(meta, "state", ""))
+        if state == "ACTIVE":
+            return
+        if state == "FAILED":
+            raise RuntimeError(f"Gemini file processing failed: {file_name}")
+        if time.time() - start > timeout_sec:
+            raise TimeoutError(f"Timed out waiting for Gemini file ACTIVE: {file_name}")
+        time.sleep(2)
+
+
+def is_503_unavailable(exc: Exception) -> bool:
+    msg = str(exc)
+    return "503" in msg and "UNAVAILABLE" in msg
+
+
+def generate_with_retry(
+    client: genai.Client,
+    model: str,
+    uploaded,
+    prompt: str,
+    max_retries: int,
+    retry_wait_sec: float,
+):
+    attempt = 0
+    while True:
+        try:
+            return client.models.generate_content(model=model, contents=[uploaded, prompt])
+        except Exception as exc:  # SDK raises typed errors but this keeps compatibility
+            if not is_503_unavailable(exc) or attempt >= max_retries:
+                raise
+            sleep_s = retry_wait_sec * (2 ** attempt)
+            print(
+                f"[retry] {model} busy (503). attempt {attempt + 1}/{max_retries}, "
+                f"sleep {sleep_s:.1f}s ..."
+            )
+            time.sleep(sleep_s)
+            attempt += 1
+
+
+def run_case(
+    client: genai.Client,
+    model: str,
+    fallback_model: str,
+    case_name: str,
+    media_path: Path,
+    prompt: str,
+    max_retries: int,
+    retry_wait_sec: float,
+):
+    uploaded = client.files.upload(file=str(media_path))
+    wait_until_active(client, uploaded.name)
+    try:
+        resp = generate_with_retry(
+            client=client,
+            model=model,
+            uploaded=uploaded,
+            prompt=prompt,
+            max_retries=max_retries,
+            retry_wait_sec=retry_wait_sec,
+        )
+    except Exception as exc:
+        if fallback_model and is_503_unavailable(exc):
+            print(f"[fallback] switch to model: {fallback_model}")
+            resp = generate_with_retry(
+                client=client,
+                model=fallback_model,
+                uploaded=uploaded,
+                prompt=prompt,
+                max_retries=max_retries,
+                retry_wait_sec=retry_wait_sec,
+            )
+        else:
+            raise
+    text = (resp.text or "").strip()
+    print(f"\n===== {case_name} =====")
+    print(text if text else "<empty response>")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Gemini AV/Video-only/Audio-only test runner.")
+    parser.add_argument("--video", required=True, help="Input video path.")
+    parser.add_argument(
+        "--model",
+        default="gemini-3.1-pro-preview",
+        help="Gemini model id.",
+    )
+    parser.add_argument(
+        "--cases",
+        default="av,video_only,audio_only",
+        help="Comma-separated cases: av,video_only,audio_only",
+    )
+    parser.add_argument(
+        "--fallback-model",
+        default="",
+        help="Optional fallback model if primary model returns 503.",
+    )
+    parser.add_argument(
+        "--max-retries",
+        type=int,
+        default=5,
+        help="Retries for transient 503 errors.",
+    )
+    parser.add_argument(
+        "--retry-wait-sec",
+        type=float,
+        default=2.0,
+        help="Base wait seconds for exponential backoff (2,4,8,...)",
+    )
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT)
+    args = parser.parse_args()
+
+    api_key = os.getenv("GEMINI_API_KEY")
+    if not api_key:
+        raise RuntimeError("GEMINI_API_KEY is not set.")
+
+    input_video = Path(args.video)
+    if not input_video.exists():
+        raise FileNotFoundError(f"Video not found: {input_video}")
+
+    selected = {c.strip() for c in args.cases.split(",") if c.strip()}
+    allowed = {"av", "video_only", "audio_only"}
+    bad = selected - allowed
+    if bad:
+        raise ValueError(f"Unknown cases: {sorted(bad)}. Allowed: {sorted(allowed)}")
+
+    client = genai.Client(api_key=api_key)
+    print(f"Model: {args.model}")
+    print(f"Video: {input_video}")
+    print(f"Cases: {sorted(selected)}")
+
+    with tempfile.TemporaryDirectory(prefix="gemini_mm_") as tmpdir:
+        tmpdir = Path(tmpdir)
+        muted_video = tmpdir / "video_only.mp4"
+        audio_wav = tmpdir / "audio_only.wav"
+
+        if "av" in selected:
+            run_case(
+                client,
+                args.model,
+                args.fallback_model,
+                "AV (video + audio)",
+                input_video,
+                args.prompt,
+                args.max_retries,
+                args.retry_wait_sec,
+            )
+
+        if "video_only" in selected:
+            make_video_only(input_video, muted_video)
+            run_case(
+                client,
+                args.model,
+                args.fallback_model,
+                "Video only (muted video)",
+                muted_video,
+                args.prompt,
+                args.max_retries,
+                args.retry_wait_sec,
+            )
+
+        if "audio_only" in selected:
+            make_audio_only(input_video, audio_wav)
+            run_case(
+                client,
+                args.model,
+                args.fallback_model,
+                "Audio only (wav)",
+                audio_wav,
+                args.prompt,
+                args.max_retries,
+                args.retry_wait_sec,
+            )
+
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/testing/test_qwen3omni_video_audio.py b/testing/test_qwen3omni_video_audio.py
new file mode 100644
index 0000000000000000000000000000000000000000..b86e54e07e2ce41096a29a08d3fed7179f27c16c
--- /dev/null
+++ b/testing/test_qwen3omni_video_audio.py
@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+import tempfile
+from typing import Dict, List
+
+import torch
+from transformers import Qwen3OmniMoeForConditionalGeneration, Qwen3OmniMoeProcessor
+from qwen_omni_utils import process_mm_info
+
+
+DEFAULT_PROMPT = (
+    "Please describe the exact sequence of events in this video. "
+    "Specifically, when does the loudest sound occur in relation to the visual impact?"
+)
+
+
+def extract_wav_from_video(video_path: str, wav_path: str) -> None:
+    cmd = [
+        "ffmpeg",
+        "-y",
+        "-i",
+        video_path,
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        wav_path,
+    ]
+    subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+
+def build_messages(media_items: List[Dict], prompt: str) -> List[Dict]:
+    return [
+        {
+            "role": "user",
+            "content": media_items + [{"type": "text", "text": prompt}],
+        }
+    ]
+
+
+def run_one_case(
+    *,
+    name: str,
+    messages: List[Dict],
+    model: Qwen3OmniMoeForConditionalGeneration,
+    processor: Qwen3OmniMoeProcessor,
+    use_audio_in_video: bool,
+    max_new_tokens: int,
+) -> str:
+    text = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=False)
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=use_audio_in_video)
+    inputs = processor(
+        text=text,
+        audio=audios,
+        images=images,
+        videos=videos,
+        return_tensors="pt",
+        padding=True,
+        use_audio_in_video=use_audio_in_video,
+    )
+    inputs = inputs.to(model.device).to(model.dtype)
+
+    with torch.inference_mode():
+        generation_output = model.generate(
+            **inputs,
+            return_audio=False,
+            use_audio_in_video=use_audio_in_video,
+            max_new_tokens=max_new_tokens,
+            do_sample=False,
+        )
+
+    if isinstance(generation_output, tuple):
+        text_ids = generation_output[0]
+    else:
+        text_ids = generation_output
+    sequences = text_ids.sequences if hasattr(text_ids, "sequences") else text_ids
+
+    decoded = processor.batch_decode(
+        sequences[:, inputs["input_ids"].shape[1] :],
+        skip_special_tokens=True,
+        clean_up_tokenization_spaces=False,
+    )
+    output = decoded[0].strip()
+    print(f"\n===== {name} =====")
+    print(output)
+    return output
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Test whether Qwen3-Omni uses audio information from video."
+    )
+    parser.add_argument("--video", required=True, help="Path to local input video file.")
+    parser.add_argument(
+        "--model",
+        default="Qwen/Qwen3-Omni-30B-A3B-Instruct",
+        help="Hugging Face model id or local model path.",
+    )
+    parser.add_argument("--prompt", default=DEFAULT_PROMPT, help="Question prompt.")
+    parser.add_argument("--max-new-tokens", type=int, default=192)
+    parser.add_argument(
+        "--cases",
+        default="av",
+        help="Comma-separated: av,video_only,audio_only (default: av).",
+    )
+    parser.add_argument(
+        "--attn-impl",
+        default="sdpa",
+        choices=["flash_attention_2", "sdpa", "eager"],
+        help="Attention implementation.",
+    )
+    args = parser.parse_args()
+
+    if not os.path.exists(args.video):
+        raise FileNotFoundError(f"Video not found: {args.video}")
+
+    print(f"Loading model: {args.model}")
+    try:
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            args.model,
+            dtype="auto",
+            device_map="auto",
+            attn_implementation=args.attn_impl,
+        )
+    except ImportError as exc:
+        if args.attn_impl != "flash_attention_2":
+            raise
+        print(
+            "flash_attention_2 is unavailable in this environment. "
+            "Falling back to sdpa."
+        )
+        model = Qwen3OmniMoeForConditionalGeneration.from_pretrained(
+            args.model,
+            dtype="auto",
+            device_map="auto",
+            attn_implementation="sdpa",
+        )
+    model.disable_talker()
+    processor = Qwen3OmniMoeProcessor.from_pretrained(args.model)
+
+    selected_cases = {item.strip() for item in args.cases.split(",") if item.strip()}
+    allowed_cases = {"av", "video_only", "audio_only"}
+    invalid = selected_cases - allowed_cases
+    if invalid:
+        raise ValueError(f"Unknown case(s): {sorted(invalid)}. Allowed: {sorted(allowed_cases)}")
+
+    outputs = {}
+    audio_path = None
+    with tempfile.TemporaryDirectory(prefix="qwen3omni_av_") as tmpdir:
+        if "audio_only" in selected_cases:
+            audio_path = os.path.join(tmpdir, "audio_from_video.wav")
+            extract_wav_from_video(args.video, audio_path)
+
+        if "av" in selected_cases:
+            av_messages = build_messages([{"type": "video", "video": args.video}], args.prompt)
+            outputs["av_video_plus_audio"] = run_one_case(
+                name="AV (video + audio from video track)",
+                messages=av_messages,
+                model=model,
+                processor=processor,
+                use_audio_in_video=True,
+                max_new_tokens=args.max_new_tokens,
+            )
+        if "video_only" in selected_cases:
+            video_only_messages = build_messages([{"type": "video", "video": args.video}], args.prompt)
+            outputs["video_only"] = run_one_case(
+                name="Video only (force ignore audio track)",
+                messages=video_only_messages,
+                model=model,
+                processor=processor,
+                use_audio_in_video=False,
+                max_new_tokens=args.max_new_tokens,
+            )
+        if "audio_only" in selected_cases and audio_path is not None:
+            audio_only_messages = build_messages([{"type": "audio", "audio": audio_path}], args.prompt)
+            outputs["audio_only"] = run_one_case(
+                name="Audio only (extracted wav)",
+                messages=audio_only_messages,
+                model=model,
+                processor=processor,
+                use_audio_in_video=False,
+                max_new_tokens=args.max_new_tokens,
+            )
+
+    # print("\n===== Quick interpretation guide =====")
+    # print(
+    #     "- If AV mentions loudest sound timing but video-only does not, the model is using audio.\n"
+    #     "- If AV and video-only are near-identical, audio contribution is weak or absent.\n"
+    #     "- Audio-only should describe sound events but not visual impact details."
+    # )
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()