src/methods/cta.py

from __future__ import annotations

from typing import Any, Dict

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

from ..models.backbones import VideoBackbone, AudioBackbone, CrossModalPredictor
from .base import BaseMethod


class CTAModel(nn.Module):
    def __init__(self, method_cfg, backbone_cfg):
        super().__init__()
        self.video = VideoBackbone(
            hf_id=backbone_cfg.hf_id, freeze_ratio=backbone_cfg.freeze_ratio,
        )
        self.audio = AudioBackbone(
            hf_id=method_cfg.audio_backbone.hf_id,
            freeze_ratio=method_cfg.audio_backbone.freeze_ratio,
        )
        vD = self.video.feature_dim
        aD = self.audio.feature_dim

        # two predictors
        self.av_pred = CrossModalPredictor(
            src_dim=aD, tgt_dim=vD,
            hidden_dim=method_cfg.av_predictor.hidden_dim,
            depth=method_cfg.av_predictor.depth,
            heads=method_cfg.av_predictor.heads,
            dropout=method_cfg.av_predictor.dropout,
        )
        self.va_pred = CrossModalPredictor(
            src_dim=vD, tgt_dim=aD,
            hidden_dim=method_cfg.va_predictor.hidden_dim,
            depth=method_cfg.va_predictor.depth,
            heads=method_cfg.va_predictor.heads,
            dropout=method_cfg.va_predictor.dropout,
        )

        # classifier on [asym_score, pooled_v, pooled_a]
        in_dim = vD + aD + 2
        self.cls = nn.Sequential(
            nn.Linear(in_dim, method_cfg.classifier.hidden),
            nn.GELU(),
            nn.Dropout(method_cfg.classifier.dropout),
            nn.Linear(method_cfg.classifier.hidden, 1),
        )

    # ------------------------------------------------------------------
    def predict_pairs(self, video, audio):
        v = self.video(video)       # pooled/tokens
        a = self.audio(audio)

        # per-sample predictor losses (MSE on token embeddings)
        v_pred = self.av_pred(src_tokens=a["tokens"], tgt_query=v["tokens"])
        a_pred = self.va_pred(src_tokens=v["tokens"], tgt_query=a["tokens"])

        # per-sample loss (mean over tokens/channels, not over batch)
        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          # (B,)
        return v, a, l_av, l_va, asym

    def classify(self, v_pooled, a_pooled, l_av, l_va):
        asym = l_va - l_av
        feat = torch.cat([v_pooled, a_pooled, asym.unsqueeze(-1), (l_av + l_va).unsqueeze(-1)], dim=-1)
        return self.cls(feat)       # (B, 1) logits


class CTALitModule(BaseMethod):
    def __init__(self, method_cfg, backbone_cfg, data_cfg):
        super().__init__(method_cfg=method_cfg, backbone_cfg=backbone_cfg, data_cfg=data_cfg)
        self.model = CTAModel(method_cfg, backbone_cfg)

    # ------------------------------------------------------------------
    def training_step(self, batch, batch_idx):
        if batch is None:
            return None
        video = batch["video"]      # (B, T, 3, H, W) -> rearrange below
        audio = batch["audio"]
        labels = batch["label"].long()

        # VideoMAE expects (B, T, C, H, W)
        v, a, l_av, l_va, asym = self.model.predict_pairs(video, audio)

        is_real = (labels == 0).float()
        # predictor losses only on reals (avoids learning fake artifacts as "audio")
        denom_r = is_real.sum().clamp(min=1.0)
        loss_av = (l_av * is_real).sum() / denom_r
        loss_va = (l_va * is_real).sum() / denom_r

        # asymmetry discrimination: real should have large gap, fake small
        # we use a pairwise margin on gap, so the head itself gets signal
        # (we make sure this signal is weak so predictors don't collapse)
        asym_r = asym[labels == 0]
        asym_f = asym[labels == 1]
        if asym_r.numel() > 0 and asym_f.numel() > 0:
            margin = 0.0
            loss_asym = F.relu(margin + asym_f.mean() - asym_r.mean())
        else:
            loss_asym = asym.new_zeros([])

        # classifier head (full batch)
        logits = self.model.classify(
            v["pooled"], a["pooled"], l_av.detach(), l_va.detach(),
        )
        loss_cls = F.binary_cross_entropy_with_logits(logits.squeeze(-1), labels.float())

        # cross-generator auxiliary: asym of two fake clips sharing (ref,audio)
        # should be close (both are fake distortions of the same ground-truth physics)
        loss_aux = asym.new_zeros([])
        if self.method_cfg.aux_crossgen.enabled and "alt_video" in batch:
            alt_v = batch["alt_video"]
            alt_a = batch["alt_audio"]
            _, _, l_av2, l_va2, asym2 = self.model.predict_pairs(alt_v, alt_a)
            # only pairs that are fake (because alt_* exists only for fakes)
            loss_aux = F.mse_loss(asym, asym2)

        loss = (
            self.method_cfg.loss.av_weight * loss_av
            + self.method_cfg.loss.va_weight * loss_va
            + self.method_cfg.loss.asym_weight * loss_asym
            + self.method_cfg.loss.cls_weight * loss_cls
            + self.method_cfg.aux_crossgen.weight * loss_aux
        )

        self.log_dict({
            "train/loss": loss,
            "train/loss_av": loss_av,
            "train/loss_va": loss_va,
            "train/loss_asym": loss_asym,
            "train/loss_cls": loss_cls,
            "train/loss_aux": loss_aux,
            "train/asym_mean_real": asym_r.mean() if asym_r.numel() > 0 else torch.zeros_like(loss),
            "train/asym_mean_fake": asym_f.mean() if asym_f.numel() > 0 else torch.zeros_like(loss),
        }, prog_bar=False, on_step=True, on_epoch=True, sync_dist=True)

        return loss

    # ------------------------------------------------------------------
    @torch.no_grad()
    def score(self, batch: Dict[str, Any]) -> torch.Tensor:
        v, a, l_av, l_va, asym = self.model.predict_pairs(batch["video"], batch["audio"])
        logits = self.model.classify(v["pooled"], a["pooled"], l_av, l_va)
        return torch.sigmoid(logits.squeeze(-1))