File size: 4,722 Bytes
54d2b91 | 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 | """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)
|