src/methods/cta_ablation.py

"""CTA Ablation Study Module.

All ablation variants are controlled by a single ``ablation_variant`` string
in the config, so we only need ONE extra method file and ONE extra config file.

Supported variants
------------------
Full ablation table (8 dimensions × multiple settings):

[A] Detection signal (classifier input features)
  A1  full              -- Full CTA (baseline, all features)
  A2  no_asym           -- Remove asymmetry score from classifier input
  A3  no_ltotal         -- Remove L_total from classifier input
  A4  asym_only         -- Classifier input = [asym] only
  A5  pooled_only       -- Classifier input = [v_pooled, a_pooled] only (no predictor signals)
  A6  flip_sign         -- asym := L_AV − L_VA (opposite sign of default). Also flips
                           the margin ranking loss so it still pushes fakes AWAY from
                           reals in the new sign convention.
  A7  abs_asym          -- asym := |L_VA − L_AV|. Loses directional forensic signature
                           but tests whether magnitude alone is sufficient.

[B] Predictor training strategy
  B1  real_only         -- Predictors trained on real samples only (default)
  B2  all_samples       -- Predictors trained on ALL samples (real + fake)
  B3  no_predictor      -- Predictors frozen at random init (test if learned physics matter)

[C] Loss function ablation
  C1  no_loss_asym      -- Remove margin ranking loss (loss_asym = 0)
  C2  no_loss_aux       -- Remove cross-generator consistency loss (loss_aux = 0)
  C3  no_loss_av        -- Remove A->V predictor loss (only train V->A)
  C4  no_loss_va        -- Remove V->A predictor loss (only train A->V)
  C5  no_detach         -- Do NOT detach l_av/l_va before classifier (allow gradient flow)

[D] Predictor architecture
  D1  depth_1           -- Predictor depth = 1 (shallow)
  D2  depth_4           -- Predictor depth = 4 (default)
  D3  depth_8           -- Predictor depth = 8 (deep)
  D4  mlp_predictor     -- Replace Transformer Decoder with MLP predictor
  D5  shared_predictor  -- A->V and V->A share the same predictor weights

[E] Backbone freeze ratio (video)
  E1  video_freeze_0    -- Video backbone fully unfrozen (freeze_ratio=0.0)
  E2  video_freeze_07   -- Video backbone freeze_ratio=0.7 (default)
  E3  video_freeze_10   -- Video backbone fully frozen (freeze_ratio=1.0)

[F] Backbone freeze ratio (audio)
  F1  audio_freeze_0    -- Audio backbone fully unfrozen (freeze_ratio=0.0)
  F2  audio_freeze_08   -- Audio backbone freeze_ratio=0.8 (default)

[G] Data strategy
  G1  aligned_crop      -- Force video frames and audio to be time-aligned
  G2  random_crop       -- Independent random crop (default)

[M] Modality / Cross-modal role ablation
  M1  video_only            -- Single-modality baseline: video features only, no predictor.
  M2  audio_only            -- Single-modality baseline: audio features only, no predictor.
  M3  intra_modal           -- Replace cross-modal preds with V->V and A->A self-reconstruction.
                               Tests whether the asymmetry signal is *cross-modal*-specific.
  M4  noise_target          -- Replace target tokens with Gaussian noise inside the predictor
                               loss; predictor cannot learn anything meaningful. Tests whether
                               the asymmetry signal is genuine causal-direction information.
  M5  shuffle_pair          -- In-batch shuffle of audio so each video is paired with someone
                               else's audio. Breaks sample correspondence but keeps modalities.
                               Tests whether *correspondence* matters (vs. raw modality stats).
  M6  drop_audio_infer      -- Train as full CTA; at inference, zero-out audio features.
                               Reveals how much the predictor signal depends on audio at test.
  M7  drop_video_infer      -- Train as full CTA; at inference, zero-out video features.
                               Reveals how much the predictor signal depends on video at test.
"""
from __future__ import annotations

import random
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


# Variant groups for quick lookup
_GROUP_M_SET = {
    "M1_video_only", "M2_audio_only", "M3_intra_modal",
    "M4_noise_target", "M5_shuffle_pair",
    "M6_drop_audio_infer", "M7_drop_video_infer",
}


# ---------------------------------------------------------------------------
# Direction-convention helper (used by A6_flip_sign / A7_abs_asym)
# ---------------------------------------------------------------------------
def _compute_asym(variant: str, l_av: torch.Tensor, l_va: torch.Tensor) -> torch.Tensor:
    """Return per-sample asymmetry score in the sign convention required by variant.

    Default: s_asym = L_VA − L_AV.  With this convention fakes score negatively
    and the margin loss pushes  asym_fake < asym_real.

    A6_flip_sign: s_asym = L_AV − L_VA.  Sign is opposite; margin loss must be
    flipped so it still pushes fakes AWAY from reals (see loss code below).

    A7_abs_asym: s_asym = |L_VA − L_AV|.  Directional information erased.
    """
    if variant == "A6_flip_sign":
        return l_av - l_va
    if variant == "A7_abs_asym":
        return (l_va - l_av).abs()
    return l_va - l_av


# ---------------------------------------------------------------------------
# MLP predictor (for variant D4)
# ---------------------------------------------------------------------------
class MLPPredictor(nn.Module):
    """Simple MLP cross-modal predictor: pools source tokens, then projects
    to target dimension. No cross-attention, no sequence modeling."""

    def __init__(self, src_dim: int, tgt_dim: int, hidden_dim: int = 512, dropout: float = 0.1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(src_dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim),
            nn.GELU(),
            nn.Dropout(dropout),
        )
        self.out = nn.Linear(hidden_dim, tgt_dim)

    def forward(self, src_tokens: torch.Tensor, tgt_query: torch.Tensor) -> torch.Tensor:
        # src_tokens: (B, T_s, D_s) -> pool -> (B, D_s)
        src_pooled = src_tokens.mean(dim=1)          # (B, D_s)
        h = self.net(src_pooled)                     # (B, hidden)
        pred_pooled = self.out(h)                    # (B, D_t)
        # Broadcast to match tgt_query shape (B, T_t, D_t)
        return pred_pooled.unsqueeze(1).expand_as(tgt_query)


# ---------------------------------------------------------------------------
# Core model
# ---------------------------------------------------------------------------
class CTAAblationModel(nn.Module):
    def __init__(self, method_cfg, backbone_cfg):
        super().__init__()
        variant = method_cfg.ablation_variant

        # ---- video backbone ------------------------------------------------
        # Variants E1/E2/E3 override freeze_ratio. M2 (audio-only) skips video.
        video_freeze = backbone_cfg.freeze_ratio
        if variant == "E1_video_freeze_0":
            video_freeze = 0.0
        elif variant == "E3_video_freeze_10":
            video_freeze = 1.0
        # E2 uses default from backbone_cfg

        # M1 only needs video; M2 only needs audio. Other M variants need both.
        # We always build BOTH backbones for code simplicity, except M2 skips
        # video and M1 skips audio (saves memory in single-modality runs).
        self.has_video = variant != "M2_audio_only"
        self.has_audio = variant != "M1_video_only"

        if self.has_video:
            self.video = VideoBackbone(
                hf_id=backbone_cfg.hf_id,
                freeze_ratio=video_freeze,
            )
            vD = self.video.feature_dim
        else:
            self.video = None
            vD = backbone_cfg.get("feature_dim", 768)  # placeholder

        # ---- audio backbone ------------------------------------------------
        audio_freeze = method_cfg.audio_backbone.freeze_ratio
        if variant == "F1_audio_freeze_0":
            audio_freeze = 0.0
        # F2 uses default

        if self.has_audio:
            self.audio = AudioBackbone(
                hf_id=method_cfg.audio_backbone.hf_id,
                freeze_ratio=audio_freeze,
            )
            aD = self.audio.feature_dim
        else:
            self.audio = None
            aD = method_cfg.audio_backbone.feature_dim  # 768

        # ---- predictor depth override (D1/D2/D3) ---------------------------
        pred_depth = method_cfg.av_predictor.depth
        if variant == "D1_depth_1":
            pred_depth = 1
        elif variant == "D3_depth_8":
            pred_depth = 8
        # D2 uses default depth from config

        # ---- build predictors ----------------------------------------------
        # M1/M2: no predictor at all (single-modality baseline).
        # M3: V->V and A->A self-reconstruction (same shape, but src_dim==tgt_dim).
        # M4/M5/M6/M7: same shape as default cross-modal (A->V, V->A).
        if variant in ("M1_video_only", "M2_audio_only"):
            self.av_pred = None
            self.va_pred = None
        elif variant == "M3_intra_modal":
            # Self-reconstruction predictors. We rebind:
            #   self.av_pred  = V->V  (was A->V)
            #   self.va_pred  = A->A  (was V->A)
            self.av_pred = CrossModalPredictor(
                src_dim=vD, tgt_dim=vD,
                hidden_dim=method_cfg.av_predictor.hidden_dim,
                depth=pred_depth,
                heads=method_cfg.av_predictor.heads,
                dropout=method_cfg.av_predictor.dropout,
            )
            self.va_pred = CrossModalPredictor(
                src_dim=aD, tgt_dim=aD,
                hidden_dim=method_cfg.va_predictor.hidden_dim,
                depth=pred_depth,
                heads=method_cfg.va_predictor.heads,
                dropout=method_cfg.va_predictor.dropout,
            )
        elif variant == "D4_mlp_predictor":
            self.av_pred = MLPPredictor(
                src_dim=aD, tgt_dim=vD,
                hidden_dim=method_cfg.av_predictor.hidden_dim,
                dropout=method_cfg.av_predictor.dropout,
            )
            self.va_pred = MLPPredictor(
                src_dim=vD, tgt_dim=aD,
                hidden_dim=method_cfg.va_predictor.hidden_dim,
                dropout=method_cfg.va_predictor.dropout,
            )
        elif variant == "D5_shared_predictor":
            # Shared predictor: both directions use the same weights.
            # Since src/tgt dims are both 768, this is valid.
            shared = CrossModalPredictor(
                src_dim=vD, tgt_dim=aD,
                hidden_dim=method_cfg.av_predictor.hidden_dim,
                depth=pred_depth,
                heads=method_cfg.av_predictor.heads,
                dropout=method_cfg.av_predictor.dropout,
            )
            self.av_pred = shared
            self.va_pred = shared
        else:
            self.av_pred = CrossModalPredictor(
                src_dim=aD, tgt_dim=vD,
                hidden_dim=method_cfg.av_predictor.hidden_dim,
                depth=pred_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=pred_depth,
                heads=method_cfg.va_predictor.heads,
                dropout=method_cfg.va_predictor.dropout,
            )

        # Variant B3: freeze predictors at random init
        if variant == "B3_no_predictor":
            for p in self.av_pred.parameters():
                p.requires_grad_(False)
            for p in self.va_pred.parameters():
                p.requires_grad_(False)

        # ---- classifier head -----------------------------------------------
        # Input dim depends on variant
        if variant == "M1_video_only":
            cls_in_dim = vD                               # only pooled video
        elif variant == "M2_audio_only":
            cls_in_dim = aD                               # only pooled audio
        elif variant == "A4_asym_only":
            cls_in_dim = 1
        elif variant == "A5_pooled_only":
            cls_in_dim = vD + aD
        elif variant == "A2_no_asym":
            cls_in_dim = vD + aD + 1                      # pooled_v + pooled_a + L_total
        elif variant == "A3_no_ltotal":
            cls_in_dim = vD + aD + 1                      # pooled_v + pooled_a + asym
        else:
            # Full / B / C / D / E / F / G / M3 / M4 / M5 / M6 / M7
            cls_in_dim = vD + aD + 2                      # pooled_v + pooled_a + asym + L_total

        self.cls = nn.Sequential(
            nn.Linear(cls_in_dim, method_cfg.classifier.hidden),
            nn.GELU(),
            nn.Dropout(method_cfg.classifier.dropout),
            nn.Linear(method_cfg.classifier.hidden, 1),
        )

        self.variant = variant
        self.vD = vD
        self.aD = aD

    # -----------------------------------------------------------------------
    def predict_pairs(self, video: torch.Tensor, audio: torch.Tensor, training: bool = True):
        """Compute predictor outputs and per-sample asymmetry score.

        For Group M variants:
          M1/M2 -> not called (training_step / score handle them directly).
          M3    -> intra-modal self-reconstruction. l_av := L_VV, l_va := L_AA.
                   asym := L_AA - L_VV (still "harder direction minus easier").
          M4    -> target tokens replaced by Gaussian noise (same shape).
          M5    -> in-batch shuffle of audio so video[i] is paired with audio[perm[i]].
                   Only applied during training; at inference we keep the natural pairing
                   so that asym reflects what the model learned about MISALIGNED pairs.
          M6/M7 -> same forward as full; the dropout is applied in `score()` or in
                   `training_step()` separately for clarity.
        """
        variant = self.variant

        v = self.video(video)
        a = self.audio(audio)

        if variant == "M3_intra_modal":
            # Intra-modal self-reconstruction.
            # av_pred: V->V (input=v tokens, target=v tokens)
            # va_pred: A->A (input=a tokens, target=a tokens)
            v_pred = self.av_pred(src_tokens=v["tokens"], tgt_query=v["tokens"])
            a_pred = self.va_pred(src_tokens=a["tokens"], tgt_query=a["tokens"])

            l_av = F.mse_loss(v_pred, v["tokens"], reduction="none").mean(dim=[1, 2])
            l_va = F.mse_loss(a_pred, a["tokens"], reduction="none").mean(dim=[1, 2])
            asym = _compute_asym(variant, l_av, l_va)
            return v, a, l_av, l_va, asym

        if variant == "M5_shuffle_pair" and training:
            # In-batch shuffle of audio so video[i] is paired with audio[perm[i]].
            B = a["tokens"].size(0)
            if B > 1:
                # Random non-identity permutation.
                perm = torch.randperm(B, device=a["tokens"].device)
                a_tokens = a["tokens"][perm]
                a_pooled_shuf = a["pooled"][perm]
            else:
                a_tokens = a["tokens"]
                a_pooled_shuf = a["pooled"]
            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)
            l_av = F.mse_loss(v_pred, v["tokens"], reduction="none").mean(dim=[1, 2])
            l_va = F.mse_loss(a_pred, a_tokens, reduction="none").mean(dim=[1, 2])
            asym = _compute_asym(variant, l_av, l_va)
            # Replace a["pooled"] with the shuffled one so the classifier sees the
            # exact pair we trained on this step.
            a = {"pooled": a_pooled_shuf, "tokens": a_tokens}
            return v, a, l_av, l_va, asym

        # Default cross-modal forward
        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"])

        if variant == "M4_noise_target":
            # Replace target tokens with Gaussian noise of matching shape/scale.
            # The predictor is forced to match noise; signal collapses.
            v_target = torch.randn_like(v["tokens"])
            a_target = torch.randn_like(a["tokens"])
        else:
            v_target = v["tokens"]
            a_target = a["tokens"]

        l_av = F.mse_loss(v_pred, v_target, reduction="none").mean(dim=[1, 2])  # (B,)
        l_va = F.mse_loss(a_pred, a_target, reduction="none").mean(dim=[1, 2])  # (B,)

        asym = _compute_asym(variant, l_av, l_va)
        return v, a, l_av, l_va, asym

    # -----------------------------------------------------------------------
    def classify(self, v_pooled, a_pooled, l_av, l_va):
        asym = _compute_asym(self.variant, l_av, l_va)
        variant = self.variant

        if variant == "M1_video_only":
            feat = v_pooled
        elif variant == "M2_audio_only":
            feat = a_pooled
        elif variant == "A4_asym_only":
            feat = asym.unsqueeze(-1)
        elif variant == "A5_pooled_only":
            feat = torch.cat([v_pooled, a_pooled], dim=-1)
        elif variant == "A2_no_asym":
            feat = torch.cat([v_pooled, a_pooled, (l_av + l_va).unsqueeze(-1)], dim=-1)
        elif variant == "A3_no_ltotal":
            feat = torch.cat([v_pooled, a_pooled, asym.unsqueeze(-1)], dim=-1)
        else:
            # Full / all other variants: use complete feature set
            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


# ---------------------------------------------------------------------------
# Lightning Module
# ---------------------------------------------------------------------------
class CTAAblationLitModule(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 = CTAAblationModel(method_cfg, backbone_cfg)
        self.variant = method_cfg.ablation_variant

    # -----------------------------------------------------------------------
    def _training_step_single_modality(self, batch):
        """Path for M1_video_only and M2_audio_only.

        These variants do NOT use a predictor, so there is no l_av / l_va /
        asym / loss_aux. We only optimize the classifier on a pooled feature.
        """
        labels = batch["label"].long()

        if self.variant == "M1_video_only":
            v = self.model.video(batch["video"])
            v_pooled = v["pooled"]
            # Build a zero "audio" so classify() shape logic still works for callers,
            # but classify() detects M1 and only uses v_pooled.
            a_pooled = torch.zeros(
                v_pooled.size(0), self.model.aD,
                device=v_pooled.device, dtype=v_pooled.dtype,
            )
        else:  # M2_audio_only
            a = self.model.audio(batch["audio"])
            a_pooled = a["pooled"]
            v_pooled = torch.zeros(
                a_pooled.size(0), self.model.vD,
                device=a_pooled.device, dtype=a_pooled.dtype,
            )

        # Dummy l_av / l_va; classify() will not use them for M1/M2.
        zero = torch.zeros(v_pooled.size(0), device=v_pooled.device, dtype=v_pooled.dtype)
        logits = self.model.classify(v_pooled, a_pooled, zero, zero)
        loss_cls = F.binary_cross_entropy_with_logits(logits.squeeze(-1), labels.float())

        loss = self.method_cfg.loss.cls_weight * loss_cls

        self.log_dict({
            "train/loss": loss,
            "train/loss_cls": loss_cls,
        }, prog_bar=False, on_step=True, on_epoch=True, sync_dist=True)

        return loss

    # -----------------------------------------------------------------------
    def training_step(self, batch, batch_idx):
        if batch is None:
            return None

        variant = self.variant

        # Single-modality baselines have a separate, simpler path.
        if variant in ("M1_video_only", "M2_audio_only"):
            return self._training_step_single_modality(batch)

        video = batch["video"]
        audio = batch["audio"]
        labels = batch["label"].long()

        # ---- M6/M7: zero-out one modality during training so the model learns
        #           a single-modality decision rule but still has all the
        #           predictor scaffolding. This makes the comparison clean.
        if variant == "M6_drop_audio_infer":
            audio = torch.zeros_like(audio)
        elif variant == "M7_drop_video_infer":
            video = torch.zeros_like(video)

        # ---- forward -------------------------------------------------------
        v, a, l_av, l_va, asym = self.model.predict_pairs(video, audio, training=True)

        is_real = (labels == 0).float()
        denom_r = is_real.sum().clamp(min=1.0)

        # ---- loss_av / loss_va (predictor losses) --------------------------
        # Variant B2: train predictors on ALL samples
        # Variant B3: predictors frozen, no predictor loss
        # Variant C3: skip loss_av (only train V->A)
        # Variant C4: skip loss_va (only train A->V)
        # Variant M4: target is noise; we still compute loss_av/loss_va so the
        #             optimizer is well-defined, but on real samples only.
        # Variant M5: misaligned pair; loss is on (v[i], a[perm[i]]) — this
        #             is valid because we're testing whether the predictor can
        #             still extract a useful asym signal under shuffled pairs.
        if variant == "B3_no_predictor":
            loss_av = l_av.new_zeros([])
            loss_va = l_va.new_zeros([])
        elif variant == "B2_all_samples":
            loss_av = l_av.mean()
            loss_va = l_va.mean()
        elif variant == "C3_no_loss_av":
            loss_av = l_av.new_zeros([])
            loss_va = (l_va * is_real).sum() / denom_r
        elif variant == "C4_no_loss_va":
            loss_av = (l_av * is_real).sum() / denom_r
            loss_va = l_va.new_zeros([])
        else:
            # Default (real_only): B1 / A* / C1 / C2 / C5 / D* / E* / F* / G* / M3-M7
            loss_av = (l_av * is_real).sum() / denom_r
            loss_va = (l_va * is_real).sum() / denom_r

        # ---- loss_asym (margin ranking) ------------------------------------
        asym_r = asym[labels == 0]
        asym_f = asym[labels == 1]
        if variant == "C1_no_loss_asym":
            loss_asym = asym.new_zeros([])
        elif asym_r.numel() > 0 and asym_f.numel() > 0:
            if variant in {"A6_flip_sign", "A7_abs_asym"}:
                # Under these variants, the empirically expected direction is
                # asym_fake > asym_real (opposite of default). Flip the ranking
                # loss so it stays dormant when the direction is correct and
                # kicks in only when the model reverses it.
                loss_asym = F.relu(asym_r.mean() - asym_f.mean())
            else:
                loss_asym = F.relu(asym_f.mean() - asym_r.mean())
        else:
            loss_asym = asym.new_zeros([])

        # ---- classifier loss -----------------------------------------------
        # Variant C5: do NOT detach l_av/l_va (allow gradient to flow back)
        if variant == "C5_no_detach":
            logits = self.model.classify(v["pooled"], a["pooled"], l_av, l_va)
        else:
            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 loss --------------------------------
        loss_aux = asym.new_zeros([])
        if variant != "C2_no_loss_aux":
            if self.method_cfg.aux_crossgen.enabled and "alt_video" in batch:
                alt_v_in = batch["alt_video"]
                alt_a_in = batch["alt_audio"]
                if variant == "M6_drop_audio_infer":
                    alt_a_in = torch.zeros_like(alt_a_in)
                elif variant == "M7_drop_video_infer":
                    alt_v_in = torch.zeros_like(alt_v_in)
                _, _, l_av2, l_va2, asym2 = self.model.predict_pairs(
                    alt_v_in, alt_a_in, training=True,
                )
                loss_aux = F.mse_loss(asym, asym2)

        # ---- total loss ----------------------------------------------------
        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:
        variant = self.variant

        # ---- M1/M2: single-modality inference ------------------------------
        if variant == "M1_video_only":
            v = self.model.video(batch["video"])
            v_pooled = v["pooled"]
            a_pooled = torch.zeros(
                v_pooled.size(0), self.model.aD,
                device=v_pooled.device, dtype=v_pooled.dtype,
            )
            zero = torch.zeros(v_pooled.size(0), device=v_pooled.device, dtype=v_pooled.dtype)
            logits = self.model.classify(v_pooled, a_pooled, zero, zero)
            return torch.sigmoid(logits.squeeze(-1))

        if variant == "M2_audio_only":
            a = self.model.audio(batch["audio"])
            a_pooled = a["pooled"]
            v_pooled = torch.zeros(
                a_pooled.size(0), self.model.vD,
                device=a_pooled.device, dtype=a_pooled.dtype,
            )
            zero = torch.zeros(a_pooled.size(0), device=a_pooled.device, dtype=a_pooled.dtype)
            logits = self.model.classify(v_pooled, a_pooled, zero, zero)
            return torch.sigmoid(logits.squeeze(-1))

        video = batch["video"]
        audio = batch["audio"]

        # ---- M6/M7: inference-time modality dropout ------------------------
        if variant == "M6_drop_audio_infer":
            audio = torch.zeros_like(audio)
        elif variant == "M7_drop_video_infer":
            video = torch.zeros_like(video)

        v, a, l_av, l_va, asym = self.model.predict_pairs(video, audio, training=False)
        logits = self.model.classify(v["pooled"], a["pooled"], l_av, l_va)
        return torch.sigmoid(logits.squeeze(-1))