# SPADE Limiter Recovery — Documentazione ## Panoramica Due script che formano una pipeline completa per il recupero di dinamiche compresse da un brickwall limiter su materiale percussivo. | Script | Ruolo | |---|---| | `spade_declip_v12.py` | Algoritmo di recupero (SPADE solver + GPU) | | `run_smart_sweep.py` | Ottimizzazione bayesiana dei parametri (Optuna) | --- ## `spade_declip_v12.py` ### Cosa fa Implementa S-SPADE e A-SPADE — algoritmi di audio declipping basati su ottimizzazione sparsa nel dominio trasformato (DCT/RDFT). In modalità `soft` il problema viene esteso dal declipping classico al **recupero di dinamiche compresse da un brickwall limiter**: i campioni sopra la soglia vengono trattati come lower-bound (non come equality), permettendo all'ADMM di recuperare valori superiori al segnale limitato. ### Algoritmo Il solver risolve iterativamente: ``` minimizza ||A(x)||₀ (L0 nel dominio trasformato) soggetto a x ∈ Γ (consistency set: vincoli dal segnale limitato) ``` tramite ADMM (Alternating Direction Method of Multipliers): - **Step 2** — hard thresholding H_k: mantiene i k coefficienti più grandi - **Step 3** — proiezione su Γ: impone i constraint del segnale limitato - **Step 7** — aggiornamento duale: accumula le correzioni residue ### Struttura del processing ``` input limitato ↓ [DC removal] → [mask detection Ir/Icp/Icm] ↓ [macro_expand pre-pass] ← opzionale, v11 ↓ [_lr_split per banda] ← opzionale multiband, v11 ↓ [WOLA frame extraction] ↓ [SPADE su ogni frame] ← GPU batch (F, M) tensor / CPU ThreadPool ↓ [WOLA accumulation + normalizzazione] ↓ [safe-Ir RMS match] ← v12: esclude campioni contaminati da WOLA ↓ output recuperato ``` ### Versioni e feature principali **v10 — GPU acceleration** - Tutti i frame attivi impacchettati in un batch tensor `(F, M)` e processati in un singolo kernel GPU - Supporto CUDA (NVIDIA) e ROCm (AMD, testato su RX 6700 XT) - Convergenza tracciata per-frame con maschera booleana: i frame convergenti vengono "congelati" mentre gli altri continuano a iterare - Speedup tipico: 15–100× rispetto a CPU single-thread **v11 — Delimiting features** (tutte disabilitate di default) - `release_ms > 0` — Dilatazione maschere: i campioni nel range di release del limiter vengono riclassificati da Ir a Icp/Icm, permettendo all'ADMM di recuperare la coda del transiente - `max_gain_db > 0` — Upper bound sulla proiezione: previene transienti artificiali causati da ADMM senza limite di guadagno - `multiband=True` — Split Linkwitz-Riley per banda con perfect reconstruction (`hp = x - lp`): ogni banda viene processata indipendentemente con il suo `delta_db`, poi sommata. I filtri sono IIR zero-phase (`sosfiltfilt`) — nessuna distorsione di fase - `macro_expand=True` — Pre-pass di espansione macro-dinamica: recupera la soppressione di livello (body compression) a lungo termine che SPADE non può correggere per via della finestra WOLA corta (~21 ms) **v12 — LF recovery** (nuovo) - `hard_thresh_lf` / `_hard_thresh_lf_gpu` — Hard thresholding stratificato per frequenza: garantisce un budget minimo di `lf_k_min` coefficienti nelle bande sotto `lf_cutoff_hz`, indipendente dalla competizione con i bin HF. Risolve il sistematico sotto-recupero LF (-3÷-8 dB su sub-bass) causato dal fatto che il limiter attenuava i coefficienti LF rendendoli invisibili al top-k globale nelle prime iterazioni ADMM - Safe-Ir RMS match: esclude dal calcolo RMS i campioni Ir entro `window_length` campioni da qualsiasi boundary Icp/Icm, prevenendo che il bleed WOLA dell'energia LF recuperata causasse un rescaling globale verso il basso che annullava parzialmente il recupero stesso **Bug fix ereditati** - BUG-1: flip output (non input) nella sintesi DST dell'RDFT - BUG-2: variabile duale A-SPADE nel dominio coefficienti, non segnale - BUG-3: WOLA gain drift per canale in elaborazione stereo - BUG-4: DC offset che rompeva la rilevazione delle maschere a mezza onda ### Nota sui filtri IIR Tutti i filtri nel codebase sono **zero-phase** (`sosfiltfilt`) eccetto il generatore di rumore rosa in `run_smart_sweep.py` (IIR causale, usato solo per la generazione del corpus, mai nel path critico). Nessun filtro introduce distorsione di fase nel segnale processato o nel residual usato per la metrica. ### `DeclipParams` — parametri principali ```python DeclipParams( algo = "sspade", # "sspade" (default) | "aspade" frame = "rdft", # "rdft" (default, P=2M) | "dct" (P=M) mode = "soft", # "soft" = limiter recovery | "hard" = clipping delta_db = 2.5, # dB dalla soglia del limiter a 0 dBFS window_length = 1024, # campioni per frame WOLA hop_length = 256, # hop WOLA (overlap = 1 - hop/win) s = 1, # sparsity step (incremento k per iter) r = 1, # sparsity rate (ogni r iter si incrementa k) eps = 0.1, # criterio di convergenza ADMM max_iter = 1000, # iterazioni massime per frame sample_rate = 44100, # v11 release_ms = 0.0, # dilatazione maschere (0 = disabilitato) max_gain_db = 0.0, # cap recupero dB (0 = disabilitato) multiband = False, band_crossovers = (250, 4000), # Hz, usati solo se multiband=True band_delta_db = (), # per-band delta_db; vuoto = usa delta_db macro_expand = False, macro_ratio = 1.2, # usato solo se macro_expand=True # v12 lf_cutoff_hz = 0.0, # Hz soglia bin LF (0 = disabilitato) lf_k_min = 0, # slot LF garantiti per iterazione ADMM # GPU use_gpu = True, gpu_device = "auto", ) ``` ### Dipendenze ``` pip install numpy scipy soundfile pip install torch # opzionale, per GPU ``` ### CLI ```bash python spade_declip_v12.py input.wav output.wav --mode soft --delta-db 2.5 # Con feature v11/v12 python spade_declip_v12.py input.wav output.wav \ --mode soft --delta-db 2.5 \ --release-ms 80 --max-gain-db 6 \ --lf-cutoff-hz 1000 --lf-k-min 8 ``` --- ## `run_smart_sweep.py` ### Cosa fa Ottimizzazione bayesiana degli iperparametri di `spade_declip_v12.py` su un corpus di drum sample. Usa Optuna TPE (Tree-structured Parzen Estimator) con MedianPruner per interrompere trial chiaramente sotto-performanti a metà corpus. ### Pipeline di valutazione Per ogni trial Optuna: ``` 1. Corpus costruito una volta sola all'avvio (build_corpus): - Carica drum sample (Kicks / Snares / Perc / Tops) - Normalizza a 0 dBFS peak - Aggiunge rumore rosa a -20 dB (simula sottofondo musicale) - Ri-normalizza a 0 dBFS - Applica limiter sintetico (brickwall, attack=1 campione, release=80 ms) - Calcola GT residual = originale − limitato - Conserva GT_res (peak-normalizzato, per cosine sim) e GT_res_raw (scala originale, per confronto energetico assoluto) 2. Per ogni trial: - Shuffle del corpus con seed = trial.number (riproducibile) - Prima metà del corpus → GPU mega-batch → check pruning - Seconda metà del corpus → GPU mega-batch → score finale - Calcolo score_breakdown per ogni file - Aggregazione e salvataggio user_attrs su Optuna ``` ### Limiter sintetico ``` Soglia: -3.0 dBFS (LIMITER_THRESHOLD_DB) Release: 80 ms (LIMITER_RELEASE_MS) Attack: 1 campione (brickwall vero) ``` La soglia è volutamente a 3 dB per creare un regime di limitazione significativo che metta alla prova il recupero LF. Il rumore rosa simula il contesto musicale su cui il limiter agisce, rendendo il training più rappresentativo dell'uso reale su full mix. ### Score composito — `score_breakdown` Il best score riportato da Optuna è lo **score composito**, non la cosine similarity semplice. Questo perché la cosine sim è scale-invariant e non rileva il deficit energetico LF. Sette metriche calcolate per ogni file: | Campo | Cosa misura | |---|---| | `cosine` | Cosine sim TF globale (shape spettrale, 12 bande log) | | `cosine_lf` | Cosine sim in 20–500 Hz (shape corpo sub-bass/bass) | | `cosine_hf` | Cosine sim in 2k–20k Hz (shape attacco/brillantezza) | | `energy_lf_db` | `RMS_lf(SPADE) − RMS_lf(GT)` su scala originale, dB | | `energy_hf_db` | idem per HF | | `overrecovery` | 1 se energy_lf_db > +3 dB (artefatti LF) | | `composite` | Score composito usato come obiettivo Optuna | **Formula composite:** ``` pen_lf = exp(min(0, energy_lf_db) / 6) # penalità sub-recupero LF pen_hf = exp(min(0, energy_hf_db) / 10) # penalità sub-recupero HF (più morbida) composite = cosine × pen_lf^0.5 × pen_hf^0.2 ``` La penalità LF è più aggressiva (esponente 0.5 vs 0.2, costante 6 vs 10) perché il problema di under-recovery LF era il deficit principale identificato a -3÷-8 dB su sub-bass. A -6 dB sotto GT, `pen_lf^0.5 ≈ 0.61` — lo score scende di ~39% rispetto alla cosine sim sola. L'energia è confrontata su **scala originale** (GT_res_raw, non normalizzato) per evitare che la peak-normalizzazione a RESIDUAL_DBFS mascheri il deficit assoluto. ### GPU mega-batch Per minimizzare il costo di ogni trial su GPU AMD RX 6700 XT (RDNA2), tutti i frame attivi dell'intero corpus vengono impacchettati in un unico tensore `(F_total, M)` e processati con un singolo `_sspade_batch_gpu`. Con corpus da ~50 file × ~350 frame ≈ 17500 frame, la GPU rimane a MCLK massimo per tutta la durata del kernel invece di ciclare tra idle e burst per ogni file. Il pruning rimane funzionale: il corpus viene diviso in due metà, la prima viene processata, lo score intermedio viene reportato a Optuna, e se il trial è chiaramente sotto-performante viene interrotto prima di processare la seconda. ### Spazio di ricerca | Parametro | Range | Note | |---|---|---| | `delta_db` | 1.5 – 3.5 dB | Calibrato sulla soglia del limiter a 3 dB | | `window_length` | 512 / 1024 / 2048 | via `win_exp` ∈ {9,10,11} | | `hop_length` | win/4 o win/8 | overlap 75% o 87.5% | | `release_ms` | 10 – 200 ms | 0 = disabilitato | | `max_gain_db` | 2 – 12 dB | cap recupero | | `eps` | 0.03 / 0.05 / 0.1 | criterio convergenza ADMM | | `max_iter` | 250 / 500 / 1000 | iterazioni massime | | `multiband` | True/False | split LF/HF | | `lf_delta_db` | 0.5 – 2.0 dB | delta per banda LF (se multiband) | | `macro_expand` | True/False | pre-pass espansione | | `macro_ratio` | 1.1 – 2.0 | rapporto espansione | | `lf_cutoff_hz` | 0 / 500 / 1000 / 2000 Hz | soglia bin LF garantiti | | `lf_k_min` | 0 – 16 | slot LF per iterazione ADMM | Il corpus viene **shufflato** con seed deterministico pari al numero del trial (`trial.number`) per prevenire bias sull'ordine dei file — senza shuffle, i file all'inizio della lista avrebbero peso sistematicamente maggiore nel pruning. ### `trial.set_user_attr` — diagnostica per trial Ogni trial completato salva nel database Optuna: ``` cosine_overall, cosine_lf, cosine_hf → shape spettrale per banda energy_lf_db, energy_hf_db → deficit/surplus energetico assoluto n_overrecovery → file con LF > +3 dB sopra GT score_std → consistenza cross-file n_files_scored → file processati ``` ### Dipendenze ``` pip install numpy scipy soundfile optuna rich pip install torch # per GPU ``` ### CLI ```bash # Sweep completo (200 trial di default) python run_smart_sweep.py # Test rapido python run_smart_sweep.py --trials 20 # Riprende da database esistente python run_smart_sweep.py --resume # Solo report finale (no sweep) python run_smart_sweep.py --report # Cartella custom python run_smart_sweep.py --base-dir /path/to/samples ``` --- ## Stato e limitazioni note ### Cosa funziona - Recupero HF (2k–20k Hz) robusto, +12÷+18 dB rispetto al limitato su kick - GPU mega-batch su AMD RX 6700 XT funzionante, speedup ~15–20× - Ottimizzazione bayesiana riprendibile, stabile dopo ~80 trial - Score composito con penalità energetica LF misura correttamente il deficit che la cosine sim sola non rileva ### Limitazioni attuali - Il corpus è composto da **sample percussivi isolati** con rumore rosa sintetico. I parametri ottimali su sample isolati possono non generalizzare a full mix musicali dove il limiter agisce su strati sovrapposti - Il limiter sintetico (threshold-based, release esponenziale fissa) è un'approssimazione di limitatori commerciali come FabFilter Pro-L 2 che usano curve di release adattive e lookahead - `A-SPADE` non ha ancora il path GPU (solo S-SPADE è accelerato) - I parametri SPADE sono **costanti per file**: il solver non si adatta frame-per-frame alla struttura locale del segnale (onset vs. release vs. silenzio). Questo è il limite strutturale principale rispetto a un approccio di tipo SPADE Unrolled ### Direzione di sviluppo: SPADE Unrolled L'evoluzione naturale del sistema è sostituire i parametri fissi con un **Context Encoder** (rete neurale piccola, ~100K parametri) che predice `λ_LF`, `λ_HF`, `delta_factor` e `gmax_factor` per ogni frame in base al contesto temporale dei K frame precedenti. Il solver SPADE viene trasformato in K layer fissi (unrolling), con `soft_thresh` stratificato al posto di `hard_thresh` per differenziabilità. Il gradiente della loss fluisce attraverso i K layer ADMM fino all'encoder. Il training è proposto in due fasi: 1. **Fase 1** su sample isolati con rumore rosa (corpus attuale) — convergenza rapida, ground truth esatto, encoder impara la firma della limitazione 2. **Fase 2** su full mix con lo stesso limiter sintetico applicato a stems sommati (Strategia A) — adattamento alla distribuzione reale, con mixed batching per prevenire catastrophic forgetting della Fase 1 La componente algoritmica di SPADE garantisce che il modello non possa inventare contenuto assente nel segnale limitato — solo i parametri del solver vengono appresi, non una mappatura arbitraria input→output.