src/models/backbones.py

"""Video & audio backbone wrappers.

Video: VideoMAE-base (MCG-NJU/videomae-base)   — 16-frame 224x224 ViT
Audio: Wav2Vec2-base (facebook/wav2vec2-base-960h)

Both wrappers support partial freezing (for finetuning sanity on small data).
"""
from __future__ import annotations

from typing import Optional

import torch
import torch.nn as nn


# -----------------------------------------------------------------------------
# Video
# -----------------------------------------------------------------------------
class VideoBackbone(nn.Module):
    """Wrap a HuggingFace VideoMAE / similar ViT.

    Input  : (B, T, 3, H, W) already normalized.
    Output : { 'pooled': (B, D), 'tokens': (B, T, D) }
    """

    def __init__(
        self,
        hf_id: str = "MCG-NJU/videomae-base",
        freeze_ratio: float = 0.0,
    ) -> None:
        super().__init__()
        from transformers import VideoMAEModel
        self.model = VideoMAEModel.from_pretrained(hf_id)
        self.feature_dim = self.model.config.hidden_size
        self._apply_freeze(freeze_ratio)

    def _apply_freeze(self, ratio: float) -> None:
        if ratio <= 0:
            return
        blocks = self.model.encoder.layer
        n_freeze = int(len(blocks) * ratio)
        for b in blocks[:n_freeze]:
            for p in b.parameters():
                p.requires_grad_(False)
        # patch embed / pos embed: freeze when ratio > 0
        for n, p in self.model.named_parameters():
            if n.startswith("embeddings"):
                p.requires_grad_(False)

    def forward(self, video: torch.Tensor) -> dict:
        # VideoMAE expects (B, T, C, H, W)
        out = self.model(pixel_values=video, output_hidden_states=False)
        tokens = out.last_hidden_state        # (B, T*N_patches, D)
        pooled = tokens.mean(dim=1)
        return {"pooled": pooled, "tokens": tokens}


# -----------------------------------------------------------------------------
# Audio
# -----------------------------------------------------------------------------
class AudioBackbone(nn.Module):
    """Wav2Vec2 wrapper.

    Input  : (B, num_samples) 16kHz raw wave.
    Output : { 'pooled': (B, D), 'tokens': (B, T_a, D) }
    """

    def __init__(
        self,
        hf_id: str = "facebook/wav2vec2-base-960h",
        freeze_ratio: float = 0.5,
    ) -> None:
        super().__init__()
        from transformers import Wav2Vec2Model
        self.model = Wav2Vec2Model.from_pretrained(hf_id)
        self.feature_dim = self.model.config.hidden_size
        self._apply_freeze(freeze_ratio)

    def _apply_freeze(self, ratio: float) -> None:
        if ratio <= 0:
            return
        # wav2vec2: freeze feature_extractor + first ratio of encoder.layers
        for p in self.model.feature_extractor.parameters():
            p.requires_grad_(False)
        layers = self.model.encoder.layers
        n_freeze = int(len(layers) * ratio)
        for layer in layers[:n_freeze]:
            for p in layer.parameters():
                p.requires_grad_(False)

    def forward(self, wav: torch.Tensor) -> dict:
        out = self.model(wav)
        tokens = out.last_hidden_state        # (B, T_a, D)
        pooled = tokens.mean(dim=1)
        return {"pooled": pooled, "tokens": tokens}


# -----------------------------------------------------------------------------
# Utility: small transformer block for cross-modal predictors
# -----------------------------------------------------------------------------
class CrossModalPredictor(nn.Module):
    """Given a source-modality token seq and a target-modality token seq,
    predict the target from the source via cross-attention. Training loss is
    MSE on the target token embeddings (teacher-forcing, no autoregression)."""

    def __init__(
        self,
        src_dim: int,
        tgt_dim: int,
        hidden_dim: int = 512,
        depth: int = 4,
        heads: int = 8,
        dropout: float = 0.1,
    ) -> None:
        super().__init__()
        self.src_proj = nn.Linear(src_dim, hidden_dim)
        self.tgt_proj = nn.Linear(tgt_dim, hidden_dim)

        layer = nn.TransformerDecoderLayer(
            d_model=hidden_dim,
            nhead=heads,
            dim_feedforward=hidden_dim * 4,
            dropout=dropout,
            batch_first=True,
            norm_first=True,
        )
        self.decoder = nn.TransformerDecoder(layer, num_layers=depth)
        self.out = nn.Linear(hidden_dim, tgt_dim)

    def forward(self, src_tokens: torch.Tensor, tgt_query: torch.Tensor) -> torch.Tensor:
        src = self.src_proj(src_tokens)
        tgt = self.tgt_proj(tgt_query)
        h = self.decoder(tgt=tgt, memory=src)
        return self.out(h)