collate_fn for dataloader and extract vision features

preprocessing/constants.py

@@ -1 +1 @@
-NUM_PROCESSED_FRAMES = 600
+CHUNK_SIZE = 64 # adapted from LongVU: number of frames in each chunk

preprocessing/entube_dataset.py

@@ -1,8 +1,3 @@
-import sys
-from pathlib import Path
-sys.path.append(str(Path.cwd()))
-from annotation.utils import get_optimal_workers
-
 import torch
 from torch.utils.data import Dataset
 from typing import List
@@ -16,36 +11,55 @@ class EnTubeDataset(Dataset):
     def __init__(
         self,   
         folder_paths: List[str],
-        image_processor: List[BaseImageProcessor],
+        image_processors: List[BaseImageProcessor],
         device: str
     ) -> None:
-        self.videos = []
-        self.image_sizes = []
+        self.file_paths = []
+        self.image_processors = image_processors
         self.device = device
 
-        with ThreadPoolExecutor(max_workers=get_optimal_workers()) as executor:
-            futures = []
-            for folder_path in folder_paths:
-                print(f'@tcm: In EnTubeDataset.__init__(): folder_path={folder_path}')
-                file_names = os.listdir(folder_path)
-                for file_name in file_names:
-                    file_path = os.path.join(folder_path, file_name)
-                    print(f'@tcm: In EnTubeDataset.__init__(): file_path={file_path}')
-                    future = executor.submit(process_video_frames, file_path, image_processor, device)
-                    futures.append(future)
-
-            for future in as_completed(futures):
-                result = future.result()
-                if result is not None:
-                    video, image_size = result
-                    self.videos.append(video)
-                    self.image_sizes.append(image_size)
+        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)
+                self.file_paths.append(file_path)
+
+        # with ThreadPoolExecutor(max_workers=get_optimal_workers()) as executor:
+        #     futures = []
+        #     for folder_path in folder_paths:
+        #         print(f'@tcm: In EnTubeDataset.__init__(): folder_path={folder_path}')
+        #         file_names = os.listdir(folder_path)
+        #         for file_name in file_names:
+        #             file_path = os.path.join(folder_path, file_name)
+        #             print(f'@tcm: In EnTubeDataset.__init__(): file_path={file_path}')
+        #             future = executor.submit(process_video_frames, file_path, image_processor, device)
+        #             futures.append(future)
+
+        #     for future in as_completed(futures):
+        #         result = future.result()
+        #         if result is not None:
+        #             video, image_size = result
+        #             self.videos.append(video)
+        #             self.image_sizes.append(image_size)
 
         
 
     def __len__(self):
-        return len(self.image_sizes)
+        return len(self.file_paths)
 
     def __getitem__(self, idx):
-        print(f'@tcm: In EnTubeDataset.__getitem__(): idx={idx}, video shape: {self.videos[idx][0].shape}')
-        return self.videos[idx], self.image_sizes[idx]
+        print(f'@tcm: In EnTubeDataset.__getitem__(): idx={idx}')
+        video, image_size = process_video_frames(self.file_paths[idx], self.image_processors, self.device)
+        return video, image_size
+
+def collate_fn(batch):
+    """
+    batch: list of samples from EnTubeDataset.__getitem__()
+    """
+    assert isinstance(batch, list)
+    assert isinstance(batch[0], tuple)
+    
+    image_sizes = batch[0][1]
+    batch_videos = [video for video, _ in batch]
+    batch_videos = [list(videos) for videos in zip(*batch_videos)]
+    return batch_videos, image_sizes

preprocessing/main.py

@@ -1,3 +1,8 @@
+import sys
+from pathlib import Path
+sys.path.append(str(Path.cwd()))
+from annotation.utils import get_optimal_workers
+
 import os
 import argparse
 from typing import List, Dict
@@ -8,7 +13,7 @@ from safetensors.torch import save_file
 from collections import defaultdict
 import logging
 from multiprocessing import cpu_count
-from entube_dataset import EnTubeDataset
+from entube_dataset import EnTubeDataset, collate_fn
 from torch.utils.data import Dataset, DataLoader
 from transformers import BaseImageProcessor
 
@@ -74,13 +79,22 @@ if __name__ == "__main__":
     
     device = 'cuda' if torch.cuda.is_available() else 'cpu'
     entube_dataset = EnTubeDataset(folder_paths, image_processors, device)
-    dataloader = DataLoader(entube_dataset, batch_size=1)
+    dataloader = DataLoader(
+        entube_dataset, 
+        batch_size=4, 
+        collate_fn=collate_fn,
+        # num_workers=get_optimal_workers()
+        num_workers=1
+    )
 
     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))
+        assert isinstance(videos, list), "List of videos features for each processor (vision encoder)"
+        assert isinstance(videos[0], list) or isinstance(videos[0], torch.Tensor), "List of videos in the batch"
+        image_aux_features_list = processor.prepare_mm_features(videos, image_sizes)
+        for i, image_aux_features in enumerate(image_aux_features_list):
+            print(f"@tcm: In main(): image_aux_features[{i}].shape={image_aux_features.shape}")
         break
         
 
-    save_file(dict(data_tensor), args.output_file)
+    # save_file(dict(data_tensor), args.output_file)

preprocessing/mm_datautils.py

@@ -22,7 +22,7 @@ def expand2square(pil_img, background_color):
 
 def process_images(
     images: torch.Tensor, 
-    image_processor: BaseImageProcessor,
+    image_processor: List[BaseImageProcessor],
     device: str
 ) -> Union[torch.Tensor, List[torch.Tensor]]:
     # images.shape: (4294, 360, 640, 3)
@@ -80,7 +80,7 @@ def process_images(
 
 def process_video_frames(
     video_path: str,
-    image_processor: List[BaseImageProcessor],
+    image_processors: List[BaseImageProcessor],
     device: str
 ) -> Tuple[List[torch.Tensor], List[Tuple[int, int]]]:
     vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
@@ -89,17 +89,17 @@ def process_video_frames(
     print(f'@tcm: In process_video_frames(): # frames = {len(frame_indices)}')
     image_sizes = [vr[0].shape[:2]]
 
-    video = [[] for _ in range(len(image_processor))]
-    for i in range(0, len(frame_indices), NUM_PROCESSED_FRAMES):
-        print(f'@tcm: In process_video_frames(): segment {i/NUM_PROCESSED_FRAMES}')
-        sub_frame_indices = frame_indices[i:min(i+NUM_PROCESSED_FRAMES, len(frame_indices))]
+    video = [[] for _ in range(len(image_processors))]
+    for i in range(0, len(frame_indices), CHUNK_SIZE):
+        print(f'@tcm: In process_video_frames(): segment {int(i/CHUNK_SIZE)}')
+        sub_frame_indices = frame_indices[i:min(i+CHUNK_SIZE, len(frame_indices))]
         sub_videos = []
         process_time = time.time()
         for frame_index in sub_frame_indices:
             img = vr[frame_index].asnumpy()
             sub_videos.append(img)
         sub_videos = np.stack(sub_videos) # shape: (num_frames, height, width, channels)
-        sub_videos = process_images(sub_videos, image_processor, device)
+        sub_videos = process_images(sub_videos, image_processors, device)
         print(f'@tcm: In process_video_frames(): process_time={time.time()-process_time:4f}')
         assert len(sub_videos) == len(video)
         for j, sub_video in enumerate(sub_videos):
@@ -120,7 +120,7 @@ def process_video_frames(
     # print(f'@tcm: In process_video_frames(): vectorize_time={time.time()-vectorize_time:4f}')
     # image_sizes = [video[0].shape[:2]]
     # process_time = time.time()
-    # video = process_images(video, image_processor, device)
+    # video = process_images(video, image_processors, device)
     # print(f'@tcm: In process_video_frames(): process_time={time.time()-process_time:4f}')
     video = [item.unsqueeze(0) for item in video]
     return video, image_sizes