""" run_smart_sweep.py — S-SPADE · Bayesian parameter search (v2) =================================================================== PIPELINE GROUND-TRUTH (Case 1 — threshold-based limiter) --------------------------------------------------------- Il limiter sintetico è threshold-based: - Originale normalizzato a 0 dBFS peak - Limiter: attua solo sui picchi sopra la soglia → output max peak ≈ −threshold_db - Il CORPO del segnale (loudness percepita) rimane invariato per definizione - NON si applica nessun gain al segnale limitato dopo il processing Allineamento per il calcolo residual: Originale e limited sono già sulla stessa scala (loudness uguale, picchi diversi). Nessuna normalizzazione LUFS / RMS necessaria o corretta. GT_res = original_0dBFS − limited (scale identiche) res_iter = spade_output − limited (idem) Entrambi vengono poi normalizzati a RESIDUAL_DBFS peak SOLO per rendere comparabili file con diversi livelli assoluti — non altera la logica. Metrica ideale: GT_res ≡ res_iter → cosine_sim = 1.0 → differenza = −∞ dB Ottimizzatore: Optuna TPE (Bayesian) + MedianPruner Storage: SQLite (riprendibile con --resume) Corpus: tutti i drum sample in Kicks / Snares / Perc / Tops DIPENDENZE ---------- pip install numpy scipy soundfile optuna rich (pyloudnorm NON necessario) USO --- python run_smart_sweep.py # 200 trial python run_smart_sweep.py --trials 50 # test rapido python run_smart_sweep.py --resume # riprende da DB python run_smart_sweep.py --report # solo risultati python run_smart_sweep.py --base-dir /path/SPADE # cartella custom """ import argparse import logging import os import sys import time import warnings from pathlib import Path from typing import Dict, List, Optional # ── AMD ROCm performance tuning ─────────────────────────────────────────────── # Must be set BEFORE any torch/ROCm import. # # HSA_ENABLE_SDMA=0: disabilita il DMA engine per i trasferimenti host↔device. # Su RDNA (RX 6700 XT e simili) l'SDMA engine ha latenza elevata per batch # piccoli (<1 MB). Usando compute-shader blits invece, il primo trasferimento # è 3-5× più veloce. Nessun effetto su batch grandi. # # GPU_MAX_HW_QUEUES=4: limita le hardware queue a 4 (default=8 su RDNA). # Con 8 queue e un singolo dispatch stream, il driver distribuisce le wave # su queue diverse causando serializzazione. Con 4 si concentrano sullo stesso # ring buffer e si riduce la latenza di scheduling. # # HSA_OVERRIDE_GFX_VERSION: solo se necessario (RX 6700 XT = gfx1031 → OK as-is). os.environ.setdefault("HSA_ENABLE_SDMA", "0") os.environ.setdefault("GPU_MAX_HW_QUEUES", "4") import numpy as np import scipy.signal as sig import soundfile as sf logging.getLogger("optuna").setLevel(logging.WARNING) # ── optuna ─────────────────────────────────────────────────────────────────── try: import optuna from optuna.samplers import TPESampler from optuna.pruners import MedianPruner _HAS_OPTUNA = True except ImportError: _HAS_OPTUNA = False warnings.warn("optuna non trovato — pip install optuna") # ── rich ───────────────────────────────────────────────────────────────────── try: from rich.console import Console from rich.table import Table _console = Console() _HAS_RICH = True except ImportError: _HAS_RICH = False _console = None # ── spade_declip ───────────────────────────────────────────────────────────── try: from spade_declip_v12 import ( declip, DeclipParams, # Internals needed for the GPU mega-batch path in evaluate_corpus_gpu_mega: _compute_masks, _dilate_masks_soft, _macro_expand_pass, _build_lf_mask, _sspade_batch_gpu, ClippingMasks, ) _HAS_SPADE = True except ImportError: _HAS_SPADE = False warnings.warn("spade_declip_v12.py non trovato") # ============================================================================= # CONFIG # ============================================================================= DRUM_DIRS = ["Kicks", "Snares", "Perc", "Tops"] # ── Limiter sintetico ───────────────────────────────────────────────────────── # Case 1: threshold-based. # Originale @ 0 dBFS peak → limiter attua sui picchi > soglia → # output max peak ≈ −LIMITER_THRESHOLD_DB dBFS, loudness invariata. # NON si tocca il segnale limitato con nessun gain dopo. LIMITER_THRESHOLD_DB = 3.0 # dB sotto il ceiling (positivo) LIMITER_RELEASE_MS = 80.0 # release del limiter sintetico (ms) # attack = 1 campione → brickwall vero # Normalizzazione residual — SOLO per comparabilità cross-file. # Scala entrambi GT e iter identicamente, quindi non altera il confronto. RESIDUAL_DBFS = -3.0 # ── Rumore rosa di sottofondo ───────────────────────────────────────────────── # Simula un sottofondo musicale sotto il transiente di batteria. # Viene mixato al sample (già a 0 dBFS peak) PRIMA del limiter. # Questo assicura che: # - il limiter agisca sul segnale realistico drum + music background # - SPADE riceva lo stesso mix e debba lavorare in condizioni realistiche # - GT_res = (drum+noise) − limiter(drum+noise) rifletta la situazione reale # Livello relativo al peak del drum sample. −20 dB = sottofondo ben sotto # il transiente, udibile ma non dominante (come un kick su un loop di batteria). PINK_NOISE_LEVEL_DB = -20.0 # dB rel. al peak del drum (negativo = sotto) # Optuna STUDY_NAME = "spade_smart_v2_thr3db" OUT_CSV = "smart_sweep_results.csv" # Parametri FISSI del solver SPADE (invarianti tra tutti i trial) FIXED_SOLVER = dict( algo = "sspade", frame = "rdft", mode = "soft", s = 1, r = 1, n_jobs = 1, verbose = False, show_progress = False, use_gpu = True, # multiband e macro_expand sono nello spazio di ricerca ) # Crossover multiband (fisso per comparabilita' tra trial) # 250 Hz separa: LF=corpo/punch del kick | HF=transiente/attacco BAND_CROSSOVER_HZ = 250.0 # ============================================================================= # HELPERS # ============================================================================= def ensure_2d(a: np.ndarray) -> np.ndarray: return a[:, None] if a.ndim == 1 else a def normalize_to_0dBFS(a: np.ndarray) -> np.ndarray: """Scala a 0 dBFS peak — usato solo sull'originale come riferimento comune.""" pk = np.max(np.abs(a)) return a / pk if pk > 1e-12 else a def normalize_peak(a: np.ndarray, target_dbfs: float) -> np.ndarray: """ Scala a target_dbfs dBFS peak. Usato SOLO sui residual per comparabilità cross-file; non altera la logica perché GT e iter vengono scalati identicamente. """ pk = np.max(np.abs(a)) return a * (10 ** (target_dbfs / 20.0) / pk) if pk > 1e-12 else a def generate_pink_noise(n_samples: int, n_channels: int, rng: np.random.Generator) -> np.ndarray: """ Genera rumore rosa (1/f) tramite filtro IIR di Voss-McCartney (approssimazione a 5 poli, accurata entro ±1 dB nel range 20 Hz – 20 kHz). Output: shape (n_samples, n_channels), RMS normalizzato a 1.0 (prima del mix-in con PINK_NOISE_LEVEL_DB, che controlla il livello finale). Algoritmo: rumore bianco filtrato con H(z) = 1 / A(z) dove i coefficienti sono ottimizzati per approssimare una densità spettrale 1/f. """ # Coefficienti del filtro IIR a 5 poli (Voss approssimazione) # Poli reali, tutti stabili (|p| < 1) b = np.array([0.049922035, -0.095993537, 0.050612699, -0.004408786]) a = np.array([1.0, -2.494956002, 2.017265875, -0.522189400]) out = np.empty((n_samples, n_channels)) for c in range(n_channels): white = rng.standard_normal(n_samples) pink = sig.lfilter(b, a, white) rms = np.sqrt(np.mean(pink ** 2)) out[:, c] = pink / (rms + 1e-12) # RMS = 1.0 return out def mix_pink_noise( audio_0dBFS: np.ndarray, sr: int, level_db: float, rng: np.random.Generator, ) -> np.ndarray: """ Mixa rumore rosa nel segnale a un livello relativo al suo peak. level_db < 0 → il rumore è sotto il peak del drum (es. −20 dB) Il rumore dura quanto il sample; se il sample è stereo, il rumore è stereo (canali indipendenti → decorrelato come un vero fondo musicale). Il segnale in uscita può superare 0 dBFS di qualche frazione di dB: è corretto, il limiter che segue si occupa di riportarlo sotto la soglia. """ audio = ensure_2d(audio_0dBFS) N, C = audio.shape noise = generate_pink_noise(N, C, rng) # RMS = 1.0 per canale # Scala il rumore al livello desiderato rispetto al peak del drum peak = np.max(np.abs(audio)) gain = peak * (10 ** (level_db / 20.0)) # gain lineare assoluto mixed = audio + noise * gain # NON normalizziamo qui: la normalizzazione a 0 dBFS avviene in build_corpus # subito dopo, su tutto il mix (drum + noise), prima di qualsiasi altra op. return mixed[:, 0] if audio_0dBFS.ndim == 1 else mixed # ============================================================================= # LIMITER SINTETICO (Case 1 — threshold-based, brickwall, 1-campione attack) # ============================================================================= def apply_brickwall_limiter( audio_0dBFS: np.ndarray, sr: int, threshold_db: float = LIMITER_THRESHOLD_DB, release_ms: float = LIMITER_RELEASE_MS, ) -> np.ndarray: """ Brickwall limiter threshold-based. Tenta la GPU (Hillis-Steele parallel prefix scan, O(log N) depth) se PyTorch + CUDA/ROCm sono disponibili, altrimenti Numba JIT, altrimenti loop numpy ottimizzato. Input: audio_0dBFS — già a 0 dBFS peak, shape (N,) o (N, C) Output: segnale limitato, stessa shape — NON boosted, NON clippato """ thr_lin = 10 ** (-abs(threshold_db) / 20.0) rc = np.exp(-1.0 / max(release_ms * sr / 1000.0, 1e-9)) audio = ensure_2d(audio_0dBFS).copy().astype(np.float32) N, C = audio.shape # ── GPU path (preferred) ────────────────────────────────────────────── try: import torch if torch.cuda.is_available(): dev = "cuda" out = np.empty_like(audio) for c in range(C): x_t = torch.from_numpy(audio[:, c]).to(device=dev) y_t = _brickwall_limiter_gpu(x_t, thr_lin, rc) out[:, c] = y_t.cpu().numpy() return out[:, 0] if audio_0dBFS.ndim == 1 else out except Exception: pass # fall through to CPU paths # ── Numba JIT path ──────────────────────────────────────────────────── try: from numba import njit @njit(cache=True) def _limiter_loop_nb(ch: np.ndarray, thr: float, rc: float, g_out: np.ndarray) -> None: env = 1.0 for n in range(len(ch)): pk = abs(ch[n]) target = thr / pk if pk > thr else 1.0 env = target if target < env else rc * env + (1.0 - rc) * target g_out[n] = env out = np.empty(audio.shape, dtype=np.float32) for c in range(C): g = np.empty(N, dtype=np.float32) _limiter_loop_nb(audio[:, c].astype(np.float64), thr_lin, rc, g) out[:, c] = audio[:, c] * g return out[:, 0] if audio_0dBFS.ndim == 1 else out except ImportError: pass # ── Pure-numpy fallback ─────────────────────────────────────────────── out = np.empty_like(audio) for c in range(C): ch = audio[:, c].astype(np.float64) pk = np.abs(ch) g_instant = np.where(pk > thr_lin, thr_lin / np.maximum(pk, 1e-12), 1.0) g = np.empty(N) env = 1.0 gi = g_instant for n in range(N): t = gi[n] env = t if t < env else rc * env + (1.0 - rc) * t g[n] = env out[:, c] = ch * g return out[:, 0] if audio_0dBFS.ndim == 1 else out # ============================================================================= # COSINE SIMILARITY TF # ============================================================================= def cosine_sim_tf( gt: np.ndarray, est: np.ndarray, sr: int, win_samples: int = 1024, hop_samples: int = 256, n_bands: int = 12, ) -> float: """ Similarità coseno media su micro-finestre tempo-frequenziali. Input: entrambi già a RESIDUAL_DBFS peak. Output: scalare in [0, 1]. Target ideale = 1.0. """ L = min(gt.shape[0], est.shape[0]) g = (gt[:L, 0] if gt.ndim == 2 else gt[:L]).copy() e = (est[:L, 0] if est.ndim == 2 else est[:L]).copy() win = min(win_samples, max(32, L // 4)) hop = min(hop_samples, win // 2) if L < win or win < 32: denom = np.linalg.norm(g) * np.linalg.norm(e) + 1e-12 return float(np.dot(g, e) / denom) _, _, Zg = sig.stft(g, fs=sr, window="hann", nperseg=win, noverlap=win - hop, boundary=None, padded=False) _, _, Ze = sig.stft(e, fs=sr, window="hann", nperseg=win, noverlap=win - hop, boundary=None, padded=False) n_freqs, n_frames = Zg.shape if n_frames == 0: return float(np.dot(g, e) / (np.linalg.norm(g) * np.linalg.norm(e) + 1e-12)) edges = np.unique(np.round( np.logspace(0, np.log10(max(n_freqs, 2)), min(n_bands, n_freqs) + 1) ).astype(int)) edges = np.clip(edges, 0, n_freqs) sims = [] for i in range(len(edges) - 1): f0, f1 = int(edges[i]), int(edges[i + 1]) if f1 <= f0: continue Mg = np.abs(Zg[f0:f1, :]) Me = np.abs(Ze[f0:f1, :]) dot = np.sum(Mg * Me, axis=0) norm_g = np.sqrt(np.sum(Mg ** 2, axis=0)) + 1e-12 norm_e = np.sqrt(np.sum(Me ** 2, axis=0)) + 1e-12 sims.extend((dot / (norm_g * norm_e)).tolist()) return float(np.mean(sims)) if sims else 0.0 # ============================================================================= # CORPUS # ============================================================================= def build_corpus(base_dir: Path, max_files: Optional[int] = None) -> List[Dict]: """ Per ogni drum sample: 1. Carica e normalizza a 0 dBFS peak (riferimento comune cross-file) 2. Mixa rumore rosa a PINK_NOISE_LEVEL_DB rel. al peak ← NUOVO Il mix avviene in float (può temporaneamente superare 0 dBFS) 3. Normalizza il mix (drum + noise) a 0 dBFS peak Riferimento comune prima di tutta la pipeline successiva 4. Applica limiter sintetico su (drum + noise) normalizzato → limited 4. GT_res_raw = (drum + noise) − limited (stessa scala, nessun gain) 5. Scarta file dove il limiter non interviene 6. Normalizza GT_res a RESIDUAL_DBFS (solo comparabilità cross-file) Il rumore è riproducibile: ogni file usa un seed deterministico derivato dal suo indice nel corpus, così i trial sono comparabili tra loro. """ corpus = [] extensions = {".wav", ".flac", ".aif", ".aiff"} file_index = 0 # usato per seed deterministico del rumore for folder in DRUM_DIRS: d = base_dir / folder if not d.exists(): print(f" [WARN] Cartella non trovata: {d}") continue for f in sorted(d.glob("*")): if f.suffix.lower() not in extensions: continue try: audio, sr = sf.read(str(f), always_2d=True) audio = audio.astype(float) except Exception as exc: print(f" [WARN] {f.name}: {exc}") continue if audio.shape[0] < 64: continue # 1. 0 dBFS peak orig = normalize_to_0dBFS(audio) # 2. Mix rumore rosa — seed deterministico per riproducibilità rng = np.random.default_rng(seed=file_index) orig_with_noise = ensure_2d(mix_pink_noise(orig, sr, PINK_NOISE_LEVEL_DB, rng)) file_index += 1 # 3. Normalizza il mix a 0 dBFS peak — riferimento comune prima # di tutta la pipeline. Il mix in float può aver superato 0 dBFS; # questa normalizzazione azzera il problema prima del limiter. orig_with_noise = ensure_2d(normalize_to_0dBFS(orig_with_noise)) # 4. Limiter sintetico su (drum + noise) @0dBFS — nessun gain dopo limited = ensure_2d(apply_brickwall_limiter(orig_with_noise, sr)) # 5. Residual grezzo — stessa scala, zero aggiustamenti gt_res_raw = orig_with_noise - limited # 6. Verifica attività del limiter if np.max(np.abs(gt_res_raw)) < 1e-6: print(f" [SKIP] {f.name} — picco sotto la soglia, limiter inattivo") continue # 7. Normalizza a RESIDUAL_DBFS solo per comparabilità cross-file gt_res = normalize_peak(gt_res_raw, RESIDUAL_DBFS) corpus.append({ "file" : f.name, "sr" : sr, "limited" : limited, # input a SPADE = drum + noise + limiter "gt_res" : gt_res, # target residual }) if max_files and len(corpus) >= max_files: return corpus return corpus # ============================================================================= # VALUTAZIONE SINGOLO FILE # ============================================================================= def evaluate_one(item: Dict, params: dict) -> Optional[float]: """ Esegue SPADE su limited, calcola il residual e lo confronta con GT. params contiene parametri SPADE puri + flag di alto livello: multiband (bool) -- split LF/HF, elabora separatamente macro_expand (bool) -- envelope pre-pass per recupero corpo LF macro_ratio (float) -- rapporto espansione (1.0 = bypass) lf_delta_db (float) -- delta_db per banda LF (<= BAND_CROSSOVER_HZ) il delta_db standard e' usato per la banda HF lf_cutoff_hz (float) -- v12: Hz sotto cui riservare bin LF (0 = off) lf_k_min (int) -- v12: slot LF garantiti per iterazione ADMM """ try: sr = item["sr"] limited = item["limited"].copy() gt_res = item["gt_res"] # Estrai flag di alto livello (non sono parametri DeclipParams diretti) p2 = dict(params) # copia per non mutare l'originale multiband = p2.pop("multiband", False) macro_expand = p2.pop("macro_expand", False) macro_ratio = p2.pop("macro_ratio", 1.0) lf_delta_db = p2.pop("lf_delta_db", p2.get("delta_db", 1.5)) # v12: stratified thresholding params — passati direttamente a DeclipParams # (già nel dict p2, non richiedono pop separato) spade_kw = dict( multiband = multiband, macro_expand = macro_expand, macro_ratio = macro_ratio if macro_expand else 1.0, macro_release_ms = 200.0, macro_attack_ms = 10.0, ) if multiband: spade_kw["band_crossovers"] = (BAND_CROSSOVER_HZ,) spade_kw["band_delta_db"] = (lf_delta_db, p2["delta_db"]) p = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **p2, **spade_kw) fixed, _ = declip(limited, p) fixed_2d = ensure_2d(fixed) # Residual generato — stessa scala dell'input, nessun gain res_raw = fixed_2d - limited res_iter = normalize_peak(res_raw, RESIDUAL_DBFS) # GPU cosine sim when available, CPU fallback otherwise try: import torch g = gt_res[:, 0] if gt_res.ndim == 2 else gt_res e = (res_iter[:, 0] if res_iter.ndim == 2 else res_iter).astype(np.float32) dev = "cuda" if torch.cuda.is_available() else "cpu" g_t = torch.from_numpy(g.astype(np.float32)).to(dev) e_t = torch.from_numpy(e).to(dev) Lmin = min(g_t.shape[0], e_t.shape[0]) return _cosine_sim_gpu(g_t[:Lmin], e_t[:Lmin]) except Exception: return cosine_sim_tf(gt_res, res_iter, sr) except Exception as exc: warnings.warn(f"evaluate_one ({item['file']}): {exc}") return None # ============================================================================= # GPU MEGA-BATCH (v12 — AMD RX 6700 XT optimisation) # ============================================================================= # ============================================================================= # GPU PIPELINE — tutti i pass su GPU (v13) # ============================================================================= # # Architettura # ------------ # _brickwall_limiter_gpu : limiter con Hillis-Steele parallel prefix scan # _compute_masks_gpu : boolean tensor ops # _dilate_masks_gpu : F.max_pool1d invece di np.convolve # _extract_frames_gpu : tensor.unfold → frame batch senza loop Python # _wola_gpu : scatter_add_ → overlap-add senza loop Python # _rms_match_gpu : F.max_pool1d per near-clip + ops tensore # _cosine_sim_gpu : torch.stft → cosine sim senza scipy # evaluate_corpus_gpu_mega : pipeline completa — zero numpy nel hot-path # ============================================================================= def _brickwall_limiter_gpu( audio_t: "torch.Tensor", # (L,) o (C, L) float32 thr_lin: float, rc: float, ) -> "torch.Tensor": """ Brickwall limiter su GPU tramite Hillis-Steele parallel prefix scan. Recurrence (causal): env[n] = min(target[n], rc * env[n-1] + (1-rc) * target[n]) Rappresentazione funzione clamp-lineare f(y) = min(t, r*y + c): - r_n = rc, c_n = (1-rc)*target[n], t_n = target[n] Operatore di composizione h_a ⋆ h_b (applica h_a prima, poi h_b): r_ab = r_a * r_b c_ab = r_b * c_a + c_b t_ab = min(t_b, r_b * t_a + c_b) Hillis-Steele inclusive prefix scan con ⋆ → O(log N) depth. Risultato: scan[n] = f_0 ⋆ f_1 ⋆ ... ⋆ f_n env[n] = scan[n](env_init=1.0) = min(t_prefix[n], r_prefix[n] + c_prefix[n]) """ import torch, math as _m squeeze = audio_t.dim() == 1 if squeeze: audio_t = audio_t.unsqueeze(0) # (1, L) C, L = audio_t.shape dev = audio_t.device dt = audio_t.dtype # ── Step 1: instantaneous gain target (fully parallel) ──────────────── pk = audio_t.abs().clamp(min=1e-12) target = (thr_lin / pk).clamp(max=1.0) # (C, L) # ── Step 2: Hillis-Steele prefix scan ───────────────────────────────── inv_rc = 1.0 - rc # Each position n represents f_n: (r=rc, c=(1-rc)*target[n], t=target[n]) r = torch.full((C, L), rc, device=dev, dtype=dt) c = target * inv_rc # (C, L) t = target.clone() # (C, L) d = 1 while d < L: # Clone previous step (Hillis-Steele requires read-before-write) r_p = r.clone() c_p = c.clone() t_p = t.clone() # For positions i >= d: scan[i] = scan_prev[i-d] ⋆ scan_prev[i] r_l = r_p[:, :-d]; c_l = c_p[:, :-d]; t_l = t_p[:, :-d] r_r = r_p[:, d:]; c_r = c_p[:, d:]; t_r = t_p[:, d:] r[:, d:] = r_l * r_r c[:, d:] = r_r * c_l + c_r t[:, d:] = torch.minimum(t_r, r_r * t_l + c_r) d *= 2 # ── Step 3: evaluate at env_init = 1.0 ─────────────────────────────── env = torch.minimum(t, r + c) # (C, L) out = audio_t * env return out.squeeze(0) if squeeze else out def _compute_masks_gpu( yc_t: "torch.Tensor", # (L,) float thresh: float, ) -> "tuple[torch.Tensor, torch.Tensor, torch.Tensor]": """GPU version of _compute_masks. Returns (Ir, Icp, Icm) bool tensors.""" Icp = yc_t >= thresh Icm = yc_t <= -thresh Ir = ~(Icp | Icm) return Ir, Icp, Icm def _dilate_masks_gpu( Icp_t: "torch.Tensor", # (L,) bool Icm_t: "torch.Tensor", # (L,) bool yc_t: "torch.Tensor", # (L,) float rel_samp: int, ) -> "tuple[torch.Tensor, torch.Tensor, torch.Tensor]": """ GPU forward morphological dilation of soft-mode masks. Replaces np.convolve(..., ones(rel_samp+1))[:N] > 0 with F.max_pool1d(causal_pad, kernel=rel_samp+1, stride=1). Causal dilation: each True in Icp/Icm infects the next rel_samp positions. Equivalent to convolving with a boxcar of length rel_samp+1 (causal). max_pool1d with left-padding of rel_samp achieves this. """ import torch.nn.functional as F if rel_samp <= 0: return ~(Icp_t | Icm_t), Icp_t, Icm_t L = yc_t.shape[0] k = rel_samp + 1 # kernel size matching np.ones(rel_samp + 1) def _dilate(mask_t): # (1, 1, L) → pad left by rel_samp → max_pool(kernel=k, stride=1) → (1,1,L) x = mask_t.float().unsqueeze(0).unsqueeze(0) # (1, 1, L) x = F.pad(x, (rel_samp, 0), value=0.0) # left-pad for causality x = F.max_pool1d(x, kernel_size=k, stride=1) # (1, 1, L) return x.squeeze().bool()[:L] dil_union = _dilate(Icp_t | Icm_t) # any clipped → forward dilation new_Icp = dil_union & (yc_t >= 0) new_Icm = dil_union & (yc_t < 0) new_Ir = ~(new_Icp | new_Icm) return new_Ir, new_Icp, new_Icm def _extract_frames_gpu( yc_t: "torch.Tensor", # (L,) float — DC-removed, normalised Ir_t: "torch.Tensor", # (L,) bool Icp_t: "torch.Tensor", # (L,) bool Icm_t: "torch.Tensor", # (L,) bool M: int, a: int, win_t: "torch.Tensor", # (M,) float thresh: float, ) -> "tuple": """ GPU frame extraction using tensor.unfold — zero Python loops. Returns ------- yc_active : (n_active, M) float — windowed frames for SPADE Ir_active : (n_active, M) bool Icp_active : (n_active, M) bool Icm_active : (n_active, M) bool is_active : (N,) bool — bypass mask for ALL N frames N : int — total number of frames idx1s_t : (N,) long — start indices for WOLA """ import torch.nn.functional as F L = yc_t.shape[0] import math N = math.ceil(L / a) dev = yc_t.device # Pad to N*a + M to ensure all frames are exactly M samples pad_len = N * a + M - L yc_pad = F.pad(yc_t, (0, pad_len), value=0.0) Ir_pad = F.pad(Ir_t.float(), (0, pad_len), value=1.0).bool() Icp_pad = F.pad(Icp_t.float(),(0, pad_len), value=0.0).bool() Icm_pad = F.pad(Icm_t.float(),(0, pad_len), value=0.0).bool() # unfold: (L_padded,) → (N, M) — zero-copy strided view yc_frames = yc_pad.unfold(0, M, a) # (N, M) Ir_frames = Ir_pad.unfold(0, M, a) # (N, M) bool Icp_frames = Icp_pad.unfold(0, M, a) Icm_frames = Icm_pad.unfold(0, M, a) # Per-frame peak → bypass decision (fully parallel) frame_peaks = yc_frames.abs().amax(dim=-1) # (N,) is_active = frame_peaks >= thresh # (N,) bool # Active frames yc_active = yc_frames [is_active] * win_t # (n_active, M) windowed Ir_active = Ir_frames [is_active] Icp_active = Icp_frames[is_active] Icm_active = Icm_frames[is_active] idx1s_t = torch.arange(N, device=dev, dtype=torch.long) * a # (N,) return yc_active, Ir_active, Icp_active, Icm_active, is_active, N, idx1s_t def _wola_gpu( x_active_t: "torch.Tensor", # (n_active, M) float — SPADE output is_active: "torch.Tensor", # (N,) bool idx1s_t: "torch.Tensor", # (N,) long — frame start indices yc_t: "torch.Tensor", # (L,) float — original signal (for bypass) win_t: "torch.Tensor", # (M,) float L: int, M: int, ) -> "torch.Tensor": """ GPU WOLA overlap-add via scatter_add_ — zero Python loops. Bypassed frames accumulate yc * win^2. Active frames accumulate x_spade * win. norm_win accumulates win^2 for ALL frames. """ import torch.nn.functional as F dev = x_active_t.device dt = x_active_t.dtype win2 = win_t ** 2 # (M,) N = idx1s_t.shape[0] # Index matrix for ALL N frames: (N, M) col = torch.arange(M, device=dev, dtype=torch.long) idx_mat = idx1s_t.unsqueeze(1) + col.unsqueeze(0) # (N, M) # Output buffers (L+M to avoid OOB) x_out = torch.zeros(L + M, device=dev, dtype=dt) norm_out = torch.zeros(L + M, device=dev, dtype=dt) # norm_win: all N frames contribute win^2 norm_vals = win2.unsqueeze(0).expand(N, -1) # (N, M) norm_out.scatter_add_(0, idx_mat.reshape(-1), norm_vals.reshape(-1)) # Bypassed frames: yc * win^2 byp_mask = ~is_active if byp_mask.any(): byp_idx = idx_mat[byp_mask] # (n_byp, M) yc_pad = F.pad(yc_t, (0, M)) # (L+M,) byp_yc = yc_pad[byp_idx] # (n_byp, M) — gather byp_val = byp_yc * win2.unsqueeze(0) x_out.scatter_add_(0, byp_idx.reshape(-1), byp_val.reshape(-1)) # Active frames: x_spade * win if is_active.any(): act_idx = idx_mat[is_active] # (n_active, M) act_val = x_active_t.to(dt) * win_t.unsqueeze(0) # (n_active, M) x_out.scatter_add_(0, act_idx.reshape(-1), act_val.reshape(-1)) norm_clamped = norm_out[:L].clamp(min=1e-12) return x_out[:L] / norm_clamped def _rms_match_gpu( x_t: "torch.Tensor", # (L,) float — reconstructed signal yc_t: "torch.Tensor", # (L,) float — input (DC-removed) Ir_t: "torch.Tensor", # (L,) bool — reliable samples M: int, ) -> "torch.Tensor": """ GPU reliable-sample RMS match (v12 safe-Ir). Replaces np.convolve(...) for near-clip detection with F.max_pool1d. All ops stay on GPU — returns rescaled x_t tensor. """ import torch.nn.functional as F if Ir_t.sum() == 0: return x_t # Near-clip: any Ir sample within M of a clip boundary is "contaminated" clip_f = (~Ir_t).float().unsqueeze(0).unsqueeze(0) # (1, 1, L) near = F.max_pool1d(clip_f, M, stride=1, padding=M // 2).squeeze()[:len(Ir_t)] > 0 safe_Ir = Ir_t & ~near use_Ir = safe_Ir if safe_Ir.sum() >= 100 else Ir_t rms_in = yc_t[use_Ir].pow(2).mean().sqrt() rms_out = x_t [use_Ir].pow(2).mean().sqrt() if rms_out > 1e-12 and rms_in > 1e-12: x_t = x_t * (rms_in / rms_out) return x_t def _cosine_sim_gpu( gt_t: "torch.Tensor", # (L,) float — GT residual est_t: "torch.Tensor", # (L,) float — estimated residual win_samples: int = 1024, hop_samples: int = 256, ) -> float: """ GPU cosine similarity via torch.stft. Replaces scipy.signal.stft + numpy band loops with a single GPU STFT call and vectorised band computation. Returns float in [0, 1]. """ import torch L = min(gt_t.shape[0], est_t.shape[0]) g = gt_t [:L].float() e = est_t[:L].float() dev = g.device win_s = min(win_samples, max(32, L // 4)) hop_s = min(hop_samples, win_s // 2) if L < win_s or win_s < 32: denom = g.norm() * e.norm() + 1e-12 return (g * e).sum().item() / denom.item() window = torch.hann_window(win_s, device=dev) # torch.stft: input (L,) → (F, T) complex Zg = torch.stft(g, win_s, hop_s, window=window, return_complex=True, normalized=False) # (F, T) Ze = torch.stft(e, win_s, hop_s, window=window, return_complex=True, normalized=False) Mg = Zg.abs() # (F, T) Me = Ze.abs() # (F, T) dot = (Mg * Me).sum(dim=0) # (T,) norm_g = Mg.norm(dim=0).clamp(min=1e-12) # (T,) norm_e = Me.norm(dim=0).clamp(min=1e-12) # (T,) return (dot / (norm_g * norm_e)).mean().item() # ── GPU corpus cache — upload limited arrays to GPU once per build_corpus ── # Keyed by (id(item), device_str). Cleared at program exit. _GPU_CORPUS_CACHE: dict = {} def evaluate_corpus_gpu_mega( items: List[Dict], params_dict: dict, device: str, ) -> List[Optional[float]]: """ Pipeline interamente GPU — v13. Pass 0 Carica i tensor GPU dal cache (upload one-time per corpus build). Pass 1 Per ogni item: normalise + DC + masks + dilation + unfold (GPU). Raccoglie i frame attivi nel mega-tensor. Pass 2 _sspade_batch_gpu — invariato, già GPU. Pass 3 Per ogni item: WOLA + RMS match + cosine sim (GPU). Nessun trasferimento GPU→CPU fino ai punteggi finali. Rispetto a v12: - Eliminati tutti i loop Python nel hot-path - ThreadPoolExecutor rimosso (serializzazione GPU è già il collo di bottiglia) - numpy utilizzato SOLO per l'inizializzazione degli array corpus (build_corpus) e per raccogliere i punteggi finali (una .item() per file) """ try: import torch import torch.nn.functional as F from scipy.signal import hann as _hann import math as _m except ImportError: return [evaluate_one(item, dict(params_dict)) for item in items] # ── Extract flags ───────────────────────────────────────────────────── p2 = dict(params_dict) multiband = p2.pop("multiband", False) macro_expand = p2.pop("macro_expand", False) macro_ratio = p2.pop("macro_ratio", 1.0) lf_delta_db = p2.pop("lf_delta_db", p2.get("delta_db", 1.5)) if multiband: return [evaluate_one(item, dict(params_dict)) for item in items] # ── Build DeclipParams ──────────────────────────────────────────────── sr_ref = items[0]["sr"] spade_kw = dict( macro_expand=macro_expand, macro_ratio=macro_ratio if macro_expand else 1.0, macro_release_ms=200.0, macro_attack_ms=10.0, ) try: p = DeclipParams(sample_rate=sr_ref, **FIXED_SOLVER, **p2, **spade_kw) except Exception as exc: warnings.warn(f"evaluate_corpus_gpu_mega: DeclipParams error: {exc}") return [None] * len(items) M = p.window_length a = p.hop_length NORM_TGT = 0.9 win_np = np.sqrt(_hann(M, sym=False)).astype(np.float32) win_t = torch.from_numpy(win_np).to(device=device) # (M,) on GPU # ── LF mask tensor ──────────────────────────────────────────────────── lf_mask_t = None if p.lf_cutoff_hz > 0.0 and p.lf_k_min > 0: lf_mask_np = _build_lf_mask(M, p.frame, sr_ref, p.lf_cutoff_hz) lf_mask_t = torch.tensor(lf_mask_np, dtype=torch.bool, device=device) g_max = (10.0 ** (p.max_gain_db / 20.0) if p.max_gain_db > 0.0 else float("inf")) # ── Pass 0: GPU corpus cache ────────────────────────────────────────── # Upload item["limited"] to GPU once; reuse across trials. limited_gpu: list = [] gt_res_gpu: list = [] for item in items: key = (id(item), device) if key not in _GPU_CORPUS_CACHE: ltd = np.asarray(item["limited"], dtype=np.float32) if ltd.ndim == 2: ltd = ltd[:, 0] # take L channel; corpus is mono-per-item _GPU_CORPUS_CACHE[key] = torch.from_numpy(ltd).to(device=device) limited_gpu.append(_GPU_CORPUS_CACHE[key]) gt_key = (id(item), device, "gt") if gt_key not in _GPU_CORPUS_CACHE: gt = np.asarray(item["gt_res"], dtype=np.float32) if gt.ndim == 2: gt = gt[:, 0] _GPU_CORPUS_CACHE[gt_key] = torch.from_numpy(gt).to(device=device) gt_res_gpu.append(_GPU_CORPUS_CACHE[gt_key]) # ── Pass 1: GPU preprocessing + frame extraction ────────────────────── # Process items sequentially; each step is a GPU kernel (no Python per-sample). item_states: list = [] all_yc_active: list = [] # (n_i, M) tensors — will be cat'd all_Ir_active: list = [] all_Icp_active: list = [] all_Icm_active: list = [] for i, item in enumerate(items): try: sr = item["sr"] yc_orig = limited_gpu[i] # (L,) on GPU # Normalise gp = float(yc_orig.abs().max().item()) if gp > NORM_TGT: scale = NORM_TGT / gp yc = yc_orig * scale else: scale = 1.0 yc = yc_orig # DC removal dc = float(yc.mean().item()) yc = yc - dc # Ceiling + threshold (GPU scalars) ceiling = float(torch.maximum(yc.max(), (-yc).max()).item()) thresh = ceiling * (10.0 ** (-p.delta_db / 20.0)) if thresh <= 0.0: item_states.append(None) continue # Masks — GPU boolean ops Ir_t, Icp_t, Icm_t = _compute_masks_gpu(yc, thresh) # Mask dilation — GPU max_pool if p.release_ms > 0.0: rs = max(0, round(p.release_ms * sr / 1000.0)) if rs > 0: Ir_t, Icp_t, Icm_t = _dilate_masks_gpu(Icp_t, Icm_t, yc, rs) # Macro expand — still CPU via imported function; runs on numpy if macro_expand and macro_ratio > 1.0: yc_np = yc.cpu().numpy().astype(float) yc_np = _macro_expand_pass(yc_np, sr, attack_ms=p.macro_attack_ms, release_ms=p.macro_release_ms, ratio=macro_ratio) yc = torch.from_numpy(yc_np.astype(np.float32)).to(device=device) Ir_t, Icp_t, Icm_t = _compute_masks_gpu(yc, thresh) if p.release_ms > 0.0 and rs > 0: Ir_t, Icp_t, Icm_t = _dilate_masks_gpu(Icp_t, Icm_t, yc, rs) L = yc.shape[0] # Frame extraction — GPU unfold yc_act, Ir_act, Icp_act, Icm_act, is_active, N, idx1s_t = \ _extract_frames_gpu(yc, Ir_t, Icp_t, Icm_t, M, a, win_t, thresh) frame_offset = sum(s["n_active"] for s in item_states if s is not None) n_active = int(is_active.sum().item()) item_states.append({ "yc": yc, "scale": scale, "Ir_t": Ir_t, "L": L, "is_active": is_active, "N": N, "idx1s_t": idx1s_t, "frame_offset":frame_offset, "n_active": n_active, "gt_t": gt_res_gpu[i], "limited_t": limited_gpu[i], "sr": sr, }) if n_active > 0: all_yc_active .append(yc_act) all_Ir_active .append(Ir_act) all_Icp_active.append(Icp_act) all_Icm_active.append(Icm_act) except Exception as exc: warnings.warn(f"evaluate_corpus_gpu_mega preprocess ({item['file']}): {exc}") item_states.append(None) if not all_yc_active: return [None] * len(items) # Concatenate into mega-batch — single GPU allocation yc_mega = torch.cat(all_yc_active, dim=0) # (total_active, M) Ir_mega = torch.cat(all_Ir_active, dim=0) Icp_mega = torch.cat(all_Icp_active, dim=0) Icm_mega = torch.cat(all_Icm_active, dim=0) total_frames = yc_mega.shape[0] total_meta = sum(s["N"] for s in item_states if s is not None) bypass_frames = total_meta - total_frames vram_mb = total_frames * M * 4 * 4 / 1024 ** 2 print(f" [mega-batch] {total_frames} active / {total_meta} total frames " f"({100*bypass_frames/max(total_meta,1):.0f}% bypassed) " f"≈{vram_mb:.0f} MB GPU") # ── Pass 2 (GPU): _sspade_batch_gpu — unchanged ─────────────────────── try: x_mega, _ = _sspade_batch_gpu( yc_mega, Ir_mega, Icp_mega, Icm_mega, p.frame, p.s, p.r, p.eps, p.max_iter, g_max=g_max, lf_mask_t=lf_mask_t, k_lf_min=p.lf_k_min, gpu_dtype=getattr(p, "gpu_dtype", "float32"), ) except Exception as exc: warnings.warn(f"evaluate_corpus_gpu_mega GPU pass: {exc}") return [None] * len(items) finally: del yc_mega, Ir_mega, Icp_mega, Icm_mega # ── Pass 3 (GPU): WOLA + RMS match + cosine sim ─────────────────────── # All operations stay on GPU. Only .item() at the very end to get the score. scores: List[Optional[float]] = [] NORM_LIN = 10.0 ** (RESIDUAL_DBFS / 20.0) for state in item_states: if state is None: scores.append(None) continue try: yc = state["yc"] # (L,) float GPU scale = state["scale"] L = state["L"] Ir_t = state["Ir_t"] is_active= state["is_active"] # (N,) bool idx1s_t = state["idx1s_t"] # (N,) long f_off = state["frame_offset"] n_act = state["n_active"] gt_t = state["gt_t"] # (L_gt,) float GPU ltd_t = state["limited_t"] # (L,) float GPU sr = state["sr"] # Slice active frames for this item x_item = x_mega[f_off:f_off + n_act] if n_act > 0 \ else torch.empty((0, M), device=device) # GPU WOLA x_t = _wola_gpu(x_item, is_active, idx1s_t, yc, win_t, L, M) # GPU RMS match x_t = _rms_match_gpu(x_t, yc, Ir_t, M) # Un-scale x_t = x_t / scale # Residual — GPU subtraction ltd_ch = ltd_t[:L] # align lengths res_raw = x_t - ltd_ch # Normalise to RESIDUAL_DBFS (GPU) pk = res_raw.abs().max().clamp(min=1e-12) res_norm = res_raw * (NORM_LIN / pk) # Align with gt_t gt_ch = gt_t[:, 0] if gt_t.dim() == 2 else gt_t Lmin = min(res_norm.shape[0], gt_ch.shape[0]) # GPU cosine sim via torch.stft sc = _cosine_sim_gpu(gt_ch[:Lmin], res_norm[:Lmin], win_samples=1024, hop_samples=256) scores.append(sc) except Exception as exc: warnings.warn(f"evaluate_corpus_gpu_mega WOLA/score ({item['file']}): {exc}") scores.append(None) return scores # OBIETTIVO OPTUNA # ============================================================================= def make_objective(corpus: List[Dict]): def objective(trial: "optuna.Trial") -> float: # ── Parametri core ──────────────────────────────────────────────── delta_db = trial.suggest_float("delta_db", 1.5, 3.5, step=0.05) win_exp = trial.suggest_int ("win_exp", 9, 11) win = 2 ** win_exp hop_div = trial.suggest_categorical("hop_div", [4, 8]) hop = win // hop_div rel_ms = trial.suggest_float("release_ms", 10.0, 200.0, step=5.0) gain_db = trial.suggest_float("max_gain_db", 2.0, 12.0, step=0.5) eps = trial.suggest_categorical("eps", [0.03, 0.05, 0.1]) max_iter = trial.suggest_categorical("max_iter", [250, 500, 1000]) # ── Multiband + Macro expand ──────────────────────────────────────── # SPAZIO STATICO: lf_delta_db e macro_ratio vengono SEMPRE campionati # dal TPE (spazio fisso) e poi usati condizionalmente a runtime. # Questo elimina il fallback a RandomSampler che degradava le performance # del TPE multivariate con spazi dinamici. multiband = trial.suggest_categorical("multiband", [False, True]) macro_expand = trial.suggest_categorical("macro_expand", [False, True]) # Sempre campionati (range fisso), usati solo se il flag e' True: lf_delta_db = trial.suggest_float("lf_delta_db", 0.5, 2.0, step=0.05) macro_ratio = trial.suggest_float("macro_ratio", 1.1, 2.0, step=0.05) # ── v12: frequency-stratified thresholding ───────────────────────── # lf_cutoff_hz: soglia in Hz che separa i bin "LF garantiti" dagli HF. # Con M=512, sr=44100: bin_k = k * sr / (2M) → lf_cutoff=1000Hz → 23 bin LF. # lf_k_min: quanti di quei bin sono garantiti per ogni iterazione ADMM. # 0 = disabilitato (comportamento identico a v11). lf_cutoff_hz = trial.suggest_categorical("lf_cutoff_hz", [0.0, 500.0, 1000.0, 2000.0]) lf_k_min = trial.suggest_int("lf_k_min", 0, 16) # Nota: quando lf_cutoff_hz=0 oppure lf_k_min=0, la feature e' disabilitata. # Il TPE impara autonomamente quando conviene attivarla. # Se multiband=False, lf_delta_db viene ignorato in evaluate_one. # Se macro_expand=False, macro_ratio viene ignorato in evaluate_one. params = dict( delta_db = delta_db, window_length = win, hop_length = hop, release_ms = rel_ms, max_gain_db = gain_db, eps = eps, max_iter = max_iter, # flag di alto livello (estratti in evaluate_one, non passati raw) multiband = multiband, lf_delta_db = lf_delta_db, macro_expand = macro_expand, macro_ratio = macro_ratio, # v12: passati direttamente a DeclipParams (non estratti in evaluate_one) lf_cutoff_hz = lf_cutoff_hz, lf_k_min = lf_k_min, ) scores = [] # ── Shuffle per-trial con seed riproducibile ────────────────────── rng_shuffle = np.random.default_rng(trial.number) shuffled_corpus = rng_shuffle.permutation(len(corpus)).tolist() midpoint = len(corpus) // 2 ordered_items = [corpus[idx] for idx in shuffled_corpus] # ── GPU mega-batch: tutti i frame del corpus in un solo kernel ──── # Rileva il device GPU disponibile per questa chiamata. # Se non disponibile, evaluate_corpus_gpu_mega ricade su evaluate_one. _gpu_dev = "cpu" try: import torch if torch.cuda.is_available(): _gpu_dev = "cuda" except ImportError: pass # Primo metà del corpus → prune check → seconda metà # (preserva il beneficio del MedianPruner senza N kernel separati) first_half = ordered_items[:midpoint + 1] second_half = ordered_items[midpoint + 1:] scores_first = evaluate_corpus_gpu_mega(first_half, dict(params), _gpu_dev) scores = [sc for sc in scores_first if sc is not None] if scores: trial.report(float(np.mean(scores)), step=midpoint) if trial.should_prune(): raise optuna.TrialPruned() if second_half: scores_second = evaluate_corpus_gpu_mega(second_half, dict(params), _gpu_dev) scores.extend(sc for sc in scores_second if sc is not None) if not scores: return 0.0 mean_score = float(np.mean(scores)) trial.report(mean_score, step=len(corpus)) return mean_score return objective # ============================================================================= # REPORT + CSV # ============================================================================= def print_report(study: "optuna.Study", top_n: int = 20): trials = sorted( [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE], key=lambda t: t.value or 0, reverse=True, ) if not trials: print("Nessun trial completato.") return if _HAS_RICH: _console.rule("[bold cyan]RISULTATI SWEEP BAYESIANO[/]") tbl = Table(show_header=True, header_style="bold cyan", show_lines=False) for col, w in [("#",4),("score",9),("ddb",6),("LFd",5),("win",6), ("hop",4),("rel",6),("gain",6),("eps",5),("iter",5), ("MB",3),("ME",3),("MR",5),("LFcut",6),("LFk",4)]: tbl.add_column(col, justify="right", width=w) for rank, t in enumerate(trials[:top_n], 1): p = t.params win = 2 ** p["win_exp"] hop = win // p["hop_div"] mb = "Y" if p.get("multiband") else "n" me = "Y" if p.get("macro_expand") else "n" lfc = p.get("lf_cutoff_hz", 0.0) lfk = p.get("lf_k_min", 0) sty = "bold green" if rank == 1 else ("yellow" if rank <= 3 else "") tbl.add_row( str(rank), f"{t.value:.5f}", f"{p['delta_db']:.2f}", f"{p.get('lf_delta_db', p['delta_db']):.2f}", str(win), str(hop), f"{p['release_ms']:.0f}", f"{p['max_gain_db']:.1f}", str(p['eps']), str(p['max_iter']), mb, me, f"{p.get('macro_ratio', 1.0):.2f}", f"{lfc:.0f}", str(lfk), style=sty, ) _console.print(tbl) else: hdr = (f"{'#':>3} {'score':>8} {'ddb':>5} {'LFd':>5} {'win':>5}" f" {'hop':>4} {'rel':>6} {'gain':>5} {'eps':>5} {'iter':>5}" f" {'MB':>3} {'ME':>3} {'MR':>5} {'LFcut':>6} {'LFk':>4}") print(hdr); print("-" * len(hdr)) for rank, t in enumerate(trials[:top_n], 1): p = t.params win = 2 ** p["win_exp"] hop = win // p["hop_div"] mb = "Y" if p.get("multiband") else "n" me = "Y" if p.get("macro_expand") else "n" lfc = p.get("lf_cutoff_hz", 0.0) lfk = p.get("lf_k_min", 0) print(f"{rank:>3} {t.value:>8.5f} {p['delta_db']:>5.2f}" f" {p.get('lf_delta_db', p['delta_db']):>5.2f} {win:>5}" f" {hop:>4} {p['release_ms']:>6.0f} {p['max_gain_db']:>5.1f}" f" {str(p['eps']):>5} {p['max_iter']:>5}" f" {mb:>3} {me:>3} {p.get('macro_ratio', 1.0):>5.2f}" f" {lfc:>6.0f} {lfk:>4}") best = trials[0] p = best.params win = 2 ** p["win_exp"] hop = win // p["hop_div"] n_pruned = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED) print("\n" + "═" * 60) print("CONFIG OTTIMALE") print("═" * 60) print(f""" params = DeclipParams( algo = "sspade", frame = "rdft", mode = "soft", delta_db = {p['delta_db']:.2f}, window_length = {win}, hop_length = {hop}, release_ms = {p['release_ms']:.1f}, max_gain_db = {p['max_gain_db']:.1f}, eps = {p['eps']}, max_iter = {p['max_iter']}, sample_rate = sr, multiband = {p.get('multiband', False)}, band_crossovers = ({BAND_CROSSOVER_HZ},), band_delta_db = ({p.get('lf_delta_db', p['delta_db']):.2f}, {p['delta_db']:.2f}), macro_expand = {p.get('macro_expand', False)}, macro_ratio = {p.get('macro_ratio', 1.0):.2f}, lf_cutoff_hz = {p.get('lf_cutoff_hz', 0.0):.1f}, # v12 lf_k_min = {p.get('lf_k_min', 0)}, # v12 n_jobs = -1, show_progress = True, )""") print(f"\n→ Best score : {best.value:.5f}") print(f" Trials done : {len(trials)}") print(f" Pruned : {n_pruned}") # ============================================================================= # DEBUG EXPORT # ============================================================================= # Parametri SPADE usati per il debug (best noti dal grid sweep precedente). # Se un DB Optuna esiste e ha trial completati, vengono sostituiti dal best. DEBUG_PARAMS = dict( delta_db = 1.5, window_length = 1024, hop_length = 256, release_ms = 100.0, max_gain_db = 6.0, eps = 0.05, max_iter = 500, ) def _pk_dbfs(a: np.ndarray) -> float: pk = float(np.max(np.abs(a))) return 20.0 * np.log10(pk) if pk > 1e-12 else -999.0 def _rms_dbfs(a: np.ndarray) -> float: rms = float(np.sqrt(np.mean(a.astype(float) ** 2))) return 20.0 * np.log10(rms) if rms > 1e-12 else -999.0 def _write_wav(path: Path, audio: np.ndarray, sr: int) -> None: """Scrive WAV float32 senza clipping. Avvisa se peak > 1.0.""" a2d = ensure_2d(audio).astype(np.float32) pk = float(np.max(np.abs(a2d))) if pk > 1.0: print(f" [WARN] {path.name}: peak={pk:.4f} > 1.0 " f"(+{20*np.log10(pk):.2f} dBFS) — float32, non clippato") sf.write(str(path), a2d, sr, subtype="FLOAT") def debug_export( corpus: list, base_dir: Path, out_dir: Path, n_files: int, spade_params: dict, ) -> None: """ Esporta WAV di debug per i primi n_files item del corpus. Per ogni file vengono scritti 6 WAV float32: 01_orig_with_noise drum + pink noise, normalizzato a 0 dBFS peak (segnale prima del limiter) 02_limited uscita del limiter sintetico (input a SPADE) 03_gt_residual orig_with_noise - limited, @RESIDUAL_DBFS peak 04_spade_output uscita SPADE (float32, puo' superare 0 dBFS) 05_res_iter spade_output - limited, @RESIDUAL_DBFS peak 06_diff_residuals gt_residual - res_iter ideale = silenzio = -inf dB Stampa una tabella con peak dBFS e RMS dBFS per ogni traccia. Livelli ATTESI: 01 peak = 0.00 dBFS (normalizzato) 02 peak ~ -LIMITER_THRESHOLD_DB dBFS (es. -1.5 dBFS) 03 peak = RESIDUAL_DBFS (es. -3.0 dBFS) 04 peak puo' essere > 0 dBFS (transiente recuperato) 05 peak = RESIDUAL_DBFS (es. -3.0 dBFS) 06 peak << 0 dBFS (piu' basso = SPADE piu' vicino al GT) """ out_dir.mkdir(parents=True, exist_ok=True) items = corpus[:n_files] col_w = max(len(it["file"]) for it in items) + 2 HDR = (f" {'file':<{col_w}} {'traccia':<22}" f" {'peak dBFS':>10} {'RMS dBFS':>9} note") SEP = " " + "-" * (len(HDR) - 2) print() if _HAS_RICH: _console.rule("[bold cyan]DEBUG EXPORT[/]") else: print("=" * 65) print("DEBUG EXPORT") print("=" * 65) print(f" Output dir : {out_dir}") print(f" SPADE params : delta_db={spade_params['delta_db']}" f" win={spade_params['window_length']}" f" hop={spade_params['hop_length']}" f" rel={spade_params['release_ms']}ms" f" gain={spade_params['max_gain_db']}dB") print(f" File esportati: {len(items)}") print() print(f" Livelli attesi:") print(f" 01_orig_with_noise : ~ 0.00 dBFS (normalizzato prima del limiter)") print(f" 02_limited : ~ {-LIMITER_THRESHOLD_DB:+.2f} dBFS (uscita limiter)") print(f" 03_gt_residual : = {RESIDUAL_DBFS:+.2f} dBFS (normalizzato)") print(f" 04_spade_output : > 0 dBFS possibile (transiente recuperato)") print(f" 05_res_iter : = {RESIDUAL_DBFS:+.2f} dBFS (normalizzato)") print(f" 06_diff_residuals : << 0 dBFS (piu' basso = pipeline piu' corretta)") print() print(HDR) diff_peaks = [] for file_index, item in enumerate(items): sr = item["sr"] limited = item["limited"].copy() gt_res = item["gt_res"] stem = Path(item["file"]).stem # ── Ricostruisci orig_with_noise ────────────────────────────────── # Riesegue la stessa pipeline di build_corpus con il seed identico orig_with_noise = None for folder in DRUM_DIRS: candidate = base_dir / folder / item["file"] if candidate.exists(): try: raw, _ = sf.read(str(candidate), always_2d=True) raw = raw.astype(float) rng = np.random.default_rng(seed=file_index) orig_0 = normalize_to_0dBFS(raw) mixed = ensure_2d(mix_pink_noise(orig_0, sr, PINK_NOISE_LEVEL_DB, rng)) orig_with_noise = ensure_2d(normalize_to_0dBFS(mixed)) except Exception: pass break if orig_with_noise is None: # Fallback: ricostruiamo da limited + gt_res (approssimazione) gt_scale = 10 ** (RESIDUAL_DBFS / 20.0) # peak di gt_res lim_peak = 10 ** (-LIMITER_THRESHOLD_DB / 20.0) # peak atteso del limited gt_raw = gt_res * (lim_peak / (gt_scale + 1e-12)) orig_with_noise = ensure_2d(normalize_to_0dBFS(limited + gt_raw)) # ── Esegui SPADE ────────────────────────────────────────────────── try: p = DeclipParams(sample_rate=sr, **FIXED_SOLVER, **spade_params) fixed, _ = declip(limited.copy(), p) fixed_2d = ensure_2d(fixed) except Exception as exc: print(f" [ERRORE SPADE] {item['file']}: {exc}") continue # ── Residual iterazione (scala RAW, senza normalizzazione) ─────────── # IMPORTANTE: il diff deve avvenire sulla scala comune PRIMA di # normalizzare i due residual, altrimenti la normalizzazione # indipendente rimuove l'informazione di ampiezza relativa. # # gt_res e res_raw sono entrambi derivati dallo stesso limited → # hanno la stessa scala di riferimento. # gt_res e' gia' stato normalizzato a RESIDUAL_DBFS in build_corpus; # dobbiamo riportarlo alla scala raw per il confronto. # # Scala comune: usiamo il peak del limited come riferimento. # limited peak ≈ 10^(-LIMITER_THRESHOLD_DB/20) → scala assoluta nota. res_raw = fixed_2d - limited # residual SPADE in scala assoluta # gt_res_raw: ricostruiamo dalla scala normalizzata # gt_res = gt_res_raw / peak(gt_res_raw) * 10^(RESIDUAL_DBFS/20) # → gt_res_raw = gt_res * peak(gt_res_raw) / 10^(RESIDUAL_DBFS/20) # Poiche' peak(gt_res_raw) non e' salvato, lo stimiamo: # gt_res_raw ≈ orig_with_noise - limited (ricostruito) gt_res_raw_approx = ensure_2d(orig_with_noise) - limited L = min(gt_res_raw_approx.shape[0], res_raw.shape[0]) # ── Diff sulla scala comune (raw, non normalizzata) ─────────────── diff_raw = gt_res_raw_approx[:L] - res_raw[:L] # ── Cosine similarity temporale (scalare, sul canale L) ────────── g_flat = gt_res_raw_approx[:L, 0] if gt_res_raw_approx.ndim == 2 else gt_res_raw_approx[:L] e_flat = res_raw[:L, 0] if res_raw.ndim == 2 else res_raw[:L] cos_sim_td = float( np.dot(g_flat, e_flat) / (np.linalg.norm(g_flat) * np.linalg.norm(e_flat) + 1e-12) ) # ── Stima floor teorico del diff dovuto al rumore rosa ──────────── # Il limiter attenue anche i picchi del rumore rosa → quella parte # sta nel GT_res ma NON in res_iter (SPADE non la recupera). # Stimiamo quanto rumore e' nel GT_res come proxy del floor. noise_gain_lin = 10 ** (PINK_NOISE_LEVEL_DB / 20.0) # Ampiezza del rumore rispetto al limited: noise_gain ≈ fraction # del GT_res che e' irrecuperabile da SPADE. noise_floor_db = 20 * np.log10(noise_gain_lin + 1e-12) + RESIDUAL_DBFS # In pratica: diff non puo' essere < noise_floor per costruzione. # ── diff dBFS relativo al GT_res (SNR-like) ─────────────────────── diff_rms_db = _rms_dbfs(diff_raw[:L]) gt_rms_db = _rms_dbfs(gt_res_raw_approx[:L]) # diff_vs_gt: quanto e' grande il diff rispetto al GT (0 dB = diff = GT) diff_vs_gt_db = diff_rms_db - gt_rms_db # piu' negativo = meglio # Normalizza per l'export WAV res_iter = normalize_peak(res_raw, RESIDUAL_DBFS) diff_norm = normalize_peak(diff_raw, RESIDUAL_DBFS) if np.max(np.abs(diff_raw)) > 1e-12 else diff_raw diff_peaks.append((diff_vs_gt_db, cos_sim_td, diff_rms_db, gt_rms_db)) # ── Definizione tracce ──────────────────────────────────────────── tracks = [ ("01_orig_with_noise", orig_with_noise, f"drum+noise @0dBFS (input pipeline)"), ("02_limited", limited, f"uscita limiter (input SPADE) atteso: ~{-LIMITER_THRESHOLD_DB:+.2f}dBFS"), ("03_gt_residual", gt_res, f"GT residual @{RESIDUAL_DBFS:.0f}dBFS (include noise attenuation)"), ("04_spade_output", fixed_2d, f"SPADE output (float32, puo' >0dBFS)"), ("05_res_iter", res_iter, f"residual SPADE @{RESIDUAL_DBFS:.0f}dBFS (solo componente sparsa)"), ("06_diff_residuals", diff_norm, f"GT - iter @{RESIDUAL_DBFS:.0f}dBFS " f"cos_sim={cos_sim_td:.3f} diff/GT={diff_vs_gt_db:+.1f}dB " f"noise_floor≈{noise_floor_db:+.1f}dB"), ] # ── Soglia realistica per il diff ───────────────────────────────── # Il diff non puo' essere < noise_floor per costruzione del corpus. # Calibriamo la soglia [OK] a noise_floor + 6 dB (margine). ok_threshold = noise_floor_db + 6.0 # tipicamente attorno a -17 dBFS warn_threshold = ok_threshold + 10.0 # tutto sopra e' davvero anomalo # ── Stampa tabella + scrivi WAV ─────────────────────────────────── print(SEP) for track_name, audio, note in tracks: pk = _pk_dbfs(audio) rms = _rms_dbfs(audio) flag = "" if track_name == "06_diff_residuals": if diff_vs_gt_db < -12: flag = "[OK] buona convergenza" elif diff_vs_gt_db < -6: flag = "[~] convergenza parziale" else: flag = "[WARN] diff elevato rispetto al GT" row = (f" {item['file']:<{col_w}} {track_name:<22}" f" {pk:>+10.2f} {rms:>+9.2f} {note} {flag}") if _HAS_RICH: color = ("green" if "[OK]" in flag else "yellow" if "[~]" in flag else "red" if "[WARN]" in flag else "") colored_row = row.replace(flag, f"[{color or 'dim'}]{flag}[/]") if flag else row _console.print(colored_row) else: print(row) wav_path = out_dir / f"{stem}__{track_name}.wav" _write_wav(wav_path, audio, sr) # ── Analisi spettrale per banda: LF vs HF ───────────────────────── # Risponde alla domanda: quanto residual c'e' nelle basse frequenze, # e quanto ne recupera SPADE? # # Bands: # Sub-bass : 20 – 80 Hz (fondamentale kick, body) # Bass : 80 – 250 Hz (corpo kick, coda) # Low-mid : 250 – 800 Hz (presenza) # High-mid : 800 – 4000 Hz (attacco, click) # High : 4k – 20k Hz (aria, snap) # # Per ogni banda misura: # GT_energy = energia del GT residual (quanto il limiter ha tolto) # iter_energy = energia recuperata da SPADE # recovery % = iter_energy / GT_energy × 100 def band_energy(audio_2d, sr, f_lo, f_hi): """RMS energy in dB di una banda passante [f_lo, f_hi] Hz.""" mono = audio_2d[:, 0] if audio_2d.ndim == 2 else audio_2d N = len(mono) if N < 8: return -999.0 # Butterworth bandpass (o lowpass/highpass ai bordi) nyq = sr / 2.0 lo = max(f_lo / nyq, 1e-4) hi = min(f_hi / nyq, 0.9999) if lo >= hi: return -999.0 if lo < 1e-3: b, a = sig.butter(4, hi, btype="low") else: b, a = sig.butter(4, [lo, hi], btype="band") filtered = sig.filtfilt(b, a, mono) return _rms_dbfs(filtered) BANDS = [ ("Sub-bass ", 20, 80), ("Bass ", 80, 250), ("Low-mid ", 250, 800), ("High-mid ", 800, 4000), ("High ", 4000, 20000), ] gt_mono = gt_res[:, 0] if gt_res.ndim == 2 else gt_res ri_mono = res_iter[:, 0] if res_iter.ndim == 2 else res_iter # Normalizza GT e iter sulla stessa scala (rimuovi la normalizzazione # a RESIDUAL_DBFS per confrontare energie assolute) gt_raw_for_bands = gt_res_raw_approx iter_raw_for_bands = res_raw print() band_hdr = f" {'banda':<12} {'GT_res RMS':>10} {'SPADE rec RMS':>13} {'recovery':>9} {'limitato?'}" print(f" Analisi spettrale per banda — {item['file']}") print(f" {'─'*75}") print(band_hdr) print(f" {'─'*75}") for bname, f_lo, f_hi in BANDS: gt_db = band_energy(gt_raw_for_bands, sr, f_lo, f_hi) iter_db = band_energy(iter_raw_for_bands, sr, f_lo, f_hi) if gt_db < -60: recovery_str = " — (silenzio)" flag_b = "" else: diff_b = iter_db - gt_db # positivo = SPADE supera GT (overrecovery) # recovery: 0 dB diff = recupero perfetto, molto negativo = sotto-recupero if diff_b > -3: flag_b = "OK" elif diff_b > -9: flag_b = "~ parziale" else: flag_b = "!! sotto-recupero" recovery_str = f"{diff_b:>+7.1f} dB {flag_b}" line = f" {bname:<12} {gt_db:>+10.1f} {iter_db:>+13.1f} {recovery_str}" if _HAS_RICH: color = "green" if "OK" in recovery_str else ( "yellow" if "~" in recovery_str else ( "red" if "!!" in recovery_str else "dim")) _console.print(f"[{color}]{line}[/]") else: print(line) print() print(SEP) print() if diff_peaks: vs_gt_vals = [d[0] for d in diff_peaks] cos_vals = [d[1] for d in diff_peaks] avg_vs_gt = float(np.mean(vs_gt_vals)) best_vs_gt = float(np.min(vs_gt_vals)) worst_vs_gt = float(np.max(vs_gt_vals)) avg_cos = float(np.mean(cos_vals)) noise_floor_db = 20 * np.log10(10 ** (PINK_NOISE_LEVEL_DB / 20.0) + 1e-12) + RESIDUAL_DBFS print(f" RIEPILOGO 06_diff_residuals:") print(f" diff/GT_rms media : {avg_vs_gt:>+7.2f} dB (0 dB = diff grande quanto GT)") print(f" diff/GT_rms migliore: {best_vs_gt:>+7.2f} dB") print(f" diff/GT_rms peggiore: {worst_vs_gt:>+7.2f} dB") print(f" cos_sim TD media : {avg_cos:>8.4f} (1.0 = identici)") print() print(f" NOTA IMPORTANTE:") print(f" Il rumore rosa ({PINK_NOISE_LEVEL_DB} dB) fa parte del GT_res ma") print(f" NON puo' essere recuperato da SPADE (non e' sparso).") print(f" Floor teorico del diff: ≈ {noise_floor_db:+.1f} dBFS — questo e' il") print(f" limite fisico massimo raggiungibile con questo corpus.") print(f" Un diff/GT < -6 dB indica buona convergenza di SPADE.") print() if worst_vs_gt < -12: verdict = "OK Convergenza eccellente — SPADE recupera bene i transienti" elif worst_vs_gt < -6: verdict = "~ Convergenza buona — residuo compatibile con il noise floor" else: verdict = "INFO diff dominato dal rumore rosa — comportamento atteso e corretto" print(f" Verdetto: {verdict}") print(f"\n WAV scritti in : {out_dir}/") print(f" Formato : float32, nessun clipping (usa un editor che supporta >0dBFS)") print(f" Nomenclatura : ___.wav") def save_csv(study: "optuna.Study"): import csv trials = sorted( [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE], key=lambda t: t.value or 0, reverse=True, ) with open(OUT_CSV, "w", newline="") as f: w = csv.writer(f) w.writerow(["rank", "score", "delta_db", "lf_delta_db", "window_length", "hop_length", "release_ms", "max_gain_db", "eps", "max_iter", "multiband", "macro_expand", "macro_ratio"]) for rank, t in enumerate(trials, 1): p = t.params win = 2 ** p["win_exp"] hop = win // p["hop_div"] w.writerow([ rank, round(t.value, 6), p["delta_db"], round(p.get("lf_delta_db", p["delta_db"]), 2), win, hop, p["release_ms"], p["max_gain_db"], p["eps"], p["max_iter"], int(p.get("multiband", False)), int(p.get("macro_expand", False)), round(p.get("macro_ratio", 1.0), 2), ]) print(f"\n 📄 CSV: {OUT_CSV}") # ============================================================================= # MAIN # ============================================================================= def parse_args(): ap = argparse.ArgumentParser(description="Smart Bayesian sweep per S-SPADE v2") ap.add_argument("--trials", type=int, default=200, help="Numero di trial Optuna (default: 200)") ap.add_argument("--resume", action="store_true", help="Carica lo study esistente e aggiunge trial") ap.add_argument("--report", action="store_true", help="Solo report (nessun nuovo trial)") ap.add_argument("--base-dir", type=str, default=".", help="Cartella radice con Kicks/Snares/Perc/Tops") ap.add_argument("--corpus-size", type=int, default=None, help="Limita il corpus a N file (None = tutti)") ap.add_argument("--top", type=int, default=20, help="Quanti trial mostrare nel ranking (default: 20)") ap.add_argument("--no-prune", action="store_true", help="Disabilita MedianPruner (più lento ma completo)") ap.add_argument("--debug-export", action="store_true", help="Esporta WAV di debug per i primi N file del corpus (no sweep)") ap.add_argument("--debug-dir", type=str, default="debug_export", help="Cartella output WAV di debug (default: debug_export)") ap.add_argument("--debug-n", type=int, default=10, help="Quanti file esportare in debug (default: 10)") return ap.parse_args() def main(): args = parse_args() missing = [] if not _HAS_OPTUNA: missing.append("optuna") if not _HAS_SPADE: missing.append("spade_declip_v11.py (nella stessa dir)") if missing: pip = [m for m in missing if not m.endswith(")")] sys.exit("Mancante:\n pip install " + " ".join(pip) + ("\n " + "\n ".join(m for m in missing if m.endswith(")")) if any(m.endswith(")") for m in missing) else "")) base_dir = Path(args.base_dir).resolve() storage = f"sqlite:///{STUDY_NAME}.db" sampler = TPESampler(seed=42, multivariate=True, warn_independent_sampling=False) pruner = (MedianPruner(n_startup_trials=10, n_warmup_steps=3) if not args.no_prune else optuna.pruners.NopPruner()) if args.report: try: study = optuna.load_study(study_name=STUDY_NAME, storage=storage, sampler=sampler, pruner=pruner) except Exception: sys.exit(f"Nessuno study trovato in {STUDY_NAME}.db") print_report(study, top_n=args.top) save_csv(study) return # ── Debug export ────────────────────────────────────────────────────────── if args.debug_export: # Usa i parametri del best trial se esiste un DB, altrimenti DEBUG_PARAMS spade_params = dict(DEBUG_PARAMS) try: study = optuna.load_study(study_name=STUDY_NAME, storage=storage, sampler=sampler, pruner=pruner) completed = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE] if completed: best_t = max(completed, key=lambda t: t.value or 0) p = best_t.params win = 2 ** p["win_exp"] hop = win // p["hop_div"] spade_params = dict( delta_db = p["delta_db"], window_length = win, hop_length = hop, release_ms = p["release_ms"], max_gain_db = p["max_gain_db"], eps = p["eps"], max_iter = p["max_iter"], ) print(f" [DEBUG] Usando best trial #{best_t.number}" f" (score={best_t.value:.5f}) dal DB.") except Exception: print(f" [DEBUG] DB non trovato — uso DEBUG_PARAMS di default.") # Costruisci corpus (limitato a debug_n file per velocita') corpus = build_corpus(base_dir, max_files=args.debug_n) if not corpus: sys.exit("Corpus vuoto. Controlla --base-dir.") debug_export( corpus = corpus, base_dir = base_dir, out_dir = Path(args.debug_dir), n_files = args.debug_n, spade_params = spade_params, ) return # ── Corpus ─────────────────────────────────────────────────────────────── print("\n" + "=" * 65) print("CORPUS + LIMITER SINTETICO (Case 1 — threshold-based)") print("=" * 65) print(f" Base dir : {base_dir}") print(f" Threshold : −{LIMITER_THRESHOLD_DB} dBFS") print(f" Release : {LIMITER_RELEASE_MS} ms") print(f" Level align: NESSUNO — loudness invariata per costruzione") print(f" Rumore rosa: {PINK_NOISE_LEVEL_DB} dB rel. peak " f"(simula sottofondo musicale sotto il transiente)") corpus = build_corpus(base_dir, max_files=args.corpus_size) if not corpus: sys.exit("Corpus vuoto. Controlla --base-dir e le cartelle.") # ── GPU warm-up: forza MCLK al massimo prima del primo trial ───────────── # Su RDNA2 (RX 6700 XT) il memory clock parte da 96 MHz (idle) e impiega # ~200ms per salire a 1750 MHz. Un primo batch piccolo lascia MCLK basso # per tutto il trial. Questo dummy dispatch forza il ramp-up in anticipo. try: import torch if torch.cuda.is_available(): _wd = "cuda" _sz = 8192 * 1024 # 8 MB → sufficiente per trigger MCLK ramp _dummy = torch.randn(_sz, device=_wd, dtype=torch.float32) _dummy2 = _dummy * 2.0 + _dummy.roll(1) torch.cuda.synchronize() del _dummy, _dummy2 print(" ✓ GPU warm-up completato (MCLK ramp forzato)") except Exception: pass print(f"\n ✓ {len(corpus)} file nel corpus\n") col_w = max(len(item["file"]) for item in corpus) + 2 for item in corpus: rms = float(np.sqrt(np.mean(item["gt_res"] ** 2))) peak = float(np.max(np.abs(item["gt_res"]))) print(f" {item['file']:<{col_w}} sr={item['sr']} " f"GT rms={rms:.4f} peak={peak:.4f}") # ── Study ───────────────────────────────────────────────────────────────── print(f"\n{'='*65}") print(f"OTTIMIZZAZIONE BAYESIANA — {args.trials} trial") print(f"TPE (multivariate) + MedianPruner | storage: {STUDY_NAME}.db") print(f"{'='*65}\n") study = optuna.create_study( study_name = STUDY_NAME, storage = storage, sampler = sampler, pruner = pruner, direction = "maximize", load_if_exists = True, ) # ── Progress bar (rich → tqdm → plain fallback) ─────────────────────────── try: from rich.progress import ( Progress, BarColumn, TextColumn, TimeElapsedColumn, TimeRemainingColumn, MofNCompleteColumn, ) _has_rich_progress = True except ImportError: _has_rich_progress = False try: import tqdm as _tqdm_mod _has_tqdm = True except ImportError: _has_tqdm = False # Stato condiviso aggiornato dal callback. # Pre-popolato con i trial gia' nel DB in caso di --resume, # cosi' la progress bar mostra il conteggio corretto dall'inizio. _existing_complete = [t for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE] _existing_pruned = [t for t in study.trials if t.state == optuna.trial.TrialState.PRUNED] if _existing_complete: _best_existing = max(_existing_complete, key=lambda t: t.value or 0) _init_best = _best_existing.value or 0.0 _init_best_p = dict(_best_existing.params) _init_last = _init_best else: _init_best, _init_best_p, _init_last = float("-inf"), {}, float("-inf") _state = { "done": len(_existing_complete), "pruned": len(_existing_pruned), "best": _init_best, "best_p": _init_best_p, "last": _init_last, "t0": time.time(), "n_total": len(_existing_complete) + len(_existing_pruned) + args.trials, } def _fmt_best(state: dict) -> str: """Stringa compatta con i parametri del best trial corrente.""" bp = state["best_p"] if not bp: return "—" win = 2 ** bp.get("win_exp", 10) hop = win // bp.get("hop_div", 4) return (f"δ={bp.get('delta_db',0):.2f} " f"win={win} hop={hop} " f"rel={bp.get('release_ms',0):.0f}ms " f"gain={bp.get('max_gain_db',0):.1f}dB") # ── Rich progress bar ───────────────────────────────────────────────────── if _has_rich_progress: progress = Progress( TextColumn("[bold cyan]Trial[/] [cyan]{task.completed}/{task.total}[/]"), BarColumn(bar_width=32), MofNCompleteColumn(), TextColumn(" score [green]{task.fields[last]:.5f}[/]"), TextColumn(" best [bold green]{task.fields[best]:.5f}[/]"), TextColumn(" [dim]pruned {task.fields[pruned]}[/]"), TimeElapsedColumn(), TextColumn("ETA"), TimeRemainingColumn(), refresh_per_second=4, transient=False, ) task_id = None # creato dentro il context def on_trial_end(study, trial): fin = (trial.state == optuna.trial.TrialState.COMPLETE) prn = (trial.state == optuna.trial.TrialState.PRUNED) if fin: _state["done"] += 1 _state["last"] = trial.value or 0.0 if _state["last"] > _state["best"]: _state["best"] = _state["last"] _state["best_p"] = dict(study.best_params) elif prn: _state["pruned"] += 1 progress.update( task_id, advance = 1, last = _state["last"], best = max(_state["best"], 0.0), pruned = _state["pruned"], ) t0 = time.time() try: with progress: task_id = progress.add_task( "sweep", total = _state["n_total"], completed = _state["done"] + _state["pruned"], last = max(_state["last"], 0.0), best = max(_state["best"], 0.0), pruned = _state["pruned"], ) study.optimize( make_objective(corpus), n_trials = args.trials, callbacks = [on_trial_end], show_progress_bar = False, ) except KeyboardInterrupt: print("\n[!] Interrotto — risultati parziali salvati.") # ── tqdm fallback ───────────────────────────────────────────────────────── elif _has_tqdm: import tqdm _already = _state["done"] + _state["pruned"] pbar = tqdm.tqdm( total = _state["n_total"], initial = _already, unit = "trial", bar_format = "{l_bar}{bar}| {n}/{total} [{elapsed}<{remaining}]", ) if _already > 0: pbar.set_postfix( score = f"{max(_state['last'], 0.0):.5f}", best = f"{max(_state['best'], 0.0):.5f}", pruned = _state["pruned"], ) def on_trial_end(study, trial): fin = trial.state == optuna.trial.TrialState.COMPLETE prn = trial.state == optuna.trial.TrialState.PRUNED if fin: _state["done"] += 1 _state["last"] = trial.value or 0.0 if _state["last"] > _state["best"]: _state["best"] = _state["last"] _state["best_p"] = dict(study.best_params) elif prn: _state["pruned"] += 1 pbar.update(1) pbar.set_postfix( score = f"{_state['last']:.5f}", best = f"{_state['best']:.5f}", pruned = _state["pruned"], ) t0 = time.time() try: study.optimize( make_objective(corpus), n_trials = args.trials, callbacks = [on_trial_end], show_progress_bar = False, ) except KeyboardInterrupt: print("\n[!] Interrotto — risultati parziali salvati.") finally: pbar.close() # ── Plain fallback ──────────────────────────────────────────────────────── else: def on_trial_end(study, trial): fin = trial.state == optuna.trial.TrialState.COMPLETE prn = trial.state == optuna.trial.TrialState.PRUNED if fin: _state["done"] += 1 _state["last"] = trial.value or 0.0 if _state["last"] > _state["best"]: _state["best"] = _state["last"] _state["best_p"] = dict(study.best_params) elapsed = time.time() - _state["t0"] done_tot = _state["done"] + _state["pruned"] eta_s = (elapsed / done_tot) * (_state["n_total"] - done_tot) if done_tot else 0 is_best = abs(_state["last"] - _state["best"]) < 1e-9 bar_n = int(32 * done_tot / max(_state["n_total"], 1)) bar = "█" * bar_n + "░" * (32 - bar_n) print(f"\r[{bar}] {done_tot}/{_state['n_total']}" f" {'★' if is_best else ' '}score={_state['last']:.5f}" f" best={_state['best']:.5f}" f" pruned={_state['pruned']}" f" ETA {eta_s/60:.1f}min ", end="", flush=True) elif prn: _state["pruned"] += 1 t0 = time.time() try: study.optimize( make_objective(corpus), n_trials = args.trials, callbacks = [on_trial_end], show_progress_bar = False, ) except KeyboardInterrupt: print("\n[!] Interrotto — risultati parziali salvati.") print() # newline dopo la riga \r elapsed = time.time() - t0 n_done = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.COMPLETE) n_prune = sum(1 for t in study.trials if t.state == optuna.trial.TrialState.PRUNED) print(f"\n Completati: {n_done} | Pruned: {n_prune}" f" | Tempo totale: {elapsed/60:.1f} min" f" | Media: {elapsed/max(n_done+n_prune,1):.1f} s/trial") print_report(study, top_n=args.top) save_csv(study) print("\nDone.") if __name__ == "__main__": main()