UPDATE: longer episode without termination

dataset.py

@@ -35,7 +35,34 @@ class TrajectoryBuffer:
                 self.traj_pool[k].append(traj_segment)
                 lst.clear()
 
+    def force_complete_trajectory(self):
+        """Force completion of current trajectory by padding with the last step"""
+        if len(self.buffers["obs"]) > 0:
+            # Get the last step data
+            last_obs = self.buffers["obs"][-1].copy()
+            last_ext_obs = self.buffers["ext_obs"][-1].copy()
+            last_action = self.buffers["action"][-1].copy()
+            last_reward = np.zeros_like(self.buffers["reward"][-1])  # Zero reward for padding
+            last_done = np.ones_like(self.buffers["done"][-1], dtype=np.bool_)  # Mark as done
+            
+            # Pad until we complete the trajectory
+            while self.step_idx % self.traj_steps != 0:
+                self.buffers["obs"].append(last_obs.copy())
+                self.buffers["ext_obs"].append(last_ext_obs.copy())
+                self.buffers["action"].append(last_action.copy())
+                self.buffers["reward"].append(last_reward.copy())
+                self.buffers["done"].append(last_done.copy())
+                self.step_idx += 1
+            
+            # Now complete the trajectory
+            for k, lst in self.buffers.items():
+                traj_segment = np.stack(lst, axis=1)
+                self.traj_pool[k].append(traj_segment)
+                lst.clear()
+
     def finalize(self):
+        # Complete any remaining partial trajectory
+        self.force_complete_trajectory()
         return {k: np.stack(v, axis=0) for k, v in self.traj_pool.items()}
 
     def save(self, path):

dataset/load_npz.py

@@ -0,0 +1,672 @@
+#!/usr/bin/env python3
+"""
+Load .npz files and display variable names and dimensions
+"""
+
+import numpy as np
+import os
+import glob
+import argparse
+import sys
+from pathlib import Path
+import matplotlib.pyplot as plt
+
+
+def load_npz_info(npz_file_path):
+    """
+    Load .npz file and display information about all variables
+    
+    Args:
+        npz_file_path (str): Path to .npz file
+    """
+    print(f"\n{'='*60}")
+    print(f"File: {os.path.basename(npz_file_path)}")
+    print(f"{'='*60}")
+    
+    try:
+        # Load .npz file
+        data = np.load(npz_file_path)
+        
+        # Display all variable names in the file
+        print(f"Total variables: {len(data.files)}")
+        print(f"Variable names: {data.files}")
+        print("\nDetailed information:")
+        print("-" * 60)
+        
+        # Iterate through each variable and display detailed information
+        for i, var_name in enumerate(data.files, 1):
+            var_data = data[var_name]
+            print(f"{i:2d}. Variable name: {var_name}")
+            print(f"    Data type: {var_data.dtype}")
+            print(f"    Shape (dimensions): {var_data.shape}")
+            print(f"    Total elements: {var_data.size}")
+            
+            # If numeric type, display some statistics
+            if np.issubdtype(var_data.dtype, np.number):
+                if var_data.size > 0:
+                    print(f"    Value range: [{np.min(var_data):.4f}, {np.max(var_data):.4f}]")
+                    print(f"    Mean: {np.mean(var_data):.4f}")
+                    print(f"    Std dev: {np.std(var_data):.4f}")
+            
+            # Display first few elements (if array is not too large)
+            if var_data.size <= 10:
+                print(f"    Data content: {var_data}")
+            elif len(var_data.shape) == 1:
+                print(f"    First 5 elements: {var_data[:5]}")
+            elif len(var_data.shape) == 2:
+                print(f"    First 3x3 elements:")
+                print(f"    {var_data[:3, :3]}")
+            
+            print()
+        
+        # Close file
+        data.close()
+        
+    except Exception as e:
+        print(f"Error: Unable to load file {npz_file_path}")
+        print(f"Error message: {str(e)}")
+
+
+def load_all_npz_in_directory(directory_path=None):
+    """
+    Load information from all .npz files in directory
+    
+    Args:
+        directory_path (str): Directory path, defaults to current directory
+    """
+    if directory_path is None:
+        directory_path = os.getcwd()
+    
+    # Find all .npz files
+    npz_files = glob.glob(os.path.join(directory_path, "*.npz"))
+    
+    if not npz_files:
+        print(f"No .npz files found in directory {directory_path}")
+        return
+    
+    print(f"Found {len(npz_files)} .npz files in directory {directory_path}")
+    
+    # Sort filenames
+    npz_files.sort()
+    
+    # Process files one by one
+    for npz_file in npz_files:
+        load_npz_info(npz_file)
+
+
+def load_specific_npz(file_path):
+    """
+    Load specific .npz file
+    
+    Args:
+        file_path (str): File path
+    
+    Returns:
+        dict: Dictionary containing all variables
+    """
+    try:
+        data = np.load(file_path)
+        result = {}
+        
+        print(f"Loading file: {os.path.basename(file_path)}")
+        print(f"Contains variables: {data.files}")
+        
+        # Store all variables in dictionary
+        for var_name in data.files:
+            result[var_name] = data[var_name]
+            print(f"  {var_name}: {data[var_name].shape} {data[var_name].dtype}")
+        
+        return result
+        
+    except Exception as e:
+        print(f"Error: Unable to load file {file_path}")
+        print(f"Error message: {str(e)}")
+        return None
+
+
+def load_npz_simple(npz_file_path):
+    """
+    Load .npz file and display only basic information (variable names and shapes)
+    
+    Args:
+        npz_file_path (str): Path to .npz file
+    """
+    try:
+        data = np.load(npz_file_path)
+        
+        print(f"\nFile: {os.path.basename(npz_file_path)}")
+        print(f"Variables ({len(data.files)}):")
+        
+        for var_name in data.files:
+            var_data = data[var_name]
+            print(f"  {var_name}: {var_data.shape} ({var_data.dtype})")
+        
+        data.close()
+        
+    except Exception as e:
+        print(f"Error loading {npz_file_path}: {str(e)}")
+
+
+def extract_trajectories_from_npz(npz_file_path, output_file_path=None):
+    """
+    Extract individual trajectories from NPZ data based on 'done' signal.
+    Split trajectories at done=True points and pad with NaN to equal length.
+    
+    Args:
+        npz_file_path (str): Path to input .npz file
+        output_file_path (str): Path to save processed data (optional)
+    
+    Returns:
+        dict: Dictionary containing processed trajectory data
+    """
+    try:
+        # Load original data
+        data = np.load(npz_file_path)
+        print(f"Loading data from: {os.path.basename(npz_file_path)}")
+        
+        # Check if 'done' variable exists
+        if 'done' not in data.files:
+            print("Error: 'done' variable not found in the data")
+            return None
+        
+        done = data['done']  # Shape: (1024, 1, 512)
+        batch_size, env_num, seq_len = done.shape
+        
+        print(f"Original data shape: batch_size={batch_size}, env_num={env_num}, seq_len={seq_len}")
+        
+        # Display done signal statistics for each batch
+        print(f"\nDone signal statistics per batch:")
+        print("-" * 40)
+
+        print(np.squeeze(done).sum(1)[1:200])
+        print(np.squeeze(done).sum())
+
+        return
+        done_per_batch = np.sum(done, axis=(1, 2))  # Sum over env and sequence dimensions
+        for batch_idx in range(min(1000, batch_size)):  # Show first 20 batches
+            print(f"Batch {batch_idx:3d}: {done_per_batch[batch_idx]:3d} done signals")
+        
+        if batch_size > 20:
+            print(f"... (showing first 20 out of {batch_size} batches)")
+        
+        print(f"\nOverall done statistics:")
+        print(f"  Total done signals: {np.sum(done)}")
+        print(f"  Average per batch: {np.mean(done_per_batch):.2f}")
+        print(f"  Min per batch: {np.min(done_per_batch)}")
+        print(f"  Max per batch: {np.max(done_per_batch)}")
+        
+        # Find all trajectory endpoints (where done=True)
+        trajectories = []
+        
+        for batch_idx in range(batch_size):
+            for env_idx in range(env_num):
+                # Get done flags for this batch and environment
+                done_flags = done[batch_idx, env_idx, :]
+                
+                # Find trajectory boundaries
+                trajectory_starts = [0]
+                trajectory_ends = []
+                
+                for step in range(seq_len):
+                    if done_flags[step]:
+                        trajectory_ends.append(step + 1)  # Include the done step
+                        if step + 1 < seq_len:  # If not the last step
+                            trajectory_starts.append(step + 1)
+                
+                # If the last trajectory doesn't end with done=True
+                if len(trajectory_ends) < len(trajectory_starts):
+                    trajectory_ends.append(seq_len)
+                
+                # Extract each trajectory
+                for start, end in zip(trajectory_starts, trajectory_ends):
+                    if end > start:  # Valid trajectory
+                        traj_length = end - start
+                        trajectories.append({
+                            'batch_idx': batch_idx,
+                            'env_idx': env_idx,
+                            'start': start,
+                            'end': end,
+                            'length': traj_length
+                        })
+        
+        print(f"Found {len(trajectories)} individual trajectories")
+        
+        # Find the maximum trajectory length for padding
+        max_length = max(traj['length'] for traj in trajectories)
+        print(f"Maximum trajectory length: {max_length}")
+        
+        # Create new data structure
+        num_trajectories = len(trajectories)
+        processed_data = {}
+        
+        # Process each variable (except 'done' which we'll recreate)
+        for var_name in data.files:
+            if var_name == 'done':
+                continue
+                
+            var_data = data[var_name]
+            print(f"Processing variable: {var_name}, shape: {var_data.shape}")
+            
+            # Determine the new shape
+            if len(var_data.shape) == 3:  # (batch, env, seq)
+                new_shape = (num_trajectories, max_length)
+            elif len(var_data.shape) == 4:  # (batch, env, seq, feature)
+                feature_dim = var_data.shape[3]
+                new_shape = (num_trajectories, max_length, feature_dim)
+            else:
+                print(f"Warning: Unexpected shape for variable {var_name}: {var_data.shape}")
+                continue
+            
+            # Create new array filled with NaN
+            if var_data.dtype in [np.float32, np.float64]:
+                new_var_data = np.full(new_shape, np.nan, dtype=var_data.dtype)
+            else:
+                # For non-float types, use zeros or appropriate fill value
+                new_var_data = np.zeros(new_shape, dtype=var_data.dtype)
+            
+            # Fill in the trajectory data
+            for traj_idx, traj in enumerate(trajectories):
+                batch_idx = traj['batch_idx']
+                env_idx = traj['env_idx']
+                start = traj['start']
+                end = traj['end']
+                length = traj['length']
+                
+                if len(var_data.shape) == 3:
+                    new_var_data[traj_idx, :length] = var_data[batch_idx, env_idx, start:end]
+                elif len(var_data.shape) == 4:
+                    new_var_data[traj_idx, :length, :] = var_data[batch_idx, env_idx, start:end, :]
+            
+            processed_data[var_name] = new_var_data
+        
+        # Create new done array
+        done_new = np.zeros((num_trajectories, max_length), dtype=bool)
+        for traj_idx, traj in enumerate(trajectories):
+            length = traj['length']
+            done_new[traj_idx, length-1] = True  # Mark the end of each trajectory
+        
+        processed_data['done'] = done_new
+        
+        # Add trajectory metadata
+        traj_lengths = np.array([traj['length'] for traj in trajectories], dtype=np.int32)
+        processed_data['trajectory_lengths'] = traj_lengths
+        
+        # Display new dataset information
+        print(f"\n{'='*60}")
+        print("PROCESSED DATASET INFORMATION")
+        print(f"{'='*60}")
+        print(f"Number of trajectories: {num_trajectories}")
+        print(f"Maximum trajectory length: {max_length}")
+        print(f"Average trajectory length: {np.mean(traj_lengths):.2f}")
+        print(f"Trajectory length distribution:")
+        print(f"  Min: {np.min(traj_lengths)}")
+        print(f"  Max: {np.max(traj_lengths)}")
+        print(f"  Median: {np.median(traj_lengths):.2f}")
+        
+        print(f"\nNew variable information:")
+        print("-" * 60)
+        
+        for i, (var_name, var_data) in enumerate(processed_data.items(), 1):
+            print(f"{i:2d}. Variable name: {var_name}")
+            print(f"    Data type: {var_data.dtype}")
+            print(f"    Shape (dimensions): {var_data.shape}")
+            print(f"    Total elements: {var_data.size}")
+            
+            if np.issubdtype(var_data.dtype, np.number) and var_name != 'trajectory_lengths':
+                # Calculate stats excluding NaN values
+                valid_data = var_data[~np.isnan(var_data)] if var_data.dtype in [np.float32, np.float64] else var_data
+                if valid_data.size > 0:
+                    print(f"    Valid elements: {valid_data.size}")
+                    print(f"    Value range: [{np.min(valid_data):.4f}, {np.max(valid_data):.4f}]")
+                    print(f"    Mean: {np.mean(valid_data):.4f}")
+                    print(f"    Std dev: {np.std(valid_data):.4f}")
+            
+            print()
+        
+        # Save processed data if output path is provided
+        if output_file_path:
+            np.savez_compressed(output_file_path, **processed_data)
+            print(f"Processed data saved to: {output_file_path}")
+        
+        data.close()
+        return processed_data
+        
+    except Exception as e:
+        print(f"Error processing file {npz_file_path}: {str(e)}")
+        return None
+
+
+def plot_trajectory(npz_file_path, trajectory_id, output_image_path=None):
+    """
+    Plot observations and actions for a specific trajectory.
+    
+    Args:
+        npz_file_path (str): Path to .npz file containing trajectory data
+        trajectory_id (int): ID of the trajectory to plot
+        output_image_path (str): Path to save the plot image (optional)
+    """
+    try:
+        # Load trajectory data
+        data = np.load(npz_file_path)
+        
+        # Check if required variables exist
+        if 'obs' not in data.files or 'action' not in data.files:
+            print("Error: 'obs' or 'action' variable not found in the data")
+            return
+        
+        obs = data['obs']  # Shape: (batch, env, seq, 18) or (num_trajectories, max_length, 18)
+        action = data['action']  # Shape: (batch, env, seq, 6) or (num_trajectories, max_length, 6)
+        
+        # Check if this is processed trajectory data or original batch data
+        if 'trajectory_lengths' in data.files:
+            # Processed trajectory data
+            traj_lengths = data['trajectory_lengths']
+            num_trajectories = obs.shape[0]
+            
+            # Validate trajectory ID
+            if trajectory_id < 0 or trajectory_id >= num_trajectories:
+                print(f"Error: Trajectory ID {trajectory_id} is out of range [0, {num_trajectories-1}]")
+                return
+            
+            traj_length = traj_lengths[trajectory_id]
+            traj_obs = obs[trajectory_id, :traj_length, :]
+            traj_action = action[trajectory_id, :traj_length, :]
+            
+            # Get done flags for this trajectory
+            if 'done' in data.files:
+                traj_done = data['done'][trajectory_id, :traj_length]
+                done_indices = np.where(traj_done)[0]
+                print(f"Done=True at time steps: {done_indices}")
+            
+        else:
+            # Original batch data - need to specify batch and env indices
+            if len(obs.shape) != 4:
+                print(f"Error: Expected 4D data (batch, env, seq, features), got shape {obs.shape}")
+                return
+            
+            batch_size, env_num, seq_len, obs_dim = obs.shape
+            total_sequences = batch_size * env_num
+            
+            # Convert trajectory_id to batch and env indices
+            if trajectory_id < 0 or trajectory_id >= total_sequences:
+                print(f"Error: Trajectory ID {trajectory_id} is out of range [0, {total_sequences-1}]")
+                return
+            
+            batch_idx = trajectory_id // env_num
+            env_idx = trajectory_id % env_num
+            
+            print(f"Using batch {batch_idx}, environment {env_idx} from original data")
+            
+            traj_obs = obs[batch_idx, env_idx, :, :]  # Shape: (seq_len, 18)
+            traj_action = action[batch_idx, env_idx, :, :]  # Shape: (seq_len, 6)
+            traj_length = seq_len
+            
+            # Get done flags for this trajectory
+            if 'done' in data.files:
+                traj_done = data['done'][batch_idx, env_idx, :]
+                done_indices = np.where(traj_done)[0]
+                print(f"Done=True at time steps: {done_indices}")
+        
+        print(f"Plotting trajectory {trajectory_id} with length {traj_length}")
+        
+        # Create time axis
+        time_steps = np.arange(traj_length)
+        
+        # Create 6x4 subplot
+        fig, axes = plt.subplots(6, 4, figsize=(16, 18))
+        fig.suptitle(f'Trajectory {trajectory_id} - Observations and Actions', fontsize=16)
+        
+        # Plot observations (18 dimensions) in first 3 columns
+        for i in range(18):
+            row = i // 3
+            col = i % 3
+            axes[row, col].plot(time_steps[:], traj_obs[:, i], 'b-o', linewidth=1)
+            axes[row, col].set_title(f'Obs {i}')
+            axes[row, col].grid(True, alpha=0.3)
+            axes[row, col].set_xlabel('Time Step')
+        
+        # Plot actions (6 dimensions) in the last column
+        for i in range(6):
+            axes[i, 3].plot(time_steps, traj_action[:, i], 'r-', linewidth=1)
+            axes[i, 3].set_title(f'Action {i}')
+            axes[i, 3].grid(True, alpha=0.3)
+            axes[i, 3].set_xlabel('Time Step')
+        
+        # Adjust layout
+        plt.tight_layout()
+        
+        # Save or show plot
+        if output_image_path:
+            plt.savefig(output_image_path, dpi=300, bbox_inches='tight')
+            print(f"Plot saved to: {output_image_path}")
+        else:
+            # Generate default filename
+            base_name = os.path.splitext(os.path.basename(npz_file_path))[0]
+            default_path = f"{base_name}_trajectory_{trajectory_id}.png"
+            plt.savefig(default_path, dpi=300, bbox_inches='tight')
+            print(f"Plot saved to: {default_path}")
+        
+        plt.close()
+        data.close()
+        
+    except Exception as e:
+        print(f"Error plotting trajectory: {str(e)}")
+
+
+def plot_done_statistics(npz_file_path, output_image_path=None):
+    """
+    Plot histogram of done time steps across all trajectories.
+    
+    Args:
+        npz_file_path (str): Path to .npz file containing trajectory data
+        output_image_path (str): Path to save the plot image (optional)
+    """
+    try:
+        # Load trajectory data
+        data = np.load(npz_file_path)
+        
+        # Check if required variables exist
+        if 'done' not in data.files:
+            print("Error: 'done' variable not found in the data")
+            return
+        
+        done = data['done']
+        
+        # Check if this is processed trajectory data or original batch data
+        if 'trajectory_lengths' in data.files:
+            # Processed trajectory data
+            traj_lengths = data['trajectory_lengths']
+            num_trajectories = done.shape[0]
+            
+            all_done_times = []
+            for traj_id in range(num_trajectories):
+                traj_length = traj_lengths[traj_id]
+                traj_done = done[traj_id, :traj_length]
+                done_indices = np.where(traj_done)[0]
+                all_done_times.extend(done_indices)
+            
+            print(f"Found {len(all_done_times)} done signals across {num_trajectories} trajectories")
+            
+        else:
+            # Original batch data
+            batch_size, env_num, seq_len = done.shape
+            
+            all_done_times = []
+            for batch_idx in range(batch_size):
+                for env_idx in range(env_num):
+                    traj_done = done[batch_idx, env_idx, :]
+                    done_indices = np.where(traj_done)[0]
+                    all_done_times.extend(done_indices)
+            
+            total_sequences = batch_size * env_num
+            print(f"Found {len(all_done_times)} done signals across {total_sequences} sequences")
+        
+        if not all_done_times:
+            print("No done signals found in the data")
+            return
+        
+        all_done_times = np.array(all_done_times)
+        
+        # Create histogram plot
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10))
+        
+        # Histogram of done times
+        ax1.hist(all_done_times, bins=50, alpha=0.7, color='blue', edgecolor='black')
+        ax1.set_xlabel('Time Step')
+        ax1.set_ylabel('Frequency')
+        ax1.set_title('Distribution of Done Signal Time Steps')
+        ax1.grid(True, alpha=0.3)
+        
+        # Statistics
+        mean_done_time = np.mean(all_done_times)
+        median_done_time = np.median(all_done_times)
+        std_done_time = np.std(all_done_times)
+        
+        ax1.axvline(mean_done_time, color='red', linestyle='--', linewidth=2, label=f'Mean: {mean_done_time:.1f}')
+        ax1.axvline(median_done_time, color='green', linestyle='--', linewidth=2, label=f'Median: {median_done_time:.1f}')
+        ax1.legend()
+        
+        # Box plot
+        ax2.boxplot(all_done_times, vert=False)
+        ax2.set_xlabel('Time Step')
+        ax2.set_title('Box Plot of Done Signal Time Steps')
+        ax2.grid(True, alpha=0.3)
+        
+        # Add statistics text
+        stats_text = f"""Statistics:
+Total done signals: {len(all_done_times)}
+Mean: {mean_done_time:.2f}
+Median: {median_done_time:.2f}
+Std Dev: {std_done_time:.2f}
+Min: {np.min(all_done_times)}
+Max: {np.max(all_done_times)}
+25th percentile: {np.percentile(all_done_times, 25):.1f}
+75th percentile: {np.percentile(all_done_times, 75):.1f}"""
+        
+        ax2.text(0.02, 0.98, stats_text, transform=ax2.transAxes, 
+                verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
+        
+        plt.tight_layout()
+        
+        # Save plot
+        if output_image_path:
+            plt.savefig(output_image_path, dpi=300, bbox_inches='tight')
+            print(f"Done statistics plot saved to: {output_image_path}")
+        else:
+            # Generate default filename
+            base_name = os.path.splitext(os.path.basename(npz_file_path))[0]
+            default_path = f"{base_name}_done_statistics.png"
+            plt.savefig(default_path, dpi=300, bbox_inches='tight')
+            print(f"Done statistics plot saved to: {default_path}")
+        
+        plt.close()
+        data.close()
+        
+        # Print summary
+        print(f"\nDone Statistics Summary:")
+        print(f"Total done signals: {len(all_done_times)}")
+        print(f"Mean time step: {mean_done_time:.2f}")
+        print(f"Median time step: {median_done_time:.2f}")
+        print(f"Standard deviation: {std_done_time:.2f}")
+        print(f"Range: [{np.min(all_done_times)}, {np.max(all_done_times)}]")
+        
+    except Exception as e:
+        print(f"Error plotting done statistics: {str(e)}")
+
+
+if __name__ == "__main__":
+    # Set up command line argument parsing
+    parser = argparse.ArgumentParser(description="Load and analyze .npz files")
+    parser.add_argument("path", nargs="?", default=".", 
+                       help="Path to .npz file or directory containing .npz files (default: current directory)")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                       help="Show detailed information including statistics")
+    parser.add_argument("-l", "--list-only", action="store_true",
+                       help="Only list variable names and shapes, no detailed info")
+    parser.add_argument("-f", "--first-only", action="store_true",
+                       help="Only process the first .npz file found")
+    parser.add_argument("-t", "--extract-trajectories", action="store_true",
+                       help="Extract individual trajectories based on done signal")
+    parser.add_argument("-o", "--output", type=str,
+                       help="Output file path for processed trajectories")
+    parser.add_argument("-p", "--plot", type=int, metavar="TRAJ_ID",
+                       help="Plot trajectory with specified ID")
+    parser.add_argument("--plot-output", type=str,
+                       help="Output path for trajectory plot image")
+    
+    args = parser.parse_args()
+    
+    # Handle case where user accidentally includes "path=" prefix
+    if args.path.startswith("path="):
+        args.path = args.path[5:]  # Remove "path=" prefix
+    
+    print("NPZ File Loader")
+    print("=" * 60)
+    
+    # Check if path exists
+    if not os.path.exists(args.path):
+        print(f"Error: Path '{args.path}' does not exist")
+        sys.exit(1)
+    
+    # If path is a file
+    if os.path.isfile(args.path):
+        if args.path.endswith('.npz'):
+            print(f"Loading single file: {args.path}")
+            
+            if args.extract_trajectories:
+                # Extract trajectories
+                output_path = args.output
+                if not output_path:
+                    # Generate default output filename
+                    base_name = os.path.splitext(args.path)[0]
+                    output_path = f"{base_name}_trajectories.npz"
+                
+                processed_data = extract_trajectories_from_npz(args.path, output_path)
+                
+                # Also display the processed data information
+                if processed_data and output_path and os.path.exists(output_path):
+                    print(f"\n{'='*60}")
+                    print("VERIFYING SAVED PROCESSED DATA")
+                    print(f"{'='*60}")
+                    if args.list_only:
+                        load_npz_simple(output_path)
+                    else:
+                        load_npz_info(output_path)
+            elif args.plot is not None:
+                # Plot trajectory
+                plot_trajectory(args.path, args.plot, args.plot_output)
+                # Always plot done statistics too
+                plot_done_statistics(args.path, None)
+            else:
+                # Default: plot trajectory 0
+                plot_trajectory(args.path, 0, None)
+                # Also plot done statistics
+                plot_done_statistics(args.path, None)
+        else:
+            print(f"Error: '{args.path}' is not a .npz file")
+            sys.exit(1)
+    
+    # If path is a directory
+    elif os.path.isdir(args.path):
+        npz_files = glob.glob(os.path.join(args.path, "*.npz"))
+        
+        if not npz_files:
+            print(f"No .npz files found in directory {args.path}")
+            sys.exit(1)
+        
+        npz_files.sort()
+        print(f"Found {len(npz_files)} .npz files in directory {args.path}")
+        
+        if args.first_only:
+            npz_files = npz_files[:1]
+            print("Processing only the first file...")
+        
+        for npz_file in npz_files:
+            if args.list_only:
+                load_npz_simple(npz_file)
+            else:
+                load_npz_info(npz_file)
+    
+    else:
+        print(f"Error: '{args.path}' is neither a file nor a directory")
+        sys.exit(1)

dataset/{sb3_cheetah_run_ckpt001_2025-08-18_23-31-33.npz → sb3_cheetah_run_ckpt001_2025-08-28_19-39-53.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eefc8c4c5e6f1e233a9bb79e1527afc6fc55b76625f190084982382d920dbf9e
-size 83471485
+oid sha256:25e74c6eba114897008ce859b2f77c7612275e09250f600b4a458d1adb4b6468
+size 83206684

dataset/sb3_cheetah_run_ckpt020_2025-08-28_17-35-15.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6f21abb567a8ec2016031d6cff665f2ca7c267a3683f20a1bd05242bddef62e7
-size 83973060

dataset/{sb3_cheetah_run_ckpt001_2025-08-28_16-46-27.npz → sb3_cheetah_run_ckpt020_2025-08-28_19-42-44.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c261689477b68d38695fd8d25b0ee9e88df56ad3cc08c187a00bb0eed2f4e5f0
-size 83472274
+oid sha256:b2196469b61f6f81c7806122eed54eceb7dbe6437fbab8ddd5e7ff03b6e582ed
+size 42271647

dataset/sb3_cheetah_run_ckpt030_2025-08-18_23-40-31.npz

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

dataset/sb3_cheetah_run_ckpt030_2025-08-28_17-38-32.npz

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:24f28dce1b3422303367426abfa92fb697ac90f4ce7e96425fb98fbac6082b76
-size 84805176

dataset/{sb3_cheetah_run_ckpt020_2025-08-18_23-36-48.npz → sb3_cheetah_run_ckpt030_2025-08-28_19-49-33.npz}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:06cc39f264964dba65a6be759d1c008bbdbcf3b73358a83d64a3f7f386e92ba9
-size 83959326
+oid sha256:7c9399cb462e5baeffb6b78b407155ece4ed039672d417f5191ad6f0d990d6d4
+size 83939631

dataset/sb3_cheetah_run_ckpt050_2025-08-18_23-43-50.npz

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

dataset/sb3_cheetah_run_ckpt050_2025-08-28_17-41-11.npz

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

dataset/sb3_cheetah_run_ckpt050_2025-08-28_17-41-11_metadata.pkl

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

dataset/sb3_cheetah_run_ckpt050_2025-08-28_20-11-25.npz

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

sb3_collect.py

@@ -230,7 +230,7 @@ def main():
     args = parse_args()
 
     # Prepare env
-    env = suite.load(domain_name=args.domain, task_name=args.task, task_kwargs={"random": args.seed})
+    env = suite.load(domain_name=args.domain, task_name=args.task, task_kwargs={"random": args.seed, 'time_limit': 100000})
     action_spec = env.action_spec()
 
     # Determine obs flatten order once