sync_split_acc.py

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