#!/usr/bin/env python3 import argparse import os import yaml import logging import torch import numpy as np import h5py import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader from torch.nn.utils.rnn import pad_sequence import pathlib # =================================================================== # (A) Argument Parsing & Setup # =================================================================== parser = argparse.ArgumentParser(description="Robust Conditional Diffusion Model Runner") parser.add_argument('--config', type=str, required=True, help='Path to YAML configuration file.') parser.add_argument('--debug', action='store_true', help='Enable debug level logging.') parser.add_argument('--log_file', type=str, default="conditional_diffusion_robust.log", help='Path to log file.') args = parser.parse_args() # Setup logging log_level = logging.DEBUG if args.debug else logging.INFO log_format = '%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s' logging.basicConfig(level=log_level, format=log_format, handlers=[logging.StreamHandler()]) logger = logging.getLogger() file_handler = logging.FileHandler(args.log_file, mode='w') file_handler.setFormatter(logging.Formatter(log_format)) logger.addHandler(file_handler) logger.info("Robust Conditional Diffusion Runner Script Started") # =================================================================== # (B) Configuration Loading # =================================================================== config_path = pathlib.Path(args.config) if not config_path.is_file(): logger.error(f"Configuration file not found: {args.config}"); exit(1) with open(config_path, 'r') as file: config = yaml.safe_load(file) logger.info(f"Loaded configuration from {config_path}") # Extract parameters params = config.get('parameters', {}) data_cfg = config.get('data', {}) USE_ENSEMBLE = params.get('use_conditioner_ensemble', False) EMBEDDINGS_H5_PATH = pathlib.Path(data_cfg['embeddings_h5_path']) CONDITIONERS_H5_PATH = pathlib.Path(data_cfg['conditioners_h5_path']) GROUP_TEMPLATE = data_cfg['group_key_template'] EMBEDDING_DSET_NAME = data_cfg['embedding_dataset_name'] OUTPUT_DIR = pathlib.Path(config['output_dir']) if USE_ENSEMBLE: CONDITIONER_DSET_NAME = data_cfg.get('conditioner_ensemble_dataset_name', 'z_ref_ensemble') logger.info("Configuration set to use CONDITIONER ENSEMBLE training.") else: CONDITIONER_DSET_NAME = data_cfg.get('conditioner_dataset_name', 'z_ref') logger.info("Configuration set to use SINGLE conditioner training.") # Global training variables BATCH_SIZE = params.get('batch_size', 64) NUM_EPOCHS = params.get('num_epochs', 50000) LEARNING_RATE = float(params.get('learning_rate', 1e-5)) # Explicitly cast to float NUM_GENERATE = params.get('num_gen', 1000) SAVE_INTERVAL = params.get('save_interval', 1000) DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") logger.info(f"Using device: {DEVICE}") # Setup output directories OUTPUT_DIR.mkdir(parents=True, exist_ok=True) checkpoint_dir = OUTPUT_DIR / 'checkpoints' checkpoint_dir.mkdir(exist_ok=True) logger.info(f"Output directory: {OUTPUT_DIR.resolve()}") # =================================================================== # (C) Data Loading (Robust Conditional w/ Ensemble Support) # =================================================================== class ConditionalEmbeddingDataset(Dataset): def __init__(self, embeddings_path, conditioners_path, group_template, emb_dset, cond_dset, use_ensemble, logger): self.logger = logger self.use_ensemble = use_ensemble self.data_pairs = [] self.system_ids = {} # Maps index to original SID if not embeddings_path.is_file() or not conditioners_path.is_file(): raise FileNotFoundError(f"HDF5 file not found at {embeddings_path} or {conditioners_path}") with h5py.File(embeddings_path, 'r') as femb, h5py.File(conditioners_path, 'r') as fcond: common_groups = sorted(list(set(femb.keys()) & set(fcond.keys()))) self.logger.info(f"Found {len(common_groups)} common system groups to load.") for group_name in common_groups: sid = int(group_name.split('_')[-1]) if emb_dset not in femb[group_name] or cond_dset not in fcond[group_name]: self.logger.warning(f"Dataset '{emb_dset}' or '{cond_dset}' missing in group {group_name}, skipping.") continue embs = torch.from_numpy(femb[group_name][emb_dset][:].astype(np.float32)) cond_data = torch.from_numpy(fcond[group_name][cond_dset][:].astype(np.float32)) for i in range(embs.shape[0]): idx = len(self.data_pairs) # Store the dynamic embedding and the *entire* conditioner data (either single or ensemble) self.data_pairs.append((embs[i], cond_data)) self.system_ids[idx] = sid self.logger.info(f"Loaded {len(self.data_pairs)} total data points (frames).") def __len__(self): return len(self.data_pairs) def __getitem__(self, idx): embedding, conditioner_data = self.data_pairs[idx] # If using ensemble and the conditioner is indeed an ensemble (3D tensor) if self.use_ensemble and conditioner_data.ndim == 3: rand_idx = torch.randint(0, conditioner_data.shape[0], (1,)).item() final_conditioner = conditioner_data[rand_idx] else: # Otherwise, just use the data as is (it's already a single 2D z_ref) final_conditioner = conditioner_data return embedding, final_conditioner def collate_fn(batch): """Pads variable-length conditioners to the max length in a batch.""" embeddings, conditioners = zip(*batch) padded_conditioners = pad_sequence(conditioners, batch_first=True, padding_value=0.0) embedding_batch = torch.stack(embeddings, 0) return embedding_batch, padded_conditioners try: dataset = ConditionalEmbeddingDataset( EMBEDDINGS_H5_PATH, CONDITIONERS_H5_PATH, GROUP_TEMPLATE, EMBEDDING_DSET_NAME, CONDITIONER_DSET_NAME, USE_ENSEMBLE, logger ) dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=0, pin_memory=True, collate_fn=collate_fn) except Exception as e: logger.error(f"Failed to create dataset: {e}", exc_info=True); exit(1) # =================================================================== # (D) Conditional Diffusion Model & Utilities # =================================================================== # Diffusion schedule T = params.get('diffusion_steps', 1000) beta_start = params.get('beta_start', 0.0001) beta_end = params.get('beta_end', 0.02) betas = torch.linspace(beta_start, beta_end, T, device=DEVICE) alphas = 1. - betas alphas_cumprod = torch.cumprod(alphas, axis=0) sqrt_alphas_cumprod = torch.sqrt(alphas_cumprod) sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - alphas_cumprod) def q_sample(x_0, t, noise=None): if noise is None: noise = torch.randn_like(x_0) sqrt_alpha_cumprod_t = sqrt_alphas_cumprod[t].view(-1, 1) sqrt_one_minus_alpha_cumprod_t = sqrt_one_minus_alphas_cumprod[t].view(-1, 1) return sqrt_alpha_cumprod_t * x_0 + sqrt_one_minus_alpha_cumprod_t * noise # --- Model Architecture --- class ConditionerEncoder(nn.Module): """Encodes a variable-length 2D conditioner to a fixed-size vector.""" def __init__(self, input_dim, output_dim): super().__init__() self.net = nn.Sequential( nn.Conv1d(in_channels=input_dim, out_channels=64, kernel_size=3, padding=1), nn.GELU(), nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, padding=1), nn.GELU(), nn.AdaptiveMaxPool1d(1), # Global Max Pooling nn.Flatten(), nn.Linear(128, output_dim) ) def forward(self, x): # Input x: [Batch, SeqLen, Features] -> e.g., [64, 450, 16] # Conv1d expects [Batch, Features, SeqLen] x = x.permute(0, 2, 1) return self.net(x) class DiffusionModel(nn.Module): """Main diffusion model that uses the conditioner encoder.""" def __init__(self, data_dim, cond_input_dim, cond_encoded_dim, hidden_dim): super().__init__() self.encoder = ConditionerEncoder(cond_input_dim, cond_encoded_dim) self.net = nn.Sequential( nn.Linear(data_dim + 1 + cond_encoded_dim, hidden_dim), nn.GELU(), nn.Linear(hidden_dim, hidden_dim), nn.GELU(), nn.Linear(hidden_dim, hidden_dim), nn.GELU(), nn.Linear(hidden_dim, data_dim) ) def forward(self, x, t, cond_2d): t_norm = t.float().unsqueeze(1) / T encoded_cond = self.encoder(cond_2d) net_input = torch.cat([x, t_norm, encoded_cond], dim=1) return self.net(net_input) # --- Sampling --- @torch.no_grad() def p_sample_loop(model, shape, conditioner_2d): x_t = torch.randn(shape, device=DEVICE) # The conditioner is the same for all samples in this batch conditioner_batch = conditioner_2d.unsqueeze(0).repeat(shape[0], 1, 1) for t in reversed(range(T)): t_batch = torch.full((shape[0],), t, device=DEVICE, dtype=torch.long) predicted_noise = model(x_t, t_batch, conditioner_batch) alpha_t = alphas[t] beta_t = betas[t] sqrt_recip_alpha_t = torch.sqrt(1.0 / alpha_t) model_mean = sqrt_recip_alpha_t * (x_t - (beta_t / sqrt_one_minus_alphas_cumprod[t]) * predicted_noise) if t > 0: noise = torch.randn_like(x_t) x_t = model_mean + torch.sqrt(beta_t) * noise else: x_t = model_mean return x_t # =================================================================== # (E) Training Loop # =================================================================== def load_checkpoint(model, optimizer, filename, device, logger): """Loads a checkpoint to resume training.""" start_epoch = 0 if os.path.isfile(filename): logger.info(f"Loading checkpoint: '{filename}'") try: ckpt = torch.load(filename, map_location=device) start_epoch = ckpt.get('epoch', 0) model.load_state_dict(ckpt['model_state_dict']) if optimizer and 'optimizer_state_dict' in ckpt: optimizer.load_state_dict(ckpt['optimizer_state_dict']) logger.info(f"Checkpoint loaded. Resuming from epoch {start_epoch + 1}") except Exception as e: logger.error(f"Error loading checkpoint: {e}. Starting from scratch.") start_epoch = 0 else: logger.info("No checkpoint found. Starting from scratch.") return model, optimizer, start_epoch def train(): data_dim = dataset[0][0].shape[0] cond_input_dim = dataset[0][1].shape[1] cond_encoded_dim = params.get('conditioner_encoded_dim', 128) model = DiffusionModel( data_dim, cond_input_dim, cond_encoded_dim, params.get('hidden_dim', 1024) ).to(DEVICE) optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE) criterion = nn.MSELoss() # --- Load Checkpoint to Resume --- checkpoint_path = checkpoint_dir / "cond_diffusion_latest.pth" model, optimizer, start_epoch = load_checkpoint(model, optimizer, checkpoint_path, DEVICE, logger) if start_epoch >= NUM_EPOCHS: logger.info(f"Training has already been completed to epoch {start_epoch}. Skipping.") return model logger.info(f"Starting training from epoch {start_epoch + 1}...") for epoch in range(start_epoch, NUM_EPOCHS): model.train() epoch_loss = 0.0 for i, (x0_batch, cond_batch) in enumerate(dataloader): x0_batch, cond_batch = x0_batch.to(DEVICE), cond_batch.to(DEVICE) optimizer.zero_grad() t = torch.randint(0, T, (x0_batch.shape[0],), device=DEVICE).long() noise = torch.randn_like(x0_batch) x_t = q_sample(x0_batch, t, noise=noise) predicted_noise = model(x_t, t, cond_batch) loss = criterion(predicted_noise, noise) loss.backward() optimizer.step() epoch_loss += loss.item() avg_epoch_loss = epoch_loss / len(dataloader) if (epoch + 1) % 10 == 0: logger.info(f"Epoch {epoch+1}/{NUM_EPOCHS}, Avg Loss: {avg_epoch_loss:.6f}") # Save a single, consistently named checkpoint file if (epoch + 1) % SAVE_INTERVAL == 0 or (epoch + 1) == NUM_EPOCHS: torch.save({ 'epoch': epoch + 1, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'loss': avg_epoch_loss, }, checkpoint_path) logger.info(f"Checkpoint saved to {checkpoint_path}") logger.info("Training finished.") return model # =================================================================== # (F) Generation (No longer called automatically) # =================================================================== def generate(model): logger.info("Starting generation...") model.eval() # Get unique system IDs from the original dataset mapping unique_sids = sorted(list(set(dataset.system_ids.values()))) logger.info(f"Will generate {NUM_GENERATE} samples for each of the {len(unique_sids)} unique systems found.") # For generation, we always use the clean, single z_ref, not the ensemble. gen_cond_dset_name = config.get('data', {}).get('conditioner_dataset_name', 'z_ref') with h5py.File(CONDITIONERS_H5_PATH, 'r') as fcond: for sid in unique_sids: group_name = GROUP_TEMPLATE.format(sid) logger.info(f"--- Generating for System ID: {sid} ---") try: if group_name not in fcond or gen_cond_dset_name not in fcond[group_name]: logger.warning(f"Clean conditioner '{gen_cond_dset_name}' not found for SID {sid}. Skipping generation.") continue cond_np = fcond[group_name][gen_cond_dset_name][:] conditioner_2d = torch.from_numpy(cond_np).float().to(DEVICE) gen_shape = (NUM_GENERATE, dataset[0][0].shape[0]) generated_samples = p_sample_loop(model, gen_shape, conditioner_2d).cpu().numpy() save_path = OUTPUT_DIR / f"generated_embeddings_cond_on_sys_{sid}.h5" with h5py.File(save_path, 'w') as f_out: f_out.create_dataset("generated_embeddings", data=generated_samples) f_out.create_dataset("conditioner_z_ref", data=cond_np) logger.info(f"Saved generated samples for system {sid} to {save_path}") except Exception as e: logger.error(f"Failed to generate for system {sid}: {e}", exc_info=True) if __name__ == "__main__": trained_model = train() # The generate() function is no longer called automatically. # Generation is now handled by a dedicated inference script. logger.info("Script finished training.")