Upload supp/ and root scripts

aggregate_results.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Aggregate mute/swap accuracy across all models in /home/ubuntu/eval_results.
+
+For each (model, prompt_mode) we report:
+  mute      : detection rate on muted inputs   (positive = muted)
+  mute_org  : detection rate on original audio (positive = synced)
+  swap      : detection rate on swapped inputs (positive = mismatched)
+  swap_org  : detection rate on original audio (positive = synced)
+  mute_all  : combined accuracy = (correct_mute + correct_mute_org) / (n_mute + n_mute_org)
+  swap_all  : combined accuracy = (correct_swap + correct_swap_org) / (n_swap + n_swap_org)
+
+When sample sizes match, the combined number equals the simple mean of the two rates.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+ROOT = Path("/home/ubuntu/eval_results")
+
+# Each task -> (list of root subpaths to scan, dirname prefix to strip, accuracy keys)
+TASKS = {
+    "mute":          (["mute", "gemini_mute_sync_swap/mute"], "mute_",
+                      ["mute_detection_rate"]),
+    "mute_original": (["mute_original"], "mute_",
+                      ["audio_present_detection_rate", "describes_audio_rate"]),
+    "swap":          (["swap", "gemini_mute_sync_swap/swap"], "swap_",
+                      ["mismatch_detection_rate"]),
+    "swap_original": (["swap_original"], "swap_",
+                      ["match_detection_rate", "correct_synced_rate"]),
+}
+
+# Suffixes attached to model names to mark which input variant was used
+INPUT_SUFFIXES = ("_audioMuxed", "_originalsControl", "_visualOnly")
+
+PROMPT_RE = re.compile(r"^(?P<model>.+)_prompt(?P<mode>[A-Za-z0-9]+)$")
+
+
+def parse_dir(name: str, prefix: str) -> tuple[str, str] | None:
+    """Return (model, prompt_mode) parsed from a result directory name."""
+    if not name.startswith(prefix):
+        return None
+    rest = name[len(prefix):]
+    m = PROMPT_RE.match(rest)
+    if not m:
+        return None
+    model = m.group("model").rstrip("_")
+    for suf in INPUT_SUFFIXES:
+        if model.endswith(suf):
+            model = model[: -len(suf)]
+            break
+    if model.startswith("gemini_"):
+        model = model[len("gemini_"):]
+    return model, m.group("mode")
+
+
+def load_metric(sub: Path, keys: list[str]) -> tuple[float, int] | None:
+    """Prefer metrics.rejudged.json (re-judged, more accurate); fall back to metrics.json."""
+    for fname in ("metrics.rejudged.json", "metrics.json"):
+        path = sub / fname
+        try:
+            data = json.loads(path.read_text())
+        except (FileNotFoundError, json.JSONDecodeError):
+            continue
+        for k in keys:
+            if k in data:
+                return float(data[k]), int(data["total_samples"])
+    return None
+
+
+def collect() -> dict[tuple[str, str], dict[str, tuple[float, int]]]:
+    rows: dict[tuple[str, str], dict[str, tuple[float, int]]] = {}
+    for task, (subpaths, prefix, keys) in TASKS.items():
+        for subpath in subpaths:
+            task_dir = ROOT / subpath
+            if not task_dir.is_dir():
+                continue
+            for sub in sorted(task_dir.iterdir()):
+                if not sub.is_dir():
+                    continue
+                parsed = parse_dir(sub.name, prefix)
+                if parsed is None:
+                    continue
+                metric = load_metric(sub, keys)
+                if metric is None:
+                    continue
+                rows.setdefault(parsed, {})[task] = metric
+    return rows
+
+
+def fmt(rate_n: tuple[float, int] | None) -> str:
+    if rate_n is None:
+        return "   —    "
+    rate, n = rate_n
+    return f"{rate * 100:5.1f}% ({n})"
+
+
+def combined(a: tuple[float, int] | None,
+             b: tuple[float, int] | None) -> tuple[float, int] | None:
+    if a is None or b is None:
+        return None
+    ra, na = a
+    rb, nb = b
+    return (ra * na + rb * nb) / (na + nb), na + nb
+
+
+def main() -> None:
+    rows = collect()
+
+    header = (
+        f"{'Model (prompt)':<70}  "
+        f"{'mute':>13}  {'mute_org':>13}  {'mute_all':>13}  "
+        f"{'swap':>13}  {'swap_org':>13}  {'swap_all':>13}"
+    )
+    print(header)
+    print("-" * len(header))
+
+    for (model, mode), entries in sorted(rows.items()):
+        mute = entries.get("mute")
+        mute_o = entries.get("mute_original")
+        swap = entries.get("swap")
+        swap_o = entries.get("swap_original")
+        label = f"{model}  [{mode}]"
+        print(
+            f"{label:<70}  "
+            f"{fmt(mute):>13}  {fmt(mute_o):>13}  {fmt(combined(mute, mute_o)):>13}  "
+            f"{fmt(swap):>13}  {fmt(swap_o):>13}  {fmt(combined(swap, swap_o)):>13}"
+        )
+
+
+if __name__ == "__main__":
+    main()

analyze_my_model.py

@@ -0,0 +1,385 @@
+"""Generate paper-quality figures comparing the user's fine-tuned model against
+two baselines (Qwen3-Omni vanilla, MiniCPM-o-4.5) on the Shift (sync) and
+VGGSoundSync benchmarks. All figures use DejaVu Serif, no titles, 300 dpi
+PDF + PNG, paper-friendly fonttype=42.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+# ---------------------------------------------------------------------------
+# Style
+# ---------------------------------------------------------------------------
+plt.rcParams.update({
+    "font.family":      "DejaVu Serif",
+    "font.serif":       ["DejaVu Serif"],
+    "mathtext.fontset": "dejavuserif",
+    "font.size":        11,
+    "axes.titlesize":   12,
+    "axes.titleweight": "bold",
+    "axes.labelsize":   11,
+    "xtick.labelsize":  10.5,
+    "ytick.labelsize":  10.5,
+    "legend.fontsize":  10,
+    "pdf.fonttype":     42,
+    "ps.fonttype":      42,
+    "savefig.dpi":      300,
+    "savefig.bbox":     "tight",
+    "axes.spines.top":   False,
+    "axes.spines.right": False,
+})
+
+# ---------------------------------------------------------------------------
+# Data sources
+# ---------------------------------------------------------------------------
+ROOT = Path("/home/ubuntu/eval_results/paper_shift_backup")
+OUT  = Path("/home/ubuntu/figs/my_model_vs_baselines")
+OUT.mkdir(parents=True, exist_ok=True)
+
+MODELS = [
+    # (display, sync_dir, vggsync_dir, color)
+    ("Qwen3-Omni",   ROOT/"sync/sync_qwen3omni_vanilla",
+                     ROOT/"vggsoundsync/vggsync_freetext_vanilla_qwen3omni_3k",
+                     "#5b8def"),
+    ("MiniCPM-o",    ROOT/"minicpmo_sync",
+                     ROOT/"minicpmo_vggsync",
+                     "#f4a04a"),
+    ("Ours",         ROOT/"sync/sync_sft_dpo_mdpo_fin_avmcqa_longform",
+                     ROOT/"vggsoundsync/vggsync_freetext_sft_dpo_mdpo_fin_avmcqa_longform_3k",
+                     "#2fa363"),
+]
+
+def load_metrics(p: Path) -> dict:
+    return json.loads((p / "metrics.json").read_text())
+
+def load_jsonl(p: Path):
+    f = p / "eval_results.jsonl"
+    if not f.exists():
+        return []
+    return [json.loads(l) for l in f.open() if l.strip()]
+
+
+# ===========================================================================
+# Figure 1 — Headline three-metric bar chart (2 panels: Shift + VGGSoundSync)
+# ===========================================================================
+def fig_headline():
+    metric_keys   = [
+        ("three_class_accuracy",        "3-class Acc."),
+        ("sync_desync_accuracy",        "Sync/Desync Acc."),
+        ("direction_accuracy_on_desync","Direction Acc."),
+    ]
+    panels = [
+        ("Shift",         [load_metrics(m[1]) for m in MODELS]),
+        ("VGGSoundSync",  [load_metrics(m[2]) for m in MODELS]),
+    ]
+
+    fig, axes = plt.subplots(1, 2, figsize=(11.0, 4.2),
+                              gridspec_kw={"wspace": 0.22})
+    n_models = len(MODELS)
+    n_metric = len(metric_keys)
+    bar_w = 0.24
+
+    for ax, (title, mets) in zip(axes, panels):
+        x = np.arange(n_metric)
+        for i, (m, met) in enumerate(zip(MODELS, mets)):
+            offsets = (i - (n_models - 1) / 2) * bar_w
+            heights = [met.get(k, 0.0) for k, _ in metric_keys]
+            bars = ax.bar(x + offsets, heights, bar_w,
+                           color=m[3], edgecolor="white", linewidth=0.6,
+                           label=m[0], zorder=3)
+            for b, v in zip(bars, heights):
+                ax.text(b.get_x() + b.get_width() / 2, v + 0.012,
+                        f"{v*100:.1f}", ha="center", va="bottom",
+                        fontsize=9, color="#1a1a1a")
+        ax.set_xticks(x)
+        ax.set_xticklabels([lbl for _, lbl in metric_keys])
+        ax.set_ylim(0, 1.05)
+        ax.set_yticks(np.arange(0, 1.01, 0.2))
+        ax.set_yticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+        ax.set_ylabel("Accuracy (%)" if ax is axes[0] else "")
+        ax.set_title(title, pad=6)
+        ax.grid(axis="y", color="#e0e0e0", lw=0.6, zorder=0)
+        ax.set_axisbelow(True)
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="upper center",
+                bbox_to_anchor=(0.5, 1.04), ncol=n_models,
+                frameon=False, fontsize=11)
+    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    fig.savefig(OUT/"fig1_headline.pdf"); fig.savefig(OUT/"fig1_headline.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Figure 2 — Per-direction accuracy on Shift (synced / delay / early)
+# ===========================================================================
+def fig_per_direction():
+    cats = [("synced_accuracy", "Synced (Orig.)"),
+            ("delay_accuracy",  "Delay"),
+            ("early_accuracy",  "Early")]
+    fig, ax = plt.subplots(figsize=(7.4, 4.0))
+    n_models = len(MODELS)
+    bar_w = 0.25
+    x = np.arange(len(cats))
+    for i, (name, sync_dir, _, color) in enumerate(MODELS):
+        m = load_metrics(sync_dir)
+        pc = m["per_category"]
+        heights = [pc[k] for k, _ in cats]
+        offsets = (i - (n_models - 1) / 2) * bar_w
+        bars = ax.bar(x + offsets, heights, bar_w, color=color,
+                       edgecolor="white", linewidth=0.6, label=name, zorder=3)
+        for b, v in zip(bars, heights):
+            ax.text(b.get_x() + b.get_width()/2, v + 0.012,
+                    f"{v*100:.1f}", ha="center", va="bottom",
+                    fontsize=9, color="#1a1a1a")
+    ax.set_xticks(x); ax.set_xticklabels([lbl for _, lbl in cats])
+    ax.set_ylim(0, 1.10)
+    ax.set_yticks(np.arange(0, 1.01, 0.2))
+    ax.set_yticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+    ax.set_ylabel("Accuracy (%)")
+    ax.grid(axis="y", color="#e0e0e0", lw=0.6, zorder=0); ax.set_axisbelow(True)
+    ax.legend(loc="upper right", frameon=False)
+    fig.tight_layout()
+    fig.savefig(OUT/"fig2_per_direction.pdf"); fig.savefig(OUT/"fig2_per_direction.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Figure 3 — Per-difficulty line chart on VGGSoundSync
+# ===========================================================================
+def fig_per_difficulty():
+    diff_order = ["synced", "very_easy", "easy", "medium", "hard"]
+    diff_labels = ["Orig.\n(synced)", "Very Easy\n(2.0–2.5s)",
+                   "Easy\n(1.5–2.0s)", "Medium\n(1.0–1.5s)",
+                   "Hard\n(0.5–1.0s)"]
+    fig, ax = plt.subplots(figsize=(8.2, 4.4))
+    x = np.arange(len(diff_order))
+    for name, _, vggsync_dir, color in MODELS:
+        m = load_metrics(vggsync_dir)
+        pd_ = m["per_difficulty"]
+        ys = [pd_[d]["accuracy"] for d in diff_order]
+        ax.plot(x, ys, marker="o", linewidth=2.2, markersize=8.5,
+                color=color, label=name, markeredgecolor="white",
+                markeredgewidth=1.2, zorder=3)
+        for xi, v in zip(x, ys):
+            ax.text(xi, v + 0.025, f"{v*100:.0f}", ha="center", va="bottom",
+                    fontsize=9, color=color)
+    ax.set_xticks(x); ax.set_xticklabels(diff_labels)
+    ax.set_ylim(0, 1.0)
+    ax.set_yticks(np.arange(0, 1.01, 0.2))
+    ax.set_yticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+    ax.set_ylabel("Accuracy (%)")
+    ax.set_xlabel("VGGSoundSync difficulty bucket  (offset magnitude shown)")
+    ax.grid(axis="y", color="#e0e0e0", lw=0.6, zorder=0); ax.set_axisbelow(True)
+    ax.legend(loc="upper right", frameon=False)
+    fig.tight_layout()
+    fig.savefig(OUT/"fig3_per_difficulty.pdf"); fig.savefig(OUT/"fig3_per_difficulty.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Figure 4 — Offset CDF on Shift and VGGSoundSync (two panels)
+# ===========================================================================
+def _abs_offset_errors(rows):
+    """Extract |pred_offset - gt_offset| only on samples where the model
+    actually claimed a desync (i.e. produced a non-zero offset)."""
+    out = []
+    for r in rows:
+        gt_off = r.get("gt_offset_sec")
+        if gt_off is None:
+            continue
+        # gt_synced=True samples have no offset to evaluate
+        if r.get("gt_synced") is True:
+            continue
+        pred_off = r.get("pred_offset_sec")
+        if pred_off is None:
+            continue
+        # only include evaluations where the model also said it was offset
+        if r.get("pred_synced") is True:
+            continue
+        out.append(abs(float(pred_off) - float(gt_off)))
+    return np.array(out, dtype=float)
+
+
+def fig_offset_cdf():
+    fig, axes = plt.subplots(1, 2, figsize=(11.0, 4.2),
+                              gridspec_kw={"wspace": 0.22})
+    panels = [
+        ("Shift",        [m[1] for m in MODELS]),
+        ("VGGSoundSync", [m[2] for m in MODELS]),
+    ]
+    thresholds = np.linspace(0, 3.0, 121)
+    for ax, (title, dirs) in zip(axes, panels):
+        for (name, _, _, color), d in zip(MODELS, dirs):
+            rows = load_jsonl(d)
+            errs = _abs_offset_errors(rows)
+            if len(errs) == 0:
+                continue
+            # CDF over ALL desync samples (denominator = total desync gt count)
+            n_desync = sum(1 for r in rows
+                            if r.get("gt_synced") is False
+                            or r.get("gt_direction") in ("delay", "early"))
+            ys = [(errs <= t).sum() / max(n_desync, 1) for t in thresholds]
+            ax.plot(thresholds, ys, color=color, linewidth=2.4,
+                    label=name, zorder=3)
+            # mark the value at 0.5s (a key threshold) with a dot
+            t_mark = 0.5
+            y_mark = (errs <= t_mark).sum() / max(n_desync, 1)
+            ax.scatter([t_mark], [y_mark], s=70, color=color,
+                       edgecolor="white", linewidth=1.2, zorder=4)
+            ax.text(t_mark + 0.05, y_mark + 0.018,
+                    f"{y_mark*100:.0f}%", color=color, fontsize=9,
+                    weight="bold")
+        ax.set_xlim(0, 3.0)
+        ax.set_ylim(0, 1.0)
+        ax.set_yticks(np.arange(0, 1.01, 0.2))
+        ax.set_yticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+        ax.set_xlabel("Offset error tolerance |Δ| (sec)")
+        ax.set_ylabel("Fraction of desync samples within tolerance (%)"
+                      if ax is axes[0] else "")
+        ax.set_title(title, pad=6)
+        ax.axvline(0.5, color="#bbb", linestyle=":", linewidth=0.8, zorder=1)
+        ax.grid(axis="both", color="#e8e8e8", lw=0.5, zorder=0)
+        ax.set_axisbelow(True)
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="upper center",
+                bbox_to_anchor=(0.5, 1.04), ncol=len(MODELS),
+                frameon=False, fontsize=11)
+    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    fig.savefig(OUT/"fig4_offset_cdf.pdf"); fig.savefig(OUT/"fig4_offset_cdf.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Figure 5 — Per-class scatter on VGGSoundSync (vanilla vs ours)
+# ===========================================================================
+def fig_per_class_scatter():
+    vanilla = load_metrics(MODELS[0][2])["per_class"]
+    ours    = load_metrics(MODELS[2][2])["per_class"]
+    minicpm = load_metrics(MODELS[1][2])["per_class"]
+    classes = sorted(set(vanilla) & set(ours) & set(minicpm))
+
+    fig, axes = plt.subplots(1, 2, figsize=(11.0, 5.2),
+                              gridspec_kw={"wspace": 0.25})
+
+    panels = [
+        (axes[0], "vs Qwen3-Omni",  vanilla, MODELS[0][3]),
+        (axes[1], "vs MiniCPM-o",   minicpm, MODELS[1][3]),
+    ]
+    for ax, sub_title, baseline_d, base_color in panels:
+        bx = np.array([baseline_d[c]["accuracy"]    for c in classes])
+        oy = np.array([ours[c]["accuracy"]          for c in classes])
+        sizes = np.array([vanilla[c]["count"]       for c in classes])
+        # Use lighter "base_color" mix for the dots; gradient by sample count
+        ax.scatter(bx, oy, s=10 + sizes * 1.5,
+                    color="#2fa363", alpha=0.65,
+                    edgecolor="white", linewidth=0.5, zorder=3)
+        ax.plot([0, 1], [0, 1], ls="--", color="#888", lw=1.0, zorder=2)
+        # Highlight a few extreme points with class names
+        deltas = oy - bx
+        top_imp = np.argsort(-deltas)[:5]
+        bot_imp = np.argsort(deltas)[:3]
+        for idx in list(top_imp) + list(bot_imp):
+            ax.annotate(classes[idx], (bx[idx], oy[idx]),
+                        xytext=(4, 4), textcoords="offset points",
+                        fontsize=7.5, color="#444", style="italic")
+        # Stats annotation
+        win = (deltas > 0).sum()
+        ax.text(0.02, 0.97,
+                f"Ours wins on {win}/{len(classes)} classes\n"
+                f"Mean Δ = +{deltas.mean()*100:.1f} pts",
+                transform=ax.transAxes, va="top", ha="left",
+                fontsize=10, color="#1a1a1a",
+                bbox=dict(facecolor="#fefef0", edgecolor="#888",
+                          boxstyle="round,pad=0.35"))
+        ax.set_xlim(0, 1.0); ax.set_ylim(0, 1.0)
+        ax.set_xticks(np.arange(0, 1.01, 0.2))
+        ax.set_yticks(np.arange(0, 1.01, 0.2))
+        ax.set_xticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+        ax.set_yticklabels([f"{int(v*100)}" for v in np.arange(0, 1.01, 0.2)])
+        ax.set_xlabel(f"Baseline accuracy {sub_title.split()[1]} (%)")
+        ax.set_ylabel("Ours accuracy (%)" if ax is axes[0] else "")
+        ax.set_title(sub_title, pad=6)
+        ax.grid(color="#eee", lw=0.5, zorder=0)
+        ax.set_axisbelow(True)
+    fig.tight_layout()
+    fig.savefig(OUT/"fig5_per_class_scatter.pdf")
+    fig.savefig(OUT/"fig5_per_class_scatter.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Figure 6 — Within-tolerance bar grid (offset attribution success)
+# ===========================================================================
+def fig_within_thresholds():
+    """Show the % of desync samples for which the predicted offset is within a
+    fixed tolerance, computed against the FULL desync sample count (not just
+    samples where the model attempted an offset)."""
+    fig, axes = plt.subplots(1, 2, figsize=(11.0, 4.2),
+                              gridspec_kw={"wspace": 0.22})
+    sync_thresh   = ["offset_within_0.5s", "offset_within_1.0s"]
+    sync_labels   = ["≤ 0.5 s", "≤ 1.0 s"]
+    vggsync_thresh = ["offset_within_0.2s", "offset_within_0.5s"]
+    vggsync_labels = ["≤ 0.2 s", "≤ 0.5 s"]
+    panels = [
+        ("Shift",        sync_thresh,    sync_labels,   1),
+        ("VGGSoundSync", vggsync_thresh, vggsync_labels, 2),
+    ]
+    bar_w = 0.25
+
+    for ax, (title, ks, labs, dir_idx) in zip(axes, panels):
+        x = np.arange(len(ks))
+        # denominator: total desync samples (= total - synced_count)
+        for i, (name, sd, vd, color) in enumerate(MODELS):
+            m = load_metrics(sd if dir_idx == 1 else vd)
+            if dir_idx == 1:
+                n_synced = m["per_category"]["synced_count"]
+            else:
+                n_synced = m["per_difficulty"]["synced"]["count"]
+            n_desync = m["total_samples"] - n_synced
+            heights = [m.get(k, 0) / max(n_desync, 1) for k in ks]
+            offsets = (i - (len(MODELS) - 1) / 2) * bar_w
+            bars = ax.bar(x + offsets, heights, bar_w, color=color,
+                           edgecolor="white", linewidth=0.6,
+                           label=name, zorder=3)
+            for b, v in zip(bars, heights):
+                ax.text(b.get_x() + b.get_width()/2, v + 0.012,
+                        f"{v*100:.1f}", ha="center", va="bottom",
+                        fontsize=9, color="#1a1a1a")
+        ax.set_xticks(x); ax.set_xticklabels(labs)
+        ax.set_xlabel("Offset tolerance")
+        ax.set_ylim(0, max(0.4, ax.get_ylim()[1]) + 0.05)
+        ax.set_ylabel("Desync samples within tolerance (%)"
+                      if ax is axes[0] else "")
+        ax.set_title(title, pad=6)
+        ax.grid(axis="y", color="#e0e0e0", lw=0.6, zorder=0)
+        ax.set_axisbelow(True)
+        # convert ticks to %
+        yticks = ax.get_yticks()
+        ax.set_yticklabels([f"{int(v*100)}" for v in yticks])
+    handles, labels = axes[0].get_legend_handles_labels()
+    fig.legend(handles, labels, loc="upper center",
+                bbox_to_anchor=(0.5, 1.04), ncol=len(MODELS),
+                frameon=False, fontsize=11)
+    fig.tight_layout(rect=(0, 0, 1, 0.95))
+    fig.savefig(OUT/"fig6_within_thresholds.pdf")
+    fig.savefig(OUT/"fig6_within_thresholds.png")
+    plt.close(fig)
+
+
+# ===========================================================================
+# Run all
+# ===========================================================================
+if __name__ == "__main__":
+    fig_headline()
+    fig_per_direction()
+    fig_per_difficulty()
+    fig_offset_cdf()
+    fig_per_class_scatter()
+    fig_within_thresholds()
+    print("All figures saved to:", OUT)
+    for p in sorted(OUT.glob("*.png")):
+        print(" ", p.name)

build_candidate_pool.py

@@ -0,0 +1,128 @@
+"""Build the candidate pool for case study (BEFORE re-running Gemini).
+
+Selection rule (only the trustworthy signals):
+  - Qwen   failed mute  (raw_output == 'yes', i.e. real hallucination)
+  - Qwen   failed swap  (raw_output == 'yes', real false-match)
+  - Qwen   failed BOTH delay AND early sync
+  - Gemini failed swap  (raw_output == 'yes', real false-match)
+
+Skipped on purpose:
+  - Gemini mute direct: all wrong rows are empty raw_output -> not real signal
+  - Gemini sync       : we will re-run this on the candidate pool
+
+Writes pool to /home/ubuntu/case_study_pool.jsonl
+"""
+
+import json
+import re
+from pathlib import Path
+
+GEMINI_SWAP = "/home/ubuntu/eval_results/gemini_mute_sync_swap/swap/swap_gemini_gemini-3.1-pro-preview__promptDirect/eval_results.jsonl"
+QWEN_MUTE   = "/home/ubuntu/eval_results/mute/mute_qwen3omni_vanilla_promptDirect/eval_results.jsonl"
+QWEN_SWAP   = "/home/ubuntu/eval_results/swap/swap_Qwen_Qwen3-Omni-30B-A3B-Instruct_promptDirect/eval_results.jsonl"
+QWEN_SYNC   = "/home/ubuntu/eval_results/sync/sync_qwen3omni_vanilla/eval_results.jsonl"
+
+OUT_PATH = Path("/home/ubuntu/case_study_pool.jsonl")
+
+SYNC_SUFFIX_RE = re.compile(r"_(delay|early)_\d+(?:\.\d+)?s(?=\.mp4$)")
+DIRECTION_RE   = re.compile(r"_(delay|early)_(\d+(?:\.\d+)?)s\.mp4$")
+
+
+def base_of(name): return SYNC_SUFFIX_RE.sub("", name)
+def direction_of(name):
+    m = DIRECTION_RE.search(name)
+    return m.group(1) if m else None
+
+
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def real_yes_wrong(jsonl_path):
+    """Wrong rows whose raw_output is actually 'yes' (drops empty/ambiguous artifacts)."""
+    out = set()
+    for r in load_jsonl(jsonl_path):
+        if r.get("correct", True):
+            continue
+        raw = (r.get("raw_output") or "").strip().lower()
+        if raw.startswith("yes"):
+            out.add(r["video"])
+    return out
+
+
+def sync_is_wrong(row):
+    gt_synced = bool(row.get("gt_synced"))
+    pred_synced = bool(row.get("pred_synced"))
+    if gt_synced != pred_synced:
+        return True
+    if not gt_synced and row.get("pred_direction") != row.get("gt_direction"):
+        return True
+    return False
+
+
+def collect_qwen_sync_intervention_failures(jsonl_path):
+    by_base = {}
+    for r in load_jsonl(jsonl_path):
+        v = r["video"]
+        d = direction_of(v)
+        if d is None:
+            continue  # skip the synced original
+        if sync_is_wrong(r):
+            by_base.setdefault(base_of(v), {})[d] = {
+                "variant": v,
+                "gt": (r.get("gt_direction"), r.get("gt_offset_sec")),
+                "pred_synced": r.get("pred_synced"),
+                "pred": (r.get("pred_direction"), r.get("pred_offset_sec")),
+            }
+    return by_base
+
+
+def main():
+    qwen_mute_yes = real_yes_wrong(QWEN_MUTE)
+    qwen_swap_yes = real_yes_wrong(QWEN_SWAP)
+    gem_swap_yes  = real_yes_wrong(GEMINI_SWAP)
+    qwen_sync_fails = collect_qwen_sync_intervention_failures(QWEN_SYNC)
+    qwen_sync_both  = {b for b, dirs in qwen_sync_fails.items()
+                       if "delay" in dirs and "early" in dirs}
+
+    print("Per-source REAL wrong sets (raw_output='yes' only):")
+    print(f"  qwen   mute yes-hallucinations : {len(qwen_mute_yes)}")
+    print(f"  qwen   swap yes-false-match    : {len(qwen_swap_yes)}")
+    print(f"  qwen   sync (delay AND early)  : {len(qwen_sync_both)}")
+    print(f"  gemini swap yes-false-match    : {len(gem_swap_yes)}")
+
+    pool = qwen_mute_yes & qwen_swap_yes & qwen_sync_both & gem_swap_yes
+    print(f"\nPool (4-way real intersection): {len(pool)} videos")
+
+    qwen_swap_rows = {r["video"]: r for r in load_jsonl(QWEN_SWAP)
+                      if not r.get("correct", True)}
+    gem_swap_rows  = {r["video"]: r for r in load_jsonl(GEMINI_SWAP)
+                      if not r.get("correct", True)}
+
+    rows = []
+    for v in sorted(pool):
+        rec = {
+            "video": v,
+            "gemini_swap_audio_from": gem_swap_rows.get(v, {}).get("swapped_from"),
+            "qwen_swap_audio_from":   qwen_swap_rows.get(v, {}).get("swapped_from"),
+            "qwen_sync_failures":     [qwen_sync_fails[v]["delay"],
+                                       qwen_sync_fails[v]["early"]],
+        }
+        rows.append(rec)
+
+    with open(OUT_PATH, "w") as f:
+        for rec in rows:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"[saved] {len(rows)} rows -> {OUT_PATH}")
+
+    print("\nPool videos:")
+    for r in rows:
+        print(f"  {r['video']}")
+
+
+if __name__ == "__main__":
+    main()

case_study_gemini_mute_neutral.py

@@ -0,0 +1,126 @@
+"""Re-run Gemini mute on the 6 case-study candidates with NEUTRAL prompt.
+
+Direct prompt failures for Gemini all turned out to be empty responses (API
+artifacts), not real audio hallucinations. Neutral prompt ("Describe the audio
+you hear") forces an open-ended answer; OpenAI judge classifies whether the
+response hallucinates audio content vs correctly reports silence.
+
+Pipeline:
+  1. Read /home/ubuntu/case_study_candidates.jsonl (6 base videos).
+  2. Build a 6-row test jsonl (mute loader dedupes to base originals only).
+  3. Run scripts/eval_gemini_mute_sync_swap.py --tasks mute
+       --mute-prompt-mode neutral --openai-judge.
+  4. Print per-video raw_output + judge classification.
+
+Usage:
+  GEMINI_API_KEY=... OPENAI_API_KEY=... python3 /home/ubuntu/case_study_gemini_mute_neutral.py
+"""
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+REPO        = Path("/home/ubuntu/CleverHans-Evaluation")
+TEST_JSONL  = REPO / "data" / "kto_training_data_v2_test.jsonl"
+EVAL_SCRIPT = REPO / "scripts" / "eval_gemini_mute_sync_swap.py"
+DATA_ROOT   = Path("/opt/dlami/nvme/video_source")
+CANDIDATES  = Path("/home/ubuntu/case_study_pool.jsonl")  # 45-video pool
+
+OUT_ROOT      = Path("/home/ubuntu/eval_results/case_study_pool")
+FILTERED_JSON = OUT_ROOT / "mute_test.jsonl"
+LABEL         = "case_study_pool_gemini_mute_neutral"
+GEMINI_RESULT = OUT_ROOT / "mute" / LABEL / "eval_results.jsonl"
+
+
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def step_filter():
+    bases = {row["video"] for row in load_jsonl(CANDIDATES)}
+    print(f"[filter] {len(bases)} base videos from {CANDIDATES}")
+
+    OUT_ROOT.mkdir(parents=True, exist_ok=True)
+    kept = []
+    for row in load_jsonl(TEST_JSONL):
+        v = row["video"]
+        if "_delay_" in v or "_early_" in v:
+            continue
+        if v in bases:
+            kept.append(row)
+
+    with open(FILTERED_JSON, "w") as f:
+        for row in kept:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    print(f"[filter] kept {len(kept)} rows -> {FILTERED_JSON}")
+    if len(kept) != len(bases):
+        print(f"[warn] expected {len(bases)} rows, got {len(kept)}")
+
+
+def step_run(gemini_key, openai_key, model, workers):
+    env = os.environ.copy()
+    env["GEMINI_API_KEY"] = gemini_key
+    env["OPENAI_API_KEY"] = openai_key
+
+    cmd = [
+        sys.executable, str(EVAL_SCRIPT),
+        "--tasks", "mute",
+        "--model", model,
+        "--data-root", str(DATA_ROOT),
+        "--test-jsonl", str(FILTERED_JSON),
+        "--output-dir", str(OUT_ROOT),
+        "--label", LABEL,
+        "--mute-prompt-mode", "neutral",
+        "--openai-judge",
+        "--workers", str(workers),
+    ]
+    print(f"[run] {' '.join(cmd)}")
+    subprocess.run(cmd, env=env, check=True)
+
+
+def step_report():
+    if not GEMINI_RESULT.exists():
+        sys.exit(f"[error] expected results at {GEMINI_RESULT}")
+    rows = list(load_jsonl(GEMINI_RESULT))
+    print(f"\n[report] {len(rows)} mute samples (neutral, OpenAI judged):")
+    for r in rows:
+        v = r["video"]
+        pred = r.get("pred_label")
+        correct = r.get("correct")
+        raw = (r.get("raw_output") or "").strip().replace("\n", " ")[:240]
+        je = (r.get("judge_explanation") or "").strip()[:120]
+        print(f"\n  VIDEO: {v}")
+        print(f"    pred={pred}  correct={correct}")
+        print(f"    raw : {raw!r}")
+        if je:
+            print(f"    judge: {je}")
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--gemini-key", default=os.environ.get("GEMINI_API_KEY"))
+    p.add_argument("--openai-key", default=os.environ.get("OPENAI_API_KEY"))
+    p.add_argument("--model", default="gemini-3.1-pro-preview")
+    p.add_argument("--workers", type=int, default=4)
+    p.add_argument("--skip-run", action="store_true")
+    args = p.parse_args()
+
+    step_filter()
+    if not args.skip_run:
+        if not args.gemini_key:
+            sys.exit("[error] need --gemini-key or GEMINI_API_KEY env")
+        if not args.openai_key:
+            sys.exit("[error] need --openai-key or OPENAI_API_KEY env")
+        step_run(args.gemini_key, args.openai_key, args.model, args.workers)
+    step_report()
+
+
+if __name__ == "__main__":
+    main()

case_study_gemini_sync.py

@@ -0,0 +1,165 @@
+"""Re-test the 12 case-study candidates' sync variants on Gemini.
+
+Pipeline:
+  1. Read /home/ubuntu/case_study_candidates.jsonl (12 base videos).
+  2. Filter the master test jsonl to the 36 rows that belong to those 12 bases
+     (each base + its delay + early variant).
+  3. Invoke scripts/eval_gemini_mute_sync_swap.py --task sync --openai-parse-sync.
+  4. Read the Gemini sync results and report which of the 36 are wrong, using
+     the same correctness rule as find_case_study.py:
+        wrong = (gt_synced != pred_synced) OR
+                (not gt_synced AND pred_direction != gt_direction)
+
+Usage:
+  GEMINI_API_KEY=... OPENAI_API_KEY=... python3 /home/ubuntu/case_study_gemini_sync.py
+or pass --gemini-key / --openai-key.
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+REPO          = Path("/home/ubuntu/CleverHans-Evaluation")
+TEST_JSONL    = REPO / "data" / "kto_training_data_v2_test.jsonl"
+EVAL_SCRIPT   = REPO / "scripts" / "eval_gemini_mute_sync_swap.py"
+DATA_ROOT     = Path("/opt/dlami/nvme/video_source")
+CANDIDATES    = Path("/home/ubuntu/case_study_pool.jsonl")  # 45-video pool
+
+OUT_ROOT      = Path("/home/ubuntu/eval_results/case_study_pool")
+FILTERED_JSON = OUT_ROOT / "sync_test.jsonl"
+LABEL         = "case_study_pool_gemini_sync"
+GEMINI_RESULT = OUT_ROOT / "sync" / LABEL / "eval_results.jsonl"
+WRONG_OUT     = OUT_ROOT / "gemini_wrong.jsonl"
+
+SYNC_SUFFIX_RE = re.compile(r"_(delay|early)_\d+(?:\.\d+)?s(?=\.mp4$)")
+
+
+def base_of(name: str) -> str:
+    return SYNC_SUFFIX_RE.sub("", name)
+
+
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def step_filter():
+    bases = {row["video"] for row in load_jsonl(CANDIDATES)}
+    print(f"[filter] {len(bases)} base videos from {CANDIDATES}")
+
+    OUT_ROOT.mkdir(parents=True, exist_ok=True)
+    kept = []
+    for row in load_jsonl(TEST_JSONL):
+        if base_of(row["video"]) in bases:
+            kept.append(row)
+
+    with open(FILTERED_JSON, "w") as f:
+        for row in kept:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    print(f"[filter] kept {len(kept)} rows -> {FILTERED_JSON}")
+    if len(kept) != 3 * len(bases):
+        print(f"[warn] expected {3*len(bases)} rows (3 per base), got {len(kept)}")
+
+
+def step_run_gemini(gemini_key: str, openai_key: str, model: str, workers: int):
+    env = os.environ.copy()
+    env["GEMINI_API_KEY"] = gemini_key
+    env["OPENAI_API_KEY"] = openai_key
+
+    cmd = [
+        sys.executable, str(EVAL_SCRIPT),
+        "--task", "sync",
+        "--model", model,
+        "--data-root", str(DATA_ROOT),
+        "--test-jsonl", str(FILTERED_JSON),
+        "--output-dir", str(OUT_ROOT),
+        "--label", LABEL,
+        "--openai-parse-sync",
+        "--workers", str(workers),
+    ]
+    print(f"[run] {' '.join(cmd)}")
+    subprocess.run(cmd, env=env, check=True)
+
+
+def step_report():
+    if not GEMINI_RESULT.exists():
+        sys.exit(f"[error] expected results at {GEMINI_RESULT}; eval did not produce one")
+
+    rows = list(load_jsonl(GEMINI_RESULT))
+    wrong = []
+    for r in rows:
+        gt_synced = bool(r["gt_synced"])
+        pred_synced = bool(r["pred_synced"])
+        is_wrong = (gt_synced != pred_synced) or (
+            (not gt_synced) and r.get("pred_direction") != r.get("gt_direction")
+        )
+        if is_wrong:
+            wrong.append({
+                "video": r["video"],
+                "base": base_of(r["video"]),
+                "gt": (r["gt_direction"], r["gt_offset_sec"]),
+                "pred_synced": pred_synced,
+                "pred": (r.get("pred_direction"), r.get("pred_offset_sec")),
+                "raw": r.get("raw_output", "")[:200],
+            })
+
+    by_base = {}
+    for w in wrong:
+        by_base.setdefault(w["base"], []).append(w)
+
+    print(f"\n[report] {len(rows)} sync samples evaluated, {len(wrong)} wrong")
+    print(f"[report] wrong distribution by base video:")
+    for base in sorted(by_base):
+        hits = by_base[base]
+        print(f"\n  {base}  ({len(hits)} variant(s) wrong)")
+        for h in hits:
+            print(f"    - {h['video']}")
+            print(f"        gt={h['gt']}  pred_synced={h['pred_synced']}  pred={h['pred']}")
+
+    with open(WRONG_OUT, "w") as f:
+        for w in wrong:
+            f.write(json.dumps(w, ensure_ascii=False) + "\n")
+    print(f"\n[saved] wrong rows -> {WRONG_OUT}")
+
+    bases_total = {base_of(r["video"]) for r in rows}
+    bases_any_wrong = set(by_base)
+    bases_all_three_wrong = {b for b, hs in by_base.items()
+                             if len(hs) == 3}
+    print(f"\n[summary]")
+    print(f"  candidates with >=1 wrong sync : {len(bases_any_wrong)} / {len(bases_total)}")
+    print(f"  candidates with all 3 wrong    : {len(bases_all_three_wrong)} / {len(bases_total)}")
+    if bases_all_three_wrong:
+        print(f"  perfect-fail candidates:")
+        for b in sorted(bases_all_three_wrong):
+            print(f"    - {b}")
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--gemini-key", default=os.environ.get("GEMINI_API_KEY"))
+    p.add_argument("--openai-key", default=os.environ.get("OPENAI_API_KEY"))
+    p.add_argument("--model", default="gemini-3.1-pro-preview")
+    p.add_argument("--workers", type=int, default=4)
+    p.add_argument("--skip-run", action="store_true",
+                   help="Skip the Gemini call (use existing results to re-report).")
+    args = p.parse_args()
+
+    step_filter()
+    if not args.skip_run:
+        if not args.gemini_key:
+            sys.exit("[error] need --gemini-key or GEMINI_API_KEY env")
+        if not args.openai_key:
+            sys.exit("[error] need --openai-key or OPENAI_API_KEY env")
+        step_run_gemini(args.gemini_key, args.openai_key, args.model, args.workers)
+    step_report()
+
+
+if __name__ == "__main__":
+    main()

case_study_gpt55.py

@@ -0,0 +1,582 @@
+"""Evaluate GPT-5.5 on the FULL test set: sync (426), mute neutral (142), swap direct (142).
+
+GPT-5.5 chat.completions does NOT accept input_audio (audio is gated to
+gpt-4o-audio-preview / realtime). We therefore send VIDEO FRAMES ONLY (8 frames
+sampled evenly per clip) + the appropriate text prompt. This is a documented
+handicap — the resulting numbers reflect what GPT-5.5 can do without hearing
+the audio.
+
+Audio is intentionally NOT extracted; for sync the model has no temporal audio
+cue, for mute the audio is silent anyway, for swap the model can't hear the
+donor track.
+
+Outputs (label includes _visualOnly to flag the handicap):
+  ~/eval_results/sync/sync_gpt-5.5_visualOnly/
+  ~/eval_results/mute/mute_gpt-5.5_visualOnly_promptNeutral/
+  ~/eval_results/swap/swap_gpt-5.5_visualOnly_promptDirect/
+
+Swap donor pairing reuses the assignments from the Gemini swap eval
+(same seed=42, so identical to Qwen swap pairing too).
+
+Usage:
+  OPENAI_API_KEY=sk-... python3 /home/ubuntu/case_study_gpt55.py
+"""
+
+import argparse
+import base64
+import json
+import os
+import re
+import subprocess
+import sys
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+DATA_ROOT     = Path("/opt/dlami/nvme/video_source")
+ORIG_DIR      = DATA_ROOT / "original" / "uag_oops"
+DELAY_DIR     = DATA_ROOT / "random_shift_video" / "delay"
+EARLY_DIR     = DATA_ROOT / "random_shift_video" / "early"
+
+TEST_JSONL    = Path("/home/ubuntu/CleverHans-Evaluation/data/kto_training_data_v2_test.jsonl")
+GEMINI_SWAP   = Path("/home/ubuntu/eval_results/gemini_mute_sync_swap/swap/"
+                     "swap_gemini_gemini-3.1-pro-preview__promptDirect/eval_results.jsonl")
+
+EVAL_ROOT     = Path("/home/ubuntu/eval_results")
+FFMPEG        = "/home/ubuntu/anaconda3/envs/video/bin/ffmpeg"
+FFPROBE       = "/home/ubuntu/anaconda3/envs/video/bin/ffprobe"
+
+DIR_OFFSET_RE = re.compile(r"_(delay|early)_(\d+(?:\.\d+)?)s\.mp4$")
+
+# ---------------------------------------------------------------------------
+# Prompts (mirror eval_gemini_mute_sync_swap.py)
+# ---------------------------------------------------------------------------
+SYNC_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."
+)
+MUTE_PROMPT_NEUTRAL = "Describe the audio you hear in this video."
+SWAP_PROMPT_DIRECT  = (
+    "Does the audio in this video match the visual content? "
+    "Answer with only 'yes' or 'no'."
+)
+
+SYNC_PARSE_SYSTEM = (
+    "You parse a free-form judgement about whether the audio in a short video is "
+    "synchronized with the visuals. Return STRICT JSON only with keys: "
+    "synced (bool), direction (one of 'delay'|'early'|'none'), "
+    "offset_sec (number, 0 if synced), t_v (number|null, visual cue time), "
+    "t_a (number|null, audio cue time), explanation (string). "
+    "If the answer says they are aligned, set synced=true, direction='none', offset_sec=0."
+)
+MUTE_JUDGE_SYSTEM = (
+    "You are evaluating a model's response about a video whose audio has been secretly "
+    "replaced with silence. Classify into ONE of: "
+    '{"prediction": "muted"|"synced"|"delay"|"early", "explanation": "<one sentence>"}. '
+    "Rules: "
+    "- 'muted' iff the model says no audio / silence / no audible sound. "
+    "- 'synced' iff the model describes audio that matches the visuals (HALLUCINATION). "
+    "- 'delay'/'early' iff the model claims a temporal offset. "
+    "Return STRICT JSON only."
+)
+
+
+# ---------------------------------------------------------------------------
+# Small utilities
+# ---------------------------------------------------------------------------
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def parse_gt_from_name(video_name: str) -> Dict[str, Any]:
+    m = DIR_OFFSET_RE.search(video_name)
+    if m:
+        return {"synced": False, "direction": m.group(1), "offset_sec": float(m.group(2))}
+    return {"synced": True, "direction": "none", "offset_sec": 0.0}
+
+
+def video_path_for(video_name: str) -> Optional[Path]:
+    """Resolve a sync test name to its on-disk mp4 (synced original / delay / early)."""
+    m = DIR_OFFSET_RE.search(video_name)
+    if m is None:
+        p = ORIG_DIR / video_name
+    elif m.group(1) == "delay":
+        p = DELAY_DIR / video_name
+    else:
+        p = EARLY_DIR / video_name
+    return p if p.exists() else None
+
+
+def video_duration(path: Path) -> float:
+    out = subprocess.run(
+        [FFPROBE, "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=noprint_wrappers=1:nokey=1", str(path)],
+        capture_output=True, text=True, check=True,
+    )
+    try:
+        return float(out.stdout.strip())
+    except ValueError:
+        return 5.0
+
+
+def extract_frames_b64(video_path: Path, n_frames: int = 8) -> List[str]:
+    dur = video_duration(video_path)
+    if dur <= 0.05:
+        dur = 0.5
+    timestamps = [dur * (i + 0.5) / n_frames for i in range(n_frames)]
+    out = []
+    with tempfile.TemporaryDirectory() as td:
+        for i, t in enumerate(timestamps):
+            png = Path(td) / f"f_{i:02d}.png"
+            subprocess.run(
+                [FFMPEG, "-y", "-ss", f"{t:.3f}", "-i", str(video_path),
+                 "-frames:v", "1", "-vf", "scale=512:-2",
+                 "-loglevel", "error", str(png)],
+                check=True,
+            )
+            out.append(base64.b64encode(png.read_bytes()).decode())
+    return out
+
+
+# ---------------------------------------------------------------------------
+# OpenAI calls (frames-only multimodal: text + images)
+# ---------------------------------------------------------------------------
+def _client(api_key: str):
+    from openai import OpenAI
+    return OpenAI(api_key=api_key)
+
+
+def call_gpt_frames(client, model, prompt, frames_b64,
+                    max_tokens=4000, temperature=0.0,
+                    reasoning_effort="minimal", _diag=True) -> str:
+    """Send text + frames to a (possibly-reasoning) GPT model.
+
+    GPT-5 family is a reasoning model: max_completion_tokens covers BOTH the
+    hidden reasoning trace AND the visible content. If the token budget is too
+    low, content can come back empty. We:
+      - bump max_completion_tokens to 4000
+      - pass reasoning_effort='minimal' to keep most of the budget for content
+      - retry once on temperature-rejection
+      - if content is still empty, fall through with a diagnostic-friendly log
+    """
+    content: List[Dict[str, Any]] = [{"type": "text", "text": prompt}]
+    for fb in frames_b64:
+        content.append({"type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{fb}"}})
+
+    base = dict(
+        model=model,
+        messages=[{"role": "user", "content": content}],
+        max_completion_tokens=max_tokens,
+    )
+
+    def _try(extra):
+        return client.chat.completions.create(**base, **extra)
+
+    resp = None
+    for kwargs in (
+        {"temperature": temperature, "reasoning_effort": reasoning_effort},
+        {"reasoning_effort": reasoning_effort},          # drop temp
+        {"temperature": temperature},                     # drop reasoning_effort
+        {},                                               # both stripped
+    ):
+        try:
+            resp = _try(kwargs)
+            break
+        except Exception as exc:
+            last_err = exc
+            continue
+    if resp is None:
+        raise last_err
+
+    msg = resp.choices[0].message
+    text = (msg.content or "").strip()
+    if not text:
+        # Diagnostic: surface finish_reason / refusal / usage so we can see why.
+        fin = resp.choices[0].finish_reason
+        refusal = getattr(msg, "refusal", None)
+        usage = getattr(resp, "usage", None)
+        if _diag:
+            print(f"  [gpt empty] finish={fin}  refusal={refusal}  usage={usage}",
+                  flush=True)
+    return text
+
+
+def call_judge(client, judge_model, system_prompt, user_text) -> Optional[Dict[str, Any]]:
+    try:
+        resp = client.chat.completions.create(
+            model=judge_model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_text},
+            ],
+            response_format={"type": "json_object"},
+            max_completion_tokens=300,
+        )
+        return json.loads(resp.choices[0].message.content or "")
+    except Exception as exc:
+        print(f"  [judge] error: {exc}", flush=True)
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Per-task runners (frames-only)
+# ---------------------------------------------------------------------------
+def run_one_sync(client, model, judge_model, item, n_frames):
+    raw = call_gpt_frames(
+        client, model, SYNC_PROMPT,
+        extract_frames_b64(item["video_path"], n_frames),
+    )
+    parsed = call_judge(client, judge_model, SYNC_PARSE_SYSTEM, raw) or {}
+    direction = str(parsed.get("direction", "none")).lower()
+    if direction not in ("delay", "early", "none"):
+        direction = "none"
+    synced = parsed.get("synced", False)
+    if isinstance(synced, str):
+        synced = synced.lower() in ("true", "yes", "1")
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_synced": item["gt_synced"],
+        "gt_direction": item["gt_direction"],
+        "gt_offset_sec": item["gt_offset_sec"],
+        "pred_synced": bool(synced),
+        "pred_direction": direction,
+        "pred_offset_sec": float(parsed.get("offset_sec", 0.0) or 0.0),
+        "pred_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openai_parse" if parsed else "openai_parse_fail",
+        "raw_output": raw,
+    }
+
+
+def run_one_mute(client, model, judge_model, item, n_frames):
+    raw = call_gpt_frames(
+        client, model, MUTE_PROMPT_NEUTRAL,
+        extract_frames_b64(item["video_path"], n_frames),
+    )
+    parsed = call_judge(client, judge_model, MUTE_JUDGE_SYSTEM, raw) or {}
+    pred = str(parsed.get("prediction", "synced")).lower()
+    if pred not in ("muted", "synced", "delay", "early"):
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_label": "muted",
+        "pred_label": pred,
+        "correct": (pred == "muted"),
+        "judge_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openai_judge" if parsed else "judge_fail",
+        "prompt_mode": "neutral",
+        "raw_output": raw,
+    }
+
+
+def run_one_swap(client, model, judge_model, item, n_frames):
+    raw = call_gpt_frames(
+        client, model, SWAP_PROMPT_DIRECT,
+        extract_frames_b64(item["video_path"], n_frames),
+        # Reasoning model needs headroom for the hidden trace even on yes/no Qs.
+    )
+    t = raw.strip().lower()
+    if t.startswith("no") or "no" in t.split()[:3]:
+        pred = "mismatched"
+    elif t.startswith("yes") or "yes" in t.split()[:3]:
+        pred = "synced"
+    else:
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "swapped_from": item["swapped_from"],
+        "gt_label": "mismatched",
+        "pred_label": pred,
+        "correct": (pred == "mismatched"),
+        "parse_method": "direct",
+        "prompt_mode": "direct",
+        "raw_output": raw,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Build work items from the FULL test set
+# ---------------------------------------------------------------------------
+def build_sync_work() -> List[Dict[str, Any]]:
+    """All 426 sync samples (142 base × 3 variants)."""
+    work = []
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        p = video_path_for(v)
+        if p is None:
+            print(f"[skip sync] missing file: {v}", flush=True)
+            continue
+        gt = parse_gt_from_name(v)
+        work.append({
+            "video": v,
+            "video_path": p,
+            "gt_synced": gt["synced"],
+            "gt_direction": gt["direction"],
+            "gt_offset_sec": gt["offset_sec"],
+        })
+    return work
+
+
+def build_mute_work() -> List[Dict[str, Any]]:
+    """142 base videos (skip delay/early variants); audio is implicit silence."""
+    work = []
+    seen = set()
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        if "_delay_" in v or "_early_" in v or v in seen:
+            continue
+        seen.add(v)
+        p = ORIG_DIR / v
+        if not p.exists():
+            print(f"[skip mute] missing: {v}", flush=True)
+            continue
+        work.append({"video": v, "video_path": p})
+    return work
+
+
+def build_swap_work() -> List[Dict[str, Any]]:
+    """142 base videos with the same donor pairing used in Gemini swap eval."""
+    if not GEMINI_SWAP.exists():
+        sys.exit(f"[error] need {GEMINI_SWAP} for swap donor pairings")
+    work = []
+    for r in load_jsonl(GEMINI_SWAP):
+        v = r["video"]
+        donor = r.get("swapped_from")
+        if not donor:
+            continue
+        p = ORIG_DIR / v
+        if not p.exists():
+            print(f"[skip swap] missing: {v}", flush=True)
+            continue
+        work.append({"video": v, "video_path": p, "swapped_from": donor})
+    return work
+
+
+# ---------------------------------------------------------------------------
+# Metrics (match existing eval_*.py schemas so results are directly comparable)
+# ---------------------------------------------------------------------------
+def _safe_div(a, b):
+    return round(a / b, 4) if b else 0.0
+
+
+def metrics_mute(rows, model, judge_model):
+    breakdown = {"muted": 0, "synced": 0, "delay": 0, "early": 0}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        breakdown[r["pred_label"]] = breakdown.get(r["pred_label"], 0) + 1
+        m = r.get("parse_method", "")
+        parse_stats[m] = parse_stats.get(m, 0) + 1
+    n = len(rows)
+    return {
+        "total_samples": n,
+        "mute_detection_rate": _safe_div(breakdown["muted"], n),
+        "hallucination_rate":  _safe_div(n - breakdown["muted"], n),
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+        "eval_config": {
+            "base_model": model,
+            "prompt_mode": "neutral",
+            "openai_judge": True,
+            "judge_model": judge_model,
+            "input_modality": "frames_only",
+        },
+    }
+
+
+def metrics_swap(rows, model, judge_model):
+    breakdown = {"mismatched": 0, "synced": 0, "delay": 0, "early": 0}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        breakdown[r["pred_label"]] = breakdown.get(r["pred_label"], 0) + 1
+        m = r.get("parse_method", "")
+        parse_stats[m] = parse_stats.get(m, 0) + 1
+    n = len(rows)
+    return {
+        "total_samples": n,
+        "mismatch_detection_rate": _safe_div(breakdown["mismatched"], n),
+        "hallucination_rate":      _safe_div(n - breakdown["mismatched"], n),
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+        "eval_config": {
+            "base_model": model,
+            "prompt_mode": "direct",
+            "judge_model": judge_model,  # not used for direct, kept for parity
+            "input_modality": "frames_only",
+        },
+    }
+
+
+def metrics_sync(rows, model, judge_model):
+    n = len(rows)
+    by_cat = {"synced": [], "delay": [], "early": []}
+    for r in rows:
+        if r["gt_synced"]:
+            by_cat["synced"].append(r)
+        else:
+            by_cat[r["gt_direction"]].append(r)
+
+    def _is_correct(r):
+        if r["gt_synced"]:
+            return r["pred_synced"]
+        return (not r["pred_synced"]) and r["pred_direction"] == r["gt_direction"]
+
+    sync_desync = sum(1 for r in rows if bool(r["pred_synced"]) == bool(r["gt_synced"]))
+    three_class = sum(1 for r in rows if _is_correct(r))
+    desync_rows = [r for r in rows if not r["gt_synced"]]
+    dir_correct = sum(1 for r in desync_rows
+                      if (not r["pred_synced"]) and r["pred_direction"] == r["gt_direction"])
+
+    # Offset MAE on rows where both gt and pred have a numeric offset for desync
+    offsets = []
+    for r in desync_rows:
+        if r.get("pred_offset_sec") is not None and r.get("gt_offset_sec") is not None:
+            offsets.append(abs(float(r["pred_offset_sec"]) - float(r["gt_offset_sec"])))
+    offset_mae = round(sum(offsets) / len(offsets), 4) if offsets else None
+
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        m = r.get("parse_method", "")
+        parse_stats[m] = parse_stats.get(m, 0) + 1
+
+    return {
+        "total_samples": n,
+        "sync_desync_accuracy":         _safe_div(sync_desync, n),
+        "three_class_accuracy":         _safe_div(three_class, n),
+        "direction_accuracy_on_desync": _safe_div(dir_correct, len(desync_rows)),
+        "per_category": {
+            "synced_accuracy": _safe_div(sum(1 for r in by_cat["synced"] if _is_correct(r)),
+                                         len(by_cat["synced"])),
+            "delay_accuracy":  _safe_div(sum(1 for r in by_cat["delay"]  if _is_correct(r)),
+                                         len(by_cat["delay"])),
+            "early_accuracy":  _safe_div(sum(1 for r in by_cat["early"]  if _is_correct(r)),
+                                         len(by_cat["early"])),
+            "synced_count": len(by_cat["synced"]),
+            "delay_count":  len(by_cat["delay"]),
+            "early_count":  len(by_cat["early"]),
+        },
+        "offset_mae_sec": offset_mae,
+        "offset_evaluated_count": len(offsets),
+        "parse_stats": parse_stats,
+        "eval_config": {
+            "base_model": model,
+            "openai_parse_sync": True,
+            "judge_model": judge_model,
+            "input_modality": "frames_only",
+        },
+    }
+
+
+METRICS_FN = {
+    "sync": metrics_sync,
+    "mute": metrics_mute,
+    "swap": metrics_swap,
+}
+
+
+# ---------------------------------------------------------------------------
+# Run loop with resume + parallel
+# ---------------------------------------------------------------------------
+def run_task(out_dir: Path, work, runner, client, model, judge_model, n_frames, workers,
+             task_kind: str):
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results_path = out_dir / "eval_results.jsonl"
+
+    processed = set()
+    if results_path.exists():
+        with open(results_path) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    processed.add(json.loads(line)["video"])
+        print(f"[{out_dir.name}] resume: {len(processed)} already done")
+
+    todo = [w for w in work if w["video"] not in processed]
+    print(f"[{out_dir.name}] {len(todo)} new / {len(work)} total")
+
+    def _go(item):
+        try:
+            return runner(client, model, judge_model, item, n_frames)
+        except Exception as exc:
+            print(f"[{out_dir.name}] error on {item['video']}: {exc}", flush=True)
+            return None
+
+    n_done = 0
+    with ThreadPoolExecutor(max_workers=workers) as ex, open(results_path, "a") as out:
+        futures = {ex.submit(_go, item): item for item in todo}
+        for fut in as_completed(futures):
+            res = fut.result()
+            if res is None:
+                continue
+            out.write(json.dumps(res, ensure_ascii=False) + "\n")
+            out.flush()
+            n_done += 1
+            if n_done % 10 == 0 or n_done == len(todo):
+                print(f"[{out_dir.name}] {n_done}/{len(todo)} done", flush=True)
+    print(f"[{out_dir.name}] saved -> {results_path}")
+
+    # Compute and write metrics.json (matches existing eval_*.py schemas).
+    rows = [json.loads(l) for l in open(results_path) if l.strip()]
+    metrics = METRICS_FN[task_kind](rows, model, judge_model)
+    metrics_path = out_dir / "metrics.json"
+    with open(metrics_path, "w") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+    print(f"[{out_dir.name}] metrics -> {metrics_path}")
+    return results_path
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--openai-key", default=os.environ.get("OPENAI_API_KEY"))
+    ap.add_argument("--model", default="gpt-5.5",
+                    help="Model under test (frames-only multimodal).")
+    ap.add_argument("--judge-model", default="gpt-5.4")
+    ap.add_argument("--tasks", default="sync,mute,swap")
+    ap.add_argument("--workers", type=int, default=6)
+    ap.add_argument("--n-frames", type=int, default=8)
+    ap.add_argument("--label-suffix", default="_visualOnly",
+                    help="Tagged into output dir name to flag the no-audio handicap.")
+    args = ap.parse_args()
+
+    if not args.openai_key:
+        sys.exit("[error] need --openai-key or OPENAI_API_KEY env")
+
+    client = _client(args.openai_key)
+    model_tag = args.model.replace("/", "_") + args.label_suffix
+
+    tasks = [t.strip() for t in args.tasks.split(",") if t.strip()]
+    if "sync" in tasks:
+        run_task(EVAL_ROOT / "sync" / f"sync_{model_tag}",
+                 build_sync_work(), run_one_sync,
+                 client, args.model, args.judge_model, args.n_frames, args.workers,
+                 task_kind="sync")
+    if "mute" in tasks:
+        run_task(EVAL_ROOT / "mute" / f"mute_{model_tag}_promptNeutral",
+                 build_mute_work(), run_one_mute,
+                 client, args.model, args.judge_model, args.n_frames, args.workers,
+                 task_kind="mute")
+    if "swap" in tasks:
+        run_task(EVAL_ROOT / "swap" / f"swap_{model_tag}_promptDirect",
+                 build_swap_work(), run_one_swap,
+                 client, args.model, args.judge_model, args.n_frames, args.workers,
+                 task_kind="swap")
+
+
+if __name__ == "__main__":
+    main()

compute_nemotron_or_metrics.py

@@ -0,0 +1,251 @@
+"""Compute metrics.json + summary.txt for the OpenRouter Nemotron eval runs.
+
+Mirrors the metric definitions from the in-repo eval_*.py scripts so numbers
+are head-to-head comparable with the Qwen / Gemini / GPT-5.5 runs.
+
+Usage:
+  python3 /home/ubuntu/compute_nemotron_or_metrics.py
+"""
+import io
+import json
+from contextlib import redirect_stdout
+from pathlib import Path
+from statistics import mean, median
+from typing import Any, Dict, List
+
+EVAL = Path("/home/ubuntu/eval_results")
+
+import sys as _sys
+TAG = _sys.argv[1] if len(_sys.argv) > 1 else "nemotron3_nano_omni_reasoning_free_audioMuxed"
+print(f"[compute] TAG={TAG}")
+
+DIRS = {
+    "sync":         EVAL / "sync" / f"sync_{TAG}",
+    "swap_direct":  EVAL / "swap" / f"swap_{TAG}_promptDirect",
+    "swap_neutral": EVAL / "swap" / f"swap_{TAG}_promptNeutral",
+    "mute_neutral": EVAL / "mute" / f"mute_{TAG}_promptNeutral",
+}
+
+
+def load_rows(path: Path) -> List[Dict[str, Any]]:
+    if not path.exists():
+        return []
+    return [json.loads(l) for l in open(path) if l.strip()]
+
+
+# --------------------------------------------------------------------------
+# sync — same fields as scripts/eval_dpo_sync.py compute_metrics
+# --------------------------------------------------------------------------
+def metrics_sync(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    n = len(rows)
+    if n == 0:
+        return {}
+    sync_correct = sum(1 for r in rows if r["pred_synced"] == r["gt_synced"])
+    sync_acc = sync_correct / n
+
+    desync = [r for r in rows if not r["gt_synced"]]
+    dir_acc = (sum(1 for r in desync if r["pred_direction"] == r["gt_direction"])
+               / len(desync)) if desync else None
+
+    def label(r, prefix):
+        return "synced" if r[f"{prefix}synced"] else r[f"{prefix}direction"]
+    three_class = sum(1 for r in rows if label(r, "pred_") == label(r, "gt_")) / n
+
+    synced_samples = [r for r in rows if r["gt_synced"]]
+    delay_samples  = [r for r in rows if r["gt_direction"] == "delay"]
+    early_samples  = [r for r in rows 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
+
+    offset_errors = [abs(r["pred_offset_sec"] - r["gt_offset_sec"])
+                     for r in desync
+                     if (not r["pred_synced"] and r.get("pred_offset_sec", 0) > 0)]
+    offset_mae    = mean(offset_errors)   if offset_errors else None
+    offset_median = median(offset_errors) if offset_errors else None
+    within_05 = sum(1 for e in offset_errors if e <= 0.5)
+    within_10 = sum(1 for e in offset_errors if e <= 1.0)
+
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        parse_stats[r.get("parse_method", "unknown")] = parse_stats.get(r.get("parse_method", "unknown"), 0) + 1
+
+    return {
+        "total_samples": n,
+        "sync_desync_accuracy": round(sync_acc, 4),
+        "three_class_accuracy": round(three_class, 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),
+        "parse_stats": parse_stats,
+    }
+
+
+# --------------------------------------------------------------------------
+# swap — eval_swap.py shape
+# --------------------------------------------------------------------------
+def metrics_swap(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    n = len(rows)
+    if n == 0:
+        return {}
+    breakdown = {k: 0 for k in ("mismatched", "synced", "delay", "early")}
+    for r in rows:
+        p = r.get("pred_label", "synced")
+        breakdown[p] = breakdown.get(p, 0) + 1
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        parse_stats[r.get("parse_method", "unknown")] = parse_stats.get(r.get("parse_method", "unknown"), 0) + 1
+    return {
+        "total_samples": n,
+        "mismatch_detection_rate": round(breakdown["mismatched"] / n, 4),
+        "hallucination_rate":      round(1 - breakdown["mismatched"] / n, 4),
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+    }
+
+
+# --------------------------------------------------------------------------
+# mute — eval_mute.py shape
+# --------------------------------------------------------------------------
+def metrics_mute(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    n = len(rows)
+    if n == 0:
+        return {}
+    breakdown = {k: 0 for k in ("muted", "synced", "delay", "early")}
+    for r in rows:
+        p = r.get("pred_label", "synced")
+        breakdown[p] = breakdown.get(p, 0) + 1
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        parse_stats[r.get("parse_method", "unknown")] = parse_stats.get(r.get("parse_method", "unknown"), 0) + 1
+    return {
+        "total_samples": n,
+        "mute_detection_rate": round(breakdown["muted"] / n, 4),
+        "hallucination_rate": round(1 - breakdown["muted"] / n, 4),
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+    }
+
+
+# --------------------------------------------------------------------------
+# Pretty summaries (mirror print_summary in each eval_*.py)
+# --------------------------------------------------------------------------
+def print_sync(m: Dict[str, Any], label: str) -> None:
+    print(f"{'=' * 60}")
+    print(f"  Sync Eval: {label}")
+    print(f"{'=' * 60}")
+    print(f"  Total samples:            {m['total_samples']}")
+    print(f"  Sync/Desync Accuracy:     {m['sync_desync_accuracy']:.1%}")
+    print(f"  3-Class Accuracy:         {m['three_class_accuracy']:.1%}")
+    if m['direction_accuracy_on_desync'] is not None:
+        print(f"  Direction Acc (desync):   {m['direction_accuracy_on_desync']:.1%}")
+    print(f"  --- Per Category ---")
+    pc = m['per_category']
+    for k in ("synced", "delay", "early"):
+        a = pc.get(f"{k}_accuracy")
+        c = pc.get(f"{k}_count")
+        if a is not None:
+            print(f"    {k:>8} correct:  {a:.1%}  ({c} samples)")
+    print(f"  --- Offset Estimation ---")
+    if m['offset_mae_sec'] is not None:
+        print(f"    MAE:                  {m['offset_mae_sec']:.3f}s")
+        print(f"    Median:               {m['offset_median_sec']:.3f}s")
+        print(f"    Within 0.5s:          {m['offset_within_0.5s']} / {m['offset_evaluated_count']}")
+        print(f"    Within 1.0s:          {m['offset_within_1.0s']} / {m['offset_evaluated_count']}")
+    else:
+        print(f"    (no valid offset predictions)")
+    print(f"  --- Parse Stats ---")
+    for k, v in sorted(m['parse_stats'].items()):
+        print(f"    {k}: {v}")
+    print(f"{'=' * 60}")
+
+
+def print_swap(m: Dict[str, Any], label: str) -> None:
+    print(f"{'=' * 60}")
+    print(f"  Swap Eval: {label}")
+    print(f"{'=' * 60}")
+    print(f"  Total samples:              {m['total_samples']}")
+    print(f"  Mismatch Detection Rate:    {m['mismatch_detection_rate']:.1%}")
+    print(f"  Hallucination Rate:         {m['hallucination_rate']:.1%}")
+    print(f"  --- Prediction Breakdown ---")
+    bd = m['prediction_breakdown']
+    print(f"    mismatched (correct): {bd['mismatched']}")
+    print(f"    synced     (halluc.): {bd['synced']}")
+    print(f"    delay      (halluc.): {bd['delay']}")
+    print(f"    early      (halluc.): {bd['early']}")
+    print(f"  --- Parse Stats ---")
+    for k, v in sorted(m['parse_stats'].items()):
+        print(f"    {k}: {v}")
+    print(f"{'=' * 60}")
+
+
+def print_mute(m: Dict[str, Any], label: str) -> None:
+    print(f"{'=' * 60}")
+    print(f"  Mute Eval: {label}")
+    print(f"{'=' * 60}")
+    print(f"  Total samples:          {m['total_samples']}")
+    print(f"  Mute Detection Rate:    {m['mute_detection_rate']:.1%}")
+    print(f"  Hallucination Rate:     {m['hallucination_rate']:.1%}")
+    print(f"  --- Prediction Breakdown ---")
+    bd = m['prediction_breakdown']
+    print(f"    muted  (correct):     {bd['muted']}")
+    print(f"    synced (halluc.):     {bd['synced']}")
+    print(f"    delay  (halluc.):     {bd['delay']}")
+    print(f"    early  (halluc.):     {bd['early']}")
+    print(f"  --- Parse Stats ---")
+    for k, v in sorted(m['parse_stats'].items()):
+        print(f"    {k}: {v}")
+    print(f"{'=' * 60}")
+
+
+# --------------------------------------------------------------------------
+# Main
+# --------------------------------------------------------------------------
+COMPUTE = {"sync": metrics_sync, "swap_direct": metrics_swap,
+           "swap_neutral": metrics_swap, "mute_neutral": metrics_mute}
+PRINT   = {"sync": print_sync, "swap_direct": print_swap,
+           "swap_neutral": print_swap, "mute_neutral": print_mute}
+
+CONFIG = {
+    "model": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
+    "provider": "openrouter",
+    "judge": "gpt-5.4 (native OpenAI)",
+    "send_mode": "muxed (ffmpeg merges target audio into video, single video_url block)",
+    "n_frames": None,
+    "input": "native video (data:video/mp4;base64,...) + embedded audio",
+}
+
+for task, d in DIRS.items():
+    jsonl = d / "eval_results.jsonl"
+    rows  = load_rows(jsonl)
+    if not rows:
+        print(f"[skip] {task}: no rows in {jsonl}")
+        continue
+    m = COMPUTE[task](rows)
+    m["eval_config"] = {**CONFIG, "task": task, "results_jsonl": str(jsonl)}
+
+    metrics_path = d / "metrics.json"
+    summary_path = d / "summary.txt"
+    metrics_path.write_text(json.dumps(m, indent=2, ensure_ascii=False))
+
+    buf = io.StringIO()
+    with redirect_stdout(buf):
+        PRINT[task](m, d.name)
+    summary_path.write_text(buf.getvalue())
+
+    PRINT[task](m, d.name)
+    print(f"  -> {metrics_path}")
+    print(f"  -> {summary_path}\n")

eval_nemotron_openrouter.py

@@ -0,0 +1,780 @@
+"""Evaluate nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free via OpenRouter
+on the FULL CleverHans test set, sending NATIVE video + audio (no frame
+extraction):
+  - sync          (426)   raw mp4 (audio is already embedded in delay/early/sync variant) + GPT judge
+  - swap-direct   (142)   donor audio MUXED INTO video via ffmpeg, yes/no parsed
+  - swap-neutral  (142)   same muxed donor video + GPT judge
+  - mute-neutral  (142)   silent wav MUXED INTO video + GPT judge
+
+OpenRouter accepts multimodal content blocks in OpenAI-compatible chat:
+  {"type": "video_url",   "video_url":   {"url": "data:video/mp4;base64,..."}}
+  {"type": "input_audio", "input_audio": {"data": "<b64>", "format": "wav"}}
+The Nemotron-3-Nano-Omni model lists input_modalities = text/audio/image/video.
+Because we don't know whether OpenRouter routes a separately-supplied
+input_audio block as an OVERRIDE of the audio embedded in video_url or as a
+SECOND track, we mux the desired audio into a tmp mp4 (ffmpeg) and send only
+video_url. That guarantees the model hears exactly the audio we intend.
+
+Usage:
+  pip install openai tqdm
+  export OPENROUTER_API_KEY=sk-or-v1-...
+  # optional: separate key for the GPT judge (defaults to OPENROUTER_API_KEY,
+  # routing openai/gpt-5.4 through OpenRouter)
+  export OPENAI_API_KEY=sk-...
+
+  python3 /home/ubuntu/eval_nemotron_openrouter.py
+  python3 /home/ubuntu/eval_nemotron_openrouter.py --tasks sync --max-samples 10
+  # If OpenRouter ever rejects 4xx the muxed payload, retry with both
+  # blocks (video_url + input_audio) instead:
+  python3 /home/ubuntu/eval_nemotron_openrouter.py --send-mode separate
+"""
+
+import argparse
+import base64
+import json
+import os
+import random
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+DATA_ROOT     = Path("/opt/dlami/nvme/video_source")
+ORIG_DIR      = DATA_ROOT / "original" / "uag_oops"
+DELAY_DIR     = DATA_ROOT / "random_shift_video" / "delay"
+EARLY_DIR     = DATA_ROOT / "random_shift_video" / "early"
+AUDIO_ORIG    = DATA_ROOT / "extracted_audio" / "original" / "uag_oops"
+AUDIO_DELAY   = DATA_ROOT / "extracted_audio" / "random_shift_video" / "delay"
+AUDIO_EARLY   = DATA_ROOT / "extracted_audio" / "random_shift_video" / "early"
+MUTE_DIR      = DATA_ROOT / "mute_audio"
+MUX_CACHE     = DATA_ROOT / "openrouter_muxed_cache"  # cached muxed videos
+
+TEST_JSONL    = Path("/home/ubuntu/CleverHans-Evaluation/data/kto_training_data_v2_test.jsonl")
+GEMINI_SWAP   = Path("/home/ubuntu/eval_results/gemini_mute_sync_swap/swap/"
+                     "swap_gemini_gemini-3.1-pro-preview__promptDirect/eval_results.jsonl")
+
+EVAL_ROOT     = Path("/home/ubuntu/eval_results")
+FFMPEG        = "/home/ubuntu/anaconda3/envs/video/bin/ffmpeg"
+FFPROBE       = "/home/ubuntu/anaconda3/envs/video/bin/ffprobe"
+if not Path(FFMPEG).exists():
+    FFMPEG = shutil.which("ffmpeg") or "ffmpeg"
+if not Path(FFPROBE).exists():
+    FFPROBE = shutil.which("ffprobe") or "ffprobe"
+
+DIR_OFFSET_RE = re.compile(r"_(delay|early)_(\d+(?:\.\d+)?)s\.mp4$")
+
+# ---------------------------------------------------------------------------
+# Prompts (same wording as the rest of the CleverHans suite)
+# ---------------------------------------------------------------------------
+SYNC_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."
+)
+MUTE_PROMPT_NEUTRAL = "Describe the audio you hear in this video."
+SWAP_PROMPT_NEUTRAL = "Describe what you see in the video and what you hear in the audio."
+SWAP_PROMPT_DIRECT  = (
+    "Does the audio in this video match the visual content? "
+    "Answer with only 'yes' or 'no'."
+)
+
+SYNC_PARSE_SYSTEM = (
+    "You parse a free-form judgement about whether the audio in a short video is "
+    "synchronized with the visuals. Return STRICT JSON only with keys: "
+    "synced (bool), direction (one of 'delay'|'early'|'none'), "
+    "offset_sec (number, 0 if synced), t_v (number|null, visual cue time), "
+    "t_a (number|null, audio cue time), explanation (string). "
+    "If the answer says they are aligned, set synced=true, direction='none', offset_sec=0."
+)
+MUTE_JUDGE_SYSTEM = (
+    "You are evaluating a model's response about a video whose audio has been secretly "
+    "replaced with silence. Classify into ONE of: "
+    '{"prediction": "muted"|"synced"|"delay"|"early", "explanation": "<one sentence>"}. '
+    "Rules: "
+    "- 'muted' iff the model says no audio / silence / no audible sound. "
+    "- 'synced' iff the model describes audio that matches the visuals (HALLUCINATION). "
+    "- 'delay'/'early' iff the model claims a temporal offset. "
+    "Return STRICT JSON only."
+)
+SWAP_JUDGE_SYSTEM = (
+    "You are evaluating a model's response about a video whose audio has been secretly "
+    "replaced with audio from a DIFFERENT unrelated video. Classify into ONE of: "
+    '{"prediction": "synced"|"delay"|"early"|"mismatched", "explanation": "<one sentence>"}. '
+    "Rules: "
+    "- 'mismatched' iff the model says the audio does NOT match the visual content, or "
+    "the audio and video are unrelated, or the sounds don't correspond to what's shown. "
+    "- 'synced' iff the model claims audio and video are well synchronized and matching. "
+    "- 'delay'/'early' iff the model claims a temporal offset (but still believes they match). "
+    "- Prefer 'mismatched' whenever the model expresses confusion or doubt. "
+    "Return STRICT JSON only."
+)
+
+
+# ---------------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------------
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def parse_gt_from_name(video_name: str) -> Dict[str, Any]:
+    m = DIR_OFFSET_RE.search(video_name)
+    if m:
+        return {"synced": False, "direction": m.group(1), "offset_sec": float(m.group(2))}
+    return {"synced": True, "direction": "none", "offset_sec": 0.0}
+
+
+def video_path_for(video_name: str) -> Optional[Path]:
+    m = DIR_OFFSET_RE.search(video_name)
+    if m is None:
+        p = ORIG_DIR / video_name
+    elif m.group(1) == "delay":
+        p = DELAY_DIR / video_name
+    else:
+        p = EARLY_DIR / video_name
+    return p if p.exists() else None
+
+
+def video_duration(path: Path) -> float:
+    out = subprocess.run(
+        [FFPROBE, "-v", "error", "-show_entries", "format=duration",
+         "-of", "default=noprint_wrappers=1:nokey=1", str(path)],
+        capture_output=True, text=True, check=True,
+    )
+    try:
+        return float(out.stdout.strip())
+    except ValueError:
+        return 5.0
+
+
+def silent_wav_for(video_path: Path) -> Path:
+    MUTE_DIR.mkdir(parents=True, exist_ok=True)
+    out = MUTE_DIR / f"{video_path.stem}_silent.wav"
+    if out.exists():
+        return out
+    import wave
+    sr = 16000
+    n = int(sr * max(0.5, video_duration(video_path)))
+    with wave.open(str(out), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(sr)
+        w.writeframes(b"\x00\x00" * n)
+    return out
+
+
+def mux_audio_into_video(video_path: Path, audio_path: Path,
+                         tag: str) -> Path:
+    """Replace video's audio track with `audio_path`. Cached under MUX_CACHE
+    by (video_stem + tag + audio_stem) so swap/mute pairings only mux once.
+    """
+    MUX_CACHE.mkdir(parents=True, exist_ok=True)
+    out = MUX_CACHE / f"{video_path.stem}__{tag}__{audio_path.stem}.mp4"
+    if out.exists():
+        return out
+    cmd = [
+        FFMPEG, "-y", "-loglevel", "error",
+        "-i", str(video_path),
+        "-i", str(audio_path),
+        "-map", "0:v:0", "-map", "1:a:0",
+        "-c:v", "copy",
+        "-c:a", "aac", "-b:a", "128k",
+        "-shortest",
+        str(out),
+    ]
+    subprocess.run(cmd, check=True)
+    return out
+
+
+def file_to_data_uri(path: Path, mime: str) -> str:
+    b = path.read_bytes()
+    return f"data:{mime};base64,{base64.b64encode(b).decode()}"
+
+
+def wav_b64(path: Path) -> str:
+    return base64.b64encode(path.read_bytes()).decode()
+
+
+# ---------------------------------------------------------------------------
+# Clients
+# ---------------------------------------------------------------------------
+def _openrouter_client(api_key: str):
+    from openai import OpenAI
+    return OpenAI(
+        api_key=api_key,
+        base_url="https://openrouter.ai/api/v1",
+        default_headers={
+            "HTTP-Referer": os.environ.get("OPENROUTER_REFERER", "https://localhost"),
+            "X-Title": os.environ.get("OPENROUTER_TITLE", "CleverHans-Nemotron-Eval"),
+        },
+        timeout=300.0,
+    )
+
+
+def _judge_client(judge_key: Optional[str], openrouter_key: str):
+    """Native OpenAI if a different key is supplied, else route through OpenRouter."""
+    from openai import OpenAI
+    if judge_key and judge_key != openrouter_key:
+        return OpenAI(api_key=judge_key, timeout=120.0), False
+    return OpenAI(api_key=openrouter_key,
+                  base_url="https://openrouter.ai/api/v1",
+                  timeout=120.0), True
+
+
+# ---------------------------------------------------------------------------
+# Build content blocks
+# ---------------------------------------------------------------------------
+def _content_video_only(prompt: str, video_path: Path) -> List[Dict[str, Any]]:
+    return [
+        {"type": "video_url",
+         "video_url": {"url": file_to_data_uri(video_path, "video/mp4")}},
+        {"type": "text", "text": prompt},
+    ]
+
+
+def _content_video_plus_audio(prompt: str, video_path: Path,
+                              audio_path: Path) -> List[Dict[str, Any]]:
+    fmt = audio_path.suffix.lstrip(".").lower() or "wav"
+    return [
+        {"type": "video_url",
+         "video_url": {"url": file_to_data_uri(video_path, "video/mp4")}},
+        {"type": "input_audio",
+         "input_audio": {"data": wav_b64(audio_path), "format": fmt}},
+        {"type": "text", "text": prompt},
+    ]
+
+
+# ---------------------------------------------------------------------------
+# One chat call with retries
+# ---------------------------------------------------------------------------
+def _extract_text(resp) -> str:
+    """Pull final answer text from a chat completion. Handles:
+     - resp / resp.choices being None (OR error responses)
+     - reasoning models that put the final answer in message.content but the
+       chain in message.reasoning / message.reasoning_content (we only return
+       content; reasoning is logged separately by callers if they want it)."""
+    if resp is None:
+        return ""
+    choices = getattr(resp, "choices", None) or []
+    if not choices:
+        return ""
+    msg = getattr(choices[0], "message", None)
+    if msg is None:
+        return ""
+    content = getattr(msg, "content", None) or ""
+    if isinstance(content, list):
+        # Some providers return content as a list of {type, text} parts.
+        parts = [p.get("text", "") for p in content if isinstance(p, dict) and p.get("type") == "text"]
+        content = "".join(parts)
+    return (content or "").strip()
+
+
+def call_model(client, model: str, content: List[Dict[str, Any]],
+               max_tokens: int = 2000, temperature: float = 0.0,
+               reasoning_budget: int = 1024,
+               max_retries: int = 4) -> str:
+    """Send chat completion. Bounds reasoning budget so reasoning tokens don't
+    eat the whole max_tokens window — without this, Nemotron-Reasoning often
+    returns empty content because max_tokens is consumed by the chain of
+    thought before any user-facing answer is produced."""
+    last_exc = None
+    for attempt in range(max_retries):
+        try:
+            kwargs = dict(
+                model=model,
+                messages=[{"role": "user", "content": content}],
+                max_tokens=max_tokens,
+                temperature=temperature,
+                # OpenRouter "reasoning" param: bound chain-of-thought length.
+                # Keys: max_tokens (cap reasoning), exclude (drop from response).
+                extra_body={"reasoning": {"max_tokens": reasoning_budget}},
+            )
+            resp = client.chat.completions.create(**kwargs)
+            text = _extract_text(resp)
+            return text
+        except Exception as exc:
+            last_exc = exc
+            msg = str(exc).lower()
+            if any(s in msg for s in ("429", "rate", "timeout", "502", "503", "504")):
+                time.sleep(2 ** attempt + random.random())
+                continue
+            # If `extra_body` / `reasoning` is rejected, retry without it.
+            if "reasoning" in msg and "unsupported" in msg:
+                try:
+                    resp = client.chat.completions.create(
+                        model=model,
+                        messages=[{"role": "user", "content": content}],
+                        max_tokens=max_tokens,
+                        temperature=temperature,
+                    )
+                    return _extract_text(resp)
+                except Exception as exc2:
+                    last_exc = exc2
+            raise
+    raise RuntimeError(f"call_model failed after {max_retries}: {last_exc}")
+
+
+def call_judge(judge_client, judge_model: str, system_prompt: str,
+               user_text: str, max_retries: int = 3) -> Optional[Dict[str, Any]]:
+    """OpenAI reasoning models (gpt-5.x, o-series) reject `max_tokens` and
+    require `max_completion_tokens`. Try the new param first; if a non-reasoning
+    model rejects it, fall back to `max_tokens`."""
+    if not user_text:
+        return None
+    last_exc = None
+    use_max_completion = True
+    for attempt in range(max_retries):
+        try:
+            kwargs = dict(
+                model=judge_model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_text},
+                ],
+                response_format={"type": "json_object"},
+            )
+            # Reasoning models need a generous budget — they spend tokens on
+            # reasoning before emitting the JSON.
+            if use_max_completion:
+                kwargs["max_completion_tokens"] = 2000
+            else:
+                kwargs["max_tokens"] = 300
+                kwargs["temperature"] = 0.0
+            resp = judge_client.chat.completions.create(**kwargs)
+            text = _extract_text(resp)
+            if not text:
+                last_exc = RuntimeError("judge returned empty content")
+                time.sleep(1.0)
+                continue
+            for pat in (re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL),
+                        re.compile(r"(\{.*\})", re.DOTALL)):
+                m = pat.search(text)
+                if m:
+                    return json.loads(m.group(1))
+            return json.loads(text)
+        except Exception as exc:
+            last_exc = exc
+            msg = str(exc).lower()
+            # Hot-swap param if the API tells us the wrong one is set.
+            if "max_completion_tokens" in msg and "instead" in msg:
+                use_max_completion = True
+                continue
+            if "max_tokens" in msg and "max_completion_tokens" in msg:
+                use_max_completion = True
+                continue
+            if "unsupported parameter" in msg and "temperature" in msg:
+                # gpt-5.x rejects temperature; we already drop it on the new path.
+                use_max_completion = True
+                continue
+            time.sleep(1.5 ** attempt + random.random())
+    print(f"  [judge] failed after {max_retries}: {last_exc}", flush=True)
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Per-task runners
+# ---------------------------------------------------------------------------
+def _build_content(prompt, video_path, audio_path, send_mode):
+    """send_mode:
+       'muxed'    – audio already muxed into video, send video_url only
+       'separate' – send video_url + input_audio (model decides)
+       'video'    – send video_url only (audio comes from video's own track)
+    """
+    if send_mode == "video" or audio_path is None:
+        return _content_video_only(prompt, video_path)
+    if send_mode == "separate":
+        return _content_video_plus_audio(prompt, video_path, audio_path)
+    # muxed: caller has already muxed; audio_path is unused at request time
+    return _content_video_only(prompt, video_path)
+
+
+def run_one_sync(item, model_client, model, judge_client, judge_model, send_mode):
+    # Sync videos already have the right audio embedded in delay/early/sync mp4.
+    content = _build_content(SYNC_PROMPT, item["video_path"], None, "video")
+    raw = call_model(model_client, model, content,
+                     max_tokens=2500, reasoning_budget=1024)
+    parsed = call_judge(judge_client, judge_model, SYNC_PARSE_SYSTEM, raw) or {}
+    direction = str(parsed.get("direction", "none")).lower()
+    if direction not in ("delay", "early", "none"):
+        direction = "none"
+    synced = parsed.get("synced", False)
+    if isinstance(synced, str):
+        synced = synced.lower() in ("true", "yes", "1")
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_synced": item["gt_synced"],
+        "gt_direction": item["gt_direction"],
+        "gt_offset_sec": item["gt_offset_sec"],
+        "pred_synced": bool(synced),
+        "pred_direction": direction,
+        "pred_offset_sec": float(parsed.get("offset_sec", 0.0) or 0.0),
+        "pred_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openrouter_judge" if parsed else "judge_fail",
+        "send_mode": send_mode if send_mode != "muxed" else "video",
+        "raw_output": raw,
+    }
+
+
+def run_one_mute(item, model_client, model, judge_client, judge_model, send_mode):
+    # Mux silent wav into video → send video_url with no audio (muted).
+    if send_mode == "muxed":
+        muxed = mux_audio_into_video(item["video_path"], item["audio_path"], "mute")
+        content = _content_video_only(MUTE_PROMPT_NEUTRAL, muxed)
+    else:
+        content = _build_content(MUTE_PROMPT_NEUTRAL, item["video_path"],
+                                 item["audio_path"], send_mode)
+    raw = call_model(model_client, model, content,
+                     max_tokens=2000, reasoning_budget=768)
+    parsed = call_judge(judge_client, judge_model, MUTE_JUDGE_SYSTEM, raw) or {}
+    pred = str(parsed.get("prediction", "synced")).lower()
+    if pred not in ("muted", "synced", "delay", "early"):
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "audio_path": str(item["audio_path"]),
+        "gt_label": "muted",
+        "pred_label": pred,
+        "correct": (pred == "muted"),
+        "judge_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openrouter_judge" if parsed else "judge_fail",
+        "prompt_mode": "neutral",
+        "send_mode": send_mode,
+        "raw_output": raw,
+    }
+
+
+def run_one_swap_neutral(item, model_client, model, judge_client, judge_model, send_mode):
+    if send_mode == "muxed":
+        muxed = mux_audio_into_video(item["video_path"], item["audio_path"], "swap")
+        content = _content_video_only(SWAP_PROMPT_NEUTRAL, muxed)
+    else:
+        content = _build_content(SWAP_PROMPT_NEUTRAL, item["video_path"],
+                                 item["audio_path"], send_mode)
+    raw = call_model(model_client, model, content,
+                     max_tokens=2000, reasoning_budget=768)
+    parsed = call_judge(judge_client, judge_model, SWAP_JUDGE_SYSTEM, raw) or {}
+    pred = str(parsed.get("prediction", "synced")).lower()
+    if pred not in ("synced", "delay", "early", "mismatched"):
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "audio_path": str(item["audio_path"]),
+        "swapped_from": item["swapped_from"],
+        "gt_label": "mismatched",
+        "pred_label": pred,
+        "correct": (pred == "mismatched"),
+        "judge_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openrouter_judge" if parsed else "judge_fail",
+        "prompt_mode": "neutral",
+        "send_mode": send_mode,
+        "raw_output": raw,
+    }
+
+
+def run_one_swap_direct(item, model_client, model, judge_client, judge_model, send_mode):
+    if send_mode == "muxed":
+        muxed = mux_audio_into_video(item["video_path"], item["audio_path"], "swap")
+        content = _content_video_only(SWAP_PROMPT_DIRECT, muxed)
+    else:
+        content = _build_content(SWAP_PROMPT_DIRECT, item["video_path"],
+                                 item["audio_path"], send_mode)
+    # Yes/no question: tiny answer budget, but reasoning model still needs
+    # headroom — give it enough that reasoning doesn't starve the final token.
+    raw = call_model(model_client, model, content,
+                     max_tokens=1200, reasoning_budget=512)
+    t = raw.strip().lower()
+    head = t.split()[:3] if t else []
+    if t.startswith("no") or "no" in head:
+        pred = "mismatched"
+    elif t.startswith("yes") or "yes" in head:
+        pred = "synced"
+    else:
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "audio_path": str(item["audio_path"]),
+        "swapped_from": item["swapped_from"],
+        "gt_label": "mismatched",
+        "pred_label": pred,
+        "correct": (pred == "mismatched"),
+        "parse_method": "direct",
+        "prompt_mode": "direct",
+        "send_mode": send_mode,
+        "raw_output": raw,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Build work items
+# ---------------------------------------------------------------------------
+def build_sync_work() -> List[Dict[str, Any]]:
+    work = []
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        p = video_path_for(v)
+        if p is None:
+            print(f"[skip sync] missing video: {v}", flush=True)
+            continue
+        gt = parse_gt_from_name(v)
+        work.append({
+            "video": v,
+            "video_path": p,
+            "gt_synced": gt["synced"],
+            "gt_direction": gt["direction"],
+            "gt_offset_sec": gt["offset_sec"],
+        })
+    return work
+
+
+def build_mute_work() -> List[Dict[str, Any]]:
+    work = []
+    seen = set()
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        if "_delay_" in v or "_early_" in v or v in seen:
+            continue
+        seen.add(v)
+        p = ORIG_DIR / v
+        if not p.exists():
+            continue
+        work.append({"video": v, "video_path": p, "audio_path": silent_wav_for(p)})
+    return work
+
+
+def build_swap_work_from_gemini() -> List[Dict[str, Any]]:
+    if not GEMINI_SWAP.exists():
+        return []
+    work = []
+    for r in load_jsonl(GEMINI_SWAP):
+        v = r["video"]
+        donor = r.get("swapped_from")
+        if not donor:
+            continue
+        p = ORIG_DIR / v
+        donor_audio = AUDIO_ORIG / f"{Path(donor).stem}.wav"
+        if not p.exists() or not donor_audio.exists():
+            continue
+        work.append({"video": v, "video_path": p,
+                     "audio_path": donor_audio, "swapped_from": donor})
+    return work
+
+
+def build_swap_work_seeded(seed: int = 42) -> List[Dict[str, Any]]:
+    base = []
+    seen = set()
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        if "_delay_" in v or "_early_" in v or v in seen:
+            continue
+        seen.add(v)
+        stem = Path(v).stem
+        vp = ORIG_DIR / v
+        ap = AUDIO_ORIG / f"{stem}.wav"
+        if vp.exists() and ap.exists():
+            base.append({"video": v, "stem": stem, "video_path": vp, "own_audio": ap})
+    rng = random.Random(seed)
+    shuffled = base.copy()
+    rng.shuffle(shuffled)
+    for i in range(len(shuffled)):
+        if shuffled[i]["stem"] == base[i]["stem"]:
+            j = (i + 1) % len(shuffled)
+            shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+    work = []
+    for i, b in enumerate(base):
+        donor = shuffled[i]
+        if donor["stem"] == b["stem"]:
+            continue
+        work.append({
+            "video": b["video"],
+            "video_path": b["video_path"],
+            "audio_path": donor["own_audio"],
+            "swapped_from": donor["video"],
+        })
+    return work
+
+
+# ---------------------------------------------------------------------------
+# Run loop with resume + parallelism
+# ---------------------------------------------------------------------------
+def run_task(out_dir: Path, work, runner, model_client, model,
+             judge_client, judge_model, send_mode, workers,
+             max_samples: int = -1):
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results_path = out_dir / "eval_results.jsonl"
+
+    processed = set()
+    if results_path.exists():
+        with open(results_path) as f:
+            for line in f:
+                line = line.strip()
+                if line:
+                    processed.add(json.loads(line)["video"])
+        print(f"[{out_dir.name}] resume: {len(processed)} already done")
+
+    todo = [w for w in work if w["video"] not in processed]
+    if max_samples > 0:
+        todo = todo[:max_samples]
+    print(f"[{out_dir.name}] {len(todo)} new / {len(work)} total")
+
+    def _go(item):
+        try:
+            return runner(item, model_client, model, judge_client, judge_model, send_mode)
+        except Exception as exc:
+            print(f"[{out_dir.name}] error on {item['video']}: {exc}", flush=True)
+            return None
+
+    n_done = 0
+    with ThreadPoolExecutor(max_workers=workers) as ex, open(results_path, "a") as out:
+        futures = {ex.submit(_go, item): item for item in todo}
+        for fut in as_completed(futures):
+            res = fut.result()
+            if res is None:
+                continue
+            out.write(json.dumps(res, ensure_ascii=False) + "\n")
+            out.flush()
+            n_done += 1
+            if n_done % 5 == 0 or n_done == len(todo):
+                print(f"[{out_dir.name}] {n_done}/{len(todo)} done", flush=True)
+    print(f"[{out_dir.name}] saved -> {results_path}")
+    return results_path
+
+
+# ---------------------------------------------------------------------------
+# Light summary
+# ---------------------------------------------------------------------------
+def summarize(results_path: Path, kind: str) -> Dict[str, Any]:
+    if not results_path.exists():
+        return {}
+    rows = [json.loads(line) for line in open(results_path) if line.strip()]
+    n = len(rows)
+    if n == 0:
+        return {}
+    if kind == "sync":
+        sync_correct = sum(1 for r in rows if r["pred_synced"] == r["gt_synced"])
+        three_class_correct = sum(
+            1 for r in rows
+            if (("synced" if r["pred_synced"] else r["pred_direction"]) ==
+                ("synced" if r["gt_synced"] else r["gt_direction"]))
+        )
+        return {"total": n,
+                "sync_desync_accuracy": round(sync_correct / n, 4),
+                "three_class_accuracy": round(three_class_correct / n, 4)}
+    if kind == "mute":
+        muted = sum(1 for r in rows if r["pred_label"] == "muted")
+        return {"total": n,
+                "mute_detection_rate": round(muted / n, 4),
+                "hallucination_rate": round(1 - muted / n, 4)}
+    if kind == "swap":
+        mis = sum(1 for r in rows if r["pred_label"] == "mismatched")
+        return {"total": n,
+                "mismatch_detection_rate": round(mis / n, 4),
+                "hallucination_rate": round(1 - mis / n, 4)}
+    return {"total": n}
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--openrouter-key", default=os.environ.get("OPENROUTER_API_KEY"))
+    ap.add_argument("--judge-key",
+                    default=os.environ.get("OPENAI_API_KEY") or os.environ.get("OPENROUTER_API_KEY"))
+    ap.add_argument("--model", default="nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free")
+    ap.add_argument("--judge-model", default="openai/gpt-5.4",
+                    help="If you have a real OPENAI_API_KEY (≠ OR key), use 'gpt-5.4' (native).")
+    ap.add_argument("--tasks", default="sync,swap_direct,swap_neutral,mute_neutral")
+    ap.add_argument("--workers", type=int, default=4)
+    ap.add_argument("--max-samples", type=int, default=-1)
+    ap.add_argument("--send-mode", choices=["muxed", "separate", "video"], default="muxed",
+                    help="muxed: ffmpeg merges target audio into video, send only video_url "
+                         "(deterministic — model hears exactly what we intend). "
+                         "separate: send video_url + input_audio blocks (model decides). "
+                         "video: send video_url only (uses whatever audio is in the mp4).")
+    ap.add_argument("--label-suffix", default="")
+    args = ap.parse_args()
+
+    if not args.openrouter_key:
+        sys.exit("[error] need --openrouter-key or OPENROUTER_API_KEY env")
+
+    model_client = _openrouter_client(args.openrouter_key)
+    judge_client, judge_via_or = _judge_client(args.judge_key, args.openrouter_key)
+    if not judge_via_or and args.judge_model.startswith("openai/"):
+        args.judge_model = args.judge_model.split("/", 1)[1]
+
+    print(f"[config] model={args.model}")
+    print(f"[config] judge={args.judge_model} (via {'OpenRouter' if judge_via_or else 'OpenAI'})")
+    print(f"[config] send_mode={args.send_mode}  workers={args.workers}")
+
+    # Derive a filesystem-safe tag from --model so the same script works for
+    # any OpenRouter omni model. `--label-suffix` is appended; `--label` (if
+    # added later) could fully override.
+    def _slug(m: str) -> str:
+        s = m.replace("/", "_").replace(":", "_").replace(" ", "_")
+        # known canonicalizations to preserve old dir names
+        if s == "nvidia_nemotron-3-nano-omni-30b-a3b-reasoning_free":
+            s = "nemotron3_nano_omni_reasoning_free"
+        return s
+    tag = _slug(args.model)
+    if args.label_suffix:
+        tag += args.label_suffix
+    elif args.send_mode == "muxed":
+        tag += "_audioMuxed"
+    elif args.send_mode == "separate":
+        tag += "_videoPlusAudio"
+    else:
+        tag += "_videoOnly"
+
+    tasks = [t.strip() for t in args.tasks.split(",") if t.strip()]
+
+    if "sync" in tasks:
+        out = run_task(EVAL_ROOT / "sync" / f"sync_{tag}",
+                       build_sync_work(), run_one_sync,
+                       model_client, args.model, judge_client, args.judge_model,
+                       args.send_mode, args.workers, args.max_samples)
+        print(f"[sync] {summarize(out, 'sync')}")
+
+    if "swap_direct" in tasks:
+        sw = build_swap_work_from_gemini() or build_swap_work_seeded()
+        out = run_task(EVAL_ROOT / "swap" / f"swap_{tag}_promptDirect",
+                       sw, run_one_swap_direct,
+                       model_client, args.model, judge_client, args.judge_model,
+                       args.send_mode, args.workers, args.max_samples)
+        print(f"[swap_direct] {summarize(out, 'swap')}")
+
+    if "swap_neutral" in tasks:
+        sw = build_swap_work_from_gemini() or build_swap_work_seeded()
+        out = run_task(EVAL_ROOT / "swap" / f"swap_{tag}_promptNeutral",
+                       sw, run_one_swap_neutral,
+                       model_client, args.model, judge_client, args.judge_model,
+                       args.send_mode, args.workers, args.max_samples)
+        print(f"[swap_neutral] {summarize(out, 'swap')}")
+
+    if "mute_neutral" in tasks:
+        out = run_task(EVAL_ROOT / "mute" / f"mute_{tag}_promptNeutral",
+                       build_mute_work(), run_one_mute,
+                       model_client, args.model, judge_client, args.judge_model,
+                       args.send_mode, args.workers, args.max_samples)
+        print(f"[mute_neutral] {summarize(out, 'mute')}")
+
+
+if __name__ == "__main__":
+    main()

eval_nemotron_openrouter_originals_control.py

@@ -0,0 +1,304 @@
+"""Control: ask Nemotron the SAME mute/swap prompts on UNMODIFIED original
+videos via OpenRouter, to measure false-positive rates (does the model
+incorrectly flag a clean clip as muted / mismatched?).
+
+Setup:
+  - Source: 142 base videos (the same ones used by the swap/mute eval).
+  - For every clip we send the ORIGINAL .mp4 as a `video_url` block — its
+    audio track is the real one and matches the visuals.
+  - No muxing. No silence. No donor audio.
+
+Tasks (same prompts as eval_nemotron_openrouter.py):
+  - swap_direct   "Does the audio in this video match...? yes/no"   -> expect 'yes' / synced
+  - swap_neutral  "Describe what you see and what you hear."          -> judge -> expect 'synced'
+  - mute_neutral  "Describe the audio you hear in this video."        -> judge -> expect NOT 'muted'
+
+Output:
+  ~/eval_results/swap_original/swap_<tag>_promptDirect/eval_results.jsonl
+  ~/eval_results/swap_original/swap_<tag>_promptNeutral/eval_results.jsonl
+  ~/eval_results/mute_original/mute_<tag>_promptNeutral/eval_results.jsonl
+  + metrics.json + summary.txt per dir.
+
+Usage:
+  export OPENROUTER_API_KEY=sk-or-v1-...
+  export OPENAI_API_KEY=sk-...    # judge (gpt-5.4)
+  python3 /home/ubuntu/eval_nemotron_openrouter_originals_control.py
+  python3 /home/ubuntu/eval_nemotron_openrouter_originals_control.py --tasks swap_direct --max-samples 10
+"""
+
+import argparse
+import io
+import json
+import os
+import sys
+from contextlib import redirect_stdout
+from pathlib import Path
+from typing import Any, Dict, List
+
+# Reuse all the heavy lifting from the main OpenRouter eval script.
+sys.path.insert(0, "/home/ubuntu")
+from eval_nemotron_openrouter import (  # noqa: E402
+    ORIG_DIR, TEST_JSONL,
+    SWAP_PROMPT_DIRECT, SWAP_PROMPT_NEUTRAL, MUTE_PROMPT_NEUTRAL,
+    SWAP_JUDGE_SYSTEM, MUTE_JUDGE_SYSTEM,
+    _openrouter_client, _judge_client,
+    _content_video_only,
+    call_model, call_judge,
+    run_task, summarize, load_jsonl,
+)
+
+EVAL_ROOT = Path("/home/ubuntu/eval_results")
+
+
+# ---------------------------------------------------------------------------
+# Build work — one entry per base (original) video. No donor / no silent wav.
+# ---------------------------------------------------------------------------
+def build_originals_work() -> List[Dict[str, Any]]:
+    work = []
+    seen = set()
+    for r in load_jsonl(TEST_JSONL):
+        v = r["video"]
+        if "_delay_" in v or "_early_" in v or v in seen:
+            continue
+        seen.add(v)
+        p = ORIG_DIR / v
+        if p.exists():
+            work.append({"video": v, "video_path": p})
+    return work
+
+
+# ---------------------------------------------------------------------------
+# Per-task runners — every clip's gt_label is "synced" (audio is real & matches)
+# ---------------------------------------------------------------------------
+def run_one_swap_direct(item, model_client, model, judge_client, judge_model, send_mode):
+    content = _content_video_only(SWAP_PROMPT_DIRECT, item["video_path"])
+    raw = call_model(model_client, model, content,
+                     max_tokens=1200, reasoning_budget=512)
+    t = (raw or "").strip().lower()
+    head = t.split()[:3] if t else []
+    if t.startswith("no") or "no" in head:
+        pred = "mismatched"
+    elif t.startswith("yes") or "yes" in head:
+        pred = "synced"
+    else:
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_label": "synced",
+        "pred_label": pred,
+        "correct": (pred == "synced"),
+        "parse_method": "direct",
+        "prompt_mode": "direct",
+        "send_mode": "video",
+        "raw_output": raw,
+    }
+
+
+def run_one_swap_neutral(item, model_client, model, judge_client, judge_model, send_mode):
+    content = _content_video_only(SWAP_PROMPT_NEUTRAL, item["video_path"])
+    raw = call_model(model_client, model, content,
+                     max_tokens=2000, reasoning_budget=768)
+    parsed = call_judge(judge_client, judge_model, SWAP_JUDGE_SYSTEM, raw) or {}
+    pred = str(parsed.get("prediction", "synced")).lower()
+    if pred not in ("synced", "delay", "early", "mismatched"):
+        pred = "synced"
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_label": "synced",
+        "pred_label": pred,
+        "correct": (pred == "synced"),
+        "judge_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openrouter_judge" if parsed else "judge_fail",
+        "prompt_mode": "neutral",
+        "send_mode": "video",
+        "raw_output": raw,
+    }
+
+
+def run_one_mute_neutral(item, model_client, model, judge_client, judge_model, send_mode):
+    content = _content_video_only(MUTE_PROMPT_NEUTRAL, item["video_path"])
+    raw = call_model(model_client, model, content,
+                     max_tokens=2000, reasoning_budget=768)
+    parsed = call_judge(judge_client, judge_model, MUTE_JUDGE_SYSTEM, raw) or {}
+    pred = str(parsed.get("prediction", "synced")).lower()
+    if pred not in ("muted", "synced", "delay", "early"):
+        pred = "synced"
+    # On a clean original, the model *should* describe the real audio (pred != muted).
+    return {
+        "video": item["video"],
+        "video_path": str(item["video_path"]),
+        "gt_label": "synced",
+        "pred_label": pred,
+        "correct": (pred != "muted"),
+        "judge_explanation": str(parsed.get("explanation", "")),
+        "parse_method": "openrouter_judge" if parsed else "judge_fail",
+        "prompt_mode": "neutral",
+        "send_mode": "video",
+        "raw_output": raw,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Metrics for control results (false-positive framing)
+# ---------------------------------------------------------------------------
+def metrics_swap_control(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    n = len(rows)
+    if n == 0:
+        return {}
+    bd = {k: 0 for k in ("synced", "mismatched", "delay", "early")}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        bd[r.get("pred_label", "synced")] = bd.get(r.get("pred_label", "synced"), 0) + 1
+        pm = r.get("parse_method", "unknown")
+        parse_stats[pm] = parse_stats.get(pm, 0) + 1
+    return {
+        "total_samples": n,
+        "correct_synced_rate": round(bd["synced"] / n, 4),       # the "right" answer
+        "false_mismatch_rate": round(bd["mismatched"] / n, 4),   # over-sensitivity
+        "prediction_breakdown": bd,
+        "parse_stats": parse_stats,
+    }
+
+
+def metrics_mute_control(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
+    n = len(rows)
+    if n == 0:
+        return {}
+    bd = {k: 0 for k in ("synced", "muted", "delay", "early")}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        bd[r.get("pred_label", "synced")] = bd.get(r.get("pred_label", "synced"), 0) + 1
+        pm = r.get("parse_method", "unknown")
+        parse_stats[pm] = parse_stats.get(pm, 0) + 1
+    return {
+        "total_samples": n,
+        "describes_audio_rate": round((n - bd["muted"]) / n, 4),  # the "right" answer
+        "false_muted_rate":   round(bd["muted"] / n, 4),         # over-sensitivity
+        "prediction_breakdown": bd,
+        "parse_stats": parse_stats,
+    }
+
+
+def print_swap_control(m, label):
+    print("=" * 60)
+    print(f"  Swap CONTROL (originals): {label}")
+    print("=" * 60)
+    print(f"  Total samples:        {m['total_samples']}")
+    print(f"  Correct 'synced' rate: {m['correct_synced_rate']:.1%}   <- desired")
+    print(f"  False mismatch rate:   {m['false_mismatch_rate']:.1%}   <- over-sensitivity")
+    bd = m["prediction_breakdown"]
+    print("  --- Prediction Breakdown ---")
+    for k in ("synced", "mismatched", "delay", "early"):
+        print(f"    {k:>10}: {bd[k]}")
+    print("  --- Parse Stats ---")
+    for k, v in sorted(m["parse_stats"].items()):
+        print(f"    {k}: {v}")
+    print("=" * 60)
+
+
+def print_mute_control(m, label):
+    print("=" * 60)
+    print(f"  Mute CONTROL (originals): {label}")
+    print("=" * 60)
+    print(f"  Total samples:           {m['total_samples']}")
+    print(f"  Describes-audio rate:    {m['describes_audio_rate']:.1%}   <- desired")
+    print(f"  False 'muted' rate:      {m['false_muted_rate']:.1%}   <- over-sensitivity")
+    bd = m["prediction_breakdown"]
+    print("  --- Prediction Breakdown ---")
+    for k in ("synced", "muted", "delay", "early"):
+        print(f"    {k:>10}: {bd[k]}")
+    print("  --- Parse Stats ---")
+    for k, v in sorted(m["parse_stats"].items()):
+        print(f"    {k}: {v}")
+    print("=" * 60)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+TASK_RUNNERS = {
+    "swap_direct":  run_one_swap_direct,
+    "swap_neutral": run_one_swap_neutral,
+    "mute_neutral": run_one_mute_neutral,
+}
+TASK_DIR = {
+    "swap_direct":  ("swap_original", "promptDirect"),
+    "swap_neutral": ("swap_original", "promptNeutral"),
+    "mute_neutral": ("mute_original", "promptNeutral"),
+}
+TASK_METRIC = {
+    "swap_direct":  (metrics_swap_control, print_swap_control, "swap"),
+    "swap_neutral": (metrics_swap_control, print_swap_control, "swap"),
+    "mute_neutral": (metrics_mute_control, print_mute_control, "mute"),
+}
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--openrouter-key", default=os.environ.get("OPENROUTER_API_KEY"))
+    ap.add_argument("--judge-key",
+                    default=os.environ.get("OPENAI_API_KEY") or os.environ.get("OPENROUTER_API_KEY"))
+    ap.add_argument("--model", default="nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free")
+    ap.add_argument("--judge-model", default="openai/gpt-5.4")
+    ap.add_argument("--tasks", default="swap_direct,swap_neutral,mute_neutral")
+    ap.add_argument("--workers", type=int, default=4)
+    ap.add_argument("--max-samples", type=int, default=-1)
+    ap.add_argument("--label-suffix", default="")
+    args = ap.parse_args()
+
+    if not args.openrouter_key:
+        sys.exit("[error] need OPENROUTER_API_KEY")
+
+    model_client = _openrouter_client(args.openrouter_key)
+    judge_client, judge_via_or = _judge_client(args.judge_key, args.openrouter_key)
+    if not judge_via_or and args.judge_model.startswith("openai/"):
+        args.judge_model = args.judge_model.split("/", 1)[1]
+    print(f"[config] model={args.model}")
+    print(f"[config] judge={args.judge_model} (via {'OpenRouter' if judge_via_or else 'OpenAI'})")
+
+    def _slug(m: str) -> str:
+        s = m.replace("/", "_").replace(":", "_").replace(" ", "_")
+        if s == "nvidia_nemotron-3-nano-omni-30b-a3b-reasoning_free":
+            s = "nemotron3_nano_omni_reasoning_free"
+        return s
+    tag = _slug(args.model) + (args.label_suffix or "_originalsControl")
+    work = build_originals_work()
+    print(f"[data] {len(work)} original (untampered) videos")
+
+    tasks = [t.strip() for t in args.tasks.split(",") if t.strip()]
+    for task in tasks:
+        if task not in TASK_RUNNERS:
+            print(f"[warn] unknown task {task}")
+            continue
+        bucket, suffix = TASK_DIR[task]
+        out_dir = EVAL_ROOT / bucket / f"{bucket.split('_')[0]}_{tag}_{suffix}"
+        run_task(out_dir, work, TASK_RUNNERS[task],
+                 model_client, args.model, judge_client, args.judge_model,
+                 send_mode="video", workers=args.workers, max_samples=args.max_samples)
+
+        # metrics
+        rows = [json.loads(l) for l in open(out_dir / "eval_results.jsonl") if l.strip()]
+        compute, prn, _kind = TASK_METRIC[task]
+        m = compute(rows)
+        m["eval_config"] = {
+            "model": args.model,
+            "provider": "openrouter",
+            "judge": args.judge_model,
+            "task": task,
+            "control": "untampered original videos (gt_label='synced' for all)",
+            "send_mode": "video (original .mp4 with its real embedded audio)",
+        }
+        (out_dir / "metrics.json").write_text(json.dumps(m, indent=2, ensure_ascii=False))
+        buf = io.StringIO()
+        with redirect_stdout(buf):
+            prn(m, out_dir.name)
+        (out_dir / "summary.txt").write_text(buf.getvalue())
+        prn(m, out_dir.name)
+        print(f"  -> {out_dir / 'metrics.json'}")
+        print(f"  -> {out_dir / 'summary.txt'}")
+
+
+if __name__ == "__main__":
+    main()

eval_originals_control.py

@@ -0,0 +1,523 @@
+"""Control eval: ask the SAME mute/swap yes/no prompts on UNMODIFIED original videos.
+
+Tests whether models correctly say 'yes' on natural audio
+(answer should be 'yes' for both prompts when audio is unmodified).
+
+Models supported (one per invocation, each may need a different conda env):
+  Qwen3-Omni vanilla : --model Qwen/Qwen3-Omni-30B-A3B-Instruct --label qwen3omni_vanilla
+  Ming-flash-omni    : --model /opt/dlami/nvme/Ming-weights              (use ming env)
+  MiniCPM-o-4_5      : --model openbmb/MiniCPM-o-4_5
+  Gemini             : --gemini  --gemini-model gemini-3.1-pro-preview
+
+Output (matches existing convention):
+  ~/eval_results/mute_original/mute_<label>_promptDirect/{eval_results.jsonl,metrics.json}
+  ~/eval_results/swap_original/swap_<label>_promptDirect/{eval_results.jsonl,metrics.json}
+
+Per-row schema mirrors eval_mute.py / eval_swap.py:
+  gt_label = "synced"  (audio is present and matches video — model should say 'yes')
+  pred_label = "synced" (yes) | "muted" (no, mute task) | "mismatched" (no, swap task)
+  correct = (pred_label == "synced")
+
+Usage:
+  conda activate <env-for-model>
+  OPENAI_API_KEY=sk-...   # not needed for direct yes/no, kept for parity
+  GEMINI_API_KEY=...      # only for --gemini
+  python3 /home/ubuntu/eval_originals_control.py --model Qwen/Qwen3-Omni-30B-A3B-Instruct \
+      --label qwen3omni_vanilla --tasks mute,swap
+"""
+
+import argparse
+import gc
+import json
+import os
+import re
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+DATA_ROOT     = Path("/opt/dlami/nvme/video_source")
+ORIG_VIDEO_DIR = DATA_ROOT / "original" / "uag_oops"
+ORIG_AUDIO_DIR = DATA_ROOT / "extracted_audio" / "original" / "uag_oops"
+TEST_JSONL    = Path("/home/ubuntu/CleverHans-Evaluation/data/kto_training_data_v2_test.jsonl")
+EVAL_ROOT     = Path("/home/ubuntu/eval_results")
+
+MUTE_PROMPT_DIRECT  = "Is there any audible sound in this video? Answer with only 'yes' or 'no'."
+MUTE_PROMPT_NEUTRAL = "Describe the audio you hear in this video."
+SWAP_PROMPT_DIRECT  = "Does the audio in this video match the visual content? Answer with only 'yes' or 'no'."
+SWAP_PROMPT_NEUTRAL = "Describe what you see in the video and what you hear in the audio."
+
+MUTE_NEUTRAL_JUDGE_SYSTEM = (
+    "You classify a model's free-form description of a short video's audio. "
+    "Return STRICT JSON only with keys: prediction (one of "
+    "'synced'|'muted'|'delay'|'early') and explanation (one sentence). "
+    "Rules: "
+    "- 'synced' iff the model describes any audible content (speech, music, "
+    "  laughter, impact sounds, ambient noise, etc.) without claiming a "
+    "  temporal offset. "
+    "- 'muted' iff the model claims no audio / silence / nothing audible. "
+    "- 'delay' iff the model claims audio lags behind visuals. "
+    "- 'early' iff the model claims audio precedes visuals."
+)
+
+SWAP_NEUTRAL_JUDGE_SYSTEM = (
+    "You classify a model's free-form description of a video's visuals and "
+    "audio for whether it claims an audio/visual mismatch. Return STRICT JSON "
+    "only with keys: prediction (one of 'synced'|'mismatched') and explanation "
+    "(one sentence). Rules: "
+    "- 'mismatched' iff the model explicitly says the audio does not match the "
+    "  visuals (e.g., dubbed/voiceover, audio describes a different scene, "
+    "  unrelated sounds). "
+    "- 'synced' otherwise — including when the model describes audio that "
+    "  appears to fit the visuals, or simply describes both without raising any "
+    "  mismatch."
+)
+
+
+# ---------------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------------
+def slugify(name: str) -> str:
+    return re.sub(r"[/:]", "_", name)
+
+
+def load_originals() -> List[Dict[str, Any]]:
+    """142 unique base videos, each with its on-disk video + extracted-audio paths."""
+    out, seen = [], set()
+    with open(TEST_JSONL) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            obj = json.loads(line)
+            v = obj["video"]
+            if "_delay_" in v or "_early_" in v or v in seen:
+                continue
+            seen.add(v)
+            video_path = ORIG_VIDEO_DIR / v
+            audio_path = ORIG_AUDIO_DIR / (v[:-4] + ".wav")
+            if not video_path.exists():
+                print(f"[skip] missing video: {v}", flush=True); continue
+            if not audio_path.exists():
+                print(f"[skip] missing audio: {audio_path.name}", flush=True); continue
+            out.append({"video": v, "video_path": str(video_path), "audio_path": str(audio_path)})
+    return out
+
+
+def _openai_classify(raw, system_prompt, allowed, default, *,
+                      api_key, judge_model, fallback_keywords=None,
+                      fallback_pred=None):
+    """Generic OpenAI JSON classifier shared by mute and swap neutral judges."""
+    try:
+        from openai import OpenAI
+    except ImportError:
+        return {"prediction": default, "judge_explanation": "openai-not-installed",
+                "parse_method": "neutral_judge_unavailable"}
+    try:
+        client = OpenAI(api_key=api_key)
+        resp = client.chat.completions.create(
+            model=judge_model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": raw},
+            ],
+            response_format={"type": "json_object"},
+            max_completion_tokens=300,
+        )
+        obj = json.loads(resp.choices[0].message.content or "")
+        pred = str(obj.get("prediction", default)).lower()
+        if pred not in allowed:
+            pred = default
+        return {
+            "prediction": pred,
+            "judge_explanation": str(obj.get("explanation", "")),
+            "parse_method": "openai_judge",
+        }
+    except Exception as exc:
+        t = (raw or "").lower()
+        if fallback_keywords and any(k in t for k in fallback_keywords):
+            return {"prediction": fallback_pred, "judge_explanation": f"fallback: {exc}",
+                    "parse_method": "neutral_keyword_fallback"}
+        return {"prediction": default, "judge_explanation": f"fallback: {exc}",
+                "parse_method": "neutral_keyword_fallback"}
+
+
+def openai_judge_mute_neutral(raw: str, *, api_key: str, judge_model: str) -> Dict[str, Any]:
+    return _openai_classify(
+        raw, MUTE_NEUTRAL_JUDGE_SYSTEM,
+        allowed={"synced", "muted", "delay", "early"}, default="synced",
+        api_key=api_key, judge_model=judge_model,
+        fallback_keywords=("no audio", "silent", "no sound", "no audible",
+                           "silence", "no discernible audio"),
+        fallback_pred="muted",
+    )
+
+
+def openai_judge_swap_neutral(raw: str, *, api_key: str, judge_model: str) -> Dict[str, Any]:
+    return _openai_classify(
+        raw, SWAP_NEUTRAL_JUDGE_SYSTEM,
+        allowed={"synced", "mismatched"}, default="synced",
+        api_key=api_key, judge_model=judge_model,
+        fallback_keywords=("does not match", "do not match", "doesn't match",
+                           "mismatch", "unrelated", "dubbed", "voiceover"),
+        fallback_pred="mismatched",
+    )
+
+
+def parse_yesno(raw: str, *, no_label: str) -> Dict[str, Any]:
+    """Same parsing convention as eval_mute.py / eval_swap.py direct mode.
+
+    Returns ``{"prediction": <pred>, "parse_method": "direct"}`` where pred is
+    "synced" on yes, ``no_label`` on no, and "synced" on ambiguous (matches
+    existing default; original videos with audio should yield 'yes' anyway).
+    """
+    t = (raw or "").strip().lower()
+    if not t:
+        return {"prediction": "synced", "parse_method": "direct_empty"}
+    if t.startswith("no") or "no" in t.split()[:3]:
+        return {"prediction": no_label, "parse_method": "direct"}
+    if t.startswith("yes") or "yes" in t.split()[:3]:
+        return {"prediction": "synced", "parse_method": "direct"}
+    return {"prediction": "synced", "parse_method": "direct"}
+
+
+def write_metrics_mute(rows, model, judge_model, out_path: Path,
+                        prompt_mode: str = "direct"):
+    breakdown = {"synced": 0, "muted": 0, "delay": 0, "early": 0}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        pl = r["pred_label"]
+        breakdown[pl] = breakdown.get(pl, 0) + 1
+        m = r.get("parse_method", "")
+        parse_stats[m] = parse_stats.get(m, 0) + 1
+    n = len(rows)
+    metrics = {
+        "total_samples": n,
+        # Correct iff model said 'synced' (for original/control, real audio is there)
+        "audio_present_detection_rate": round(breakdown["synced"] / n, 4) if n else 0.0,
+        "false_silent_rate":            round(breakdown["muted"] / n, 4) if n else 0.0,
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+        "eval_config": {
+            "base_model": model,
+            "prompt_mode": prompt_mode,
+            "judge_model": judge_model,
+            "input_kind": "original_video_with_original_audio",
+            "task_kind":  "mute_control",
+        },
+    }
+    out_path.write_text(json.dumps(metrics, indent=2, ensure_ascii=False))
+
+
+def write_metrics_swap(rows, model, judge_model, out_path: Path,
+                        prompt_mode: str = "direct"):
+    breakdown = {"synced": 0, "mismatched": 0}
+    parse_stats: Dict[str, int] = {}
+    for r in rows:
+        breakdown[r["pred_label"]] = breakdown.get(r["pred_label"], 0) + 1
+        m = r.get("parse_method", "")
+        parse_stats[m] = parse_stats.get(m, 0) + 1
+    n = len(rows)
+    metrics = {
+        "total_samples": n,
+        "match_detection_rate":  round(breakdown["synced"] / n, 4) if n else 0.0,
+        "false_mismatch_rate":   round(breakdown["mismatched"] / n, 4) if n else 0.0,
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+        "eval_config": {
+            "base_model": model,
+            "prompt_mode": prompt_mode,
+            "judge_model": judge_model,
+            "input_kind": "original_video_with_original_audio",
+            "task_kind":  "swap_control",
+        },
+    }
+    out_path.write_text(json.dumps(metrics, indent=2, ensure_ascii=False))
+
+
+# ---------------------------------------------------------------------------
+# Omni-model path (Qwen / Ming / MiniCPM): reuse multi_omni_adapter
+# ---------------------------------------------------------------------------
+def _load_omni(base_model: str):
+    sys.path.insert(0, "/home/ubuntu/CleverHans-Evaluation/scripts")
+    from multi_omni_adapter import get_adapter
+    print(f"[load] {base_model}", flush=True)
+    omni = get_adapter(base_model)
+    omni.load()
+    return omni
+
+
+def run_omni_task(omni, items, prompt, parser, out_dir, max_new_tokens,
+                   prompt_mode="direct", task_is_swap=False):
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results_path = out_dir / "eval_results.jsonl"
+
+    processed = set()
+    if results_path.exists():
+        for line in open(results_path):
+            line = line.strip()
+            if line:
+                processed.add(json.loads(line)["video"])
+        print(f"[{out_dir.name}] resume: {len(processed)} done", flush=True)
+
+    todo = [it for it in items if it["video"] not in processed]
+    print(f"[{out_dir.name}] {len(todo)} new / {len(items)} total", flush=True)
+
+    n_done = 0
+    with open(results_path, "a") as out:
+        for it in todo:
+            try:
+                raw = omni.infer(it["video_path"], it["audio_path"], prompt,
+                                 max_new_tokens=max_new_tokens, temperature=0.0)
+            except Exception as exc:
+                print(f"[error] {it['video']}: {exc}", flush=True)
+                continue
+            if not raw:
+                print(f"[skip] empty raw for {it['video']}", flush=True)
+                continue
+            pj = parser(raw)
+            row = {
+                "video": it["video"],
+                "video_path": it["video_path"],
+                "gt_label": "synced",
+                "pred_label": pj["prediction"],
+                "correct": pj["prediction"] == "synced",
+                "parse_method": pj["parse_method"],
+                "prompt_mode": prompt_mode,
+                "raw_output": raw,
+            }
+            if "judge_explanation" in pj:
+                row["judge_explanation"] = pj["judge_explanation"]
+            if task_is_swap:
+                row["swapped_from"] = None  # original audio
+            out.write(json.dumps(row, ensure_ascii=False) + "\n")
+            out.flush()
+            n_done += 1
+            if n_done % 10 == 0 or n_done == len(todo):
+                print(f"[{out_dir.name}] {n_done}/{len(todo)}", flush=True)
+            try:
+                import torch; torch.cuda.empty_cache()
+            except Exception:
+                pass
+            gc.collect()
+
+    return [json.loads(l) for l in open(results_path) if l.strip()]
+
+
+# ---------------------------------------------------------------------------
+# Gemini path
+# ---------------------------------------------------------------------------
+def _gemini_client(api_key: str):
+    from google import genai
+    return genai.Client(api_key=api_key)
+
+
+def _wait_active(client, file_obj, timeout=600):
+    start = time.time()
+    while True:
+        f = client.files.get(name=file_obj.name)
+        state = getattr(f.state, "name", str(f.state))
+        if state == "ACTIVE":
+            return f
+        if state == "FAILED":
+            raise RuntimeError(f"Gemini file FAILED: {file_obj.name}")
+        if time.time() - start > timeout:
+            raise TimeoutError(f"Gemini upload state {state} after {timeout}s")
+        time.sleep(2)
+
+
+def gemini_infer(client, model: str, video_path: str, prompt: str,
+                  max_tokens=4096, temperature=0.0, delete=True) -> str:
+    """Upload + ask. Some Gemini 3.x previews REQUIRE thinking mode (reject
+    ``thinking_budget=0`` with INVALID_ARGUMENT), so we don't try to disable
+    it. We just budget enough output tokens to cover thinking + visible
+    content (default 4096)."""
+    fobj = client.files.upload(file=video_path)
+    fobj = _wait_active(client, fobj)
+    try:
+        cfg: Dict[str, Any] = {
+            "max_output_tokens": max_tokens,
+            "temperature": temperature,
+        }
+        resp = client.models.generate_content(
+            model=model,
+            contents=[prompt, fobj],
+            config=cfg,
+        )
+        return (resp.text or "").strip()
+    finally:
+        if delete:
+            try: client.files.delete(name=fobj.name)
+            except Exception: pass
+
+
+def run_gemini_task(client, gemini_model, items, prompt, parser, out_dir, workers,
+                     prompt_mode="direct", task_is_swap=False, gemini_max_tokens=2048):
+    out_dir.mkdir(parents=True, exist_ok=True)
+    results_path = out_dir / "eval_results.jsonl"
+
+    processed = set()
+    if results_path.exists():
+        for line in open(results_path):
+            line = line.strip()
+            if line:
+                processed.add(json.loads(line)["video"])
+        print(f"[{out_dir.name}] resume: {len(processed)} done", flush=True)
+
+    todo = [it for it in items if it["video"] not in processed]
+    print(f"[{out_dir.name}] {len(todo)} new / {len(items)} total", flush=True)
+
+    def _go(it):
+        try:
+            raw = gemini_infer(client, gemini_model, it["video_path"], prompt,
+                                max_tokens=gemini_max_tokens)
+        except Exception as exc:
+            print(f"[error] {it['video']}: {exc}", flush=True)
+            return None
+        if not raw:
+            print(f"[empty] {it['video']}", flush=True)
+            return None
+        pj = parser(raw)
+        row = {
+            "video": it["video"],
+            "video_path": it["video_path"],
+            "gt_label": "synced",
+            "pred_label": pj["prediction"],
+            "correct": pj["prediction"] == "synced",
+            "parse_method": pj["parse_method"],
+            "prompt_mode": prompt_mode,
+            "raw_output": raw,
+        }
+        if "judge_explanation" in pj:
+            row["judge_explanation"] = pj["judge_explanation"]
+        if task_is_swap:
+            row["swapped_from"] = None
+        return row
+
+    n_done = 0
+    with ThreadPoolExecutor(max_workers=workers) as ex, open(results_path, "a") as out:
+        futures = {ex.submit(_go, it): it for it in todo}
+        for fut in as_completed(futures):
+            row = fut.result()
+            if row is None:
+                continue
+            out.write(json.dumps(row, ensure_ascii=False) + "\n")
+            out.flush()
+            n_done += 1
+            if n_done % 10 == 0 or n_done == len(todo):
+                print(f"[{out_dir.name}] {n_done}/{len(todo)}", flush=True)
+
+    return [json.loads(l) for l in open(results_path) if l.strip()]
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", help="HF id or local path for omni model.")
+    ap.add_argument("--label", help="Output dir suffix (defaults to slug of --model).")
+    ap.add_argument("--tasks", default="mute,swap")
+    ap.add_argument("--max-new-tokens", type=int, default=0,
+                    help="0 = pick per-task default (32 for direct, 256 for neutral).")
+    ap.add_argument("--mute-prompt-mode", choices=["direct", "neutral"], default="direct",
+                    help="'neutral' uses 'Describe the audio you hear' + OpenAI judge.")
+    ap.add_argument("--swap-prompt-mode", choices=["direct", "neutral"], default="direct",
+                    help="'neutral' uses 'Describe what you see and hear' + OpenAI judge.")
+    ap.add_argument("--all-modes", action="store_true",
+                    help="Run mute×{direct,neutral} and swap×{direct,neutral} sequentially "
+                         "(4 phases). Each phase has independent resume.")
+    ap.add_argument("--gemini", action="store_true",
+                    help="Use Gemini API instead of an omni adapter.")
+    ap.add_argument("--gemini-model", default="gemini-3.1-pro-preview")
+    ap.add_argument("--gemini-api-key", default=os.environ.get("GEMINI_API_KEY"))
+    ap.add_argument("--openai-api-key", default=os.environ.get("OPENAI_API_KEY"),
+                    help="Required when --mute-prompt-mode=neutral (for the judge).")
+    ap.add_argument("--judge-model", default="gpt-5.4")
+    ap.add_argument("--workers", type=int, default=4)
+    args = ap.parse_args()
+
+    items = load_originals()
+    print(f"[data] {len(items)} original videos", flush=True)
+
+    tasks = [t.strip() for t in args.tasks.split(",") if t.strip()]
+    if args.all_modes:
+        phases = [("mute", "direct"), ("mute", "neutral"),
+                  ("swap", "direct"), ("swap", "neutral")]
+    else:
+        phases = []
+        if "mute" in tasks:
+            phases.append(("mute", args.mute_prompt_mode))
+        if "swap" in tasks:
+            phases.append(("swap", args.swap_prompt_mode))
+
+    needs_openai = any(mode == "neutral" for _, mode in phases)
+    if needs_openai and not args.openai_api_key:
+        sys.exit("[error] neutral phases need --openai-api-key or OPENAI_API_KEY")
+
+    def _phase_config(task, mode):
+        """Return (prompt, parser, max_new_tokens, dir_suffix, root_dir, write_metrics)."""
+        if task == "mute" and mode == "direct":
+            return (MUTE_PROMPT_DIRECT,
+                    lambda raw: parse_yesno(raw, no_label="muted"),
+                    args.max_new_tokens or 32, "_promptDirect",
+                    EVAL_ROOT / "mute_original",
+                    lambda rows, p: write_metrics_mute(rows, _model_name, args.judge_model, p, "direct"))
+        if task == "mute" and mode == "neutral":
+            return (MUTE_PROMPT_NEUTRAL,
+                    lambda raw: openai_judge_mute_neutral(
+                        raw, api_key=args.openai_api_key, judge_model=args.judge_model),
+                    args.max_new_tokens or 256, "_promptNeutral",
+                    EVAL_ROOT / "mute_original",
+                    lambda rows, p: write_metrics_mute(rows, _model_name, args.judge_model, p, "neutral"))
+        if task == "swap" and mode == "direct":
+            return (SWAP_PROMPT_DIRECT,
+                    lambda raw: parse_yesno(raw, no_label="mismatched"),
+                    args.max_new_tokens or 32, "_promptDirect",
+                    EVAL_ROOT / "swap_original",
+                    lambda rows, p: write_metrics_swap(rows, _model_name, args.judge_model, p, "direct"))
+        if task == "swap" and mode == "neutral":
+            return (SWAP_PROMPT_NEUTRAL,
+                    lambda raw: openai_judge_swap_neutral(
+                        raw, api_key=args.openai_api_key, judge_model=args.judge_model),
+                    args.max_new_tokens or 256, "_promptNeutral",
+                    EVAL_ROOT / "swap_original",
+                    lambda rows, p: write_metrics_swap(rows, _model_name, args.judge_model, p, "neutral"))
+        raise ValueError(f"bad task/mode: {task}/{mode}")
+
+    if args.gemini:
+        if not args.gemini_api_key:
+            sys.exit("[error] need --gemini-api-key or GEMINI_API_KEY")
+        _model_name = args.gemini_model
+        label = args.label or slugify(args.gemini_model)
+        client = _gemini_client(args.gemini_api_key)
+        for task, mode in phases:
+            prompt, parser, _, dir_suffix, root_dir, wm = _phase_config(task, mode)
+            d = root_dir / f"{task}_{label}{dir_suffix}"
+            rows = run_gemini_task(client, args.gemini_model, items, prompt, parser,
+                                   d, args.workers, prompt_mode=mode,
+                                   task_is_swap=(task == "swap"))
+            wm(rows, d / "metrics.json")
+            print(f"[{task}/{mode}] saved -> {d} ({len(rows)}/{len(items)}; "
+                  f"{len(items) - len(rows)} missing — re-run to retry)")
+    else:
+        if not args.model:
+            sys.exit("[error] need --model (or pass --gemini)")
+        _model_name = args.model
+        label = args.label or slugify(args.model)
+        omni = _load_omni(args.model)
+        for task, mode in phases:
+            prompt, parser, max_new, dir_suffix, root_dir, wm = _phase_config(task, mode)
+            d = root_dir / f"{task}_{label}{dir_suffix}"
+            rows = run_omni_task(omni, items, prompt, parser, d, max_new,
+                                 prompt_mode=mode, task_is_swap=(task == "swap"))
+            wm(rows, d / "metrics.json")
+            print(f"[{task}/{mode}] saved -> {d}")
+
+
+if __name__ == "__main__":
+    main()

finalize_case_study.py

@@ -0,0 +1,153 @@
+"""Final 6-way intersection for the case study, using all real signals.
+
+Conditions (all must hold for a base video):
+  Qwen3-Omni:
+    - mute   : raw_output starts with 'yes'  (hallucinated audio in silence)
+    - swap   : raw_output starts with 'yes'  (claimed mismatched audio matches)
+    - sync   : both delay AND early variants are wrong (sync_is_wrong())
+  Gemini-3.1-pro-preview:
+    - swap   : raw_output starts with 'yes'  (claimed mismatched audio matches)
+    - sync   : both delay AND early variants are wrong (re-run on pool)
+    - mute   : neutral prompt -> OpenAI judge marks correct=False (real hallucination)
+
+Writes survivors to /home/ubuntu/case_study_candidates.jsonl with full failure detail.
+"""
+
+import json
+import re
+from pathlib import Path
+
+# Qwen
+QWEN_MUTE   = "/home/ubuntu/eval_results/mute/mute_qwen3omni_vanilla_promptDirect/eval_results.jsonl"
+QWEN_SWAP   = "/home/ubuntu/eval_results/swap/swap_Qwen_Qwen3-Omni-30B-A3B-Instruct_promptDirect/eval_results.jsonl"
+QWEN_SYNC   = "/home/ubuntu/eval_results/sync/sync_qwen3omni_vanilla/eval_results.jsonl"
+# Gemini direct swap (the original yes/no eval)
+GEMINI_SWAP = "/home/ubuntu/eval_results/gemini_mute_sync_swap/swap/swap_gemini_gemini-3.1-pro-preview__promptDirect/eval_results.jsonl"
+# Gemini results we re-ran on the 45-pool
+GEMINI_SYNC = "/home/ubuntu/eval_results/case_study_pool/sync/case_study_pool_gemini_sync/eval_results.jsonl"
+GEMINI_MUTE = "/home/ubuntu/eval_results/case_study_pool/mute/case_study_pool_gemini_mute_neutral/eval_results.jsonl"
+
+OUT_PATH = Path("/home/ubuntu/case_study_candidates.jsonl")
+
+SYNC_SUFFIX_RE = re.compile(r"_(delay|early)_\d+(?:\.\d+)?s(?=\.mp4$)")
+DIRECTION_RE   = re.compile(r"_(delay|early)_(\d+(?:\.\d+)?)s\.mp4$")
+
+
+def base_of(name): return SYNC_SUFFIX_RE.sub("", name)
+def direction_of(name):
+    m = DIRECTION_RE.search(name)
+    return m.group(1) if m else None
+
+
+def load_jsonl(path):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def real_yes_wrong(jsonl_path):
+    """Wrong rows whose raw_output starts with 'yes' (drops empty/ambiguous artifacts)."""
+    out = set()
+    for r in load_jsonl(jsonl_path):
+        if r.get("correct", True):
+            continue
+        if (r.get("raw_output") or "").strip().lower().startswith("yes"):
+            out.add(r["video"])
+    return out
+
+
+def sync_is_wrong(row):
+    gt_synced = bool(row.get("gt_synced"))
+    pred_synced = bool(row.get("pred_synced"))
+    if gt_synced != pred_synced:
+        return True
+    if not gt_synced and row.get("pred_direction") != row.get("gt_direction"):
+        return True
+    return False
+
+
+def collect_sync_intervention_failures(jsonl_path):
+    """{base: {direction: row_summary}} for wrong delay/early variants only."""
+    by_base = {}
+    for r in load_jsonl(jsonl_path):
+        v = r["video"]
+        d = direction_of(v)
+        if d is None:
+            continue
+        if sync_is_wrong(r):
+            by_base.setdefault(base_of(v), {})[d] = {
+                "variant": v,
+                "gt": (r.get("gt_direction"), r.get("gt_offset_sec")),
+                "pred_synced": r.get("pred_synced"),
+                "pred": (r.get("pred_direction"), r.get("pred_offset_sec")),
+            }
+    return by_base
+
+
+def main():
+    qwen_mute_yes    = real_yes_wrong(QWEN_MUTE)
+    qwen_swap_yes    = real_yes_wrong(QWEN_SWAP)
+    gem_swap_yes     = real_yes_wrong(GEMINI_SWAP)
+    qwen_sync_fails  = collect_sync_intervention_failures(QWEN_SYNC)
+    gem_sync_fails   = collect_sync_intervention_failures(GEMINI_SYNC)
+
+    qwen_sync_both = {b for b, d in qwen_sync_fails.items() if "delay" in d and "early" in d}
+    gem_sync_both  = {b for b, d in gem_sync_fails.items()  if "delay" in d and "early" in d}
+
+    gem_mute_wrong = {r["video"] for r in load_jsonl(GEMINI_MUTE) if not r.get("correct", True)}
+
+    print("Per-source REAL failure sets:")
+    print(f"  qwen   mute     (yes)        : {len(qwen_mute_yes)}")
+    print(f"  qwen   swap     (yes)        : {len(qwen_swap_yes)}")
+    print(f"  qwen   sync     (delay&early): {len(qwen_sync_both)}")
+    print(f"  gemini swap     (yes)        : {len(gem_swap_yes)}")
+    print(f"  gemini sync     (delay&early): {len(gem_sync_both)}")
+    print(f"  gemini mute neu (judge wrong): {len(gem_mute_wrong)}")
+
+    final = (
+        qwen_mute_yes
+        & qwen_swap_yes
+        & qwen_sync_both
+        & gem_swap_yes
+        & gem_sync_both
+        & gem_mute_wrong
+    )
+    print(f"\nFinal 6-way intersection: {len(final)} videos\n")
+
+    qwen_swap_rows = {r["video"]: r for r in load_jsonl(QWEN_SWAP) if not r.get("correct", True)}
+    gem_swap_rows  = {r["video"]: r for r in load_jsonl(GEMINI_SWAP) if not r.get("correct", True)}
+    gem_mute_rows  = {r["video"]: r for r in load_jsonl(GEMINI_MUTE)}
+
+    rows = []
+    for v in sorted(final):
+        gem_mute = gem_mute_rows.get(v, {})
+        rec = {
+            "video": v,
+            "gemini_swap_audio_from": gem_swap_rows.get(v, {}).get("swapped_from"),
+            "qwen_swap_audio_from":   qwen_swap_rows.get(v, {}).get("swapped_from"),
+            "gemini_mute_neutral_raw": (gem_mute.get("raw_output") or "").strip(),
+            "gemini_mute_judge":       gem_mute.get("judge_explanation"),
+            "gemini_sync_failures": [gem_sync_fails[v]["delay"], gem_sync_fails[v]["early"]],
+            "qwen_sync_failures":   [qwen_sync_fails[v]["delay"], qwen_sync_fails[v]["early"]],
+        }
+        rows.append(rec)
+        print(f"VIDEO: {v}")
+        print(f"  swap audio source           : {rec['gemini_swap_audio_from']}")
+        print(f"  gemini mute neutral raw     : {rec['gemini_mute_neutral_raw'][:140]}")
+        for label, fails in (("gemini", rec["gemini_sync_failures"]),
+                             ("qwen  ", rec["qwen_sync_failures"])):
+            for f in fails:
+                tag = f["variant"].rsplit("_", 1)[-1].rstrip(".mp4")
+                print(f"  [{label}] {tag:<8} gt={f['gt']}  pred_synced={f['pred_synced']}  pred={f['pred']}")
+        print()
+
+    with open(OUT_PATH, "w") as f:
+        for rec in rows:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"[saved] {len(rows)} rows -> {OUT_PATH}")
+
+
+if __name__ == "__main__":
+    main()

find_case_study.py

@@ -0,0 +1,140 @@
+"""Find videos where Gemini and Qwen3-Omni both failed across mute/swap/sync.
+
+Selection criteria (all must hold for a base video X.mp4):
+  1. Gemini failed on swap version of X    -> X in swap case_study_explicit.jsonl
+  2. Gemini failed on muted version of X   -> X in gemini mute jsonl with correct=false
+  3. Qwen failed on muted version of X     -> X in qwen mute jsonl with correct=false
+  4. Qwen failed on swap version of X      -> X in qwen swap jsonl with correct=false
+  5. Qwen failed on >=1 sync intervention  -> X_delay_*.mp4 / X_early_*.mp4 wrong
+                                              (gt_synced=False but pred_synced=True,
+                                               OR pred_direction != gt_direction)
+"""
+
+import json
+import re
+from pathlib import Path
+
+GEMINI_SWAP_CASE  = "/home/ubuntu/eval_results/gemini_mute_sync_swap/swap/swap_gemini_gemini-3.1-pro-preview__promptDirect/case_study_explicit.jsonl"
+GEMINI_MUTE       = "/home/ubuntu/eval_results/gemini_mute_sync_swap/mute/mute_gemini_gemini-3.1-pro-preview__promptDirect/eval_results.jsonl"
+QWEN_MUTE         = "/home/ubuntu/eval_results/mute/mute_qwen3omni_vanilla_promptDirect/eval_results.jsonl"
+QWEN_SWAP         = "/home/ubuntu/eval_results/swap/swap_Qwen_Qwen3-Omni-30B-A3B-Instruct_promptDirect/eval_results.jsonl"
+QWEN_SYNC         = "/home/ubuntu/eval_results/sync/sync_qwen3omni_vanilla/eval_results.jsonl"
+
+# Strip `_delay_2.39s` or `_early_1.95s` right before .mp4 to recover the base name.
+SYNC_SUFFIX_RE = re.compile(r"_(delay|early)_\d+(?:\.\d+)?s(?=\.mp4$)")
+
+
+def base_of(video_name: str) -> str:
+    return SYNC_SUFFIX_RE.sub("", video_name)
+
+
+def load_jsonl(path: str):
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                yield json.loads(line)
+
+
+def sync_is_wrong(row: dict) -> bool:
+    """Qwen sync correctness: pred must match gt_synced AND (when not synced) direction."""
+    gt_synced = bool(row.get("gt_synced"))
+    pred_synced = bool(row.get("pred_synced"))
+    if gt_synced != pred_synced:
+        return True
+    if not gt_synced and row.get("pred_direction") != row.get("gt_direction"):
+        return True
+    return False
+
+
+def main():
+    # 1. Gemini swap: every row in case_study_explicit is by construction a Gemini failure.
+    gemini_swap_wrong = {row["video"] for row in load_jsonl(GEMINI_SWAP_CASE)}
+
+    # 2-4. Mute & swap with explicit `correct` field.
+    gemini_mute_wrong = {r["video"] for r in load_jsonl(GEMINI_MUTE) if not r.get("correct", True)}
+    qwen_mute_wrong   = {r["video"] for r in load_jsonl(QWEN_MUTE)   if not r.get("correct", True)}
+    qwen_swap_wrong   = {r["video"] for r in load_jsonl(QWEN_SWAP)   if not r.get("correct", True)}
+
+    # 5. Qwen sync: collect, per base video, which delay/early variants were wrong.
+    qwen_sync_variants = {}
+    for r in load_jsonl(QWEN_SYNC):
+        v = r["video"]
+        base = base_of(v)
+        if v == base:
+            continue  # skip the synced original; we want intervention failures
+        if sync_is_wrong(r):
+            qwen_sync_variants.setdefault(base, []).append({
+                "variant": v,
+                "gt": (r.get("gt_direction"), r.get("gt_offset_sec")),
+                "pred_synced": r.get("pred_synced"),
+                "pred": (r.get("pred_direction"), r.get("pred_offset_sec")),
+            })
+    qwen_sync_intervention_wrong = set(qwen_sync_variants.keys())
+
+    # Intersection.
+    candidates = (
+        gemini_swap_wrong
+        & gemini_mute_wrong
+        & qwen_mute_wrong
+        & qwen_swap_wrong
+        & qwen_sync_intervention_wrong
+    )
+
+    print(f"Per-source wrong sets:")
+    print(f"  gemini swap (case_study)      : {len(gemini_swap_wrong)}")
+    print(f"  gemini mute (correct=false)   : {len(gemini_mute_wrong)}")
+    print(f"  qwen   mute (correct=false)   : {len(qwen_mute_wrong)}")
+    print(f"  qwen   swap (correct=false)   : {len(qwen_swap_wrong)}")
+    print(f"  qwen   sync (>=1 wrong inter.): {len(qwen_sync_intervention_wrong)}")
+    print(f"\nFull intersection (5/5): {len(candidates)} videos")
+    print("=" * 60)
+
+    # Pre-index swap rows so we can show what "swap audio" was used.
+    gemini_swap_rows = {r["video"]: r for r in load_jsonl(GEMINI_SWAP_CASE)}
+    qwen_swap_rows   = {r["video"]: r for r in load_jsonl(QWEN_SWAP)
+                        if not r.get("correct", True)}
+
+    out_path = Path("/home/ubuntu/case_study_candidates.jsonl")
+    records = []
+    for v in sorted(candidates):
+        gs = gemini_swap_rows.get(v, {})
+        qs = qwen_swap_rows.get(v, {})
+        rec = {
+            "video": v,
+            "gemini_swap_audio_from": gs.get("swapped_from"),
+            "qwen_swap_audio_from":   qs.get("swapped_from"),
+            "qwen_sync_failures":     qwen_sync_variants[v],
+        }
+        records.append(rec)
+        print(f"\nVIDEO: {v}")
+        print(f"  swap audio source (gemini view) : {rec['gemini_swap_audio_from']}")
+        print(f"  swap audio source (qwen   view) : {rec['qwen_swap_audio_from']}")
+        print(f"  qwen sync intervention failures :")
+        for hit in qwen_sync_variants[v]:
+            print(f"    - {hit['variant']}")
+            print(f"        gt={hit['gt']}  pred_synced={hit['pred_synced']}  pred={hit['pred']}")
+
+    with open(out_path, "w") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"\n[saved] {len(records)} candidates -> {out_path}")
+
+    # Diagnostic: if intersection is empty, show the largest reachable subset.
+    if not candidates:
+        print("\nNo full intersection. Pairwise overlap diagnostic:")
+        sets = {
+            "gemini_swap": gemini_swap_wrong,
+            "gemini_mute": gemini_mute_wrong,
+            "qwen_mute":   qwen_mute_wrong,
+            "qwen_swap":   qwen_swap_wrong,
+            "qwen_sync":   qwen_sync_intervention_wrong,
+        }
+        names = list(sets)
+        for i, a in enumerate(names):
+            for b in names[i+1:]:
+                print(f"  {a} & {b}: {len(sets[a] & sets[b])}")
+
+
+if __name__ == "__main__":
+    main()

probe_gpt55_audio.py

@@ -0,0 +1,70 @@
+"""Probe whether the target model accepts input_audio + image_url.
+
+Usage:
+  OPENAI_API_KEY=sk-... python3 /home/ubuntu/probe_gpt55_audio.py [model_name]
+"""
+import base64
+import os
+import struct
+import sys
+
+from openai import OpenAI
+
+model = sys.argv[1] if len(sys.argv) > 1 else "gpt-5.5"
+client = OpenAI()
+
+# Build a 0.1s silent 16k mono WAV in memory.
+sr, secs = 16000, 0.1
+n = int(sr * secs)
+header = b"RIFF" + struct.pack("<I", 36 + n*2) + b"WAVEfmt " + struct.pack(
+    "<IHHIIHH", 16, 1, 1, sr, sr*2, 2, 16) + b"data" + struct.pack("<I", n*2)
+wav_b64 = base64.b64encode(header + b"\x00" * (n*2)).decode()
+
+# Tiny 1x1 white PNG.
+png_b64 = ("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAj"
+           "CB0C8AAAAASUVORK5CYII=")
+
+print(f"Testing model: {model}")
+
+# Test 1: image only
+try:
+    r = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": [
+            {"type": "text", "text": "ok?"},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{png_b64}"}},
+        ]}],
+        max_completion_tokens=8,
+    )
+    print(f"  image_url: OK -> {r.choices[0].message.content!r}")
+except Exception as exc:
+    print(f"  image_url: FAIL  ({exc.__class__.__name__}: {str(exc)[:200]})")
+
+# Test 2: audio only
+try:
+    r = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": [
+            {"type": "text", "text": "What audio is this?"},
+            {"type": "input_audio", "input_audio": {"data": wav_b64, "format": "wav"}},
+        ]}],
+        max_completion_tokens=16,
+    )
+    print(f"  input_audio: OK -> {r.choices[0].message.content!r}")
+except Exception as exc:
+    print(f"  input_audio: FAIL  ({exc.__class__.__name__}: {str(exc)[:200]})")
+
+# Test 3: both
+try:
+    r = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": [
+            {"type": "text", "text": "describe"},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{png_b64}"}},
+            {"type": "input_audio", "input_audio": {"data": wav_b64, "format": "wav"}},
+        ]}],
+        max_completion_tokens=16,
+    )
+    print(f"  image+audio: OK -> {r.choices[0].message.content!r}")
+except Exception as exc:
+    print(f"  image+audio: FAIL  ({exc.__class__.__name__}: {str(exc)[:200]})")

probe_gpt55_one_sample.py

@@ -0,0 +1,30 @@
+"""Probe GPT-5.5 on a single real video frame batch — see if we get non-empty content.
+
+Usage: OPENAI_API_KEY=sk-... python3 /home/ubuntu/probe_gpt55_one_sample.py
+"""
+import os, sys
+sys.path.insert(0, "/home/ubuntu")
+from pathlib import Path
+from case_study_gpt55 import (
+    call_gpt_frames, extract_frames_b64, _client,
+    SYNC_PROMPT, ORIG_DIR,
+)
+
+if not os.environ.get("OPENAI_API_KEY"):
+    sys.exit("[error] need OPENAI_API_KEY")
+
+client = _client(os.environ["OPENAI_API_KEY"])
+sample = ORIG_DIR / "Anger Management - Fails of the Week (January 2019) _ FailArmy11.mp4"
+print(f"sample: {sample}  exists={sample.exists()}")
+
+frames = extract_frames_b64(sample, n_frames=8)
+print(f"extracted {len(frames)} frames")
+
+for budget, effort in [(4000, "minimal"), (2000, "low"), (8000, "minimal")]:
+    print(f"\n--- max_completion_tokens={budget}  reasoning_effort={effort} ---")
+    raw = call_gpt_frames(client, "gpt-5.5", SYNC_PROMPT, frames,
+                          max_tokens=budget, reasoning_effort=effort)
+    print(f"raw_output ({len(raw)} chars): {raw!r}")
+    if raw:
+        print("OK -- got content; you can re-run the full eval")
+        break

prune_broken_rows.py

@@ -0,0 +1,65 @@
+"""Prune broken rows (empty raw_output / judge_fail) from eval_results.jsonl
+files in-place so the next eval run will re-process them.
+
+A backup .bak is written next to each modified file.
+
+Usage:
+  python3 /home/ubuntu/prune_broken_rows.py <jsonl_or_dir> [more...]
+  python3 /home/ubuntu/prune_broken_rows.py /home/ubuntu/eval_results/sync/sync_xiaomi_mimo-v2.5_audioMuxed
+  python3 /home/ubuntu/prune_broken_rows.py /home/ubuntu/eval_results/{sync,swap,mute,swap_original,mute_original}/*xiaomi*
+"""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+
+def is_broken(row: dict) -> str:
+    raw = (row.get("raw_output") or "").strip()
+    if not raw:
+        return "empty_raw"
+    if row.get("parse_method") == "judge_fail":
+        return "judge_fail"
+    return ""
+
+
+def prune(jsonl: Path) -> None:
+    if jsonl.is_dir():
+        jsonl = jsonl / "eval_results.jsonl"
+    if not jsonl.exists():
+        print(f"[skip] {jsonl} does not exist")
+        return
+    rows = [json.loads(l) for l in open(jsonl) if l.strip()]
+    keep, drop = [], []
+    for r in rows:
+        why = is_broken(r)
+        (drop if why else keep).append((r, why))
+    if not drop:
+        print(f"[ok]   {jsonl.parent.name}: {len(rows)} rows, none broken")
+        return
+
+    bak = jsonl.with_suffix(".jsonl.bak")
+    if not bak.exists():
+        shutil.copy2(jsonl, bak)
+    with open(jsonl, "w") as f:
+        for r, _ in keep:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    by_reason = {}
+    for r, why in drop:
+        by_reason[why] = by_reason.get(why, 0) + 1
+    reasons = ", ".join(f"{k}={v}" for k, v in by_reason.items())
+    print(f"[pruned] {jsonl.parent.name}: kept {len(keep)} / dropped {len(drop)} ({reasons})  -> backup: {bak.name}")
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        print(__doc__)
+        sys.exit(1)
+    for a in args:
+        prune(Path(a).expanduser())
+
+
+if __name__ == "__main__":
+    main()

rejudge_mute_neutral.py

@@ -0,0 +1,209 @@
+"""Re-classify existing mute-neutral eval_results.jsonl with a 3-way GT-agnostic judge.
+
+The original mute-neutral judge had two bugs:
+  1. Its system prompt told GPT "audio has been replaced with silence", which
+     biased classifications on CONTROL files (where audio is actually real).
+  2. Visual-only responses (model never addressed the audio at all) got
+     non-deterministically labeled as 'synced' or 'muted' depending on the
+     judge's mood, polluting both hallucination and detection rates.
+
+This rejudge:
+  * Uses a GT-agnostic prompt: classify what the model CLAIMED about audio.
+  * Adds a third category 'visual_only' for responses that describe only
+    visuals and never mention sound (neither audio nor silence).
+  * Computes metrics with a separate visual_only_rate so they don't pollute
+    hallucination_rate or detection_rate.
+
+Usage:
+  OPENAI_API_KEY=sk-... python3 /home/ubuntu/rejudge_mute_neutral.py \\
+      /path/to/eval_results.jsonl [/path/to/another.jsonl ...]
+"""
+
+import json
+import sys
+from pathlib import Path
+
+NEW_MUTE_JUDGE_SYSTEM = (
+    "You read a model's free-form description of a short video. Classify "
+    "what the model claimed about the AUDIO of the video. "
+    "\n\nReturn STRICT JSON only:"
+    "\n  prediction: 'muted' | 'audio_described' | 'visual_only'"
+    "\n  explanation: one short sentence"
+    "\n\nRules:"
+    "\n- 'muted': the model EXPLICITLY claims silence — phrases like 'no audio', "
+    "  'no audible sound', 'video is silent', 'no speech, music, or sounds', etc."
+    "\n- 'audio_described': the model describes any specific audible content — "
+    "  speech with quoted dialogue, music, sound effects, impact thuds, laughter, "
+    "  ambient noise, environmental sound, etc. Even one sound counts."
+    "\n- 'visual_only': the model only describes visual content and does NOT "
+    "  address the audio at all (neither claims silence nor describes any sound). "
+    "  Pure scene/action descriptions go here."
+    "\n\nBe objective: do NOT assume any prior about whether the audio is "
+    "actually silent or real — base the call only on what the model said."
+)
+
+
+def call_judge(client, judge_model, raw):
+    try:
+        resp = client.chat.completions.create(
+            model=judge_model,
+            messages=[
+                {"role": "system", "content": NEW_MUTE_JUDGE_SYSTEM},
+                {"role": "user", "content": raw},
+            ],
+            response_format={"type": "json_object"},
+            max_completion_tokens=300,
+        )
+        obj = json.loads(resp.choices[0].message.content or "")
+        pred = str(obj.get("prediction", "visual_only")).lower().strip()
+        if pred not in ("muted", "audio_described", "visual_only"):
+            pred = "visual_only"
+        return {
+            "pred_label": pred,
+            "judge_explanation": str(obj.get("explanation", "")),
+            "parse_method": "openai_judge_3way",
+        }
+    except Exception as exc:
+        return {
+            "pred_label": "visual_only",
+            "judge_explanation": f"judge_error: {exc}",
+            "parse_method": "judge_error",
+        }
+
+
+def write_metrics(rows, out_path: Path, gt_label: str):
+    """Compute metrics per dataset GT.
+
+      intervention (gt=muted):     correct iff pred=='muted'
+        - mute_detection_rate = muted / n
+        - hallucination_rate  = audio_described / n     (real hallucination)
+        - visual_only_rate    = visual_only / n         (model dodged audio)
+      control (gt=synced):         correct iff pred=='audio_described'
+        - audio_present_detection_rate = audio_described / n
+        - false_silent_rate            = muted / n
+        - visual_only_rate             = visual_only / n
+    """
+    breakdown = {"muted": 0, "audio_described": 0, "visual_only": 0}
+    parse_stats = {}
+    for r in rows:
+        breakdown[r["pred_label"]] = breakdown.get(r["pred_label"], 0) + 1
+        pm = r.get("parse_method", "")
+        parse_stats[pm] = parse_stats.get(pm, 0) + 1
+    n = len(rows)
+
+    if gt_label == "muted":
+        correct_pred = "muted"
+        task_kind = "mute_intervention"
+    else:  # 'synced'
+        correct_pred = "audio_described"
+        task_kind = "mute_control"
+
+    correct = breakdown[correct_pred]
+
+    metrics = {
+        "total_samples": n,
+        "gt_label": gt_label,
+        "task_kind": task_kind,
+        "accuracy": round(correct / n, 4) if n else 0.0,
+        "prediction_breakdown": breakdown,
+        "visual_only_rate": round(breakdown["visual_only"] / n, 4) if n else 0.0,
+        "parse_stats": parse_stats,
+        "judge": "openai_judge_3way",
+    }
+    if gt_label == "muted":
+        metrics["mute_detection_rate"] = round(breakdown["muted"] / n, 4) if n else 0.0
+        metrics["hallucination_rate"]  = round(breakdown["audio_described"] / n, 4) if n else 0.0
+    else:
+        metrics["audio_present_detection_rate"] = round(breakdown["audio_described"] / n, 4) if n else 0.0
+        metrics["false_silent_rate"]            = round(breakdown["muted"] / n, 4) if n else 0.0
+    with open(out_path, "w") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+
+
+def _normalize_gt_label(rows):
+    """Each dataset has exactly one GT.  Pick from first row, normalize.
+
+    Existing files use gt_label='muted' for intervention and 'synced' for
+    control. We keep that convention for downstream compatibility.
+    """
+    gt = (rows[0].get("gt_label") or "").lower()
+    if gt in ("muted", "mute"):
+        return "muted"
+    if gt in ("synced", "sync", "audio_present", "matched"):
+        return "synced"
+    return "muted"  # default: assume intervention
+
+
+def main():
+    import argparse, os
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    p = argparse.ArgumentParser()
+    p.add_argument("paths", nargs="+", help="eval_results.jsonl files to re-judge")
+    p.add_argument("--openai-key", default=os.environ.get("OPENAI_API_KEY"))
+    p.add_argument("--judge-model", default="gpt-5.4")
+    p.add_argument("--workers", type=int, default=8)
+    args = p.parse_args()
+
+    if not args.openai_key:
+        sys.exit("[error] need --openai-key or OPENAI_API_KEY")
+
+    from openai import OpenAI
+    client = OpenAI(api_key=args.openai_key)
+
+    print("[preflight] testing judge API ...", flush=True)
+    probe = call_judge(client, args.judge_model, "I hear a loud thud and laughter.")
+    if probe["parse_method"] == "judge_error":
+        sys.exit(f"[error] judge API broken; aborting. detail: {probe['judge_explanation']}")
+    print(f"[preflight] OK (model={args.judge_model})", flush=True)
+
+    for path in args.paths:
+        path = Path(path)
+        rows_in = [json.loads(l) for l in open(path) if l.strip()]
+        if not rows_in:
+            print(f"[{path}] empty, skipping")
+            continue
+        gt_label = _normalize_gt_label(rows_in)
+        correct_pred = "muted" if gt_label == "muted" else "audio_described"
+        print(f"\n[{path}] re-judging {len(rows_in)} rows (gt_label={gt_label})")
+
+        def _go(r):
+            judge = call_judge(client, args.judge_model, r.get("raw_output", "") or "")
+            new = dict(r)
+            new["orig_pred_label"]        = r.get("pred_label")
+            new["orig_judge_explanation"] = r.get("judge_explanation")
+            new["pred_label"]             = judge["pred_label"]
+            new["judge_explanation"]      = judge["judge_explanation"]
+            new["parse_method"]           = judge["parse_method"]
+            new["correct"]                = (judge["pred_label"] == correct_pred)
+            return new
+
+        results = []
+        with ThreadPoolExecutor(max_workers=args.workers) as ex:
+            futures = {ex.submit(_go, r): r for r in rows_in}
+            for i, fut in enumerate(as_completed(futures), 1):
+                results.append(fut.result())
+                if i % 20 == 0 or i == len(rows_in):
+                    print(f"  {i}/{len(rows_in)}", flush=True)
+
+        out_jsonl   = path.with_name(path.stem.replace("eval_results", "eval_results.rejudged") + path.suffix)
+        out_metrics = path.parent / "metrics.rejudged.json"
+        with open(out_jsonl, "w") as f:
+            for r in results:
+                f.write(json.dumps(r, ensure_ascii=False) + "\n")
+        write_metrics(results, out_metrics, gt_label)
+
+        flips = sum(1 for r in results if r["pred_label"] != r["orig_pred_label"])
+        old_correct = sum(1 for r in results
+                          if r["orig_pred_label"] == correct_pred
+                          or (correct_pred == "audio_described" and r["orig_pred_label"] == "synced"))
+        new_correct = sum(1 for r in results if r["pred_label"] == correct_pred)
+        new_visual  = sum(1 for r in results if r["pred_label"] == "visual_only")
+        print(f"[{path.name}] flipped {flips}/{len(results)}; "
+              f"correct (gt={gt_label}): {old_correct} -> {new_correct}; "
+              f"visual_only: {new_visual}")
+        print(f"  saved -> {out_jsonl}")
+        print(f"  saved -> {out_metrics}")
+
+
+if __name__ == "__main__":
+    main()

rejudge_swap_neutral.py

@@ -0,0 +1,191 @@
+"""Re-classify existing swap-neutral eval_results.jsonl with a SMARTER judge.
+
+The original judge only marked 'mismatched' when the model EXPLICITLY said the
+audio doesn't match. Neutral describe-prompts rarely do that — the model just
+describes what it sees and what it hears, leaving incongruity implicit.
+
+This re-judge does plausibility checking on the (visual, audio) description
+pair:  given the visual scene, would the described audio reasonably occur?
+
+Usage:
+  OPENAI_API_KEY=sk-... python3 /home/ubuntu/rejudge_swap_neutral.py \\
+      /path/to/eval_results.jsonl [/path/to/another.jsonl ...]
+
+For each input file, writes alongside:
+  - eval_results.rejudged.jsonl   (with new pred_label / judge_explanation /
+                                    parse_method, plus the originals preserved
+                                    as orig_pred_label / orig_judge_explanation)
+  - metrics.rejudged.json
+"""
+
+import json
+import sys
+from pathlib import Path
+
+NEW_SWAP_JUDGE_SYSTEM = (
+    "You read a model's free-form description of a short video — both the "
+    "visual content and the audio content. Your task is to determine, from "
+    "the model's own description, whether the described audio is plausibly "
+    "the natural soundtrack of the described visuals (regardless of whether "
+    "the model itself raises any concern). "
+    "\n\nReturn STRICT JSON only with keys:"
+    "\n  prediction: 'mismatched' | 'synced'"
+    "\n  explanation: one short sentence"
+    "\n\nClassification rules:"
+    "\n- 'mismatched' if the audio described would NOT plausibly arise from "
+    "the visual scene described. Treat it as mismatched even when the model "
+    "doesn't explicitly say so. Examples:"
+    "\n   * visual=person flipping a wooden plank, audio=power-tool whirring → mismatched"
+    "\n   * visual=baseball field outdoor, audio=woman laughing in a quiet room → mismatched"
+    "\n   * visual=ocean waves, audio=engine revving + a clear phone-call dialogue → mismatched"
+    "\n   * audio described as 'voiceover', 'dubbed', 'unrelated', 'sped-up cartoon voice' → mismatched"
+    "\n- 'synced' if the audio described is plausibly the natural soundtrack "
+    "of the visuals (impact thuds, crowd reactions, ambient noise that fits, "
+    "speech consistent with what's happening on screen)."
+    "\n- If the model only describes visuals and gives essentially NO audio "
+    "description, default to 'synced'."
+    "\n- If you genuinely cannot tell, default to 'synced'."
+    "\n- Be objective: do NOT assume any prior about whether the audio is "
+    "real or swapped — base the call only on whether the descriptions fit "
+    "each other."
+)
+
+
+def call_judge(client, judge_model, raw):
+    try:
+        resp = client.chat.completions.create(
+            model=judge_model,
+            messages=[
+                {"role": "system", "content": NEW_SWAP_JUDGE_SYSTEM},
+                {"role": "user", "content": raw},
+            ],
+            response_format={"type": "json_object"},
+            max_completion_tokens=300,
+        )
+        obj = json.loads(resp.choices[0].message.content or "")
+        pred = str(obj.get("prediction", "synced")).lower().strip()
+        if pred not in ("mismatched", "synced"):
+            pred = "synced"
+        return {
+            "pred_label": pred,
+            "judge_explanation": str(obj.get("explanation", "")),
+            "parse_method": "openai_judge_plausibility",
+        }
+    except Exception as exc:
+        return {
+            "pred_label": "synced",
+            "judge_explanation": f"judge_error: {exc}",
+            "parse_method": "judge_error",
+        }
+
+
+def write_metrics(rows, out_path: Path, gt_label: str):
+    """Pick metric semantics based on the dataset's GT.
+
+      intervention (gt=mismatched): we want the model to say 'mismatched'.
+        - mismatch_detection_rate = correct / n
+        - hallucination_rate      = (model said 'synced') / n
+      control (gt=synced):         we want the model to say 'synced'.
+        - match_detection_rate    = correct / n
+        - false_mismatch_rate     = (model said 'mismatched') / n
+    """
+    breakdown = {"mismatched": 0, "synced": 0, "delay": 0, "early": 0}
+    parse_stats = {}
+    correct = 0
+    for r in rows:
+        breakdown[r["pred_label"]] = breakdown.get(r["pred_label"], 0) + 1
+        pm = r.get("parse_method", "")
+        parse_stats[pm] = parse_stats.get(pm, 0) + 1
+        if r["pred_label"] == gt_label:
+            correct += 1
+    n = len(rows)
+    metrics = {
+        "total_samples": n,
+        "gt_label": gt_label,
+        "accuracy": round(correct / n, 4) if n else 0.0,
+        "prediction_breakdown": breakdown,
+        "parse_stats": parse_stats,
+        "judge": "openai_judge_plausibility",
+    }
+    if gt_label == "mismatched":
+        metrics["mismatch_detection_rate"] = round(breakdown["mismatched"] / n, 4) if n else 0.0
+        metrics["hallucination_rate"]      = round(breakdown["synced"] / n, 4) if n else 0.0
+        metrics["task_kind"] = "swap_intervention"
+    elif gt_label == "synced":
+        metrics["match_detection_rate"] = round(breakdown["synced"] / n, 4) if n else 0.0
+        metrics["false_mismatch_rate"]  = round(breakdown["mismatched"] / n, 4) if n else 0.0
+        metrics["task_kind"] = "swap_control"
+    with open(out_path, "w") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+
+
+def main():
+    import argparse, os
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    p = argparse.ArgumentParser()
+    p.add_argument("paths", nargs="+", help="eval_results.jsonl files to re-judge")
+    p.add_argument("--openai-key", default=os.environ.get("OPENAI_API_KEY"))
+    p.add_argument("--judge-model", default="gpt-5.4")
+    p.add_argument("--workers", type=int, default=8)
+    args = p.parse_args()
+
+    if not args.openai_key:
+        sys.exit("[error] need --openai-key or OPENAI_API_KEY")
+
+    from openai import OpenAI
+    client = OpenAI(api_key=args.openai_key)
+
+    # Fail-fast preflight: a single judge call to surface auth/quota errors
+    # before we write garbage metrics across many files.
+    print("[preflight] testing judge API ...", flush=True)
+    probe = call_judge(client, args.judge_model, "video shows a dog. audio is silent.")
+    if probe["parse_method"] == "judge_error":
+        sys.exit(f"[error] judge API broken; aborting. detail: {probe['judge_explanation']}")
+    print(f"[preflight] OK (model={args.judge_model})", flush=True)
+
+    for path in args.paths:
+        path = Path(path)
+        rows_in = [json.loads(l) for l in open(path) if l.strip()]
+        if not rows_in:
+            print(f"[{path}] empty, skipping")
+            continue
+        gt_label = rows_in[0].get("gt_label") or "mismatched"
+        print(f"\n[{path}] re-judging {len(rows_in)} rows (gt_label={gt_label})")
+
+        def _go(r):
+            judge = call_judge(client, args.judge_model, r.get("raw_output", "") or "")
+            new = dict(r)
+            new["orig_pred_label"]        = r.get("pred_label")
+            new["orig_judge_explanation"] = r.get("judge_explanation")
+            new["pred_label"]             = judge["pred_label"]
+            new["judge_explanation"]      = judge["judge_explanation"]
+            new["parse_method"]           = judge["parse_method"]
+            new["correct"]                = (judge["pred_label"] == gt_label)
+            return new
+
+        results = []
+        with ThreadPoolExecutor(max_workers=args.workers) as ex:
+            futures = {ex.submit(_go, r): r for r in rows_in}
+            for i, fut in enumerate(as_completed(futures), 1):
+                results.append(fut.result())
+                if i % 20 == 0 or i == len(rows_in):
+                    print(f"  {i}/{len(rows_in)}", flush=True)
+
+        out_jsonl   = path.with_name(path.stem.replace("eval_results", "eval_results.rejudged") + path.suffix)
+        out_metrics = path.parent / "metrics.rejudged.json"
+        with open(out_jsonl, "w") as f:
+            for r in results:
+                f.write(json.dumps(r, ensure_ascii=False) + "\n")
+        write_metrics(results, out_metrics, gt_label)
+
+        flips = sum(1 for r in results if r["pred_label"] != r["orig_pred_label"])
+        old_correct = sum(1 for r in results if r["orig_pred_label"] == gt_label)
+        new_correct = sum(1 for r in results if r["pred_label"]      == gt_label)
+        print(f"[{path.name}] flipped {flips}/{len(results)} predictions; "
+              f"correct (gt={gt_label}): {old_correct} -> {new_correct}")
+        print(f"  saved -> {out_jsonl}")
+        print(f"  saved -> {out_metrics}")
+
+
+if __name__ == "__main__":
+    main()

supp/eval_daily_omni.py

@@ -0,0 +1,586 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ctypes
+import gc
+import json
+import os
+import re
+import site
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib"
+_npp_so = _npp_lib / "libnppicc.so.12"
+if _npp_so.is_file():
+    ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL)
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_DATA_DIR = Path("./data/daily_omni")
+DEFAULT_OUTPUT_DIR = Path("./eval_results/daily_omni")
+
+QUESTION_TYPES = [
+    "AV Event Alignment", "Event Sequence", "Inference",
+    "Reasoning", "Comparative", "Context understanding",
+]
+CONTENT_PARENT_CATEGORIES = [
+    "Lifestyle", "Hobbies & Interests", "Education", "Entertainment",
+    "Sports", "Science & Technology", "Art & Creativity", "News & Politics",
+    "Automotive",
+]
+VIDEO_CATEGORIES = [
+    "Howto & Style", "Entertainment", "Education", "Science & Technology",
+    "People & Blogs", "News & Politics", "Sports", "Music",
+    "Film & Animation", "Gaming", "Comedy", "Autos & Vehicles",
+    "Nonprofits & Activism",
+]
+
+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 Daily-Omni 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("--data-dir", type=Path, default=DEFAULT_DATA_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)
+    p.add_argument("--tp", type=int, default=None)
+    p.add_argument("--batch-size", type=int, default=32)
+    p.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    p.add_argument("--max-model-len", type=int, default=65536)
+    return p.parse_args()
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    from omni_model_loading import load_qwen_omni_model
+
+    model, processor, _ = load_qwen_omni_model(base_model, adapter)
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, prompt: str,
+                  max_new_tokens: int, temperature: float) -> str:
+    from qwen_omni_utils import process_mm_info
+
+    tmp_dir = tempfile.mkdtemp(prefix="eval_do_")
+    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=True)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=True,
+    )
+
+    model_dtype = next(model.parameters()).dtype
+    converted = {}
+    for k, v in inputs.items():
+        if hasattr(v, "to"):
+            v = v.to(model.device)
+            if torch.is_floating_point(v):
+                v = v.to(model_dtype)
+        converted[k] = v
+    inputs = converted
+
+    from omni_model_loading import is_omni_thinker_model
+
+    is_thinker = is_omni_thinker_model(model)
+    if is_thinker:
+        gen_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": temperature > 0}
+    else:
+        gen_kwargs = {
+            "thinker_max_new_tokens": max_new_tokens,
+            "use_audio_in_video": True,
+            "return_audio": False,
+            "do_sample": temperature > 0,
+        }
+    if temperature > 0:
+        gen_kwargs["temperature"] = temperature
+        gen_kwargs["top_p"] = 0.9
+
+    with torch.inference_mode():
+        output_ids = model.generate(**inputs, **gen_kwargs)
+
+    if isinstance(output_ids, tuple):
+        output_ids = output_ids[0]
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+    return response
+
+
+def preprocess_video_for_vllm(video_path: str):
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "fps": 2.0, "max_frames": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=True)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    audio_tuple = None
+    if audios:
+        aud = audios[0]
+        if isinstance(aud, tuple):
+            audio_tuple = (aud[0].numpy() if hasattr(aud[0], "numpy") else np.asarray(aud[0]),
+                           aud[1])
+        elif hasattr(aud, "numpy"):
+            audio_tuple = (aud.numpy(), 16000)
+        else:
+            audio_tuple = (np.asarray(aud), 16000)
+    return video_np, audio_tuple
+
+
+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, base_model: str) -> str:
+    from omni_model_loading import vllm_user_mm_prefix
+
+    mm = vllm_user_mm_prefix(base_model, include_audio=True)
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"{mm}"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    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 ""
+
+
+def load_daily_omni(data_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    qa_path = data_dir / "qa.json"
+    videos_dir = data_dir / "Videos"
+
+    with open(qa_path) as f:
+        qa_data = json.load(f)
+
+    data = []
+    skipped = 0
+    for idx, row in enumerate(qa_data):
+        vid = row["video_id"]
+        video_path = videos_dir / vid / f"{vid}_video.mp4"
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        choices = row["Choice"]
+        options_text = "\n".join(choices)
+        prompt = MCQ_PROMPT + row["Question"] + "\n" + options_text + "\nThe best answer is:"
+
+        data.append({
+            "question_id": f"do_{idx}",
+            "video_id": vid,
+            "video_path": str(video_path),
+            "question_type": row.get("Type", ""),
+            "content_parent_category": row.get("content_parent_category", ""),
+            "content_fine_category": row.get("content_fine_category", ""),
+            "video_category": row.get("video_category", ""),
+            "video_duration": row.get("video_duration", ""),
+            "question": row["Question"],
+            "choices": choices,
+            "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
+
+
+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 qt in QUESTION_TYPES:
+        subset = [r for r in results if r.get("question_type") == qt]
+        if subset:
+            per_type[qt] = {"accuracy": acc_for(subset), "count": len(subset)}
+    remaining = [r for r in results if r.get("question_type") not in QUESTION_TYPES]
+    if remaining:
+        other_types = set(r.get("question_type", "") for r in remaining)
+        for ot in sorted(other_types):
+            subset = [r for r in remaining if r.get("question_type") == ot]
+            if subset:
+                per_type[ot] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_content_cat = {}
+    for cat in CONTENT_PARENT_CATEGORIES:
+        subset = [r for r in results if r.get("content_parent_category") == cat]
+        if subset:
+            per_content_cat[cat] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_video_cat = {}
+    for vc in VIDEO_CATEGORIES:
+        subset = [r for r in results if r.get("video_category") == vc]
+        if subset:
+            per_video_cat[vc] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_duration = {}
+    for dur in sorted(set(r.get("video_duration", "") for r in results)):
+        if not dur:
+            continue
+        subset = [r for r in results if r.get("video_duration") == dur]
+        if subset:
+            per_duration[dur] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    return {
+        "total_samples": total,
+        "overall_accuracy": round(overall_acc, 4),
+        "per_question_type": per_type,
+        "per_content_category": per_content_cat,
+        "per_video_category": per_video_cat,
+        "per_duration": per_duration,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  Daily-Omni Summary: {label}")
+    print(f"{'=' * 65}")
+    print(f"  Total samples:         {metrics['total_samples']}")
+    print(f"  Overall Accuracy:      {metrics['overall_accuracy']:.1%}")
+
+    print(f"  ─── Per Question Type ───")
+    for qt, d in metrics.get("per_question_type", {}).items():
+        print(f"    {qt:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Content Category ───")
+    for cat, d in metrics.get("per_content_category", {}).items():
+        print(f"    {cat:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Video Category ───")
+    for vc, d in metrics.get("per_video_category", {}).items():
+        print(f"    {vc:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    if metrics.get("per_duration"):
+        print(f"  ─── Per Duration ───")
+        for dur, d in metrics["per_duration"].items():
+            print(f"    {dur:10s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+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 Daily-Omni dataset...")
+    test_data = load_daily_omni(args.data_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("[vllm] Preprocessing videos (before model load) ...")
+        todo = [item for item in test_data if item["question_id"] not in processed]
+        unique_videos = list(dict.fromkeys(item["video_path"] for item in todo))
+        from omni_model_loading import parallel_preprocess_videos
+        preprocessed, preprocessed_audio, preprocess_failed_paths = parallel_preprocess_videos(
+            unique_videos, preprocess_video_for_vllm,
+        )
+
+        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."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        from omni_model_loading import cap_vllm_max_model_len
+
+        vllm_max_len = cap_vllm_max_model_len(model_path, args.max_model_len)
+        print(f"[vllm] Loading {model_path} with tp={tp} (max_model_len={vllm_max_len}) ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=vllm_max_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 1, "audio": 1},
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            dtype="bfloat16",
+            trust_remote_code=True,
+        )
+        sampling_params = SamplingParams(
+            temperature=args.temperature if args.temperature > 0 else 0.0,
+            top_p=0.9 if args.temperature > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        vllm_todo = [item for item in todo if item["video_path"] 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"], args.base_model),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            if item["video_path"] in preprocessed_audio:
+                inp["multi_modal_data"]["audio"] = preprocessed_audio[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"],
+                    "question_type": item["question_type"],
+                    "content_parent_category": item["content_parent_category"],
+                    "content_fine_category": item["content_fine_category"],
+                    "video_category": item["video_category"],
+                    "video_duration": item["video_duration"],
+                    "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()
+        preprocessed_audio.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"],
+                    "question_type": item["question_type"],
+                    "content_parent_category": item["content_parent_category"],
+                    "content_fine_category": item["content_fine_category"],
+                    "video_category": item["video_category"],
+                    "video_duration": item["video_duration"],
+                    "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="Daily-Omni", 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"],
+                "question_type": item["question_type"],
+                "content_parent_category": item["content_parent_category"],
+                "content_fine_category": item["content_fine_category"],
+                "video_category": item["video_category"],
+                "video_duration": item["video_duration"],
+                "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,
+        "data_dir": str(args.data_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()

supp/eval_dpo_sync.py

@@ -0,0 +1,826 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ctypes
+import gc
+import json
+import os
+import re
+import site
+import time
+from pathlib import Path
+from statistics import mean, median
+from typing import Any, Dict, List, Optional, Tuple
+
+_npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib"
+_npp_so = _npp_lib / "libnppicc.so.12"
+if _npp_so.is_file():
+    ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL)
+
+import torch
+from tqdm import tqdm
+
+_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]]:
+    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("./data/video_source")
+ORIGINAL_ROOT = DATA_ROOT / "original"
+AUDIO_ROOT = DATA_ROOT / "extracted_audio" / "original"
+
+
+def set_data_root(root: Path) -> None:
+    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 sync model on test set.")
+    p.add_argument("--base-model", type=str, required=True)
+    p.add_argument("--adapter", type=str, default=None)
+    p.add_argument(
+        "--data-root",
+        type=Path,
+        default=Path("./data/video_source"),
+    )
+    p.add_argument(
+        "--test-jsonl",
+        type=Path,
+        default=None,
+    )
+    p.add_argument(
+        "--output-dir",
+        type=Path,
+        default=None,
+    )
+    p.add_argument("--max-samples", type=int, default=-1)
+    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)
+    p.add_argument("--gpt-judge", action="store_true", default=False)
+    p.add_argument("--openai-api-key", type=str, default=None)
+    p.add_argument("--gpt-model", type=str, default="gpt-5.4")
+    p.add_argument("--vllm", action="store_true", default=False)
+    p.add_argument("--tp", type=int, default=None)
+    p.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    p.add_argument("--max-model-len", type=int, default=65536)
+    return p.parse_args()
+
+
+def parse_ground_truth(video_field: str) -> Dict[str, Any]:
+    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]]:
+    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]:
+    text = text.strip()
+
+    for pattern in [
+        re.compile(r"```(?:json)?\s*(\{.*?\})\s*```", re.DOTALL),
+        re.compile(r"(\{[^{}]*\"synced\"[^{}]*\})", re.DOTALL),
+        re.compile(r"(\{.*?\})", re.DOTALL),
+    ]:
+        m = pattern.search(text)
+        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
+
+    text_lower = text.lower()
+    synced = None
+    direction = "none"
+    offset = 0.0
+
+    pred_t_v, pred_t_a = extract_timestamps(text)
+
+    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:
+        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"
+
+        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)
+
+        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]):
+    from multi_omni_adapter import get_adapter
+
+    omni = get_adapter(base_model, adapter)
+    omni.load()
+    return omni
+
+
+def run_inference(omni, video_path: str, audio_path: str,
+                  max_new_tokens: int, temperature: float) -> str:
+    return omni.infer(video_path, audio_path, EVAL_PROMPT, max_new_tokens, temperature)
+
+
+SYSTEM_PROMPT = (
+    "You are Qwen, a virtual human developed by the Qwen Team, Alibaba "
+    "Group, capable of perceiving auditory and visual inputs, as well as "
+    "generating text and speech."
+)
+
+
+def preprocess_video_for_vllm(video_path: str):
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "fps": 2.0, "max_frames": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=True)
+    video_tensor = videos[0]
+    return (video_tensor * 255).byte().numpy()
+
+
+def preprocess_audio_for_vllm(audio_path: str, target_sr: int = 16000):
+    import numpy as np
+    import wave
+
+    with wave.open(audio_path, "rb") as w:
+        sr = w.getframerate()
+        n = w.getnframes()
+        raw = w.readframes(n)
+    x = np.frombuffer(raw, dtype=np.int16).astype(np.float32) / 32768.0
+    if sr != target_sr:
+        duration = len(x) / sr
+        new_len = int(duration * target_sr)
+        x = np.interp(
+            np.linspace(0, len(x) - 1, new_len),
+            np.arange(len(x)),
+            x,
+        )
+    return x, target_sr
+
+
+def build_vllm_prompt(question: str, base_model: str) -> str:
+    from omni_model_loading import vllm_user_mm_prefix
+
+    mm = vllm_user_mm_prefix(base_model, include_audio=True)
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"{mm}"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def compute_metrics(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = len(results)
+    if total == 0:
+        return {}
+
+    sync_correct = sum(1 for r in results if r["pred_synced"] == r["gt_synced"])
+    sync_acc = sync_correct / total
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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")
+
+    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 / "test.jsonl")
+    output_dir = args.output_dir or Path("./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"
+
+    test_data = load_test_data(test_jsonl, args.max_samples)
+    print(f"[data] Loaded {len(test_data)} test samples")
+
+    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")
+
+    def _do_extract(raw_output: str) -> Dict[str, Any]:
+        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:
+                return gpt_pred
+        return extract_prediction(raw_output)
+
+    def _build_result(item: Dict, pred: Dict, raw_output: str) -> Dict:
+        return {
+            "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.get("pred_explanation", ""),
+            "parse_method": pred["parse_method"],
+            "raw_output": raw_output,
+        }
+
+    use_vllm = args.vllm
+
+    if use_vllm:
+        from vllm import LLM, SamplingParams
+
+        tp = args.tp or torch.cuda.device_count()
+        todo = [item for item in test_data if item["video"] not in processed]
+
+        print(f"[vllm] Preprocessing {len(todo)} samples (video + audio) ...")
+        preprocessed_v: Dict[str, Any] = {}
+        preprocessed_a: Dict[str, Any] = {}
+        failed_paths: set = set()
+
+        unique_videos = list(dict.fromkeys(item["video_path"] for item in todo))
+        unique_audios = list(dict.fromkeys(item["audio_path"] for item in todo))
+
+        for vp in tqdm(unique_videos, desc="Preprocess video", unit="video"):
+            if vp in failed_paths:
+                continue
+            try:
+                preprocessed_v[vp] = preprocess_video_for_vllm(vp)
+            except Exception as e:
+                failed_paths.add(vp)
+                print(f"  [skip] video preprocess error: {Path(vp).name}: {e}")
+
+        for ap in tqdm(unique_audios, desc="Preprocess audio", unit="audio"):
+            if ap in failed_paths:
+                continue
+            try:
+                preprocessed_a[ap] = preprocess_audio_for_vllm(ap)
+            except Exception as e:
+                failed_paths.add(ap)
+                print(f"  [skip] audio preprocess error: {Path(ap).name}: {e}")
+
+        n_skip = sum(1 for item in todo
+                     if item["video_path"] in failed_paths or item["audio_path"] in failed_paths)
+        if failed_paths:
+            print(f"[vllm] Preprocess failed for {len(failed_paths)} path(s), "
+                  f"{n_skip} sample(s) will be skipped.")
+
+        from omni_model_loading import cap_vllm_max_model_len
+
+        vllm_max_len = cap_vllm_max_model_len(args.base_model, args.max_model_len)
+        print(f"[vllm] Loading {args.base_model} with tp={tp} (max_model_len={vllm_max_len}) ...")
+        llm = LLM(
+            model=args.base_model,
+            tensor_parallel_size=tp,
+            max_model_len=vllm_max_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 1, "audio": 1},
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            dtype="bfloat16",
+            trust_remote_code=True,
+        )
+        sampling_params = SamplingParams(
+            temperature=args.temperature if args.temperature > 0 else 0.0,
+            top_p=0.9 if args.temperature > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        vllm_todo = [item for item in todo
+                     if item["video_path"] not in failed_paths
+                     and item["audio_path"] not in failed_paths]
+        fallback_items = [item for item in todo
+                          if item["video_path"] in failed_paths
+                          or item["audio_path"] in failed_paths]
+        print(f"[vllm] {len(vllm_todo)} samples ready, {len(fallback_items)} deferred to transformers ...")
+
+        for i, item in enumerate(vllm_todo):
+            if item["video"] in processed:
+                continue
+            inp = {
+                "prompt": build_vllm_prompt(EVAL_PROMPT, args.base_model),
+                "multi_modal_data": {
+                    "video": preprocessed_v[item["video_path"]],
+                    "audio": preprocessed_a[item["audio_path"]],
+                },
+            }
+            try:
+                outputs = llm.generate([inp], sampling_params=sampling_params)
+                raw_output = outputs[0].outputs[0].text.strip()
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" in str(exc):
+                    print(f"  [too long] {item['video']} -> fallback")
+                    fallback_items.append(item)
+                    continue
+                else:
+                    print(f"  [error] {item['video']}: {exc}")
+                    raw_output = ""
+
+            pred = _do_extract(raw_output)
+            result = _build_result(item, pred, 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"])
+
+            if (i + 1) % 100 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] done, {len(fallback_items)} deferred")
+
+        preprocessed_v.clear()
+        preprocessed_a.clear()
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} samples with transformers ...")
+            del llm
+            gc.collect()
+            torch.cuda.empty_cache()
+
+            omni = load_model(args.base_model, args.adapter)
+            for item in tqdm(fallback_items, desc="Fallback", unit="q"):
+                if item["video"] in processed:
+                    continue
+                try:
+                    raw_output = run_inference(
+                        omni, 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 = ""
+
+                pred = _do_extract(raw_output)
+                result = _build_result(item, pred, 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()
+
+    else:
+        todo = [it for it in test_data if it["video"] not in processed]
+        if not todo:
+            print(f"[resume] all {len(test_data)} samples already done — skipping model load")
+            omni = None
+        else:
+            omni = load_model(args.base_model, args.adapter)
+
+        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(
+                    omni, 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()
+                continue
+            if not raw_output:
+                print(f"  [skip] empty output for {item['video']}; will retry next run")
+                continue
+
+            pred = _do_extract(raw_output)
+            result = _build_result(item, pred, 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()
+
+    all_results = []
+    if results_jsonl.exists():
+        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,
+        "vllm": args.vllm,
+    }
+
+    with open(metrics_json, "w", encoding="utf-8") as f:
+        json.dump(metrics, f, indent=2, ensure_ascii=False)
+
+    print_summary(metrics, label)
+
+    with open(summary_txt, "w", encoding="utf-8") as f:
+        import io, contextlib
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            print_summary(metrics, label)
+        f.write(buf.getvalue())
+
+    print(f"\n[output] Results JSONL: {results_jsonl}")
+    print(f"[output] Metrics JSON:  {metrics_json}")
+    print(f"[output] Summary:       {summary_txt}")
+
+
+if __name__ == "__main__":
+    main()

supp/eval_lvbench.py

@@ -0,0 +1,632 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ctypes
+import gc
+import json
+import os
+import re
+import site
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib"
+_npp_so = _npp_lib / "libnppicc.so.12"
+if _npp_so.is_file():
+    ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL)
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("./data/lvbench")
+DEFAULT_OUTPUT_DIR = Path("./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)
+    p.add_argument("--tp", type=int, default=None)
+    p.add_argument("--batch-size", type=int, default=16)
+    p.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    p.add_argument("--max-model-len", type=int, default=65536)
+    p.add_argument("--max-num-seqs", type=int, default=4)
+    p.add_argument("--vllm-batch-size", type=int, default=1)
+    p.add_argument("--enforce-eager", action="store_true", default=False)
+    p.add_argument("--shard", type=int, default=0)
+    p.add_argument("--num-shards", type=int, default=1)
+    p.add_argument("--merge-only", action="store_true", default=False)
+    return p.parse_args()
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    from omni_model_loading import load_qwen_omni_model
+
+    model, processor, _ = load_qwen_omni_model(base_model, adapter)
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, prompt: str,
+                  max_new_tokens: int, temperature: float,
+                  cached_mm: Optional[Dict[str, Any]] = None) -> 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,
+    )
+    if cached_mm is not None:
+        audios, images, videos = cached_mm["audios"], cached_mm["images"], cached_mm["videos"]
+    else:
+        audios, images, videos = process_mm_info(conversation, use_audio_in_video=True)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=True,
+    )
+
+    model_dtype = next(model.parameters()).dtype
+    converted = {}
+    for k, v in inputs.items():
+        if hasattr(v, "to"):
+            v = v.to(model.device)
+            if torch.is_floating_point(v):
+                v = v.to(model_dtype)
+        converted[k] = v
+    inputs = converted
+
+    from omni_model_loading import is_omni_thinker_model
+
+    is_thinker = is_omni_thinker_model(model)
+    if is_thinker:
+        gen_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": temperature > 0}
+    else:
+        gen_kwargs = {
+            "thinker_max_new_tokens": max_new_tokens,
+            "use_audio_in_video": True,
+            "return_audio": False,
+            "do_sample": temperature > 0,
+        }
+    if temperature > 0:
+        gen_kwargs["temperature"] = temperature
+        gen_kwargs["top_p"] = 0.9
+
+    with torch.inference_mode():
+        output_ids = model.generate(**inputs, **gen_kwargs)
+
+    if isinstance(output_ids, tuple):
+        output_ids = output_ids[0]
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+    return response
+
+
+def preprocess_video_for_vllm(video_path: str):
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "fps": 2.0, "max_frames": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=True)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    audio_tuple = None
+    if audios:
+        aud = audios[0]
+        if isinstance(aud, tuple):
+            audio_tuple = (aud[0].numpy() if hasattr(aud[0], "numpy") else np.asarray(aud[0]),
+                           aud[1])
+        elif hasattr(aud, "numpy"):
+            audio_tuple = (aud.numpy(), 16000)
+        else:
+            audio_tuple = (np.asarray(aud), 16000)
+    return video_np, audio_tuple
+
+
+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, base_model: str) -> str:
+    from omni_model_loading import vllm_user_mm_prefix
+
+    mm = vllm_user_mm_prefix(base_model, include_audio=True)
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"{mm}"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    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 ""
+
+
+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
+
+
+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}")
+
+
+def _load_processed_uids(out_dir: Path) -> set:
+    processed: set = set()
+    for p in sorted(out_dir.glob("eval_results*.jsonl")):
+        try:
+            with open(p) as f:
+                for line in f:
+                    try:
+                        processed.add(json.loads(line)["uid"])
+                    except Exception:
+                        continue
+        except FileNotFoundError:
+            continue
+    return processed
+
+
+def _finalize_metrics(out_dir: Path, label: str, args: argparse.Namespace,
+                      vllm_preprocess_stats: Optional[Dict[str, int]] = None) -> None:
+    results_by_uid: Dict[str, Dict[str, Any]] = {}
+    source_files = sorted(out_dir.glob("eval_results*.jsonl"))
+    for p in source_files:
+        with open(p) as f:
+            for line in f:
+                try:
+                    obj = json.loads(line)
+                except Exception:
+                    continue
+                results_by_uid[obj["uid"]] = obj
+
+    if not results_by_uid:
+        print("[warn] No results to compute metrics from.")
+        return
+
+    all_results = list(results_by_uid.values())
+    merged_jsonl = out_dir / "eval_results.jsonl"
+    with open(merged_jsonl, "w", encoding="utf-8") as f:
+        for r in all_results:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+    print(f"[merge] Wrote {len(all_results)} unique results to {merged_jsonl} "
+          f"(merged {len(source_files)} source file(s)).")
+
+    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,
+        "vllm": bool(args.vllm),
+        "max_num_seqs": args.max_num_seqs,
+        "vllm_batch_size": args.vllm_batch_size,
+        "max_model_len": args.max_model_len,
+        "num_shards": args.num_shards,
+    }
+    if vllm_preprocess_stats is not None:
+        metrics["eval_config"]["vllm_preprocess_skips"] = vllm_preprocess_stats
+
+    metrics_json = out_dir / "metrics.json"
+    summary_txt = out_dir / "summary.txt"
+    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: {merged_jsonl}")
+    print(f"[output] Metrics: {metrics_json}")
+    print(f"[output] Summary: {summary_txt}")
+
+
+def main() -> None:
+    args = parse_args()
+    label = args.label or (
+        Path(args.adapter).name if args.adapter
+        else Path(args.base_model).name
+    )
+
+    out_dir = args.output_dir / label
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    if args.num_shards < 1 or args.shard < 0 or args.shard >= args.num_shards:
+        raise SystemExit(f"Invalid --shard {args.shard} / --num-shards {args.num_shards}")
+    is_sharded = args.num_shards > 1
+    shard_tag = f".shard{args.shard}of{args.num_shards}" if is_sharded else ""
+    results_jsonl = out_dir / f"eval_results{shard_tag}.jsonl"
+
+    if args.merge_only:
+        print(f"[merge-only] out_dir={out_dir}")
+        _finalize_metrics(out_dir, label, args)
+        return
+
+    print("[data] Loading LVBench dataset...")
+    test_data = load_lvbench(args.video_dir, args.max_samples)
+    print(f"[data] {len(test_data)} total questions")
+
+    if is_sharded:
+        shard_data = [x for i, x in enumerate(test_data)
+                      if i % args.num_shards == args.shard]
+        print(f"[shard] shard={args.shard}/{args.num_shards} -> "
+              f"{len(shard_data)} questions in this shard")
+        test_data = shard_data
+
+    processed = _load_processed_uids(out_dir)
+    if processed:
+        print(f"[resume] {len(processed)} uids already processed across all "
+              f"eval_results*.jsonl under {out_dir}")
+
+    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] Preprocessing videos (before model load) ...")
+        todo = [item for item in test_data if item["uid"] not in processed]
+        unique_videos = list(dict.fromkeys(item["video_path"] for item in todo))
+        from omni_model_loading import parallel_preprocess_videos
+        preprocessed, preprocessed_audio, preprocess_failed_paths = parallel_preprocess_videos(
+            unique_videos, preprocess_video_for_vllm,
+        )
+
+        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,
+        }
+
+        from omni_model_loading import cap_vllm_max_model_len
+
+        vllm_max_len = cap_vllm_max_model_len(model_path, args.max_model_len)
+        print(f"[vllm] Loading {model_path} with tp={tp} "
+              f"(max_num_seqs={args.max_num_seqs}, max_model_len={vllm_max_len}) ...")
+        llm_kwargs = dict(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=vllm_max_len,
+            max_num_seqs=args.max_num_seqs,
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            dtype="bfloat16",
+            trust_remote_code=True,
+            limit_mm_per_prompt={"video": 1, "audio": 1},
+            enforce_eager=args.enforce_eager,
+        )
+        llm = LLM(**llm_kwargs)
+        sampling_params = SamplingParams(
+            temperature=args.temperature if args.temperature > 0 else 0.0,
+            top_p=0.9 if args.temperature > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        vllm_todo = [item for item in todo if item["video_path"] in preprocessed]
+        fallback_items = []
+        print(f"[vllm] {len(vllm_todo)} questions ready, running inference "
+              f"(batch={args.vllm_batch_size}) ...")
+
+        def _write_result(item: Dict[str, Any], raw_output: str) -> None:
+            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"])
+
+        def _build_inp(item: Dict[str, Any]) -> Dict[str, Any]:
+            inp = {
+                "prompt": build_vllm_prompt(item["prompt"], args.base_model),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            if item["video_path"] in preprocessed_audio:
+                inp["multi_modal_data"]["audio"] = preprocessed_audio[item["video_path"]]
+            return inp
+
+        def _flush(batch: List[Dict[str, Any]]) -> None:
+            if not batch:
+                return
+            inps = [b["inp"] for b in batch]
+            try:
+                outs = llm.generate(inps, sampling_params=sampling_params)
+                for b, o in zip(batch, outs):
+                    _write_result(b["item"], o.outputs[0].text.strip())
+                return
+            except (ValueError, RuntimeError) as exc:
+                if "longer than the maximum model length" not in str(exc):
+                    raise
+            for b in batch:
+                try:
+                    outs = llm.generate([b["inp"]], sampling_params=sampling_params)
+                    _write_result(b["item"], outs[0].outputs[0].text.strip())
+                except (ValueError, RuntimeError) as exc2:
+                    if "longer than the maximum model length" in str(exc2):
+                        print(f"  [too long] {b['item']['uid']} -> fallback")
+                        fallback_items.append(b["item"])
+                    else:
+                        raise
+
+        batch: List[Dict[str, Any]] = []
+        for i, item in enumerate(vllm_todo):
+            if item["uid"] in processed:
+                continue
+            batch.append({"inp": _build_inp(item), "item": item})
+            if len(batch) >= max(1, args.vllm_batch_size):
+                _flush(batch)
+                batch = []
+            if (i + 1) % 50 == 0:
+                print(f"  [vllm] [{i+1}/{len(vllm_todo)}] submitted, "
+                      f"{len(fallback_items)} deferred")
+        _flush(batch)
+
+        preprocessed.clear()
+        preprocessed_audio.clear()
+
+        if fallback_items:
+            print(f"[fallback] Running {len(fallback_items)} long-video questions with transformers ...")
+            del llm
+            gc.collect()
+            torch.cuda.empty_cache()
+
+            fallback_items.sort(key=lambda it: it["video_path"])
+
+            model, processor = load_model(args.base_model, args.adapter)
+            last_vp: Optional[str] = None
+            cached_mm: Optional[Dict[str, Any]] = None
+            for item in tqdm(fallback_items, desc="Fallback", unit="q"):
+                if item["uid"] in processed:
+                    continue
+                if item["video_path"] != last_vp:
+                    cached_mm = None
+                    last_vp = item["video_path"]
+                try:
+                    if cached_mm is None:
+                        from qwen_omni_utils import process_mm_info as _pmi
+                        tmp_conv = [{"role": "user", "content": [
+                            {"type": "video", "video": item["video_path"]},
+                            {"type": "text", "text": item["prompt"]},
+                        ]}]
+                        a, im, v = _pmi(tmp_conv, use_audio_in_video=True)
+                        cached_mm = {"audios": a, "images": im, "videos": v}
+                    raw_output = run_inference(
+                        model, processor, item["video_path"], item["prompt"],
+                        args.max_new_tokens, args.temperature,
+                        cached_mm=cached_mm,
+                    )
+                except Exception as exc:
+                    import traceback
+                    print(f"  [error] {item['uid']}: {exc}")
+                    traceback.print_exc()
+                    raw_output = ""
+                    cached_mm = None
+
+                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()
+
+    if is_sharded:
+        print(f"[shard {args.shard}/{args.num_shards}] finished inference. "
+              f"Run `--merge-only` after all shards complete to produce final metrics.")
+        return
+
+    _finalize_metrics(out_dir, label, args, vllm_preprocess_stats)
+
+
+if __name__ == "__main__":
+    main()

supp/eval_vggsoundsync.py

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

supp/eval_videomme.py

@@ -0,0 +1,564 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ctypes
+import gc
+import json
+import os
+import re
+import site
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib"
+_npp_so = _npp_lib / "libnppicc.so.12"
+if _npp_so.is_file():
+    ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL)
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_VIDEO_DIR = Path("./data/videomme/data")
+DEFAULT_OUTPUT_DIR = Path("./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)
+    p.add_argument("--tp", type=int, default=None)
+    p.add_argument("--batch-size", type=int, default=32)
+    p.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    p.add_argument("--max-model-len", type=int, default=65536)
+    return p.parse_args()
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    from omni_model_loading import load_qwen_omni_model
+
+    model, processor, _ = load_qwen_omni_model(base_model, adapter)
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, 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=True)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=True,
+    )
+
+    model_dtype = next(model.parameters()).dtype
+    converted = {}
+    for k, v in inputs.items():
+        if hasattr(v, "to"):
+            v = v.to(model.device)
+            if torch.is_floating_point(v):
+                v = v.to(model_dtype)
+        converted[k] = v
+    inputs = converted
+
+    from omni_model_loading import is_omni_thinker_model
+
+    is_thinker = is_omni_thinker_model(model)
+    if is_thinker:
+        gen_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": temperature > 0}
+    else:
+        gen_kwargs = {
+            "thinker_max_new_tokens": max_new_tokens,
+            "use_audio_in_video": True,
+            "return_audio": False,
+            "do_sample": temperature > 0,
+        }
+    if temperature > 0:
+        gen_kwargs["temperature"] = temperature
+        gen_kwargs["top_p"] = 0.9
+
+    with torch.inference_mode():
+        output_ids = model.generate(**inputs, **gen_kwargs)
+
+    if isinstance(output_ids, tuple):
+        output_ids = output_ids[0]
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+    return response
+
+
+def preprocess_video_for_vllm(video_path: str):
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "nframes": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=True)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    audio_tuple = None
+    if audios:
+        aud = audios[0]
+        if isinstance(aud, tuple):
+            audio_tuple = (aud[0].numpy() if hasattr(aud[0], "numpy") else np.asarray(aud[0]),
+                           aud[1])
+        elif hasattr(aud, "numpy"):
+            audio_tuple = (aud.numpy(), 16000)
+        else:
+            audio_tuple = (np.asarray(aud), 16000)
+    return video_np, audio_tuple
+
+
+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, base_model: str) -> str:
+    from omni_model_loading import vllm_user_mm_prefix
+
+    mm = vllm_user_mm_prefix(base_model, include_audio=True)
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"{mm}"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    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 ""
+
+
+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
+
+
+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}")
+
+
+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("[vllm] Preprocessing videos (before model load) ...")
+        todo = [item for item in test_data if item["question_id"] not in processed]
+        unique_videos = list(dict.fromkeys(item["video_path"] for item in todo))
+        from omni_model_loading import parallel_preprocess_videos
+        preprocessed, preprocessed_audio, preprocess_failed_paths = parallel_preprocess_videos(
+            unique_videos, preprocess_video_for_vllm,
+        )
+
+        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,
+        }
+
+        from omni_model_loading import cap_vllm_max_model_len
+
+        vllm_max_len = cap_vllm_max_model_len(model_path, args.max_model_len)
+        print(f"[vllm] Loading {model_path} with tp={tp} (max_model_len={vllm_max_len}) ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=vllm_max_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 1, "audio": 1},
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            dtype="bfloat16",
+            trust_remote_code=True,
+        )
+        sampling_params = SamplingParams(
+            temperature=args.temperature if args.temperature > 0 else 0.0,
+            top_p=0.9 if args.temperature > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        vllm_todo = [item for item in todo if item["video_path"] 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"], args.base_model),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            if item["video_path"] in preprocessed_audio:
+                inp["multi_modal_data"]["audio"] = preprocessed_audio[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()
+        preprocessed_audio.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()

supp/eval_worldsense.py

@@ -0,0 +1,591 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import ctypes
+import gc
+import json
+import os
+import re
+import site
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_npp_lib = Path(site.getsitepackages()[0]) / "nvidia" / "npp" / "lib"
+_npp_so = _npp_lib / "libnppicc.so.12"
+if _npp_so.is_file():
+    ctypes.CDLL(str(_npp_so), mode=ctypes.RTLD_GLOBAL)
+
+import torch
+from tqdm import tqdm
+
+DEFAULT_DATA_DIR = Path("./data/worldsense")
+DEFAULT_OUTPUT_DIR = Path("./eval_results/worldsense")
+
+DURATIONS = ["<1min", "1-2min", "2-4min", "4-6min", "6-8min", ">8min"]
+DOMAINS = [
+    "Music", "Culture & Politics", "Tech & Science", "Daily Life",
+    "Film & TV", "Sports", "Performance", "Games",
+]
+TASK_DOMAINS = ["Understanding", "Reasoning", "Recognition"]
+TASK_TYPES = [
+    "Action Counting", "Anomaly Recognition", "Attribute Reasoning",
+    "Attribute Recognition", "Audio Change", "Audio Counting",
+    "Audio Recognition", "Audio Source Localization", "Causal Reasoning",
+    "Emotion Change", "Event Recognition", "Event Sorting",
+    "Hallucination", "Human Emotions", "Human Interaction",
+    "Human-object Interaction", "Object Counting",
+    "Object Existence Recognition", "Object State Change",
+    "Relation Reasoning", "Scene Recognition", "Spatial Relation",
+    "Temporal Localization", "Temporal Prediction",
+    "Text and Diagram Understanding", "Video Emotions",
+]
+
+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 WorldSense 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("--data-dir", type=Path, default=DEFAULT_DATA_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)
+    p.add_argument("--tp", type=int, default=None)
+    p.add_argument("--batch-size", type=int, default=32)
+    p.add_argument("--gpu-memory-utilization", type=float, default=0.90)
+    p.add_argument("--max-model-len", type=int, default=65536)
+    return p.parse_args()
+
+
+def load_model(base_model: str, adapter: Optional[str]):
+    from omni_model_loading import load_qwen_omni_model
+
+    model, processor, _ = load_qwen_omni_model(base_model, adapter)
+    return model, processor
+
+
+def run_inference(model, processor, video_path: str, prompt: str,
+                  max_new_tokens: int, temperature: float) -> str:
+    from qwen_omni_utils import process_mm_info
+
+    tmp_dir = tempfile.mkdtemp(prefix="eval_ws_")
+    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=True)
+    inputs = processor(
+        text=text, audio=audios, images=images, videos=videos,
+        return_tensors="pt", padding=True, use_audio_in_video=True,
+    )
+
+    model_dtype = next(model.parameters()).dtype
+    converted = {}
+    for k, v in inputs.items():
+        if hasattr(v, "to"):
+            v = v.to(model.device)
+            if torch.is_floating_point(v):
+                v = v.to(model_dtype)
+        converted[k] = v
+    inputs = converted
+
+    from omni_model_loading import is_omni_thinker_model
+
+    is_thinker = is_omni_thinker_model(model)
+    if is_thinker:
+        gen_kwargs = {"max_new_tokens": max_new_tokens, "do_sample": temperature > 0}
+    else:
+        gen_kwargs = {
+            "thinker_max_new_tokens": max_new_tokens,
+            "use_audio_in_video": True,
+            "return_audio": False,
+            "do_sample": temperature > 0,
+        }
+    if temperature > 0:
+        gen_kwargs["temperature"] = temperature
+        gen_kwargs["top_p"] = 0.9
+
+    with torch.inference_mode():
+        output_ids = model.generate(**inputs, **gen_kwargs)
+
+    if isinstance(output_ids, tuple):
+        output_ids = output_ids[0]
+
+    prompt_len = inputs["input_ids"].shape[1]
+    response = processor.batch_decode(
+        output_ids[:, prompt_len:], skip_special_tokens=True,
+    )[0].strip()
+
+    shutil.rmtree(tmp_dir, ignore_errors=True)
+    return response
+
+
+def preprocess_video_for_vllm(video_path: str):
+    from qwen_omni_utils import process_mm_info
+    import numpy as np
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "video", "video": video_path, "fps": 2.0, "max_frames": 128},
+            {"type": "text", "text": "placeholder"},
+        ],
+    }]
+    audios, images, videos = process_mm_info(messages, use_audio_in_video=True)
+    video_tensor = videos[0]
+    video_np = (video_tensor * 255).byte().numpy()
+    audio_tuple = None
+    if audios:
+        aud = audios[0]
+        if isinstance(aud, tuple):
+            audio_tuple = (aud[0].numpy() if hasattr(aud[0], "numpy") else np.asarray(aud[0]),
+                           aud[1])
+        elif hasattr(aud, "numpy"):
+            audio_tuple = (aud.numpy(), 16000)
+        else:
+            audio_tuple = (np.asarray(aud), 16000)
+    return video_np, audio_tuple
+
+
+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, base_model: str) -> str:
+    from omni_model_loading import vllm_user_mm_prefix
+
+    mm = vllm_user_mm_prefix(base_model, include_audio=True)
+    return (
+        f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n"
+        f"<|im_start|>user\n"
+        f"{mm}"
+        f"{question}<|im_end|>\n"
+        f"<|im_start|>assistant\n"
+    )
+
+
+def extract_answer(text: str) -> str:
+    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 ""
+
+
+def load_worldsense(data_dir: Path, max_samples: int) -> List[Dict[str, Any]]:
+    import pandas as pd
+
+    parquet_path = data_dir / "data" / "test-00000-of-00001.parquet"
+    if not parquet_path.exists():
+        from datasets import load_dataset
+        ds = load_dataset("lmms-lab/WorldSense", split="test")
+        df = ds.to_pandas()
+    else:
+        df = pd.read_parquet(parquet_path)
+
+    data = []
+    skipped = 0
+    for idx, row in df.iterrows():
+        video_rel = row["video_path"]
+        video_path = data_dir / video_rel.lstrip("./")
+        if not video_path.exists():
+            skipped += 1
+            continue
+
+        candidates = list(row["candidates"])
+        options_text = "\n".join(candidates)
+        prompt = MCQ_PROMPT + row["question"] + "\n" + options_text + "\nThe best answer is:"
+
+        data.append({
+            "question_id": f"ws_{row['index']}",
+            "video_id": row["video"],
+            "video_path": str(video_path),
+            "duration": row["duration"],
+            "domain": row["domain"],
+            "sub_category": row["sub_category"],
+            "task_domain": row["task_domain"],
+            "task_type": row["task_type"],
+            "question": row["question"],
+            "candidates": candidates,
+            "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
+
+
+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 dur in DURATIONS:
+        subset = [r for r in results if r["duration"] == dur]
+        if subset:
+            per_duration[dur] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_domain = {}
+    for dom in DOMAINS:
+        subset = [r for r in results if r["domain"] == dom]
+        if subset:
+            per_domain[dom] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task_domain = {}
+    for td in TASK_DOMAINS:
+        subset = [r for r in results if r.get("task_domain") == td]
+        if subset:
+            per_task_domain[td] = {"accuracy": acc_for(subset), "count": len(subset)}
+
+    per_task_type = {}
+    for tt in TASK_TYPES:
+        subset = [r for r in results if r["task_type"] == tt]
+        if subset:
+            per_task_type[tt] = {"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_domain": per_task_domain,
+        "per_task_type": per_task_type,
+    }
+
+
+def print_summary(metrics: Dict[str, Any], label: str) -> None:
+    print()
+    print(f"{'=' * 65}")
+    print(f"  WorldSense 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 dur in DURATIONS:
+        if dur in metrics["per_duration"]:
+            d = metrics["per_duration"][dur]
+            print(f"    {dur:8s}:  {d['accuracy']:.1%}  ({d['count']} questions)")
+
+    print(f"  ─── Per Domain ───")
+    for dom in DOMAINS:
+        if dom in metrics["per_domain"]:
+            d = metrics["per_domain"][dom]
+            print(f"    {dom:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Task Domain ───")
+    for td in TASK_DOMAINS:
+        if td in metrics["per_task_domain"]:
+            d = metrics["per_task_domain"][td]
+            print(f"    {td:25s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"  ─── Per Task Type ───")
+    for tt in TASK_TYPES:
+        if tt in metrics["per_task_type"]:
+            d = metrics["per_task_type"][tt]
+            print(f"    {tt:30s}: {d['accuracy']:.1%}  ({d['count']})")
+
+    print(f"{'=' * 65}")
+
+
+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 WorldSense dataset...")
+    test_data = load_worldsense(args.data_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("[vllm] Preprocessing videos (before model load) ...")
+        todo = [item for item in test_data if item["question_id"] not in processed]
+        unique_videos = list(dict.fromkeys(item["video_path"] for item in todo))
+        from omni_model_loading import parallel_preprocess_videos
+        preprocessed, preprocessed_audio, preprocess_failed_paths = parallel_preprocess_videos(
+            unique_videos, preprocess_video_for_vllm,
+        )
+
+        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."
+            )
+        vllm_preprocess_stats = {
+            "preprocess_failed_videos": len(preprocess_failed_paths),
+            "preprocess_skipped_questions": n_pp_skip,
+        }
+
+        from omni_model_loading import cap_vllm_max_model_len
+
+        vllm_max_len = cap_vllm_max_model_len(model_path, args.max_model_len)
+        print(f"[vllm] Loading {model_path} with tp={tp} (max_model_len={vllm_max_len}) ...")
+        llm = LLM(
+            model=model_path,
+            tensor_parallel_size=tp,
+            max_model_len=vllm_max_len,
+            max_num_seqs=4,
+            limit_mm_per_prompt={"video": 1, "audio": 1},
+            gpu_memory_utilization=args.gpu_memory_utilization,
+            dtype="bfloat16",
+            trust_remote_code=True,
+        )
+        sampling_params = SamplingParams(
+            temperature=args.temperature if args.temperature > 0 else 0.0,
+            top_p=0.9 if args.temperature > 0 else 1.0,
+            max_tokens=args.max_new_tokens,
+        )
+
+        vllm_todo = [item for item in todo if item["video_path"] 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"], args.base_model),
+                "multi_modal_data": {"video": preprocessed[item["video_path"]]},
+            }
+            if item["video_path"] in preprocessed_audio:
+                inp["multi_modal_data"]["audio"] = preprocessed_audio[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_domain": item["task_domain"],
+                    "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()
+        preprocessed_audio.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_domain": item["task_domain"],
+                    "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="WorldSense", 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_domain": item["task_domain"],
+                "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,
+        "data_dir": str(args.data_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()

sync_split_acc.py

@@ -0,0 +1,176 @@
+"""Print sync accuracy split into:
+  - original (gt_synced=True)        : did the model correctly say 'synced'?
+  - shifted  (gt_direction=delay/early): did the model correctly call it desync?
+                                         (and, separately, get the direction right?)
+
+Usage:
+  python3 /home/ubuntu/sync_split_acc.py <eval_results.jsonl OR its parent dir> [more...]
+
+Examples:
+  python3 /home/ubuntu/sync_split_acc.py ~/eval_results/sync/sync_qwen3omni_vanilla
+  python3 /home/ubuntu/sync_split_acc.py ~/eval_results/sync/sync_qwen3omni_vanilla/eval_results.jsonl
+  python3 /home/ubuntu/sync_split_acc.py ~/eval_results/sync/sync_*    # multiple at once
+"""
+import json
+import sys
+from pathlib import Path
+
+
+def resolve(arg: str) -> Path:
+    """Return either an eval_results.jsonl (preferred) or a metrics.json
+    (fallback when per-sample data isn't available)."""
+    p = Path(arg).expanduser()
+    if p.is_dir():
+        jsonl = p / "eval_results.jsonl"
+        metrics = p / "metrics.json"
+        return jsonl if jsonl.exists() else metrics
+    return p
+
+
+def report_from_metrics(metrics_path: Path) -> None:
+    """Fallback: derive original-vs-shifted breakdown from a pre-computed
+    metrics.json that has total_samples, sync_desync_accuracy,
+    three_class_accuracy, per_category{synced/delay/early _accuracy/_count}."""
+    m = json.load(open(metrics_path))
+    total = m.get("total_samples")
+    pc = m.get("per_category", {})
+    if not total or not pc:
+        print(f"[skip] {metrics_path} missing fields needed for split")
+        return
+
+    n_orig  = pc.get("synced_count", 0)
+    n_delay = pc.get("delay_count", 0)
+    n_early = pc.get("early_count", 0)
+    n_shift = n_delay + n_early
+
+    syn_acc   = pc.get("synced_accuracy") or 0
+    delay_acc = pc.get("delay_accuracy") or 0    # strict: detected AND direction right
+    early_acc = pc.get("early_accuracy") or 0    # strict: detected AND direction right
+
+    sync_desync_acc  = m.get("sync_desync_accuracy") or 0
+    three_class_acc  = m.get("three_class_accuracy") or 0
+
+    orig_correct = n_orig * syn_acc                 # said 'synced' on originals
+    delay_dir_correct = n_delay * delay_acc         # detected + dir right
+    early_dir_correct = n_early * early_acc
+    shifted_dir_correct = delay_dir_correct + early_dir_correct
+
+    # detected desync (looser, ignores direction): from sync_desync_accuracy.
+    # sync_desync_acc = (orig_correct + shifted_detected) / total
+    shifted_detected = sync_desync_acc * total - orig_correct
+
+    print("=" * 64)
+    print(f"  {metrics_path.parent.name}   [from metrics.json — no per-sample jsonl]")
+    print("=" * 64)
+    print(f"  total samples                 : {int(total)}")
+    print(f"  --- original (gt = synced) ---")
+    if n_orig:
+        print(f"    n                           : {n_orig}")
+        print(f"    correctly said 'synced'     : {int(round(orig_correct))} / {n_orig} = {syn_acc:.4%}")
+    print(f"  --- shifted  (gt = delay/early) ---")
+    print(f"    n                           : {n_shift}  (delay={n_delay}, early={n_early})")
+    if n_shift:
+        print(f"    detected desync             : {int(round(shifted_detected))} / {n_shift} = "
+              f"{shifted_detected / n_shift:.4%}")
+        print(f"    + got direction right       : {int(round(shifted_dir_correct))} / {n_shift} = "
+              f"{shifted_dir_correct / n_shift:.4%}")
+        if n_delay:
+            print(f"      delay direction right     : {int(round(delay_dir_correct))} / {n_delay} = "
+                  f"{delay_acc:.4%}")
+        if n_early:
+            print(f"      early direction right     : {int(round(early_dir_correct))} / {n_early} = "
+                  f"{early_acc:.4%}")
+    if m.get("offset_mae_sec") is not None:
+        print(f"  --- offset estimate ---")
+        print(f"    MAE                         : {m['offset_mae_sec']:.4f}s "
+              f"(n={m.get('offset_evaluated_count', '?')})")
+        if m.get("offset_median_sec") is not None:
+            print(f"    median                      : {m['offset_median_sec']:.4f}s")
+    print("=" * 64)
+    print()
+
+
+def report(jsonl: Path) -> None:
+    if not jsonl.exists():
+        print(f"[skip] {jsonl} does not exist")
+        return
+    if jsonl.name == "metrics.json":
+        report_from_metrics(jsonl)
+        return
+    rows = [json.loads(l) for l in open(jsonl) if l.strip()]
+    n = len(rows)
+    if n == 0:
+        print(f"[skip] {jsonl} is empty")
+        return
+
+    orig    = [r for r in rows if r["gt_synced"]]
+    delay   = [r for r in rows if r.get("gt_direction") == "delay"]
+    early   = [r for r in rows if r.get("gt_direction") == "early"]
+    shifted = delay + early
+
+    # On originals: correct iff pred_synced is True.
+    orig_correct = sum(1 for r in orig if r["pred_synced"])
+    # On shifted: correct iff pred_synced is False (i.e. detected desync).
+    shifted_detected = sum(1 for r in shifted if not r["pred_synced"])
+    # Stricter: also got the direction right.
+    shifted_dir_correct = sum(
+        1 for r in shifted
+        if not r["pred_synced"] and r.get("pred_direction") == r["gt_direction"]
+    )
+
+    print("=" * 64)
+    print(f"  {jsonl.parent.name}")
+    print("=" * 64)
+    print(f"  total samples                 : {n}")
+    print(f"  --- original (gt = synced) ---")
+    print(f"    n                           : {len(orig)}")
+    if orig:
+        print(f"    correctly said 'synced'     : {orig_correct} / {len(orig)} = "
+              f"{(orig_correct / len(orig)):.4%}")
+    print(f"  --- shifted  (gt = delay/early) ---")
+    print(f"    n                           : {len(shifted)}  (delay={len(delay)}, early={len(early)})")
+    if shifted:
+        print(f"    detected desync             : {shifted_detected} / {len(shifted)} = "
+              f"{(shifted_detected / len(shifted)):.4%}")
+        print(f"    + got direction right       : {shifted_dir_correct} / {len(shifted)} = "
+              f"{(shifted_dir_correct / len(shifted)):.4%}")
+        if delay:
+            d_det = sum(1 for r in delay if not r["pred_synced"])
+            d_dir = sum(1 for r in delay if not r["pred_synced"] and r["pred_direction"] == "delay")
+            print(f"      delay only detected       : {d_det} / {len(delay)} = {d_det / len(delay):.4%}"
+                  f"   (direction right: {d_dir} = {d_dir / len(delay):.4%})")
+        if early:
+            e_det = sum(1 for r in early if not r["pred_synced"])
+            e_dir = sum(1 for r in early if not r["pred_synced"] and r["pred_direction"] == "early")
+            print(f"      early only detected       : {e_det} / {len(early)} = {e_det / len(early):.4%}"
+                  f"   (direction right: {e_dir} = {e_dir / len(early):.4%})")
+
+    # offset MAE on shifted videos that were predicted as desync with a non-zero offset
+    errs = [abs(r["pred_offset_sec"] - r["gt_offset_sec"])
+            for r in shifted
+            if not r["pred_synced"] and r.get("pred_offset_sec", 0) > 0]
+    if errs:
+        errs.sort()
+        med = errs[len(errs) // 2]
+        print(f"  --- offset estimate on detected shifted ---")
+        print(f"    MAE                         : {sum(errs) / len(errs):.4f}s  (n={len(errs)})")
+        print(f"    median                      : {med:.4f}s")
+        print(f"    within 0.5s                 : {sum(1 for e in errs if e <= 0.5)} / {len(errs)} = "
+              f"{sum(1 for e in errs if e <= 0.5) / len(errs):.4%}")
+        print(f"    within 1.0s                 : {sum(1 for e in errs if e <= 1.0)} / {len(errs)} = "
+              f"{sum(1 for e in errs if e <= 1.0) / len(errs):.4%}")
+    print("=" * 64)
+    print()
+
+
+def main():
+    args = sys.argv[1:]
+    if not args:
+        print(__doc__)
+        sys.exit(1)
+    for a in args:
+        report(resolve(a))
+
+
+if __name__ == "__main__":
+    main()