code/infer_sa_test_set.py

"""Bulk Stable Audio Open inference on the full 3919-pair test set, saved as
<root>/<rel_path>/{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 <root>/<rel_path>/{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()