README.md

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