Snapshot 20260424-2142

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()

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()

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()

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()

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()

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()

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()

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()

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".

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()
+

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()

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()

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()

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()
+

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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()

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>/`

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`.

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()

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()

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()

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()

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()

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()

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()

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 "========================================"

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)."

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()

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}"

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()

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()

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()

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()
+'''

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()
+

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()