code/infer_sa_3ckpt_compare.py

"""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_<sid>/
          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_<sid>/...

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()