Update code

.gitignore

@@ -0,0 +1,2 @@
+preprocessing/__pycache__/
+preprocessing/vision_encoders/__pycache__/

preprocessing/dataset.py

@@ -0,0 +1,30 @@
+from torch.utils.data import Dataset
+from typing import List
+import os
+from mm_datautils import process_video_frames
+from transformers import BaseImageProcessor
+
+class EnTubeDataset(Dataset):
+    
+    def __init__(
+        self,   
+        folder_paths: List[str],
+        image_processor: List[BaseImageProcessor],
+        device: str
+    ) -> None:
+        self.videos = []
+        self.image_sizes = []
+        self.device = device
+        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)
+                video, image_size = process_video_frames(file_path, image_processor, device)
+                self.videos.append(video)
+                self.image_sizes.append(image_size)
+
+    def __len__():
+        return len(self.image_sizes)
+
+    def __getitem__(idx):
+        return self.videos[idx], self.image_sizes[idx]

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 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,23 @@ if __name__ == "__main__":
 
     cambrianConfig = CambrianConfig.from_json_file(args.config_file)
     processor = CambrianEncoders(cambrianConfig)
+    image_processors = []
+    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=4)
 
-        # 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))
+        
 
     save_file(dict(data_tensor), args.output_file)

preprocessing/mm_datautils.py

@@ -2,6 +2,8 @@ import numpy as np
 from PIL import Image
 import torch
 from decord import cpu, VideoReader
+from transformers import BaseImageProcessor
+from typing import List, List, Union, Tuple
 
 def expand2square(pil_img, background_color):
     width, height = pil_img.size
@@ -16,7 +18,11 @@ def expand2square(pil_img, background_color):
         result.paste(pil_img, ((height - width) // 2, 0))
         return result
 
-def process_images(images, image_processor, model_cfg):
+def process_images(
+    images: torch.Tensor, 
+    image_processor: List[BaseImageProcessor],
+    device: str
+) -> Union[torch.Tensor, List[torch.Tensor]]:
     if isinstance(image_processor, list):
         processor_aux_list = image_processor
         new_images_aux_list = []
@@ -43,11 +49,11 @@ def process_images(images, image_processor, model_cfg):
             list(batch_image_aux) for batch_image_aux in zip(*new_images_aux_list)
         ]
         new_images_aux_list = [
-            torch.stack(image_aux).half().cuda() for image_aux in new_images_aux_list
+            torch.stack(image_aux).half().to(device) for image_aux in new_images_aux_list
         ]
         return new_images_aux_list
     else:
-        image_aspect_ratio = getattr(model_cfg, "image_aspect_ratio", None)
+        image_aspect_ratio = "pad"
         new_images = []
         if image_aspect_ratio == "pad":
             for image in images:
@@ -64,7 +70,11 @@ def process_images(images, image_processor, model_cfg):
             new_images = torch.stack(new_images, dim=0)
         return new_images
 
-def process_video_frames(video_path: str):
+def process_video_frames(
+    video_path: str,
+    image_processor: List[BaseImageProcessor],
+    device: str
+) -> Tuple[List[torch.Tensor], List[Tuple[int, int]]]:
     vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
     fps = float(vr.get_avg_fps())
     frame_indices = np.array([i for i in range(0, len(vr), round(fps),)])
@@ -74,6 +84,6 @@ def process_video_frames(video_path: str):
         video.append(img)
     video = np.stack(video)
     image_sizes = [video[0].shape[:2]]
-    video = process_images(video, image_processor, self.config)
+    video = process_images(video, image_processor, device)
     video = [item.unsqueeze(0) for item in video]
     return video, image_sizes

preprocessing/preprocessor.py

@@ -1,9 +1,9 @@
 from vision_encoders.builder import build_vision_tower_aux_list
 from transformers import Qwen2Config
-from mm_datautils import process_video_frames
 from typing import Optional, List, Tuple
 import torch
 import json
+from transformers import BaseImageProcessor
 
 class CambrianConfig(Qwen2Config):
     model_type = "cambrian_qwen"

requirements.txt

@@ -4,4 +4,6 @@ decord
 torch==2.1.2
 torchvision
 transformers==4.42.4
-safetensors
+safetensors
+pillow
+huggingface_hub