"""Run 3 fixed train + 3 fixed test pairs through 3 ckpts (pretrained, step=1000, step=2000) and save per-sample comparison outputs: sa_3ckpt_compare/ train/sample_0_/ bg.wav, fg_gt.wav (shared across ckpts) pretrained_fg_pred.wav step1000_fg_pred.wav step2000_fg_pred.wav spec.png (5-panel: bg, fg_gt, *_fg_pred) test/sample_0_/... The waveforms are saved AT MODEL OUTPUT GAIN (no LUFS rescaling) so silent / near-silent fg_pred shows up as obvious flat-line — the goal here is to see if the ckpts differ qualitatively, not to make a balanced mix. """ 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 render_specs import log_mel, render_panels # noqa SR = 44100 CH = 2 # Fixed pair indices — deterministic across ckpts. Picked early in each split # for reproducibility; they're the same indices the demo callback would have # rendered on rank 0. TRAIN_INDICES = [0, 100, 1000] TEST_INDICES = [0, 100, 1000] CKPTS = [ ("pretrained", "/nfs/turbo/coe-ahowens-nobackup/dingqy/friendly-stable-audio-tools/data/ckpt/sa_open_1_0_bg_expanded.ckpt"), ("step1000", "sa_open_bg2fg_rebalance/lbkb1h5z/epoch=0-step=1000.ckpt"), ("step2000", "sa_open_bg2fg_rebalance/lbkb1h5z/epoch=0-step=2000.ckpt"), ] def resolve_ckpt(ck): """Local abs path → return as-is. Otherwise treat as HF path under AE-W/ckpt.""" if os.path.isabs(ck) and os.path.exists(ck): return ck from huggingface_hub import hf_hub_download return hf_hub_download(repo_id="AE-W/ckpt", filename=ck, repo_type="dataset", cache_dir=os.environ.get("HF_CACHE", "/nfs/turbo/coe-ahowens-nobackup/dingqy/.cache/huggingface")) def load_sample(p, sample_size): """Returns (bg [C,T], fg_gt [C,T]) — both cropped/padded to sample_size.""" bg = load_bg_wav(p["bg_wav"], target_sr=SR, target_channels=CH) fg = load_bg_wav(p["fg_wav"], target_sr=SR, target_channels=CH) bg = crop_or_pad_to(bg, sample_size).clamp(-1.0, 1.0) fg = crop_or_pad_to(fg, sample_size).clamp(-1.0, 1.0) return bg, fg def main(): ap = argparse.ArgumentParser() ap.add_argument("--manifest", default="/nfs/turbo/coe-ahowens-nobackup/ymdou/hidingsound/data/noise_guidance_out_latent/manifest.json") 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("--out", default="/nfs/turbo/coe-ahowens-nobackup/dingqy/inference_demo/sa_3ckpt_compare") ap.add_argument("--steps", type=int, default=100) ap.add_argument("--cfg-scale", type=float, default=1.0) ap.add_argument("--seed", type=int, default=42) 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)) train_pairs = [p for p in m["pairs"] if p["split"] == "train"] test_pairs = [p for p in m["pairs"] if p["split"] == "test"] print(f" {len(train_pairs)} train, {len(test_pairs)} test") selected = [("train", train_pairs[i]) for i in TRAIN_INDICES] \ + [("test", test_pairs[i]) for i in TEST_INDICES] mc = json.load(open(args.model_config)) sample_size = mc["sample_size"] print(f"sample_size={sample_size} ({sample_size / SR:.2f} s @ {SR} Hz)") # Pre-load all 6 (bg, fg_gt) pairs ONCE — reuse across ckpts. print("\nloading 6 fixed pairs...") pair_data = [] for split, p in selected: bg, fg = load_sample(p, sample_size) sid_safe = p["rel_path"].replace("/", "_") pair_data.append({ "split": split, "sid": sid_safe, "rel": p["rel_path"], "bg": bg, "fg_gt": fg, }) print(f" [{split}] {p['rel_path']}") # Save shared bg + fg_gt + their specs (only once — same for every ckpt). print("\nsaving shared bg/fg_gt + per-sample dirs...") cfg = {"sr": SR, "n_fft": 2048, "hop_length": 512, "n_mels": 128, "fmax": 22050} for i, pd in enumerate(pair_data): sub = out_root / pd["split"] / f"sample_{i % 3}_{pd['sid']}" sub.mkdir(parents=True, exist_ok=True) torchaudio.save(str(sub / "bg.wav"), pd["bg"].clamp(-1, 1), SR) torchaudio.save(str(sub / "fg_gt.wav"), pd["fg_gt"].clamp(-1, 1), SR) pd["sub"] = sub # Instantiate wrapper + model ONCE; re-use for every ckpt by reloading # state_dict in place (saves ~30s × 3 ckpts in instantiation). print("\ninstantiating model + training wrapper (one-time)...") base_model = create_model_from_config(mc) wrapper = create_training_wrapper_from_config(mc, base_model) wrapper = wrapper.cuda() for ckpt_name, ckpt_arg in CKPTS: print(f"\n=== {ckpt_name} ({ckpt_arg}) ===") local = resolve_ckpt(ckpt_arg) sd = load_ckpt_state_dict(local) # Pretrained baseline saves only the inner ConditionedDiffusionModelWrapper # (keys = model.model.*); training ckpts save the Lightning wrapper # (keys = diffusion.* / diffusion_ema.*). copy_state_dict handles the # first; load_state_dict handles the second. is_raw_inner = any(k.startswith("model.model.") for k in sd.keys()) \ and not any(k.startswith("diffusion.") for k in sd.keys()) if is_raw_inner: from stable_audio_tools.utils.torch_common import copy_state_dict copy_state_dict(wrapper.diffusion, sd) print(f" copy_state_dict into wrapper.diffusion (raw, no EMA)") ema_loaded = False else: missing, unexpected = wrapper.load_state_dict(sd, strict=False) ema_loaded = any(k.startswith("diffusion_ema") for k in sd.keys()) print(f" load_state_dict: missing={len(missing)} unexpected={len(unexpected)}") if ema_loaded and getattr(wrapper, "diffusion_ema", None) is not None: wrapper.diffusion.model = wrapper.diffusion_ema.ema_model print(f" using EMA weights") else: print(f" using raw (non-EMA) weights") model = wrapper.diffusion.cuda().eval() # Run inference per pair (batch of 6 is fine for A40 — fp16 1.2B DiT). conditioning = [{ "bg_audio": pd["bg"].unsqueeze(0), "seconds_start": 0, "seconds_total": int(sample_size / SR), } for pd in pair_data] 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, disable_tqdm=True, ) fakes = fakes.cpu().float() # Save per-pair fg_pred + render 5-panel spec for i, pd in enumerate(pair_data): fg_pred = fakes[i].clamp(-1, 1) torchaudio.save(str(pd["sub"] / f"{ckpt_name}_fg_pred.wav"), fg_pred, SR) print(f" saved {pd['split']}/{pd['sid'][:40]} " f"fg_pred peak={float(fg_pred.abs().max()):.3f} " f"rms={float((fg_pred**2).mean().sqrt()):.4f}") # Now render 5-panel spec.png for each pair (after all 3 ckpts done). print("\nrendering 5-panel spectrograms...") for i, pd in enumerate(pair_data): panels = [] for label, key in [("bg", "bg.wav"), ("fg_gt", "fg_gt.wav"), ("pretrained", "pretrained_fg_pred.wav"), ("step1000", "step1000_fg_pred.wav"), ("step2000", "step2000_fg_pred.wav")]: w, sr_w = torchaudio.load(str(pd["sub"] / key)) if sr_w != SR: w = torchaudio.functional.resample(w, sr_w, SR) mel = log_mel(w, cfg["sr"], cfg["n_fft"], cfg["hop_length"], cfg["n_mels"], cfg["fmax"]) panels.append((label, mel)) out_png = pd["sub"] / "spec.png" render_panels(panels, title=f"[{pd['split']}] {pd['rel']}", out_path=str(out_png), sr=cfg["sr"], hop_length=cfg["hop_length"], fmax=cfg["fmax"]) print(f" {out_png}") print(f"\n=== DONE ===\noutput: {out_root}") if __name__ == "__main__": main()