diffusion/train_yukawa.py

"""
Train a score-based diffusion model on the scalar field of the 2D Yukawa model.

Training data: HMC configs from ../samples/yukawa_g{g}_L{L}_1000000.jld2
(key "configs", shape (N, L, L)).

Usage:
    python train_yukawa.py --g 0.1 --device cuda:0
    python train_yukawa.py --g 0.3 --epochs 2000
"""

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

import os
import functools
import argparse

import numpy as np
import torch
import pytorch_lightning as pl
from pytorch_lightning.callbacks import Callback
from torch.utils.data import TensorDataset

torch.set_float32_matmul_precision('high')
torch.backends.cudnn.benchmark = True

from networks import ScoreNet, ScoreNetUNetPeriodic, NCSNpp2D
from diffusion_lightning import DiffusionModel, marginal_prob_std
from data import FieldDataModule, _normalize_pm1


class YukawaDataModule(FieldDataModule):
    """FieldDataModule variant for the Yukawa jld2 files (key "configs", (N, L, L))."""

    def setup(self, stage=None):
        import h5py
        with h5py.File(self.data_path, "r") as f:
            cfgs = np.array(f["configs"])

        if self.normalize:
            self.cfgs_min = float(cfgs.min())
            self.cfgs_max = float(cfgs.max())
            cfgs = _normalize_pm1(cfgs, self.cfgs_min, self.cfgs_max)

        configs = torch.from_numpy(cfgs).unsqueeze(1).float()
        del cfgs

        if self.device:
            self.data_on_gpu = configs.to(self.device)
            size_gb = self.data_on_gpu.nbytes / 1e9
            print(f"Field data loaded to {self.device} ({size_gb:.2f} GB, shape={tuple(self.data_on_gpu.shape)})")

        self.train_data = TensorDataset(configs, configs)


class LogScaleCheckpoint(Callback):
    """Save checkpoints on a log-scale schedule: denser early, sparser later."""

    def __init__(self, dirpath, max_epochs, num_checkpoints=100):
        super().__init__()
        self.dirpath = dirpath
        log_epochs = np.unique(np.geomspace(1, max_epochs, num=num_checkpoints).astype(int))
        self.save_epochs = set(log_epochs.tolist())

    def on_train_epoch_end(self, trainer, pl_module):
        epoch = trainer.current_epoch + 1  # 1-based
        if epoch in self.save_epochs:
            filepath = os.path.join(self.dirpath, f"epoch={epoch:04d}.ckpt")
            trainer.save_checkpoint(filepath)


def main():
    parser = argparse.ArgumentParser(description="Train diffusion model on 2D Yukawa scalar field")
    parser.add_argument("--L", type=int, default=16, help="Lattice size")
    parser.add_argument("--g", type=float, default=0.1, help="Yukawa coupling")
    parser.add_argument("--sigma", type=float, default=50.0,
                        help="Noise scale (std(t=1)=2*D_max_norm rule: g=0.1 -> ~56, g=0.3 -> ~48)")
    parser.add_argument("--lr", type=float, default=1e-3, help="Learning rate")
    parser.add_argument("--batch_size", type=int, default=64, help="Batch size")
    parser.add_argument("--epochs", type=int, default=1000, help="Number of epochs")
    parser.add_argument("--ema_start", type=int, default=0, help="Start EMA after this epoch")
    parser.add_argument("--device", type=str, default="cuda:0", help="GPU device")
    parser.add_argument("--data_path", type=str, default=None, help="Path to data file")
    parser.add_argument("--network", type=str, default="ncsnpp",
                        choices=["scorenet", "unet", "ncsnpp"],
                        help="Network architecture: scorenet | unet | ncsnpp")
    parser.add_argument("--ckpt_path", type=str, default=None, help="Path to checkpoint for resuming training")
    parser.add_argument("--num_ckpts", type=int, default=100,
                        help="Number of log-spaced checkpoints to save")
    parser.add_argument("--gpu_data", action="store_true",
                        help="Load all training data onto GPU once (avoids per-epoch H2D transfer)")
    parser.add_argument("--output_suffix", type=str, default="",
                        help="Suffix appended to output directory name (e.g. '_sigma50')")
    parser.add_argument("--compile_mode", type=str, default="default",
                        choices=["default", "reduce-overhead", "max-autotune"],
                        help="torch.compile mode")
    args = parser.parse_args()

    # Default data path
    if args.data_path is None:
        args.data_path = f"../samples/yukawa_g{args.g}_L{args.L}_1000000.jld2"

    # Create data module and setup to get normalization parameters
    data_module = YukawaDataModule(
        data_path=args.data_path,
        batch_size=args.batch_size,
        normalize=True,
        device=args.device if args.gpu_data else None,
    )
    data_module.setup()  # Compute cfgs_min, cfgs_max

    # Create marginal_prob_std function
    marginal_prob_std_fn = functools.partial(marginal_prob_std, sigma=args.sigma)

    # Create score model based on network choice
    if args.network == "unet":
        score_model = ScoreNetUNetPeriodic(marginal_prob_std_fn)
        print("Using UNet with downsampling (periodic BC)")
    elif args.network == "ncsnpp":
        score_model = NCSNpp2D(marginal_prob_std_fn)
        print("Using NCSNpp2D (NCSN++ style, periodic BC)")
    else:
        score_model = ScoreNet(marginal_prob_std_fn, periodic=True)
        print("Using ScoreNet (no downsampling)")

    score_model = score_model.to(memory_format=torch.channels_last)
    score_model = torch.compile(score_model, mode=args.compile_mode)

    # Create diffusion model with normalization parameters
    model = DiffusionModel(
        score_model=score_model,
        sigma=args.sigma,
        lr=args.lr,
        L=args.L,
        ema_start_epoch=args.ema_start,
        norm_min=data_module.cfgs_min,
        norm_max=data_module.cfgs_max,
    )
    print(f"Normalization range: [{data_module.cfgs_min:.4f}, {data_module.cfgs_max:.4f}]")
    print(f"EMA starts at epoch: {args.ema_start}")

    # Output directory for logs and models
    output_dir = f"runs/yukawa_L{args.L}_g{args.g}_{args.network}{args.output_suffix}"
    os.makedirs(f"{output_dir}/models", exist_ok=True)
    print(f"Output directory: {output_dir}/")

    # Log-scale checkpoint callback
    checkpoint_log = LogScaleCheckpoint(
        dirpath=f"{output_dir}/models",
        max_epochs=args.epochs,
        num_checkpoints=args.num_ckpts,
    )
    print(f"Log-scale checkpoints ({len(checkpoint_log.save_epochs)} total): "
          f"{sorted(checkpoint_log.save_epochs)[:5]} ... "
          f"{sorted(checkpoint_log.save_epochs)[-5:]}")

    # Trainer
    device_id = int(args.device.split(":")[-1]) if ":" in args.device else 0
    trainer = pl.Trainer(
        max_epochs=args.epochs,
        accelerator="gpu",
        devices=[device_id],
        callbacks=[checkpoint_log],
        default_root_dir=output_dir,
        precision="bf16-mixed",
        log_every_n_steps=10,
        enable_progress_bar=False,
        enable_checkpointing=False,
    )

    # Train
    trainer.fit(model, data_module, ckpt_path=args.ckpt_path)
    print("\nTraining complete!")


if __name__ == "__main__":
    main()