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))