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