import argparse import os import sys # Added for path manipulation import torch import torch.nn as nn import torch.multiprocessing as mp # Added for multiprocessing from tqdm import tqdm import json import re import math import random import yaml from PIL import Image, ImageFile import numpy as np import copy from transformers import AutoProcessor # Added import from glob import glob # For finding video files from pathlib import Path # For path manipulation import traceback # For error reporting in subprocesses import h5py # Added for potential HDF5 saving (though not used currently for point clouds) # Assume necessary imports from llava are available in the PYTHONPATH # You might need to adjust imports based on your project structure from llava.utils import process_video_with_decord # Or other video processing functions used from llava.utils import rank0_print # Use rank0_print for controlled output from llava.train.train import DataArguments # Re-use DataArguments for consistency from llava.constants import DEFAULT_IMAGE_TOKEN from llava.model.multimodal_encoder.siglip_encoder import SigLipImageProcessor # Added direct import # Add imports for direct spatial tower loading from llava.model.multimodal_spatial_encoder.cut3r_spatial_encoder import Cut3rSpatialConfig, Cut3rEncoder from src.dust3r.model import ARCroco3DStereo # Import CUT3R model class ImageFile.LOAD_TRUNCATED_IMAGES = True # --- Constants --- VIDEO_EXTENSIONS = ['.mp4', '.avi', '.mov', '.mkv'] # Add more if needed # --- Image/Video Loading and Preprocessing --- # (Adapted from LazySupervisedDataset and encode_spatial_features) def load_image(image_path): try: image = Image.open(image_path).convert("RGB") return image except Exception as e: rank0_print(f"Error loading image {image_path}: {e}") # Use rank0_print return None def preprocess_image_for_spatial(image, processor, target_size=(432, 432)): """Preprocesses a single PIL image for spatial feature extraction using the provided processor.""" # Process using the vision model's processor try: processed_output = processor(images=image, return_tensors='pt') image_tensor = processed_output['pixel_values'].squeeze(0) # Shape (C, H_proc, W_proc) except Exception as e: rank0_print(f"Error processing image with processor: {e}") # Use rank0_print return None # Resize to the target size expected by the spatial tower (if different) c, h_proc, w_proc = image_tensor.shape if h_proc != target_size[0] or w_proc != target_size[1]: image_scaled = nn.functional.interpolate( image_tensor.unsqueeze(0), # Add batch dim for interpolate size=target_size, mode='bilinear', align_corners=False ).squeeze(0) # Remove batch dim else: image_scaled = image_tensor # Return shape (1, C, H_target, W_target) - batch dim added later before spatial tower return image_scaled.unsqueeze(0) # Old manual preprocessing: # image_tensor = torch.from_numpy(np.array(image)).permute(2, 0, 1).float() / 255.0 # image_scaled = nn.functional.interpolate(image_tensor.unsqueeze(0), size=target_size, mode='bilinear', align_corners=False) # return image_scaled # Output shape (1, C, H, W) def load_and_preprocess_video_frames(video_path, data_args, processor, target_size=(432, 432), rank=0): """ Loads video, samples frames, preprocesses them using the processor, and returns a tensor of shape (F, C, H_target, W_target). Includes rank for logging. """ try: # Use the same video processing function as in training video_frames, video_time, frame_time, num_frames_to_sample = process_video_with_decord(video_path, data_args) # Preprocess all frames together using the processor try: # Ensure video_frames is a list of PIL Images or compatible format processed_output = processor.preprocess(images=video_frames, return_tensors="pt") frames_tensor = processed_output['pixel_values'] # Shape (F, C, H_proc, W_proc) except Exception as e: rank0_print(f"[GPU {rank}] Error processing video frames with processor for {video_path}: {e}") return None # Resize frames to the target size if necessary f, c, h_proc, w_proc = frames_tensor.shape if h_proc != target_size[0] or w_proc != target_size[1]: # Interpolate expects (B, C, H, W) or (C, H, W) # Process frame by frame or reshape if possible, let's do frame by frame for simplicity frames_scaled_list = [] for i in range(f): frame_scaled = nn.functional.interpolate( frames_tensor[i].unsqueeze(0), # Add batch dim size=target_size, mode='bilinear', align_corners=False ).squeeze(0) # Remove batch dim frames_scaled_list.append(frame_scaled) frames_scaled = torch.stack(frames_scaled_list) # Shape (F, C, H_target, W_target) else: frames_scaled = frames_tensor # Return shape (F, C, H_target, W_target) - Batch dim added later during batching return frames_scaled except Exception as e: rank0_print(f"[GPU {rank}] Error processing video {video_path}: {e}") return None # --- Main Extraction Logic --- def find_video_files(input_dir): """Recursively finds all video files in the input directory.""" video_files = [] rank0_print(f"Scanning for video files in {input_dir}...") for ext in VIDEO_EXTENSIONS: # Using Path for easier relative path calculation input_path = Path(input_dir) # **/*{ext} finds files in input_dir and subdirectories video_files.extend(input_path.rglob(f"*{ext}")) # Case-insensitive search for extensions video_files.extend(input_path.rglob(f"*{ext.upper()}")) # Remove duplicates if extensions overlap (e.g., .MP4 and .mp4) unique_video_files = sorted(list(set(video_files))) rank0_print(f"Found {len(unique_video_files)} potential video files.") return [str(f) for f in unique_video_files] # Return as strings def get_output_path(input_file_path: Path, input_base_dir: Path, output_base_dir: Path) -> Path: """Calculates the output path for a given input file.""" try: relative_path = input_file_path.relative_to(input_base_dir) except ValueError: rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting directly to {output_base_dir}.") relative_path = input_file_path.name # Use only the filename # Change extension to .pt output_filename_path = output_base_dir / relative_path.with_suffix('.pt') return output_filename_path def get_point_cloud_output_path(input_file_path: Path, input_base_dir: Path, point_cloud_output_base_dir: Path) -> Path: """Calculates the output path for the point cloud corresponding to an input file.""" try: relative_path = input_file_path.relative_to(input_base_dir) except ValueError: rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting point cloud directly to {point_cloud_output_base_dir}.") relative_path = input_file_path.name # Use only the filename # Change extension to .ply output_filename_path = point_cloud_output_base_dir / relative_path.with_suffix('.ply') return output_filename_path def get_preprocessed_frames_output_dir(input_file_path: Path, input_base_dir: Path, frames_output_base_dir: Path) -> Path: """Calculates the output directory for the preprocessed frames corresponding to an input file.""" try: relative_path = input_file_path.relative_to(input_base_dir) except ValueError: rank0_print(f"Warning: Input file {input_file_path} is not within the specified base input directory {input_base_dir}. Outputting frames directly under {frames_output_base_dir}.") relative_path = input_file_path.stem # Use only the filename stem (no extension) # Create a directory based on the relative path (without extension) output_dir_path = frames_output_base_dir / relative_path.parent / relative_path.stem return output_dir_path # --- Worker Process Function --- def process_videos_on_gpu(rank, gpu_id, args, video_files_chunk, input_base_dir, output_dir): """ Worker function executed by each process to handle a chunk of videos on a specific GPU. """ device = torch.device(f"cuda:{gpu_id}") torch.cuda.set_device(device) # Ensure this process uses the assigned GPU processed_count = 0 skipped_count = 0 total_files_in_chunk = len(video_files_chunk) batch_size = args.batch_size rank0_print(f"[GPU {gpu_id}] Worker started, assigned {total_files_in_chunk} files.") # -- Load Model Components (within each worker process) -- try: rank0_print(f"[GPU {gpu_id}] Loading CUT3R Spatial Tower...") if not os.path.exists(args.cut3r_weights_path): rank0_print(f"[GPU {gpu_id}] ERROR: CUT3R weights file not found at: {args.cut3r_weights_path}") return 0, total_files_in_chunk # Return counts # Pass point cloud config from args cut3r_config = Cut3rSpatialConfig( weights_path=args.cut3r_weights_path, export_point_cloud=args.export_point_cloud, point_cloud_output_dir=args.point_cloud_output_dir, # Pass base dir, specific file handled later point_cloud_voxel_size=args.point_cloud_voxel_size ) spatial_tower = Cut3rEncoder(config=cut3r_config) model_dtype = torch.bfloat16 if args.precision == 'bf16' else torch.float16 if args.precision == 'fp16' else torch.float32 spatial_tower.to(device=device, dtype=model_dtype).eval() rank0_print(f"[GPU {gpu_id}] CUT3R Spatial Tower loaded on {device}.") # -- Load Image Processor Config and Initialize Processor -- rank0_print(f"[GPU {gpu_id}] Loading Processor config from {args.processor_config_path}...") with open(args.processor_config_path, 'r') as f: processor_config = json.load(f) image_mean_list = processor_config.get("image_mean", (0.5, 0.5, 0.5)) image_std_list = processor_config.get("image_std", (0.5, 0.5, 0.5)) size_config = processor_config.get("size", {"height": 384, "width": 384}) size_tuple = (size_config["height"], size_config["width"]) resample_val = processor_config.get("resample", 3) rescale_factor_val = processor_config.get("rescale_factor", 1/255.0) image_processor = SigLipImageProcessor( image_mean=image_mean_list, image_std=image_std_list, size=size_tuple, resample=resample_val, rescale_factor=rescale_factor_val ) rank0_print(f"[GPU {gpu_id}] SigLipImageProcessor initialized.") # Convert mean/std to tensors for de-normalization if saving frames if args.save_preprocessed_frames: mean_tensor = torch.tensor(image_mean_list, device=device).view(3, 1, 1) std_tensor = torch.tensor(image_std_list, device=device).view(3, 1, 1) else: mean_tensor, std_tensor = None, None # Avoid unused variables except Exception as e: rank0_print(f"[GPU {gpu_id}] Error during initialization: {e}\n{traceback.format_exc()}") return 0, total_files_in_chunk # Indicate all files skipped due to init error # --- Load Dummy DataArguments --- data_args = DataArguments( video_fps=args.video_fps, frames_upbound=args.frames_upbound, force_sample=True ) # --- Feature Extraction Loop for the Chunk (Batched Processing) --- # Use tqdm only on rank 0 or manage it externally if needed # Simple loop without per-process tqdm for now for i in range(0, total_files_in_chunk, batch_size): batch_paths_str = video_files_chunk[i:min(i + batch_size, total_files_in_chunk)] batch_paths = [Path(p) for p in batch_paths_str] # --- Batch Preprocessing --- batch_data_to_process = [] # Stores (preprocessed_input, feature_output_filename, point_cloud_output_filename, video_full_path) files_in_batch = 0 skipped_in_batch = 0 max_frames_in_batch = 0 point_cloud_base_dir = Path(args.point_cloud_output_dir) if args.export_point_cloud else None frames_base_dir = Path(args.save_preprocessed_frames_dir) if args.save_preprocessed_frames else None for video_full_path in batch_paths: files_in_batch += 1 feature_output_filename_path = get_output_path(video_full_path, input_base_dir, output_dir) feature_output_filename = str(feature_output_filename_path) point_cloud_output_filename = None if args.export_point_cloud and point_cloud_base_dir: point_cloud_output_filename_path = get_point_cloud_output_path(video_full_path, input_base_dir, point_cloud_base_dir) point_cloud_output_filename = str(point_cloud_output_filename_path) # Ensure parent dir for point cloud exists point_cloud_output_filename_path.parent.mkdir(parents=True, exist_ok=True) # Check feature file existence feature_output_filename_path.parent.mkdir(parents=True, exist_ok=True) feature_exists = os.path.exists(feature_output_filename) # Check point cloud existence (if exporting) point_cloud_exists = False if args.export_point_cloud and point_cloud_output_filename: point_cloud_exists = os.path.exists(point_cloud_output_filename) # Determine if skipping is needed # Skip if NOT overwriting AND (feature exists AND (point cloud exists OR not exporting point cloud)) should_skip = not args.overwrite and (feature_exists and (point_cloud_exists or not args.export_point_cloud)) if should_skip: skipped_in_batch += 1 continue preprocessed_input = load_and_preprocess_video_frames( str(video_full_path), data_args, image_processor, rank=gpu_id # Pass rank for logging ) if preprocessed_input is not None and preprocessed_input.nelement() > 0: # Store point cloud path only if exporting pc_path_to_store = point_cloud_output_filename if args.export_point_cloud else None # --- Save Preprocessed Frames (if enabled) --- if args.save_preprocessed_frames and frames_base_dir is not None and mean_tensor is not None and std_tensor is not None: try: frames_output_dir_path = get_preprocessed_frames_output_dir(video_full_path, input_base_dir, frames_base_dir) frames_output_dir_path.mkdir(parents=True, exist_ok=True) # De-normalize and save each frame # Move tensor to CPU for processing/saving if it isn't already # Note: preprocessed_input is on CPU from load_and_preprocess... preprocessed_input_float = preprocessed_input.float() # Ensure float32 for calculation for frame_idx in range(preprocessed_input_float.shape[0]): frame_tensor = preprocessed_input_float[frame_idx] # Shape (C, H, W) # De-normalize: (tensor * std + mean) / rescale_factor # Assuming rescale_factor = 1/255.0 # (tensor * std + mean) * 255.0 # Move mean/std to the frame's device (likely CPU here) denormalized_frame = (frame_tensor * std_tensor.to(frame_tensor.device) + mean_tensor.to(frame_tensor.device)) / rescale_factor_val # Clamp and convert to uint8 denormalized_frame = torch.clamp(denormalized_frame, 0, 255).to(torch.uint8) # Convert to PIL Image (C, H, W) -> (H, W, C) pil_image = Image.fromarray(denormalized_frame.permute(1, 2, 0).cpu().numpy()) # Construct filename frame_filename = frames_output_dir_path / f"frame_{frame_idx:04d}.png" # Save the image pil_image.save(frame_filename) except Exception as e_save_frame: rank0_print(f"[GPU {gpu_id}] Error saving preprocessed frame for {video_full_path}, frame {frame_idx}: {e_save_frame}") # Continue processing other frames/videos # Append data for batch inference batch_data_to_process.append((preprocessed_input, feature_output_filename, pc_path_to_store, video_full_path)) max_frames_in_batch = max(max_frames_in_batch, preprocessed_input.shape[0]) else: rank0_print(f"[GPU {gpu_id}] Failed to load/preprocess {video_full_path}. Skipping.") skipped_in_batch += 1 # --- Batch Inference (True Batching) --- processed_in_batch = 0 if batch_data_to_process: padded_tensors = [] output_info = [] # Stores (feature_output_filename, point_cloud_output_filename, video_full_path) for preprocessed_input, feature_output_filename, point_cloud_output_filename, video_full_path in batch_data_to_process: num_frames = preprocessed_input.shape[0] padding_needed = max_frames_in_batch - num_frames padded_tensor = torch.nn.functional.pad( preprocessed_input, (0, 0, 0, 0, 0, 0, 0, padding_needed), mode='constant', value=0 ) padded_tensors.append(padded_tensor) output_info.append((feature_output_filename, point_cloud_output_filename, video_full_path)) # Stack padded tensors into a single batch # Note: Cut3rEncoder expects input shape (B, F, C, H, W) or (F, C, H, W) # Our load function returns (F, C, H, W), stack adds batch: (B, F, C, H, W) ? Check stack dim. # torch.stack(tensors, dim=0) makes (B, F, C, H, W) # Let's adjust the input format if needed, assuming Cut3rEncoder handles (B, F, C, H, W) or (F, C, H, W) # If it expects (F, B, C, H, W), need permute. Sticking with (B, F, C, H, W) for now. batch_tensor = torch.stack(padded_tensors, dim=1).to(device=device, dtype=model_dtype) # Shape (F_max, B, C, H, W) point_cloud_paths_for_batch = [info[1] for info in output_info] if args.export_point_cloud else None try: with torch.no_grad(): # Pass batch_tensor directly. Cut3rEncoder handles iterating through frames internally. # Expected input is (B, F, C, H, W) or (F, C, H, W) # Expected output is (B * F, token_num, token_dim) # Pass point cloud paths if exporting camera_tokens_batch, patch_tokens_batch = spatial_tower( batch_tensor, point_cloud_output_paths=point_cloud_paths_for_batch # Pass the paths here ) # Reshape the outputs to separate Batch and Frame dimensions B = batch_tensor.shape[0] # Actual batch size processed F_max = max_frames_in_batch # Note: The Cut3rEncoder might flatten B*F in the output. Confirm expected output shape. # Assuming output is (B * F_max, token_num, token_dim) expected_output_len = B * F_max if camera_tokens_batch.shape[0] != expected_output_len: rank0_print(f"[GPU {gpu_id}] Warning: Output dimension mismatch. Expected {expected_output_len} but got {camera_tokens_batch.shape[0]}. Skipping save for this batch.") skipped_in_batch += B # Mark all items in batch as skipped else: _, token_num_cam, token_dim_cam = camera_tokens_batch.shape _, token_num_patch, token_dim_patch = patch_tokens_batch.shape # View as (B, F_max, token_num, token_dim) camera_tokens_reshaped = camera_tokens_batch.view(B, F_max, token_num_cam, token_dim_cam) patch_tokens_reshaped = patch_tokens_batch.view(B, F_max, token_num_patch, token_dim_patch) for idx, (feature_output_filename, point_cloud_output_filename, video_full_path) in enumerate(output_info): try: # Save features regardless features_to_save = { "camera_tokens": camera_tokens_reshaped[idx].cpu(), "patch_tokens": patch_tokens_reshaped[idx].cpu() } torch.save(features_to_save, feature_output_filename) # Point cloud saving is handled inside spatial_tower if enabled processed_in_batch += 1 except Exception as e_save: rank0_print(f"[GPU {gpu_id}] Error saving features for {video_full_path} (point cloud saving handled separately): {e_save}") skipped_in_batch += 1 # Attempt to remove potentially corrupted feature file if os.path.exists(feature_output_filename): try: os.remove(feature_output_filename) except OSError: rank0_print(f"Warning: Could not remove potentially corrupted file {feature_output_filename}") # Note: Point cloud file removal isn't handled here as saving happens in the model except Exception as e_batch: rank0_print(f"[GPU {gpu_id}] Error during batch inference (features or point clouds): {e_batch}\n{traceback.format_exc()}") skipped_in_batch += len(batch_data_to_process) - processed_in_batch processed_count += processed_in_batch skipped_count += skipped_in_batch # Optional: Print progress per worker periodically if (i // batch_size) % 10 == 0: # Print every 10 batches rank0_print(f"[GPU {gpu_id}] Progress: Batch {i//batch_size+1}/{math.ceil(total_files_in_chunk/batch_size)}, Processed: {processed_count}, Skipped: {skipped_count}") rank0_print(f"[GPU {gpu_id}] Worker finished. Processed: {processed_count}, Skipped: {skipped_count}") return processed_count, skipped_count # --- Main Execution --- if __name__ == "__main__": mp.set_start_method('spawn', force=True) # Recommended for CUDA with multiprocessing parser = argparse.ArgumentParser(description="Extract Spatial Features using CUT3R (Multi-GPU)") parser.add_argument("--cut3r-weights-path", type=str, required=True, help="Path to the CUT3R weights file (e.g., cut3r_512_dpt_4_64.pth)") parser.add_argument("--input-dir", type=str, default=None, help="Root directory containing video files to process recursively (ignored if --input-file is provided)") parser.add_argument("--input-file", type=str, default=None, help="Path to a single video file to process") parser.add_argument("--output-dir", type=str, required=True, help="Root directory to save the extracted features, mirroring input structure") parser.add_argument("--processor-config-path", type=str, required=True, help="Path to the processor_config.json file for SigLipImageProcessor") # parser.add_argument("--device", type=str, default="cuda:0", help="Device to use (e.g., 'cuda:0', 'cpu')") # Replaced by gpu-ids parser.add_argument("--gpu-ids", type=str, default="0", help="Comma-separated list of GPU IDs to use (e.g., '0,1,2') or 'all'") parser.add_argument("--precision", type=str, default="fp16", choices=['fp16', 'bf16', 'fp32'], help="Computation precision") parser.add_argument("--overwrite", action="store_true", help="Overwrite existing feature files") parser.add_argument("--video-fps", type=int, default=1, help="FPS for video frame sampling") parser.add_argument("--frames-upbound", type=int, default=10, help="Max frames to sample per video") parser.add_argument("--batch-size", type=int, default=1, help="Number of videos to process per batch *per GPU*") # Clarified batch size scope parser.add_argument("--export-point-cloud", action="store_true", help="Export generated point cloud for each video") parser.add_argument("--point-cloud-output-dir", type=str, default="point_clouds", help="Directory to save exported point clouds (used if --export-point-cloud is set)") parser.add_argument("--point-cloud-voxel-size", type=float, default=0.01, help="Voxel size for downsampling exported point clouds") parser.add_argument("--save-preprocessed-frames", action="store_true", help="Save the preprocessed frames used for feature extraction as images") parser.add_argument("--save-preprocessed-frames-dir", type=str, default="preprocessed_frames", help="Directory to save preprocessed frames (used if --save-preprocessed-frames is set)") args = parser.parse_args() # --- Validate Input Arguments --- if not args.input_dir and not args.input_file: parser.error("Either --input-dir or --input-file must be specified.") if args.input_dir and args.input_file: rank0_print("Warning: Both --input-dir and --input-file provided. --input-file will be used.") args.input_dir = None # Prioritize input_file # --- Determine GPUs to Use --- if args.gpu_ids.lower() == 'all': if torch.cuda.is_available(): num_gpus = torch.cuda.device_count() gpu_ids = list(range(num_gpus)) if num_gpus == 0: rank0_print("Error: 'all' GPUs requested, but no CUDA devices found.") sys.exit(1) rank0_print(f"Using all available GPUs: {gpu_ids}") else: rank0_print("Error: 'all' GPUs requested, but CUDA is not available.") sys.exit(1) else: try: gpu_ids = [int(id.strip()) for id in args.gpu_ids.split(',')] # Validate GPU IDs if torch.cuda.is_available(): num_gpus = torch.cuda.device_count() for gpu_id in gpu_ids: if gpu_id < 0 or gpu_id >= num_gpus: rank0_print(f"Error: Invalid GPU ID {gpu_id}. Available GPUs: {list(range(num_gpus))}") sys.exit(1) else: rank0_print(f"Warning: Specified GPU IDs {gpu_ids}, but CUDA is not available. Will attempt CPU if possible (not recommended/tested).") # Or exit if CPU processing is not intended/supported # sys.exit(1) rank0_print(f"Using specified GPUs: {gpu_ids}") except ValueError: rank0_print(f"Error: Invalid format for --gpu-ids. Expected comma-separated integers (e.g., '0,1,2') or 'all'. Got: {args.gpu_ids}") sys.exit(1) if not gpu_ids: rank0_print("Error: No valid GPUs specified or found.") sys.exit(1) num_workers = len(gpu_ids) # --- Prepare Output Directory --- output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # Use Path.mkdir if args.export_point_cloud: pc_output_dir = Path(args.point_cloud_output_dir) pc_output_dir.mkdir(parents=True, exist_ok=True) rank0_print(f"Point clouds will be saved to: {args.point_cloud_output_dir}") if args.save_preprocessed_frames: frames_output_dir = Path(args.save_preprocessed_frames_dir) frames_output_dir.mkdir(parents=True, exist_ok=True) rank0_print(f"Preprocessed frames will be saved to: {args.save_preprocessed_frames_dir}") # --- Determine Input Files --- if args.input_file: input_file_path = Path(args.input_file) if not input_file_path.is_file(): rank0_print(f"Error: Provided --input-file '{args.input_file}' not found or is not a file.") sys.exit(1) all_video_files_paths = [input_file_path] input_base_dir = Path(args.input_dir) if args.input_dir and input_file_path.is_relative_to(args.input_dir) else input_file_path.parent rank0_print(f"Processing single input file: {args.input_file}") elif args.input_dir: input_base_dir = Path(args.input_dir) # Find files needs Path objects all_video_files_paths_str = find_video_files(args.input_dir) all_video_files_paths = [Path(p) for p in all_video_files_paths_str] # Keep as Path objects if not all_video_files_paths: rank0_print(f"No video files found in {args.input_dir}. Exiting.") sys.exit(0) rank0_print(f"Found {len(all_video_files_paths)} video files in {args.input_dir}.") else: # This case should be caught by parser.error earlier rank0_print("Error: No input specified.") sys.exit(1) # --- Distribute Files Among Workers --- files_per_worker = [[] for _ in range(num_workers)] for i, file_path in enumerate(all_video_files_paths): worker_index = i % num_workers # Pass file paths as strings to worker processes files_per_worker[worker_index].append(str(file_path)) # --- Launch Worker Processes --- rank0_print(f"Starting feature extraction with {num_workers} worker process(es) on GPUs {gpu_ids}...") pool_args = [] for rank, gpu_id in enumerate(gpu_ids): pool_args.append( (rank, gpu_id, args, files_per_worker[rank], input_base_dir, output_dir) ) total_processed = 0 total_skipped = 0 try: with mp.Pool(processes=num_workers) as pool: # Use starmap to pass multiple arguments to the worker function results = pool.starmap(process_videos_on_gpu, pool_args) # Aggregate results for processed, skipped in results: total_processed += processed total_skipped += skipped except Exception as e: rank0_print(f"\n--- An error occurred during multiprocessing ---") rank0_print(f"Error: {e}") rank0_print(traceback.format_exc()) rank0_print("Feature extraction may be incomplete.") # Ensure totals reflect potentially partial completion if some processes finished if 'results' in locals(): for processed, skipped in results: total_processed += processed total_skipped += skipped else: # If pool creation failed or starmap didn't even start total_skipped = len(all_video_files_paths) # --- Final Summary --- rank0_print("-" * 30) rank0_print(f"Feature extraction complete.") rank0_print(f"Successfully processed: {total_processed}") rank0_print(f"Skipped (exists or error): {total_skipped}") rank0_print(f"Total files considered: {len(all_video_files_paths)}") rank0_print(f"Features saved in: {args.output_dir}")