UPDATE:init mppi file and infra, loaded model success

.gitignore

@@ -0,0 +1 @@
+*.pyc

logs/run-20250920_075505-k227j0rs/checkpoint_step_210000_20250920_144806.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1661992b3b0eada2f7960db6019c0901dd170cf81cb0ed9ac2af6c24af13b176
+size 1948153

logs/run-20250920_075505-k227j0rs/config.yaml

@@ -0,0 +1,238 @@
+_wandb:
+    value:
+        cli_version: 0.21.0
+        e:
+            w6ksdvd23g5609btg3agj7flfwr4evlf:
+                args:
+                    - --config
+                    - ICLR/config/bb6/bb6_v2.yaml
+                    - --gpu_id
+                    - "2"
+                codePath: main_cheetah.py
+                codePathLocal: main_cheetah.py
+                cpu_count: 128
+                cpu_count_logical: 255
+                cudaVersion: "12.6"
+                disk:
+                    /:
+                        total: "6598647398400"
+                        used: "2392582606848"
+                email: sangliteng@gmail.com
+                executable: /home/sangliteng/miniconda3/envs/learning-hybrid-systems/bin/python3
+                git:
+                    commit: e65e9632c7a9d9bc1847e0a5a83e8e29db0ac56e
+                    remote: git@github.com:SangliTeng/Leaning-Hybrid-Systems.git
+                gpu: NVIDIA RTX 6000 Ada Generation
+                gpu_count: 8
+                gpu_nvidia:
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-45d30378-435b-de16-3aea-9fc48527fe61
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-19a03a90-a9e0-a194-8d43-c2dcb7925140
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-ea5b1c7d-baf5-6bcb-1ce1-0ee9ca4b5c8f
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-b1a2e98c-e563-a0fe-47ce-cfa29028d5c7
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-208eeaba-0174-d4e0-bc7a-2eb5f7983a6e
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-81a0e787-8873-418d-6ff3-e3f59deb75a0
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-8619099e-16b4-d667-b97f-518c3954df8c
+                    - architecture: Ada
+                      cudaCores: 18176
+                      memoryTotal: "51527024640"
+                      name: NVIDIA RTX 6000 Ada Generation
+                      uuid: GPU-8042fac2-fd28-c8e9-668b-ceb33605fb49
+                host: hr-6000ada
+                memory:
+                    total: "811164614656"
+                os: Linux-5.15.0-143-generic-x86_64-with-glibc2.35
+                program: /home/sangliteng/Research/Leaning-Hybrid-Systems/main_cheetah.py
+                python: CPython 3.12.11
+                root: ./ICLR/bb6
+                startedAt: "2025-09-20T07:55:05.803083Z"
+                writerId: w6ksdvd23g5609btg3agj7flfwr4evlf
+        m: []
+        python_version: 3.12.11
+        t:
+            "1":
+                - 1
+            "2":
+                - 1
+            "3":
+                - 2
+                - 13
+                - 15
+                - 16
+            "4": 3.12.11
+            "5": 0.21.0
+            "12": 0.21.0
+            "13": linux-x86_64
+anti_collapse_weight:
+    value: 1000
+batch_size:
+    value: 4096
+data_path_test:
+    value: None
+data_path_train:
+    value: /home/sangliteng/Research/DynaTraj/dataset/bb/bb_shift_down_sample.npz
+decoder_batch_size:
+    value: 131072
+decoder_finetune_steps:
+    value: 200000
+decoder_lr:
+    value: 0.01
+default_activation:
+    value: ReLU
+dim_linear_in_decoder:
+    value:
+        - 0
+        - 0
+dim_linear_in_encoder:
+    value:
+        - 0
+        - 0
+dim_linear_in_vec_field:
+    value:
+        - 0
+        - 0
+dim_linear_out_decoder:
+    value: 0
+dim_linear_out_encoder:
+    value: 0
+dim_linear_out_vec_field:
+    value: 0
+dynamics_init_scale:
+    value: 0.005
+dynamics_loss_type:
+    value: l2
+dynamics_weight:
+    value: 10
+encoder_lr:
+    value: 0.01
+eval_batch_size:
+    value: 64
+eval_every:
+    value: 2.5e+22
+eval_trajectory_length:
+    value: 500
+except_features:
+    value: []
+external_input_dim:
+    value: 6
+hidden_dim_linear_decoder:
+    value: []
+hidden_dim_linear_encoder:
+    value: []
+hidden_dim_linear_vec_field:
+    value: []
+hidden_dims_dec:
+    value:
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+        - 128
+hidden_dims_enc:
+    value:
+        - 64
+        - 64
+        - 64
+hidden_dims_vector_field:
+    value:
+        - 128
+        - 128
+input_dim:
+    value: 18
+is_lagrangian_system:
+    value: true
+isometry_loss_weight:
+    value: 1
+latent_dim:
+    value: 30
+learning_rate:
+    value: 0.0005
+log_interval:
+    value: 50
+loss_mode:
+    value: z
+max_iso_samples:
+    value: 16384
+min_covariance_threshold:
+    value: 0.09
+model_type:
+    value: hybrid
+normalize_data:
+    value: false
+ode_method:
+    value: rk4
+project_name:
+    value: debug architecture
+reconstruction_loss_type:
+    value: l2
+run_name:
+    value: bb with paddle
+save_checkpoint_every:
+    value: 250
+smooth_budget:
+    value: 0.0001
+smooth_weight:
+    value: 0
+steps_per_length:
+    value: 2000
+switching_threshold_scale:
+    value: 1.5
+switching_weight_multiplier:
+    value: 2
+test_info:
+    value: same profile as bb, much larger network
+time_step:
+    value: 0.01
+train_test_ratio:
+    value: 0.95
+trajectory_lengths:
+    value:
+        - 80
+        - 150
+        - 200
+        - 200
+        - 200
+use_switching_weights:
+    value: true
+use_weight_smoothing:
+    value: false
+vector_field_lr:
+    value: 0.01
+viz_interval:
+    value: 50
+wandb_base_dir:
+    value: ./ICLR/bb6
+weight_smoothing_window:
+    value: 0
+z_continuity_weight:
+    value: 10

models/__init__.py

@@ -0,0 +1,29 @@
+"""
+Models Package for Neural Hybrid Systems
+
+This package contains all neural network architectures and model utilities.
+"""
+
+from .factory import create_model
+from .utils import interpolate_trajectory, interpolate_external_input, create_vector_field_with_external_input
+from .architectures import HybridLatentODEModel, VanillaODEModel, EventODEModel
+from .base import BaseModel
+from .components import MLPWithCustomInit
+from .components.initialization import (
+    init_dynamics_network, init_autoencoder_network,
+    init_event_network, init_reset_network
+)
+
+# Backward compatibility imports
+from .factory import create_hybrid_models, create_neural_ode_models, create_event_ode_models
+
+__all__ = [
+    'create_model', 'interpolate_trajectory', 
+    'interpolate_external_input', 'create_vector_field_with_external_input',
+    'HybridLatentODEModel', 'VanillaODEModel', 'EventODEModel',
+    'BaseModel', 'MLPWithCustomInit',
+    'init_dynamics_network', 'init_autoencoder_network',
+    'init_event_network', 'init_reset_network',
+    # Backward compatibility
+    'create_hybrid_models', 'create_neural_ode_models', 'create_event_ode_models',
+]

models/architectures/__init__.py

@@ -0,0 +1,17 @@
+"""
+Model Architectures Package
+"""
+
+from .hybrid import HybridLatentODEModel
+from .vanilla_ode import VanillaODEModel
+from .event_ode import EventODEModel
+from .augmented_ode import AugmentedODEModel
+from .autoregressive import AutoregressiveModel
+
+__all__ = [
+    'HybridLatentODEModel',
+    'VanillaODEModel', 
+    'EventODEModel',
+    'AugmentedODEModel',
+    'AutoregressiveModel',
+]

models/architectures/augmented_ode.py

@@ -0,0 +1,199 @@
+"""
+Augmented Neural ODE Model Architecture
+
+Augmented ODE extends vanilla ODE by appending encoded features to the state space.
+The vector field operates on [x; aug(x); u] where aug(x) = encoder(x) and u is external input.
+Only the original x dimensions are used for reconstruction loss.
+"""
+
+import torch
+import torch.optim as optim
+import itertools
+import torchdiffeq
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_autoencoder_network, init_dynamics_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+
+class AugmentedODEModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_enc = config.get('hidden_dims_enc', [32, 64])
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        
+        # 默认 aug_dim = input_dim，即增强维度与原始状态维度相同
+        aug_dim = config.get('aug_dim', input_dim)  # 这里是关键！
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        
+        # Total dimension for vector field: original x + augmented features + external input
+        total_dim = input_dim + aug_dim + external_input_dim
+        vector_field_output_dim = input_dim + aug_dim  # Only predict derivatives for state + augmented
+        
+        # Get activation functions
+        encoder_activations = config.get('encoder_activations', None)
+        vector_field_activations = config.get('vector_field_activations', None)
+        default_activation = getattr(torch.nn, config.get('default_activation', 'ReLU'))
+        
+        # Create encoder for augmentation: x -> aug(x)
+        self.encoder = MLPWithCustomInit(
+            input_dim, hidden_dims_enc, aug_dim,
+            activation=default_activation,
+            activation_per_layer=encoder_activations
+        ).to(device)
+        
+        # Create vector field for augmented space: [x; aug(x); u] -> d/dt[x; aug(x)]
+        self.vector_field = MLPWithCustomInit(
+            total_dim, hidden_dims_vector_field, vector_field_output_dim,
+            activation=default_activation,
+            activation_per_layer=vector_field_activations
+        ).to(device)
+        
+        # Initialize networks
+        init_autoencoder_network(self.encoder)
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        
+        # Create optimizers with different learning rates
+        self.optimizers = {
+            'encoder': optim.Adam(self.encoder.parameters(), 
+                                lr=config.get('encoder_lr', config['learning_rate'])),
+            'vector_field': optim.Adam(self.vector_field.parameters(), 
+                                     lr=config.get('vector_field_lr', config['learning_rate']))
+        }
+        
+        # Print architecture information
+        self.encoder.print_architecture("Augmentation Encoder")
+        self.vector_field.print_architecture("Augmented Vector Field")
+        
+        # Store augmentation dimension in config
+        config['aug_dim'] = aug_dim
+        config['total_dim'] = input_dim + aug_dim  # State space dimension
+        config['vector_field_input_dim'] = total_dim  # Including external input
+        
+        print(f"Augmented ODE Configuration:")
+        print(f"  Original dimension: {input_dim}")
+        print(f"  Augmentation dimension: {aug_dim}")
+        print(f"  External input dimension: {external_input_dim}")
+        print(f"  Total state dimension: {input_dim + aug_dim}")
+        print(f"  Vector field input dimension: {total_dim}")
+        
+        total_params = sum(p.numel() for p in itertools.chain(
+            self.encoder.parameters(), self.vector_field.parameters()))
+        print(f"Total parameters: {total_params}")
+
+    def _augment_state(self, x):
+        """
+        Augment state x with encoded features.
+        
+        Args:
+            x: State tensor [B, input_dim] or [T, B, input_dim]
+            
+        Returns:
+            x_aug: Augmented state [B, total_dim] or [T, B, total_dim]
+        """
+        original_shape = x.shape
+        
+        # Flatten to [N, input_dim] for encoder
+        if len(original_shape) == 3:  # [T, B, input_dim]
+            T, B, D = original_shape
+            x_flat = x.reshape(T * B, D)
+        else:  # [B, input_dim]
+            x_flat = x
+        
+        # Encode to get augmentation features
+        aug_features = self.encoder([], x_flat)  # [N, aug_dim]
+        
+        # Concatenate original state with augmented features
+        x_aug_flat = torch.cat([x_flat, aug_features], dim=1)  # [N, total_dim]
+        
+        # Reshape back to original structure
+        if len(original_shape) == 3:
+            x_aug = x_aug_flat.reshape(T, B, self.config['total_dim'])
+        else:
+            x_aug = x_aug_flat
+            
+        return x_aug
+
+    def _extract_original_state(self, x_aug):
+        """
+        Extract original state from augmented state.
+        
+        Args:
+            x_aug: Augmented state [..., total_dim]
+            
+        Returns:
+            x: Original state [..., input_dim]
+        """
+        return x_aug[..., :self.config['input_dim']]
+
+    def inference(self, xt_batch, ut_batch=None):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+        
+        # Get initial state and augment it
+        x0 = x_batch[:, 0, :]  # [B, input_dim]
+        x0_aug = self._augment_state(x0)  # [B, total_dim]
+        
+        # Setup time
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=L, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:
+            # u_interp = interpolate_external_input(t_eval, t_batch_relative, ut_batch, self.external_input_dim)
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                            t_eval,                                  # [T]
+                            t_batch_u,                               # [B, L_u] (already relative)
+                            ut_batch[:, :, :-1].permute(1, 0, 2)     # traj: [L_u, B, U]
+                            ).permute(1, 0, 2)                           # -> [T, B, U]
+        
+        # Create enhanced vector field - need special handling for augmented state
+        def augmented_vector_field_with_input(t, x_aug):
+            if u_interp is None:
+                return self.vector_field(t, x_aug)
+            
+            # Find time index
+            t_idx = torch.searchsorted(t_eval, t, right=False)
+            t_idx = torch.clamp(t_idx, 0, len(t_eval) - 1)
+            
+            # Get interpolated external input at time t
+            u_t = u_interp[t_idx, :, :]  # [B, U]
+            
+            # Concatenate augmented state with external input
+            x_aug_u = torch.cat([x_aug, u_t], dim=-1)  # [B, total_dim + external_input_dim]
+            
+            return self.vector_field(t, x_aug_u)
+        
+        vector_field_func = augmented_vector_field_with_input
+        
+        # Solve ODE in augmented space
+        x_aug_trajectory = torchdiffeq.odeint(
+            vector_field_func, x0_aug, t_eval, 
+            method=self.config.get('ode_method', 'rk4')
+        )  # [T, B, total_dim]
+        
+        # Extract original state trajectory
+        x_trajectory = self._extract_original_state(x_aug_trajectory)  # [T, B, input_dim]
+        
+        return {
+            'x0': x0,
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'x_trajectory': x_trajectory,
+            'x_aug_trajectory': x_aug_trajectory,  # For debugging/analysis
+            'u_interp': u_interp,
+        }

models/architectures/autoregressive.py

@@ -0,0 +1,306 @@
+"""
+Autoregressive Model Architecture
+
+Autoregressive model for sequential prediction: x_{k+1} = AG(x_k, Δt, u_k)
+Supports MLP, RNN, and LSTM architectures for the AG (AutoreGressive) function.
+"""
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import itertools
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_dynamics_network
+from ..utils import interpolate_trajectory
+
+
+class AutoregressiveModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims = config.get('hidden_dims_autoregressive', [64, 64])
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        
+        # Architecture type: 'mlp', 'rnn', 'lstm'
+        arch_type = config.get('autoregressive_architecture', 'mlp').lower()
+        
+        # Get activation functions
+        default_activation = getattr(nn, config.get('default_activation', 'ReLU'))
+        activations = config.get('autoregressive_activations', None)
+        
+        # Input to AG function: [x_k, Δt, u_k] -> concatenated input
+        ag_input_dim = input_dim + 1 + external_input_dim  # x_k + Δt + u_k
+        ag_output_dim = input_dim     # x_{k+1}
+        
+        if arch_type == 'mlp':
+            self.ag_function = MLPWithCustomInit(
+                ag_input_dim, hidden_dims, ag_output_dim,
+                activation=default_activation,
+                activation_per_layer=activations
+            ).to(device)
+            
+        elif arch_type == 'rnn':
+            # RNN-based AG function
+            self.hidden_dim = hidden_dims[0] if hidden_dims else 64
+            self.num_layers = config.get('rnn_num_layers', 2)
+            self.rnn = nn.RNN(
+                input_size=ag_input_dim,
+                hidden_size=self.hidden_dim,
+                num_layers=self.num_layers,
+                batch_first=True,
+                dropout=config.get('rnn_dropout', 0.0) if self.num_layers > 1 else 0.0
+            ).to(device)
+            self.output_layer = nn.Linear(self.hidden_dim, ag_output_dim).to(device)
+            
+            # Combine RNN and output layer into a single module for consistency
+            self.ag_function = nn.Sequential(
+                nn.Identity()  # Placeholder - actual RNN computation done in forward
+            )
+            
+        elif arch_type == 'lstm':
+            # LSTM-based AG function
+            self.hidden_dim = hidden_dims[0] if hidden_dims else 64
+            self.num_layers = config.get('lstm_num_layers', 2)
+            self.lstm = nn.LSTM(
+                input_size=ag_input_dim,
+                hidden_size=self.hidden_dim,
+                num_layers=self.num_layers,
+                batch_first=True,
+                dropout=config.get('lstm_dropout', 0.0) if self.num_layers > 1 else 0.0
+            ).to(device)
+            self.output_layer = nn.Linear(self.hidden_dim, ag_output_dim).to(device)
+            
+            # Combine LSTM and output layer into a single module for consistency
+            self.ag_function = nn.Sequential(
+                nn.Identity()  # Placeholder - actual LSTM computation done in forward
+            )
+        
+        else:
+            raise ValueError(f"Unknown architecture type: {arch_type}. Choose from 'mlp', 'rnn', 'lstm'")
+        
+        self.arch_type = arch_type
+        
+        # Initialize networks
+        if arch_type == 'mlp':
+            init_dynamics_network(self.ag_function, scale=config['dynamics_init_scale'])
+        else:  # RNN/LSTM
+            init_dynamics_network(self.output_layer, scale=config['dynamics_init_scale'])
+            # Initialize RNN/LSTM with Xavier initialization
+            for name, param in (self.rnn if arch_type == 'rnn' else self.lstm).named_parameters():
+                if 'weight' in name:
+                    nn.init.xavier_uniform_(param)
+                elif 'bias' in name:
+                    nn.init.zeros_(param)
+        
+        # Create optimizer
+        if arch_type == 'mlp':
+            params = self.ag_function.parameters()
+        else:  # RNN/LSTM
+            rnn_module = self.rnn if arch_type == 'rnn' else self.lstm
+            params = itertools.chain(rnn_module.parameters(), self.output_layer.parameters())
+        
+        self.optimizers = {
+            'ag_function': optim.Adam(params, lr=config['learning_rate'])
+        }
+        
+        # Print architecture information
+        self._print_architecture_info(config)
+        
+        # Store configuration
+        config['autoregressive_architecture'] = arch_type
+        config['ag_input_dim'] = ag_input_dim
+        config['ag_output_dim'] = ag_output_dim
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+            config['external_input_dim'] = external_input_dim
+        
+        if arch_type != 'mlp':
+            config['hidden_dim'] = self.hidden_dim
+            config['num_layers'] = self.num_layers
+        
+        # COMPLETELY REMOVE NORMALIZATION - set to False by default
+        self.normalize_dt = False
+        self.residual = True  # residual form enforced
+    
+    def _print_architecture_info(self, config):
+        """Print architecture information"""
+        if self.arch_type == 'mlp':
+            self.ag_function.print_architecture("Autoregressive MLP")
+        else:
+            print(f"\nAutoregressive {self.arch_type.upper()} Architecture:")
+            print(f"  Architecture type: {self.arch_type.upper()}")
+            print(f"  Input dimension: {config['input_dim'] + 1 + config.get('external_input_dim', 0)} (x + Δt + u)")
+            print(f"  Hidden dimension: {self.hidden_dim}")
+            print(f"  Number of layers: {self.num_layers}")
+            print(f"  Output dimension: {config['input_dim']}")
+            
+            # Count parameters
+            if self.arch_type == 'rnn':
+                rnn_params = sum(p.numel() for p in self.rnn.parameters())
+                output_params = sum(p.numel() for p in self.output_layer.parameters())
+            else:  # lstm
+                rnn_params = sum(p.numel() for p in self.lstm.parameters())
+                output_params = sum(p.numel() for p in self.output_layer.parameters())
+            
+            total_params = rnn_params + output_params
+            print(f"  Total parameters: {total_params}")
+            print(f"    {self.arch_type.upper()}: {rnn_params}")
+            print(f"    Output layer: {output_params}")
+    
+    def _interpolate_external_input(self, t_relative, ut_batch):
+        """Interpolate external input at relative times using utility function"""
+        if ut_batch is None or self.external_input_dim == 0:
+            return None
+        
+        # Use utility function - just need to reshape inputs properly
+        u_batch = ut_batch[:, :, :self.external_input_dim]  # [B, L_u, U]
+        t_u_batch = ut_batch[:, :, self.external_input_dim]  # [B, L_u]
+        
+        # Create source trajectory [L_u, B, U] for interpolate_trajectory
+        u_traj = u_batch.transpose(0, 1)  # [L_u, B, U]
+        
+        # Use first batch's time as reference (assume all batches have same relative timing)
+        u_interp = interpolate_trajectory(t_u_batch[0, :], t_relative, u_traj)
+        
+        return u_interp.transpose(0, 1)  # [B, L, U]
+    
+    def _forward_step(self, x_k, dt, u_k=None, hidden_state=None):
+        """
+        Single forward step: x_{k+1} = AG(x_k, Δt, u_k)
+        
+        Args:
+            x_k: Current state [B, input_dim]
+            dt: Time step [B, 1]
+            u_k: External input [B, external_input_dim] (optional)
+            hidden_state: Hidden state for RNN/LSTM (optional)
+            
+        Returns:
+            x_k_plus_1: Next state [B, input_dim]
+            new_hidden_state: Updated hidden state (for RNN/LSTM)
+        """
+        # Concatenate x_k, dt, and u_k
+        inputs = [x_k, dt]
+        if u_k is not None:
+            inputs.append(u_k)
+        ag_input = torch.cat(inputs, dim=1)  # [B, input_dim + 1 + external_input_dim]
+        
+        if self.arch_type == 'mlp':
+            # MLP forward pass - CRITICAL FIX: Use proper forward call with two arguments
+            dx = self.ag_function(None, ag_input)  # Use (t, x) interface where t is ignored
+            x_k_plus_1 = x_k + dx           # residual form
+            return x_k_plus_1, None
+            
+        elif self.arch_type == 'rnn':
+            # RNN forward pass
+            ag_input_seq = ag_input.unsqueeze(1)  # [B, 1, input_dim + 1 + external_input_dim]
+            rnn_output, new_hidden_state = self.rnn(ag_input_seq, hidden_state)
+            dx = self.output_layer(rnn_output.squeeze(1))
+            x_k_plus_1 = x_k + dx
+            return x_k_plus_1, new_hidden_state
+            
+        elif self.arch_type == 'lstm':
+            # LSTM forward pass
+            ag_input_seq = ag_input.unsqueeze(1)  # [B, 1, input_dim + 1 + external_input_dim]
+            lstm_output, new_hidden_state = self.lstm(ag_input_seq, hidden_state)
+            dx = self.output_layer(lstm_output.squeeze(1))
+            x_k_plus_1 = x_k + dx
+            return x_k_plus_1, new_hidden_state
+
+    def _rollout_trajectory(self, x0, t_relative, u_interp=None):
+        """
+        Rollout using real (possibly non-uniform) time steps with external input.
+        t_relative: [B, L] relative times (first = 0)
+        u_interp: [B, L, U] interpolated external inputs (optional)
+        """
+        B, L = t_relative.shape
+        device = x0.device
+        x_traj = torch.zeros(L, B, self.config['input_dim'], device=device)
+        x_traj[0] = x0
+        
+        # prepare dt sequence - NO NORMALIZATION AT ALL
+        dt_seq = t_relative[:, 1:] - t_relative[:, :-1]  # [B, L-1]
+        # Use raw dt values directly without any normalization
+        dt_norm = dt_seq
+        
+        # hidden state
+        hidden_state = None
+        if self.arch_type == 'rnn':
+            hidden_state = torch.zeros(self.num_layers, B, self.hidden_dim, device=device)
+        elif self.arch_type == 'lstm':
+            h0 = torch.zeros(self.num_layers, B, self.hidden_dim, device=device)
+            c0 = torch.zeros(self.num_layers, B, self.hidden_dim, device=device)
+            hidden_state = (h0, c0)
+        
+        x_current = x0
+        for k in range(L - 1):
+            dt_k = dt_norm[:, k].unsqueeze(1)  # [B,1] - raw dt values
+            u_k = u_interp[:, k, :] if u_interp is not None else None  # [B, U]
+            x_next, hidden_state = self._forward_step(x_current, dt_k, u_k, hidden_state)
+            x_traj[k + 1] = x_next
+            x_current = x_next
+        return x_traj
+
+    def inference(self, xt_batch, ut_batch=None):
+        """
+        xt_batch: [B, L, D+1] (last dim is absolute time)
+        ut_batch: [B, L_u, U+1] (last dim is absolute time, optional)
+        Returns discrete trajectory at original time stamps (no interpolation).
+        """
+        state_dim = self.config['input_dim']
+        x_batch = xt_batch[:, :, :state_dim]          # not used directly (closed-loop rollout)
+        t_batch = xt_batch[:, :, state_dim]           # absolute times
+        B, L, _ = x_batch.shape
+        t_rel = t_batch - t_batch[:, 0:1]
+        x0 = x_batch[:, 0, :]
+        
+        # Handle external input
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:
+            # u_interp = self._interpolate_external_input(t_rel, ut_batch)
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_rel.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                            t_rel,                                  # [T]
+                            t_batch_u,                               # [B, L_u] (already relative)
+                            ut_batch[:, :, :-1].permute(1, 0, 2)     # traj: [L_u, B, U]
+                            ).permute(1, 0, 2)                           # -> [T, B, U]
+        
+        x_traj = self._rollout_trajectory(x0, t_rel, u_interp)  # [L,B,D]
+        
+        return {
+            'x0': x0,
+            't_batch': t_batch,
+            't_batch_relative': t_rel,
+            't_eval': t_rel[0],  # keep interface (first trajectory's relative times)
+            'x_trajectory': x_traj,
+            'u_interp': u_interp,
+        }
+
+    def get_layer_info(self):
+        """
+        Unified architecture_info interface for main_v2.
+        """
+        info = {
+            'model_type': 'autoregressive',
+            'architecture_type': self.arch_type,
+            'residual': self.residual,
+        }
+        if self.arch_type == 'mlp':
+            mlp_info = self.ag_function.get_layer_info()
+            mlp_info['role'] = 'increment_predictor'
+            info['ag_function'] = mlp_info
+        else:
+            info['recurrent'] = {
+                'hidden_dim': self.hidden_dim,
+                'num_layers': self.num_layers,
+                'increment_head_params': sum(p.numel() for p in self.output_layer.parameters()),
+                'total_parameters': sum(p.numel() for p in self.parameters())
+            }
+        return info

models/architectures/event_ode.bak

@@ -0,0 +1,226 @@
+"""
+Event-based Neural ODE Model Architecture
+"""
+
+import torch
+import torch.optim as optim
+import itertools
+import torchdiffeq
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_dynamics_network, init_event_network, init_reset_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+
+class EventODEModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        hidden_dims_event = config.get('hidden_dims_event', [32, 16])
+        hidden_dims_reset = config.get('hidden_dims_reset', [32, 16])
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        vector_field_input_dim = input_dim + external_input_dim
+        event_input_dim = input_dim + external_input_dim
+        reset_input_dim = input_dim + external_input_dim
+        
+        # Get activation functions
+        default_activation = getattr(torch.nn, config.get('default_activation', 'ReLU'))
+        
+        # Create vector field, event function, and state reset networks
+        self.vector_field = MLPWithCustomInit(
+            vector_field_input_dim, hidden_dims_vector_field, input_dim,
+            activation=default_activation
+        ).to(device)
+        
+        self.event_function = MLPWithCustomInit(
+            event_input_dim, hidden_dims_event, 1,
+            activation=default_activation
+        ).to(device)
+        
+        self.state_reset = MLPWithCustomInit(
+            reset_input_dim, hidden_dims_reset, input_dim,
+            activation=default_activation
+        ).to(device)
+        
+        # Initialize networks with specialized functions
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        init_event_network(self.event_function, scale=config.get('event_init_scale', 0.1))
+        init_reset_network(self.state_reset, scale=config.get('reset_init_scale', 0.05))
+        
+        # Create optimizers with potentially different learning rates
+        self.optimizers = {
+            'vector_field': optim.Adam(self.vector_field.parameters(), 
+                                     lr=config.get('vector_field_lr', config['learning_rate'])),
+            'event_function': optim.Adam(self.event_function.parameters(), 
+                                       lr=config.get('event_lr', config['learning_rate'])),
+            'state_reset': optim.Adam(self.state_reset.parameters(), 
+                                    lr=config.get('reset_lr', config['learning_rate']))
+        }
+        
+        # Print architecture information
+        self.vector_field.print_architecture("Vector Field")
+        self.event_function.print_architecture("Event Function")
+        self.state_reset.print_architecture("State Reset")
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+            print(f"Vector field input dimension: {vector_field_input_dim} (state + external)")
+        
+        # Print initialization information
+        print(f"Initialization scales:")
+        print(f"  Vector field: {config['dynamics_init_scale']}")
+        print(f"  Event function: {config.get('event_init_scale', 0.1)} (large to prevent runaway boundaries)")
+        print(f"  State reset: {config.get('reset_init_scale', 0.05)}")
+        
+        total_params = sum(p.numel() for p in itertools.chain(
+            self.vector_field.parameters(), self.event_function.parameters(), self.state_reset.parameters()))
+        print(f"Total parameters: {total_params}")
+
+    def _create_vector_field_with_input(self, u_interp, t_eval):
+        """Create a vector field function that includes interpolated external input"""
+        def vector_field_func(t, x):
+            if u_interp is None:
+                return self.vector_field(t, x)
+            
+            # Find the time index for interpolation
+            t_idx = torch.searchsorted(t_eval, t, right=False)
+            t_idx = torch.clamp(t_idx, 0, len(t_eval) - 1)
+            
+            # Get interpolated u at time t
+            u_t = u_interp[t_idx, :, :]  # [B, U]
+            
+            return self.vector_field(t, x, u_t)
+        
+        return vector_field_func
+
+    def _event_ode_with_reset(self, x0, t_span, u_interp=None, event_threshold=0.0):
+        """
+        Solve ODE with event detection and state reset including external input
+        
+        Args:
+            x0: Initial condition [B, D]
+            t_span: Time span [T]
+            u_interp: Interpolated external input [T, B, U] (optional)
+            event_threshold: Threshold for event detection (default: 0.0)
+            
+        Returns:
+            x_trajectory: [T, B, D] trajectory with resets
+            event_times: List of event times
+            event_states: List of states at event times
+        """
+        B, D = x0.shape
+        T = len(t_span)
+        device = x0.device
+        
+        # Initialize trajectory storage
+        x_trajectory = torch.zeros(T, B, D, device=device)
+        x_trajectory[0] = x0
+        
+        # Event tracking
+        event_times = []
+        event_states = []
+        
+        # Current state
+        x_current = x0.clone()
+        
+        # Create vector field with external input
+        vector_field_func = self._create_vector_field_with_input(u_interp, t_span)
+        
+        # Solve ODE step by step with event detection
+        for i in range(1, T):
+            dt = t_span[i] - t_span[i-1]
+            t_current = t_span[i-1:i+1]
+            
+            # Solve ODE for this time step
+            x_step = torchdiffeq.odeint(
+                vector_field_func, x_current, t_current, 
+                method=self.config.get('ode_method', 'rk4')
+            )  # [2, B, D]
+            
+            x_next = x_step[-1]  # [B, D]
+            
+            # Check for events
+            with torch.no_grad():
+                # Get external input for event function if available
+                if u_interp is not None:
+                    u_current = u_interp[i, :, :]  # [B, U]
+                    event_input = torch.cat([x_next, u_current], dim=-1)
+                    event_values = self.event_function([], event_input).squeeze(-1)  # [B]
+                else:
+                    event_values = self.event_function([], x_next).squeeze(-1)  # [B]
+                
+                event_mask = (event_values > event_threshold)  # [B]
+                
+                if event_mask.any():
+                    # Apply state reset for trajectories that triggered events
+                    if u_interp is not None:
+                        reset_input = torch.cat([x_next, u_current], dim=-1)
+                        x_reset = self.state_reset([], reset_input)  # [B, D]
+                    else:
+                        x_reset = self.state_reset([], x_next)  # [B, D]
+                    
+                    x_next = torch.where(event_mask.unsqueeze(-1), x_reset, x_next)
+                    
+                    # Record event information
+                    event_times.append(t_span[i].item())
+                    event_states.append(x_next[event_mask].clone())
+            
+            x_trajectory[i] = x_next
+            x_current = x_next
+        
+        return x_trajectory, event_times, event_states
+
+    def inference(self, xt_batch, ut_batch=None):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+        
+        x0 = x_batch[:, 0, :]
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        
+        # Create time evaluation grid
+        time_step = self.config.get('time_step', 0.1)
+        n_steps = max(L, int(torch.ceil(max_time / time_step).item()) + 1)
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=n_steps, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:
+            # u_interp = interpolate_external_input(t_eval, t_batch_relative, ut_batch, self.external_input_dim)
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                            t_eval,                                  # [T]
+                            t_batch_u,                               # [B, L_u] (already relative)
+                            ut_batch[:, :, :-1].permute(1, 0, 2)     # traj: [L_u, B, U]
+                            ).permute(1, 0, 2)                           # -> [T, B, U]
+        
+        # Create enhanced vector field
+        vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_eval)
+        
+        # Solve Event ODE with event detection
+        event_threshold = self.config.get('event_threshold', 0.0)
+        x_trajectory, event_times, event_states = self._event_ode_with_reset(
+            x0, t_eval, u_interp, event_threshold
+        )
+        
+        return {
+            'x0': x0,
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'x_trajectory': x_trajectory,
+            'event_times': event_times,
+            'event_states': event_states,
+            'num_events': len(event_times),
+            'u_interp': u_interp,
+        }

models/architectures/event_ode.py

@@ -0,0 +1,266 @@
+"""
+Event-based Neural ODE Model Architecture
+"""
+
+import torch
+import torch.optim as optim
+import itertools
+import torchdiffeq
+import torch.nn as nn
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_dynamics_network, init_event_network, init_reset_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+
+class EventODEModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        hidden_dims_event = config.get('hidden_dims_event', [32, 16])
+        hidden_dims_reset = config.get('hidden_dims_reset', [32, 16])
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        vector_field_input_dim = input_dim + external_input_dim
+        event_input_dim = input_dim + external_input_dim
+        reset_input_dim = input_dim + external_input_dim
+        
+        # Get activation functions
+        default_activation = getattr(torch.nn, config.get('default_activation', 'ReLU'))
+        
+        # Create vector field, event function, and state reset networks
+        self.vector_field = MLPWithCustomInit(
+            vector_field_input_dim, hidden_dims_vector_field, input_dim,
+            activation=default_activation
+        ).to(device)
+        
+        self.event_function = MLPWithCustomInit(
+            event_input_dim, hidden_dims_event, 1,
+            activation=default_activation
+        ).to(device)
+        
+        self.state_reset = MLPWithCustomInit(
+            reset_input_dim, hidden_dims_reset, input_dim,
+            activation=default_activation
+        ).to(device)
+        
+        # Initialize networks with specialized functions
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        init_event_network(self.event_function, scale=config.get('event_init_scale', 0.1 * 100))
+        init_reset_network(self.state_reset, scale=config.get('reset_init_scale', 0.05 * 100))
+        
+        # Create optimizers with potentially different learning rates
+        self.optimizers = {
+            'vector_field': optim.Adam(self.vector_field.parameters(), 
+                                     lr=config.get('vector_field_lr', config['learning_rate'])),
+            'event_function': optim.Adam(self.event_function.parameters(), 
+                                       lr=config.get('event_lr', config['learning_rate'])),
+            'state_reset': optim.Adam(self.state_reset.parameters(), 
+                                    lr=config.get('reset_lr', config['learning_rate']))
+        }
+        
+        # Print architecture information
+        self.vector_field.print_architecture("Vector Field")
+        self.event_function.print_architecture("Event Function")
+        self.state_reset.print_architecture("State Reset")
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+            print(f"Vector field input dimension: {vector_field_input_dim} (state + external)")
+        
+        # Print initialization information
+        print(f"Initialization scales:")
+        print(f"  Vector field: {config['dynamics_init_scale']}")
+        print(f"  Event function: {config.get('event_init_scale', 0.1)} (large to prevent runaway boundaries)")
+        print(f"  State reset: {config.get('reset_init_scale', 0.05)}")
+        
+        total_params = sum(p.numel() for p in itertools.chain(
+            self.vector_field.parameters(), self.event_function.parameters(), self.state_reset.parameters()))
+        print(f"Total parameters: {total_params}")
+
+    def _event_ode_with_reset(self, x0, t_span, u_interp=None, event_threshold=0.0):
+        """
+        Solve ODE with event detection and state reset using odeint_event for event times,
+        then densely integrate along the provided t_span grid between events until t_span[-1].
+        Returns x_trajectory aligned to t_span, and lists of event times/states.
+        """
+
+        # #####
+        # print(f"Terminaltion time = {t_span[-1]}")
+        # ####
+        B, D = x0.shape
+        T = len(t_span)
+        device = x0.device
+        
+        # Vector field with external input (signature: f(t, state) -> dx/dt)
+        vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_span)
+        
+        # Event function for odeint_event: batch-min with threshold (zero crossing)
+        def event_fn(t, state):
+            # print(f"Event function called at t={t}")
+            if u_interp is not None:
+                idx = torch.searchsorted(t_span, t, right=False)
+                idx = torch.clamp(idx, 0, T - 1)
+                u_t = u_interp[idx, :, :]
+                vals = self.event_function([], torch.cat([state, u_t], dim=-1)).squeeze(-1)  # [B]
+            else:
+                vals = self.event_function([], state).squeeze(-1)  # [B]
+            
+            vals = (vals - event_threshold).min()
+            # print(f"Event function values at t={t}: {vals.item():6f}")
+            return vals
+        
+        # Storage (raw dense samples); start with initial point
+        time_samples = [t_span[0].reshape(-1)]              # list of [k]
+        state_samples = [x0.unsqueeze(0)]                   # list of [k,B,D]
+        event_times = []
+        event_states = []
+        
+        # Integration settings
+        atol = self.config.get('ode_atol', 1e-6)
+        rtol = self.config.get('ode_rtol', 1e-6)
+        method = self.config.get('ode_method', 'rk4')
+        
+        # Current state/time
+        current_time = t_span[0]
+        current_state = x0
+        
+        # Main loop until end of t_span
+        safety_steps = 0
+        while float(current_time) < float(t_span[-1]) - 1e-12:
+            safety_steps += 1
+            if safety_steps > 100000:
+                print("[WARN] Max safety steps reached in _event_ode_with_reset; breaking.")
+                break
+            
+            # 1) Detect next event time from current_time
+            try:
+                options = {'max_num_steps': 100}
+                event_t, _ = torchdiffeq.odeint_event(
+                    vector_field_func,
+                    current_state,
+                    current_time,
+                    # t_span,
+                    event_fn=event_fn,
+                    reverse_time=False,
+                    atol=atol,
+                    rtol=rtol,
+                    odeint_interface=torchdiffeq.odeint_adjoint,
+                    options = options,
+                    # t_span = t_span,
+                )
+                print(f"Detected event at t={event_t}, safety_steps={safety_steps}")
+            except Exception:
+                # Fallback: no event detectable; go to the end
+                event_t = t_span[-1]
+                # print(f"No event at triggered! Fuck!")
+            
+            # Clamp event time to final span
+            # print(f"t_span[-1] = {t_span[-1].item():6f}")
+            if float(event_t) > float(t_span[-1]):
+                event_t = t_span[-1]
+                # print("No fucking event")
+            
+            # 2) Dense integration on t_span between (current_time, event_t]
+            mask = (t_span > current_time) & (t_span <= event_t)
+            if mask.any():
+                tt = torch.cat([current_time.reshape(-1), t_span[mask]], dim=0)
+                x_seg = torchdiffeq.odeint_adjoint(
+                    vector_field_func, current_state, tt, method=method, atol=atol, rtol=rtol
+                )  # [K, B, D]
+                # Append excluding first point to avoid duplication
+                time_samples.append(tt[1:])
+                state_samples.append(x_seg[1:])
+                current_state = x_seg[-1]
+            else:
+                # No grid points in (current_time, event_t]; still advance to event_t for reset
+                tt = torch.stack([current_time, event_t])
+                x_seg = torchdiffeq.odeint_adjoint(
+                    vector_field_func, current_state, tt, method=method, atol=atol, rtol=rtol
+                )
+                # Append event point for interpolation coverage
+                time_samples.append(event_t.reshape(-1))
+                state_samples.append(x_seg[-1:].reshape(1, B, D))
+                current_state = x_seg[-1]
+            
+            # 3) If reached end, stop
+            if float(event_t) >= float(t_span[-1]) - 1e-12:
+                current_time = event_t
+                break
+            
+            # 4) Record event and apply reset (use interpolate_trajectory for u_t)
+            event_times.append(event_t)
+            event_states.append(current_state.clone())
+            if u_interp is not None:
+                t_query_ev = torch.full((B, 1), float(event_t), device=device, dtype=t_span.dtype)
+                u_ev = interpolate_trajectory(t_span, t_query_ev, u_interp)  # [B,1,U]
+                reset_inp = torch.cat([current_state, u_ev[:, 0, :]], dim=-1)
+                current_state = self.state_reset([], reset_inp)
+            else:
+                current_state = self.state_reset([], current_state)
+            current_time = event_t
+        
+        # Re-interpolate trajectory back to t_span
+        t_dense = torch.cat(time_samples, dim=0)            # [K]
+        x_dense = torch.cat(state_samples, dim=0)           # [K,B,D]
+        t_query_full = t_span.unsqueeze(0).expand(B, -1)    # [B,T]
+        x_interp = interpolate_trajectory(t_dense, t_query_full, x_dense)  # [B,T,D]
+        x_out = x_interp.permute(1, 0, 2)                   # [T,B,D]
+        
+        return x_out, event_times, event_states
+
+    def inference(self, xt_batch, ut_batch=None):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+        
+        x0 = x_batch[:, 0, :]
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        
+        # Create time evaluation grid
+        time_step = self.config.get('time_step', 0.1)
+        n_steps = max(L, int(torch.ceil(max_time / time_step).item()) + 1)
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=n_steps, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:
+            # u_interp = interpolate_external_input(t_eval, t_batch_relative, ut_batch, self.external_input_dim)
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                            t_eval,                                  # [T]
+                            t_batch_u,                               # [B, L_u] (already relative)
+                            ut_batch[:, :, :-1].permute(1, 0, 2)     # traj: [L_u, B, U]
+                            ).permute(1, 0, 2)                           # -> [T, B, U]
+        
+        # Create enhanced vector field
+        # vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_eval)
+        
+        # Solve Event ODE with event detection
+        event_threshold = self.config.get('event_threshold', 0.0)
+        x_trajectory, event_times, event_states = self._event_ode_with_reset(
+            x0, t_eval, u_interp, event_threshold
+        )
+
+        # print(f"Total events detected: {len(event_times)}")
+        
+        return {
+            'x0': x0,
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'x_trajectory': x_trajectory,
+            'event_times': event_times,
+            'event_states': event_states,
+            'num_events': len(event_times),
+            'u_interp': u_interp,
+        }

models/architectures/hybrid.py

@@ -0,0 +1,165 @@
+"""
+Hybrid Latent ODE Model Architecture
+"""
+
+import torch
+import torch.optim as optim
+import itertools
+import torchdiffeq
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_autoencoder_network, init_dynamics_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+from torchdiffeq import odeint_adjoint as odeint
+
+class HybridLatentODEModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_enc = config.get('hidden_dims_enc', [])# config['hidden_dims_enc']
+        # FIX: Properly extract and use hidden_dims_dec from config
+        hidden_dims_dec = config.get('hidden_dims_dec', hidden_dims_enc[::-1])
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        latent_dim = config['latent_dim']
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        vector_field_input_dim = latent_dim + external_input_dim
+        self.has_external_input = external_input_dim > 0  # --- NEW ---
+        
+        # Get activation functions for each component
+        encoder_activations = config.get('encoder_activations', None)
+        decoder_activations = config.get('decoder_activations', None)
+        vector_field_activations = config.get('vector_field_activations', None)
+        default_activation = getattr(torch.nn, config.get('default_activation', 'ReLU'))
+        
+        # Create models
+        self.encoder = MLPWithCustomInit(
+            input_dim, hidden_dims_enc, latent_dim,
+            activation=default_activation,
+            activation_per_layer=encoder_activations,
+            dim_in_linear=config.get('dim_linear_in_encoder', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_encoder', 0), # should equal to the DOF of position components
+            hidden_dim_linear=config.get('hidden_dim_linear_encoder', []) # if empty, use linear branch
+        ).to(device)
+        
+        # vector field with linear:
+        # d[q; v] / dt = [A q + B v; MLP(q; v; u)]
+        self.vector_field = MLPWithCustomInit(
+            vector_field_input_dim, hidden_dims_vector_field, latent_dim,
+            activation=default_activation,
+            activation_per_layer=vector_field_activations,
+            dim_in_linear=config.get('dim_linear_in_vec_field', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_vec_field', 0), # should equal to the DOF of position components 
+            hidden_dim_linear=config.get('hidden_dim_linear_vec_field', []) # if empty, use linear branch
+        ).to(device)
+        
+        # FIX: Ensure decoder uses the correct dimensions
+        self.decoder = MLPWithCustomInit(
+            latent_dim, hidden_dims_dec, input_dim,
+            activation=default_activation,
+            activation_per_layer=decoder_activations,
+            dim_in_linear=config.get('dim_linear_in_decoder', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_decoder', 0), # should equal to the DOF of position components
+            hidden_dim_linear=config.get('hidden_dim_linear_decoder', []) # if empty, use linear branch
+        ).to(device)
+        
+        # Initialize networks
+        init_autoencoder_network(self.encoder)
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        init_autoencoder_network(self.decoder)
+        
+        # Create optimizers with different learning rates
+        self.optimizers = {
+            'encoder': optim.Adam(self.encoder.parameters(), lr=config.get('encoder_lr', config['learning_rate'])),
+            'vector_field': optim.Adam(self.vector_field.parameters(), lr=config.get('vector_field_lr', config['learning_rate'])),
+            'decoder': optim.Adam(self.decoder.parameters(), lr=config.get('decoder_lr', config['learning_rate']))
+        }
+        
+        # Print architecture information
+        self.encoder.print_architecture("Encoder")
+        self.vector_field.print_architecture("Vector Field")
+        self.decoder.print_architecture("Decoder")
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+        print(f"Vector field input dimension: {vector_field_input_dim} (latent {latent_dim}"
+              f"{' + external ' + str(external_input_dim) if external_input_dim>0 else ''})")
+        
+        # Store layer information in config for logging
+        config['encoder_layer_info'] = self.encoder.get_layer_info()
+        config['vector_field_layer_info'] = self.vector_field.get_layer_info()
+        config['decoder_layer_info'] = self.decoder.get_layer_info()
+        
+        total_params = sum(p.numel() for p in itertools.chain(
+            self.encoder.parameters(), self.vector_field.parameters(), self.decoder.parameters()))
+        print(f"Total parameters: {total_params}")
+
+    def inference(self, xt_batch, ut_batch=None, keep_Jx=False, infer_x=False):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        latent_dim = self.config['latent_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+
+        x_flat = x_batch.reshape(-1, D)
+        # z_encoded, J_encoded = self.encoder([], x_flat)  # OLD
+        if keep_Jx:
+            # z_encoded, J_encoded = self.encoder.forward_Jac(None, x_flat)  # NEW: get Jacobian
+            z_encoded = self.encoder.forward(None, x_flat)
+            num_smple = self.config.get('max_iso_samples', x_flat.shape[0])
+            # Sample points from x_flat
+            if num_smple < x_flat.shape[0]:
+                indices = torch.randperm(x_flat.shape[0])[:num_smple]
+                x_sampled = x_flat[indices]
+            else:
+                x_sampled = x_flat
+            _, J_encoded = self.encoder.forward_Jac(None, x_sampled)  # NEW: get Jacobian
+        else:
+            z_encoded = self.encoder.forward(None, x_flat)
+            J_encoded = None
+
+        z_encoded_traj = z_encoded.reshape(B, L, latent_dim)
+        z0 = z_encoded_traj[:, 0, :]
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=L, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:  # uses flag defined above
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                t_eval,
+                t_batch_u,
+                ut_batch[:, :, :-1].permute(1, 0, 2)
+            ).permute(1, 0, 2)
+            
+        # Create enhanced vector field using utility function
+        vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_eval)
+        
+        z_trajectory = torchdiffeq.odeint_adjoint(vector_field_func, z0, t_eval, method=self.config['ode_method'])
+        
+        # decode all z
+        if infer_x:
+            x_trajectory = self.decoder([], z_trajectory.reshape(-1, latent_dim)).reshape(L, B, D)
+        else:
+            x_trajectory = None
+        
+        return {
+            'x0': x_batch[:, 0, :],
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'z_trajectory': z_trajectory,
+            'x_trajectory': x_trajectory,
+            'z_encoded_traj': z_encoded_traj,
+            'u_interp': u_interp,
+            'J_encoded': J_encoded ## for the isometry loss.
+        }

models/architectures/latent_rnn.py

@@ -0,0 +1,165 @@
+"""
+Hybrid Latent ODE Model Architecture
+"""
+
+import torch
+import torch.optim as optim
+import itertools
+import torchdiffeq
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_autoencoder_network, init_dynamics_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+from torchdiffeq import odeint_adjoint as odeint
+
+class RNNLatentODE(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_enc = config.get('hidden_dims_enc', [])# config['hidden_dims_enc']
+        # FIX: Properly extract and use hidden_dims_dec from config
+        hidden_dims_dec = config.get('hidden_dims_dec', hidden_dims_enc[::-1])
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        latent_dim = config['latent_dim']
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        vector_field_input_dim = latent_dim + external_input_dim
+        self.has_external_input = external_input_dim > 0  # --- NEW ---
+        
+        # Get activation functions for each component
+        encoder_activations = config.get('encoder_activations', None)
+        decoder_activations = config.get('decoder_activations', None)
+        vector_field_activations = config.get('vector_field_activations', None)
+        default_activation = getattr(torch.nn, config.get('default_activation', 'ReLU'))
+        
+        # Create models
+        self.encoder = MLPWithCustomInit(
+            input_dim, hidden_dims_enc, latent_dim,
+            activation=default_activation,
+            activation_per_layer=encoder_activations,
+            dim_in_linear=config.get('dim_linear_in_encoder', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_encoder', 0), # should equal to the DOF of position components
+            hidden_dim_linear=config.get('hidden_dim_linear_encoder', []) # if empty, use linear branch
+        ).to(device)
+        
+        # vector field with linear:
+        # d[q; v] / dt = [A q + B v; MLP(q; v; u)]
+        self.vector_field = MLPWithCustomInit(
+            vector_field_input_dim, hidden_dims_vector_field, latent_dim,
+            activation=default_activation,
+            activation_per_layer=vector_field_activations,
+            dim_in_linear=config.get('dim_linear_in_vec_field', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_vec_field', 0), # should equal to the DOF of position components 
+            hidden_dim_linear=config.get('hidden_dim_linear_vec_field', []) # if empty, use linear branch
+        ).to(device)
+        
+        # FIX: Ensure decoder uses the correct dimensions
+        self.decoder = MLPWithCustomInit(
+            latent_dim, hidden_dims_dec, input_dim,
+            activation=default_activation,
+            activation_per_layer=decoder_activations,
+            dim_in_linear=config.get('dim_linear_in_decoder', [0, 0]), # should may equal to DOF of manifold M(latent_dim) or the position components.
+            dim_out_linear=config.get('dim_linear_out_decoder', 0), # should equal to the DOF of position components
+            hidden_dim_linear=config.get('hidden_dim_linear_decoder', []) # if empty, use linear branch
+        ).to(device)
+        
+        # Initialize networks
+        init_autoencoder_network(self.encoder)
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        init_autoencoder_network(self.decoder)
+        
+        # Create optimizers with different learning rates
+        self.optimizers = {
+            'encoder': optim.Adam(self.encoder.parameters(), lr=config.get('encoder_lr', config['learning_rate'])),
+            'vector_field': optim.Adam(self.vector_field.parameters(), lr=config.get('vector_field_lr', config['learning_rate'])),
+            'decoder': optim.Adam(self.decoder.parameters(), lr=config.get('decoder_lr', config['learning_rate']))
+        }
+        
+        # Print architecture information
+        self.encoder.print_architecture("Encoder")
+        self.vector_field.print_architecture("Vector Field")
+        self.decoder.print_architecture("Decoder")
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+        print(f"Vector field input dimension: {vector_field_input_dim} (latent {latent_dim}"
+              f"{' + external ' + str(external_input_dim) if external_input_dim>0 else ''})")
+        
+        # Store layer information in config for logging
+        config['encoder_layer_info'] = self.encoder.get_layer_info()
+        config['vector_field_layer_info'] = self.vector_field.get_layer_info()
+        config['decoder_layer_info'] = self.decoder.get_layer_info()
+        
+        total_params = sum(p.numel() for p in itertools.chain(
+            self.encoder.parameters(), self.vector_field.parameters(), self.decoder.parameters()))
+        print(f"Total parameters: {total_params}")
+
+    def inference(self, xt_batch, ut_batch=None, keep_Jx=False, infer_x=False):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        latent_dim = self.config['latent_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+
+        x_flat = x_batch.reshape(-1, D)
+        # z_encoded, J_encoded = self.encoder([], x_flat)  # OLD
+        if keep_Jx:
+            # z_encoded, J_encoded = self.encoder.forward_Jac(None, x_flat)  # NEW: get Jacobian
+            z_encoded = self.encoder.forward(None, x_flat)
+            num_smple = self.config.get('max_iso_samples', x_flat.shape[0])
+            # Sample points from x_flat
+            if num_smple < x_flat.shape[0]:
+                indices = torch.randperm(x_flat.shape[0])[:num_smple]
+                x_sampled = x_flat[indices]
+            else:
+                x_sampled = x_flat
+            _, J_encoded = self.encoder.forward_Jac(None, x_sampled)  # NEW: get Jacobian
+        else:
+            z_encoded = self.encoder.forward(None, x_flat)
+            J_encoded = None
+
+        z_encoded_traj = z_encoded.reshape(B, L, latent_dim)
+        z0 = z_encoded_traj[:, 0, :]
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=L, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None and self.has_external_input:  # uses flag defined above
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                t_eval,
+                t_batch_u,
+                ut_batch[:, :, :-1].permute(1, 0, 2)
+            ).permute(1, 0, 2)
+            
+        # Create enhanced vector field using utility function
+        vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_eval)
+        
+        z_trajectory = torchdiffeq.odeint_adjoint(vector_field_func, z0, t_eval, method=self.config['ode_method'])
+        
+        # decode all z
+        if infer_x:
+            x_trajectory = self.decoder([], z_trajectory.reshape(-1, latent_dim)).reshape(L, B, D)
+        else:
+            x_trajectory = None
+        
+        return {
+            'x0': x_batch[:, 0, :],
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'z_trajectory': z_trajectory,
+            'x_trajectory': x_trajectory,
+            'z_encoded_traj': z_encoded_traj,
+            'u_interp': u_interp,
+            'J_encoded': J_encoded ## for the isometry loss.
+        }

models/architectures/vanilla_ode.py

@@ -0,0 +1,89 @@
+"""
+Vanilla Neural ODE Model Architecture
+"""
+
+import torch
+import torch.optim as optim
+import torchdiffeq
+import itertools
+
+from ..base import BaseModel
+from ..components.mlp import MLPWithCustomInit
+from ..components.initialization import init_dynamics_network
+from ..utils import interpolate_external_input, create_vector_field_with_external_input, interpolate_trajectory
+
+
+class VanillaODEModel(BaseModel):
+    def __init__(self, config, device):
+        super().__init__(config, device)
+        input_dim = config['input_dim']
+        hidden_dims_vector_field = config['hidden_dims_vector_field']
+        
+        # External input support
+        external_input_dim = config.get('external_input_dim', 0)
+        vector_field_input_dim = input_dim + external_input_dim
+        
+        # Create vector field
+        self.vector_field = MLPWithCustomInit(
+            vector_field_input_dim, hidden_dims_vector_field, input_dim
+        ).to(device)
+        init_dynamics_network(self.vector_field, scale=config['dynamics_init_scale'])
+        
+        self.optimizers = {
+            'vector_field': optim.Adam(self.vector_field.parameters(), lr=config['learning_rate'])
+        }
+        
+        if external_input_dim > 0:
+            print(f"External input dimension: {external_input_dim}")
+            print(f"Vector field input dimension: {vector_field_input_dim} (state + external)")
+        else:
+            print(f"Vector field input dimension: {vector_field_input_dim} (state {input_dim})")
+        
+        # Print architecture information (if supported by MLP implementation)
+        if hasattr(self.vector_field, 'print_architecture'):
+            self.vector_field.print_architecture("Vector Field")
+        if hasattr(self.vector_field, 'get_layer_info'):
+            config['vector_field_layer_info'] = self.vector_field.get_layer_info()
+        
+        total_params = sum(p.numel() for p in self.vector_field.parameters())
+        print(f"Total parameters: {total_params}")
+
+    def inference(self, xt_batch, ut_batch=None, infer_x=True):
+        # xt_batch: [B, L, D+1]
+        state_dim = self.config['input_dim']
+        x_batch = xt_batch[:, :, :state_dim]
+        t_batch = xt_batch[:, :, state_dim]
+        B, L, D = x_batch.shape
+        x0 = x_batch[:, 0, :]
+        t_batch_relative = t_batch - t_batch[:, 0:1]
+        max_time = torch.max(t_batch_relative[:, -1])
+        t_eval = torch.linspace(0, max_time.item() + 1e-5, steps=L, device=self.device)
+        
+        # Handle external input using utility function
+        u_interp = None
+        if ut_batch is not None: # and self.has_external_input:
+            # u_interp = interpolate_external_input(t_eval, t_batch_relative, ut_batch, self.external_input_dim)
+            t_batch_u = ut_batch[:, :, -1]
+            t_batch_u = t_batch_u - t_batch[:, 0:1]
+            # print(t_eval.shape, t_batch_u.shape, ut_batch[:, :, :-1].shape)
+            
+            u_interp = interpolate_trajectory(
+                            t_eval,                                  # [T]
+                            t_batch_u,                               # [B, L_u] (already relative)
+                            ut_batch[:, :, :-1].permute(1, 0, 2)     # traj: [L_u, B, U]
+                            ).permute(1, 0, 2)                           # -> [T, B, U]
+        
+        # Create enhanced vector field
+        vector_field_func = create_vector_field_with_external_input(self.vector_field, u_interp, t_eval)
+        
+        x_trajectory = torchdiffeq.odeint(vector_field_func, x0, t_eval, method=self.config['ode_method'])
+        
+        return {
+            'x0': x0,
+            't_batch': t_batch,
+            't_batch_relative': t_batch_relative,
+            't_eval': t_eval,
+            'x_trajectory': x_trajectory,
+            'u_interp': u_interp,
+        }
+

models/base.py

@@ -0,0 +1,203 @@
+"""
+Base Model Classes for Neural Hybrid Systems
+"""
+
+import torch
+import torch.nn as nn
+import os
+
+
+class BaseModel(nn.Module):
+    def __init__(self, config, device):
+        super().__init__()
+        self.config = config
+        self.device = device
+        self.optimizers = {}
+        
+        # Support for external inputs
+        self.has_external_input = config.get('has_external_input', False)
+        self.external_input_dim = config.get('external_input_dim', 0)
+
+    def zero_grad(self):
+        for opt in self.optimizers.values():
+            opt.zero_grad()
+
+    def step(self):
+        for opt in self.optimizers.values():
+            opt.step()
+            
+    def step_component(self, component_name):
+        """Step optimizer for a specific component only"""
+        if component_name in self.optimizers:
+            self.optimizers[component_name].step()
+        else:
+            raise ValueError(f"Component '{component_name}' not found in optimizers. Available: {list(self.optimizers.keys())}")
+    
+    def zero_grad_component(self, component_name):
+        """Zero gradients for a specific component only"""
+        if component_name in self.optimizers:
+            self.optimizers[component_name].zero_grad()
+        else:
+            raise ValueError(f"Component '{component_name}' not found in optimizers. Available: {list(self.optimizers.keys())}")
+
+    def inference(self, xt_batch, ut_batch=None):
+        """
+        Given xt_batch: [B, L, D+1] and optional ut_batch: [B, L, U+1], return dict with
+        - x0: [B, D]
+        - t_batch: [B, L]
+        - flow: [T, B, D] (ODE solution in x or z space)
+        - t_eval: [T]
+        - z_encoded_traj: [B, L, latent_dim] (if applicable)
+        """
+        raise NotImplementedError
+
+    def update(self, loss):
+        loss.backward()
+        self.step()
+
+    def save_checkpoint(self, filepath, epoch=None, step=None, best_loss=None, metadata=None):
+        """Save model checkpoint with optimizers and metadata"""
+        checkpoint = {
+            'model_state_dict': self.state_dict(),
+            'optimizers': {name: opt.state_dict() for name, opt in self.optimizers.items()},
+            'config': self.config,
+            'epoch': epoch,
+            'step': step,
+            'best_loss': best_loss,
+            'metadata': metadata or {}
+        }
+        
+        os.makedirs(os.path.dirname(filepath), exist_ok=True)
+        torch.save(checkpoint, filepath)
+        print(f"Checkpoint saved to: {filepath}")
+
+    def load_checkpoint(self, filepath, map_location=None, strict=True):
+        """Load model checkpoint and restore optimizers"""
+        if not os.path.exists(filepath):
+            raise FileNotFoundError(f"Checkpoint not found: {filepath}")
+        
+        if map_location is None:
+            map_location = self.device
+            
+        checkpoint = torch.load(filepath, map_location=map_location)
+        
+        # Handle different checkpoint formats
+        if 'model_state_dict' in checkpoint:
+            # New format: checkpoint saved with save_checkpoint()
+            try:
+                self.load_state_dict(checkpoint['model_state_dict'], strict=strict)
+                print(f"Model state loaded from: {filepath} (new format)")
+            except RuntimeError as e:
+                if "size mismatch" in str(e) and not strict:
+                    print(f"Warning: Dimension mismatch detected, loading with strict=False")
+                    print(f"Using current config dimensions as ground truth")
+                    self.load_state_dict(checkpoint['model_state_dict'], strict=False)
+                    print(f"Model state loaded with dimension mismatches ignored")
+                else:
+                    raise e
+            
+            # Load optimizer states if available and optimizers exist
+            if 'optimizers' in checkpoint and self.optimizers:
+                for name, opt_state in checkpoint['optimizers'].items():
+                    if name in self.optimizers:
+                        self.optimizers[name].load_state_dict(opt_state)
+                        print(f"Optimizer '{name}' state loaded")
+                    else:
+                        print(f"Warning: Optimizer '{name}' not found in current model, skipping")
+            
+            # Return metadata for trainer to use
+            return {
+                'epoch': checkpoint.get('epoch'),
+                'step': checkpoint.get('step'),
+                'best_loss': checkpoint.get('best_loss'),
+                'config': checkpoint.get('config'),
+                'metadata': checkpoint.get('metadata', {})
+            }
+        
+        else:
+            # Old format: component states saved separately (e.g., 'encoder', 'vector_field', 'decoder')
+            print(f"Loading model from old format checkpoint: {filepath}")
+            
+            # Try to load component states with dimension mismatch handling
+            loaded_components = []
+            
+            # Load encoder
+            if 'encoder' in checkpoint and hasattr(self, 'encoder'):
+                try:
+                    self.encoder.load_state_dict(checkpoint['encoder'], strict=strict)
+                    loaded_components.append('encoder')
+                except RuntimeError as e:
+                    if "size mismatch" in str(e):
+                        print(f"Warning: Encoder dimension mismatch, using config dimensions")
+                        self.encoder.load_state_dict(checkpoint['encoder'], strict=False)
+                        loaded_components.append('encoder (with mismatches)')
+                    else:
+                        print(f"Failed to load encoder: {e}")
+            
+            # Load vector_field
+            if 'vector_field' in checkpoint and hasattr(self, 'vector_field'):
+                try:
+                    self.vector_field.load_state_dict(checkpoint['vector_field'], strict=strict)
+                    loaded_components.append('vector_field')
+                except RuntimeError as e:
+                    if "size mismatch" in str(e):
+                        print(f"Warning: Vector field dimension mismatch, using config dimensions")
+                        self.vector_field.load_state_dict(checkpoint['vector_field'], strict=False)
+                        loaded_components.append('vector_field (with mismatches)')
+                    else:
+                        print(f"Failed to load vector_field: {e}")
+            
+            # Load decoder
+            if 'decoder' in checkpoint and hasattr(self, 'decoder'):
+                try:
+                    self.decoder.load_state_dict(checkpoint['decoder'], strict=strict)
+                    loaded_components.append('decoder')
+                except RuntimeError as e:
+                    if "size mismatch" in str(e):
+                        print(f"Warning: Decoder dimension mismatch, using config dimensions")
+                        self.decoder.load_state_dict(checkpoint['decoder'], strict=False)
+                        loaded_components.append('decoder (with mismatches)')
+                    else:
+                        print(f"Failed to load decoder: {e}")
+            
+            # Load other components with same error handling pattern
+            component_map = {
+                'ag_function': 'ag_function',
+                'rnn': 'rnn', 
+                'lstm': 'lstm',
+                'output_layer': 'output_layer',
+                'event_function': 'event_function',
+                'state_reset': 'state_reset'
+            }
+            
+            for checkpoint_key, attr_name in component_map.items():
+                if checkpoint_key in checkpoint and hasattr(self, attr_name):
+                    try:
+                        getattr(self, attr_name).load_state_dict(checkpoint[checkpoint_key], strict=strict)
+                        loaded_components.append(attr_name)
+                    except RuntimeError as e:
+                        if "size mismatch" in str(e):
+                            print(f"Warning: {attr_name} dimension mismatch, using config dimensions")
+                            getattr(self, attr_name).load_state_dict(checkpoint[checkpoint_key], strict=False)
+                            loaded_components.append(f"{attr_name} (with mismatches)")
+                        else:
+                            print(f"Failed to load {attr_name}: {e}")
+            
+            print(f"Loaded components: {loaded_components}")
+            
+            # Try to load optimizer states (old format: component_name_optimizer)
+            if self.optimizers:
+                for component_name in loaded_components:
+                    opt_key = f"{component_name}_optimizer"
+                    if opt_key in checkpoint and component_name in self.optimizers:
+                        self.optimizers[component_name].load_state_dict(checkpoint[opt_key])
+                        print(f"Optimizer '{component_name}' state loaded")
+            
+            # Return metadata (old format may not have all fields)
+            return {
+                'epoch': checkpoint.get('epoch'),
+                'step': checkpoint.get('step'),
+                'best_loss': checkpoint.get('best_loss'),
+                'config': checkpoint.get('config'),
+                'metadata': checkpoint.get('experiment_info', {})  # Old format uses 'experiment_info'
+            }

models/components/__init__.py

@@ -0,0 +1,15 @@
+"""
+Model Components Package
+"""
+
+from .mlp import MLPWithCustomInit
+from .initialization import (
+    init_dynamics_network, init_autoencoder_network,
+    init_event_network, init_reset_network
+)
+
+__all__ = [
+    'MLPWithCustomInit',
+    'init_dynamics_network', 'init_autoencoder_network',
+    'init_event_network', 'init_reset_network',
+]

models/components/initialization.py

@@ -0,0 +1,61 @@
+"""
+Network Initialization Functions
+"""
+
+import torch.nn as nn
+
+
+def init_dynamics_network(model, scale=0.01):
+    """Initialize dynamics network with small random weights"""
+    for module in model.modules():
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=scale)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+
+
+def init_autoencoder_network(model):
+    """Initialize autoencoder network with Xavier initialization"""
+    for module in model.modules():
+        if isinstance(module, nn.Linear):
+            nn.init.xavier_uniform_(module.weight, gain=nn.init.calculate_gain('tanh'))
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+
+
+def init_event_network(model, scale=0.1):
+    """
+    Initialize event function network with large standard deviation.
+    
+    Large initialization helps prevent runaway event boundaries where the event function
+    is never triggered, which would result in no gradients and model degeneration to 
+    vanilla Neural ODE.
+    
+    Args:
+        model: Event function network
+        scale: Standard deviation for weight initialization (default: 0.1, larger than dynamics)
+    """
+    for module in model.modules():
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=scale)
+            if module.bias is not None:
+                # Initialize bias with small random values to encourage event triggering
+                nn.init.normal_(module.bias, mean=0.0, std=scale * 0.5)
+
+
+def init_reset_network(model, scale=0.05):
+    """
+    Initialize state reset network with moderate variance.
+    
+    Reset networks should provide meaningful state perturbations without being too
+    aggressive, so we use moderate initialization variance.
+    
+    Args:
+        model: State reset network  
+        scale: Standard deviation for weight initialization (default: 0.05)
+    """
+    for module in model.modules():
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=scale)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)

models/components/mlp.py

@@ -0,0 +1,597 @@
+"""
+Multi-Layer Perceptron with Custom Initialization
+"""
+
+import torch
+import torch.nn as nn
+
+# --- Added activation registry with custom sine (supports autograd) ---
+class SinActFunc(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x):
+        ctx.save_for_backward(x)
+        return x.sin()
+    @staticmethod
+    def backward(ctx, grad_out):
+        (x,) = ctx.saved_tensors
+        return grad_out * x.cos()
+
+class Sine(nn.Module):
+    def forward(self, x):
+        return SinActFunc.apply(x)
+
+ACTIVATION_REGISTRY = {
+    'relu': lambda: nn.ReLU(),
+    'tanh': lambda: nn.Tanh(),
+    'sin':  lambda: Sine(),
+}
+
+def get_activation(name: str):
+    key = name.lower()
+    if key not in ACTIVATION_REGISTRY:
+        raise ValueError(f"Unknown activation '{name}'. Available: {list(ACTIVATION_REGISTRY.keys())}")
+    return ACTIVATION_REGISTRY[key]()
+
+
+def act_prime(mod, a):
+    """
+    Unified activation derivative for manual Jacobian.
+    a: pre-activation tensor.
+    """
+    if isinstance(mod, nn.ReLU):
+        return (a > 0).to(a.dtype)
+    if isinstance(mod, nn.LeakyReLU):
+        ns = getattr(mod, "negative_slope", 0.01)
+        return torch.where(a > 0, torch.ones_like(a), torch.full_like(a, ns))
+    if isinstance(mod, nn.Tanh):
+        ta = torch.tanh(a)
+        return 1.0 - ta * ta
+    if isinstance(mod, nn.Sigmoid):
+        s = torch.sigmoid(a)
+        return s * (1.0 - s)
+    if isinstance(mod, nn.Softplus):
+        beta = getattr(mod, "beta", 1.0)
+        return torch.sigmoid(beta * a)
+    if isinstance(mod, nn.SiLU):  # Swish
+        s = torch.sigmoid(a)
+        return s * (1.0 + a * (1.0 - s))
+    if isinstance(mod, nn.ELU):
+        alpha = getattr(mod, "alpha", 1.0)
+        return torch.where(a > 0, torch.ones_like(a), alpha * torch.exp(a))
+    if isinstance(mod, nn.Identity):
+        return torch.ones_like(a)
+    if isinstance(mod, Sine):
+        return torch.cos(a)
+    raise NotImplementedError(f"Jacobian for activation {mod.__class__.__name__} not implemented.")
+
+class MLPWithCustomInit(nn.Module):
+    def __init__(self, input_dim, hidden_dims, output_dim, activation=nn.ReLU, init_type='kaiming', activation_per_layer=None, dim_in_linear=[0, 0], dim_out_linear=0, hidden_dim_linear=[]):
+        super().__init__()
+        layers = []
+        
+        # Store linear branch parameters
+        self.dim_in_linear = dim_in_linear
+        self.dim_out_linear = dim_out_linear
+        self.hidden_dim_linear = hidden_dim_linear
+        
+        # Validate dim_in_linear format
+        if not isinstance(dim_in_linear, (list, tuple)) or len(dim_in_linear) != 2:
+            raise ValueError(f"dim_in_linear must be a list/tuple of length 2 [start_idx, end_idx], got {dim_in_linear}")
+        
+        start_idx, end_idx = dim_in_linear
+        linear_input_size = end_idx - start_idx
+        
+        # Create linear/MLP branch if specified
+        if linear_input_size > 0 and dim_out_linear > 0:
+            if start_idx < 0 or end_idx > input_dim or start_idx >= end_idx:
+                raise ValueError(f"Invalid dim_in_linear {dim_in_linear}: must satisfy 0 <= start < end <= {input_dim}")
+            if dim_out_linear > output_dim:
+                raise ValueError(f"dim_out_linear ({dim_out_linear}) cannot be larger than output_dim ({output_dim})")
+            
+            # Create branch network (linear or MLP)
+            if len(hidden_dim_linear) == 0:
+                # Simple linear branch
+                self.linear_branch = nn.Linear(linear_input_size, dim_out_linear)
+                branch_type = 'linear_branch'
+            else:
+                # MLP branch
+                branch_layers = []
+                branch_dims = [linear_input_size] + hidden_dim_linear + [dim_out_linear]
+                
+                for i, (in_dim, out_dim) in enumerate(zip(branch_dims[:-1], branch_dims[1:])):
+                    branch_layers.append(nn.Linear(in_dim, out_dim))
+                    # Add activation for all layers except the last one
+                    if i < len(branch_dims) - 2:
+                        branch_layers.append(activation())
+                
+                self.linear_branch = nn.Sequential(*branch_layers)
+                branch_type = 'mlp_branch'
+            
+            # MLP output dimension is total minus branch output
+            mlp_output_dim = output_dim - dim_out_linear
+            total_output_dim = output_dim
+        else:
+            self.linear_branch = None
+            mlp_output_dim = output_dim
+            total_output_dim = output_dim
+            linear_input_size = 0
+            branch_type = None
+        
+        dims = [input_dim] + hidden_dims
+        
+        # Record layer information for debugging/analysis
+        self.layer_info = {
+            'input_dim': input_dim,
+            'hidden_dims': hidden_dims,
+            'output_dim': output_dim,
+            'mlp_output_dim': mlp_output_dim,
+            'total_output_dim': total_output_dim,
+            'dim_in_linear': dim_in_linear,
+            'linear_input_size': linear_input_size,
+            'dim_out_linear': dim_out_linear,
+            'hidden_dim_linear': hidden_dim_linear,
+            'branch_type': branch_type,
+            'total_layers': len(hidden_dims) + 1,
+            'layer_details': []
+        }
+        
+        # Add branch info if exists
+        if self.linear_branch is not None:
+            if branch_type == 'linear_branch':
+                # Simple linear branch
+                self.layer_info['layer_details'].append({
+                    'layer_idx': -1,  # Special index for branch
+                    'type': 'linear_branch',
+                    'input_dim': linear_input_size,
+                    'input_slice': f"[{start_idx}:{end_idx}]",
+                    'output_dim': dim_out_linear,
+                    'activation': 'None',
+                    'parameters': linear_input_size * dim_out_linear + dim_out_linear
+                })
+            else:
+                # MLP branch - record each layer
+                branch_dims = [linear_input_size] + hidden_dim_linear + [dim_out_linear]
+                total_branch_params = 0
+                for i, (in_dim, out_dim) in enumerate(zip(branch_dims[:-1], branch_dims[1:])):
+                    layer_params = in_dim * out_dim + out_dim
+                    total_branch_params += layer_params
+                    
+                    if i < len(branch_dims) - 2:
+                        # Hidden layer in branch
+                        self.layer_info['layer_details'].append({
+                            'layer_idx': f"b{i}",  # Branch layer index
+                            'type': 'branch_hidden',
+                            'input_dim': in_dim,
+                            'output_dim': out_dim,
+                            'input_slice': f"[{start_idx}:{end_idx}]" if i == 0 else None,
+                            'activation': activation().__class__.__name__,
+                            'parameters': layer_params
+                        })
+                    else:
+                        # Output layer in branch
+                        self.layer_info['layer_details'].append({
+                            'layer_idx': f"b{i}",
+                            'type': 'branch_output',
+                            'input_dim': in_dim,
+                            'output_dim': out_dim,
+                            'input_slice': f"[{start_idx}:{end_idx}]" if i == 0 and len(branch_dims) == 2 else None,
+                            'activation': 'None',
+                            'parameters': layer_params
+                        })
+        
+        # Handle activation per layer
+        if activation_per_layer is None:
+            activation_fns = [activation() for _ in hidden_dims]
+        else:
+            if len(activation_per_layer) != len(hidden_dims):
+                raise ValueError(f"Number of activations ({len(activation_per_layer)}) must match number of hidden layers ({len(hidden_dims)})")
+            activation_fns = [get_activation(a) for a in activation_per_layer]
+
+        for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])):
+            layer_linear = nn.Linear(in_dim, out_dim)
+            activation_fn = activation_fns[i]
+            layers.append(layer_linear)
+            layers.append(activation_fn)
+            # Record layer details
+            self.layer_info['layer_details'].append({
+                'layer_idx': i,
+                'type': 'hidden',
+                'input_dim': in_dim,
+                'output_dim': out_dim,
+                'activation': activation_fn.__class__.__name__,
+                'parameters': in_dim * out_dim + out_dim
+            })
+        
+        # Output layer - use mlp_output_dim instead of output_dim
+        output_layer = nn.Linear(dims[-1], mlp_output_dim)
+        layers.append(output_layer)
+        
+        # Record output layer details
+        self.layer_info['layer_details'].append({
+            'layer_idx': len(hidden_dims),
+            'type': 'output',
+            'input_dim': dims[-1],
+            'output_dim': mlp_output_dim,
+            'activation': 'None',
+            'parameters': dims[-1] * mlp_output_dim + mlp_output_dim
+        })
+        
+        # Calculate total parameters
+        self.layer_info['total_parameters'] = sum(detail['parameters'] for detail in self.layer_info['layer_details'])
+        
+        self.net = nn.Sequential(*layers)
+        self.activation = activation
+        self.init_type = init_type
+        self.apply(self._init_weights)
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            if self.init_type == 'xavier':
+                if isinstance(self.activation(), (nn.Tanh, nn.ReLU)):
+                    gain = nn.init.calculate_gain('tanh' if isinstance(self.activation(), nn.Tanh) else 'relu')
+                    nn.init.xavier_uniform_(module.weight, gain=gain)
+                else:
+                    nn.init.xavier_uniform_(module.weight)
+            elif self.init_type == 'kaiming':
+                nn.init.kaiming_uniform_(module.weight, nonlinearity='relu')
+            elif self.init_type == 'orthogonal':
+                nn.init.orthogonal_(module.weight, gain=1.0)
+            elif self.init_type == 'small_normal':
+                nn.init.normal_(module.weight, mean=0.0, std=0.01)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+
+    def _apply_network(self, x):
+        """Apply the complete network with linear branch if present"""
+        if self.linear_branch is not None:
+            # Extract slice from input for linear branch
+            start_idx, end_idx = self.dim_in_linear
+            x1 = x[..., start_idx:end_idx]
+            # Apply linear branch
+            linear_out = self.linear_branch(x1)
+            # Apply MLP to full input
+            mlp_out = self.net(x)
+            # Concatenate outputs: [linear_out; mlp_out]
+            return torch.cat([linear_out, mlp_out], dim=-1)
+        else:
+            # No linear branch, just apply MLP
+            return self.net(x)
+
+    def forward(self, t=None, x=None, u=None):
+        """
+        Forward pass - handle both (t, x) and single argument calls, plus external input u
+        IMPORTANT: This must maintain compatibility with:
+        1. Hybrid models: encoder([], x_flat) and decoder([], z_flat)
+        2. Vector fields in torchdiffeq: vector_field(t, z) or vector_field(t, z, u)
+        3. Autoregressive models: ag_function(None, ag_input)
+        4. NEW: External input conditioning: vector_field(t, z, u)
+        """
+        if x is None and u is None:
+            # Single argument call: forward(input)
+            # This handles autoregressive case: ag_function(ag_input)
+            return self._apply_network(t)  # t is actually the input
+        elif u is None:
+            # Two argument call: forward(t, x)
+            # This handles hybrid case: encoder([], x_flat) where t=[] and x=x_flat
+            # And vector field case: vector_field(t, z) where we use z
+            return self._apply_network(x)
+        else:
+            # Three argument call: forward(t, x, u) - NEW for external conditioning
+            # Concatenate x and u for input to network
+            if isinstance(u, (int, float)):
+                # Scalar u, expand to match batch size
+                u_expanded = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype)
+            else:
+                u_expanded = u
+            xu_input = torch.cat([x, u_expanded], dim=-1)
+            return self._apply_network(xu_input)
+        
+    def forward_Jac(self, t=None, x=None, u=None):
+        """
+        Manual forward + Jacobian for the MLP with branch support.
+        Returns:
+        y: [B, total_out_dim] where total_out_dim = dim_out_linear + mlp_output_dim
+        J: [B, total_out_dim, in_dim_eff], where in_dim_eff is the actual input fed to the network
+
+        The Jacobian accounts for the branch structure: output = [branch(x1); MLP(x)]
+        """
+        # --- 1) Parse inputs to match your forward conventions ---
+        if x is None and u is None:
+            inp = t
+        elif u is None:
+            inp = x
+        else:
+            if isinstance(u, (int, float)):
+                u = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype)
+            inp = torch.cat([x, u], dim=-1)
+
+        B, Din = inp.shape
+
+        if self.linear_branch is not None:
+            # Extract slice from input for branch
+            start_idx, end_idx = self.dim_in_linear
+            x1 = inp[..., start_idx:end_idx]
+            
+            # Apply branch network
+            if len(self.hidden_dim_linear) == 0:
+                # Simple linear branch: y_branch = A @ x1 + b
+                branch_out = self.linear_branch(x1)  # [B, dim_out_linear]
+                
+                # Construct Jacobian for linear branch
+                W_branch = self.linear_branch.weight  # [dim_out_linear, linear_input_size]
+                J_branch = torch.zeros(B, self.dim_out_linear, Din, device=inp.device, dtype=inp.dtype)
+                J_branch[:, :, start_idx:end_idx] = W_branch.unsqueeze(0).expand(B, -1, -1)
+            else:
+                # MLP branch - need to compute Jacobian through the branch network
+                y_branch = x1
+                J_branch = None
+                is_first_branch = True
+                a_cache_branch = None
+                
+                # Propagate through branch layers
+                for i, module in enumerate(self.linear_branch):
+                    if isinstance(module, nn.Linear):
+                        W = module.weight      # [out, in]
+                        b = module.bias        # [out]
+                        a = y_branch @ W.t() + b  # pre-activation
+
+                        Wb = W.unsqueeze(0).expand(B, -1, -1)     # [B, out, in]
+                        if is_first_branch:
+                            J_branch = Wb                          # [B, out, linear_input_size]
+                            is_first_branch = False
+                        else:
+                            J_branch = torch.bmm(Wb, J_branch)    # [B, out, linear_input_size]
+
+                        y_branch = a
+                        a_cache_branch = a
+
+                    else:
+                        # Activation function in branch
+                        ap = act_prime(module, a_cache_branch)  # [B, dim]
+                        y_branch = module(y_branch)
+                        J_branch = ap.unsqueeze(-1) * J_branch
+
+                branch_out = y_branch
+                
+                # Expand J_branch to full input dimensions
+                J_branch_full = torch.zeros(B, self.dim_out_linear, Din, device=inp.device, dtype=inp.dtype)
+                J_branch_full[:, :, start_idx:end_idx] = J_branch
+                J_branch = J_branch_full
+            
+            # MLP branch: apply full network to full input
+            y_mlp = inp
+            J_mlp = None
+            is_first = True
+            a_cache = None
+            
+            # Propagate through MLP layers
+            for module in self.net:
+                if isinstance(module, nn.Linear):
+                    W = module.weight      # [out, in]
+                    b = module.bias        # [out]
+                    a = y_mlp @ W.t() + b  # pre-activation
+
+                    Wb = W.unsqueeze(0).expand(B, -1, -1)     # [B, out, in]
+                    if is_first:
+                        J_mlp = Wb                             # [B, out, Din]
+                        is_first = False
+                    else:
+                        J_mlp = torch.bmm(Wb, J_mlp)          # [B, out, Din]
+
+                    y_mlp = a
+                    a_cache = a
+
+                else:
+                    # Activation function
+                    ap = act_prime(module, a_cache)  # [B, dim]
+                    y_mlp = module(y_mlp)
+
+                    if J_mlp is None:
+                        I = torch.eye(Din, device=y_mlp.device, dtype=y_mlp.dtype)
+                        J_mlp = I.unsqueeze(0).expand(B, Din, Din).clone()
+                        is_first = False
+
+                    J_mlp = ap.unsqueeze(-1) * J_mlp
+
+            # Combine outputs and Jacobians
+            y = torch.cat([branch_out, y_mlp], dim=-1)  # [B, total_out_dim]
+            J = torch.cat([J_branch, J_mlp], dim=1)     # [B, total_out_dim, Din]
+
+        else:
+            # No linear branch, use original implementation
+            y = inp
+            J = None
+            is_first = True
+            a_cache = None
+
+            for module in self.net:
+                if isinstance(module, nn.Linear):
+                    W = module.weight
+                    b = module.bias
+                    a = y @ W.t() + b
+
+                    Wb = W.unsqueeze(0).expand(B, -1, -1)
+                    if is_first:
+                        J = Wb
+                        is_first = False
+                    else:
+                        J = torch.bmm(Wb, J)
+
+                    y = a
+                    a_cache = a
+
+                else:
+                    ap = act_prime(module, a_cache)
+                    y = module(y)
+
+                    if J is None:
+                        I = torch.eye(Din, device=y.device, dtype=y.dtype)
+                        J = I.unsqueeze(0).expand(B, Din, Din).clone()
+                        is_first = False
+
+                    J = ap.unsqueeze(-1) * J
+
+        return y, J
+
+    def __call__(self, *args):
+        """
+        Allow flexible calling - CRITICAL for compatibility
+        This ensures all calling patterns work correctly
+        """
+        if len(args) == 1:
+            # Single argument: autoregressive case
+            return self._apply_network(args[0])
+        elif len(args) == 2:
+            # Two arguments: hybrid/ODE case - use second argument (actual data)
+            return self._apply_network(args[1])
+        elif len(args) == 3:
+            # Three arguments: external input case - concatenate second and third
+            x, u = args[1], args[2]
+            if isinstance(u, (int, float)):
+                u_expanded = torch.full((x.shape[0], 1), u, device=x.device, dtype=x.dtype)
+            else:
+                u_expanded = u
+            xu_input = torch.cat([x, u_expanded], dim=-1)
+            return self._apply_network(xu_input)
+        else:
+            raise ValueError(f"Expected 1, 2, or 3 arguments, got {len(args)}")
+    
+    def get_layer_info(self):
+        """Return detailed layer information"""
+        return self.layer_info
+    
+    def print_architecture(self, name="MLP"):
+        """Print a summary of the network architecture"""
+        print(f"\n{name} Architecture:")
+        print(f"  Input dimension: {self.layer_info['input_dim']}")
+        if self.linear_branch is not None:
+            start_idx, end_idx = self.dim_in_linear
+            if self.layer_info['branch_type'] == 'linear_branch':
+                print(f"  Linear branch: input[{start_idx}:{end_idx}] ({self.layer_info['linear_input_size']}) -> {self.layer_info['dim_out_linear']}")
+            else:
+                print(f"  MLP branch: input[{start_idx}:{end_idx}] ({self.layer_info['linear_input_size']}) -> {self.layer_info['hidden_dim_linear']} -> {self.layer_info['dim_out_linear']}")
+        print(f"  Total layers: {self.layer_info['total_layers']}")
+        print(f"  MLP output dimension: {self.layer_info['mlp_output_dim']}")
+        print(f"  Total output dimension: {self.layer_info['total_output_dim']}")
+        print(f"  Total parameters: {self.layer_info['total_parameters']}")
+        print("  Layer details:")
+        for detail in self.layer_info['layer_details']:
+            if 'branch' in detail['type']:
+                layer_type = detail['type'].replace('_', ' ').title()
+                slice_info = f" {detail['input_slice']}" if detail.get('input_slice') else ""
+                print(f"    {layer_type} {detail['layer_idx']}: "
+                      f"{detail['input_dim']}{slice_info} -> {detail['output_dim']}, "
+                      f"activation: {detail['activation']}, "
+                      f"params: {detail['parameters']}")
+            else:
+                print(f"    Layer {detail['layer_idx']} ({detail['type']}): "
+                      f"{detail['input_dim']} -> {detail['output_dim']}, "
+                      f"activation: {detail['activation']}, "
+                      f"params: {detail['parameters']}")
+
+
+# --- Example usage (adapt constructor to your class) ---
+if __name__ == "__main__":
+    import time
+    def _batch_jacobian_autograd(model, x, *, mode="x"):
+        """
+        Compute Jacobian batch-wise using torch.autograd.functional.jacobian
+        Returns: J_auto [B, out_dim, in_dim]
+        mode:
+        - "x": calls model.forward(inp) where inp=x
+        - "tx": calls model.forward(t=None, x=inp)
+        """
+        x = x.detach()
+        B, Din = x.shape
+
+        if mode == "x":
+            def f_single(x_single):  # x_single: [Din]
+                y_single = model.forward(x_single.unsqueeze(0)).squeeze(0)  # [Dout]
+                return y_single
+        elif mode == "tx":
+            def f_single(x_single):
+                y_single = model.forward(None, x_single.unsqueeze(0)).squeeze(0)
+                return y_single
+        else:
+            raise NotImplementedError
+
+        J_list = []
+        for b in range(B):
+            xb = x[b].clone().requires_grad_(True)
+            Jb = torch.autograd.functional.jacobian(
+                f_single, xb, create_graph=False, vectorize=True
+            )  # [Dout, Din]
+            J_list.append(Jb)
+        return torch.stack(J_list, dim=0)  # [B, Dout, Din]
+
+
+    @torch.no_grad()
+    def check_manual_jacobian(model, x, *, atol=1e-6, rtol=1e-5, mode="x", verbose=True):
+        """
+        Compare manual Jacobian (forward_Jac) vs. autograd Jacobian.
+
+        Args:
+        model: your MLP instance (with .forward and .forward_Jac)
+        x: [B, in_dim] input
+        atol, rtol: tolerances for allclose
+        mode: see _batch_jacobian_autograd; default assumes forward(x)
+
+        Prints max abs diff and raises AssertionError if mismatch.
+        """
+        start_manual = time.time()
+        y_man, J_man = model.forward_Jac(x) if mode == "x" else model.forward_Jac(None, x)
+        end_manual = time.time()
+        print(f"Manual Jacobian time: {end_manual - start_manual:.4f} seconds")
+
+        J_auto = _batch_jacobian_autograd(model, x, mode=mode)
+
+        start_auto = time.time()
+        J_auto = _batch_jacobian_autograd(model, x, mode=mode)
+        end_auto = time.time()
+        print(f"Autograd Jacobian time: {end_auto - start_auto:.4f} seconds")
+
+        # print(J_man)
+        # print(J_auto)
+
+        if J_auto.shape != J_man.shape:
+            raise RuntimeError(f"Shape mismatch: auto {J_auto.shape} vs manual {J_man.shape}")
+
+        max_abs = (J_auto - J_man).abs().max().item()
+        ok = torch.allclose(J_auto, J_man, atol=atol, rtol=rtol)
+
+        if verbose:
+            print(f"[Jacobian check] shape={tuple(J_man.shape)}, max|Δ|={max_abs:.3e}, "
+                f"allclose(atol={atol}, rtol={rtol})={ok}")
+
+        assert ok, f"Jacobian mismatch: max|Δ|={max_abs:.3e} exceeds tolerances."
+
+    torch.manual_seed(0)
+    # Test with MLP branch using slice [1, 4] - total output dim is 7 (3 from branch + 4 from MLP)
+    model = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[1, 4], dim_out_linear=3, hidden_dim_linear=[8, 6]).to('cuda')
+    x = torch.randn(512, 6).to('cuda')
+    _ = model(x)  # warmup
+    print(f"Input shape: {x.shape}")
+    print(f"Output shape: {model(x).shape}")
+    model.print_architecture("MLP with MLP Branch (slice [1:4])")
+    check_manual_jacobian(model, x, mode="x")
+    
+    # Test with linear branch (empty hidden_dim_linear)
+    model_linear = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[1, 4], dim_out_linear=3, hidden_dim_linear=[]).to('cuda')
+    model_linear.print_architecture("MLP with Linear Branch")
+    check_manual_jacobian(model_linear, x, mode="x")
+    
+    # Test without branch (original behavior)
+    model_orig = MLPWithCustomInit(6, [64] * 3, 4).to('cuda')
+    _ = model_orig(x)
+    print(f"Original output shape: {model_orig(x).shape}")
+    check_manual_jacobian(model_orig, x, mode="x")
+    # Test with legacy int format (should work as [0, 2])
+    model_legacy = MLPWithCustomInit(6, [64] * 3, 7, dim_in_linear=[0, 2], dim_out_linear=3).to('cuda')
+    print(f"Legacy format dim_in_linear=2 -> {model_legacy.dim_in_linear}")
+    model_legacy.print_architecture("MLP with Linear Branch (legacy format)")
+    
+    # Test without linear branch (original behavior)
+    model_orig = MLPWithCustomInit(6, [64] * 3, 4).to('cuda')
+    _ = model_orig(x)
+    print(f"Original output shape: {model_orig(x).shape}")
+    check_manual_jacobian(model_orig, x, mode="x")

models/factory.py

@@ -0,0 +1,72 @@
+"""
+Model Factory Functions
+"""
+
+from .architectures.hybrid import HybridLatentODEModel
+from .architectures.vanilla_ode import VanillaODEModel
+from .architectures.event_ode import EventODEModel
+from .architectures.augmented_ode import AugmentedODEModel
+from .architectures.autoregressive import AutoregressiveModel
+
+def create_model(model_type, config, device):
+    """
+    Factory function to create different types of models
+    
+    Args:
+        model_type: 'hybrid', 'vanilla_ode', 'event_ode', 'augmented_ode', 'autoregressive'
+        config: Configuration dictionary
+        device: PyTorch device
+    
+    Returns:
+        model: Instance of BaseModel subclass
+    """
+    if model_type == 'hybrid':
+        from .architectures.hybrid import HybridLatentODEModel
+        return HybridLatentODEModel(config, device)
+    elif model_type == 'vanilla_ode':
+        from .architectures.vanilla_ode import VanillaODEModel
+        return VanillaODEModel(config, device)
+    elif model_type == 'event_ode':
+        from .architectures.event_ode import EventODEModel
+        return EventODEModel(config, device)
+    elif model_type == 'augmented_ode':
+        from .architectures.augmented_ode import AugmentedODEModel
+        return AugmentedODEModel(config, device)
+    elif model_type == 'autoregressive':
+        from .architectures.autoregressive import AutoregressiveModel
+        return AutoregressiveModel(config, device)
+    else:
+        raise ValueError(f"Unknown model type: {model_type}")
+
+
+# Deprecated functions for backward compatibility
+def create_hybrid_models(config, device):
+    """Deprecated: Use create_model('hybrid', config, device) instead"""
+    model = HybridLatentODEModel(config, device)
+    models = {
+        'encoder': model.encoder,
+        'vector_field': model.vector_field,
+        'decoder': model.decoder
+    }
+    optimizers = model.optimizers
+    return models, optimizers
+
+
+def create_neural_ode_models(config, device):
+    """Deprecated: Use create_model('vanilla_ode', config, device) instead"""
+    model = VanillaODEModel(config, device)
+    models = {'vector_field': model.vector_field}
+    optimizers = {'optimizer': model.optimizers['vector_field']}
+    return models, optimizers
+
+
+def create_event_ode_models(config, device):
+    """Deprecated: Use create_model('event_ode', config, device) instead"""
+    model = EventODEModel(config, device)
+    models = {
+        'vector_field': model.vector_field,
+        'event_function': model.event_function,
+        'state_reset': model.state_reset
+    }
+    optimizers = {'optimizer': model.optimizers['combined']}
+    return models, optimizers

models/utils.py

@@ -0,0 +1,189 @@
+"""
+Model Utility Functions
+"""
+
+import torch
+import torch.nn as nn
+
+
+def interpolate_trajectory(t_eval, t_query, traj, dim_batch=1):
+    """
+    Interpolate trajectory (z or x) at t_query based on t_eval and traj.
+    Args:
+        t_eval: [T] time grid of ODE solution
+        t_query: [B, L] query times for each batch
+        traj: [T, B, D] trajectory (z or x)
+        dim_batch: batch dimension (default 1)
+    Returns:
+        interp: [B, L, D]
+    """
+    B, L = t_query.shape
+    T = t_eval.shape[0]
+    indices_flat = torch.searchsorted(t_eval, t_query.flatten(), right=False)
+    indices = torch.clamp(indices_flat, 0, T - 2).reshape(B, L)
+    t_left = t_eval[indices]
+    t_right = t_eval[indices + 1]
+    batch_indices = torch.arange(B, device=t_eval.device).unsqueeze(1).expand(-1, L)
+    traj_left = traj[indices, batch_indices, :]
+    traj_right = traj[indices + 1, batch_indices, :]
+    weight = ((t_query - t_left) / (t_right - t_left + 1e-8)).unsqueeze(-1)
+    interp = traj_left + weight * (traj_right - traj_left)
+    return interp
+
+
+def interpolate_external_input(t_eval, t_batch, ut_batch, external_input_dim):
+    """
+    Interpolate external input at t_eval times using existing interpolate_trajectory function.
+    
+    Args:
+        t_eval: [T] evaluation times
+        t_batch: [B, L] relative time batches (not used, for API consistency)
+        ut_batch: [B, L_u, U+1] external input batch with time as last dimension
+        external_input_dim: dimension of external input
+    
+    Returns:
+        u_interp: [T, B, U] interpolated external inputs
+    """
+    if ut_batch is None or external_input_dim == 0:
+        return None
+    
+    u_batch = ut_batch[:, :, :external_input_dim]  # [B, L_u, U]
+    t_u_batch = ut_batch[:, :, external_input_dim]  # [B, L_u]
+    
+    B, L_u, U = u_batch.shape
+    T = len(t_eval)
+    
+    # 简单粗暴：用第一个batch的时间网格，假设所有batch时间一致
+    t_u = t_u_batch[0, :] - t_batch[0]  # [L_u] 
+    t_query = t_eval.unsqueeze(0).expand(B, -1)  # [B, T]
+    traj = u_batch.permute(1, 0, 2)  # [L_u, B, U]
+    
+    # 直接调用 interpolate_trajectory
+    result = interpolate_trajectory(t_u, t_query, traj)  # [B, T, U]
+    
+    # 转置成需要的格式 [T, B, U]
+    return result.permute(1, 0, 2)
+
+
+def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
+    """
+    Universal wrapper to add external input to any vector field.
+    
+    Args:
+        base_vector_field: Original vector field function
+        u_interp: [T, B, U] interpolated external inputs (None if no external input)
+        t_eval: [T] evaluation times
+    
+    Returns:
+        Enhanced vector field function that includes external input
+    """
+    if u_interp is None:
+        return base_vector_field
+    
+    def vector_field_with_input(t, state):
+        t_idx = torch.searchsorted(t_eval, t, right=False)
+        t_idx = torch.clamp(t_idx, 0, len(t_eval) - 1)
+        u_t = u_interp[t_idx, :, :]  # [B, U]
+        return base_vector_field(t, state, u_t)
+    
+    return vector_field_with_input
+
+class VectorFieldWithInput(nn.Module):
+    def __init__(self, base_vector_field: nn.Module, u_interp, t_eval):
+        """
+        base_vector_field: nn.Module, takes (t, state, u_t) and outputs dx/dt
+        u_interp: [T, B, U] external inputs sampled on t_eval (None if no input)
+        t_eval: [T] monotonically nondecreasing time grid corresponding to u_interp
+        """
+        super().__init__()
+        self.base_vector_field = base_vector_field
+        self.register_buffer("t_eval", t_eval)    # 注册成 buffer, 会跟随 device 移动
+        if u_interp is not None:
+            self.register_buffer("u_interp", u_interp)
+        else:
+            self.u_interp = None
+
+    def forward(self, t, state):
+        if self.u_interp is None:
+            # 无外部输入，保持三输入形式
+            return self.base_vector_field(t, state)
+
+        T = self.t_eval.shape[0]
+        t_scalar = torch.as_tensor(t, dtype=self.t_eval.dtype, device=self.t_eval.device)
+
+        # Clamp to endpoints
+        if t_scalar <= self.t_eval[0]:
+            u_t = self.u_interp[0, :, :]  # [B, U]
+        elif t_scalar >= self.t_eval[-1]:
+            u_t = self.u_interp[-1, :, :]
+        else:
+            idx_right = torch.searchsorted(self.t_eval, t_scalar, right=False)
+            idx_right = torch.clamp(idx_right, 1, T - 1)
+            idx_left = idx_right - 1
+
+            t_left = self.t_eval[idx_left]
+            t_right = self.t_eval[idx_right]
+
+            u_left = self.u_interp[idx_left, :, :]
+            u_right = self.u_interp[idx_right, :, :]
+
+            w = (t_scalar - t_left) / (t_right - t_left + 1e-8)
+            u_t = u_left + w * (u_right - u_left)
+
+        # 传给原始 vector field（恢复三参数形式，不再拼接）
+        return self.base_vector_field(t, state, u_t)
+
+
+def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
+    return VectorFieldWithInput(base_vector_field, u_interp, t_eval)
+
+# def create_vector_field_with_external_input(base_vector_field, u_interp, t_eval):
+#     """
+#     Wrap a vector field to inject time-varying external input u(t) via linear interpolation.
+
+#     Args:
+#         base_vector_field: callable(t, state, u_t) -> dx/dt
+#         u_interp: [T, B, U] external inputs sampled on t_eval (None if no input)
+#         t_eval: [T] monotonically nondecreasing time grid corresponding to u_interp
+
+#     Returns:
+#         vector_field_with_input(t, state): calls base_vector_field with linearly
+#         interpolated u(t) aligned to t_eval.
+#     """
+#     if u_interp is None:
+#         return base_vector_field
+
+#     T = t_eval.shape[0]
+
+#     def vector_field_with_input(t, state):
+#         # Ensure t is a tensor on the same device/dtype as t_eval
+#         t_scalar = torch.as_tensor(t, dtype=t_eval.dtype, device=t_eval.device)
+
+#         # Clamp to endpoints: constant extension outside [t_eval[0], t_eval[-1]]
+#         if t_scalar <= t_eval[0]:
+#             u_t = u_interp[0, :, :]  # [B, U]
+#         elif t_scalar >= t_eval[-1]:
+#             u_t = u_interp[-1, :, :]  # [B, U]
+#         else:
+#             # Find the right interval [t_left, t_right] with t_left <= t < t_right
+#             idx_right = torch.searchsorted(t_eval, t_scalar, right=False)
+#             # Guarantee we have both neighbors
+#             idx_right = torch.clamp(idx_right, 1, T - 1)
+#             idx_left = idx_right - 1
+
+#             t_left = t_eval[idx_left]
+#             t_right = t_eval[idx_right]
+
+#             u_left = u_interp[idx_left, :, :]  # [B, U]
+#             u_right = u_interp[idx_right, :, :]  # [B, U]
+
+#             # Linear interpolation weight in [0,1]
+#             w = (t_scalar - t_left) / (t_right - t_left + 1e-8)
+
+#             # Linear interpolation of u(t)
+#             u_t = u_left + w * (u_right - u_left)  # [B, U]
+
+#         # Call the original vector field with interpolated control
+#         return base_vector_field(t, state, u_t)
+
+#     return vector_field_with_input

mppi/mppi/mppi.py

@@ -0,0 +1,362 @@
+import logging
+import time
+import typing
+
+import torch
+from torch.distributions.multivariate_normal import MultivariateNormal
+from arm_pytorch_utilities import handle_batch_input
+from functorch import vmap
+
+logger = logging.getLogger(__name__)
+
+
+def _ensure_non_zero(cost, beta, factor):
+    return torch.exp(-factor * (cost - beta))
+
+
+class SpecificActionSampler:
+    def __init__(self):
+        self.start_idx = 0
+        self.end_idx = 0
+        self.slice = slice(0, 0)
+
+    def sample_trajectories(self, state, info):
+        raise NotImplementedError
+
+    def specific_dynamics(self, next_state, state, action, t):
+        """Handle dynamics in a specific way for the specific action sampler; defaults to using default dynamics"""
+        return next_state
+
+    def register_sample_start_end(self, start_idx, end_idx):
+        self.start_idx = start_idx
+        self.end_idx = end_idx
+        self.slice = slice(start_idx, end_idx)
+
+class MPPI():
+    """
+    Model Predictive Path Integral control
+    This implementation batch samples the trajectories and so scales well with the number of samples K.
+
+    Implemented according to algorithm 2 in Williams et al., 2017
+    'Information Theoretic MPC for Model-Based Reinforcement Learning',
+    based off of https://github.com/ferreirafabio/mppi_pendulum
+    """
+
+    def __init__(self, dynamics, running_cost, nx, noise_sigma, num_samples=100, horizon=15, device="cpu",
+                 terminal_state_cost=None,
+                 lambda_=1.,
+                 noise_mu=None,
+                 u_min=None,
+                 u_max=None,
+                 u_init=None,
+                 U_init=None,
+                 u_scale=1,
+                 u_per_command=1,
+                 step_dependent_dynamics=False,
+                 rollout_samples=1,
+                 rollout_var_cost=0,
+                 rollout_var_discount=0.95,
+                 sample_null_action=False,
+                 specific_action_sampler: typing.Optional[SpecificActionSampler] = None,
+                 noise_abs_cost=False):
+        """
+        :param dynamics: function(state, action) -> next_state (K x nx) taking in batch state (K x nx) and action (K x nu)
+        :param running_cost: function(state, action) -> cost (K) taking in batch state and action (same as dynamics)
+        :param nx: state dimension
+        :param noise_sigma: (nu x nu) control noise covariance (assume v_t ~ N(u_t, noise_sigma))
+        :param num_samples: K, number of trajectories to sample
+        :param horizon: T, length of each trajectory
+        :param device: pytorch device
+        :param terminal_state_cost: function(state) -> cost (K x 1) taking in batch state
+        :param lambda_: temperature, positive scalar where larger values will allow more exploration
+        :param noise_mu: (nu) control noise mean (used to bias control samples); defaults to zero mean
+        :param u_min: (nu) minimum values for each dimension of control to pass into dynamics
+        :param u_max: (nu) maximum values for each dimension of control to pass into dynamics
+        :param u_init: (nu) what to initialize new end of trajectory control to be; defeaults to zero
+        :param U_init: (T x nu) initial control sequence; defaults to noise
+        :param step_dependent_dynamics: whether the passed in dynamics needs horizon step passed in (as 3rd arg)
+        :param rollout_samples: M, number of state trajectories to rollout for each control trajectory
+            (should be 1 for deterministic dynamics and more for models that output a distribution)
+        :param rollout_var_cost: Cost attached to the variance of costs across trajectory rollouts
+        :param rollout_var_discount: Discount of variance cost over control horizon
+        :param sample_null_action: Whether to explicitly sample a null action (bad for starting in a local minima)
+        :param specific_action_sampler: Function to explicitly sample actions to use instead of sampling from noise from
+            nominal trajectory, may output a number of action trajectories fewer than horizon
+        :param noise_abs_cost: Whether to use the absolute value of the action noise to avoid bias when all states have the same cost
+        """
+        self.d = device
+        self.dtype = noise_sigma.dtype
+        self.K = num_samples  # N_SAMPLES
+        self.T = horizon  # TIMESTEPS
+
+        # dimensions of state and control
+        self.nx = nx
+        self.nu = 1 if len(noise_sigma.shape) == 0 else noise_sigma.shape[0]
+        self.lambda_ = lambda_
+
+        if noise_mu is None:
+            noise_mu = torch.zeros(self.nu, dtype=self.dtype)
+
+        if u_init is None:
+            u_init = torch.zeros_like(noise_mu)
+
+        # handle 1D edge case
+        if self.nu == 1:
+            noise_mu = noise_mu.view(-1)
+            noise_sigma = noise_sigma.view(-1, 1)
+
+        # bounds
+        self.u_min = u_min
+        self.u_max = u_max
+        self.u_scale = u_scale
+        self.u_per_command = u_per_command
+        # make sure if any of them is specified, both are specified
+        if self.u_max is not None and self.u_min is None:
+            if not torch.is_tensor(self.u_max):
+                self.u_max = torch.tensor(self.u_max)
+            self.u_min = -self.u_max
+        if self.u_min is not None and self.u_max is None:
+            if not torch.is_tensor(self.u_min):
+                self.u_min = torch.tensor(self.u_min)
+            self.u_max = -self.u_min
+        if self.u_min is not None:
+            self.u_min = self.u_min.to(device=self.d)
+            self.u_max = self.u_max.to(device=self.d)
+
+        self.noise_mu = noise_mu.to(self.d)
+        self.noise_sigma = noise_sigma.to(self.d)
+        self.noise_sigma_inv = torch.inverse(self.noise_sigma)
+        self.noise_dist = MultivariateNormal(self.noise_mu, covariance_matrix=self.noise_sigma)
+        # T x nu control sequence
+        self.U = U_init
+        self.u_init = u_init.to(self.d)
+
+        if self.U is None:
+            self.U = self.noise_dist.sample((self.T,))
+
+        self.step_dependency = step_dependent_dynamics
+        self.F = dynamics
+        self.running_cost = running_cost
+        self.terminal_state_cost = terminal_state_cost
+        self.sample_null_action = sample_null_action
+        self.specific_action_sampler = specific_action_sampler
+        self.noise_abs_cost = noise_abs_cost
+        self.state = None
+        self.info = None
+
+        # handling dynamics models that output a distribution (take multiple trajectory samples)
+        self.M = rollout_samples
+        self.rollout_var_cost = rollout_var_cost
+        self.rollout_var_discount = rollout_var_discount
+
+        # sampled results from last command
+        self.cost_total = None
+        self.cost_total_non_zero = None
+        self.omega = None
+        self.states = None
+        self.actions = None
+
+    def get_params(self):
+        return f"K={self.K} T={self.T} M={self.M} lambda={self.lambda_} noise_mu={self.noise_mu.cpu().numpy()} noise_sigma={self.noise_sigma.cpu().numpy()}".replace(
+            "\n", ",")
+
+    @handle_batch_input(n=2)
+    def _dynamics(self, state, u, t):
+        return self.F(state, u, t) if self.step_dependency else self.F(state, u)
+
+    @handle_batch_input(n=2)
+    def _running_cost(self, state, u, t):
+        return self.running_cost(state, u, t) if self.step_dependency else self.running_cost(state, u)
+
+    def get_action_sequence(self):
+        return self.U
+
+    def shift_nominal_trajectory(self):
+        """
+        Shift the nominal trajectory forward one step
+        """
+        # shift command 1 time step
+        self.U = torch.roll(self.U, -1, dims=0)
+        self.U[-1] = self.u_init
+
+    def command(self, state, shift_nominal_trajectory=True, info=None):
+        """
+        :param state: (nx) or (K x nx) current state, or samples of states (for propagating a distribution of states)
+        :param shift_nominal_trajectory: Whether to roll the nominal trajectory forward one step. This should be True
+            if the command is to be executed. If the nominal trajectory is to be refined then it should be False.
+        :param info: Optional dictionary to store context information
+        :returns action: (nu) best action
+        """
+        self.info = info
+        if shift_nominal_trajectory:
+            self.shift_nominal_trajectory()
+
+        return self._command(state)
+
+    def _compute_weighting(self, cost_total):
+        beta = torch.min(cost_total)
+        self.cost_total_non_zero = _ensure_non_zero(cost_total, beta, 1 / self.lambda_)
+        eta = torch.sum(self.cost_total_non_zero)
+        self.omega = (1. / eta) * self.cost_total_non_zero
+        return self.omega
+
+    def _command(self, state):
+        if not torch.is_tensor(state):
+            state = torch.tensor(state)
+        self.state = state.to(dtype=self.dtype, device=self.d)
+        cost_total = self._compute_total_cost_batch()
+
+        self._compute_weighting(cost_total)
+        perturbations = torch.sum(self.omega.view(-1, 1, 1) * self.noise, dim=0)
+
+        self.U = self.U + perturbations
+        action = self.get_action_sequence()[:self.u_per_command]
+        # reduce dimensionality if we only need the first command
+        if self.u_per_command == 1:
+            action = action[0]
+        return action
+
+    def change_horizon(self, horizon):
+        if horizon < self.U.shape[0]:
+            # truncate trajectory
+            self.U = self.U[:horizon]
+        elif horizon > self.U.shape[0]:
+            # extend with u_init
+            self.U = torch.cat((self.U, self.u_init.repeat(horizon - self.U.shape[0], 1)))
+        self.T = horizon
+
+    def reset(self):
+        """
+        Clear controller state after finishing a trial
+        """
+        self.U = self.noise_dist.sample((self.T,))
+
+    def _compute_rollout_costs(self, perturbed_actions):
+        K, T, nu = perturbed_actions.shape
+        assert nu == self.nu
+
+        cost_total = torch.zeros(K, device=self.d, dtype=self.dtype)
+        cost_samples = cost_total.repeat(self.M, 1)
+        cost_var = torch.zeros_like(cost_total)
+
+        # allow propagation of a sample of states (ex. to carry a distribution), or to start with a single state
+        if self.state.shape == (K, self.nx):
+            state = self.state
+        else:
+            state = self.state.view(1, -1).repeat(K, 1)
+
+        # rollout action trajectory M times to estimate expected cost
+        state = state.repeat(self.M, 1, 1)
+
+        states = []
+        actions = []
+        for t in range(T):
+            u = self.u_scale * perturbed_actions[:, t].repeat(self.M, 1, 1)
+            next_state = self._dynamics(state, u, t)
+            # potentially handle dynamics in a specific way for the specific action sampler
+            next_state = self._sample_specific_dynamics(next_state, state, u, t)
+            state = next_state
+            c = self._running_cost(state, u, t)
+            cost_samples = cost_samples + c
+            if self.M > 1:
+                cost_var += c.var(dim=0) * (self.rollout_var_discount ** t)
+
+            # Save total states/actions
+            states.append(state)
+            actions.append(u)
+
+        # Actions is K x T x nu
+        # States is K x T x nx
+        actions = torch.stack(actions, dim=-2)
+        states = torch.stack(states, dim=-2)
+
+        # action perturbation cost
+        if self.terminal_state_cost:
+            c = self.terminal_state_cost(states, actions)
+            cost_samples = cost_samples + c
+        cost_total = cost_total + cost_samples.mean(dim=0)
+        cost_total = cost_total + cost_var * self.rollout_var_cost
+        return cost_total, states, actions
+
+    def _compute_perturbed_action_and_noise(self):
+        # parallelize sampling across trajectories
+        # resample noise each time we take an action
+        noise = self.noise_dist.rsample((self.K, self.T))
+        # broadcast own control to noise over samples; now it's K x T x nu
+        perturbed_action = self.U + noise
+        perturbed_action = self._sample_specific_actions(perturbed_action)
+        # naively bound control
+        self.perturbed_action = self._bound_action(perturbed_action)
+        # bounded noise after bounding (some got cut off, so we don't penalize that in action cost)
+        self.noise = self.perturbed_action - self.U
+
+    def _sample_specific_actions(self, perturbed_action):
+        # specific sampling of actions (encoding trajectory prior and domain knowledge to create biases)
+        i = 0
+        if self.sample_null_action:
+            perturbed_action[i] = 0
+            i += 1
+        if self.specific_action_sampler is not None:
+            actions = self.specific_action_sampler.sample_trajectories(self.state, self.info)
+            # check how long it is
+            actions = actions.reshape(-1, self.T, self.nu)
+            perturbed_action[i:i + actions.shape[0]] = actions
+            self.specific_action_sampler.register_sample_start_end(i, i + actions.shape[0])
+            i += actions.shape[0]
+        return perturbed_action
+
+    def _sample_specific_dynamics(self, next_state, state, u, t):
+        if self.specific_action_sampler is not None:
+            next_state = self.specific_action_sampler.specific_dynamics(next_state, state, u, t)
+        return next_state
+
+    def _compute_total_cost_batch(self):
+        self._compute_perturbed_action_and_noise()
+        if self.noise_abs_cost:
+            action_cost = self.lambda_ * torch.abs(self.noise) @ self.noise_sigma_inv
+            # NOTE: The original paper does self.lambda_ * torch.abs(self.noise) @ self.noise_sigma_inv, but this biases
+            # the actions with low noise if all states have the same cost. With abs(noise) we prefer actions close to the
+            # nomial trajectory.
+        else:
+            action_cost = self.lambda_ * self.noise @ self.noise_sigma_inv  # Like original paper
+
+        rollout_cost, self.states, actions = self._compute_rollout_costs(self.perturbed_action)
+        self.actions = actions / self.u_scale
+
+        # action perturbation cost
+        perturbation_cost = torch.sum(self.U * action_cost, dim=(1, 2))
+        self.cost_total = rollout_cost + perturbation_cost
+        return self.cost_total
+
+    def _bound_action(self, action):
+        if self.u_max is not None:
+            return torch.max(torch.min(action, self.u_max), self.u_min)
+        return action
+
+    def _slice_control(self, t):
+        return slice(t * self.nu, (t + 1) * self.nu)
+
+    def get_rollouts(self, state, num_rollouts=1, U=None):
+        """
+            :param state: either (nx) vector or (num_rollouts x nx) for sampled initial states
+            :param num_rollouts: Number of rollouts with same action sequence - for generating samples with stochastic
+                                 dynamics
+            :returns states: num_rollouts x T x nx vector of trajectories
+
+        """
+        state = state.view(-1, self.nx)
+        if state.size(0) == 1:
+            state = state.repeat(num_rollouts, 1)
+
+        if U is None:
+            U = self.get_action_sequence()
+        T = U.shape[0]
+        states = torch.zeros((num_rollouts, T + 1, self.nx), dtype=U.dtype, device=U.device)
+        states[:, 0] = state
+        for t in range(T):
+            next_state = self._dynamics(states[:, t].view(num_rollouts, -1),
+                                        self.u_scale * U[t].tile(num_rollouts, 1), t)
+            # dynamics may augment state; here we just take the first nx dimensions
+            states[:, t + 1] = next_state[:, :self.nx]
+
+        return states[:, 1:]

mppi/task/bb_track.py

@@ -0,0 +1,198 @@
+# Author: Hang
+# Date: 2025-09-20
+# Description: This file contains the implementation of the ball tracking task with MPPI and learned hybrid dynamics model.
+
+import mujoco
+import numpy as np
+import argparse
+from typing import Optional, Tuple, Dict, Any
+import time
+import os
+from datetime import datetime
+from dataclasses import dataclass
+from scipy.spatial.transform import Rotation as R
+from tqdm import tqdm
+import pickle
+import yaml
+import torch
+import glob
+
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
+from bb_collect import PingPongEnv, PingPongDummyController, Config
+# from mppi.mppi import MPPI
+from models import create_model, interpolate_trajectory
+
+class NeuralHybridDynamics:
+    def __init__(self, weights_dir: str, device: str = "cpu"):
+        self.weights_dir = weights_dir
+        self.device = device
+        self.config = None
+        self.model = None
+        self.checkpoint = None
+        self.load_checkpoint()
+        self.load_config()
+        self.load_weights()
+
+    def load_checkpoint(self):
+        """Load the checkpoint with the largest step number from checkpoint_step_*.pth"""
+        search_dirs = [self.weights_dir, os.path.join(self.weights_dir, "files")]
+        checkpoint_files = []
+        for search_dir in search_dirs:
+            if os.path.exists(search_dir):
+                checkpoint_files.extend(glob.glob(os.path.join(search_dir, "best_model_step_*.pth")))
+                checkpoint_files.extend(glob.glob(os.path.join(search_dir, "checkpoint_step_*.pth")))
+        if not checkpoint_files:
+            raise FileNotFoundError("No checkpoint files found")
+
+        def extract_step(path):
+            name = os.path.basename(path)
+            if name.startswith("checkpoint_step_"):
+                core = name[len("checkpoint_step_"):]
+                core = core.split('.')[0]
+                # handle accidental trailing underscores: checkpoint_step_123_.pth
+                core = core.strip('_')
+                try:
+                    return int(core)
+                except ValueError:
+                    return -1
+            return -1
+
+        # Prefer checkpoint_step_* files; fall back to previous heuristic if none
+        ckpt_step_files = [f for f in checkpoint_files if os.path.basename(f).startswith("checkpoint_step_")]
+        if ckpt_step_files:
+            checkpoint_path = max(ckpt_step_files, key=extract_step)
+        else:
+            # fallback: pick latest by sort (previous behavior)
+            checkpoint_files.sort()
+            checkpoint_path = checkpoint_files[-1]
+
+        self.checkpoint = torch.load(checkpoint_path, map_location=self.device, weights_only=False)
+        print(f"\nCheckpoint from step {self.checkpoint.get('step', 'unknown')}")
+
+
+    def load_config(self):
+        """Load ALL parameters from files/config.yaml (no selective picking)."""
+
+        config_path = os.path.join(self.weights_dir, "config.yaml")
+
+        if not os.path.exists(config_path):
+            raise FileNotFoundError(f"config.yaml not found at {config_path}")
+        with open(config_path, "r") as f:
+            raw = yaml.safe_load(f)
+
+        flat = {}
+        for k, v in raw.items():
+            if isinstance(v, dict) and 'value' in v and len(v) == 1:
+                flat[k] = v['value']
+            else:
+                flat[k] = v
+        # Use ALL flattened keys directly as model config
+        config = dict(flat)
+        
+        self.config = config
+        print(f"\nLoaded config from {config_path}")
+        
+    
+    def load_weights(self):
+        """Create and load the hybrid model (optionally using provided config)"""
+        # Create model
+        self.model = create_model('hybrid', self.config, self.device)
+        
+        # Load weights with shape checking
+        def safe_load_state_dict(module, state_dict, name):
+            """Load state dict with shape mismatch handling"""
+            current_state = module.state_dict()
+            filtered_state = {}
+            
+            for key, value in state_dict.items():
+                if key in current_state:
+                    if current_state[key].shape == value.shape:
+                        filtered_state[key] = value
+                    else:
+                        print(f"  Shape mismatch in {name}.{key}: "
+                              f"expected {current_state[key].shape}, got {value.shape}")
+            
+            module.load_state_dict(filtered_state, strict=False)
+            print(f"Loaded {len(filtered_state)}/{len(state_dict)} parameters for {name}")
+        
+        # Load each component (guarded)
+        if hasattr(self.model, 'encoder') and (self.model.encoder is not None) and ('encoder' in self.checkpoint):
+            safe_load_state_dict(self.model.encoder, self.checkpoint['encoder'], 'encoder')
+        else:
+            print("Skip loading encoder: missing in model or checkpoint")
+        
+        if hasattr(self.model, 'decoder') and (getattr(self.model, 'decoder', None) is not None) and ('decoder' in self.checkpoint):
+            safe_load_state_dict(self.model.decoder, self.checkpoint['decoder'], 'decoder')
+        else:
+            print("Skip loading decoder: missing in model or checkpoint")
+        
+        if hasattr(self.model, 'vector_field') and (getattr(self.model, 'vector_field', None) is not None) and ('vector_field' in self.checkpoint):
+            safe_load_state_dict(self.model.vector_field, self.checkpoint['vector_field'], 'vector_field')
+        else:
+            print("Skip loading vector_field: missing in model or checkpoint")
+        
+        self.model.eval()
+        print("Model loaded successfully")
+        
+
+
+class BBTrack:
+    def __init__(self, env: PingPongEnv):
+
+        self.parser = self.parse_bb_track_args()
+
+        # self.env = env
+        self.controller = None
+        self.dynamics = NeuralHybridDynamics(self.parser.weights_dir)        
+
+    def parse_bb_track_args(self):
+        """Parse command line arguments for data collection"""
+        parser = argparse.ArgumentParser(description="Collect bouncing ball dataset")
+        parser.add_argument("--steps", type=int, default=1000, help="Steps to run")
+        parser.add_argument("--realtime", action="store_true", help="Match simulation speed to real time")
+        parser.add_argument("--seed", type=int, default=42, help="Random seed")
+        parser.add_argument("--headless", action="store_true", help="Run in headless mode (no rendering)")
+        parser.add_argument("--weights_dir", type=str, default="/home/lau/sim/DynaTraj/logs/run-20250920_075505-k227j0rs", help="absolute path to the weights directory")
+        
+        return parser.parse_args()
+
+    def load_dynamics(self):
+        self.dynamics = NeuralHybridDynamics(self.parser.weights_dir)
+
+
+    def run(self):
+        args = self.parser
+        # Set random seed
+        np.random.seed(args.seed)
+        config = Config()
+        env = PingPongEnv(headless=args.headless, config=config)
+        controller = PingPongDummyController(config=config)
+        
+        # Reset environment and controller
+        obs = env.reset()
+        controller.reset_controller()
+        
+        # Run simulation for 1000 steps
+        for step in range(1000):
+            # Get action from ball_response controller
+            action = controller.get_ball_response_action(env)
+            
+            obs, reward, done, info = env.step(action)
+            
+            if not args.headless:
+                # Render every frame for smooth visualization
+                env.render()
+            if args.realtime:
+                time.sleep(env.model.opt.timestep)
+            if done:
+                obs = env.reset()  # Auto-reset if done
+                controller.reset_controller()  # Reset controller state
+        
+        print("Demo simulation completed")
+        
+
+if __name__ == "__main__":
+    bb_track = BBTrack(env=None)