evaluate_robustness.py

"""evaluate_robustness.py

Run robustness evaluation on LipFD: in-memory perturb the bottom face strip
(rows 500: of the 1000x2500 composite) and re-evaluate AUROC / per-fake-vs-real /
fairness. ZERO additional disk: perturbation is applied inside __getitem__,
only the metrics JSON is written.

Perturbation set (paper-aligned, 7 frame-level subset):
  color_saturation | color_contrast | block_wise | gaussian_noise |
  gaussian_blur   | pixelate        | jpeg_quality
Levels: 1..5  (level 1 = no-op for all 7 in SEVERITY, level 5 = heaviest).

Aggregation: clip-level by basename (e.g. '2358_Real', '1681_Fake').
Demographics (gender / race4 / age_group) joined from a CSV that maps
basename -> demo attributes.

============================================================================
Commands actually executed in this session (cwd = /apdcephfs_gy4/share_303628665/joywu/research/LipFD)
============================================================================
# (a) Smoke test 1 — level=1 (no-op) clean baseline:
#     /opt/conda/envs/LipFD/bin/python evaluate_robustness.py \
#         --real_list_path datasets/FairTalking-Bench/test/0_real \
#         --fake_list_path datasets/FairTalking-Bench/test/1_fake \
#         --ckpt          checkpoints/lipfd_train/model_epoch_44.pth \
#         --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
#         --perturbation gaussian_noise --level 1 \
#         --batch_size 16 --loader_workers 4 --gpu 0 \
#         --save_json /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustness/runs.json
#     -> overall_clip AUROC=0.9958  AP=0.9956  Acc=0.9484  n_clips=581  n_samples=11610
#
# (b) Smoke test 2 — gaussian_noise level=3 (verify perturbation actually bites):
#     /opt/conda/envs/LipFD/bin/python evaluate_robustness.py \
#         --real_list_path datasets/FairTalking-Bench/test/0_real \
#         --fake_list_path datasets/FairTalking-Bench/test/1_fake \
#         --ckpt          checkpoints/lipfd_train/model_epoch_44.pth \
#         --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
#         --perturbation gaussian_noise --level 3 \
#         --batch_size 16 --loader_workers 4 --gpu 0 \
#         --save_json /apdcephfs_gy4/share_303628665/joywu/research/LipFD/robustness/runs.json
#     -> overall_clip AUROC=0.9772 (down 0.019)  TPR@1%FPR=0.4966 (down 0.34) — perturbation works
#
# (c) Full sweep (7 perturbations x 5 levels = 35 combos, level=1 only run once):
#     nohup bash run_robustness.sh > robustness/sweep.log 2>&1 &
#     # run_robustness.sh internally calls this script 29 times (1 baseline + 7*4 levels),
#     # appending each run to robustness/runs.json. ~2.7h on a single 100GB-class GPU.

Usage (single perturbation x level):
    python evaluate_robustness.py \
        --real_list_path datasets/FairTalking-Bench/test/0_real \
        --fake_list_path datasets/FairTalking-Bench/test/1_fake \
        --ckpt           checkpoints/lipfd_train/model_epoch_44.pth \
        --demographics_csv /apdcephfs_gy4/share_303628665/joywu/research/test.csv \
        --perturbation gaussian_noise --level 3 \
        --save_json    robustness/runs.json
"""

import argparse
import collections
import csv as _csv
import json
import math
import os
import random as _rng_mod
import re
import sys
import time

import cv2
import numpy as np
import torch
import torchvision.transforms as transforms
from sklearn.metrics import (
    accuracy_score,
    average_precision_score,
    classification_report,
    confusion_matrix,
    roc_auc_score,
    roc_curve,
)
from torch.utils.data import DataLoader, Dataset
from tqdm import tqdm

_REPO_ROOT = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, _REPO_ROOT)

from models import build_model  # noqa: E402
import utils as _u  # noqa: E402


# ============================================================================
# Perturbation parameters — verbatim from X-AVDT/train/evaluate_robustness.py
# (originally from AVH-Align/robustness/distortions.py).
# ============================================================================
SEVERITY = {
    "color_saturation":  [1.0,   0.8,   1.2,   1.5,   2.0],
    "color_contrast":    [1.0,   0.85,  1.2,   1.4,   1.6],
    "block_wise":        [0,     8,     16,    24,    32],
    "gaussian_noise":    [0.0,   0.001, 0.005, 0.01,  0.05],
    "gaussian_blur":     [1,     3,     7,     11,    15],
    "pixelate":          [1,     2,     4,     6,     8],
    "jpeg_quality":      [100,   85,    70,    50,    30],
}
PERTURBATIONS = list(SEVERITY.keys())
DEMO_DIMS = ("gender", "race4", "age_group")


# ----- frame-level perturbation primitives (BGR uint8) -----
def _bgr2ycbcr(img_bgr):
    img = img_bgr.astype(np.float32) / 255.0
    M = np.array([
        [ 0.299,    0.587,    0.114],
        [-0.16874, -0.33126,  0.5],
        [ 0.5,    -0.41869, -0.08131],
    ], dtype=np.float32)
    yuv = img @ M.T
    yuv[..., 1:] += 0.5
    return yuv


def _ycbcr2bgr(ycbcr):
    yuv = ycbcr.copy()
    yuv[..., 1:] -= 0.5
    M = np.array([
        [1.0,  0.0,      1.402],
        [1.0, -0.34414, -0.71414],
        [1.0,  1.772,    0.0],
    ], dtype=np.float32)
    return np.clip(yuv @ M.T * 255.0, 0, 255)


def _apply_color_saturation(b, p):
    if abs(p - 1.0) < 1e-6:
        return b
    y = _bgr2ycbcr(b)
    y[..., 1] = 0.5 + (y[..., 1] - 0.5) * p
    y[..., 2] = 0.5 + (y[..., 2] - 0.5) * p
    return np.clip(_ycbcr2bgr(y), 0, 255).astype(np.uint8)


def _apply_color_contrast(b, p):
    if abs(p - 1.0) < 1e-6:
        return b
    return np.clip(b.astype(np.float32) * p, 0, 255).astype(np.uint8)


def _apply_block_wise(b, p, rng):
    if p <= 0:
        return b
    width = 8
    block = np.ones((width, width, 3), dtype=np.uint8) * 128
    n = max(1, min(b.shape[0], b.shape[1]) // 256 * int(p))
    out = b.copy()
    H, W = b.shape[:2]
    for _ in range(n):
        rw = rng.randint(0, W - 1 - width)
        rh = rng.randint(0, H - 1 - width)
        out[rh:rh + width, rw:rw + width, :] = block
    return out


def _apply_gaussian_noise(b, p, rng_np):
    if p <= 0:
        return b
    y = _bgr2ycbcr(b)
    h, w, c = y.shape
    noise = math.sqrt(p) * rng_np.standard_normal((h, w, c)).astype(np.float32)
    return np.clip(_ycbcr2bgr(y + noise), 0, 255).astype(np.uint8)


def _apply_gaussian_blur(b, k):
    k = int(k)
    if k <= 1:
        return b
    if k % 2 == 0:
        k += 1
    return cv2.GaussianBlur(b, (k, k), k / 6.0)


def _apply_pixelate(b, f):
    f = int(f)
    if f <= 1:
        return b
    h, w = b.shape[:2]
    sw, sh = max(1, w // f), max(1, h // f)
    small = cv2.resize(b, (sw, sh), interpolation=cv2.INTER_AREA)
    return cv2.resize(small, (w, h), interpolation=cv2.INTER_LINEAR)


def _apply_jpeg(b, q):
    q = int(q)
    if q >= 100:
        return b
    ok, buf = cv2.imencode(".jpg", b, [int(cv2.IMWRITE_JPEG_QUALITY), q])
    if not ok:
        return b
    dec = cv2.imdecode(buf, cv2.IMREAD_COLOR)
    return dec if dec is not None else b


def perturb_bgr(bgr_uint8, perturbation, level, base_seed=42):
    """Apply perturbation to a single BGR uint8 region. Returns BGR uint8."""
    param = SEVERITY[perturbation][level - 1]
    seed = (hash((base_seed, perturbation, level)) & 0xFFFFFFFF)
    py_rng = _rng_mod.Random(seed)
    np_rng = np.random.RandomState(seed)
    if perturbation == "color_saturation":
        return _apply_color_saturation(bgr_uint8, param)
    elif perturbation == "color_contrast":
        return _apply_color_contrast(bgr_uint8, param)
    elif perturbation == "block_wise":
        return _apply_block_wise(bgr_uint8, param, py_rng)
    elif perturbation == "gaussian_noise":
        return _apply_gaussian_noise(bgr_uint8, param, np_rng)
    elif perturbation == "gaussian_blur":
        return _apply_gaussian_blur(bgr_uint8, param)
    elif perturbation == "pixelate":
        return _apply_pixelate(bgr_uint8, param)
    elif perturbation == "jpeg_quality":
        return _apply_jpeg(bgr_uint8, param)
    raise ValueError(f"unsupported perturbation: {perturbation}")


# ============================================================================
# Wrapper Dataset — replicate AVLip preprocessing, perturbing only the bottom
# face strip (rows 500: of the 1000x2500 composite).
# ============================================================================
_BASENAME_RE = re.compile(r"(\d+_(?:Real|Fake))")


def _extract_basename(img_path):
    """'/.../2358_Real_CelebV-HQ_0.png' -> '2358_Real'
       '/.../EDTalk_1681_Fake_EDTalk_0.png' -> '1681_Fake'."""
    m = _BASENAME_RE.search(os.path.basename(img_path))
    return m.group(1) if m else os.path.basename(img_path).rsplit(".", 1)[0]


def _extract_model_id(img_path, label):
    """Real -> 'Real'; fake -> the prefix model name (EDTalk / Float / SadTalk / ...)."""
    if label == 0:
        return "Real"
    return os.path.basename(img_path).split("_", 1)[0]


class PerturbedAVLip(Dataset):
    """Mirrors data.AVLip preprocessing exactly, but perturbs the bottom 500
    rows (face strip) before slicing into crops at 3 scales."""

    def __init__(self, real_dir, fake_dir, perturbation, level, base_seed=42):
        self.real_list = _u.get_list(real_dir)
        self.fake_list = _u.get_list(fake_dir)
        self.label_dict = {p: 0 for p in self.real_list}
        self.label_dict.update({p: 1 for p in self.fake_list})
        self.total_list = self.real_list + self.fake_list
        self.perturbation = perturbation
        self.level = level
        self.base_seed = base_seed
        self._is_noop = level == 1   # level 1 is no-op for every perturbation

    def __len__(self):
        return len(self.total_list)

    def _read_with_skip(self, idx, tried):
        if len(tried) >= len(self.total_list):
            raise RuntimeError("All samples are corrupted or cannot be read!")
        tried.add(idx)
        path = self.total_list[idx]
        if not os.path.exists(path):
            print(f"WARNING: File not found, skipping: {path}")
            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
        img_cv = cv2.imread(path)
        if img_cv is None:
            print(f"WARNING: Failed to read image, skipping: {path}")
            return self._read_with_skip((idx + 1) % len(self.total_list), tried)
        return img_cv, self.label_dict[path], path

    def __getitem__(self, idx):
        img_cv, label, path = self._read_with_skip(idx, set())   # BGR (H,W,3) uint8

        # ---- perturb only the bottom face strip (rows 500:) ----
        if not self._is_noop:
            face_strip = img_cv[500:, :, :]
            perturbed = perturb_bgr(face_strip, self.perturbation, self.level, self.base_seed)
            img_cv = img_cv.copy()
            img_cv[500:, :, :] = perturbed

        # ---- preprocessing — bit-faithful with data/datasets.py:AVLip.__getitem__ ----
        img = torch.tensor(img_cv, dtype=torch.float32).permute(2, 0, 1)
        # NB: original AVLip computes Normalize(img) then immediately overwrites
        # `crops` with un-normalized strips, so the normalize is dead. We omit it.
        # FIX: 5-crop slicing was `i:i+500 for i in range(5)` (5 near-identical
        # 1-px-shifted views of face0); changed to `i*500:(i+1)*500` so 5 distinct
        # 500x500 face patches reach the model. Same fix in data/datasets.py:64.
        crops = [[transforms.Resize((224, 224))(img[:, 500:, i*500:(i+1)*500]) for i in range(5)], [], []]
        crop_idx = [(28, 196), (61, 163)]
        for i in range(len(crops[0])):
            crops[1].append(transforms.Resize((224, 224))(
                crops[0][i][:, crop_idx[0][0]:crop_idx[0][1], crop_idx[0][0]:crop_idx[0][1]]))
            crops[2].append(transforms.Resize((224, 224))(
                crops[0][i][:, crop_idx[1][0]:crop_idx[1][1], crop_idx[1][0]:crop_idx[1][1]]))
        big = transforms.Resize((1120, 1120))(img)
        return big, crops, label, path


def custom_collate(batch):
    """Same collate as validate.py — flattens the (scales x crops) list-of-tensors
    into per-(scale, crop) batched tensors of shape (B, 3, 224, 224)."""
    imgs = torch.stack([item[0] for item in batch])
    num_scales = len(batch[0][1])
    num_crops = len(batch[0][1][0])
    crops = []
    for s in range(num_scales):
        scale_crops = []
        for c in range(num_crops):
            tensors = [batch[i][1][s][c] for i in range(len(batch))]
            scale_crops.append(torch.stack(tensors))
        crops.append(scale_crops)
    labels = torch.tensor([item[2] for item in batch])
    paths = [item[3] for item in batch]
    return imgs, crops, labels, paths


# ============================================================================
# metric helpers (X-AVDT-compatible)
# ============================================================================
def _tpr_at_fpr(y_true, y_score, fpr_target):
    fpr, tpr, _ = roc_curve(y_true, y_score)
    if (fpr <= fpr_target).any():
        return float(tpr[fpr <= fpr_target].max())
    return 0.0


def _compute_eer_threshold(y_true, y_score):
    fpr, tpr, thresholds = roc_curve(y_true, y_score)
    fnr = 1 - tpr
    return float(thresholds[int(np.argmin(np.abs(fpr - fnr)))])


def _metrics_block(y_true, y_score, threshold=0.5):
    y_true = np.asarray(y_true)
    y_score = np.asarray(y_score)
    y_pred = (y_score >= threshold).astype(int)

    out = {}
    try:
        out["AUROC"] = float(roc_auc_score(y_true, y_score))
    except Exception:
        out["AUROC"] = None
    try:
        out["AP"] = float(average_precision_score(y_true, y_score))
    except Exception:
        out["AP"] = None
    out[f"Accuracy@{threshold:.2f}"] = float(accuracy_score(y_true, y_pred))
    out["Confusion Matrix"] = confusion_matrix(y_true, y_pred, labels=[0, 1]).tolist()
    out["Classification Report"] = classification_report(
        y_true, y_pred, labels=[0, 1], output_dict=True, zero_division=0
    )
    try:
        thr = _compute_eer_threshold(y_true, y_score)
        out["EER_threshold"] = thr
        out["Acc@EER"] = float(accuracy_score(y_true, (y_score >= thr).astype(int)))
    except Exception:
        out["EER_threshold"] = None
        out["Acc@EER"] = None
    try:
        out["TPR@FPR=1%"] = _tpr_at_fpr(y_true, y_score, 0.01)
        out["TPR@FPR=0.1%"] = _tpr_at_fpr(y_true, y_score, 0.001)
    except Exception:
        out["TPR@FPR=1%"] = None
        out["TPR@FPR=0.1%"] = None
    return out


def _fmt4(v):
    try:
        return f"{float(v):.4f}"
    except Exception:
        return "n/a"


def _set_seed(seed):
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False


def load_ckpt(model, ckpt_path):
    ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
    state = ckpt.get("model", ckpt) if isinstance(ckpt, dict) else ckpt
    cleaned = collections.OrderedDict()
    for k, v in state.items():
        if k.startswith("module."):
            k = k[len("module."):]
        cleaned[k] = v
    info = model.load_state_dict(cleaned, strict=False)
    out = {"missing_count": len(info.missing_keys),
           "unexpected_count": len(info.unexpected_keys)}
    if not info.missing_keys and not info.unexpected_keys:
        print(f"[OK] Strict checkpoint match: all {len(cleaned)} keys consumed.")
    else:
        print(f"[WARN] missing={len(info.missing_keys)} unexpected={len(info.unexpected_keys)}")
    return out


def compute_fairness(y_true, y_score, groups):
    y_true = np.asarray(y_true)
    y_score = np.asarray(y_score)
    groups = np.asarray(groups)
    pred = (y_score > 0.5).astype(int)

    def _g_fpr(g):
        m = (groups == g) & (y_true == 0)
        return float(pred[m].mean()) if m.sum() else 0.0

    def _g_tpr(g):
        m = (groups == g) & (y_true == 1)
        return float(pred[m].mean()) if m.sum() else 0.0

    def _g_acc(g):
        m = (groups == g)
        return float((pred[m] == y_true[m]).mean()) if m.sum() else 0.0

    def _g_dp(g):
        m = (groups == g)
        return float(pred[m].mean()) if m.sum() else 0.0

    uniq = sorted(set(groups.tolist()))
    if not uniq:
        return None
    fprs = [_g_fpr(g) for g in uniq]
    tprs = [_g_tpr(g) for g in uniq]
    accs = [_g_acc(g) for g in uniq]
    dps  = [_g_dp(g)  for g in uniq]
    ns   = [int((groups == g).sum()) for g in uniq]
    return {
        "F_FPR": float(np.std(fprs)) * 100,
        "F_MEO": (max(max(fprs) - min(fprs), max(tprs) - min(tprs))) * 100,
        "F_DP":  float(np.std(dps))  * 100,
        "F_OAE": float(np.std(accs)) * 100,
        "groups": {g: {"n": n, "fpr": f, "tpr": t, "acc": a, "dp": d}
                   for g, n, f, t, a, d in zip(uniq, ns, fprs, tprs, accs, dps)},
    }


def load_demographics(csv_path):
    out = {}
    with open(csv_path, newline="") as f:
        for row in _csv.DictReader(f):
            base = row["basename"].strip()
            if base:
                out[base] = {
                    "gender":    (row.get("gender") or "").strip(),
                    "race4":     (row.get("race4") or "").strip(),
                    "age_group": (row.get("age_group") or "").strip(),
                }
    return out


# ============================================================================
# main
# ============================================================================
def parse_args():
    p = argparse.ArgumentParser()
    p.add_argument("--real_list_path", type=str, required=True)
    p.add_argument("--fake_list_path", type=str, required=True)
    p.add_argument("--ckpt", type=str, required=True)
    p.add_argument("--demographics_csv", type=str, required=True)
    p.add_argument("--perturbation", type=str, required=True, choices=PERTURBATIONS)
    p.add_argument("--level", type=int, required=True, choices=[1, 2, 3, 4, 5])
    p.add_argument("--arch", type=str, default="CLIP:ViT-L/14")
    p.add_argument("--batch_size", type=int, default=8)
    p.add_argument("--loader_workers", type=int, default=4)
    p.add_argument("--gpu", type=int, default=0)
    p.add_argument("--seed", type=int, default=42)
    p.add_argument("--save_json", type=str, default=None)
    return p.parse_args()


def main():
    args = parse_args()
    _set_seed(args.seed)
    device = torch.device(f"cuda:{args.gpu}" if torch.cuda.is_available() else "cpu")
    print(f"[robustness] perturbation={args.perturbation} level={args.level} "
          f"param={SEVERITY[args.perturbation][args.level - 1]} ckpt={args.ckpt}")

    model = build_model(args.arch)
    load_info = load_ckpt(model, args.ckpt)
    model.to(device).eval()

    demographics = load_demographics(args.demographics_csv)

    dataset = PerturbedAVLip(args.real_list_path, args.fake_list_path,
                             args.perturbation, args.level, args.seed)
    loader = DataLoader(
        dataset, batch_size=args.batch_size, shuffle=False,
        num_workers=args.loader_workers, pin_memory=torch.cuda.is_available(),
        collate_fn=custom_collate,
        persistent_workers=args.loader_workers > 0,
        prefetch_factor=2 if args.loader_workers > 0 else None,
    )

    all_scores, all_labels, all_paths = [], [], []
    with torch.inference_mode():
        for imgs, crops, labels, paths in tqdm(
                loader, desc=f"{args.perturbation}/L{args.level}", leave=False):
            imgs = imgs.to(device)
            crops = [[t.to(device) for t in sc] for sc in crops]
            features = model.get_features(imgs).to(device)
            logits = model(crops, features)[0]
            prob = torch.sigmoid(logits.flatten()).cpu().numpy()
            all_scores.extend(prob.tolist())
            all_labels.extend(labels.numpy().tolist())
            all_paths.extend(paths)

    # ----- clip-level aggregation by basename -----
    bag_scores = collections.defaultdict(list)
    bag_meta = {}
    for path, lab, sc in zip(all_paths, all_labels, all_scores):
        basename = _extract_basename(path)
        bag_scores[basename].append(sc)
        if basename not in bag_meta:
            mid = _extract_model_id(path, lab)
            demo = demographics.get(basename, {"gender": "", "race4": "", "age_group": ""})
            bag_meta[basename] = {"label": int(lab), "model_id": mid, **demo}

    clip_keys = sorted(bag_scores)
    clip_scores = np.array([float(np.mean(bag_scores[k])) for k in clip_keys])
    clip_labels = np.array([bag_meta[k]["label"] for k in clip_keys])
    clip_models = [bag_meta[k]["model_id"] for k in clip_keys]
    clip_demos  = {d: [bag_meta[k][d] for k in clip_keys] for d in DEMO_DIMS}

    result = {
        "perturbation": args.perturbation,
        "level": args.level,
        "param": SEVERITY[args.perturbation][args.level - 1],
        "n_clips": len(clip_keys),
        "n_samples": len(all_scores),
    }

    # overall (clip-level)
    o = _metrics_block(clip_labels.tolist(), clip_scores.tolist())
    o["Accuracy"] = o["Accuracy@0.50"]
    result["overall_clip"] = o

    # per-fake-vs-real (clip-level)
    real_idx = [i for i, y in enumerate(clip_labels) if y == 0]
    real_scores = clip_scores[real_idx].tolist()
    real_labels = clip_labels[real_idx].tolist()

    fake_models = sorted({m for m, l in zip(clip_models, clip_labels) if l == 1})
    per_fake = {}
    for fm in fake_models:
        idxs = [i for i, (m, l) in enumerate(zip(clip_models, clip_labels))
                if m == fm and l == 1]
        joint_s = clip_scores[idxs].tolist() + real_scores
        joint_l = clip_labels[idxs].tolist() + real_labels
        block = _metrics_block(joint_l, joint_s)
        block["Accuracy"] = block["Accuracy@0.50"]
        per_fake[fm] = block
    result["per_fake_vs_real"] = per_fake

    # fairness (whole test, clip-level)
    result["fairness_overall"] = {}
    for d in DEMO_DIMS:
        groups = clip_demos[d]
        valid = [i for i, g in enumerate(groups) if g]
        if not valid:
            continue
        fb = compute_fairness(
            [clip_labels[i] for i in valid],
            [clip_scores[i] for i in valid],
            [groups[i] for i in valid],
        )
        result["fairness_overall"][d] = fb

    # ----- console summary -----
    print(f"\n[{args.perturbation} L{args.level}]  overall_clip "
          f"AUROC={_fmt4(o['AUROC'])} AP={_fmt4(o['AP'])} Acc={_fmt4(o['Accuracy'])} "
          f"Acc@EER={_fmt4(o['Acc@EER'])} TPR@1%FPR={_fmt4(o['TPR@FPR=1%'])} "
          f"TPR@0.1%FPR={_fmt4(o['TPR@FPR=0.1%'])}  "
          f"(n_clips={result['n_clips']} n_samples={result['n_samples']})")
    for fm, blk in per_fake.items():
        print(f"  [{fm}+Real] AUROC={_fmt4(blk['AUROC'])} AP={_fmt4(blk['AP'])} "
              f"Acc={_fmt4(blk['Accuracy'])} Acc@EER={_fmt4(blk['Acc@EER'])}")
    for d in DEMO_DIMS:
        fb = result["fairness_overall"].get(d)
        if fb:
            print(f"  fairness[{d}] F_FPR={fb['F_FPR']:.2f} F_MEO={fb['F_MEO']:.2f} "
                  f"F_DP={fb['F_DP']:.2f} F_OAE={fb['F_OAE']:.2f}")

    # ----- save / append json -----
    if args.save_json:
        os.makedirs(os.path.dirname(args.save_json) or ".", exist_ok=True)
        existing = []
        if os.path.exists(args.save_json):
            try:
                with open(args.save_json) as f:
                    blob = json.load(f)
                existing = blob.get("runs", []) if isinstance(blob, dict) else []
            except Exception:
                existing = []
        run = {
            "ckpt": args.ckpt,
            "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"),
            "load_info": load_info,
            "real_list_path": args.real_list_path,
            "fake_list_path": args.fake_list_path,
            "demographics_csv": args.demographics_csv,
            "seed": args.seed,
            **result,
        }
        existing.append(run)
        with open(args.save_json, "w") as f:
            json.dump({"runs": existing}, f, indent=2, default=float)
        print(f"\n>>> Appended run to {args.save_json}")


if __name__ == "__main__":
    main()