src/methods/radr.py

"""RADR: Reference-Anchored Diffusion Residual.

Hypothesis
----------
Pretrained generative video models (VideoMAE, SVD, CogVideoX) were trained
on billions of natural video frames. They embed a 'universal natural video
prior' that is NOT biased by FairTalking-Bench's three real-video sources.

For each input video we compute a reconstruction or inversion *residual*
against a frozen reference model. Fake videos generated by different
architectures than the reference (Sonic, Float, JoyVASA, etc.) will leave
systematic residual signatures that real videos do not.

Why this avoids the 'one-class on dataset real videos' trap
-----------------------------------------------------------
We never fit the reference model on FairTalking-Bench. The only trainable
parameters are a small classifier head on top of the residual. Quality
imbalance across CelebV-HQ / DFDC / HDTF does not contaminate the anchor.

Implementation (default path: VideoMAE)
---------------------------------------
1. Feed video through VideoMAE with high MAE mask ratio (0.75).
2. Read reconstruction logits vs. input patches; residual = |x - x_hat|.
3. Also keep decoder hidden features at multiple layers as 'residual
   statistics' (mean, var, higher moments over spatial-temporal dim).
4. MLP head -> BCE.

An optional heavier path uses Stable Video Diffusion DDIM-inversion;
stubbed out here; flip the cfg to 'svd' to enable. For first-round
training stick to VideoMAE — much faster and robust.
"""
from __future__ import annotations

from typing import Any, Dict

import torch
import torch.nn as nn
import torch.nn.functional as F

from .base import BaseMethod


class VideoMAEResidual(nn.Module):
    """Wraps VideoMAEForPreTraining to extract reconstruction residuals."""

    def __init__(self, hf_id: str, mask_ratio: float = 0.75):
        super().__init__()
        from transformers import VideoMAEForPreTraining
        self.model = VideoMAEForPreTraining.from_pretrained(hf_id)
        self.feature_dim = self.model.config.hidden_size
        self.decoder_dim = self.model.config.decoder_hidden_size
        self.mask_ratio = mask_ratio
        for p in self.model.parameters():
            p.requires_grad_(False)
        self.model.eval()

    @torch.no_grad()
    def forward(self, video: torch.Tensor) -> dict:
        """video: (B, T, 3, H, W) normalized for VideoMAE.
        Returns residual feature summary as a (B, D_feat) tensor."""
        B, T, C, H, W = video.shape
        # mask: deterministic per forward (no random seed shuffle per call)
        n_patches = (T // self.model.config.tubelet_size) \
            * (H // self.model.config.patch_size) \
            * (W // self.model.config.patch_size)
        n_masked = int(n_patches * self.mask_ratio)
        bool_masked_pos = torch.zeros((B, n_patches), dtype=torch.bool, device=video.device)
        # use first n_masked positions; deterministic
        bool_masked_pos[:, :n_masked] = True

        out = self.model(pixel_values=video, bool_masked_pos=bool_masked_pos)
        logits = out.logits                     # (B, n_masked, patch_dim)

        # ground-truth masked patches (normalized pixels)
        with torch.no_grad():
            patch_size = self.model.config.patch_size
            tub = self.model.config.tubelet_size
            # build patchified ground-truth (from model's patchify util)
            patchified = self._patchify(video, patch_size, tub)  # (B, n_patches, P*P*3*tub)
            target = patchified[bool_masked_pos].view(B, n_masked, -1)

        residual = logits - target               # (B, n_masked, patch_dim)

        # summary statistics per sample
        mean = residual.mean(dim=[1, 2])
        var = residual.var(dim=[1, 2])
        abs_mean = residual.abs().mean(dim=[1, 2])
        abs_max = residual.abs().amax(dim=[1, 2])
        l2_mean = residual.pow(2).mean(dim=[1, 2])
        # per-channel moments of final-layer decoder features
        summary = torch.stack([mean, var, abs_mean, abs_max, l2_mean], dim=-1)  # (B, 5)

        # also encoder pooled representation for extra info
        pooled = out.hidden_states[-1].mean(dim=1) if getattr(out, "hidden_states", None) is not None else residual.mean(dim=[1, 2]).unsqueeze(-1).expand(-1, self.feature_dim)

        return {"summary": summary, "pooled": pooled}

    @staticmethod
    def _patchify(video: torch.Tensor, patch_size: int, tubelet: int) -> torch.Tensor:
        """Replicate VideoMAE's patchification.  (B, T, 3, H, W) -> (B, N, P*P*3*tub)."""
        B, T, C, H, W = video.shape
        x = video.reshape(B, T // tubelet, tubelet, C, H, W)
        x = x.permute(0, 1, 4, 5, 2, 3, 6).contiguous() if False else x
        # simpler: unfold spatial
        x = video                                                 # (B, T, C, H, W)
        x = x.unfold(1, tubelet, tubelet)                          # (B, T', C, H, W, tub)
        x = x.unfold(3, patch_size, patch_size)                    # (B, T', C, H/P, W, tub, P)
        x = x.unfold(4, patch_size, patch_size)                    # (B, T', C, H/P, W/P, tub, P, P)
        x = x.permute(0, 1, 3, 4, 2, 5, 6, 7).contiguous()         # (B, T', Hp, Wp, C, tub, P, P)
        N = x.shape[1] * x.shape[2] * x.shape[3]
        patch_dim = C * tubelet * patch_size * patch_size
        return x.view(B, N, patch_dim)


class ResidualHead(nn.Module):
    def __init__(self, in_dim: int, hidden_dim: int, depth: int, dropout: float):
        super().__init__()
        layers = []
        d = in_dim
        for _ in range(depth):
            layers += [nn.Linear(d, hidden_dim), nn.GELU(), nn.Dropout(dropout)]
            d = hidden_dim
        self.mlp = nn.Sequential(*layers)
        self.out_dim = hidden_dim

    def forward(self, x): return self.mlp(x)


class RADRLitModule(BaseMethod):
    def __init__(self, method_cfg, backbone_cfg, data_cfg):
        super().__init__(method_cfg=method_cfg, backbone_cfg=backbone_cfg, data_cfg=data_cfg)
        assert method_cfg.anchor.type == "videomae", \
            "SVD path not implemented in the first round; set anchor.type=videomae"
        self.anchor = VideoMAEResidual(
            hf_id=method_cfg.anchor.hf_id,
            mask_ratio=method_cfg.anchor.mask_ratio,
        )
        in_dim = 5 + self.anchor.feature_dim
        self.head = ResidualHead(
            in_dim=in_dim,
            hidden_dim=method_cfg.residual_head.hidden_dim,
            depth=method_cfg.residual_head.depth,
            dropout=method_cfg.residual_head.dropout,
        )
        self.cls = nn.Sequential(
            nn.Linear(self.head.out_dim, method_cfg.classifier.hidden),
            nn.GELU(),
            nn.Dropout(method_cfg.classifier.dropout),
            nn.Linear(method_cfg.classifier.hidden, 1),
        )

    def _forward_logits(self, video: torch.Tensor) -> torch.Tensor:
        out = self.anchor(video)
        feat = torch.cat([out["summary"], out["pooled"]], dim=-1)
        h = self.head(feat)
        return self.cls(h)

    def training_step(self, batch, batch_idx):
        if batch is None:
            return None
        logits = self._forward_logits(batch["video"])
        labels = batch["label"].long()
        loss_cls = F.binary_cross_entropy_with_logits(
            logits.squeeze(-1), labels.float(),
        )
        # regularizer: keep head weights small so it has to use anchor signal
        reg = sum((p ** 2).sum() for p in self.head.parameters())
        loss = self.method_cfg.loss.cls_weight * loss_cls \
            + self.method_cfg.loss.residual_reg_weight * reg * 1e-6
        self.log_dict({
            "train/loss": loss, "train/loss_cls": loss_cls, "train/reg": reg,
        }, on_step=True, on_epoch=True, sync_dist=True)
        return loss

    @torch.no_grad()
    def score(self, batch: Dict[str, Any]) -> torch.Tensor:
        logits = self._forward_logits(batch["video"])
        return torch.sigmoid(logits.squeeze(-1))