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