simone00/mymodel

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

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

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

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