| import numpy as np |
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| import torchaudio |
|
|
| from htsat import create_htsat_model |
| from seldnet import SELDModel |
| from text_encoder import RobertaTextEncoder |
|
|
| class AudioEncoder(nn.Module): |
| def __init__(self): |
| super().__init__() |
| self.mel_encoder = create_htsat_model() |
| self.spatial_encoder = SELDModel() |
| self.resampler = torchaudio.transforms.Resample( |
| orig_freq = 16000, |
| new_freq = 48000, |
| ) |
|
|
| self.mel_feature_dim = 1024 |
| self.spatial_feature_dim = 256 |
| |
| def get_output_dim(self): |
| return self.mel_feature_dim + self.spatial_feature_dim |
|
|
| def load_default_state_dict(self): |
| self.mel_encoder.load_default_state_dict() |
| self.spatial_encoder.load_default_state_dict() |
|
|
| def forward(self, x): |
| B = len(x) |
|
|
| mel_encoded = self.mel_encoder({ |
| "waveform": self.resampler((x[:, 0, :] + x[:, 1, :]) / 2) |
| })["embedding"] |
| assert mel_encoded.shape == (B, self.mel_feature_dim), f"{mel_encoded.shape=}" |
|
|
| spatial_encoded = self.spatial_encoder(x) |
| assert spatial_encoded.shape == (B, self.spatial_feature_dim), f"{spatial_encoded.shape=}" |
|
|
| return torch.cat( |
| [mel_encoded, spatial_encoded], |
| dim=1 |
| ) |
|
|
| class CLAPEncoder(nn.Module): |
| def __init__( |
| self, |
| joint_embed_shape: int = 512, |
| ): |
| super().__init__() |
|
|
| self.audio_encoder = AudioEncoder() |
| self.audio_projection = nn.Sequential( |
| nn.Linear(self.audio_encoder.get_output_dim(), joint_embed_shape), |
| nn.ReLU(), |
| nn.Linear(joint_embed_shape, joint_embed_shape), |
| ) |
|
|
| self.text_encoder = RobertaTextEncoder() |
| self.text_projection = nn.Sequential( |
| nn.Linear(512, joint_embed_shape), |
| nn.ReLU(), |
| nn.Linear(joint_embed_shape, joint_embed_shape), |
| ) |
|
|
| self.logit_scale = nn.Parameter(torch.tensor(np.log(1 / (0.07)))) |
|
|
| def load_default_state_dict(self): |
| self.audio_encoder.load_default_state_dict() |
| self.text_encoder.load_default_state_dict() |
|
|
| def load_pretrained(self, url=None): |
| if url is None: |
| url = "https://huggingface.co/sarulab-speech/SpatialCLAP/resolve/main/ckpt/l1proposed-spatial_contrastive-model_epoch_49.pt" |
| ckpt = torch.hub.load_state_dict_from_url(url, map_location="cpu")["model_state_dict"] |
| self.load_state_dict(ckpt) |
|
|
| def embed_audio(self, x): |
| encoded = self.audio_encoder(x) |
| projected_encoded = self.audio_projection(encoded) |
| return F.normalize(projected_encoded, dim=-1) |
| |
| def embed_text(self, x): |
| encoded = self.text_encoder(x) |
| projected_encoded = self.text_projection(encoded) |
| return F.normalize(projected_encoded, dim=-1) |
|
|
| def forward(self, audio=None, text=None): |
| if audio is None: |
| z_audio = None |
| else: |
| z_audio = self.embed_audio(audio) |
| |
| if text is None: |
| z_text = None |
| else: |
| z_text = self.embed_text(text) |
|
|
| return { |
| "audio": z_audio, |
| "text": z_text, |
| } |
|
|
