diffusion/sample_yukawa.py

"""
Generate samples from a trained 2D Yukawa scalar-field diffusion model.

Usage:
    python sample_yukawa.py --g 0.1 --ep 1000
    python sample_yukawa.py --g 0.1 --method ode --num_steps 200
"""

import sys
sys.path.append("../..")

import os
import re
import functools
import argparse
from pathlib import Path

import torch
import numpy as np
import matplotlib.pyplot as plt

from networks import ScoreNet, ScoreNetUNetPeriodic, NCSNpp2D
from diffusion_lightning import DiffusionModel, marginal_prob_std


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--checkpoint", type=str, default=None)
    parser.add_argument("--num_samples", type=int, default=1024)
    parser.add_argument("--num_steps", type=int, default=1000)
    parser.add_argument("--method", type=str, default="em",
                        choices=["em", "ode", "pc"])
    parser.add_argument("--ep", type=str, default=None)
    parser.add_argument("--L", type=int, default=16)
    parser.add_argument("--g", type=float, default=0.1)
    parser.add_argument("--plot_grid", type=int, default=4)
    parser.add_argument("--device", type=str, default="cuda:0")
    parser.add_argument("--network", type=str, default="ncsnpp",
                        choices=["scorenet", "unet", "ncsnpp"],
                        help="Network architecture: scorenet | unet | ncsnpp")
    parser.add_argument("--output_suffix", type=str, default="",
                        help="Suffix on the training output dir (e.g. '_sigma50')")
    parser.add_argument("--schedule", type=str, default="log",
                        choices=["log", "linear"],
                        help="Reverse-time step schedule")
    parser.add_argument("--ode_method", type=str, default="dpm2",
                        choices=["dpm1", "dpm2", "dpm3", "rk45"],
                        help="ODE solver when --method=ode (default dpm2)")
    parser.add_argument("--n_repeats", type=int, default=1,
                        help="Number of independent sampling passes to concatenate")
    parser.add_argument("--seed", type=int, default=None,
                        help="If set, seeds torch/cuda RNG before each sampling pass. "
                             "Fixes both the initial noise x_T and all per-step noise "
                             "in SDE reverse integration, giving identical trajectories "
                             "across calls. Repeats use seed, seed+1, ... (deterministic).")
    args = parser.parse_args()

    run_dir = f"runs/yukawa_L{args.L}_g{args.g}_{args.network}{args.output_suffix}"

    # Get checkpoint
    if args.checkpoint is None:
        ckpts = sorted(Path(f"{run_dir}/models").glob(f"*{args.ep}*.ckpt"))
        args.checkpoint = str(ckpts[-1]) if ckpts else None
    print(f"Checkpoint: {args.checkpoint}")

    # Load hparams from checkpoint first
    ckpt = torch.load(args.checkpoint, map_location="cpu", weights_only=False)
    hparams = ckpt.get("hyper_parameters", {})
    sigma = hparams.get("sigma", 50.0)
    L = hparams.get("L", args.L)
    norm_min = hparams["norm_min"]
    norm_max = hparams["norm_max"]
    print(f"norm_min: {norm_min}, norm_max: {norm_max}")
    output = f"{run_dir}/data/"
    if not os.path.exists(output):
        os.makedirs(output)
    output = os.path.join(output, "samples")
    # Parse g from checkpoint path (directory or filename)
    g_match = re.search(r'_g([\d.]+?)_', str(args.checkpoint))
    g = float(g_match.group(1)) if g_match else args.g
    print(f"L={L}, g={g}, sigma={sigma}")

    # Load model with correct sigma
    marginal_prob_std_fn = functools.partial(marginal_prob_std, sigma=sigma)
    if args.network == "ncsnpp":
        score_model = NCSNpp2D(marginal_prob_std_fn)
    elif args.network == "scorenet":
        score_model = ScoreNet(marginal_prob_std_fn, periodic=True)
    else:
        score_model = ScoreNetUNetPeriodic(marginal_prob_std_fn)
    model = DiffusionModel.load_from_checkpoint(args.checkpoint, score_model=score_model, map_location=args.device, weights_only=False)
    model = model.to(args.device).eval()

    # Sample
    print(f"Sampling ({args.method.upper()})  num_steps={args.num_steps}  n_repeats={args.n_repeats}  num_samples/rep={args.num_samples}")
    if args.seed is not None:
        print(f"Seed: {args.seed} (fixed IC + reverse-step noise)")

    def _seed_for(rep_idx):
        if args.seed is not None:
            s = args.seed + rep_idx
            torch.manual_seed(s)
            torch.cuda.manual_seed_all(s)

    if args.method == "em":
        reps = []
        for i in range(args.n_repeats):
            _seed_for(i)
            reps.append(model.sample(args.num_samples, args.num_steps, schedule=args.schedule))
        samples = torch.concatenate(reps, axis=0)
    elif args.method == "ode":
        reps = []
        for i in range(args.n_repeats):
            _seed_for(i)
            reps.append(model.sample_ode(args.num_samples, args.num_steps,
                                         schedule=args.schedule, method=args.ode_method))
        samples = torch.concatenate(reps, axis=0)
    else:  # pc
        reps = []
        for i in range(args.n_repeats):
            _seed_for(i)
            reps.append(model.sample_pc(args.num_samples, args.num_steps))
        samples = torch.concatenate(reps, axis=0)

    # Samples are in normalized [-1, 1] range, shape (num_samples, 1, L, L)
    samples_norm = samples[:, 0].cpu().numpy()

    # Renormalize to original range
    samples_renorm = (samples_norm + 1) / 2 * (norm_max - norm_min) + norm_min

    # Save as (L, L, num_samples*n_repeats)
    samples_out = samples_renorm.transpose(1, 2, 0)
    tag = f"{args.method}_{args.schedule}_steps{args.num_steps}_{args.ep}"
    np.save(f"{output}_{tag}.npy", samples_out)
    print(f"Saved samples to {output}_{tag}.npy, shape: {samples_out.shape}")

    # Plot grid (only first plot_grid^2 samples)
    n = args.plot_grid
    fig, axes = plt.subplots(n, n, figsize=(n * 2, n * 2))
    for i, ax in enumerate(axes.flatten()):
        ax.imshow(samples[i, 0].cpu().numpy(), cmap="viridis")
        ax.axis("off")
    plt.tight_layout()
    plt.savefig(f"{output}_{tag}.png", dpi=150)
    print(f"Saved plot to {output}_{tag}.png")


if __name__ == "__main__":
    main()