File size: 6,140 Bytes
1ef5ba8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | 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))
|