UPDATE: traj visualize, sin cost

mppi/mppi/mppi.py

@@ -155,7 +155,7 @@ class MPPIController:
                     # Subsequent iterations: add smaller perturbations around current mean
                     torch.randn(self.horizon, self.num_samples, self.action_dim, 
                               device=self.device, out=self._noise_buffer)
-                    self._noise_buffer *= 0.5
+                    self._noise_buffer *= 0.9
                 
                 # Compute actions_sample in-place
                 torch.addcmul(mean.unsqueeze(1), self._iteration_std_buffer.unsqueeze(1), 

mppi/task/bb1d_track.py

@@ -102,7 +102,8 @@ class NeuralHybridDynamics:
     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)
+        self.model_type = self.config['model_type']
+        self.model = create_model(self.model_type, self.config, self.device)
         
         # Load weights with shape checking
         def safe_load_state_dict(module, state_dict, name):
@@ -119,17 +120,19 @@ class NeuralHybridDynamics:
                               f"expected {current_state[key].shape}, got {value.shape}")
             
             module.load_state_dict(filtered_state, strict=False)
+
+        if self.model_type == 'hybrid':
         
-        # 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:
-            raise ValueError("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:
-            raise ValueError("Skip loading decoder: missing in model or checkpoint")
+            # 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:
+                raise ValueError("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:
+                raise ValueError("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')
@@ -175,8 +178,9 @@ class NeuralHybridDynamics:
 
         t_eval = out.get('t_eval', t_batch)        # [B, Te] or [Te]
         x_traj = out['x_trajectory']               # [B, Te, Dx]
-        z_traj_raw = out['z_trajectory']               # [Te, B, latent_dim] -> [20, 512, 4]
-        self.z_traj = z_traj_raw.permute(1, 0, 2)      # Convert to [B, Te, latent_dim] -> [512, 20, 4] 
+        if self.model_type == 'hybrid':
+            z_traj_raw = out['z_trajectory']               # [Te, B, latent_dim] -> [20, 512, 4]
+            self.z_traj = z_traj_raw.permute(1, 0, 2)      # Convert to [B, Te, latent_dim] -> [512, 20, 4] 
 
         # 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]
@@ -217,14 +221,14 @@ class BBTrack:
         self.horizon = 20
         self.iterations = 10
         self.state_dims = 4
-        self.num_samples = 256
+        self.num_samples = 512
         self.num_elites = 16
         self.device = "cuda:0"
         self.current_simulation_time = 0 
         # Objective
-        self.omega = 2
-        self.amplitude = 1
-        self.offset = 0.8
+        self.omega = 5
+        self.amplitude = 0.4
+        self.offset = 0.6
         self.latent_cost = True
         np.random.seed(self.parser.seed)
 
@@ -232,6 +236,9 @@ class BBTrack:
         self.env_config = Config()
         self.env = PingPongEnv(headless=self.parser.headless, config=self.env_config)
         
+        # Add target visualization
+        self.setup_target_visualization()
+        
         print("\n=======Loading Dynamics=======")
         self.dynamics = NeuralHybridDynamics(self.parser.weights_dir, self.control_dt, self.horizon, self.device)      
 
@@ -255,44 +262,76 @@ class BBTrack:
     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=8000, help="Steps to run")
+        parser.add_argument("--steps", type=int, default=16000, 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-20250923_164030-16e9sup5", help="absolute path to the weights directory") # ode
         parser.add_argument("--weights_dir", type=str, default="/home/lau/sim/DynaTraj/logs/run-20250923_060650-u2cujbdh", help="absolute path to the weights directory")
+
         
         return parser.parse_args()
 
 
+    # def cost_function(self, state, action):
+
+
+    #     if not self.latent_cost:
+        
+    #         # Extract ball position from state (first 3 dimensions)
+    #         ball_pos = state[..., 0]  # [batch, 3] or [batch, horizon, 3]
+    #         ball_vel = state[..., 1]
+    #         board_pos = state[..., 2]
+    #         board_vel = state[..., 3]
+
+            
+    #         target_state = state.clone()
+    #         target_state[..., 0] = torch.ones_like(target_state[..., 0]) * self.offset
+    #         target_state[..., 1] = torch.ones_like(target_state[..., 1]) * 0
+    #         target_state[..., 2] = torch.ones_like(target_state[..., 2]) * self.offset
+    #         target_state[..., 3] = torch.ones_like(target_state[..., 3]) * 0
+
+            
+    #         # Calculate target trajectory for each time step in horizon
+    #         # batch_size, horizon_len = ball_pos.shape[:2]
+    #         # time_steps = torch.arange(horizon_len, dtype=torch.float32, device=ball_pos.device)
+    #         # future_times = self.current_simulation_time + time_steps * self.control_dt
+    #         # target_z = torch.abs(torch.sin(self.omega * future_times)) * self.amplitude + self.offset  # [horizon]
+    #         # target_z = target_z.unsqueeze(0).expand(batch_size, -1)  # [batch, horizon]
+
+    #         # target_z = torch.ones_like(target_z) * self.offset
+            
+    #         # Tracking cost - quadratic penalty for deviation from target
+    #         cost = torch.sum((target_state - state) ** 2, dim=-1)
+
+    #         return cost
+
+    #     if self.latent_cost:
+    #         ball_pos = state[..., 0]  # [batch, horizon]
+    #         ball_vel = state[..., 1]
+    #         board_pos = state[..., 2]
+    #         board_vel = state[..., 3]
+
+    #         # Create target state for each time step
+    #         target_state = state.clone()
+    #         target_state[..., 0] = torch.ones_like(target_state[..., 0]) * self.offset
+    #         target_state[..., 1] = torch.ones_like(target_state[..., 1]) * 0
+    #         target_state[..., 2] = torch.ones_like(target_state[..., 2]) * self.offset
+    #         target_state[..., 3] = torch.ones_like(target_state[..., 3]) * 0
+
+    #         # Batch encode target states directly
+    #         target_z_traj = self.dynamics.encode_state(target_state)  # [batch, horizon, latent_dim]
+    #         current_z_traj = self.dynamics.z_traj  # [batch, horizon, latent_dim]
+            
+    #         # Compute cost: [batch, horizon]
+    #         cost = torch.sum((target_z_traj - current_z_traj) ** 2, dim=-1)
+            
+    #         return cost
+
+
+
     def cost_function(self, state, action):
-        '''
-        cost function for bouncing ball tracking
-        Objective: ball should track a sin wave trajectory
-            x: 0
-            y: 0
-            z: abs(sin(t))
-        Other cost:
-            board velocity(x,y,z,wx,wy,wz) as control input should be small
-        Input:
-            state: [batch, horizon, state_dim]
-            action: [batch, horizon, action_dim]
-            t: in
-        Output:
-            cost: [batch, horizon]
-
-        STATE:
-            ball_pos,       # ball position (3)
-            ball_vel,       # ball velocity (3)
-            board_pos,      # board position (3)
-            board_euler,    # board euler angles (3)
-            board_vel,      # board velocity (3)
-            board_angvel    # board angular velocity (3)
-            ball_pos_relative,  # ball position relative to board (3) ball_pos - board_pos
-            ball_vel_relative,  # ball velocity relative to board (3) ball_vel - board_vel
-            board_euler,        # board euler angles (3)
-            board_vel,          # board velocity (3)
-            board_angvel        # board angular velocity (3)
-        '''
+
 
         if not self.latent_cost:
         
@@ -303,9 +342,8 @@ class BBTrack:
             board_vel = state[..., 3]
 
             
-            # Target trajectory: x=0, y=0, z=abs(sin(t))
-            target_x = 0.0
-            target_y = 0.0
+            target_state = state.clone()
+
             
             # Calculate target trajectory for each time step in horizon
             batch_size, horizon_len = ball_pos.shape[:2]
@@ -314,30 +352,17 @@ class BBTrack:
             target_z = torch.abs(torch.sin(self.omega * future_times)) * self.amplitude + self.offset  # [horizon]
             target_z = target_z.unsqueeze(0).expand(batch_size, -1)  # [batch, horizon]
 
-            target_z = torch.ones_like(target_z) * self.offset
+            target_state[..., 0] = target_z
+            target_state[..., 1] = torch.ones_like(target_state[..., 1]) * 0
+            target_state[..., 2] = torch.ones_like(target_state[..., 2]) * self.offset
+            target_state[..., 3] = torch.ones_like(target_state[..., 3]) * 0
 
-            # print("Decoded:zt:",ball_pos[0,0])
-            # print("target_z:",target_z[0,0])
+            # target_z = torch.ones_like(target_z) * self.offset
             
             # Tracking cost - quadratic penalty for deviation from target
-            pos_cost = (ball_pos - target_z) ** 2
-            vel_cost = (ball_vel) ** 2 + (board_vel) ** 2
-            # pos_cost = (board_pos - target_z) ** 2 *100 # TODO
-
-            
-            # Control cost - penalize large board velocities (action is 6D: vx,vy,vz,wx,wy,wz)
-            control_cost = torch.sum(action ** 2, dim=-1)
-            
-            # Combine costs with weights
-            tracking_weight = 10
-            vel_weight = 1
-            control_weight = 0
+            cost = torch.sum((target_state - state) ** 2, dim=-1)
 
-            total_cost = tracking_weight * pos_cost +\
-                            vel_weight * vel_cost +\
-                            control_weight * control_cost
-
-            return total_cost
+            return cost
 
         if self.latent_cost:
             ball_pos = state[..., 0]  # [batch, horizon]
@@ -347,7 +372,16 @@ class BBTrack:
 
             # Create target state for each time step
             target_state = state.clone()
-            target_state[..., 0] = torch.ones_like(target_state[..., 0]) * self.offset
+
+
+            # Calculate target trajectory for each time step in horizon
+            batch_size, horizon_len = ball_pos.shape[:2]
+            time_steps = torch.arange(horizon_len, dtype=torch.float32, device=ball_pos.device)
+            future_times = self.current_simulation_time + time_steps * self.control_dt
+            target_z = torch.abs(torch.sin(self.omega * future_times)) * self.amplitude + self.offset  # [horizon]
+            target_z = target_z.unsqueeze(0).expand(batch_size, -1)  # [batch, horizon]
+
+            target_state[..., 0] = target_z
             target_state[..., 1] = torch.ones_like(target_state[..., 1]) * 0
             target_state[..., 2] = torch.ones_like(target_state[..., 2]) * self.offset
             target_state[..., 3] = torch.ones_like(target_state[..., 3]) * 0
@@ -360,6 +394,87 @@ class BBTrack:
             cost = torch.sum((target_z_traj - current_z_traj) ** 2, dim=-1)
             
             return cost
+
+    def setup_target_visualization(self):
+        """Add a target sphere to the MuJoCo environment for visualization"""
+        if not self.parser.headless:
+            # Add a visual target sphere to the model as mocap body
+            target_xml = '''
+            <body name="target_sphere" pos="0 0 0.5" mocap="true">
+                <geom name="target_geom" type="sphere" size="0.03" 
+                      rgba="1 0 0 0.7" contype="0" conaffinity="0"/>
+            </body>
+            '''
+            
+            # Parse the existing model XML and add the target sphere
+            import xml.etree.ElementTree as ET
+            
+            # Get the current model XML string
+            model_xml = self.env.model_xml
+            
+            # Parse XML
+            root = ET.fromstring(model_xml)
+            worldbody = root.find('worldbody')
+            
+            # Parse and add the target sphere
+            target_element = ET.fromstring(target_xml)
+            worldbody.append(target_element)
+            
+            # Recreate the model with target sphere
+            new_xml = ET.tostring(root, encoding='unicode')
+            self.env.model = mujoco.MjModel.from_xml_string(new_xml)
+            self.env.data = mujoco.MjData(self.env.model)
+            
+            # Get the target body ID for updating position
+            self.target_body_id = mujoco.mj_name2id(self.env.model, mujoco.mjtObj.mjOBJ_BODY, "target_sphere")
+            
+            # Recreate the renderer/viewer with new model
+            if hasattr(self.env, 'viewer') and self.env.viewer is not None:
+                self.env.viewer.close()
+                try:
+                    import mujoco.viewer as mj_viewer
+                    self.env.viewer = mj_viewer.launch_passive(self.env.model, self.env.data)
+                except ImportError:
+                    pass
+            
+            if hasattr(self.env, 'renderer') and self.env.renderer is not None:
+                self.env.renderer.close()
+                self.env.renderer = mujoco.Renderer(self.env.model, 
+                                                   height=self.env_config.video_height, 
+                                                   width=self.env_config.video_width)
+
+    def update_target_visualization(self):
+        """Update the target sphere position based on current trajectory"""
+        if not self.parser.headless and hasattr(self, 'target_body_id'):
+            target_pos = self.vis_tar_traj(self.env)
+            
+            # Update target sphere position using mocap
+            if target_pos is not None:
+                target_pos_np = target_pos.cpu().numpy() if isinstance(target_pos, torch.Tensor) else target_pos
+                if target_pos_np.ndim > 1:
+                    target_pos_np = target_pos_np.flatten()[:3]
+                
+                # Use mocap to control the target sphere position
+                mocap_id = self.env.model.body_mocapid[self.target_body_id]
+                if mocap_id >= 0:
+                    self.env.data.mocap_pos[mocap_id] = target_pos_np[:3]
+                    # Debug: print every 50 steps to see if it's updating
+                    if hasattr(self, '_debug_counter'):
+                        self._debug_counter += 1
+                    else:
+                        self._debug_counter = 0
+                
+                else:
+                    print("Warning: Target sphere is not a mocap body")
+
+    def vis_tar_traj(self, env):
+        target_z = torch.abs(torch.sin(self.omega * torch.tensor(self.current_simulation_time,device=self.device))) * self.amplitude + self.offset
+        target_x = torch.ones_like(target_z) * 0
+        target_y = torch.ones_like(target_z) * 0
+        target_pos = torch.stack([target_x, target_y, target_z], dim=-1)
+        # visualize target trajectory
+        return target_pos
+
             
             
 
@@ -374,6 +489,9 @@ class BBTrack:
 
             # update simulation time
             self.current_simulation_time = self.env.data.time
+            
+            # Update target visualization
+            self.update_target_visualization()
 
             if step % (1/self.control_dt) == 0:
                 # Convert obs to torch tensor if needed
@@ -382,10 +500,10 @@ class BBTrack:
                 else:
                     obs_tensor = obs
 
-                print("Ball GT:zt:",obs_tensor[0,0])
-                print("Board GT:zt:",obs_tensor[0,2]) # TODO
+                # print("Ball GT:zt:",obs_tensor[0,0])
+                # print("Board GT:zt:",obs_tensor[0,2]) # TODO
                 target_z = torch.abs(torch.sin(self.omega * torch.tensor(self.current_simulation_time,device=self.device))) * self.amplitude + self.offset  # [horizon]
-                # print("target_z:",target_z)
+                # print("Ball Tar:zt::",target_z)
 
                 # Call the MPPI controller
                 action_tensor = self.controller._plan(obs_tensor, obs_tensor, t0=(step==0))