"""Spatial-AST 音频前端的共享组件（torchlibrosa shim + conv/patch 工具）。 Vendored from SLAM-LLM's `src/slam_llm/models/SpatialAST/SpatialAST.py`. 原 `BinauralEncoder`（双声道编码器）与 `load_spatial_ast` 已随 ST-Audio Encoder 改造移除——本模块现在只保留被 `foa_features` / `st_audio_encoder` 复用的部件： `_STFTBuffer` / `_LogmelFilterBankBuffer`（STFT/logmel shim）、`conv3x3`、 `PatchEmbed_new`。 torchlibrosa's `STFT` / `LogmelFilterBank` use `nn.Parameter.data = torch.Tensor(...)` assignment in __init__, which crashes inside HF's `init_empty_weights()` and DeepSpeed's `zero.Init()` contexts (the parameter has been moved to meta device or partitioned, and in-place .data assignment from a real cpu tensor mismatches). We provide drop-in replacements `_STFTBuffer` and `_LogmelFilterBankBuffer` that use `register_buffer` for the (frozen) FFT basis and mel filter — the math is byte-identical to torchlibrosa, only the storage type differs, and buffers are not subject to accelerate's parameter materialisation hook (when `include_buffers=False`, the default). """ import librosa import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from timm.models.layers import to_2tuple # ---------------------------- torchlibrosa-compatible shims ---------------------------- def _dft_matrix(n: int) -> np.ndarray: """Same as torchlibrosa.stft.DFTBase.dft_matrix — returns (n, n) complex.""" x, y = np.meshgrid(np.arange(n), np.arange(n)) omega = np.exp(-2 * np.pi * 1j / n) return np.power(omega, x * y) class _STFTBuffer(nn.Module): """Drop-in replacement for torchlibrosa.stft.STFT using register_buffer. Same fourier-basis math, same windowing, same conv1d compute, same output shape `(batch, 1, time_steps, n_fft//2+1)` — bit-exact with torchlibrosa. """ def __init__(self, n_fft=2048, hop_length=None, win_length=None, window='hann', center=True, pad_mode='reflect', freeze_parameters=True): super().__init__() self.n_fft = n_fft self.center = center self.pad_mode = pad_mode self.win_length = win_length if win_length is not None else n_fft self.hop_length = hop_length if hop_length is not None else int(self.win_length // 4) fft_window = librosa.filters.get_window(window, self.win_length, fftbins=True) fft_window = librosa.util.pad_center(fft_window, size=n_fft) W = _dft_matrix(n_fft) out_channels = n_fft // 2 + 1 real_w = np.real(W[:, :out_channels] * fft_window[:, None]).T[:, None, :] # (n_freq, 1, n_fft) imag_w = np.imag(W[:, :out_channels] * fft_window[:, None]).T[:, None, :] self.register_buffer("conv_real_weight", torch.tensor(real_w, dtype=torch.float32)) self.register_buffer("conv_imag_weight", torch.tensor(imag_w, dtype=torch.float32)) def forward(self, input): # input: (B, T) x = input.unsqueeze(1) # (B, 1, T) if self.center: x = F.pad(x, (self.n_fft // 2, self.n_fft // 2), mode=self.pad_mode) # Buffers stay fp32 by design (numerical stability of FFT basis); cast to # input dtype on the fly so bf16 / fp16 audio flows work without `model.to` # having converted them. w_real = self.conv_real_weight.to(x.dtype) w_imag = self.conv_imag_weight.to(x.dtype) real = F.conv1d(x, w_real, stride=self.hop_length) # (B, n_freq, T') imag = F.conv1d(x, w_imag, stride=self.hop_length) real = real[:, None, :, :].transpose(2, 3) # (B, 1, T', n_freq) imag = imag[:, None, :, :].transpose(2, 3) return real, imag class _LogmelFilterBankBuffer(nn.Module): """Drop-in replacement for torchlibrosa.stft.LogmelFilterBank using register_buffer. Same mel matrix (librosa.filters.mel), same matmul, same power_to_db. `self.melW` attribute exposed for code that reaches into it (e.g. FOAFeatureExtractor uses it to apply mel to intensity features). """ def __init__(self, sr=22050, n_fft=2048, n_mels=64, fmin=0.0, fmax=None, is_log=True, ref=1.0, amin=1e-10, top_db=80.0, freeze_parameters=True): super().__init__() self.is_log = is_log self.ref = ref self.amin = amin self.top_db = top_db if fmax is None: fmax = sr // 2 mel_np = librosa.filters.mel( sr=sr, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax, ).T # (n_freq, n_mels) self.register_buffer("melW", torch.tensor(mel_np, dtype=torch.float32)) def forward(self, input): # input: (..., n_freq) → output: (..., n_mels) # Cast melW to input dtype on the fly (same rationale as _STFTBuffer). mel = torch.matmul(input, self.melW.to(input.dtype)) if not self.is_log: return mel log_spec = 10.0 * torch.log10(torch.clamp(mel, min=self.amin)) log_spec = log_spec - 10.0 * float(np.log10(max(self.amin, self.ref))) if self.top_db is not None: log_spec = torch.clamp(log_spec, min=log_spec.max().item() - self.top_db) return log_spec # ---------------------------- shared conv / patch-embed helpers ---------------------------- def conv3x3(in_channels, out_channels, stride=1): "3x3 convolution with padding" return nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False) class PatchEmbed_new(nn.Module): """Flexible image-to-patch embedding (overlapping patches supported).""" def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, stride=10): super().__init__() img_size = to_2tuple(img_size) patch_size = to_2tuple(patch_size) stride = to_2tuple(stride) self.img_size = img_size self.patch_size = patch_size self.in_chans = in_chans self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=stride) # Conv2d output shape (padding=0, dilation=1, groups=1): # out = floor((in - kernel) / stride) + 1 # We compute it analytically rather than running a dummy forward in # __init__ — under DeepSpeed zero.Init the Conv2d weight has shape [0] # (partitioned) and forward crashes with "weight should have at least # three dimensions". h = (img_size[0] - patch_size[0]) // stride[0] + 1 w = (img_size[1] - patch_size[1]) // stride[1] + 1 self.patch_hw = (h, w) self.num_patches = h * w def get_output_shape(self, img_size): # Kept for backward-compat with any external caller; not used in __init__. return self.proj(torch.randn(1, self.in_chans, img_size[0], img_size[1])).shape def forward(self, x): x = self.proj(x) x = x.flatten(2) x = x.transpose(1, 2) return x