scripts/analysis/dump_cta_features.py

"""Dump per-sample CTA features for motivation analysis.

Loads a trained CTA checkpoint, runs forward on a dataloader, and dumps
EVERY per-sample quantity needed for the motivation plots in PAPER_MOTIVATION.md:

  * `l_av`      : (N,) MSE of A→V predictor
  * `l_va`      : (N,) MSE of V→A predictor
  * `asym`      : (N,) = l_va - l_av
  * `score`     : (N,) sigmoid(classifier logit), the model's fake probability
  * `label`     : (N,) 0=real, 1=fake
  * `generator` : (N,) string, generator name ("" for real)
  * `basename`  : (N,) string id
  * `r_av`      : (N, vD)  residual feature: mean over tokens of (v_tokens - v_pred)
  * `r_va`      : (N, aD)  residual feature: mean over tokens of (a_tokens - a_pred)

Output: a single .npz file you can `np.load` and pass to `visualize_motivation.py`.

Usage
-----
    # NOTE: ckpt / out / split / max_batches are runtime fields not declared
    # in configs/train.yaml, so they MUST be added with hydra's `+` prefix.
    # Already-declared fields (method / data / ...) use plain `=`.

    python3 scripts/analysis/dump_cta_features.py \
        +ckpt=outputs/cta_ablation_A1_full_20260602_153521/checkpoints/epoch10-valauc1.0000.ckpt \
        method=cta_ablation \
        method.ablation_variant=A1_full \
        data=fairtalking \
        +split=val \
        +out=outputs/analysis/cta_features_oursval.npz \
        +max_batches=null

  Optional overrides:
    method=cta_ablation method.ablation_variant=A1_full   # for ablation ckpts
    data=fairtalking_test_sadtalker  +split=test          # holdout family

  TIP: shell continuations with `\` must NOT have any character after the
  backslash (not even a space) — otherwise the line is broken. The safest
  form is to put everything on a single line.

The script honors the standard hydra overrides used elsewhere in the project.
It assumes 1-GPU single-process inference (no DDP) — this analysis pass is
quick (<10 min for an entire test split) and DDP gather logic is not needed.
"""
from __future__ import annotations

import os
import sys
from pathlib import Path
from typing import Any, Dict, List

import hydra
import numpy as np
import torch
import torch.nn.functional as F
from omegaconf import DictConfig, OmegaConf
from torch.utils.data import DataLoader

# --- silence torch.load weights_only restriction (mirror src/train.py) -----
import lightning_fabric.utilities.cloud_io as _lf_cloud_io
_orig_torch_load = torch.load
def _unsafe_torch_load(*args, **kwargs):
    kwargs["weights_only"] = False
    return _orig_torch_load(*args, **kwargs)
_lf_cloud_io.torch.load = _unsafe_torch_load
torch.load = _unsafe_torch_load

# ensure src/ is importable
sys.path.insert(0, str(Path(__file__).resolve().parents[2]))

from src.data import FairTalkingDataModule  # noqa: E402
from src.methods import build_method        # noqa: E402


@hydra.main(version_base=None, config_path="../../configs", config_name="train")
def main(cfg: DictConfig) -> None:
    # ---- required runtime overrides ----------------------------------------
    ckpt_path = cfg.get("ckpt", None)
    if ckpt_path is None:
        raise SystemExit(
            "Missing `ckpt=...` override. Example:\n"
            "  python3 scripts/analysis/dump_cta_features.py \\\n"
            "      ckpt=outputs/.../epoch08-valauc1.0000.ckpt \\\n"
            "      data=fairtalking out=outputs/analysis/cta_features.npz"
        )
    ckpt_path = str(Path(ckpt_path).resolve())
    out_path = Path(cfg.get("out", "outputs/analysis/cta_features.npz")).resolve()
    out_path.parent.mkdir(parents=True, exist_ok=True)

    split = cfg.get("split", "val")  # "train" / "val" / "test"
    if split not in {"train", "val", "test"}:
        raise SystemExit(f"split must be train/val/test (got {split})")
    max_batches = cfg.get("max_batches", None)
    max_batches = None if max_batches in (None, "null", "None") else int(max_batches)

    # ---- model + data -------------------------------------------------------
    print(f"[dump] ckpt          = {ckpt_path}")
    print(f"[dump] data config   = {cfg.data.name}")
    print(f"[dump] split         = {split}")
    print(f"[dump] out           = {out_path}")
    print(f"[dump] max_batches   = {max_batches}")

    model = build_method(
        method_name=cfg.method.name,
        method_cfg=cfg.method,
        backbone_cfg=cfg.backbone,
        data_cfg=cfg.data,
    )
    print(f"[dump] loading state_dict from ckpt …")
    state = torch.load(ckpt_path, map_location="cpu")
    sd = state.get("state_dict", state)
    missing, unexpected = model.load_state_dict(sd, strict=False)
    if missing:
        print(f"[dump]   {len(missing)} missing keys (first 5): {missing[:5]}")
    if unexpected:
        print(f"[dump]   {len(unexpected)} unexpected keys (first 5): {unexpected[:5]}")

    device = "cuda" if torch.cuda.is_available() else "cpu"
    model.to(device).eval()

    dm = FairTalkingDataModule(
        data_cfg=cfg.data,
        return_paired=False,
    )
    # In test-only configs (use_*_test), setup('fit') would crash; pick stage
    # based on requested split.
    stage = "fit" if split in {"train", "val"} else "test"
    dm.setup(stage=stage)

    if split == "train":
        loader = dm.train_dataloader()
    elif split == "val":
        loader = dm.val_dataloader()
    else:
        loader = dm.test_dataloader()

    # ---- forward + dump -----------------------------------------------------
    L_AV: List[np.ndarray] = []
    L_VA: List[np.ndarray] = []
    ASYM: List[np.ndarray] = []
    SCORE: List[np.ndarray] = []
    LABEL: List[np.ndarray] = []
    GEN: List[str] = []
    BN: List[str] = []
    R_AV: List[np.ndarray] = []
    R_VA: List[np.ndarray] = []

    n_batches = len(loader) if max_batches is None else min(max_batches, len(loader))
    print(f"[dump] forwarding {n_batches} batches …")

    with torch.no_grad():
        for bi, batch in enumerate(loader):
            if batch is None:
                continue
            if max_batches is not None and bi >= max_batches:
                break
            video = batch["video"].to(device, non_blocking=True)
            audio = batch["audio"].to(device, non_blocking=True)
            labels = batch["label"].long()
            metas = batch.get("meta", [{}] * video.size(0))

            # The CTAModel / CTAAblationModel both expose predict_pairs that
            # returns (v, a, l_av, l_va, asym).  We ALSO need the raw token
            # residuals for t-SNE, so we re-do the forward here in-line.
            v = model.model.video(video)
            a = model.model.audio(audio)
            v_pred = model.model.av_pred(src_tokens=a["tokens"], tgt_query=v["tokens"])
            a_pred = model.model.va_pred(src_tokens=v["tokens"], tgt_query=a["tokens"])

            # per-sample MSE (mean over tokens & channels)
            l_av = F.mse_loss(v_pred, v["tokens"], reduction="none").mean(dim=[1, 2])  # (B,)
            l_va = F.mse_loss(a_pred, a["tokens"], reduction="none").mean(dim=[1, 2])  # (B,)
            asym = l_va - l_av

            # residuals for t-SNE: per-sample mean of (target - pred) over tokens
            r_av = (v["tokens"] - v_pred).mean(dim=1)  # (B, vD)
            r_va = (a["tokens"] - a_pred).mean(dim=1)  # (B, aD)

            # classifier score
            logits = model.model.classify(v["pooled"], a["pooled"], l_av, l_va)
            score = torch.sigmoid(logits.squeeze(-1))

            L_AV.append(l_av.cpu().float().numpy())
            L_VA.append(l_va.cpu().float().numpy())
            ASYM.append(asym.cpu().float().numpy())
            SCORE.append(score.cpu().float().numpy())
            LABEL.append(labels.numpy().astype(np.int64))
            R_AV.append(r_av.cpu().float().numpy())
            R_VA.append(r_va.cpu().float().numpy())
            for m in metas:
                GEN.append(str(m.get("generator", "")) if isinstance(m, dict) else "")
                BN.append(str(m.get("basename", "")) if isinstance(m, dict) else "")

            if (bi + 1) % 20 == 0:
                print(f"[dump]   batch {bi+1}/{n_batches}  "
                      f"l_av≈{np.concatenate(L_AV).mean():.4f}  "
                      f"l_va≈{np.concatenate(L_VA).mean():.4f}")

    L_AV_arr  = np.concatenate(L_AV)
    L_VA_arr  = np.concatenate(L_VA)
    ASYM_arr  = np.concatenate(ASYM)
    SCORE_arr = np.concatenate(SCORE)
    LABEL_arr = np.concatenate(LABEL)
    R_AV_arr  = np.concatenate(R_AV, axis=0)
    R_VA_arr  = np.concatenate(R_VA, axis=0)
    GEN_arr   = np.asarray(GEN, dtype=object)
    BN_arr    = np.asarray(BN, dtype=object)

    print(f"[dump] collected {len(L_AV_arr)} samples")
    print(f"[dump]   reals = {(LABEL_arr == 0).sum()}, fakes = {(LABEL_arr == 1).sum()}")
    print(f"[dump]   l_av  : mean(real)={L_AV_arr[LABEL_arr==0].mean():.4f}  "
                       f"mean(fake)={L_AV_arr[LABEL_arr==1].mean():.4f}")
    print(f"[dump]   l_va  : mean(real)={L_VA_arr[LABEL_arr==0].mean():.4f}  "
                       f"mean(fake)={L_VA_arr[LABEL_arr==1].mean():.4f}")
    print(f"[dump]   asym  : mean(real)={ASYM_arr[LABEL_arr==0].mean():.4f}  "
                       f"mean(fake)={ASYM_arr[LABEL_arr==1].mean():.4f}")

    np.savez_compressed(
        out_path,
        l_av=L_AV_arr, l_va=L_VA_arr, asym=ASYM_arr,
        score=SCORE_arr, label=LABEL_arr,
        generator=GEN_arr, basename=BN_arr,
        r_av=R_AV_arr, r_va=R_VA_arr,
        meta=np.array({
            "ckpt": ckpt_path,
            "data_cfg": cfg.data.name,
            "split": split,
            "n_samples": int(len(L_AV_arr)),
        }, dtype=object),
    )
    print(f"[dump] wrote {out_path}  ({out_path.stat().st_size/1e6:.1f} MB)")


if __name__ == "__main__":
    main()