""" Whisper encoder with HGA-modulated self-attention. ================================================================================ V1 (2A): HGA now includes a Möbius bias term that breaks exp/log cancellation, making the curvature c a real, gradient-bearing parameter. Modulation formula (per Q/K/V projection, per layer): W_HGA = log_0^c( ( diag(s) ⊗_c exp_0^c(W_ref) ) ⊕_c exp_0^c(b) ) Without b, the chain reduces to s ⊙ W_ref (DoRA-like, c does nothing — this is the SER paper's formula). With b ≠ 0, the Möbius addition step entangles c with the norms of q and b in a way that cannot be algebraically cancelled. Key properties: - b tiny-random-init (std=1e-4) → init is numerically ≈ s ⊙ W_ref but with b ≠ 0, so c receives gradient signal from step 0. (Zero-init would freeze c at a saddle ∂L/∂c = 0.) - All layers use the same (c_min, c_init, c_max) bounds; layer-aware bucketing removed because b makes c a real parameter that learns its own per-layer optimum without artificial floors. ================================================================================ """ import math import logging from typing import List, Dict, Any, Optional import torch import torch.nn as nn import torch.nn.functional as F from .hyperbolic_ops import ( exp_map_zero, log_map_zero, mobius_add, clamp_norm, LearnableCurvature, ) logger = logging.getLogger(__name__) class HGALinear(nn.Module): """Drop-in replacement for nn.Linear that applies HGA weight modulation with a Möbius bias term. Stores a frozen reference weight W_ref. At forward time: p = exp_0^c(W_ref) # rows → ball v = log_0^c(p) # = W_ref (id) q = exp_0^c(diag(s) · v) = exp_0^c(s ⊙ W_ref)# Möbius scale b_pt = exp_0^c(b) # bias → ball r = q ⊕_c b_pt # Möbius add — c becomes essential W_mod = log_0^c(r) # ball → tangent output = x @ W_mod^T + bias_orig Trainable: s (d_in,), b (d_in,), c (via curvature_module) Frozen: W_ref, bias_orig (from pretrained Whisper) """ def __init__(self, original_linear: nn.Linear, s: nn.Parameter, b: nn.Parameter, curvature_module: nn.Module): super().__init__() # Frozen reference weight (rows are the d_out "row vectors" in R^{d_in}) self.register_buffer("W_ref", original_linear.weight.data.clone().float()) # Keep original bias (frozen but used in forward) if original_linear.bias is not None: self.register_buffer("bias", original_linear.bias.data.clone()) else: self.bias = None # Learnable HGA parameters (shared from the per-layer container) self.s = s self.b = b self.curvature = curvature_module def forward(self, x: torch.Tensor) -> torch.Tensor: c = self.curvature().float() # Step 1: rows of W_ref → Poincaré ball p = exp_map_zero(self.W_ref, c) # (d_out, d_in) # Step 2: Möbius diagonal scaling diag(s) ⊗_c p # = exp_0^c( s ⊙ log_0^c(p) ) = exp_0^c( s ⊙ W_ref ) v = log_map_zero(p, c) # = W_ref (cancellation) v_scaled = v * self.s.float().unsqueeze(0) q = exp_map_zero(v_scaled, c) # (d_out, d_in) in ball # Step 3: Möbius bias addition — broadcasts b across d_out rows b_pt = exp_map_zero(self.b.float(), c) # (d_in,) in ball b_pt_b = b_pt.unsqueeze(0).expand_as(q) # (d_out, d_in) r = mobius_add(q, b_pt_b, c) # (d_out, d_in) r = clamp_norm(r, c) # numerical safety # Step 4: log_map back to tangent → modulated weight W_mod = log_map_zero(r, c) # (d_out, d_in) with torch.amp.autocast("cuda", enabled=False): return F.linear(x.float(), W_mod.float(), self.bias.float() if self.bias is not None else None).to(x.dtype) class HGAWhisperEncoder(nn.Module): """Whisper encoder with HGA-modulated Q/K/V on all 32 layers. Architecture: 1. Load Whisper encoder, freeze every original parameter. 2. For each layer, create one shared LearnableCurvature c^(l) plus three pairs of (s, b) — for q_proj, k_proj, v_proj. 3. Replace q_proj/k_proj/v_proj with HGALinear wrappers that compute the modulated weight on the fly. 4. Register forward hooks to capture multi-scale features for EMCA. Trainable params per layer: 3 × d_model (s_Q, s_K, s_V) + 3 × d_model (b_Q, b_K, b_V) + 1 (c) = 6 × d_model + 1 For d_model=1280 → 7,681 per layer × 32 layers ≈ 246K total (HGA only). """ output_dim = 1280 output_frame_rate_hz = 50.0 def __init__(self, model_path: str, extract_layers: List[int], num_encoder_layers: int = 32, hga_c_init: float = 1.0, hga_c_min: float = 0.001, hga_c_max: float = 8.0, hga_b_init_std: float = 1.0e-4): super().__init__() self.extract_layers = sorted(extract_layers) self.num_encoder_layers = num_encoder_layers self.hga_c_init = hga_c_init self.hga_c_min = hga_c_min self.hga_c_max = hga_c_max self.hga_b_init_std = hga_b_init_std # --- Load Whisper encoder --- from transformers import WhisperModel whisper = WhisperModel.from_pretrained(model_path) self.encoder = whisper.encoder del whisper # Freeze ALL original encoder parameters for p in self.encoder.parameters(): p.requires_grad = False # --- Create HGA params and inject into Whisper --- self.hga_layers = nn.ModuleList() d = self.output_dim for i, layer in enumerate(self.encoder.layers): attn = layer.self_attn # Shared curvature for Q/K/V of this layer curvature = LearnableCurvature( init_value=hga_c_init, c_min=hga_c_min, c_max=hga_c_max ) # Diagonal scaling: identity (s=1) at init → first-step output ≈ W_ref s_q = nn.Parameter(torch.ones(d)) s_k = nn.Parameter(torch.ones(d)) s_v = nn.Parameter(torch.ones(d)) # Möbius bias: tiny random init so b ≠ 0 from step 0 and ∂L/∂c ≠ 0 b_q = nn.Parameter(torch.randn(d) * hga_b_init_std) b_k = nn.Parameter(torch.randn(d) * hga_b_init_std) b_v = nn.Parameter(torch.randn(d) * hga_b_init_std) # Replace q/k/v_proj with HGA-modulated versions attn.q_proj = HGALinear(attn.q_proj, s_q, b_q, curvature) attn.k_proj = HGALinear(attn.k_proj, s_k, b_k, curvature) attn.v_proj = HGALinear(attn.v_proj, s_v, b_v, curvature) # Container so optimizer sees these params cont = nn.Module() cont.curvature = curvature cont.s_q, cont.s_k, cont.s_v = s_q, s_k, s_v cont.b_q, cont.b_k, cont.b_v = b_q, b_k, b_v self.hga_layers.append(cont) logger.info( f"Whisper encoder: {num_encoder_layers} layers, " f"all Q/K/V wrapped in HGALinear " f"(c_init={hga_c_init}, c_min={hga_c_min}, c_max={hga_c_max}, " f"b_std={hga_b_init_std})" ) # --- Feature capture hooks --- self._features: Dict[int, torch.Tensor] = {} self._hooks = [] for idx, layer in enumerate(self.encoder.layers): if idx in self.extract_layers: self._hooks.append( layer.register_forward_hook(self._make_hook(idx)) ) def _make_hook(self, layer_idx: int): def hook_fn(module, input, output): self._features[layer_idx] = ( output[0] if isinstance(output, tuple) else output ) return hook_fn def forward(self, mel_input: torch.Tensor) -> List[torch.Tensor]: """Run Whisper with HGA-modulated attention. Args: mel_input: (B, n_mels, T_mel) Returns: List of (B, T, 1280) tensors, one per extract_layer (sorted). """ encoder_dtype = self.encoder.layer_norm.weight.dtype mel = mel_input.to(dtype=encoder_dtype) self._features.clear() _ = self.encoder(mel) features = [] for ln in self.extract_layers: if ln not in self._features: raise RuntimeError( f"Layer {ln} not captured. Got: {sorted(self._features.keys())}" ) features.append(self._features[ln]) return features def num_audio_frames(self, audio_samples_16khz: int) -> int: return min(math.ceil(audio_samples_16khz / 320), 1500) # ---- Diagnostics ---- def get_hga_diagnostics(self) -> Dict[str, float]: """Per-layer scalars logged to TensorBoard.""" diag = {} for i, hga in enumerate(self.hga_layers): diag[f"hga/c_L{i}"] = hga.curvature().item() diag[f"hga/s_q_mean_L{i}"] = hga.s_q.data.mean().item() diag[f"hga/s_v_mean_L{i}"] = hga.s_v.data.mean().item() # b norms — key indicator: if these stay ~0, c won't learn diag[f"hga/b_q_norm_L{i}"] = hga.b_q.data.norm().item() diag[f"hga/b_k_norm_L{i}"] = hga.b_k.data.norm().item() diag[f"hga/b_v_norm_L{i}"] = hga.b_v.data.norm().item() return diag def get_curvatures_summary(self) -> str: """Compact c-per-layer string for log lines (grouped 8 per row).""" vals = [f"{hga.curvature().item():.4f}" for hga in self.hga_layers] groups = [] for i in range(0, len(vals), 8): groups.append("/".join(vals[i:i+8])) return " | ".join(groups) def get_b_norm_summary(self) -> str: """Compact b_q-per-layer norm string (grouped 8 per row). Used to verify the 'b grows → c learns' training dynamic.""" vals = [f"{hga.b_q.data.norm().item():.4f}" for hga in self.hga_layers] groups = [] for i in range(0, len(vals), 8): groups.append("/".join(vals[i:i+8])) return " | ".join(groups)