Upload ProDiff/train.py with huggingface_hub

ProDiff/train.py

@@ -0,0 +1,279 @@
+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.")