I think batching data loader is more general: give batch_size=1 in case limited mem

preprocessing/main.py

@@ -1,14 +1,19 @@
 import os
+os.environ["HF_HOME"] = "D:\\hf_cache"
+
 import argparse
 from typing import List, Dict
 from mm_datautils import process_video_frames
 from preprocessor import CambrianConfig, CambrianEncoders
 import torch
 from safetensors.torch import save_file
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from collections import defaultdict
 import logging
 from multiprocessing import cpu_count
+from entube_dataset import EnTubeDataset
+from torch.utils.data import Dataset, DataLoader
+from transformers import BaseImageProcessor
+
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -57,26 +62,27 @@ if __name__ == "__main__":
 
     cambrianConfig = CambrianConfig.from_json_file(args.config_file)
     processor = CambrianEncoders(cambrianConfig)
+    image_processors = []
+    if not processor.vision_tower_aux_list[0].is_loaded:
+        processor.vision_tower_aux_list[0].load_model()
+    image_processors.append(processor.vision_tower_aux_list[0].image_processor)
+    # for vision_tower_aux in processor.vision_tower_aux_list:
+    #     if not vision_tower_aux.is_loaded:
+    #         vision_tower_aux.load_model()
+    #     image_processors.append(vision_tower_aux.image_processor)
 
     folder_paths: List[str] = args.folders
-    data_tensor = defaultdict(torch.Tensor)  # Use defaultdict for thread safety
-    # Determine optimal workers
-    optimal_workers = get_optimal_workers()
-    print(f"Using {optimal_workers} workers for multithreading.")
-
-    with ThreadPoolExecutor(max_workers=optimal_workers) as executor:
-        # Submit all tasks upfront
-        futures = []
-        for folder_path in folder_paths:
-            file_names = os.listdir(folder_path)
-            for file_name in file_names:
-                file_path = os.path.join(folder_path, file_name)
-                futures.append(executor.submit(extract_features, processor, file_path, file_name))
+    data_tensor = dict()
+    
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    entube_dataset = EnTubeDataset(folder_paths, image_processors, device)
+    dataloader = DataLoader(entube_dataset, batch_size=1)
 
-        # Collect results as tasks complete
-        for future in as_completed(futures):
-            result = future.result()
-            if result:
-                data_tensor.update(result)  # Thread-safe update using defaultdict
+    for batch_idx, (videos, image_sizes) in enumerate(dataloader):
+        print(f"Processing batch {batch_idx + 1}/{len(dataloader)}")
+        print(type(videos))
+        print(type(image_sizes))
+        break
+        
 
-    save_file(dict(data_tensor), args.output_file)
+    save_file(dict(data_tensor), args.output_file)