| # 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. |
|
|
