FIX: gpu ram and control frequency

mppi/task/bb1d_track.py

@@ -122,7 +122,6 @@ class NeuralHybridDynamics:
             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')
@@ -174,13 +173,14 @@ class NeuralHybridDynamics:
         at_batch[:, 0, 0:-1] = action[:, 0, :]  # use only the first frame to init the encoder
 
         # Inference on the model's internal eval grid, then decode to x_trajectory
-        out = self.model.inference(xt_batch.to(torch.float32), at_batch.to(torch.float32), infer_x=True)
+        with torch.no_grad():
+            out = self.model.inference(xt_batch.to(torch.float32), at_batch.to(torch.float32), infer_x=True)
 
-        t_eval = out.get('t_eval', t_batch)        # [B, Te] or [Te]
-        x_traj = out['x_trajectory']               # [B, Te, Dx]
-        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] 
+            t_eval = out.get('t_eval', t_batch)        # [B, Te] or [Te]
+            x_traj = out['x_trajectory']               # [B, Te, Dx]
+            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,7 +217,8 @@ class NeuralHybridDynamics:
 class BBTrack:
     def __init__(self):
         self.parser = self.parse_bb_track_args()
-        self.control_dt = 1/100 # 50Hz
+        self.control_dt = 1/100 # 100Hz
+        self.control_hz = 100
         self.horizon = 20
         self.iterations = 10
         self.state_dims = 4
@@ -262,7 +263,7 @@ 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=16000, help="Steps to run")
+        parser.add_argument("--steps", type=int, default=10000, 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)")
@@ -468,13 +469,70 @@ class BBTrack:
                     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)
+        with torch.no_grad():
+            target_z = torch.abs(torch.sin(self.omega * torch.tensor(self.current_simulation_time,device=self.device))) * self.amplitude + self.offset
+            target_x = torch.zeros_like(target_z)
+            target_y = torch.zeros_like(target_z)
+            target_pos = torch.stack([target_x, target_y, target_z], dim=-1)
         # visualize target trajectory
         return target_pos
 
+    def log_step(self, state, target_pos, cost, action=None):
+        """Log data to arrays at each step"""
+        # Initialize arrays
+        if not hasattr(self, 'log_states'):
+            self.log_states = []
+            self.log_targets = []
+            self.log_costs = []
+            self.log_times = []
+            self.log_actions = []
+        
+        # Convert tensors to numpy and add to arrays
+        if isinstance(state, torch.Tensor):
+            state = state.cpu().numpy()
+        if isinstance(target_pos, torch.Tensor):
+            target_pos = target_pos.cpu().numpy()
+        if isinstance(cost, torch.Tensor):
+            cost = cost.detach().cpu().numpy()
+            
+        self.log_states.append(state)
+        self.log_targets.append(target_pos)
+        self.log_costs.append(cost)
+        self.log_times.append(self.current_simulation_time)
+        if action is not None:
+            if isinstance(action, torch.Tensor):
+                action = action.cpu().numpy()
+            self.log_actions.append(action)
+        else:
+            self.log_actions.append(0.0)
+    
+    def save_log(self):
+        """Save all data to files"""
+        if not hasattr(self, 'log_states') or len(self.log_states) == 0:
+            return
+            
+        from datetime import datetime
+        import shutil
+        
+        # Create directory
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        log_dir = f"/home/lau/sim/DynaTraj/logs/bb/{timestamp}"
+        os.makedirs(log_dir, exist_ok=True)
+        
+        # Save data
+        np.savez_compressed(
+            f"{log_dir}/{timestamp}.npz",
+            states=np.array(self.log_states),
+            targets=np.array(self.log_targets),
+            costs=np.array(self.log_costs),
+            times=np.array(self.log_times),
+            actions=np.array(self.log_actions)
+        )
+        
+        # Copy code file
+        shutil.copy2("/home/lau/sim/DynaTraj/mppi/task/bb1d_track.py", f"{log_dir}/bb1d_track.py")
+        
+        print(f"Saved {len(self.log_states)} data points to {log_dir}")
             
             
 
@@ -493,23 +551,32 @@ class BBTrack:
             # Update target visualization
             self.update_target_visualization()
 
-            if step % (1/self.control_dt) == 0:
-                # Convert obs to torch tensor if needed
-                if isinstance(obs, np.ndarray):
-                    obs_tensor = torch.from_numpy(obs).float().to(self.device).unsqueeze(0)  # Add batch dim
-                else:
-                    obs_tensor = obs
-
-                # 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("Ball Tar:zt::",target_z)
-
-                # Call the MPPI controller
-                action_tensor = self.controller._plan(obs_tensor, obs_tensor, t0=(step==0))
-                action = action_tensor.cpu().numpy().flatten()  # Convert back to numpy
-                # action = action.reshape(1, -1)
-                # print(action.shape)
+            if step % (1000/self.control_hz) == 0:
+                print(self.current_simulation_time)
+                
+                with torch.no_grad():  # Prevent gradient accumulation
+                    # Convert obs to torch tensor if needed
+                    if isinstance(obs, np.ndarray):
+                        obs_tensor = torch.from_numpy(obs).float().to(self.device).unsqueeze(0)  # Add batch dim
+                    else:
+                        obs_tensor = obs
+
+                    # Call the MPPI controller
+                    action_tensor = self.controller._plan(obs_tensor, obs_tensor, t0=(step==0))
+                    action = action_tensor.cpu().numpy().flatten()  # Convert back to numpy
+                    
+                    # Log data: state, target, and cost
+                    target_pos = self.vis_tar_traj(self.env)
+                    # Compute cost for current state
+                    dummy_action = torch.zeros(1, self.horizon, 1, device=self.device)
+                    current_cost = self.cost_function(obs_tensor.unsqueeze(1).expand(-1, self.horizon, -1), dummy_action)
+                    
+                    # Log data
+                    self.log_step(obs_tensor, target_pos, current_cost.mean(), action)
+                    
+                    # Clear cache periodically
+                    if step % 1000 == 0:
+                        torch.cuda.empty_cache()
 
             
 
@@ -525,6 +592,14 @@ class BBTrack:
         
         print("Demo simulation completed")
         
+        # Save log data
+        self.save_log()
+        
+        # Clean up GPU memory
+        torch.cuda.empty_cache()
+        if hasattr(self, 'z_traj'):
+            del self.z_traj
+        
 
 if __name__ == "__main__":
     bb_track = BBTrack()

plot/plot_mppi.py

@@ -0,0 +1,124 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import argparse
+import os
+import glob
+
+def load_data(log_path):
+    """Load data from npz file"""
+    data = np.load(log_path)
+    return {
+        'states': data['states'],
+        'targets': data['targets'],
+        'costs': data['costs'],
+        'times': data['times'],
+        'actions': data['actions']
+    }
+
+def plot_ball_trajectory(times, states, save_path):
+    """Plot ball z-axis trajectory"""
+    ball_z = states[:, 0, 0] if states.ndim == 3 else states[:, 0]
+    
+    plt.figure(figsize=(10, 6))
+    plt.plot(times, ball_z, 'b-', linewidth=2, label='Ball Z Position')
+    plt.xlabel('Time (s)')
+    plt.ylabel('Z Position (m)')
+    plt.title('Ball Trajectory')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(f"{save_path}/ball_trajectory.png", dpi=300)
+    plt.close()
+
+def plot_reference_trajectory(times, targets, save_path):
+    """Plot reference z-axis trajectory"""
+    ref_z = targets[:, 2] if targets.ndim == 2 else targets[:, 0, 2]
+    
+    plt.figure(figsize=(10, 6))
+    plt.plot(times, ref_z, 'r--', linewidth=2, label='Reference Z Position')
+    plt.xlabel('Time (s)')
+    plt.ylabel('Z Position (m)')
+    plt.title('Reference Trajectory')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(f"{save_path}/reference_trajectory.png", dpi=300)
+    plt.close()
+
+def plot_cost(times, costs, save_path):
+    """Plot cost over time"""
+    plt.figure(figsize=(10, 6))
+    plt.plot(times, costs, 'g-', linewidth=2, label='Cost')
+    plt.xlabel('Time (s)')
+    plt.ylabel('Cost')
+    plt.title('Cost Over Time')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(f"{save_path}/cost.png", dpi=300)
+    plt.close()
+
+def plot_actions(times, actions, save_path):
+    """Plot actions over time"""
+    plt.figure(figsize=(10, 6))
+    plt.plot(times, actions, 'm-', linewidth=2, label='Action')
+    plt.xlabel('Time (s)')
+    plt.ylabel('Action Value')
+    plt.title('Actions Over Time')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(f"{save_path}/actions.png", dpi=300)
+    plt.close()
+
+def plot_comparison(times, states, targets, save_path):
+    """Plot ball and reference trajectories together"""
+    ball_z = states[:, 0, 0] if states.ndim == 3 else states[:, 0]
+    ref_z = targets[:, 2] if targets.ndim == 2 else targets[:, 0, 2]
+    
+    plt.figure(figsize=(12, 6))
+    plt.plot(times, ball_z, 'b-', linewidth=2, label='Ball Z Position')
+    plt.plot(times, ref_z, 'r--', linewidth=2, label='Reference Z Position')
+    plt.xlabel('Time (s)')
+    plt.ylabel('Z Position (m)')
+    plt.title('Ball vs Reference Trajectory')
+    plt.grid(True, alpha=0.3)
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(f"{save_path}/comparison.png", dpi=300)
+    plt.close()
+
+def main():
+    parser = argparse.ArgumentParser(description='Plot MPPI tracking results')
+    parser.add_argument('--log_dir',default='/home/lau/sim/DynaTraj/logs/bb/20250924_104647', type=str, help='Path to log directory')
+    args = parser.parse_args()
+    
+    # Find npz file
+    npz_files = glob.glob(os.path.join(args.log_dir, "*.npz"))
+    if not npz_files:
+        print(f"No npz files found in {args.log_dir}")
+        return
+    
+    npz_file = npz_files[0]
+    print(f"Loading data from {npz_file}")
+    
+    # Load data
+    data = load_data(npz_file)
+    times = data['times']
+    states = data['states']
+    targets = data['targets']
+    costs = data['costs']
+    actions = data['actions']
+    
+    # Create plots
+    print("Generating plots...")
+    plot_ball_trajectory(times, states, args.log_dir)
+    plot_reference_trajectory(times, targets, args.log_dir)
+    plot_cost(times, costs, args.log_dir)
+    plot_actions(times, actions, args.log_dir)
+    plot_comparison(times, states, targets, args.log_dir)
+    
+    print(f"Plots saved to {args.log_dir}")
+
+if __name__ == "__main__":
+    main()