evaluate_test.py

"""evaluate_test.py

Plain test-set evaluation for LipFD: load a trained ckpt, run inference on
the FairTalking-Bench test split, and report:
  - overall (clip-level): AUROC / AP / Accuracy / Acc@EER / TPR@1%FPR / TPR@0.1%FPR
  - per-fake-vs-real (each fake model paired with all reals)
  - fairness (gender / race4 / age_group): F_FPR, F_MEO, F_DP, F_OAE
Clip-level aggregation: mean prob over all frames sharing the same basename
(e.g. '2358_Real', '1681_Fake').

NO perturbation, NO sweeping — single pass over the test set.

============================================================================
Usage
============================================================================
    cd /apdcephfs_gy4/share_303628665/joywu/research/LipFD
    /opt/conda/envs/LipFD/bin/python evaluate_test.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 \
        --batch_size 16 --loader_workers 4 --gpu 0 \
        --save_json     robustness/test_clean.json
"""

import argparse
import collections
import csv as _csv
import json
import os
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
from evaluate_robustness import (  # noqa: E402  reuse the helpers
    DEMO_DIMS,
    _extract_basename,
    _extract_model_id,
    _metrics_block,
    _fmt4,
    _set_seed,
    load_ckpt,
    compute_fairness,
    load_demographics,
    custom_collate,
)


class TestAVLip(Dataset):
    """Mirrors data.AVLip preprocessing; no perturbation."""

    def __init__(self, real_dir, fake_dir):
        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

    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())
        img = torch.tensor(img_cv, dtype=torch.float32).permute(2, 0, 1)
        # FIX: 5-crop slicing — see evaluate_robustness.py:286 for context.
        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 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("--arch", type=str, default="CLIP:ViT-L/14")
    p.add_argument("--batch_size", type=int, default=16)
    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,
                   help="Output JSON. Overwrites if exists (single test = single object, not a list).")
    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"[test] 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 = TestAVLip(args.real_list_path, args.fake_list_path)
    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="test", 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 = {
        "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
    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
    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[test]  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 json (single test = one object, not a list) -----
    if args.save_json:
        os.makedirs(os.path.dirname(args.save_json) or ".", exist_ok=True)
        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,
        }
        with open(args.save_json, "w") as f:
            json.dump(run, f, indent=2, default=float)
        print(f"\n>>> Saved test result to {args.save_json}")


if __name__ == "__main__":
    main()