import os import torch from torch import nn import torch.nn.functional as F import itertools import numpy as np from tqdm import tqdm from torch.utils.data import DataLoader, DistributedSampler from torch.nn.parallel import DistributedDataParallel as DDP from torch.distributed import init_process_group, destroy_process_group from torch.utils.data import TensorDataset from datetime import datetime from torch.optim.lr_scheduler import LambdaLR import sys from utils.logger import Logger from dataset.data_util import MinMaxScaler, TrajectoryDataset from utils.utils import IterativeKMeans, assign_labels, get_positive_negative_pairs, mask_data_general, get_data_paths, continuous_mask_data, continuous_time_based_mask, mask_multiple_segments from diffProModel.loss import ContrastiveLoss from diffProModel.protoTrans import TrajectoryTransformer from diffProModel.Diffusion import Diffusion from test import test_model # Import test_model def ddp_setup(distributed): """Initialize the process group for distributed data parallel if distributed is True.""" if distributed: if not torch.distributed.is_initialized(): init_process_group(backend="nccl") torch.cuda.set_device(int(os.environ['LOCAL_RANK'])) def setup_model_save_directory(exp_dir, timestamp): """Set up the directory for saving model checkpoints.""" model_save_path = exp_dir / 'models' / (timestamp + '/') os.makedirs(model_save_path, exist_ok=True) return model_save_path def lr_lambda_fn(current_epoch, warmup_epochs, total_epochs): if current_epoch < warmup_epochs: return float(current_epoch) / float(max(1, warmup_epochs)) return 0.5 * (1. + torch.cos(torch.tensor(torch.pi * (current_epoch - warmup_epochs) / float(total_epochs - warmup_epochs)))) def train_main(config, logger, exp_dir, timestamp_str): """Main function to run the training and testing pipeline for DDPM or DDIM.""" distributed = config.dis_gpu local_rank = 0 # Default for non-DDP logging/master tasks #logger.info(config.validation_freq) # 1 if distributed: ddp_setup(distributed) # This also calls torch.cuda.set_device(os.environ['LOCAL_RANK']) local_rank = int(os.environ['LOCAL_RANK']) device = torch.device(f'cuda:{local_rank}') else: device_id_to_use = config.device_id if torch.cuda.is_available(): torch.cuda.set_device(device_id_to_use) device = torch.device(f'cuda:{device_id_to_use}') else: device = torch.device('cpu') train_file_paths = get_data_paths(config.data, for_train=True) diffusion_model = Diffusion(loss_type=config.model.loss_type, config=config).to(device) lr = config.learning_rate model_save_dir = setup_model_save_directory(exp_dir, timestamp_str) train_dataset = TrajectoryDataset(train_file_paths, config.data.traj_length) train_sampler = DistributedSampler(train_dataset, shuffle=True) if distributed else None train_dataloader = DataLoader(train_dataset, batch_size=config.batch_size, shuffle=(train_sampler is None), num_workers=config.data.num_workers, drop_last=True, sampler=train_sampler, pin_memory=True) # Create Test DataLoader test_file_paths = get_data_paths(config.data, for_train=False) test_dataset = TrajectoryDataset(test_file_paths, config.data.traj_length) test_dataloader = DataLoader(test_dataset, batch_size=config.sampling.batch_size, # Use sampling batch_size from config shuffle=False, num_workers=config.data.num_workers, drop_last=False, # Typically False for full test set evaluation pin_memory=True) if distributed: diffusion_model = DDP(diffusion_model, device_ids=[local_rank], find_unused_parameters=False) short_samples_model = TrajectoryTransformer( input_dim=config.trans.input_dim, embed_dim=config.trans.embed_dim, num_layers=config.trans.num_layers, num_heads=config.trans.num_heads, forward_dim=config.trans.forward_dim, seq_len=config.data.traj_length, n_cluster=config.trans.N_CLUSTER, dropout=config.trans.dropout ).to(device) if distributed: short_samples_model = DDP(short_samples_model, device_ids=[local_rank], find_unused_parameters=False) optim = torch.optim.AdamW(itertools.chain(diffusion_model.parameters(), short_samples_model.parameters()), lr=lr, foreach=False) warmup_epochs = config.warmup_epochs total_epochs = config.n_epochs scheduler = LambdaLR(optim, lr_lambda=lambda epoch: lr_lambda_fn(epoch, warmup_epochs, total_epochs)) losses_dict = {} contrastive_loss_fn = ContrastiveLoss(margin=config.contrastive_margin) ce_loss_fn = nn.CrossEntropyLoss() for epoch in range(1, config.n_epochs + 1): if distributed: train_sampler.set_epoch(epoch) epoch_losses = [] previous_features_for_kmeans = [] if local_rank == 0: logger.info(f"<----Epoch-{epoch}---->") kmeans = IterativeKMeans(num_clusters=config.trans.N_CLUSTER, device=device) pbar = tqdm(train_dataloader, desc=f"Epoch {epoch} Training", disable=(local_rank != 0)) for batch_idx, (abs_time, lat, lng) in enumerate(pbar): trainx_raw = torch.stack([abs_time, lat, lng], dim=-1).to(device) # Use global normalization parameters to avoid per-batch inconsistency scaler = MinMaxScaler(global_params_file='./data/robust_normalization_params.json') scaler.fit(trainx_raw) # This does nothing for global scaler, but maintains interface trainx_scaled = scaler.transform(trainx_raw) prototypes_from_transformer, features_for_kmeans_and_contrastive = short_samples_model(trainx_scaled) if not previous_features_for_kmeans: current_batch_prototypes_kmeans, _ = kmeans.fit(features_for_kmeans_and_contrastive.detach()) else: features_memory = torch.cat(previous_features_for_kmeans, dim=0).detach() current_batch_prototypes_kmeans, _ = kmeans.update(features_for_kmeans_and_contrastive.detach(), features_memory) if len(previous_features_for_kmeans) < config.kmeans_memory_size: previous_features_for_kmeans.append(features_for_kmeans_and_contrastive.detach()) elif config.kmeans_memory_size > 0 : previous_features_for_kmeans.pop(0) previous_features_for_kmeans.append(features_for_kmeans_and_contrastive.detach()) # Permute the dimensions to match the model's expected input shape x0_for_diffusion = trainx_scaled.permute(0, 2, 1) # Apply masking if config.masking_strategy == 'general': masked_x0_condition_diffusion = mask_data_general(x0_for_diffusion) elif config.masking_strategy == 'continuous': masked_x0_condition_diffusion = continuous_mask_data(x0_for_diffusion, config.mask_ratio) elif config.masking_strategy == 'time_based': masked_x0_condition_diffusion = continuous_time_based_mask(x0_for_diffusion, points_to_mask=config.mask_points_per_hour) elif config.masking_strategy == 'multi_segment': masked_x0_condition_diffusion = mask_multiple_segments(x0_for_diffusion, points_per_segment=config.mask_segments) else: raise ValueError(f"Unknown masking strategy: {config.masking_strategy}") masked_x0_permuted_for_ssm = masked_x0_condition_diffusion.permute(0, 2, 1) with torch.no_grad(): _, query_features_from_masked = short_samples_model(masked_x0_permuted_for_ssm) cos_sim = F.cosine_similarity(query_features_from_masked.unsqueeze(1), prototypes_from_transformer.unsqueeze(0), dim=-1) d_k = query_features_from_masked.size(-1) scaled_cos_sim = F.softmax(cos_sim / np.sqrt(d_k), dim=-1) matched_prototypes_for_diffusion = torch.matmul(scaled_cos_sim, prototypes_from_transformer) positive_pairs, negative_pairs = get_positive_negative_pairs(prototypes_from_transformer, features_for_kmeans_and_contrastive) contrastive_loss_val = contrastive_loss_fn(features_for_kmeans_and_contrastive, positive_pairs, negative_pairs) contrastive_loss_val = contrastive_loss_val * config.contrastive_loss_weight labels_from_transformer_protos = assign_labels(prototypes_from_transformer.detach(), features_for_kmeans_and_contrastive.detach()).long() labels_from_kmeans = kmeans.predict(features_for_kmeans_and_contrastive.detach()).long() ce_loss_val = torch.tensor(0.0, device=device) if config.ce_loss_weight > 0: logits_for_ce = features_for_kmeans_and_contrastive @ F.normalize(prototypes_from_transformer.detach(), dim=-1).T ce_loss_val = ce_loss_fn(logits_for_ce, labels_from_kmeans) ce_loss_val = ce_loss_val * config.ce_loss_weight diffusion_model_ref = diffusion_model.module if distributed else diffusion_model diffusion_loss_val = diffusion_model_ref.trainer( x0_for_diffusion.float(), masked_x0_condition_diffusion.float(), matched_prototypes_for_diffusion.float(), weights=config.diffusion_loss_weight ) total_loss = diffusion_loss_val + ce_loss_val + contrastive_loss_val optim.zero_grad() total_loss.backward() torch.nn.utils.clip_grad_norm_(itertools.chain(diffusion_model.parameters(), short_samples_model.parameters()), max_norm=1.0) optim.step() epoch_losses.append(total_loss.item()) if local_rank == 0: pbar.set_postfix({ 'Loss': total_loss.item(), 'Diff': diffusion_loss_val.item(), 'Cont': contrastive_loss_val.item(), 'CE': ce_loss_val.item(), 'LR': optim.param_groups[0]['lr'] }) avg_epoch_loss = sum(epoch_losses) / len(epoch_losses) if epoch_losses else 0 losses_dict[epoch] = avg_epoch_loss scheduler.step() if local_rank == 0: logger.info(f"Epoch {epoch} Avg Loss: {avg_epoch_loss:.4f}") logger.info(f"Current LR: {optim.param_groups[0]['lr']:.6f}") if epoch % config.validation_freq == 0 and local_rank == 0: # Save model snapshot diffusion_state_dict = diffusion_model.module.state_dict() if distributed else diffusion_model.state_dict() transformer_state_dict = short_samples_model.module.state_dict() if distributed else short_samples_model.state_dict() torch.save(diffusion_state_dict, model_save_dir / f"diffusion_model_epoch_{epoch}.pt") torch.save(transformer_state_dict, model_save_dir / f"transformer_epoch_{epoch}.pt") if 'prototypes_from_transformer' in locals(): # Check if prototypes were generated in this epoch np.save(model_save_dir / f"prototypes_transformer_epoch_{epoch}.npy", prototypes_from_transformer.detach().cpu().numpy()) all_losses_path = exp_dir / 'results' / 'all_epoch_losses.npy' current_losses_to_save = {e: l for e, l in losses_dict.items()} if os.path.exists(all_losses_path): try: existing_losses = np.load(all_losses_path, allow_pickle=True).item() existing_losses.update(current_losses_to_save) np.save(all_losses_path, existing_losses) except Exception as e: if logger: logger.error(f"Error loading/updating losses file: {e}. Saving current losses only.") np.save(all_losses_path, current_losses_to_save) else: np.save(all_losses_path, current_losses_to_save) if logger: logger.info(f"Saved model and prototypes snapshot at epoch {epoch} to {model_save_dir}") # Periodic validation call if logger: logger.info(f"--- Starting validation for epoch {epoch} ---") diffusion_model_to_test = diffusion_model.module if distributed else diffusion_model short_samples_model_to_test = short_samples_model.module if distributed else short_samples_model diffusion_model_to_test.eval() short_samples_model_to_test.eval() current_prototypes_for_test = short_samples_model_to_test.prototypes.detach() with torch.no_grad(): test_model( test_dataloader=test_dataloader, diffusion_model=diffusion_model_to_test, short_samples_model=short_samples_model_to_test, config=config, epoch=epoch, prototypes=current_prototypes_for_test, device=device, logger=logger, exp_dir=exp_dir ) diffusion_model_to_test.train() short_samples_model_to_test.train() if logger: logger.info(f"--- Finished validation for epoch {epoch} ---") if distributed: destroy_process_group() if logger and local_rank == 0: # Ensure logger calls are rank-specific logger.info("Training finished.")