Segment long videos and multithreading in EnTubeDataset

annotation/annotate.py

@@ -1,3 +1,8 @@
+# In case this module is invoked from other modules, e.g., preprocessing
+from pathlib import Path
+import sys
+sys.path.append(str(Path.cwd() / "annotation"))
+
 import json
 import os
 from typing import List, Union, Dict, Any, Callable, Optional

annotation/train_test.py

@@ -1,3 +1,8 @@
+# In case this module is invoked from other modules, e.g., preprocessing
+from pathlib import Path
+import sys
+sys.path.append(str(Path.cwd() / "annotation"))
+
 import json
 import os
 import argparse

annotation/utils.py

@@ -1,3 +1,8 @@
+# In case this module is invoked from other modules, e.g., preprocessing
+from pathlib import Path
+import sys
+sys.path.append(str(Path.cwd() / "annotation"))
+
 import decord as de
 from datatypes import Metadata
 from typing import List
@@ -6,6 +11,7 @@ from multiprocessing import cpu_count
 import traceback
 from pathlib import Path
 
+
 def convert_to_linux_path(path: str) -> str:
     return Path(path).as_posix()
 

preprocessing/constants.py

@@ -0,0 +1 @@
+NUM_PROCESSED_FRAMES = 600

preprocessing/entube_dataset.py

@@ -1,9 +1,15 @@
+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
 import os
 from mm_datautils import process_video_frames
 from transformers import BaseImageProcessor
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 class EnTubeDataset(Dataset):
     
@@ -16,20 +22,30 @@ class EnTubeDataset(Dataset):
         self.videos = []
         self.image_sizes = []
         self.device = device
-        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}')
-                video, image_size = process_video_frames(file_path, image_processor, device)
-                self.videos.append(video)
-                self.image_sizes.append(image_size)
+
+        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)
 
     def __getitem__(self, idx):
-        print(f'@tcm: In EnTubeDataset.__getitem__(): idx={idx}')
-        print(f'@tcm: In EnTubeDataset.__getitem__(): video shape: {self.videos[idx][0].shape}')
+        print(f'@tcm: In EnTubeDataset.__getitem__(): idx={idx}, video shape: {self.videos[idx][0].shape}')
         return self.videos[idx], self.image_sizes[idx]

preprocessing/mm_datautils.py

@@ -5,6 +5,7 @@ from decord import cpu, VideoReader
 from transformers import BaseImageProcessor
 from typing import List, Union, Tuple
 import time
+from constants import *
 
 def expand2square(pil_img, background_color):
     width, height = pil_img.size
@@ -25,7 +26,7 @@ def process_images(
     device: str
 ) -> Union[torch.Tensor, List[torch.Tensor]]:
     # images.shape: (4294, 360, 640, 3)
-    print(f'@tcm: In process_images(): images.shape={images.shape}')
+    # print(f'@tcm: In process_images(): images.shape={images.shape}')
     if isinstance(image_processor, list):
         processor_aux_list = image_processor
         new_images_aux_list = []
@@ -51,7 +52,7 @@ def process_images(
                 # image_aux.shape: torch.Size([3, 384, 384])
                 image_aux_list.append(image_aux)
             new_images_aux_list.append(image_aux_list) # torch.Tensor(C, H, W) new_images_aux_list[num_frames][num_processor]
-        print()
+        
         new_images_aux_list = [
             list(batch_image_aux) for batch_image_aux in zip(*new_images_aux_list)
         ] # torch.Tensor(C, H, W) new_images_aux_list[num_processor][num_frames]
@@ -82,21 +83,44 @@ def process_video_frames(
     image_processor: List[BaseImageProcessor],
     device: str
 ) -> Tuple[List[torch.Tensor], List[Tuple[int, int]]]:
-    init_time = time.time()
     vr = VideoReader(video_path, ctx=cpu(0), num_threads=1)
-    print(f'@tcm: In process_video_frames(): init_time={time.time()-init_time:4f}')
     fps = float(vr.get_avg_fps())
     frame_indices = np.array([i for i in range(0, len(vr), round(fps),)])
-    video = []
-    vectorize_time = time.time()
-    for frame_index in frame_indices:
-        img = vr[frame_index].asnumpy()
-        video.append(img)
-    video = np.stack(video) # shape: (num_frames, height, width, channels)
-    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)
-    print(f'@tcm: In process_video_frames(): process_time={time.time()-process_time:4f}')
+    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))]
+        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)
+        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):
+            video[j].append(sub_video)
+        
+        del sub_videos
+        if 'cuda' in device:
+            torch.cuda.empty_cache()
+
+    for i in range(len(video)):
+        video[i] = torch.cat(video[i], dim=0)
+    
+    # vectorize_time = time.time()
+    # for frame_index in frame_indices:
+    #     img = vr[frame_index].asnumpy()
+    #     video.append(img)
+    # video = np.stack(video) # shape: (num_frames, height, width, channels)
+    # 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)
+    # 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