UPDATE: new ckpt

bb_collect.py

@@ -295,7 +295,7 @@ class PingPongEnv:
         obs = obs[:18] #
         obs[0:3] = obs[0:3] - obs[6:9] # board center
         obs[3:6] = obs[3:6] - obs[12:15] # board center
-        obs = obs[:12]
+        obs = obs[[0,1,2,3,4,5,9,10,11]]
 
 
         # Done condition: ball(x,y) out of [100,100] or z lower than board - 0.1m

logs/run-20250921_185254-bj8djt57/checkpoint_step_214000_20250922_004234.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:963ac1e8401512a982e6b1ef8307e05e29f723ebf84a1f4a6f5dbe9b1e037325
+size 1862585

logs/run-20250921_185254-bj8djt57/config.yaml

@@ -0,0 +1,248 @@
+_wandb:
+    value:
+        cli_version: 0.21.0
+        e:
+            cktml8c757zvaai93h400eufkxhuf5xi:
+                args:
+                    - --config
+                    - ICLR/config/bb6_reduced/bb6_switching_dim.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: "2417479077888"
+                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_reduced
+                startedAt: "2025-09-21T18:52:54.190585Z"
+                writerId: cktml8c757zvaai93h400eufkxhuf5xi
+        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: 2048
+data_path_test:
+    value: None
+data_path_train:
+    value: /home/sangliteng/Research/DynaTraj/dataset/bb/bb_ball_reduced_v2_not_normalized.npz
+decoder_batch_size:
+    value: 131072
+decoder_finetune_steps:
+    value: 200000
+decoder_lr:
+    value: 0.001
+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.001
+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: 9
+is_lagrangian_system:
+    value: true
+isometry_loss_weight:
+    value: 1
+latent_dim:
+    value: 18
+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 reduced - dim 9 unnormalized
+save_checkpoint_every:
+    value: 250
+smooth_budget:
+    value: 0.0001
+smooth_weight:
+    value: 0
+steps_per_length:
+    value: 2000
+switching_dim:
+    value:
+        - 0
+        - 1
+        - 2
+        - 3
+        - 4
+        - 5
+switching_threshold_scale:
+    value: 1.5
+switching_weight_multiplier:
+    value: 2
+test_info:
+    value: same profile as bb, much larger network, no isometry loss
+time_step:
+    value: 0.01
+train_test_ratio:
+    value: 0.95
+trajectory_lengths:
+    value:
+        - 10
+        - 20
+        - 40
+        - 80
+        - 150
+        - 200
+        - 200
+use_switching_weights:
+    value: true
+use_weight_smoothing:
+    value: false
+vector_field_lr:
+    value: 0.001
+viz_interval:
+    value: 50
+wandb_base_dir:
+    value: ./ICLR/bb6_reduced
+weight_smoothing_window:
+    value: 0
+z_continuity_weight:
+    value: 10

mppi/task/bb_track.py

@@ -26,66 +26,6 @@ from mppi.mppi.mppi import MPPIController
 from models import create_model, interpolate_trajectory
 
 
-def obs_normalize(obs):
-    """Normalize observations for network input"""
-    obs_mean = np.array([4.1115395e-06, 7.5212418e-05, 5.6337732e-01, -1.3034559e-04, 
-                        -6.7626464e-04, -9.7243134e-03, -1.0762236e-03, 8.8590048e-02, 
-                        5.4583937e-01, -5.2461156e-04, -1.1820005e-04, 4.9850909e-04])
-    obs_std = np.array([0.008502, 0.00853375, 0.6281913, 0.36238843, 0.36033645, 2.388929, 
-                        2.4867563, 2.5405889, 0.08288698, 0.05330177, 0.05352837, 0.05296409])
-
-    # Handle both numpy arrays and torch tensors
-    if isinstance(obs, torch.Tensor):
-        obs_mean = torch.tensor(obs_mean, device=obs.device, dtype=obs.dtype)
-        obs_std = torch.tensor(obs_std, device=obs.device, dtype=obs.dtype)
-    
-    obs_normalized = (obs - obs_mean) / obs_std
-    return obs_normalized
-
-def obs_denormalize(obs):
-    """Denormalize observations from network output"""
-    obs_mean = np.array([4.1115395e-06, 7.5212418e-05, 5.6337732e-01, -1.3034559e-04, 
-                        -6.7626464e-04, -9.7243134e-03, -1.0762236e-03, 8.8590048e-02, 
-                        5.4583937e-01, -5.2461156e-04, -1.1820005e-04, 4.9850909e-04])
-    obs_std = np.array([0.008502, 0.00853375, 0.6281913, 0.36238843, 0.36033645, 2.388929, 
-                        2.4867563, 2.5405889, 0.08288698, 0.05330177, 0.05352837, 0.05296409])
-
-    # Handle both numpy arrays and torch tensors
-    if isinstance(obs, torch.Tensor):
-        obs_mean = torch.tensor(obs_mean, device=obs.device, dtype=obs.dtype)
-        obs_std = torch.tensor(obs_std, device=obs.device, dtype=obs.dtype)
-    
-    obs_denormalized = obs * obs_std + obs_mean
-    return obs_denormalized
-
-def action_normalize(action):
-    """Normalize actions for network processing"""
-    action_mean = np.array([1.8646908e-03, 3.1277258e-02, 3.7151906e-01, 3.1675972e-04, 
-                            -1.5510405e-04, -7.3288589e-05])
-    action_std = np.array([1.2320997, 1.2293005, 3.7507675, 0.33227754, 0.33331886, 0.33228952])
-    
-    # Handle both numpy arrays and torch tensors
-    if isinstance(action, torch.Tensor):
-        action_mean = torch.tensor(action_mean, device=action.device, dtype=action.dtype)
-        action_std = torch.tensor(action_std, device=action.device, dtype=action.dtype)
-    
-    action_normalized = (action - action_mean) / action_std
-    return action_normalized
-
-def action_denormalize(action):
-    """Denormalize actions from network output"""
-    action_mean = np.array([1.8646908e-03, 3.1277258e-02, 3.7151906e-01, 3.1675972e-04, 
-                            -1.5510405e-04, -7.3288589e-05])
-    action_std = np.array([1.2320997, 1.2293005, 3.7507675, 0.33227754, 0.33331886, 0.33228952])
-    
-    # Handle both numpy arrays and torch tensors
-    if isinstance(action, torch.Tensor):
-        action_mean = torch.tensor(action_mean, device=action.device, dtype=action.dtype)
-        action_std = torch.tensor(action_std, device=action.device, dtype=action.dtype)
-    
-    action_denormalized = action * action_std + action_mean
-    return action_denormalized
-
 class NeuralHybridDynamics:
     def __init__(self, weights_dir: str, dt, horizon, device: str = "cpu"):
         self.weights_dir = weights_dir
@@ -213,8 +153,6 @@ class NeuralHybridDynamics:
         assert state0.ndim == 3 and state0.size(1) == 1, f"Expected x0 [B,1,Dx], got {tuple(state0.shape)}"
         assert action.ndim == 3 and action.size(1) == self.horizon, f"u time dim {action.size(1)} != horizon {self.horizon}"
 
-        state0 = obs_normalize(state0)
-        action = action_normalize(action)
 
 
         B, _, Dx = state0.shape
@@ -242,16 +180,15 @@ class NeuralHybridDynamics:
 
         # Interpolate from t_eval to our target sampling times
         x_pred = interpolate_trajectory(t_eval, t_batch - t_batch[:, :1], x_traj)  # [B, H, Dx]
-        x_pred = obs_denormalize(x_pred)
         return x_pred
 
 class BBTrack:
     def __init__(self):
         self.parser = self.parse_bb_track_args()
         self.control_dt = 1/50 # 50Hz
-        self.horizon = 50
+        self.horizon = 20
         self.iterations = 20
-        self.state_dims = 12
+        self.state_dims = 9
         self.num_samples = 100
         self.num_elites = 10
         self.device = "cuda:0"
@@ -294,7 +231,7 @@ class BBTrack:
         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_181129-yzvsgbbo", help="absolute path to the weights directory")
+        parser.add_argument("--weights_dir", type=str, default="/home/lau/sim/DynaTraj/logs/run-20250921_185254-bj8djt57", help="absolute path to the weights directory")
         
         return parser.parse_args()