Upload ProDiff/main.py with huggingface_hub

ProDiff/main.py

@@ -0,0 +1,275 @@
+import os
+import torch
+import datetime
+import shutil
+from pathlib import Path
+import argparse
+from types import SimpleNamespace
+import sys
+import numpy as np
+
+
+from conf import config as config_module # Corrected alias
+from utils.logger import Logger, log_info
+from utils.utils import set_seed, ddp_setup, destroy_process_group, get_data_paths
+from dataset.data_util import TrajectoryDataset
+from torch.utils.data import DataLoader
+from diffProModel.Diffusion import Diffusion
+from diffProModel.protoTrans import TrajectoryTransformer
+
+
+from train import train_main 
+from test import test_model
+
+def setup_experiment_environment(base_exp_dir, exp_name_with_timestamp, config_to_save, files_to_copy=None):
+    """Sets up the experiment directory structure and saves essential files."""
+    exp_dir = base_exp_dir / exp_name_with_timestamp
+    results_dir = exp_dir / 'results'
+    models_dir = exp_dir / 'models' # Unified models dir, not timestamped sub-dir by default here
+    logs_dir = exp_dir / 'logs'
+    code_save_dir = exp_dir / 'code_snapshot'
+
+    os.makedirs(results_dir, exist_ok=True)
+    os.makedirs(models_dir, exist_ok=True)
+    os.makedirs(logs_dir, exist_ok=True)
+    os.makedirs(code_save_dir, exist_ok=True)
+
+    # Save configuration
+    # (Convert SimpleNamespace to dict for easier saving if needed, or save as text)
+    with open(exp_dir / 'config_used.txt', 'w') as f:
+        import json
+        # Convert SimpleNamespace to dict for JSON serialization
+        def ns_to_dict(ns):
+            if isinstance(ns, SimpleNamespace):
+                return {k: ns_to_dict(v) for k, v in ns.__dict__.items()}
+            elif isinstance(ns, dict):
+                return {k: ns_to_dict(v) for k, v in ns.items()}
+            elif isinstance(ns, list):
+                return [ns_to_dict(i) for i in ns]
+            return ns
+        config_dict = ns_to_dict(config_to_save)
+        json.dump(config_dict, f, indent=4)
+
+    # Copy essential code files
+    if files_to_copy:
+        for file_path_str in files_to_copy:
+            try:
+                file_path = Path(file_path_str)
+                if file_path.exists():
+                    shutil.copy(file_path, code_save_dir)
+                else:
+                    print(f"Warning: File to copy not found: {file_path_str}") # Use logger if available
+            except Exception as e:
+                print(f"Warning: Could not copy file {file_path_str}: {e}")
+    
+    return exp_dir, models_dir, logs_dir, results_dir
+
+def main():
+    parser = argparse.ArgumentParser(description='Unified Trajectory Interpolation - Training with Periodic Validation')
+    parser.add_argument('--sampling_type', type=str, default='ddpm', choices=['ddpm', 'ddim'], 
+                        help='Diffusion sampling type (ddpm or ddim) - influences periodic validation if DDIM is chosen, and experiment naming.')
+    parser.add_argument('--config_module_path', type=str, default='conf.config', 
+                        help='Python module path for base configuration (e.g., conf.config)')
+    parser.add_argument('--exp_name', type=str, default='traj_interp_exp', 
+                        help='Base name for the experiment directory')
+    parser.add_argument('--seed', type=int, default=42, help='Random seed')
+    parser.add_argument('--device_id', type=int, default=0, help='CUDA device ID to use')
+    parser.add_argument('--distributed', action='store_true', help='Enable distributed training (DDP)')
+    
+    parser.add_argument('--ddim_steps', type=int, default=50, help='Number of DDIM sampling steps for periodic validation')
+    parser.add_argument('--ddim_eta', type=float, default=0.0, 
+                        help='DDIM stochasticity parameter for periodic validation (0=deterministic, 1=DDPM-like)')
+    
+    parser.add_argument('--debug', action='store_true', help='Enable debug mode for more detailed logs')
+    
+    # 添加测试模式相关参数
+    parser.add_argument('--mode', type=str, default='train', choices=['train', 'test'],
+                        help='运行模式：训练或测试')
+    parser.add_argument('--model_path', type=str, default=None,
+                        help='测试模式下，指定要加载的模型路径')
+    parser.add_argument('--model_epoch', type=int, default=None,
+                        help='测试模式下，指定要加载的模型epoch')
+
+    args = parser.parse_args()
+
+    # --- Basic Setup ---
+    if args.distributed:
+        ddp_setup(args.distributed) # Sets LOCAL_RANK env var if not already set by launcher
+        local_rank = int(os.environ.get('LOCAL_RANK', 0))
+    else:
+        local_rank = 0
+    
+    if not args.distributed or local_rank == 0: # Setup master process first or if not distributed
+        print(f"Running on device: cuda:{args.device_id}" if torch.cuda.is_available() else "Running on CPU")
+    
+    if torch.cuda.is_available():
+        torch.cuda.set_device(args.device_id if not args.distributed else local_rank)
+    
+    set_seed(args.seed + local_rank) # Ensure different seeds for different processes in DDP for some operations
+
+    # --- Load Configuration ---
+    try:
+        base_config_dict = config_module.load_config() # from conf.config import load_config
+    except Exception as e:
+        print(f"Error loading base configuration from {args.config_module_path}: {e}")
+        sys.exit(1)
+
+    # Handle both dict and SimpleNamespace return from load_config()
+    if isinstance(base_config_dict, dict):
+        cfg_ns = {k: SimpleNamespace(**v) for k, v in base_config_dict.items()}
+        config = SimpleNamespace(**cfg_ns)
+    else:
+        # load_config() already returned a SimpleNamespace
+        config = base_config_dict
+
+    # Update config with command-line arguments
+    config.debug = args.debug
+    config.training.dis_gpu = args.distributed
+    config.sampling.type = args.sampling_type
+    config.sampling.ddim_steps = args.ddim_steps
+    config.sampling.ddim_eta = args.ddim_eta
+    config.device_id = args.device_id # Pass device_id for train_main
+    # Ensure other necessary fields exist in config (add defaults if not in config.py)
+    if not hasattr(config, 'model'): config.model = SimpleNamespace()
+    if not hasattr(config.model, 'loss_type'): config.model.loss_type = 'l1' # Default
+    if not hasattr(config.training, 'learning_rate'): config.training.learning_rate = 2e-4
+    if not hasattr(config.training, 'warmup_epochs'): config.training.warmup_epochs = 10
+    if not hasattr(config.training, 'contrastive_margin'): config.training.contrastive_margin = 1.0
+    if not hasattr(config.training, 'use_amp'): config.training.use_amp = True 
+    if not hasattr(config.training, 'kmeans_memory_size'): config.training.kmeans_memory_size = 10 # Batches
+    if not hasattr(config.training, 'ce_loss_weight'): config.training.ce_loss_weight = 0.1
+    if not hasattr(config.training, 'diffusion_loss_weight'): config.training.diffusion_loss_weight = 1.0
+    if not hasattr(config.training, 'contrastive_loss_weight'): config.training.contrastive_loss_weight = 1.0
+
+    # --- Setup Experiment Environment (only on rank 0 if DDP) ---
+    timestamp_str = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
+    # Include sampling type in experiment name for clarity
+    exp_name_ts = f"{args.exp_name}_{config.data.dataset}_len{config.data.traj_length}_{args.sampling_type}_{timestamp_str}"
+    
+    exp_dir, models_save_dir, logs_dir, results_dir = Path("."), Path("."), Path("."), Path(".") # Defaults for non-rank0
+    if local_rank == 0:
+        root_dir = Path(__file__).resolve().parent # Project root
+        base_experiment_path = root_dir / "Experiments" # Changed from "Backups"
+        
+        files_to_copy_snapshot = [
+            'main.py', 'train.py', 'test.py', 'conf/config.py',
+            'diffProModel/Diffusion.py', 'diffProModel/protoTrans.py', 'diffProModel/loss.py',
+            'utils/utils.py', 'utils/logger.py', 'utils/metric.py', 'dataset/data_util.py'
+        ]
+        exp_dir, models_save_dir, logs_dir, results_dir = setup_experiment_environment(
+            base_experiment_path, exp_name_ts, config, files_to_copy_snapshot
+        )
+    
+    # Logger setup (after exp_dir is known by all processes if DDP, or just for rank 0)
+    logger = None
+    if local_rank == 0:
+        log_file_path = logs_dir / f"log_{timestamp_str}.txt"
+        logger = Logger(
+            name=exp_name_ts,
+            log_path=log_file_path,
+            colorize=True,
+            level="debug" if args.debug else "info"
+        )
+        logger.info(f"Experiment directory: {exp_dir}")
+        log_info(config, logger) # Log the configuration details
+        logger.info(f"Using sampling type for periodic validation: {args.sampling_type}")
+        if args.sampling_type == 'ddim':
+            logger.info(f"DDIM Steps for validation: {args.ddim_steps}, Eta for validation: {args.ddim_eta}")
+
+    # Barrier to ensure exp_dir is created by rank 0 before other ranks proceed if DDP
+    if args.distributed:
+        torch.distributed.barrier()
+
+    # 设置设备
+    device = torch.device(f"cuda:{args.device_id}" if torch.cuda.is_available() else "cpu")
+
+    if args.mode == 'train':
+        # --- Main Execution: Call Training (which includes periodic validation) ---
+        if logger and local_rank == 0: 
+            logger.info("Starting training with periodic validation...")
+        
+        train_main(config, logger, exp_dir, timestamp_str) 
+    else:  # 测试模式
+        if logger and local_rank == 0:
+            logger.info("Starting model testing...")
+            logger.info(f"Loading model from: {args.model_path}")
+            logger.info(f"Using epoch: {args.model_epoch}")
+
+        # 加载数据
+        test_dataset = TrajectoryDataset(
+            file_paths=get_data_paths(config.data, for_train=False),
+            traj_length=config.data.traj_length
+        )
+        test_dataloader = DataLoader(
+            test_dataset,
+            batch_size=config.sampling.batch_size,
+            shuffle=False,
+            num_workers=config.data.num_workers if isinstance(config.data.num_workers, int) else 4,
+            pin_memory=True
+        )
+
+        # 初始化模型
+        diffusion_model = Diffusion(
+            loss_type=config.model.loss_type,
+            config=config,
+            clip_denoised=True,
+            predict_epsilon=True
+        ).to(device)
+        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)
+
+        # 加载模型权重 - 自动检测最新的timestamp目录
+        models_base_dir = Path(args.model_path) / "models"
+        # 获取models目录下的所有子目录，选择最新的timestamp目录
+        timestamp_dirs = [d for d in models_base_dir.iterdir() if d.is_dir()]
+        if not timestamp_dirs:
+            raise FileNotFoundError(f"No model timestamp directories found in {models_base_dir}")
+        
+        # 按时间戳排序，选择最新的
+        latest_timestamp_dir = sorted(timestamp_dirs, key=lambda x: x.name)[-1]
+        model_dir = latest_timestamp_dir
+        
+        diffusion_model_path = model_dir / f"diffusion_model_epoch_{args.model_epoch}.pt"
+        transformer_model_path = model_dir / f"transformer_epoch_{args.model_epoch}.pt"
+        prototypes_path = model_dir / f"prototypes_transformer_epoch_{args.model_epoch}.npy"
+
+        if logger and local_rank == 0:
+            logger.info(f"Loading diffusion model from: {diffusion_model_path}")
+            logger.info(f"Loading transformer model from: {transformer_model_path}")
+            logger.info(f"Loading prototypes from: {prototypes_path}")
+
+        diffusion_model.load_state_dict(torch.load(diffusion_model_path, map_location=device))
+        short_samples_model.load_state_dict(torch.load(transformer_model_path, map_location=device))
+        prototypes = torch.from_numpy(np.load(prototypes_path)).float().to(device)
+
+        # 运行测试
+        with torch.no_grad():
+            test_model(
+                test_dataloader=test_dataloader,
+                diffusion_model=diffusion_model,
+                short_samples_model=short_samples_model,
+                config=config,
+                epoch=args.model_epoch,
+                prototypes=prototypes,
+                device=device,
+                logger=logger,
+                exp_dir=exp_dir
+            )
+    
+    if args.distributed:
+        if torch.distributed.is_initialized():
+            destroy_process_group()
+    
+    if local_rank == 0 and logger: 
+        logger.info("Main script execution finished.")
+
+if __name__ == "__main__":
+    main()