"""Bulk Stable Audio Open inference on the full 3919-pair test set, saved as //{bg.wav, fg_pred.wav, mix.wav} matching the Frieren output layout so the same eval pipeline can consume both projects' inferences. LUFS protocol (identical to infer_frieren_test_set.py): - bg.wav normalized to LUFS=-30 (FIXED). - fg_pred.wav saved at gain s s.t. LUFS(bg_norm + s*fg) = -23 (binary search on s in dB via find_lufs_mixture_gains). - mix.wav = bg_norm + fg_pred_scaled. Differences vs Frieren: - 44.1 kHz STEREO output (vs Frieren 16 kHz mono). Files keep SA's native sample rate; downstream eval pipeline resamples as needed. - Sample size 440320 (~10 s). - Model loaded via TrainingWrapper (Lightning ckpt namespace) + EMA model preferred for inference. Sampling via `generate_diffusion_cond`. - LUFS gains computed on the channel-mean (mono) signal, then applied multiplicatively to the original stereo waveform — preserves L/R balance. """ import argparse, json, os, sys from pathlib import Path import numpy as np import torch import torchaudio SA_ROOT = Path("/nfs/turbo/coe-ahowens-nobackup/dingqy/friendly-stable-audio-tools") sys.path.insert(0, str(SA_ROOT)) sys.path.insert(0, "/nfs/turbo/coe-ahowens-nobackup/dingqy") from stable_audio_tools.models import create_model_from_config # noqa from stable_audio_tools.models.utils import load_ckpt_state_dict # noqa from stable_audio_tools.training import create_training_wrapper_from_config # noqa from stable_audio_tools.utils.audio_utils import load_bg_wav, crop_or_pad_to # noqa from stable_audio_tools.inference.generation import generate_diffusion_cond # noqa from infer_bg2fg_variable import find_lufs_mixture_gains # noqa SR = 44100 CH = 2 def main(): ap = argparse.ArgumentParser() ap.add_argument("--ckpt", required=True, help="path to Lightning .ckpt") ap.add_argument("--model-config", default=str(SA_ROOT / "stable_audio_tools/configs/model_configs/txt2audio/stable_audio_open_1_0_bg2fg_rebalance.json")) ap.add_argument("--manifest", default="/nfs/turbo/coe-ahowens-nobackup/ymdou/hidingsound/data/noise_guidance_out_latent/manifest.json") ap.add_argument("--out", default="/nfs/turbo/coe-ahowens-nobackup/dingqy/inference_demo/sa_test_set", help="root dir; output goes to //{bg,fg_pred,mix}.wav") ap.add_argument("--steps", type=int, default=100) ap.add_argument("--cfg-scale", type=float, default=1.0) ap.add_argument("--batch-size", type=int, default=4, help="generate_diffusion_cond fp16 + 1.2B DiT — 4 fits A40") ap.add_argument("--bg-lufs", type=float, default=-30.0) ap.add_argument("--mix-lufs", type=float, default=-23.0) ap.add_argument("--seed", type=int, default=42) ap.add_argument("--limit", type=int, default=0, help="for testing: only N pairs") args = ap.parse_args() out_root = Path(args.out) out_root.mkdir(parents=True, exist_ok=True) print(f"loading manifest: {args.manifest}") m = json.load(open(args.manifest)) pairs = [p for p in m["pairs"] if p["split"] == "test"] print(f" {len(pairs)} test pairs") if args.limit: pairs = pairs[: args.limit] print(f" limiting to first {len(pairs)}") mc = json.load(open(args.model_config)) sample_size = mc["sample_size"] # 440320 @ 44.1 kHz = ~9.98 s print(f"sample_size={sample_size} ({sample_size / SR:.2f} s @ {SR} Hz, {CH}-channel)") print("instantiating model + training wrapper...", flush=True) base_model = create_model_from_config(mc) wrapper = create_training_wrapper_from_config(mc, base_model) sd = load_ckpt_state_dict(args.ckpt) missing, unexpected = wrapper.load_state_dict(sd, strict=False) print(f" wrapper.load_state_dict: missing={len(missing)} unexpected={len(unexpected)}") if getattr(wrapper, "diffusion_ema", None) is not None: print(" using EMA weights for inference") wrapper.diffusion.model = wrapper.diffusion_ema.ema_model model = wrapper.diffusion.cuda().eval() n_done = n_skip = n_clipped = 0 total = len(pairs) for batch_start in range(0, total, args.batch_size): batch = pairs[batch_start: batch_start + args.batch_size] # Resume-friendly: skip pairs whose mix.wav already exists. todo = [p for p in batch if not (out_root / p["rel_path"] / "mix.wav").exists()] if not todo: n_skip += len(batch) continue # Load + crop/pad bg to sample_size for each pair in batch bg_list = [] for p in todo: bg = load_bg_wav(p["bg_wav"], target_sr=SR, target_channels=CH) bg = crop_or_pad_to(bg, sample_size).clamp(-1.0, 1.0) bg_list.append(bg) # Build conditioning dicts in the format generate_diffusion_cond expects conditioning = [{ "bg_audio": bg.unsqueeze(0), # (1, C, T) — PretransformConditioner convention "seconds_start": 0, "seconds_total": int(sample_size / SR), } for bg in bg_list] with torch.no_grad(): with torch.cuda.amp.autocast(): fakes = generate_diffusion_cond( model, steps=args.steps, cfg_scale=args.cfg_scale, conditioning=conditioning, sample_size=sample_size, seed=args.seed + batch_start, # different seed per batch for variety disable_tqdm=True, ) fakes = fakes.cpu().float() # (N, C, T) for i, p in enumerate(todo): rel = p["rel_path"] sub = out_root / rel sub.mkdir(parents=True, exist_ok=True) bg_stereo = bg_list[i].numpy().astype(np.float32) # (C, T) fg_pred_stereo = fakes[i].clamp(-1, 1).numpy().astype(np.float32) # (C, T) # LUFS gains computed on channel-mean (mono); applied multiplicatively # to the original stereo signal — preserves L/R balance. bg_mono = bg_stereo.mean(axis=0) fg_mono = fg_pred_stereo.mean(axis=0) bg_g, fg_g = find_lufs_mixture_gains( bg_mono, fg_mono, SR, bg_lufs=args.bg_lufs, mix_lufs=args.mix_lufs, ) bg_norm = (bg_stereo * bg_g).astype(np.float32) fg_pred_scaled = (fg_pred_stereo * fg_g).astype(np.float32) mix = (bg_norm + fg_pred_scaled).astype(np.float32) peak = float(np.max(np.abs(mix))) if peak > 1.0: n_clipped += 1 torchaudio.save(str(sub / "bg.wav"), torch.from_numpy(bg_norm).clamp(-1, 1), SR) torchaudio.save(str(sub / "fg_pred.wav"), torch.from_numpy(fg_pred_scaled).clamp(-1, 1), SR) torchaudio.save(str(sub / "mix.wav"), torch.from_numpy(mix).clamp(-1, 1), SR) n_done += 1 if (batch_start // args.batch_size) % 20 == 0 or batch_start + args.batch_size >= total: print(f" [{batch_start + len(batch)}/{total}] done={n_done} skip={n_skip} clipped={n_clipped}", flush=True) print(f"\n=== DONE ===\n total: {total}\n generated: {n_done}\n pre-existing skipped: {n_skip}\n clipped (peak > 1.0): {n_clipped}") if __name__ == "__main__": main()