spade_unrolled.py

"""
spade_unrolled.py  —  SPADE Unrolled  (Algorithm Unrolling + Context Encoder)
================================================================================

Replaces the fixed S-SPADE solver (v12) with a learned parameter predictor.

Architecture
------------

  Input (limited audio frame + K context frames)
       ↓
  SpectralFeatureExtractor
    • log-mel spectrogram (n_mels=32) per frame
    • short-time loudness proxy (RMS in dB)
    → shape: (B, K+1, n_mels+1)
       ↓
  ContextEncoder (causal GRU)
    • 2-layer GRU, hidden_size=128
    • Only K previous frames are seen (strict causality)
    → h_t: (B, 128)
       ↓
  ParameterHead  (linear → 5 outputs per frame)
    • lambda_lf   : soft-threshold for LF bins (≥ 0)
    • lambda_hf   : soft-threshold for HF bins (≥ 0)
    • delta_factor: scales delta_db    ∈ [0.5, 2.0]
    • gmax_factor : scales max_gain_db ∈ [0.5, 2.0]
    • eps_factor  : scales convergence eps ∈ [0.5, 2.0]
       ↓
  UnrolledADMM   (K_unroll=8 fixed layers, fully differentiable)
    Each layer:
      1. Analysis:     z = frana(x, frame)          — DCT / RDFT
      2. Soft-thresh:  z̃ = S_λ(z + u)              — stratified LF/HF
      3. Synthesis:    Dv = frsyn(z̃ - u, frame, M)  — reconstruction
      4. Projection:   pDv = proj_Γ(Dv, yc, masks, g_max)
      5. Residual:     z ← z̃ - u - frana(Dv - pDv, frame)
      6. Dual update:  u ← u + z - z̃
    →  x̂ = frsyn(z_K, frame, M)
       ↓
  Output: restored audio frame (B, M)

Key differences from v12 (classical SPADE)
-------------------------------------------
• Hard thresholding H_k (L0)  →  differentiable soft thresholding S_λ (L1 proxy)
• Fixed hyperparameters       →  predicted per-frame by ContextEncoder
• Fixed iteration count       →  exactly K_unroll unrolled layers (no convergence loop)
• Global sparsity level k     →  independent LF/HF soft-threshold budgets

Transform operators  (GPU-compatible, differentiable)
------------------------------------------------------
The DCT-II / RDFT analysis-synthesis operators from spade_declip_v12 are
re-implemented in PyTorch so gradients flow through them.  Numerically they
match scipy to float32 precision.

Projection operator
-------------------
proj_Γ is already differentiable (clamp + max/min).  Gradients flow through
the Icp / Icm branches; Ir samples are pinned (zero gradient, correct).

WOLA (Weighted Overlap-Add) integration
----------------------------------------
The model processes individual frames.  The full WOLA loop lives in
SPADEUnrolledInference which wraps UnrolledSPADE with frame extraction +
accumulation.  Training uses individual frames to allow per-sample gradient
computation without materialising the full signal in the graph.

References
----------
[1] Gregor & LeCun, "Learning Fast Approximations of Sparse Coding", ICML 2010.
[2] Adler et al., "Learned Primal-Dual Reconstruction", IEEE TMI 2018.
[3] Kitić et al., "SPADE", LVA/ICA 2015 (arXiv:1506.01830).
[4] Záviška et al., "Revisiting SPADE", 2018 (arXiv:1807.03612).
"""

from __future__ import annotations

import math
from dataclasses import dataclass, field
from typing import Literal, Optional, Tuple

import numpy as np

try:
    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    _TORCH_OK = True
except ImportError:
    _TORCH_OK = False
    raise ImportError("PyTorch is required for spade_unrolled.py  (pip install torch)")


# =============================================================================
# Config dataclass
# =============================================================================

@dataclass
class UnrolledConfig:
    """All hyperparameters for the SPADE-Unrolled model."""

    # ── Signal / transform ────────────────────────────────────────────────
    # Defaults from run_smart_sweep.py rank-1 result:
    #   window=2048, hop=512  (score=0.916, the best-performing WOLA config)
    window_length:  int   = 2048          # M — samples per WOLA frame
    hop_length:     int   = 512           # a — WOLA hop
    frame:          Literal["dct", "rdft"] = "rdft"  # transform type
    sample_rate:    int   = 44100

    # ── Unrolling ─────────────────────────────────────────────────────────
    # K_unroll=4: literatura su algorithm unrolling (LISTA, ALISTA, ISTA-Net)
    # mostra 3-5 layer come punto ottimale. Con K=8 e soft-thresh, il prodotto
    # dei Jacobiani attraverso le dead zones → grad ≈ 0 al GRU.
    K_unroll: int = 4                     # number of ADMM layers per frame

    # ── Context encoder ───────────────────────────────────────────────────
    K_context:    int = 8                 # # of past frames fed to GRU
    n_mels:       int = 32                # mel bands for feature extraction
    gru_hidden:   int = 128               # GRU hidden size
    gru_layers:   int = 2                 # GRU depth

    # ── Per-frame parameter bounds ────────────────────────────────────────
    # All outputs of the head are mapped to these ranges.
    #
    # Lambda calibration rationale  (POST-NORMALISATION)
    # ---------------------------------------------------
    # UnrolledADMM normalises each frame by its max DCT coefficient magnitude,
    # so inside the ADMM loop ALL coefficients are in [-1, 1] with max = 1.0.
    # Lambda must therefore be expressed relative to this [0, 1] scale.
    #
    # For a typical kick drum (M=1024, 44100 Hz), the 47 LF bins (≤ 1 kHz)
    # have post-normalisation magnitudes distributed roughly as 1/k:
    #   p25 ≈ 0.028  median ≈ 0.042  p75 ≈ 0.083
    # A lambda in (0.01, 0.50) spans the full meaningful sparsification range
    # from "keep almost all" to "keep only the dominant few" coefficients.
    #
    # Previous range (1e-6, 0.015) was 10-100× too small: even at the maximum
    # λ=0.015, ZERO LF coefficients were ever thresholded → pure all-pass →
    # encoder collapsed to identity (λ→0) because the loss gradient for λ
    # was essentially zero everywhere in (0, 0.015).
    lambda_lf_range:  Tuple[float, float] = (1e-3, 0.50)
    # Upper bound reduced 0.30 → 0.08.
    # For M=2048, sr=44100: HF DCT coefficients (>1kHz, post-normalisation)
    # have typical magnitudes 0.01–0.06.  With λ_hf=0.10 (old upper range median)
    # *all* HF content was zeroed → dsdr_high < −1 dB at every epoch.
    # Cap at 0.08 ensures only sub-noise coefficients are thresholded.
    lambda_hf_range:  Tuple[float, float] = (1e-3, 0.08)
    delta_factor_range:  Tuple[float, float] = (0.5,  1.5)
    # [FIX] Range expanded to (0.5, 2.0): with base_max_gain_db=12 this maps
    # to g_max ∈ [6, 24] dB, giving the Parameter Head full freedom to be
    # conservative in the mid band (g_fac≈0.5 → 6 dB) or aggressive in
    # sub-bass (g_fac≈2.0 → 24 dB) without hitting a hard floor/ceiling.
    # The old (0.85, 1.5) floor was causing mid regression: the model could
    # not reduce gain selectively in the 500–2000 Hz region.
    gmax_factor_range:   Tuple[float, float] = (0.2, 2.0)
    eps_factor_range:    Tuple[float, float] = (0.5,  1.5)

    # ── LF/HF split ──────────────────────────────────────────────────────
    # 8000 Hz is the crossover between:
    #   LF (0–8 kHz): learned reconstruction — this is where v11 S-SPADE
    #                 struggled (kick body, transient fundamental, sub-bass).
    #                 The model learns a content-adaptive sparse prior here.
    #   HF (8–22 kHz): v11 S-SPADE hard thresholding H_k is used unchanged
    #                  via HybridSPADEInference — v11 already recovers HF
    #                  transients (cymbal snap, hi-hat attack) accurately.
    # During training, the model processes the full LF-bandpassed signal.
    # At inference, HybridSPADEInference handles the LR split and v11 HF.
    lf_cutoff_hz: float = 8000.0          # bins below this → LF soft thresh (learned)

    # ── Base SPADE params (encoder predicts *multipliers* of these) ───────
    # Initialised from run_smart_sweep.py rank-1 result (score=0.916):
    #   delta_db=3.5, eps=0.05
    # max_gain_db: sweep rank-1 = 9.0, but Phase-1 training showed the model
    # converges to g_fac≈0.50 (factor range lower bound) which gives 4.5 dB.
    # Using base=6.0 dB instead: g_fac=0.75 (mid-range) → 4.5 dB, and the
    # model can still explore up to 9.0 dB (g_fac=1.5) if needed.
    base_delta_db:    float = 3.5         # rank-1: delta_db
    base_max_gain_db: float = 6.0         # calibrated: g_fac=0.75 → 4.5 dB (Phase-1 optimum)
    base_eps:         float = 0.05        # rank-1: eps

    # lf_delta_db from rank-1 = 1.0 vs delta_db = 3.5  →  ratio ≈ 0.286
    # Used to derive a softer lambda_lf initialisation relative to lambda_hf:
    # lower lf_delta means LF region is recovered more aggressively (fewer
    # coefficients zeroed), so lambda_lf_init < lambda_hf_init.
    lf_delta_ratio:   float = 0.286       # lf_delta_db / delta_db  (rank-1: 1.0/3.5)


# =============================================================================
# Transform operators (differentiable, GPU-compatible)
# =============================================================================

def _dct2(x: torch.Tensor) -> torch.Tensor:
    """Batched orthonormal DCT-II.  x: (..., N) → (..., N).
    Matches scipy.fft.dct(x, type=2, norm='ortho') to float32.
    Makhoul (1980) FFT-based algorithm.
    """
    N = x.shape[-1]
    v = torch.cat([x[..., ::2], x[..., 1::2].flip(-1)], dim=-1)
    V = torch.fft.fft(v.double(), dim=-1)
    k = torch.arange(N, device=x.device, dtype=torch.float64)
    tw = torch.exp(-1j * math.pi * k / (2.0 * N))
    C = (tw * V).real * math.sqrt(2.0 / N)
    C = C.clone()
    C[..., 0] /= math.sqrt(2.0)
    return C.to(x.dtype)


def _idct2(X: torch.Tensor) -> torch.Tensor:
    """Batched orthonormal IDCT-II.  X: (..., N) → (..., N).
    Inverse of _dct2.  BUG-GPU-3 fix included.
    """
    N = X.shape[-1]
    C = X.double() * math.sqrt(N / 2.0)
    C = C.clone()
    C[..., 0] *= math.sqrt(2.0)
    ipart = torch.zeros_like(C)
    ipart[..., 1:] = -C.flip(-1)[..., :-1]
    W = torch.view_as_complex(torch.stack([C, ipart], dim=-1))
    k = torch.arange(N, device=X.device, dtype=torch.float64)
    V = W * torch.exp(1j * math.pi * k / (2.0 * N))
    v = torch.fft.ifft(V, dim=-1).real
    half = (N + 1) // 2
    x = torch.empty_like(v)
    x[..., ::2] = v[..., :half]
    x[..., 1::2] = v[..., half:].flip(-1)
    return x.to(X.dtype)


def frana(x: torch.Tensor, frame: str) -> torch.Tensor:
    """Analysis operator A: (..., M) → (..., P).
    DCT:  P = M;  RDFT: P = 2M.
    Differentiable.
    """
    if frame == "dct":
        return _dct2(x)
    s2 = math.sqrt(2.0)
    return torch.cat([_dct2(x) / s2, _dct2(x.flip(-1)) / s2], dim=-1)


def frsyn(z: torch.Tensor, frame: str, M: int) -> torch.Tensor:
    """Synthesis operator D = A^H: (..., P) → (..., M).
    Adjoint of frana.  BUG-1 fix: flip output (not input) for DST part.
    Differentiable.
    """
    if frame == "dct":
        return _idct2(z)
    s2 = math.sqrt(2.0)
    cos_part = _idct2(z[..., :M]) / s2
    sin_part = _idct2(z[..., M:]).flip(-1) / s2
    return cos_part + sin_part


def build_lf_mask(M: int, frame: str, sr: int, lf_cutoff_hz: float,
                  device: torch.device) -> torch.Tensor:
    """Boolean mask: True for LF bins (freq < lf_cutoff_hz).  Shape: (P,)."""
    P = M if frame == "dct" else 2 * M
    mask = torch.zeros(P, dtype=torch.bool, device=device)
    k_cut = int(math.ceil(lf_cutoff_hz * 2.0 * M / sr))
    k_cut = max(1, min(k_cut, M))
    if frame == "dct":
        mask[:k_cut] = True
    else:
        mask[:k_cut] = True
        mask[M:M + k_cut] = True
    return mask


# =============================================================================
# Differentiable Projection onto Γ
# =============================================================================

def proj_gamma_torch(
    w: torch.Tensor,          # (..., M) — time-domain estimate
    yc: torch.Tensor,         # (..., M) — limited signal
    Ir: torch.Tensor,         # (..., M) bool — reliable
    Icp: torch.Tensor,        # (..., M) bool — positive-clipped
    Icm: torch.Tensor,        # (..., M) bool — negative-clipped
    g_max: float = float("inf"),
) -> torch.Tensor:
    """
    Differentiable projection onto the consistency set Γ.

    Reliable samples: pin to yc (zero gradient — correct for training).
    Positive clipped: lower bound max(w, yc), optional upper bound yc*g_max.
    Negative clipped: upper bound min(w, yc), optional lower bound yc*g_max.

    NOTE: The gradient through Ir positions is zero by construction — the
    model cannot change reliable samples.  This is the physically correct
    inductive bias: SPADE must be transparent on non-limited regions.
    """
    v = w.clone()

    # Reliable: pin exactly — no gradient contribution from these
    v = torch.where(Ir, yc, v)

    # Positive clipped: lower-bound constraint ≥ yc
    lower_p = yc * Icp.float()
    if math.isfinite(g_max):
        upper_p = (lower_p * g_max).clamp(min=lower_p)
        v = torch.where(Icp, torch.clamp(torch.maximum(v, lower_p),
                                          min=lower_p, max=upper_p), v)
    else:
        v = torch.where(Icp, torch.maximum(v, yc), v)

    # Negative clipped: upper-bound constraint ≤ yc
    upper_m = yc * Icm.float()  # negative values
    if math.isfinite(g_max):
        lower_m_cap = (upper_m * g_max).clamp(max=upper_m)
        v = torch.where(Icm, torch.clamp(torch.minimum(v, upper_m),
                                          min=lower_m_cap, max=upper_m), v)
    else:
        v = torch.where(Icm, torch.minimum(v, yc), v)

    return v


# =============================================================================
# Differentiable stratified soft thresholding
# =============================================================================

def soft_thresh_stratified(
    z: torch.Tensor,          # (..., P) — coefficient vector
    u: torch.Tensor,          # (..., P) — dual variable (same shape)
    lambda_lf: torch.Tensor,  # (..., 1) — LF threshold
    lambda_hf: torch.Tensor,  # (..., 1) — HF threshold
    lf_mask: torch.Tensor,    # (P,)     — True = LF bin
) -> torch.Tensor:
    """
    Differentiable soft-thresholding S_λ(z+u) with separate LF/HF budgets.

    S_λ(x) = sign(x) * max(|x| - λ, 0)

    LF bins (lf_mask=True) : threshold = lambda_lf
    HF bins (lf_mask=False): threshold = lambda_hf

    Replaces the hard (non-differentiable) H_k thresholding in classical SPADE.
    """
    x = z + u
    # Broadcast lf_mask to match x shape
    lf = lf_mask.view(*([1] * (x.dim() - 1)), -1)  # (..., P)
    lam = torch.where(lf, lambda_lf, lambda_hf)    # (..., P)
    return torch.sign(x) * F.relu(x.abs() - lam)


# =============================================================================
# Spectral Feature Extractor  (for Context Encoder input)
# =============================================================================

class SpectralFeatureExtractor(nn.Module):
    """
    Converts a raw audio frame (shape: B × M) into a feature vector
    suitable for the ContextEncoder.

    Features per frame:
      • log-mel spectrogram: n_mels values (shape of spectral envelope)
      • short-time loudness:  1 value (RMS in dB, proxy for LUFS)
      → total: n_mels + 1  features

    Implementation note:
      Uses a fixed (non-trained) triangular mel filterbank computed from
      the DCT-II power spectrum.  Mel filters are registered as buffers so
      they move with the module to the correct device automatically.
    """

    def __init__(self, cfg: UnrolledConfig):
        super().__init__()
        self.M   = cfg.window_length
        self.sr  = cfg.sample_rate
        self.n_mels = cfg.n_mels
        self.P = self.M if cfg.frame == "dct" else 2 * self.M

        # ── Build mel filterbank (fixed, not trained) ─────────────────────
        # Map DCT frequency bins → mel scale using triangular filters.
        # We use only the DCT-part (first M bins of RDFT) for the spectrogram.
        mel_filters = self._build_mel_filterbank()           # (n_mels, M)
        self.register_buffer("mel_filters", mel_filters)

    def _build_mel_filterbank(self) -> torch.Tensor:
        """Triangular mel filterbank as a (n_mels, M) matrix."""
        def hz_to_mel(f):
            return 2595.0 * math.log10(1.0 + f / 700.0)

        def mel_to_hz(m):
            return 700.0 * (10.0 ** (m / 2595.0) - 1.0)

        M  = self.M
        sr = self.sr
        n_mels = self.n_mels

        mel_lo = hz_to_mel(20.0)
        mel_hi = hz_to_mel(min(sr / 2.0, 20000.0))
        mel_pts = torch.linspace(mel_lo, mel_hi, n_mels + 2)
        hz_pts  = torch.tensor([mel_to_hz(m.item()) for m in mel_pts])

        # DCT-II bin frequencies: f_k = k * sr / (2M)
        freqs   = torch.arange(M, dtype=torch.float32) * sr / (2.0 * M)
        filters = torch.zeros(n_mels, M)

        for m in range(n_mels):
            f_lo = hz_pts[m].item()
            f_c  = hz_pts[m + 1].item()
            f_hi = hz_pts[m + 2].item()
            # Rising flank: lo → c
            mask_r = (freqs >= f_lo) & (freqs <= f_c)
            if (f_c - f_lo) > 0:
                filters[m][mask_r] = (freqs[mask_r] - f_lo) / (f_c - f_lo)
            # Falling flank: c → hi
            mask_f = (freqs > f_c) & (freqs <= f_hi)
            if (f_hi - f_c) > 0:
                filters[m][mask_f] = (f_hi - freqs[mask_f]) / (f_hi - f_c)

        # Normalise each filter to unit area (power-preserving)
        area = filters.sum(dim=-1, keepdim=True).clamp(min=1e-8)
        return filters / area

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        """
        x: (B, M) — raw audio frame (windowed or not)
        returns: (B, n_mels + 1) — spectral features
        """
        B, M = x.shape

        # ── Log-mel spectrogram ───────────────────────────────────────────
        dct_coeff = _dct2(x.float())               # (B, M)
        power_spec = dct_coeff[:, :M] ** 2          # (B, M) — DCT-part power
        mel_spec   = torch.matmul(power_spec,
                                   self.mel_filters.T)          # (B, n_mels)
        log_mel    = torch.log(mel_spec.clamp(min=1e-10))

        # ── Short-time loudness (RMS in dB) ───────────────────────────────
        rms  = x.pow(2).mean(dim=-1, keepdim=True).clamp(min=1e-10).sqrt()
        lufs = 20.0 * torch.log10(rms.clamp(min=1e-10))  # (B, 1) — dBFS approx

        return torch.cat([log_mel, lufs], dim=-1)           # (B, n_mels+1)


# =============================================================================
# Context Encoder  (causal GRU → per-frame parameters)
# =============================================================================

class ContextEncoder(nn.Module):
    """
    Causal GRU encoder that predicts per-frame SPADE parameters from
    the spectral context of K previous frames + the current frame.

    Input:  (B, K_context+1, n_feats) — spectral features, last dim = current
    Output: (B, 5) — [lambda_lf, lambda_hf, delta_factor, gmax_factor, eps_factor]
                     All values are in their configured physical range.

    Architecture:
      Input linear projection → 2-layer GRU → last hidden state → ParameterHead

    Causality:
      The GRU processes the context sequence [frame_{t-K}, …, frame_{t-1}, frame_t]
      in forward order.  Only the hidden state at the LAST position (frame_t) is
      used to predict parameters for frame_t.  No future frames are seen.

    Parameter ~count:
      input_proj:   (n_feats, 64)            →   64 * (n_feats+1)  ≈   2 K
      GRU layer 1:  input=64, hidden=128     →   3 * 128 * (64+128+1)  ≈  74 K
      GRU layer 2:  input=128, hidden=128    →   3 * 128 * (128+128+1) ≈  98 K
      head:         128 → 64 → 5            →   ~ 8 K
      ─────────────────────────────────────────────────────────────────────
      Total:        ~ 182 K  (target ≤ 200 K)
    """

    def __init__(self, cfg: UnrolledConfig):
        super().__init__()
        self.cfg    = cfg
        n_feats     = cfg.n_mels + 1          # spectral + loudness
        proj_dim    = 64

        self.input_proj = nn.Sequential(
            nn.Linear(n_feats, proj_dim),
            nn.LayerNorm(proj_dim),
            nn.GELU(),
        )
        self.gru = nn.GRU(
            input_size=proj_dim,
            hidden_size=cfg.gru_hidden,
            num_layers=cfg.gru_layers,
            batch_first=True,
            dropout=0.1 if cfg.gru_layers > 1 else 0.0,
        )
        self.head = nn.Sequential(
            nn.Linear(cfg.gru_hidden, 64),
            nn.GELU(),
            nn.Linear(64, 5),   # 5 output parameters
        )
        # ── Bias initialisation ───────────────────────────────────────────
        # delta/gmax/eps: with range (0.5, 1.5), sigmoid(0) = 0.5 → factor = 1.0
        # (identity: start exactly at the sweep-optimised base values).
        # bias[2,3,4] remain at 0 → correct.
        #
        # lambda_lf / lambda_hf: start near median post-normalised coeff (~0.042).
        # The sweep rank-1 has lf_delta_ratio=0.286, meaning LF recovery is softer
        # (lower effective threshold).  We encode this as lambda_lf starting lower
        # than lambda_hf, so fewer LF coefficients are zeroed on iteration 1.
        #
        # For lambda range (lo, hi) = (1e-3, 0.5):
        #   bias_hf = -1.4 → sigmoid(-1.4)=0.198 → lambda_hf ≈ 0.001+0.499*0.198 = 0.10
        #   bias_lf = bias_hf + ln(lf_delta_ratio) ≈ -1.4 + (-1.25) = -2.65
        #           → sigmoid(-2.65)=0.066 → lambda_lf ≈ 0.001+0.499*0.066 = 0.034
        # Ratio lambda_lf/lambda_hf ≈ 0.34 — reflects the softer LF threshold.
        lf_ratio = getattr(cfg, "lf_delta_ratio", 1.0)
        lf_bias_offset = math.log(max(lf_ratio, 1e-3))   # negative → lower lambda_lf
        with torch.no_grad():
            self.head[-1].bias[0] = -1.4 + lf_bias_offset  # lambda_lf init ≈ 0.034 (range 0.001–0.50)
            # lambda_hf: range changed to (0.001, 0.08), span=0.079.
            # Target init ≈ 0.03 (passes real transient energy, zeros only noise).
            # sigmoid(-0.54) = 0.368 → λ_hf = 0.001 + 0.079*0.368 ≈ 0.030
            # Previous bias=-1.4 with old range (0.001,0.30) also gave 0.10,
            # but 0.10 zeroed all HF DCT bins for M=2048 → dsdr_high always < 0.
            self.head[-1].bias[1] = -0.54                   # lambda_hf init ≈ 0.030

    def forward(self, feat_seq: torch.Tensor) -> torch.Tensor:
        """
        feat_seq: (B, K_context+1, n_feats) — spectral features, ordered t-K … t
        returns:  (B, 5) — physical parameter values
        """
        B, T, _ = feat_seq.shape
        projected = self.input_proj(feat_seq)           # (B, T, 64)
        gru_out, _ = self.gru(projected)                # (B, T, 128)
        h_t = gru_out[:, -1, :]                         # (B, 128) — last step only

        raw = self.head(h_t)                            # (B, 5)  — unconstrained
        params = self._scale_outputs(raw)               # (B, 5)  — physical ranges
        return params

    def _scale_outputs(self, raw: torch.Tensor) -> torch.Tensor:
        """Apply sigmoid + affine rescaling to map raw logits → physical ranges."""
        s = torch.sigmoid(raw)                          # (B, 5) in (0, 1)

        def rescale(x_01, lo, hi):
            return lo + (hi - lo) * x_01

        cfg = self.cfg
        lambda_lf    = rescale(s[:, 0], *cfg.lambda_lf_range)
        lambda_hf    = rescale(s[:, 1], *cfg.lambda_hf_range)
        delta_factor = rescale(s[:, 2], *cfg.delta_factor_range)
        gmax_factor  = rescale(s[:, 3], *cfg.gmax_factor_range)
        eps_factor   = rescale(s[:, 4], *cfg.eps_factor_range)

        return torch.stack([lambda_lf, lambda_hf, delta_factor,
                             gmax_factor, eps_factor], dim=-1)


# =============================================================================
# Unrolled ADMM  (K_unroll differentiable SPADE layers)
# =============================================================================

class UnrolledADMM(nn.Module):
    """
    K_unroll unrolled S-SPADE ADMM layers with differentiable soft thresholding.

    Each layer follows the S-SPADE update equations from [4] eq.(12),
    with hard thresholding H_k replaced by stratified soft thresholding S_λ:

        z̄^(l) = S_{λ_LF, λ_HF}( z^(l-1) + u^(l-1) )   ← stratified soft thresh
        v^(l)  = z̄^(l) - u^(l-1)
        Dv     = frsyn(v^(l), frame, M)
        pDv    = proj_Γ(Dv, yc, masks, g_max)
        z^(l)  = v^(l) - frana(Dv - pDv, frame)
        u^(l)  = u^(l-1) + z^(l) - z̄^(l)               ← dual update

    The frame parameters (lambda_lf, lambda_hf, g_max) are computed ONCE before
    the loop from the ContextEncoder output and held constant across all layers
    for the current frame.

    Learnable per-layer scalings
    ----------------------------
    Following Gregor & LeCun (2010), we add a learnable scale per layer for
    both the threshold and the dual step:
        layer_lf_scale[l]   : multiplied on lambda_lf before thresholding
        layer_hf_scale[l]   : multiplied on lambda_hf before thresholding
        layer_dual_scale[l] : multiplied on the dual update magnitude

    These are initialised to 1.0 and learned jointly with the encoder.
    They allow the unrolled ADMM to adapt the effective threshold per layer
    (e.g. coarser thresh early, finer late) without changing the architecture.

    Total learnable params here: 3 × K_unroll  ≈ 24 scalars  (negligible)
    """

    def __init__(self, cfg: UnrolledConfig):
        super().__init__()
        self.cfg      = cfg
        self.M        = cfg.window_length
        self.frame    = cfg.frame
        self.K        = cfg.K_unroll

        # Per-layer learnable scale factors.
        # Mirror S-SPADE where k increases over iterations (threshold decreases).
        # Range [1.5 → 0.3]: aggressive early thresholding, fine late.
        # Kept smaller than before (was [3.0,0.6]) to avoid over-killing the
        # gradient in the first layers.
        n = self.K
        init_scales = torch.linspace(1.5, 0.3, n)
        self.layer_lf_scale   = nn.Parameter(init_scales.clone())
        self.layer_hf_scale   = nn.Parameter(init_scales.clone())
        self.layer_dual_scale = nn.Parameter(torch.ones(n))

    def forward(
        self,
        yc_w: torch.Tensor,           # (B, M)  — windowed limited frame
        Ir:   torch.Tensor,           # (B, M)  bool — reliable
        Icp:  torch.Tensor,           # (B, M)  bool — pos-clipped
        Icm:  torch.Tensor,           # (B, M)  bool — neg-clipped
        lambda_lf:  torch.Tensor,     # (B,)    — LF soft-threshold
        lambda_hf:  torch.Tensor,     # (B,)    — HF soft-threshold
        g_max:      torch.Tensor,     # (B,)    — linear gain cap
        lf_mask:    torch.Tensor,     # (P,)    bool — LF bin mask
    ) -> Tuple[torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
        """
        Returns
        -------
        x_hat     : (B, M)       — restored frame (final layer)
        z_thresh  : (B, P)       — thresholded coefficients at final layer
                                   (used for sparsity loss: L1 penalty)
        x_hat_mid : (B, M) | None — restored frame at K//2 layer
                                   (used for deep supervision auxiliary loss)
        """
        B, M = yc_w.shape
        P    = M if self.frame == "dct" else 2 * M

        # ── Per-frame input normalisation ─────────────────────────────────
        # Scale yc_w so that the max DCT coefficient magnitude ≈ 1.0.
        # IMPORTANT: .detach() — frame_scale is a normalisation constant
        # computed from the INPUT (not a learned parameter).  Without detach,
        # the gradient flows back through amax/clamp into the DCT of yc_w,
        # creating a confusing secondary path that competes with ∂loss/∂λ.
        yc_d = yc_w.double()
        z_init = frana(yc_d, self.frame)                     # (B, P)
        frame_scale = z_init.abs().amax(dim=-1, keepdim=True).clamp(min=1e-8).detach()
        yc_d_norm = yc_d / frame_scale                       # normalised frame

        # ── Initialise ADMM state ─────────────────────────────────────────
        zi = frana(yc_d_norm, self.frame)        # (B, P)  float64
        ui = torch.zeros_like(zi)

        # Expand lambda tensors for broadcasting: (B,) → (B, 1)
        lam_lf = lambda_lf.unsqueeze(-1).double()    # (B, 1)
        lam_hf = lambda_hf.unsqueeze(-1).double()    # (B, 1)

        # Normalise masks and yc to the same frame scale
        Ir_d  = Ir.bool()
        Icp_d = Icp.bool()
        Icm_d = Icm.bool()
        yc_norm_d = yc_d_norm   # already computed above

        # g_max is scale-invariant (ratio), no adjustment needed

        # ── Unrolled ADMM layers ──────────────────────────────────────────
        mid_layer = self.K // 2
        x_hat_mid: Optional[torch.Tensor] = None
        zb_last = torch.zeros_like(zi)   # will hold last thresholded coefficients

        for l in range(self.K):
            scale_lf   = self.layer_lf_scale[l].double().clamp(min=0.1)   # prevent negative
            scale_hf   = self.layer_hf_scale[l].double().clamp(min=0.1)
            scale_dual = self.layer_dual_scale[l].double()

            # Step 2: stratified soft thresholding
            zb = soft_thresh_stratified(
                zi, ui,
                lam_lf * scale_lf,
                lam_hf * scale_hf,
                lf_mask,
            )                                         # (B, P)
            zb_last = zb   # track for sparsity loss

            # Step 3: projection onto Γ via eq.(12)
            v_c  = zb - ui                            # (B, P)
            Dv   = frsyn(v_c, self.frame, M)          # (B, M)

            # Differentiable proj_Γ on the normalised domain
            pDv = Dv.clone()
            pDv = torch.where(Ir_d, yc_norm_d, pDv)

            # Positive clipped
            lo_p = yc_norm_d
            hi_p = lo_p * g_max.unsqueeze(-1).double().clamp(min=1.0)
            pDv  = torch.where(Icp_d, torch.clamp(torch.maximum(pDv, lo_p),
                                                   min=lo_p, max=hi_p), pDv)

            # Negative clipped
            up_m   = yc_norm_d
            lo_m   = up_m * g_max.unsqueeze(-1).double().clamp(min=1.0)
            lo_m_c = torch.minimum(lo_m, up_m)
            pDv    = torch.where(Icm_d, torch.clamp(torch.minimum(pDv, up_m),
                                                    min=lo_m_c, max=up_m), pDv)

            # ADMM coefficient update — eq.(12) from [4]
            zi = v_c - frana(Dv - pDv, self.frame)    # (B, P)

            # Dual update
            ui = ui + (zi - zb) * scale_dual

            # ── Deep supervision: record mid-layer reconstruction ─────────
            if l == mid_layer - 1:
                x_mid_norm = frsyn(zi, self.frame, M)
                x_hat_mid  = (x_mid_norm * frame_scale).float()

        # Synthesise output and invert the per-frame normalisation
        x_hat_norm = frsyn(zi, self.frame, M)              # (B, M)
        x_hat = (x_hat_norm * frame_scale).float()         # back to original scale

        # Return thresholded coefficients (float32, original scale) for sparsity loss
        z_thresh = (zb_last * frame_scale).float()

        return x_hat, z_thresh, x_hat_mid


# =============================================================================
# Full SPADE-Unrolled model
# =============================================================================

class SPADEUnrolled(nn.Module):
    """
    Full SPADE-Unrolled model.

    Combines:
      1. SpectralFeatureExtractor  — raw frames → spectral features
      2. ContextEncoder            — spectral context → per-frame SPADE params
      3. UnrolledADMM              — K differentiable ADMM layers

    Forward pass (single-frame mode for training):
      • Takes a batch of (limited frame, K context frames, clipping masks)
      • Returns the restored frame and the predicted parameters (for logging)

    Inference mode (WOLA loop):
      • Use SPADEUnrolledInference wrapper to process full signals
    """

    def __init__(self, cfg: UnrolledConfig):
        super().__init__()
        self.cfg = cfg

        self.feature_extractor = SpectralFeatureExtractor(cfg)
        self.context_encoder   = ContextEncoder(cfg)
        self.unrolled_admm     = UnrolledADMM(cfg)

        # LF mask — registered as buffer (moves with module.to(device))
        # Built lazily on first forward call (needs device info)
        self._lf_mask: Optional[torch.Tensor] = None

    def _get_lf_mask(self, device: torch.device) -> torch.Tensor:
        if self._lf_mask is None or self._lf_mask.device != device:
            self._lf_mask = build_lf_mask(
                self.cfg.window_length, self.cfg.frame,
                self.cfg.sample_rate, self.cfg.lf_cutoff_hz,
                device,
            )
        return self._lf_mask

    def forward(
        self,
        yc_w:      torch.Tensor,   # (B, M)         — current windowed limited frame
        ctx_frames: torch.Tensor,  # (B, K_ctx, M)  — K previous frames (limited, windowed)
        Ir:        torch.Tensor,   # (B, M)  bool
        Icp:       torch.Tensor,   # (B, M)  bool
        Icm:       torch.Tensor,   # (B, M)  bool
    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, Optional[torch.Tensor]]:
        """
        Returns
        -------
        x_hat    : (B, M)       — restored frame (float32)
        params   : (B, 5)       — predicted per-frame parameters
        z_thresh : (B, P)       — thresholded coefficients (for sparsity loss)
        x_hat_mid: (B, M)|None  — mid-layer reconstruction (for deep supervision)
        """
        B = yc_w.shape[0]
        device = yc_w.device

        # ── 1. Extract spectral features ──────────────────────────────────
        # Current frame features
        feat_curr = self.feature_extractor(yc_w)          # (B, n_feats)

        # Context frames features: process all at once for efficiency
        B, K, M = ctx_frames.shape
        ctx_flat = ctx_frames.reshape(B * K, M)
        feat_ctx_flat = self.feature_extractor(ctx_flat)   # (B*K, n_feats)
        feat_ctx = feat_ctx_flat.reshape(B, K, -1)         # (B, K, n_feats)

        # Concatenate: [ctx_{t-K}, …, ctx_{t-1}, current_t]
        feat_seq = torch.cat([feat_ctx, feat_curr.unsqueeze(1)], dim=1)  # (B, K+1, n_feats)

        # ── 2. Predict per-frame parameters ───────────────────────────────
        params = self.context_encoder(feat_seq)             # (B, 5)

        lambda_lf    = params[:, 0]   # (B,)
        lambda_hf    = params[:, 1]   # (B,)
        delta_factor = params[:, 2]   # (B,)
        gmax_factor  = params[:, 3]   # (B,)
        # eps_factor = params[:, 4]  — used for convergence check (inference only)

        # Compute physical gain cap (linear) from predicted multiplier
        g_max_db = self.cfg.base_max_gain_db * gmax_factor  # (B,) dB
        g_max    = 10.0 ** (g_max_db / 20.0)                # (B,) linear

        # ── 3. Run unrolled ADMM ───────────────────────────────────────────
        lf_mask = self._get_lf_mask(device)                  # (P,)

        x_hat, z_thresh, x_hat_mid = self.unrolled_admm(
            yc_w=yc_w,
            Ir=Ir, Icp=Icp, Icm=Icm,
            lambda_lf=lambda_lf,
            lambda_hf=lambda_hf,
            g_max=g_max,
            lf_mask=lf_mask,
        )   # (B, M), (B, P), (B, M)|None

        return x_hat, params, z_thresh, x_hat_mid

    def parameter_count(self) -> int:
        """Total trainable parameters."""
        return sum(p.numel() for p in self.parameters() if p.requires_grad)


# =============================================================================
# Loss functions
# =============================================================================

class SPADEUnrolledLoss(nn.Module):
    """
    Composite loss for SPADE-Unrolled training.

    Components
    ----------
    1. Mask MSE       (w_mask=2.0)     MSE on Icp|Icm — recovery region only
    2. Transparency   (w_transp=0.1)   MSE on Ir       — non-limited must be unchanged
    3. STFT           (w_stft=0.05)    Multi-scale L1.
    4. LF coeff MSE   (w_lf_coeff=2.0) PRIMARY LF loss.
    5. LF energy      (w_lf_energy=0.5) One-sided RMS under-recovery penalty.
    6. Over-recovery  (w_over=0.3)     LF energy > GT+3dB.
    7. λ reg          (w_reg=5.0)      Anti-saturation: L2 from target center.
       Centers: λ_lf=0.034, λ_hf=0.03 — calibrated for M=2048, sr=44100.
       IMPORTANT: λ_hf_center was previously 0.10 (calibrated for M=1024).
       For M=2048, HF DCT coefficients post-normalisation are 0.01–0.05;
       λ_hf=0.10 zeroed all of them → dsdr_high < −1.8 dB every epoch.
       λ_hf_center=0.03 allows real HF transient content to pass through.
    7b.g_fac floor    (w_gfac_floor=3.0) ReLU(floor - g_fac)^2 penalty.
       Blocks the attenuative shortcut: without this, g_fac collapses toward
       the range lower bound (0.5) making g_max ≈ 3 dB, which attenuates the
       signal rather than declipping it (observed: dsdr_high/mid both < 0 from
       epoch 1, worsening steadily to −1.2 / −0.7 dB by ep22).
       floor=0.85 → g_max ≥ 5.1 dB — conservative but blocks the shortcut.
    8. Sparsity       (w_sparsity=0.5) L1 of thresholded coefficients z_thresh.
       Penalises passing too many coefficients: forces λ to actually zero things out.
       Combined with λ-reg this creates a stable equilibrium where the ADMM does
       real sparse solving rather than degenerating to an identity mapping.
    9. Deep supervision (w_ds=0.5)     Auxiliary mask+LF loss at mid-layer (K//2).
       Directly injects gradient into the GRU, preventing vanishing gradients
       across K unrolled ADMM layers.
    """

    def __init__(
        self,
        w_mask:           float = 2.0,
        w_transp:         float = 0.1,
        w_stft:           float = 0.05,
        w_lf_coeff:       float = 2.0,
        w_lf_energy:      float = 0.5,
        w_over:           float = 0.3,
        w_reg:            float = 5.0,
        w_sparsity:       float = 0.5,
        w_ds:             float = 0.15,    # deep supervision — guide gradient early, don't dominate
        w_gfac_floor:     float = 3.0,     # g_fac floor penalty: ReLU(g_floor - g_fac)^2
        gfac_floor:       float = 0.5,     # [FIX] matches new gmax_factor_range lower bound (0.5, 2.0)
        sample_rate:      int   = 44100,
        lf_cutoff_hz:     float = 500.0,
        lambda_lf_center: float = 0.034,   # softer LF: reflects lf_delta_ratio=0.286
        # hf_center corrected 0.10 → 0.03.
        # 0.10 was calibrated for M=1024 but model uses M=2048.  For M=2048,
        # HF post-normalised magnitudes are 0.01–0.05; λ_hf=0.10 zeros them all
        # (confirmed: dsdr_high stable at −1.8 dB while λ-reg held λ_hf=0.10).
        lambda_hf_center: float = 0.03,
    ):
        super().__init__()
        self.w_mask        = w_mask
        self.w_transp      = w_transp
        self.w_stft        = w_stft
        self.w_lf_coeff    = w_lf_coeff
        self.w_lf_energy   = w_lf_energy
        self.w_over        = w_over
        self.w_reg         = w_reg
        self.w_sparsity    = w_sparsity
        self.w_ds          = w_ds
        self.w_gfac_floor  = w_gfac_floor
        self.gfac_floor    = gfac_floor
        self.sr            = sample_rate
        self.lf_cutoff     = lf_cutoff_hz
        self.lf_center     = lambda_lf_center
        self.hf_center     = lambda_hf_center
        self.stft_wins     = [256, 512, 1024]

    def _frame_loss(
        self,
        x_hat:   torch.Tensor,   # (B, M)
        x_clean: torch.Tensor,   # (B, M)
        yc_w:    torch.Tensor,   # (B, M)
        Ir:      torch.Tensor,   # (B, M) bool
        Icp:     torch.Tensor,   # (B, M) bool
        Icm:     torch.Tensor,   # (B, M) bool
    ) -> Tuple[torch.Tensor, dict]:
        """Compute mask + transparency + STFT + LF losses for one frame estimate."""
        B, M = x_hat.shape
        losses = {}

        mask_active = (Icp | Icm).float()
        mask_ir     = Ir.float()
        n_active    = mask_active.sum(dim=-1).clamp(min=1)
        n_ir        = mask_ir.sum(dim=-1).clamp(min=1)

        # 1. Mask MSE
        sq_err_active = ((x_hat - x_clean) ** 2) * mask_active
        loss_mask = (sq_err_active.sum(dim=-1) / n_active).mean()
        losses["mask"] = loss_mask.item()

        # 2. Transparency
        sq_err_ir = ((x_hat - x_clean) ** 2) * mask_ir
        loss_transp = (sq_err_ir.sum(dim=-1) / n_ir).mean()
        losses["transp"] = loss_transp.item()

        # 3. Multi-scale STFT
        loss_stft = x_hat.new_zeros(1)
        for win in self.stft_wins:
            hop = win // 4
            wnd = torch.hann_window(win, device=x_hat.device)
            def _stft(x, _w=wnd, _win=win, _hop=hop):
                return torch.stft(x, n_fft=_win, hop_length=_hop,
                                  win_length=_win, window=_w, return_complex=True)
            loss_stft = loss_stft + F.l1_loss(_stft(x_hat.float()).abs(),
                                               _stft(x_clean.float()).abs())
        loss_stft = loss_stft / len(self.stft_wins)
        losses["stft"] = loss_stft.item()

        # 4. LF coefficient MSE (PRIMARY)
        k_cut = int(math.ceil(self.lf_cutoff * 2.0 * M / self.sr))
        k_cut = max(1, min(k_cut, M))
        dct_res_hat   = _dct2(x_hat.float() - yc_w.float())[:, :k_cut]
        dct_res_clean = _dct2(x_clean.float() - yc_w.float())[:, :k_cut]
        loss_lf_coeff = F.mse_loss(dct_res_hat, dct_res_clean)
        losses["lf_coeff"] = loss_lf_coeff.item()

        # 5. LF energy asymmetric
        dct_hat   = _dct2(x_hat.float())[:, :k_cut]
        dct_clean = _dct2(x_clean.float())[:, :k_cut]
        rms_lf_hat   = dct_hat.pow(2).mean(dim=-1).clamp(min=1e-10).sqrt()
        rms_lf_clean = dct_clean.pow(2).mean(dim=-1).clamp(min=1e-10).sqrt()
        loss_lf_energy = F.relu(rms_lf_clean - rms_lf_hat).pow(2).mean()
        losses["lf_energy"] = loss_lf_energy.item()

        # 6. Over-recovery
        loss_over = F.relu(rms_lf_hat - rms_lf_clean * 10.0 ** (3.0/20.0)).pow(2).mean()
        losses["over"] = loss_over.item()

        total = (self.w_mask      * loss_mask
               + self.w_transp    * loss_transp
               + self.w_stft      * loss_stft.squeeze()
               + self.w_lf_coeff  * loss_lf_coeff
               + self.w_lf_energy * loss_lf_energy
               + self.w_over      * loss_over)
        return total, losses

    def forward(
        self,
        x_hat:     torch.Tensor,              # (B, M)
        x_clean:   torch.Tensor,              # (B, M)
        yc_w:      torch.Tensor,              # (B, M)
        Ir:        torch.Tensor,              # (B, M) bool
        Icp:       torch.Tensor,              # (B, M) bool
        Icm:       torch.Tensor,              # (B, M) bool
        params:    Optional[torch.Tensor] = None,  # (B, 5)
        z_thresh:  Optional[torch.Tensor] = None,  # (B, P) thresholded coeffs
        x_hat_mid: Optional[torch.Tensor] = None,  # (B, M) mid-layer x_hat
    ) -> Tuple[torch.Tensor, dict]:
        losses = {}

        # ── Primary frame losses ──────────────────────────────────────────
        total, frame_losses = self._frame_loss(x_hat, x_clean, yc_w, Ir, Icp, Icm)
        losses.update(frame_losses)

        # ── 7. λ anti-saturation regularization (STRONGER, CORRECT CENTERS) ─
        loss_reg = x_hat.new_zeros(1)
        if params is not None and self.w_reg > 0:
            loss_reg = ((params[:, 0] - self.lf_center).pow(2).mean() +
                        (params[:, 1] - self.hf_center).pow(2).mean())
        losses["reg"] = loss_reg.item()
        total = total + self.w_reg * loss_reg.squeeze()

        # ── 7b. g_fac floor penalty ───────────────────────────────────────
        # Prevents the model from using gain attenuation as a shortcut to
        # satisfy the mask/over losses.  Without this, g_fac drifts toward
        # the range lower bound (observed: 0.5 → ~0.54 by ep22) causing
        # dsdr_high < 0 and dsdr_mid < 0 — the model makes the signal worse.
        #
        # Loss = w_gfac_floor * mean( ReLU(floor - g_fac)^2 )
        # Zero when g_fac >= floor.  Quadratic below floor → smooth gradient.
        loss_gfac_floor = x_hat.new_zeros(1)
        if params is not None and self.w_gfac_floor > 0:
            g_fac = params[:, 3]    # (B,)
            loss_gfac_floor = F.relu(self.gfac_floor - g_fac).pow(2).mean()
        losses["gfac_floor"] = loss_gfac_floor.item()
        total = total + self.w_gfac_floor * loss_gfac_floor.squeeze()

        # ── 8. Sparsity loss: L1 of z_thresh ─────────────────────────────
        # Penalises z_thresh being large: encourages λ to zero out coefficients.
        # This breaks the identity-mapping local minimum (λ→0 = all coeffs pass).
        loss_sparsity = x_hat.new_zeros(1)
        if z_thresh is not None and self.w_sparsity > 0:
            loss_sparsity = z_thresh.abs().mean()
        losses["sparsity"] = loss_sparsity.item()
        total = total + self.w_sparsity * loss_sparsity.squeeze()

        # ── 9. Deep supervision: auxiliary loss at mid-layer ──────────────
        # Same primary losses applied to x_hat_mid (reconstruction at K//2).
        # Injects gradient directly into the GRU, preventing vanishing gradients.
        loss_ds = x_hat.new_zeros(1)
        if x_hat_mid is not None and self.w_ds > 0:
            ds_total, _ = self._frame_loss(x_hat_mid, x_clean, yc_w, Ir, Icp, Icm)
            loss_ds = ds_total
        losses["ds"] = loss_ds.item()
        total = total + self.w_ds * loss_ds.squeeze()

        losses["total"] = total.item()
        return total, losses



# =============================================================================
# WOLA-based inference wrapper
# =============================================================================

class SPADEUnrolledInference:
    """
    Wraps SPADEUnrolled to process a full audio signal via WOLA.

    Equivalent to _declip_mono_gpu but calls the learned model instead of
    the classical SPADE solver.  Used at test time only (not differentiable
    end-to-end because of the frame-level sliding window).

    Usage
    -----
        model = SPADEUnrolled(cfg)
        model.load_state_dict(...)
        model.eval()

        infer = SPADEUnrolledInference(model, delta_db=2.5, device="cuda")
        x_hat = infer.process(y_limited, sample_rate=44100)
    """

    def __init__(
        self,
        model:     SPADEUnrolled,
        delta_db:  float = 2.5,
        max_gain_db: float = 6.0,
        device:    str = "cuda",
        batch_frames: int = 256,  # GPU batch size for frame processing
    ):
        self.model = model.to(device)
        self.model.eval()
        self.cfg        = model.cfg
        self.delta_db   = delta_db
        self.max_gain_db = max_gain_db
        self.device     = device
        self.batch_frames = batch_frames

    @torch.no_grad()
    def process(self, y_limited: np.ndarray, sample_rate: int = 44100) -> np.ndarray:
        """
        y_limited : (N,) or (N, C) — limited audio
        returns   : (N,) or (N, C) — restored audio
        """
        from scipy.signal.windows import hann as _hann
        try:
            from spade_declip_v12 import _compute_masks, _dilate_masks_soft
        except ImportError:
            raise ImportError("spade_declip_v12.py must be in the Python path")

        mono = y_limited.ndim == 1
        if mono:
            y_limited = y_limited[:, None]
        _, C = y_limited.shape
        outputs = []

        for ch in range(C):
            yc = y_limited[:, ch].astype(np.float64)
            dc = float(np.mean(yc))
            yc -= dc

            ceiling = float(np.max(np.abs(yc)))
            thresh  = ceiling * (10.0 ** (-self.delta_db / 20.0))
            if thresh <= 0:
                outputs.append(yc)
                continue

            masks_obj = _compute_masks(yc, thresh)

            M = self.cfg.window_length
            a = self.cfg.hop_length
            N = int(np.ceil(len(yc) / a))
            win = np.sqrt(_hann(M, sym=False))

            out_buf  = np.zeros(len(yc) + M)
            norm_buf = np.zeros(len(yc) + M)
            L = len(yc)

            # Build context buffer: circular buffer of K_ctx frames
            K_ctx = self.cfg.K_context
            ctx_buf = np.zeros((K_ctx, M), dtype=np.float32)

            for i in range(N):
                idx1    = i * a
                idx2    = min(idx1 + M, L)
                seg_len = idx2 - idx1

                yc_frame = np.zeros(M)
                yc_frame[:seg_len] = yc[idx1:idx2]
                win_frame = yc_frame * win

                # Bypass: no limiting in this frame
                frame_peak = np.max(np.abs(yc[idx1:idx2]))
                if frame_peak < thresh:
                    out_buf[idx1:idx1+M]  += win_frame * win
                    norm_buf[idx1:idx1+M] += win ** 2
                    ctx_buf = np.roll(ctx_buf, -1, axis=0)
                    ctx_buf[-1] = win_frame.astype(np.float32)
                    continue

                # Extract masks for this frame
                Ir_f  = masks_obj.Ir[idx1:idx2]
                Icp_f = masks_obj.Icp[idx1:idx2]
                Icm_f = masks_obj.Icm[idx1:idx2]

                # Pad masks to M
                Ir_p  = np.zeros(M, dtype=bool); Ir_p[:seg_len]  = Ir_f
                Icp_p = np.zeros(M, dtype=bool); Icp_p[:seg_len] = Icp_f
                Icm_p = np.zeros(M, dtype=bool); Icm_p[:seg_len] = Icm_f
                Ir_p[seg_len:] = True   # padded region = reliable

                # To tensors
                def _t(arr, dtype=torch.float32):
                    return torch.tensor(arr, dtype=dtype,
                                        device=self.device).unsqueeze(0)

                yc_t  = _t(win_frame.astype(np.float32))
                ctx_t = torch.tensor(ctx_buf, dtype=torch.float32,
                                     device=self.device).unsqueeze(0)  # (1, K, M)
                Ir_t  = _t(Ir_p, dtype=torch.bool)
                Icp_t = _t(Icp_p, dtype=torch.bool)
                Icm_t = _t(Icm_p, dtype=torch.bool)

                with torch.no_grad():
                    x_hat_t, _, _, _ = self.model(yc_t, ctx_t, Ir_t, Icp_t, Icm_t)

                x_hat = x_hat_t.squeeze(0).cpu().numpy()

                out_buf[idx1:idx1+M]  += x_hat * win
                norm_buf[idx1:idx1+M] += win ** 2

                # Update context buffer
                ctx_buf = np.roll(ctx_buf, -1, axis=0)
                ctx_buf[-1] = win_frame.astype(np.float32)

            # Normalise WOLA
            safe_norm = np.where(norm_buf > 1e-8, norm_buf, 1.0)
            recovered = out_buf / safe_norm
            recovered = recovered[:L] + dc
            outputs.append(recovered)

        result = np.column_stack(outputs)
        return result[:, 0] if mono else result



# =============================================================================
# Hybrid inference: v11 S-SPADE (HF unchanged) + SPADEUnrolled (LF learned)
# =============================================================================

class HybridSPADEInference:
    """
    Hybrid audio delimiting inference.

    Architecture
    ------------
    1. LR crossover split at `crossover_hz` (default 8000 Hz).
       Uses the same phase-perfect Butterworth HP = x − LP formula as v11
       `_lr_split`, ensuring lf + hf == x exactly (no energy loss or leakage).

    2. HF band (≥ crossover_hz):
       → ``spade_declip_v11._sspade_batch_gpu`` (GPU) or
         ``spade_declip_v11.tight_sspade``      (CPU)
       Algorithm is BYTE-FOR-BYTE identical to v11.  Hard thresholding H_k
       with progressive relaxation (k starts at hf_s, increments by hf_s
       every hf_r iterations up to hf_max_iter).

    3. LF band (< crossover_hz):
       → ``SPADEUnrolledInference.process()`` — learned reconstruction.
       ContextEncoder predicts per-frame lambda_lf, g_max, delta from the
       K previous frames; UnrolledADMM applies K_unroll differentiable
       soft-threshold layers.

    4. Output = lf_recovered + hf_recovered.

    Rationale for 8 kHz crossover
    ------------------------------
    v11 S-SPADE recovers HF transients (cymbal snap, hi-hat attack) well:
    the DCT coefficients above 8 kHz are sparse and hard thresholding with
    small k finds them reliably.  Below 8 kHz (kick body, bass fundamental)
    v11 under-recovers because:
      • The "true" sparsity level k is content-dependent and poorly set
        by the fixed s/r schedule in the time available (K_unroll layers).
      • Tonal/sustain content is not globally sparse, so H_k wastes budget
        zeroing low-energy HF coefficients instead of recovering LF energy.
    The learned model addresses both issues via adaptive lambda_lf and g_max.

    Parameters
    ----------
    model          : trained SPADEUnrolled (loaded from checkpoint)
    crossover_hz   : LR crossover frequency (default 8000 Hz)
    lf_delta_db    : threshold for LF band mask detection (dB below ceiling)
    lf_max_gain_db : gain cap for LF band recovery
    lf_release_ms  : mask dilation for LF band (limiter release smear)
    hf_delta_db    : threshold for HF band mask detection
    hf_s           : v11 sparsity step (k starts at hf_s, increments by hf_s)
    hf_r           : v11 sparsity relaxation period (k incremented every hf_r iter)
    hf_eps         : v11 convergence threshold
    hf_max_iter    : v11 max iterations per frame
    hf_max_gain_db : v11 ratio-aware gain cap for HF band
    hf_release_ms  : v11 mask dilation for HF band
    hf_window_length : v11 WOLA window for HF band (default 2048)
    hf_hop_length    : v11 WOLA hop for HF band   (default 512)
    device         : 'cuda' | 'cpu' | 'auto'
    batch_frames   : GPU batch size for SPADEUnrolled LF processing
    """

    def __init__(
        self,
        model:            "SPADEUnrolled",
        crossover_hz:     float = 8000.0,
        lf_delta_db:      float = 1.5,
        lf_max_gain_db:   float = 6.0,
        lf_release_ms:    float = 0.0,
        hf_delta_db:      float = 1.5,
        hf_s:             int   = 1,
        hf_r:             int   = 1,
        hf_eps:           float = 0.05,
        hf_max_iter:      int   = 500,
        hf_max_gain_db:   float = 6.0,
        hf_release_ms:    float = 0.0,
        hf_window_length: int   = 2048,
        hf_hop_length:    int   = 512,
        device:           str   = "auto",
        batch_frames:     int   = 256,
    ):
        if device == "auto":
            try:
                import torch as _t
                device = "cuda" if _t.cuda.is_available() else "cpu"
            except ImportError:
                device = "cpu"

        self.model    = model.to(device)
        self.model.eval()
        self.cfg      = model.cfg

        self.crossover_hz     = crossover_hz
        self.lf_delta_db      = lf_delta_db
        self.lf_max_gain_db   = lf_max_gain_db
        self.lf_release_ms    = lf_release_ms
        self.hf_delta_db      = hf_delta_db
        self.hf_s             = hf_s
        self.hf_r             = hf_r
        self.hf_eps           = hf_eps
        self.hf_max_iter      = hf_max_iter
        self.hf_max_gain_db   = hf_max_gain_db
        self.hf_release_ms    = hf_release_ms
        self.hf_window_length = hf_window_length
        self.hf_hop_length    = hf_hop_length
        self.device           = device
        self.batch_frames     = batch_frames

        # Cached LF inference wrapper (re-used across calls)
        self._lf_infer = SPADEUnrolledInference(
            model,
            delta_db      = lf_delta_db,
            max_gain_db   = lf_max_gain_db,
            device        = device,
            batch_frames  = batch_frames,
        )

    @staticmethod
    def _lr_split(
        x: np.ndarray,
        crossover_hz: float,
        sr: int,
    ) -> "Tuple[np.ndarray, np.ndarray]":
        """
        Phase-perfect Linkwitz-Riley crossover.  lp + hp == x exactly.
        Identical to spade_declip_v11._lr_split.
        """
        from scipy.signal import butter, sosfiltfilt
        fc = float(np.clip(crossover_hz, 1.0, sr / 2.0 - 1.0))
        sos = butter(2, fc, btype="low", fs=sr, output="sos")
        lp  = sosfiltfilt(sos, x)
        hp  = x - lp
        return lp, hp

    def _process_hf_band(
        self,
        hf_mono: np.ndarray,
        sr:      int,
    ) -> np.ndarray:
        """
        Run v11 S-SPADE on the HF band.  Algorithm is identical to v11.
        Imports lazily so spade_declip_v11 is only required at inference.
        """
        try:
            from spade_declip_v11 import (
                declip as _v11_declip,
                DeclipParams as _V11Params,
            )
        except ImportError:
            raise ImportError(
                "spade_declip_v11.py must be in the Python path for HF processing."
            )

        params = _V11Params(
            algo          = "sspade",
            frame         = self.cfg.frame,
            mode          = "soft",
            delta_db      = self.hf_delta_db,
            window_length = self.hf_window_length,
            hop_length    = self.hf_hop_length,
            s             = self.hf_s,
            r             = self.hf_r,
            eps           = self.hf_eps,
            max_iter      = self.hf_max_iter,
            max_gain_db   = self.hf_max_gain_db,
            release_ms    = self.hf_release_ms,
            sample_rate   = sr,
            use_gpu       = (self.device != "cpu"),
            gpu_device    = (self.device if self.device != "cpu" else "auto"),
            show_progress = False,
            verbose       = False,
        )
        fixed, _ = _v11_declip(hf_mono, params)
        return fixed

    @torch.no_grad()
    def process(
        self,
        y_limited:   np.ndarray,
        sample_rate: int = 44100,
    ) -> np.ndarray:
        """
        y_limited : (N,) or (N, C) — limited audio at any sample rate
        returns   : (N,) or (N, C) — hybrid-recovered audio

        Pipeline per channel
        --------------------
        1. LR crossover split at self.crossover_hz
           → lf_band (0 – crossover_hz)
           → hf_band (crossover_hz – Nyquist)
        2. HF: spade_declip_v11 S-SPADE (identical algorithm, unchanged)
        3. LF: SPADEUnrolledInference (learned soft-threshold ADMM)
        4. hf_recovered + lf_recovered = full signal
        """
        mono = y_limited.ndim == 1
        if mono:
            y_limited = y_limited[:, None]
        _, C = y_limited.shape
        out_channels = []

        for ch in range(C):
            yc = y_limited[:, ch].astype(np.float64)

            # ── Phase-perfect LR split ────────────────────────────────────
            lf_band, hf_band = self._lr_split(yc, self.crossover_hz, sample_rate)

            # ── HF: v11 S-SPADE (unchanged) ────────────────────────────────
            hf_rec = self._process_hf_band(hf_band.astype(np.float64), sample_rate)

            # ── LF: SPADEUnrolled (learned) ────────────────────────────────
            lf_rec = self._lf_infer.process(
                lf_band.astype(np.float32), sample_rate
            )

            # ── Recombine ─────────────────────────────────────────────────
            L = min(len(lf_rec), len(hf_rec))
            combined = lf_rec[:L].astype(np.float64) + hf_rec[:L]
            out_channels.append(combined)

        result = np.column_stack(out_channels)
        return result[:, 0] if mono else result


# =============================================================================
# Model factory
# =============================================================================

def build_model(cfg: Optional[UnrolledConfig] = None) -> SPADEUnrolled:
    """Construct a SPADEUnrolled model with default or custom config."""
    if cfg is None:
        cfg = UnrolledConfig()
    model = SPADEUnrolled(cfg)
    n = model.parameter_count()
    print(f"[SPADEUnrolled] Built model: {n:,} trainable parameters")
    return model


# =============================================================================
# Quick sanity check
# =============================================================================

def _smoke_test():
    """Run a forward pass with random data to verify shapes and dtypes."""
    print("=" * 60)
    print("SPADE Unrolled — Smoke Test")
    print("=" * 60)

    cfg = UnrolledConfig(
        window_length=512,
        hop_length=128,
        K_unroll=4,
        K_context=4,
        n_mels=16,
        gru_hidden=64,
        gru_layers=1,
    )
    model = build_model(cfg)
    model.eval()

    B = 4
    M = cfg.window_length
    K = cfg.K_context

    # Random limited frames + masks
    yc    = torch.randn(B, M) * 0.5
    ctx   = torch.randn(B, K, M) * 0.5
    thresh = 0.3
    Ir    = yc.abs() < thresh
    Icp   = yc >= thresh
    Icm   = yc <= -thresh

    with torch.no_grad():
        x_hat, params, z_thresh, x_hat_mid = model(yc, ctx, Ir, Icp, Icm)

    print(f"  Input  yc:      {tuple(yc.shape)}  dtype={yc.dtype}")
    print(f"  Output x_hat:   {tuple(x_hat.shape)}  dtype={x_hat.dtype}")
    print(f"  Params:         {tuple(params.shape)}  dtype={params.dtype}")
    print(f"  Param ranges:")
    print(f"    lambda_lf   ∈ [{params[:,0].min():.4f}, {params[:,0].max():.4f}]")
    print(f"    lambda_hf   ∈ [{params[:,1].min():.4f}, {params[:,1].max():.4f}]")
    print(f"    delta_fac   ∈ [{params[:,2].min():.4f}, {params[:,2].max():.4f}]")
    print(f"    gmax_fac    ∈ [{params[:,3].min():.4f}, {params[:,3].max():.4f}]")
    print(f"    eps_fac     ∈ [{params[:,4].min():.4f}, {params[:,4].max():.4f}]")

    # Loss test
    x_clean = yc + torch.randn_like(yc) * 0.1
    loss_fn = SPADEUnrolledLoss()
    loss, details = loss_fn(x_hat, x_clean, yc, Ir, Icp, Icm)
    print(f"\n  Loss: {loss.item():.6f}")
    for k, v in details.items():
        print(f"    {k:12s}: {v:.6f}")

    # Check gradients
    model.train()
    x_hat2, _, z2, xm2 = model(yc, ctx, Ir, Icp, Icm)
    loss2, _  = loss_fn(x_hat2, x_clean, yc, Ir, Icp, Icm, z_thresh=z2, x_hat_mid=xm2)
    loss2.backward()
    grad_norms = {
        name: p.grad.norm().item()
        for name, p in model.named_parameters()
        if p.grad is not None
    }
    print(f"\n  Gradient norms (sample):")
    for k, v in list(grad_norms.items())[:6]:
        print(f"    {k:40s}: {v:.6f}")

    print("\n  ✓ Smoke test passed.")


if __name__ == "__main__":
    _smoke_test()