Merge new repo on WSL Ubuntu and remote HF

.gitattributes

@@ -1,59 +1,59 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,4 +1,4 @@
-preprocessing/__pycache__/
-preprocessing/vision_encoders/__pycache__/
-annotations/__pycache__/
+preprocessing/__pycache__/
+preprocessing/vision_encoders/__pycache__/
+annotations/__pycache__/
 .vscode/

2.4.0

@@ -0,0 +1,5 @@
+Collecting pygments
+  Using cached pygments-2.18.0-py3-none-any.whl.metadata (2.5 kB)
+Using cached pygments-2.18.0-py3-none-any.whl (1.2 MB)
+Installing collected packages: pygments
+Successfully installed pygments-2.18.0

annotation/annotate.py

@@ -1,59 +1,59 @@
-# 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
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datatypes import VideoAnnotation, Metadata
-from utils import get_optimal_workers, extract_label, convert_to_linux_path
-
-
-def annotate_video(
-    file_path: str,
-    label: str,
-    video_filter: Callable[[str, Any], bool] = lambda path: True,
-    **kwargs
-) -> VideoAnnotation:
-    if not video_filter(file_path, **kwargs):
-        return None
-    # print(f'Begin annotating {file_path}...')
-    json_content: VideoAnnotation = {
-        'video': convert_to_linux_path(file_path),
-        'label': label,
-        'conversations': [
-            {
-                'from': 'human',    
-                'value': '<image>\nThis video is a Youtube video on one of many categories such as Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs, etc. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The higher number of likes and lower number of dislikes, the more engaged the video is. The final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged). Please predict one of the three labels for this video, based on its contents only.'
-            },
-            {
-                'from': 'gpt',
-                'value': f'The engagement label of the video is {label}.'
-            }
-        ]
-    }
-    return json_content
-
-
-
-def dump_json(
-    metadata: Metadata,
-    video_filter: Callable[[str, Any], bool] = lambda path: True,
-    **kwargs
-) -> List[VideoAnnotation]:
-    print(f'Annotating {len(metadata)} videos...')
-    json_contents: List[VideoAnnotation] = []
-
-    with ThreadPoolExecutor(max_workers=get_optimal_workers()) as executor:
-        futures = []
-        for (file_path, label) in metadata:
-            futures.append(executor.submit(annotate_video, file_path, label, video_filter=video_filter, **kwargs))
-        
-        for future in as_completed(futures):
-            result = future.result()
-            if result:
-                json_contents.append(result)
-    
+# 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
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datatypes import VideoAnnotation, Metadata
+from utils import get_optimal_workers, extract_label, convert_to_linux_path
+
+
+def annotate_video(
+    file_path: str,
+    label: str,
+    video_filter: Callable[[str, Any], bool] = lambda path: True,
+    **kwargs
+) -> VideoAnnotation:
+    if not video_filter(file_path, **kwargs):
+        return None
+    # print(f'Begin annotating {file_path}...')
+    json_content: VideoAnnotation = {
+        'video': convert_to_linux_path(file_path),
+        'label': label,
+        'conversations': [
+            {
+                'from': 'human',    
+                'value': '<image>\nThis video is a Youtube video on one of many categories such as Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs, etc. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The higher number of likes and lower number of dislikes, the more engaged the video is. The final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged). Please predict one of the three labels for this video, based on its contents only.'
+            },
+            {
+                'from': 'gpt',
+                'value': f'The engagement label of the video is {label}.'
+            }
+        ]
+    }
+    return json_content
+
+
+
+def dump_json(
+    metadata: Metadata,
+    video_filter: Callable[[str, Any], bool] = lambda path: True,
+    **kwargs
+) -> List[VideoAnnotation]:
+    print(f'Annotating {len(metadata)} videos...')
+    json_contents: List[VideoAnnotation] = []
+
+    with ThreadPoolExecutor(max_workers=get_optimal_workers()) as executor:
+        futures = []
+        for (file_path, label) in metadata:
+            futures.append(executor.submit(annotate_video, file_path, label, video_filter=video_filter, **kwargs))
+        
+        for future in as_completed(futures):
+            result = future.result()
+            if result:
+                json_contents.append(result)
+    
     return json_contents

annotation/datatypes.py

@@ -1,4 +1,4 @@
-from typing import List, Union, Dict, Tuple, Callable, Optional
-
-VideoAnnotation = Optional[Dict[str, Union[str, List[Dict[str, str]]]]]
+from typing import List, Union, Dict, Tuple, Callable, Optional
+
+VideoAnnotation = Optional[Dict[str, Union[str, List[Dict[str, str]]]]]
 Metadata = List[Tuple[str, str]]

annotation/train_test.py

@@ -1,87 +1,87 @@
-# 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
-from sklearn.model_selection import train_test_split
-from datatypes import VideoAnnotation, Metadata
-from annotate import dump_json
-from utils import get_metadata, filter_video
-from typing import List
-
-
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser(
-        prog = 'train_test.py',
-        description='Annotate video dataset with JSON format'
-    )
-    parser.add_argument(
-        '--folders',
-        type = str,
-        nargs = '+',
-        required = True,
-        help = "List of folder paths to video data"
-    )
-    parser.add_argument(
-        '--train_size', 
-        type=float, 
-        default=0.8, 
-        help='Proportion of the dataset for training'
-    )
-    parser.add_argument(
-        '--output_train_file', 
-        type=str, 
-        default='data/EnTube_train.json', 
-        help='Output JSON file for training'
-    )
-    parser.add_argument(
-        '--output_test_file',
-        type=str,
-        default='data/EnTube_test.json',
-        help='Output JSON file for testing'
-    )
-    parser.add_argument(
-        '--max_duration', 
-        type=int, 
-        help='Maximum duration of video in seconds'
-    )
-    parser.add_argument(
-        '--random_state',
-        type=int,
-        default=42,
-        help='Random seed for train-test split'
-    )
-    args = parser.parse_args()
-
-    folder_paths: List[str] = args.folders
-    metadata: Metadata = get_metadata(folder_paths)
-    # split metadata into 3 submetadata corresponding to 3 labels
-    metadata_label = {0: [], 1: [], 2: []}
-    for video, label in metadata:
-        metadata_label[int(label)].append((video, label))
-    train = []
-    test = []
-    for label, videos in metadata_label.items():
-        train_l, test_l = train_test_split(
-            videos,
-            train_size=args.train_size,
-            random_state=args.random_state
-        )
-        print(f'Label {label}: {len(train_l)} training videos, {len(test_l)} testing videos')
-        train.extend(train_l)
-        test.extend(test_l)
-
-    json_train: List[VideoAnnotation] = dump_json(train, filter_video, **vars(args))
-    json_test: List[VideoAnnotation] = dump_json(test, filter_video, **vars(args))
-
-    with open(args.output_train_file, 'w') as f:
-        json.dump(json_train, f, indent=4)
-    print(f"Training data saved to {args.output_train_file}")
-    with open(args.output_test_file, 'w') as f:
-        json.dump(json_test, f, indent=4)
+# 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
+from sklearn.model_selection import train_test_split
+from datatypes import VideoAnnotation, Metadata
+from annotate import dump_json
+from utils import get_metadata, filter_video
+from typing import List
+
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(
+        prog = 'train_test.py',
+        description='Annotate video dataset with JSON format'
+    )
+    parser.add_argument(
+        '--folders',
+        type = str,
+        nargs = '+',
+        required = True,
+        help = "List of folder paths to video data"
+    )
+    parser.add_argument(
+        '--train_size', 
+        type=float, 
+        default=0.8, 
+        help='Proportion of the dataset for training'
+    )
+    parser.add_argument(
+        '--output_train_file', 
+        type=str, 
+        default='data/EnTube_train.json', 
+        help='Output JSON file for training'
+    )
+    parser.add_argument(
+        '--output_test_file',
+        type=str,
+        default='data/EnTube_test.json',
+        help='Output JSON file for testing'
+    )
+    parser.add_argument(
+        '--max_duration', 
+        type=int, 
+        help='Maximum duration of video in seconds'
+    )
+    parser.add_argument(
+        '--random_state',
+        type=int,
+        default=42,
+        help='Random seed for train-test split'
+    )
+    args = parser.parse_args()
+
+    folder_paths: List[str] = args.folders
+    metadata: Metadata = get_metadata(folder_paths)
+    # split metadata into 3 submetadata corresponding to 3 labels
+    metadata_label = {0: [], 1: [], 2: []}
+    for video, label in metadata:
+        metadata_label[int(label)].append((video, label))
+    train = []
+    test = []
+    for label, videos in metadata_label.items():
+        train_l, test_l = train_test_split(
+            videos,
+            train_size=args.train_size,
+            random_state=args.random_state
+        )
+        print(f'Label {label}: {len(train_l)} training videos, {len(test_l)} testing videos')
+        train.extend(train_l)
+        test.extend(test_l)
+
+    json_train: List[VideoAnnotation] = dump_json(train, filter_video, **vars(args))
+    json_test: List[VideoAnnotation] = dump_json(test, filter_video, **vars(args))
+
+    with open(args.output_train_file, 'w') as f:
+        json.dump(json_train, f, indent=4)
+    print(f"Training data saved to {args.output_train_file}")
+    with open(args.output_test_file, 'w') as f:
+        json.dump(json_test, f, indent=4)
     print(f"Testing data saved to {args.output_test_file}")

annotation/utils.py

@@ -1,68 +1,68 @@
-# 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
-import os
-from multiprocessing import cpu_count
-import traceback
-from pathlib import Path
-
-
-def convert_to_linux_path(path: str) -> str:
-    return Path(path).as_posix()
-
-def extract_label(path: str) -> str:
-    idx = len(path) - 1
-    while idx >= 0:
-        if path[idx].isnumeric():
-            return path[idx]
-        idx -= 1
-    return '-1'
-
-def get_duration(path: str) -> int:
-    try:
-        vr = de.VideoReader(path, ctx=de.cpu(0), num_threads=1)
-        return int(len(vr) / vr.get_avg_fps())
-    except Exception as e:
-        print(f"Error reading video {path}: {e}")
-        print(traceback.format_exc())  # Include the full traceback for debugging
-        return -1  # Use -1 to indicate an invalid duration
-
-def filter_video(path: str, **kwargs) -> bool:
-    try:
-        max_duration = kwargs.get('max_duration', None)
-        if max_duration is not None:
-            duration = get_duration(path)
-            if duration == -1:  # Handle invalid duration
-                print(f"Skipping invalid video: {path}")
-                return False
-            return duration <= max_duration
-        return True
-    except Exception as e:
-        print(f"Error in filter_video for {path}: {e}")
-        return False
-
-def get_optimal_workers() -> int:
-    """Determine the optimal number of workers based on available CPU cores."""
-    try:
-        return max(1, cpu_count() - 1)  # Leave one core free
-    except (NotImplementedError, ValueError):
-        return 1  # Fallback to a single worker in case of an error
-
-def get_metadata(
-    folder_paths: List[str]
-) -> Metadata:
-    metadata: Metadata = []
-    for folder_path in folder_paths:
-        label: str = extract_label(folder_path)
-        assert label != '-1', f"Invalid folder path: {folder_path}"
-        for file_name in os.listdir(folder_path):
-            file_path: str = os.path.join(folder_path.rstrip('/'), file_name)
-            if os.path.exists(file_path) and os.path.isfile(file_path):
-                metadata.append((file_path, label))
-    print(f'Found {len(metadata)} videos')
+# 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
+import os
+from multiprocessing import cpu_count
+import traceback
+from pathlib import Path
+
+
+def convert_to_linux_path(path: str) -> str:
+    return Path(path).as_posix()
+
+def extract_label(path: str) -> str:
+    idx = len(path) - 1
+    while idx >= 0:
+        if path[idx].isnumeric():
+            return path[idx]
+        idx -= 1
+    return '-1'
+
+def get_duration(path: str) -> int:
+    try:
+        vr = de.VideoReader(path, ctx=de.cpu(0), num_threads=1)
+        return int(len(vr) / vr.get_avg_fps())
+    except Exception as e:
+        print(f"Error reading video {path}: {e}")
+        print(traceback.format_exc())  # Include the full traceback for debugging
+        return -1  # Use -1 to indicate an invalid duration
+
+def filter_video(path: str, **kwargs) -> bool:
+    try:
+        max_duration = kwargs.get('max_duration', None)
+        if max_duration is not None:
+            duration = get_duration(path)
+            if duration == -1:  # Handle invalid duration
+                print(f"Skipping invalid video: {path}")
+                return False
+            return duration <= max_duration
+        return True
+    except Exception as e:
+        print(f"Error in filter_video for {path}: {e}")
+        return False
+
+def get_optimal_workers() -> int:
+    """Determine the optimal number of workers based on available CPU cores."""
+    try:
+        return max(1, cpu_count() - 1)  # Leave one core free
+    except (NotImplementedError, ValueError):
+        return 1  # Fallback to a single worker in case of an error
+
+def get_metadata(
+    folder_paths: List[str]
+) -> Metadata:
+    metadata: Metadata = []
+    for folder_path in folder_paths:
+        label: str = extract_label(folder_path)
+        assert label != '-1', f"Invalid folder path: {folder_path}"
+        for file_name in os.listdir(folder_path):
+            file_path: str = os.path.join(folder_path.rstrip('/'), file_name)
+            if os.path.exists(file_path) and os.path.isfile(file_path):
+                metadata.append((file_path, label))
+    print(f'Found {len(metadata)} videos')
     return metadata

data/EnTube_short_train.json

@@ -1,44 +1,44 @@
-[
-    {
-        "video": "0/jh2wXnuckEs.mp4",
-        "label": "0",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 0."
-            }
-        ]
-    },
-    {
-        "video": "1/5YbX5V7O8Oc.mp4",
-        "label": "1",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 1."
-            }
-        ]
-    },
-    {
-        "video": "2/kiVkwc1MR8U.mp4",
-        "label": "2",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 2."
-            }
-        ]
-    }
+[
+    {
+        "video": "0/jh2wXnuckEs.mp4",
+        "label": "0",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 0."
+            }
+        ]
+    },
+    {
+        "video": "1/5YbX5V7O8Oc.mp4",
+        "label": "1",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 1."
+            }
+        ]
+    },
+    {
+        "video": "2/kiVkwc1MR8U.mp4",
+        "label": "2",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 2."
+            }
+        ]
+    }
 ]

data/EnTube_short_val.json

@@ -1,44 +1,44 @@
-[
-    {
-        "video": "0/o89G2LyStsI.mp4",
-        "label": "0",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 0."
-            }
-        ]
-    },
-    {
-        "video": "1/oPC9C21Tt1o.mp4",
-        "label": "1",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 1."
-            }
-        ]
-    },
-    {
-        "video": "2/wbZk7Mkgf9Q.mp4",
-        "label": "2",
-        "conversations": [
-            {
-                "from": "human",
-                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
-            },
-            {
-                "from": "gpt",
-                "value": "The engagement label of the video is 2."
-            }
-        ]
-    }
+[
+    {
+        "video": "0/o89G2LyStsI.mp4",
+        "label": "0",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 0."
+            }
+        ]
+    },
+    {
+        "video": "1/oPC9C21Tt1o.mp4",
+        "label": "1",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 1."
+            }
+        ]
+    },
+    {
+        "video": "2/wbZk7Mkgf9Q.mp4",
+        "label": "2",
+        "conversations": [
+            {
+                "from": "human",
+                "value": "<image>\nThis video is a Youtube video on one of the following categories: Education, Film & Animation, Comedy, Entertainment, Music, Howto & Style, and People & Blogs. The engagement rate defined for each such video is based on the number of potential likes and dislikes only when published on Youtube. The exact formula for the score is (likes-dislikes) / (likes+dislikes) and the final prediction label is either 0 (not engaged), 1 (neutral), or 2 (engaged) based on thresholding this score. Please predict one of the three labels for this video, based on its contents only."
+            },
+            {
+                "from": "gpt",
+                "value": "The engagement label of the video is 2."
+            }
+        ]
+    }
 ]

preprocessing/entube_dataset.py

@@ -1,65 +1,65 @@
-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):
-    
-    def __init__(
-        self,   
-        folder_paths: List[str],
-        image_processors: List[BaseImageProcessor],
-        device: str
-    ) -> None:
-        self.file_paths = []
-        self.image_processors = image_processors
-        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)
-                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.file_paths)
-
-    def __getitem__(self, 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
+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):
+    
+    def __init__(
+        self,   
+        folder_paths: List[str],
+        image_processors: List[BaseImageProcessor],
+        device: str
+    ) -> None:
+        self.file_paths = []
+        self.image_processors = image_processors
+        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)
+                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.file_paths)
+
+    def __getitem__(self, 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,100 +1,100 @@
-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
-from mm_datautils import process_video_frames
-from preprocessor import CambrianConfig, CambrianEncoders
-import torch
-from safetensors.torch import save_file
-from collections import defaultdict
-import logging
-from multiprocessing import cpu_count
-from entube_dataset import EnTubeDataset, collate_fn
-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')
-
-def get_optimal_workers() -> int:
-    """Determine the optimal number of workers based on available CPU cores."""
-    try:
-        return max(1, cpu_count() - 1)  # Leave one core free
-    except (NotImplementedError, ValueError):
-        return 1  # Fallback to a single worker in case of an error
-
-def extract_features(processor: CambrianEncoders, file_path: str, file_name: str) -> Dict[str, torch.Tensor]:
-    try:
-        video, image_sizes = process_video_frames(file_path)
-        image_aux_features_list = processor.prepare_mm_features(images=video, image_sizes=image_sizes)
-        return {
-            file_name + '-siglip': image_aux_features_list[0],
-            file_name + '-dino': image_aux_features_list[1]
-        }
-    except Exception as e:
-        logging.error(f"Error processing {file_path}: {e}")
-        return {}
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        '--folders',
-        type=str,
-        nargs='+',
-        required=True,
-        help="List of folder paths to video data"
-    )
-    parser.add_argument(
-        '--output_file',
-        type = str,
-        default = 'entube_tensors.safetensors',
-        help = 'Safetensor file to store embeddings of EnTube dataset by vision encoders'
-    )
-    parser.add_argument(
-        '--config_file',
-        type = str,
-        default = 'config.json',
-        help = 'Path to configuration file of encoders parameters'
-    )
-    args = parser.parse_args()
-
-    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 = 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, 
-        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)}")
-        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)
+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
+from mm_datautils import process_video_frames
+from preprocessor import CambrianConfig, CambrianEncoders
+import torch
+from safetensors.torch import save_file
+from collections import defaultdict
+import logging
+from multiprocessing import cpu_count
+from entube_dataset import EnTubeDataset, collate_fn
+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')
+
+def get_optimal_workers() -> int:
+    """Determine the optimal number of workers based on available CPU cores."""
+    try:
+        return max(1, cpu_count() - 1)  # Leave one core free
+    except (NotImplementedError, ValueError):
+        return 1  # Fallback to a single worker in case of an error
+
+def extract_features(processor: CambrianEncoders, file_path: str, file_name: str) -> Dict[str, torch.Tensor]:
+    try:
+        video, image_sizes = process_video_frames(file_path)
+        image_aux_features_list = processor.prepare_mm_features(images=video, image_sizes=image_sizes)
+        return {
+            file_name + '-siglip': image_aux_features_list[0],
+            file_name + '-dino': image_aux_features_list[1]
+        }
+    except Exception as e:
+        logging.error(f"Error processing {file_path}: {e}")
+        return {}
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--folders',
+        type=str,
+        nargs='+',
+        required=True,
+        help="List of folder paths to video data"
+    )
+    parser.add_argument(
+        '--output_file',
+        type = str,
+        default = 'entube_tensors.safetensors',
+        help = 'Safetensor file to store embeddings of EnTube dataset by vision encoders'
+    )
+    parser.add_argument(
+        '--config_file',
+        type = str,
+        default = 'config.json',
+        help = 'Path to configuration file of encoders parameters'
+    )
+    args = parser.parse_args()
+
+    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 = 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, 
+        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)}")
+        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)

preprocessing/mm_datautils.py

@@ -1,126 +1,126 @@
-import numpy as np
-from PIL import Image
-import torch
-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
-    if width == height:
-        return pil_img
-    elif width > height:
-        result = Image.new(pil_img.mode, (width, width), background_color)
-        result.paste(pil_img, (0, (width - height) // 2))
-        return result
-    else:
-        result = Image.new(pil_img.mode, (height, height), background_color)
-        result.paste(pil_img, ((height - width) // 2, 0))
-        return result
-
-def process_images(
-    images: torch.Tensor, 
-    image_processor: List[BaseImageProcessor],
-    device: str
-) -> Union[torch.Tensor, List[torch.Tensor]]:
-    # images.shape: (4294, 360, 640, 3)
-    # print(f'@tcm: In process_images(): images.shape={images.shape}')
-    if isinstance(image_processor, list):
-        processor_aux_list = image_processor
-        new_images_aux_list = []
-        for i, image in enumerate(images):
-            # image.shape: (height, width, channels)
-            # print(f'@tcm: In process_images(): frame {i}')
-            if isinstance(image, np.ndarray):
-                image = Image.fromarray(image)
-            image_aux_list = []
-            for processor_aux in processor_aux_list:
-                image_aux = image # PIL.Image
-                if hasattr(processor_aux, "image_mean"):
-                    try:
-                        target_resolution = processor_aux.crop_size["height"]
-                    except:
-                        target_resolution = processor_aux.size["height"]
-                    image_aux = expand2square(
-                        image_aux, tuple(int(x * 255) for x in processor_aux.image_mean)
-                    ).resize((target_resolution, target_resolution))
-                image_aux = processor_aux.preprocess(image_aux, return_tensors="pt")[
-                    "pixel_values"
-                ][0]
-                # 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]
-        
-        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]
-        new_images_aux_list = [
-            torch.stack(image_aux).half().to(device) for image_aux in new_images_aux_list
-        ] # torch.Tensor(num_frames, C, H, W) new_images_aux_list[num_processor]
-        return new_images_aux_list 
-    else:
-        image_aspect_ratio = "pad"
-        new_images = []
-        if image_aspect_ratio == "pad":
-            for image in images:
-                image = expand2square(
-                    image, tuple(int(x * 255) for x in image_processor.image_mean)
-                )
-                image = image_processor.preprocess(image, return_tensors="pt")[
-                    "pixel_values"
-                ][0]
-                new_images.append(image)
-        else:
-            return image_processor(images, return_tensors="pt")["pixel_values"]
-        if all(x.shape == new_images[0].shape for x in new_images):
-            new_images = torch.stack(new_images, dim=0)
-        return new_images
-
-def process_video_frames(
-    video_path: str,
-    image_processors: 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),)])
-    print(f'@tcm: In process_video_frames(): # frames = {len(frame_indices)}')
-    image_sizes = [vr[0].shape[:2]]
-
-    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_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):
-            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_processors, device)
-    # print(f'@tcm: In process_video_frames(): process_time={time.time()-process_time:4f}')
-    video = [item.unsqueeze(0) for item in video]
+import numpy as np
+from PIL import Image
+import torch
+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
+    if width == height:
+        return pil_img
+    elif width > height:
+        result = Image.new(pil_img.mode, (width, width), background_color)
+        result.paste(pil_img, (0, (width - height) // 2))
+        return result
+    else:
+        result = Image.new(pil_img.mode, (height, height), background_color)
+        result.paste(pil_img, ((height - width) // 2, 0))
+        return result
+
+def process_images(
+    images: torch.Tensor, 
+    image_processor: List[BaseImageProcessor],
+    device: str
+) -> Union[torch.Tensor, List[torch.Tensor]]:
+    # images.shape: (4294, 360, 640, 3)
+    # print(f'@tcm: In process_images(): images.shape={images.shape}')
+    if isinstance(image_processor, list):
+        processor_aux_list = image_processor
+        new_images_aux_list = []
+        for i, image in enumerate(images):
+            # image.shape: (height, width, channels)
+            # print(f'@tcm: In process_images(): frame {i}')
+            if isinstance(image, np.ndarray):
+                image = Image.fromarray(image)
+            image_aux_list = []
+            for processor_aux in processor_aux_list:
+                image_aux = image # PIL.Image
+                if hasattr(processor_aux, "image_mean"):
+                    try:
+                        target_resolution = processor_aux.crop_size["height"]
+                    except:
+                        target_resolution = processor_aux.size["height"]
+                    image_aux = expand2square(
+                        image_aux, tuple(int(x * 255) for x in processor_aux.image_mean)
+                    ).resize((target_resolution, target_resolution))
+                image_aux = processor_aux.preprocess(image_aux, return_tensors="pt")[
+                    "pixel_values"
+                ][0]
+                # 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]
+        
+        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]
+        new_images_aux_list = [
+            torch.stack(image_aux).half().to(device) for image_aux in new_images_aux_list
+        ] # torch.Tensor(num_frames, C, H, W) new_images_aux_list[num_processor]
+        return new_images_aux_list 
+    else:
+        image_aspect_ratio = "pad"
+        new_images = []
+        if image_aspect_ratio == "pad":
+            for image in images:
+                image = expand2square(
+                    image, tuple(int(x * 255) for x in image_processor.image_mean)
+                )
+                image = image_processor.preprocess(image, return_tensors="pt")[
+                    "pixel_values"
+                ][0]
+                new_images.append(image)
+        else:
+            return image_processor(images, return_tensors="pt")["pixel_values"]
+        if all(x.shape == new_images[0].shape for x in new_images):
+            new_images = torch.stack(new_images, dim=0)
+        return new_images
+
+def process_video_frames(
+    video_path: str,
+    image_processors: 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),)])
+    print(f'@tcm: In process_video_frames(): # frames = {len(frame_indices)}')
+    image_sizes = [vr[0].shape[:2]]
+
+    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_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):
+            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_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

preprocessing/preprocessor.py

@@ -1,240 +1,240 @@
-from vision_encoders.builder import build_vision_tower_aux_list
-from transformers import Qwen2Config
-from typing import Optional, List, Tuple
-import torch
-import json
-from transformers import BaseImageProcessor
-
-class CambrianConfig(Qwen2Config):
-    model_type = "cambrian_qwen"
-    debug = "debug"
-
-    def __init__(
-        self,
-        **kwargs
-    ) -> None:
-        super().__init__(**kwargs)
-
-        for key, value in kwargs.items():
-            setattr(self, key, value)
-
-    @classmethod
-    def from_json_file(cls, json_file_path):
-        """Load a config from a json file."""
-        with open(json_file_path, "r") as f:
-            config_dict = json.load(f)
-        return cls(**config_dict)
-
-
-class CambrianEncoders:
-
-    def __init__(
-        self, 
-        config: CambrianConfig
-    ) -> None:
-        self.config: CambrianConfig = config
-        self.vision_tower_aux_list = build_vision_tower_aux_list(config, delay_load=True)
-
-    def encode_images(self, image_aux_list, encode_type=None):
-        vision_tower_aux_list = self.vision_tower_aux_list
-        image_aux_features_list = []
-        chunk_size = 64
-        if encode_type == "dino":
-            image_aux = image_aux_list[-1]
-            vision_tower_aux = vision_tower_aux_list[-1]
-            if image_aux.shape[0] > chunk_size:
-                image_aux_features_chunks = []
-                for start_idx in range(0, image_aux.shape[0], chunk_size):
-                    end_idx = min(start_idx + chunk_size, image_aux.shape[0])
-                    chunk = image_aux[start_idx:end_idx]
-                    image_aux_features_chunk = vision_tower_aux(chunk)
-                    image_aux_features_chunks.append(image_aux_features_chunk)
-                image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
-            else:
-                image_aux_features = vision_tower_aux(image_aux)
-            return image_aux_features
-        elif encode_type == "siglip":
-            image_aux = image_aux_list[0]
-            vision_tower_aux = vision_tower_aux_list[0]
-            if image_aux.shape[0] > chunk_size:
-                image_aux_features_chunks = []
-                for start_idx in range(0, image_aux.shape[0], chunk_size):
-                    end_idx = min(start_idx + chunk_size, image_aux.shape[0])
-                    chunk = image_aux[start_idx:end_idx]
-                    image_aux_features_chunk = vision_tower_aux(chunk)
-                    image_aux_features_chunks.append(image_aux_features_chunk)
-                image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
-            else:
-                image_aux_features = vision_tower_aux(image_aux)
-            return image_aux_features
-        else:
-            for image_aux, vision_tower_aux in zip(
-                image_aux_list, vision_tower_aux_list
-            ):
-                if image_aux.shape[0] > chunk_size:
-                    image_aux_features_chunks = []
-                    for start_idx in range(0, image_aux.shape[0], chunk_size):
-                        end_idx = min(start_idx + chunk_size, image_aux.shape[0])
-                        chunk = image_aux[start_idx:end_idx]
-                        image_aux_features_chunk = vision_tower_aux(chunk)
-                        image_aux_features_chunks.append(image_aux_features_chunk)
-                    image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
-                else:
-                    image_aux_features = vision_tower_aux(image_aux)
-                image_aux_features_list.append(image_aux_features)
-            return image_aux_features_list
-
-    def select_frame(
-            self,
-            feature_list,
-            split_sizes,
-            new_image_aux_list,
-            image_sizes,
-            window_size=16,
-            threshold=0.83,
-        ):
-        dino_features_batch = torch.split(feature_list, split_sizes, dim=0)
-        new_image_aux_batch_0 = torch.split(new_image_aux_list[0], split_sizes, dim=0)
-        new_image_aux_batch_1 = torch.split(new_image_aux_list[1], split_sizes, dim=0)
-        new_split_sizes = []
-        selected_frames_all_0 = []
-        selected_frames_all_1 = []
-        selected_frames_feature_all = []
-        selected_frame_indices_all = []
-        for i_batch, frame_features in enumerate(dino_features_batch):
-
-            original_width, original_height = image_sizes[i_batch]
-            if getattr(self.get_model().config, "highres", False):
-                token_per_frame = self.config.lowres_token ** 2
-            else:
-                token_per_frame = self.config.image_token_len
-
-            max_num_frames = max(
-                1,
-                (
-                    self.config.tokenizer_model_max_length
-                    - getattr(self.config, "inference_max_length", 16)
-                )
-                // token_per_frame,
-            )
-            if len(frame_features) < max_num_frames:
-                selected_frames_all_0.append(new_image_aux_batch_0[i_batch])
-                selected_frames_all_1.append(new_image_aux_batch_1[i_batch])
-                selected_frames_feature_all.append(frame_features)
-                new_split_sizes.append(len(frame_features))
-                selected_frame_indices_all.append(torch.arange(len(frame_features)))
-                continue
-
-            num_segments = len(frame_features) // window_size
-            if num_segments == 0:
-                query_feature = frame_features.flatten(1, 2)
-                query_feature = query_feature / torch.norm(
-                    (query_feature), dim=1, keepdim=True
-                )
-                similarities = torch.mean(query_feature @ query_feature.T, dim=1)
-                similarities[len(frame_features) // 2] = 0
-                indices = torch.where(similarities < threshold)[0]
-                selected_frame_indices_all.append(indices)
-                selected_frames_all_0.append(new_image_aux_batch_0[i_batch][indices])
-                selected_frames_all_1.append(new_image_aux_batch_1[i_batch][indices])
-                selected_frames_feature_all.append(frame_features[indices])
-                new_split_sizes.append(len(indices))
-                continue
-            segments_frames_0 = []
-            segments_frames_1 = []
-            segments_features = []
-            for start_idx in range(0, len(frame_features), window_size):
-                end_idx = min(start_idx + window_size, len(frame_features))
-                segments_frames_0.append(
-                    new_image_aux_batch_0[i_batch][start_idx:end_idx]
-                )
-                segments_frames_1.append(
-                    new_image_aux_batch_1[i_batch][start_idx:end_idx]
-                )
-                segments_features.append(frame_features[start_idx:end_idx])
-            selected_frames_0 = []
-            selected_frames_1 = []
-            selected_features = []
-            selected_frame_indices = []
-            for i, segment in enumerate(segments_features):
-                query_feature = segment.flatten(1, 2)
-                query_feature = query_feature / torch.norm(
-                    (query_feature), dim=1, keepdim=True
-                )
-                similarities = torch.mean(query_feature @ query_feature.T, dim=1)
-                similarities[len(segment) // 2] = 0
-                indices = torch.where(similarities < threshold)[0]
-                selected_frames_0.append(segments_frames_0[i][indices])
-                selected_frames_1.append(segments_frames_1[i][indices])
-                selected_features.append(segment[indices])
-                selected_frame_indices.extend(indices + i * window_size)
-            selected_frames_0 = torch.cat(selected_frames_0, dim=0)
-            selected_frames_1 = torch.cat(selected_frames_1, dim=0)
-            selected_features = torch.cat(selected_features, dim=0)
-            selected_frame_indices = torch.tensor(selected_frame_indices)
-            # ablation
-            max_num_frames = 400  # in case of OOM
-            if len(selected_frames_0) > max_num_frames:
-                interval = len(selected_frames_0) / float(max_num_frames)
-                indices = [int(interval * i) for i in range(max_num_frames)]
-                new_split_sizes.append(len(indices))
-                selected_frames_all_0.append(selected_frames_0[indices])
-                selected_frames_all_1.append(selected_frames_1[indices])
-                selected_frames_feature_all.append(selected_features[indices])
-                selected_frame_indices = selected_frame_indices[indices]
-            else:
-                new_split_sizes.append(len(selected_frames_0))
-                selected_frames_all_0.append(selected_frames_0)
-                selected_frames_all_1.append(selected_frames_1)
-                selected_frames_feature_all.append(selected_features)
-            selected_frame_indices_all.append(selected_frame_indices)
-        selected_frames_all_0 = torch.cat(selected_frames_all_0, dim=0)
-        selected_frames_all_1 = torch.cat(selected_frames_all_1, dim=0)
-        selected_frames_feature_all = torch.cat(selected_frames_feature_all, dim=0)
-        return (
-            selected_frames_feature_all,
-            new_split_sizes,
-            [selected_frames_all_0, selected_frames_all_1],
-            selected_frame_indices_all,
-        )
-
-    def prepare_mm_features(
-        self,
-        images: List[torch.Tensor],
-        image_sizes: List[Tuple[int, int]],
-    ):
-        image_aux_list = images
-        split_sizes_ori = [
-            1 if image.ndim == 3 else image.shape[0] for image in image_aux_list[0]
-        ]
-        new_image_aux_list = []
-        for image_aux in image_aux_list:
-            if type(image_aux) is list:
-                image_aux = [
-                    x.unsqueeze(0) if x.ndim == 3 else x for x in image_aux
-                ]
-            concat_image_aux = torch.cat([image for image in image_aux], dim=0)
-            new_image_aux_list.append(concat_image_aux)
-        image_aux_features_dino = self.encode_images(
-            new_image_aux_list, encode_type="dino"
-        )
-        (
-            image_aux_features_dino,
-            split_sizes,
-            new_image_aux_list,
-            selected_frame_indices_all,
-        ) = self.select_frame(
-            image_aux_features_dino,
-            split_sizes_ori,
-            new_image_aux_list,
-            image_sizes,
-            threshold=getattr(self.config, "dino_threshold", 0.83),
-        )
-        image_aux_features_siglip = self.encode_images(
-            new_image_aux_list, encode_type="siglip"
-        )
-        image_aux_features_list = [
-            image_aux_features_siglip,
-            image_aux_features_dino,
-        ]
+from vision_encoders.builder import build_vision_tower_aux_list
+from transformers import Qwen2Config
+from typing import Optional, List, Tuple
+import torch
+import json
+from transformers import BaseImageProcessor
+
+class CambrianConfig(Qwen2Config):
+    model_type = "cambrian_qwen"
+    debug = "debug"
+
+    def __init__(
+        self,
+        **kwargs
+    ) -> None:
+        super().__init__(**kwargs)
+
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    @classmethod
+    def from_json_file(cls, json_file_path):
+        """Load a config from a json file."""
+        with open(json_file_path, "r") as f:
+            config_dict = json.load(f)
+        return cls(**config_dict)
+
+
+class CambrianEncoders:
+
+    def __init__(
+        self, 
+        config: CambrianConfig
+    ) -> None:
+        self.config: CambrianConfig = config
+        self.vision_tower_aux_list = build_vision_tower_aux_list(config, delay_load=True)
+
+    def encode_images(self, image_aux_list, encode_type=None):
+        vision_tower_aux_list = self.vision_tower_aux_list
+        image_aux_features_list = []
+        chunk_size = 64
+        if encode_type == "dino":
+            image_aux = image_aux_list[-1]
+            vision_tower_aux = vision_tower_aux_list[-1]
+            if image_aux.shape[0] > chunk_size:
+                image_aux_features_chunks = []
+                for start_idx in range(0, image_aux.shape[0], chunk_size):
+                    end_idx = min(start_idx + chunk_size, image_aux.shape[0])
+                    chunk = image_aux[start_idx:end_idx]
+                    image_aux_features_chunk = vision_tower_aux(chunk)
+                    image_aux_features_chunks.append(image_aux_features_chunk)
+                image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
+            else:
+                image_aux_features = vision_tower_aux(image_aux)
+            return image_aux_features
+        elif encode_type == "siglip":
+            image_aux = image_aux_list[0]
+            vision_tower_aux = vision_tower_aux_list[0]
+            if image_aux.shape[0] > chunk_size:
+                image_aux_features_chunks = []
+                for start_idx in range(0, image_aux.shape[0], chunk_size):
+                    end_idx = min(start_idx + chunk_size, image_aux.shape[0])
+                    chunk = image_aux[start_idx:end_idx]
+                    image_aux_features_chunk = vision_tower_aux(chunk)
+                    image_aux_features_chunks.append(image_aux_features_chunk)
+                image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
+            else:
+                image_aux_features = vision_tower_aux(image_aux)
+            return image_aux_features
+        else:
+            for image_aux, vision_tower_aux in zip(
+                image_aux_list, vision_tower_aux_list
+            ):
+                if image_aux.shape[0] > chunk_size:
+                    image_aux_features_chunks = []
+                    for start_idx in range(0, image_aux.shape[0], chunk_size):
+                        end_idx = min(start_idx + chunk_size, image_aux.shape[0])
+                        chunk = image_aux[start_idx:end_idx]
+                        image_aux_features_chunk = vision_tower_aux(chunk)
+                        image_aux_features_chunks.append(image_aux_features_chunk)
+                    image_aux_features = torch.cat(image_aux_features_chunks, dim=0)
+                else:
+                    image_aux_features = vision_tower_aux(image_aux)
+                image_aux_features_list.append(image_aux_features)
+            return image_aux_features_list
+
+    def select_frame(
+            self,
+            feature_list,
+            split_sizes,
+            new_image_aux_list,
+            image_sizes,
+            window_size=16,
+            threshold=0.83,
+        ):
+        dino_features_batch = torch.split(feature_list, split_sizes, dim=0)
+        new_image_aux_batch_0 = torch.split(new_image_aux_list[0], split_sizes, dim=0)
+        new_image_aux_batch_1 = torch.split(new_image_aux_list[1], split_sizes, dim=0)
+        new_split_sizes = []
+        selected_frames_all_0 = []
+        selected_frames_all_1 = []
+        selected_frames_feature_all = []
+        selected_frame_indices_all = []
+        for i_batch, frame_features in enumerate(dino_features_batch):
+
+            original_width, original_height = image_sizes[i_batch]
+            if getattr(self.get_model().config, "highres", False):
+                token_per_frame = self.config.lowres_token ** 2
+            else:
+                token_per_frame = self.config.image_token_len
+
+            max_num_frames = max(
+                1,
+                (
+                    self.config.tokenizer_model_max_length
+                    - getattr(self.config, "inference_max_length", 16)
+                )
+                // token_per_frame,
+            )
+            if len(frame_features) < max_num_frames:
+                selected_frames_all_0.append(new_image_aux_batch_0[i_batch])
+                selected_frames_all_1.append(new_image_aux_batch_1[i_batch])
+                selected_frames_feature_all.append(frame_features)
+                new_split_sizes.append(len(frame_features))
+                selected_frame_indices_all.append(torch.arange(len(frame_features)))
+                continue
+
+            num_segments = len(frame_features) // window_size
+            if num_segments == 0:
+                query_feature = frame_features.flatten(1, 2)
+                query_feature = query_feature / torch.norm(
+                    (query_feature), dim=1, keepdim=True
+                )
+                similarities = torch.mean(query_feature @ query_feature.T, dim=1)
+                similarities[len(frame_features) // 2] = 0
+                indices = torch.where(similarities < threshold)[0]
+                selected_frame_indices_all.append(indices)
+                selected_frames_all_0.append(new_image_aux_batch_0[i_batch][indices])
+                selected_frames_all_1.append(new_image_aux_batch_1[i_batch][indices])
+                selected_frames_feature_all.append(frame_features[indices])
+                new_split_sizes.append(len(indices))
+                continue
+            segments_frames_0 = []
+            segments_frames_1 = []
+            segments_features = []
+            for start_idx in range(0, len(frame_features), window_size):
+                end_idx = min(start_idx + window_size, len(frame_features))
+                segments_frames_0.append(
+                    new_image_aux_batch_0[i_batch][start_idx:end_idx]
+                )
+                segments_frames_1.append(
+                    new_image_aux_batch_1[i_batch][start_idx:end_idx]
+                )
+                segments_features.append(frame_features[start_idx:end_idx])
+            selected_frames_0 = []
+            selected_frames_1 = []
+            selected_features = []
+            selected_frame_indices = []
+            for i, segment in enumerate(segments_features):
+                query_feature = segment.flatten(1, 2)
+                query_feature = query_feature / torch.norm(
+                    (query_feature), dim=1, keepdim=True
+                )
+                similarities = torch.mean(query_feature @ query_feature.T, dim=1)
+                similarities[len(segment) // 2] = 0
+                indices = torch.where(similarities < threshold)[0]
+                selected_frames_0.append(segments_frames_0[i][indices])
+                selected_frames_1.append(segments_frames_1[i][indices])
+                selected_features.append(segment[indices])
+                selected_frame_indices.extend(indices + i * window_size)
+            selected_frames_0 = torch.cat(selected_frames_0, dim=0)
+            selected_frames_1 = torch.cat(selected_frames_1, dim=0)
+            selected_features = torch.cat(selected_features, dim=0)
+            selected_frame_indices = torch.tensor(selected_frame_indices)
+            # ablation
+            max_num_frames = 400  # in case of OOM
+            if len(selected_frames_0) > max_num_frames:
+                interval = len(selected_frames_0) / float(max_num_frames)
+                indices = [int(interval * i) for i in range(max_num_frames)]
+                new_split_sizes.append(len(indices))
+                selected_frames_all_0.append(selected_frames_0[indices])
+                selected_frames_all_1.append(selected_frames_1[indices])
+                selected_frames_feature_all.append(selected_features[indices])
+                selected_frame_indices = selected_frame_indices[indices]
+            else:
+                new_split_sizes.append(len(selected_frames_0))
+                selected_frames_all_0.append(selected_frames_0)
+                selected_frames_all_1.append(selected_frames_1)
+                selected_frames_feature_all.append(selected_features)
+            selected_frame_indices_all.append(selected_frame_indices)
+        selected_frames_all_0 = torch.cat(selected_frames_all_0, dim=0)
+        selected_frames_all_1 = torch.cat(selected_frames_all_1, dim=0)
+        selected_frames_feature_all = torch.cat(selected_frames_feature_all, dim=0)
+        return (
+            selected_frames_feature_all,
+            new_split_sizes,
+            [selected_frames_all_0, selected_frames_all_1],
+            selected_frame_indices_all,
+        )
+
+    def prepare_mm_features(
+        self,
+        images: List[torch.Tensor],
+        image_sizes: List[Tuple[int, int]],
+    ):
+        image_aux_list = images
+        split_sizes_ori = [
+            1 if image.ndim == 3 else image.shape[0] for image in image_aux_list[0]
+        ]
+        new_image_aux_list = []
+        for image_aux in image_aux_list:
+            if type(image_aux) is list:
+                image_aux = [
+                    x.unsqueeze(0) if x.ndim == 3 else x for x in image_aux
+                ]
+            concat_image_aux = torch.cat([image for image in image_aux], dim=0)
+            new_image_aux_list.append(concat_image_aux)
+        image_aux_features_dino = self.encode_images(
+            new_image_aux_list, encode_type="dino"
+        )
+        (
+            image_aux_features_dino,
+            split_sizes,
+            new_image_aux_list,
+            selected_frame_indices_all,
+        ) = self.select_frame(
+            image_aux_features_dino,
+            split_sizes_ori,
+            new_image_aux_list,
+            image_sizes,
+            threshold=getattr(self.config, "dino_threshold", 0.83),
+        )
+        image_aux_features_siglip = self.encode_images(
+            new_image_aux_list, encode_type="siglip"
+        )
+        image_aux_features_list = [
+            image_aux_features_siglip,
+            image_aux_features_dino,
+        ]
         return image_aux_features_list

preprocessing/vision_encoders/base_encoder.py

@@ -1,135 +1,135 @@
-from abc import ABC, abstractmethod
-
-import torch
-import torch.nn as nn
-
-
-class ProcessorWrapper:
-    def __init__(
-        self,
-        transform,
-        height=378,
-        width=378,
-        image_mean=[0.48145466, 0.4578275, 0.40821073],
-    ):
-        self._crop_size = {
-            "height": height,
-            "width": width,
-        }
-        self._transforms = transform
-        # print(transform)
-        self.image_mean = image_mean
-
-    @property
-    def crop_size(self):
-        return self._crop_size
-
-    def preprocess(self, image, return_tensors="pt"):
-        # Ensure image is a PIL Image
-        output = {}
-        output["pixel_values"] = [self._transforms(image)]
-        return output
-
-
-class BaseVisionTower(nn.Module):
-    def __init__(self, vision_tower_name, args, delay_load=False):
-        super().__init__()
-
-        self.is_loaded = False
-        self.args = args
-
-        self.vision_tower_name = vision_tower_name
-        self.select_layer = args.mm_vision_select_layer
-        self.select_feature = getattr(args, "mm_vision_select_feature", "patch")
-        self.unfreeze_mm_vision_tower = getattr(args, "unfreeze_mm_vision_tower", False)
-        self.delay_load = delay_load
-
-    @abstractmethod
-    def load_model(self, device_map=None):
-        raise NotImplementedError("Subclasses must implement load_model")
-
-    @abstractmethod
-    def _forward(self, images):
-        raise NotImplementedError("Subclasses must implement forward")
-
-    def forward(self, images):
-        if type(images) is list:
-            image_features = [self._forward(image.unsqueeze(0)) for image in images]
-        else:
-            image_features = self._forward(images)
-
-        return image_features
-
-    @property
-    def dummy_feature(self):
-        return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)
-
-    @property
-    def dtype(self):
-        # Dynamically infer the dtype from the first parameter, if not explicitly specified
-        if hasattr(self.vision_tower, "dtype"):
-            return self.vision_tower.dtype
-        else:
-            params = list(self.vision_tower.parameters())
-            return (
-                params[0].dtype if len(params) > 0 else torch.float32
-            )  # Default to torch.float32 if no parameters
-
-    @property
-    def device(self):
-        # Dynamically infer the device from the first parameter, if not explicitly specified
-        if hasattr(self.vision_tower, "device"):
-            return self.vision_tower.device
-        else:
-            params = list(self.vision_tower.parameters())
-            return (
-                params[0].device if len(params) > 0 else torch.device("cpu")
-            )  # Default to CPU if no parameters
-
-    @property
-    def config(self):
-        if self.is_loaded:
-            return self.vision_tower.config
-        else:
-            return self.cfg_only
-
-    @property
-    def hidden_size(self):
-        try:
-            return self.config.hidden_size
-        except:
-            return self._hidden_size
-
-    @property
-    def image_size(self):  # resolution
-        # return self.config.image_size
-        try:
-            return self.config.image_size
-        except:
-            return self._image_size
-
-    @property
-    def patch_size(self):
-        # return self.config.patch_size
-        try:
-            return self.config.patch_size
-        except:
-            return self._patch_size
-
-    @property
-    def num_patches_per_side(self):
-        if self._interp_size is not None:
-            return int(self._interp_size**0.5)
-        try:
-            return self.image_size // self.patch_size
-        except:
-            return self._num_patches_per_side
-
-    @property
-    def num_patches(self):
-        if self._interp_size is not None:
-            return self._interp_size
-        try:
-            return self.num_patches_per_side**2
-        except:
-            return self._num_patches
+from abc import ABC, abstractmethod
+
+import torch
+import torch.nn as nn
+
+
+class ProcessorWrapper:
+    def __init__(
+        self,
+        transform,
+        height=378,
+        width=378,
+        image_mean=[0.48145466, 0.4578275, 0.40821073],
+    ):
+        self._crop_size = {
+            "height": height,
+            "width": width,
+        }
+        self._transforms = transform
+        # print(transform)
+        self.image_mean = image_mean
+
+    @property
+    def crop_size(self):
+        return self._crop_size
+
+    def preprocess(self, image, return_tensors="pt"):
+        # Ensure image is a PIL Image
+        output = {}
+        output["pixel_values"] = [self._transforms(image)]
+        return output
+
+
+class BaseVisionTower(nn.Module):
+    def __init__(self, vision_tower_name, args, delay_load=False):
+        super().__init__()
+
+        self.is_loaded = False
+        self.args = args
+
+        self.vision_tower_name = vision_tower_name
+        self.select_layer = args.mm_vision_select_layer
+        self.select_feature = getattr(args, "mm_vision_select_feature", "patch")
+        self.unfreeze_mm_vision_tower = getattr(args, "unfreeze_mm_vision_tower", False)
+        self.delay_load = delay_load
+
+    @abstractmethod
+    def load_model(self, device_map=None):
+        raise NotImplementedError("Subclasses must implement load_model")
+
+    @abstractmethod
+    def _forward(self, images):
+        raise NotImplementedError("Subclasses must implement forward")
+
+    def forward(self, images):
+        if type(images) is list:
+            image_features = [self._forward(image.unsqueeze(0)) for image in images]
+        else:
+            image_features = self._forward(images)
+
+        return image_features
+
+    @property
+    def dummy_feature(self):
+        return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)
+
+    @property
+    def dtype(self):
+        # Dynamically infer the dtype from the first parameter, if not explicitly specified
+        if hasattr(self.vision_tower, "dtype"):
+            return self.vision_tower.dtype
+        else:
+            params = list(self.vision_tower.parameters())
+            return (
+                params[0].dtype if len(params) > 0 else torch.float32
+            )  # Default to torch.float32 if no parameters
+
+    @property
+    def device(self):
+        # Dynamically infer the device from the first parameter, if not explicitly specified
+        if hasattr(self.vision_tower, "device"):
+            return self.vision_tower.device
+        else:
+            params = list(self.vision_tower.parameters())
+            return (
+                params[0].device if len(params) > 0 else torch.device("cpu")
+            )  # Default to CPU if no parameters
+
+    @property
+    def config(self):
+        if self.is_loaded:
+            return self.vision_tower.config
+        else:
+            return self.cfg_only
+
+    @property
+    def hidden_size(self):
+        try:
+            return self.config.hidden_size
+        except:
+            return self._hidden_size
+
+    @property
+    def image_size(self):  # resolution
+        # return self.config.image_size
+        try:
+            return self.config.image_size
+        except:
+            return self._image_size
+
+    @property
+    def patch_size(self):
+        # return self.config.patch_size
+        try:
+            return self.config.patch_size
+        except:
+            return self._patch_size
+
+    @property
+    def num_patches_per_side(self):
+        if self._interp_size is not None:
+            return int(self._interp_size**0.5)
+        try:
+            return self.image_size // self.patch_size
+        except:
+            return self._num_patches_per_side
+
+    @property
+    def num_patches(self):
+        if self._interp_size is not None:
+            return self._interp_size
+        try:
+            return self.num_patches_per_side**2
+        except:
+            return self._num_patches

preprocessing/vision_encoders/builder.py

@@ -1,37 +1,37 @@
-# pyre-unsafe
-import copy
-
-from .dino_encoder import DinoVisionTower
-from .siglip_encoder import SiglipVisionTower
-
-
-def build_vision_tower_aux_list(vision_tower_cfg, **kwargs):
-    vision_tower_aux_name_list = getattr(
-        vision_tower_cfg,
-        "mm_vision_tower_aux_list",
-        getattr(vision_tower_cfg, "vision_tower_aux_list", None),
-    )
-    vision_tower_aux_token_len_list = getattr(
-        vision_tower_cfg,
-        "mm_vision_tower_aux_token_len_list",
-        getattr(vision_tower_cfg, "vision_tower_aux_token_len_list", None),
-    )
-    vision_tower_aux_list = []
-    for vision_tower_aux_name, vision_tower_aux_token_len in zip(
-        vision_tower_aux_name_list, vision_tower_aux_token_len_list
-    ):
-        config = copy.deepcopy(vision_tower_cfg)
-        vision_tower_aux_name += "-interp{}".format(vision_tower_aux_token_len)
-        if "siglip" in vision_tower_aux_name.lower():
-            vision_tower_aux_list.append(
-                SiglipVisionTower(vision_tower_aux_name, args=config, **kwargs)
-            )
-
-        # SSL-based Vision Towers
-        elif "dinov2" in vision_tower_aux_name.lower():
-            vision_tower_aux_list.append(
-                DinoVisionTower(vision_tower_aux_name, args=config, **kwargs)
-            )
-        else:
-            raise ValueError(f"Unknown vision tower: {vision_tower_aux_name}")
-    return vision_tower_aux_list
+# pyre-unsafe
+import copy
+
+from .dino_encoder import DinoVisionTower
+from .siglip_encoder import SiglipVisionTower
+
+
+def build_vision_tower_aux_list(vision_tower_cfg, **kwargs):
+    vision_tower_aux_name_list = getattr(
+        vision_tower_cfg,
+        "mm_vision_tower_aux_list",
+        getattr(vision_tower_cfg, "vision_tower_aux_list", None),
+    )
+    vision_tower_aux_token_len_list = getattr(
+        vision_tower_cfg,
+        "mm_vision_tower_aux_token_len_list",
+        getattr(vision_tower_cfg, "vision_tower_aux_token_len_list", None),
+    )
+    vision_tower_aux_list = []
+    for vision_tower_aux_name, vision_tower_aux_token_len in zip(
+        vision_tower_aux_name_list, vision_tower_aux_token_len_list
+    ):
+        config = copy.deepcopy(vision_tower_cfg)
+        vision_tower_aux_name += "-interp{}".format(vision_tower_aux_token_len)
+        if "siglip" in vision_tower_aux_name.lower():
+            vision_tower_aux_list.append(
+                SiglipVisionTower(vision_tower_aux_name, args=config, **kwargs)
+            )
+
+        # SSL-based Vision Towers
+        elif "dinov2" in vision_tower_aux_name.lower():
+            vision_tower_aux_list.append(
+                DinoVisionTower(vision_tower_aux_name, args=config, **kwargs)
+            )
+        else:
+            raise ValueError(f"Unknown vision tower: {vision_tower_aux_name}")
+    return vision_tower_aux_list

preprocessing/vision_encoders/dino_encoder.py

@@ -1,131 +1,131 @@
-import torch
-import torch.nn.functional as F
-
-from transformers import AutoImageProcessor, Dinov2Config, Dinov2Model
-
-from .base_encoder import BaseVisionTower, ProcessorWrapper
-
-
-class DinoVisionTower(BaseVisionTower):
-    def __init__(self, vision_tower, args, delay_load=False):
-        super(DinoVisionTower, self).__init__(vision_tower, args, delay_load)
-
-        model_path = "facebook/dinov2-giant"
-        base_model_name, res, interp = model_path, 378, 576
-        self._vision_tower_name = vision_tower
-        self.vision_tower_name = base_model_name
-        self._image_size = res
-        self._interp_size = interp
-        self._patch_size = 14  # default patch size
-
-        if not self.delay_load:
-            self.load_model()
-        else:
-            self.cfg_only = Dinov2Config.from_pretrained(self.vision_tower_name)
-
-    def load_model(self, device_map=None):
-
-        self.vision_tower = Dinov2Model.from_pretrained(self.vision_tower_name)
-        """ValueError: Dinov2Model does not support `device_map='auto'`. To implement support, the model class needs to implement the `_no_split_modules` attribute."""
-        self.vision_tower._no_split_modules = ["Dinov2SwiGLUFFN"]
-
-        _image_size = self.vision_tower.config.image_size
-        if self._image_size is None:
-            self._image_size = _image_size
-
-        # increase shortest edge to prevent edge case crops
-        default_shortest_ratio = 8 / 7  # 224/256
-        # shortest_edge = int(default_shortest_ratio * self._image_size)
-        shortest_edge = self._image_size
-
-        processor = AutoImageProcessor.from_pretrained(
-            self.vision_tower_name,
-            crop_size=dict(height=self._image_size, width=self._image_size),
-            size=dict(shortest_edge=shortest_edge),
-        )
-        self.image_processor = processor
-
-        # Assign the output channels of the projection convolution as the hidden size
-        self._hidden_size = (
-            self.vision_tower.embeddings.patch_embeddings.projection.out_channels
-        )
-        # Assign the first value of the stride of the projection convolution as the patch size
-        self._patch_size = (
-            self.vision_tower.embeddings.patch_embeddings.projection.stride[0]
-        )
-
-        # print(self._hidden_size, self._patch_size)
-
-        self.vision_tower.requires_grad_(self.unfreeze_mm_vision_tower)
-        self.is_loaded = True
-
-    @property
-    def image_size(self):
-        return self._image_size
-
-    def feature_select(self, outputs):
-        sequence_output = outputs[
-            "last_hidden_state"
-        ]  # batch_size, sequence_length, hidden_size
-
-        if self.select_feature == "cls_patch":
-            image_features = sequence_output
-        elif self.select_feature == "patch":
-            image_features = sequence_output[:, 1:]
-        elif self.select_feature == "cls":
-            image_features = sequence_output[:, 0]
-        else:
-            raise ValueError(f"Unexpected select feature: {self.select_feature}")
-        return image_features
-
-    def interpolate(self, image_features):
-        if self._interp_size is None:
-            return image_features
-
-        b, num_tokens, dim = image_features.shape
-
-        if num_tokens != self.num_patches:
-            target_h = target_w = int(self._interp_size**0.5)
-            h = w = int(num_tokens**0.5)
-
-            image_features = image_features.view(b, h, w, dim)
-            image_features = image_features.permute(0, 3, 1, 2).contiguous()
-
-            image_features = F.interpolate(
-                image_features.to(torch.float32),
-                size=(target_h, target_w),
-                mode="bilinear",
-                align_corners=False,
-            ).to(image_features.dtype)
-
-            # Permute the dimensions back to (b, target_h, target_w, dim)
-            image_features = image_features.permute(0, 2, 3, 1).contiguous()
-
-            # Flatten the spatial dimensions (target_h, target_w) into a single dimension
-            image_features = image_features.flatten(1, 2)
-
-        return image_features
-
-    def _forward(self, images):
-        # logger.warning(f"images shape: {images.shape}")
-        with torch.set_grad_enabled(self.unfreeze_mm_vision_tower):
-            image_forward_outs = self.vision_tower.forward(
-                images.to(device=self.device, dtype=self.dtype)
-            )
-            # logger.warning(f"image_forward_outs shape: {image_forward_outs['last_hidden_state'].shape}")
-            image_features = self.feature_select(image_forward_outs).to(images.dtype)
-            # logger.warning(f"image_features shape: {image_features.shape}")
-            interp_features = self.interpolate(image_features)
-            # logger.warning(f"interp_features shape: {interp_features.shape}")
-            return interp_features
-
-    @property
-    def num_patches_per_side(self):
-        return int(self.num_patches**0.5)
-
-    @property
-    def num_patches(self):
-        if self._interp_size is None:
-            return (self._image_size // self._patch_size) ** 2
-        else:
-            return self._interp_size
+import torch
+import torch.nn.functional as F
+
+from transformers import AutoImageProcessor, Dinov2Config, Dinov2Model
+
+from .base_encoder import BaseVisionTower, ProcessorWrapper
+
+
+class DinoVisionTower(BaseVisionTower):
+    def __init__(self, vision_tower, args, delay_load=False):
+        super(DinoVisionTower, self).__init__(vision_tower, args, delay_load)
+
+        model_path = "facebook/dinov2-giant"
+        base_model_name, res, interp = model_path, 378, 576
+        self._vision_tower_name = vision_tower
+        self.vision_tower_name = base_model_name
+        self._image_size = res
+        self._interp_size = interp
+        self._patch_size = 14  # default patch size
+
+        if not self.delay_load:
+            self.load_model()
+        else:
+            self.cfg_only = Dinov2Config.from_pretrained(self.vision_tower_name)
+
+    def load_model(self, device_map=None):
+
+        self.vision_tower = Dinov2Model.from_pretrained(self.vision_tower_name)
+        """ValueError: Dinov2Model does not support `device_map='auto'`. To implement support, the model class needs to implement the `_no_split_modules` attribute."""
+        self.vision_tower._no_split_modules = ["Dinov2SwiGLUFFN"]
+
+        _image_size = self.vision_tower.config.image_size
+        if self._image_size is None:
+            self._image_size = _image_size
+
+        # increase shortest edge to prevent edge case crops
+        default_shortest_ratio = 8 / 7  # 224/256
+        # shortest_edge = int(default_shortest_ratio * self._image_size)
+        shortest_edge = self._image_size
+
+        processor = AutoImageProcessor.from_pretrained(
+            self.vision_tower_name,
+            crop_size=dict(height=self._image_size, width=self._image_size),
+            size=dict(shortest_edge=shortest_edge),
+        )
+        self.image_processor = processor
+
+        # Assign the output channels of the projection convolution as the hidden size
+        self._hidden_size = (
+            self.vision_tower.embeddings.patch_embeddings.projection.out_channels
+        )
+        # Assign the first value of the stride of the projection convolution as the patch size
+        self._patch_size = (
+            self.vision_tower.embeddings.patch_embeddings.projection.stride[0]
+        )
+
+        # print(self._hidden_size, self._patch_size)
+
+        self.vision_tower.requires_grad_(self.unfreeze_mm_vision_tower)
+        self.is_loaded = True
+
+    @property
+    def image_size(self):
+        return self._image_size
+
+    def feature_select(self, outputs):
+        sequence_output = outputs[
+            "last_hidden_state"
+        ]  # batch_size, sequence_length, hidden_size
+
+        if self.select_feature == "cls_patch":
+            image_features = sequence_output
+        elif self.select_feature == "patch":
+            image_features = sequence_output[:, 1:]
+        elif self.select_feature == "cls":
+            image_features = sequence_output[:, 0]
+        else:
+            raise ValueError(f"Unexpected select feature: {self.select_feature}")
+        return image_features
+
+    def interpolate(self, image_features):
+        if self._interp_size is None:
+            return image_features
+
+        b, num_tokens, dim = image_features.shape
+
+        if num_tokens != self.num_patches:
+            target_h = target_w = int(self._interp_size**0.5)
+            h = w = int(num_tokens**0.5)
+
+            image_features = image_features.view(b, h, w, dim)
+            image_features = image_features.permute(0, 3, 1, 2).contiguous()
+
+            image_features = F.interpolate(
+                image_features.to(torch.float32),
+                size=(target_h, target_w),
+                mode="bilinear",
+                align_corners=False,
+            ).to(image_features.dtype)
+
+            # Permute the dimensions back to (b, target_h, target_w, dim)
+            image_features = image_features.permute(0, 2, 3, 1).contiguous()
+
+            # Flatten the spatial dimensions (target_h, target_w) into a single dimension
+            image_features = image_features.flatten(1, 2)
+
+        return image_features
+
+    def _forward(self, images):
+        # logger.warning(f"images shape: {images.shape}")
+        with torch.set_grad_enabled(self.unfreeze_mm_vision_tower):
+            image_forward_outs = self.vision_tower.forward(
+                images.to(device=self.device, dtype=self.dtype)
+            )
+            # logger.warning(f"image_forward_outs shape: {image_forward_outs['last_hidden_state'].shape}")
+            image_features = self.feature_select(image_forward_outs).to(images.dtype)
+            # logger.warning(f"image_features shape: {image_features.shape}")
+            interp_features = self.interpolate(image_features)
+            # logger.warning(f"interp_features shape: {interp_features.shape}")
+            return interp_features
+
+    @property
+    def num_patches_per_side(self):
+        return int(self.num_patches**0.5)
+
+    @property
+    def num_patches(self):
+        if self._interp_size is None:
+            return (self._image_size // self._patch_size) ** 2
+        else:
+            return self._interp_size

preprocessing/vision_encoders/siglip_encoder.py

@@ -1,78 +1,78 @@
-import torch
-import torch.nn.functional as F
-
-from transformers import SiglipImageProcessor, SiglipVisionConfig, SiglipVisionModel
-
-from .base_encoder import BaseVisionTower, ProcessorWrapper
-
-
-class SiglipVisionTower(BaseVisionTower):
-    def __init__(self, vision_tower_name, args, delay_load=False):
-        super(SiglipVisionTower, self).__init__(vision_tower_name, args, delay_load)
-        
-        model_path = "google/siglip-so400m-patch14-384"
-        base_model_name, res, interp = model_path, 384, 576
-        self.vision_tower_name = base_model_name
-        self._image_size = res if res is not None else 512
-        self._interp_size = interp
-        if not self.delay_load:
-            self.load_model()
-        elif self.unfreeze_mm_vision_tower:
-            self.load_model()
-        else:
-            self._hidden_size = 1152
-
-    def load_model(self, device_map=None):
-        self.vision_model = "siglip"
-        # clip_model, processor = create_model_from_pretrained(self.vision_tower_name)
-        self.vision_tower = SiglipVisionModel.from_pretrained(self.vision_tower_name)
-
-        # self.vision_tower = clip_model.visual.trunk
-        self.vision_tower.output_tokens = True
-
-        self._hidden_size = self.vision_tower.config.hidden_size
-        self._image_size = self.vision_tower.config.image_size
-        self._patch_size = self.vision_tower.config.patch_size
-        self.image_processor = SiglipImageProcessor.from_pretrained(
-            self.vision_tower_name
-        )
-
-        self.vision_tower.requires_grad_(self.unfreeze_mm_vision_tower)
-        self.is_loaded = True
-
-    def interpolate(self, image_features):
-        if self._interp_size is None:
-            return image_features
-
-        b, num_tokens, dim = image_features.shape
-
-        if num_tokens != self.num_patches:
-            target_h = target_w = int(self._interp_size**0.5)
-            h = w = int(num_tokens**0.5)
-
-            image_features = image_features.view(b, h, w, dim)
-            image_features = image_features.permute(0, 3, 1, 2).contiguous()
-
-            image_features = F.interpolate(
-                image_features.to(torch.float32),
-                size=(target_h, target_w),
-                mode="bilinear",
-                align_corners=False,
-            ).to(image_features.dtype)
-
-            # Permute the dimensions back to (b, target_h, target_w, dim)
-            image_features = image_features.permute(0, 2, 3, 1).contiguous()
-
-            # Flatten the spatial dimensions (target_h, target_w) into a single dimension
-            image_features = image_features.flatten(1, 2)
-
-        return image_features
-
-    def _forward(self, images, interpolate_token=576):
-        with torch.set_grad_enabled(self.unfreeze_mm_vision_tower):
-            image_features = self.vision_tower.forward(
-                images.to(device=self.device, dtype=self.dtype),
-                output_hidden_states=True,
-            ).hidden_states[-1]
-            interp_features = self.interpolate(image_features)
-            return interp_features
+import torch
+import torch.nn.functional as F
+
+from transformers import SiglipImageProcessor, SiglipVisionConfig, SiglipVisionModel
+
+from .base_encoder import BaseVisionTower, ProcessorWrapper
+
+
+class SiglipVisionTower(BaseVisionTower):
+    def __init__(self, vision_tower_name, args, delay_load=False):
+        super(SiglipVisionTower, self).__init__(vision_tower_name, args, delay_load)
+        
+        model_path = "google/siglip-so400m-patch14-384"
+        base_model_name, res, interp = model_path, 384, 576
+        self.vision_tower_name = base_model_name
+        self._image_size = res if res is not None else 512
+        self._interp_size = interp
+        if not self.delay_load:
+            self.load_model()
+        elif self.unfreeze_mm_vision_tower:
+            self.load_model()
+        else:
+            self._hidden_size = 1152
+
+    def load_model(self, device_map=None):
+        self.vision_model = "siglip"
+        # clip_model, processor = create_model_from_pretrained(self.vision_tower_name)
+        self.vision_tower = SiglipVisionModel.from_pretrained(self.vision_tower_name)
+
+        # self.vision_tower = clip_model.visual.trunk
+        self.vision_tower.output_tokens = True
+
+        self._hidden_size = self.vision_tower.config.hidden_size
+        self._image_size = self.vision_tower.config.image_size
+        self._patch_size = self.vision_tower.config.patch_size
+        self.image_processor = SiglipImageProcessor.from_pretrained(
+            self.vision_tower_name
+        )
+
+        self.vision_tower.requires_grad_(self.unfreeze_mm_vision_tower)
+        self.is_loaded = True
+
+    def interpolate(self, image_features):
+        if self._interp_size is None:
+            return image_features
+
+        b, num_tokens, dim = image_features.shape
+
+        if num_tokens != self.num_patches:
+            target_h = target_w = int(self._interp_size**0.5)
+            h = w = int(num_tokens**0.5)
+
+            image_features = image_features.view(b, h, w, dim)
+            image_features = image_features.permute(0, 3, 1, 2).contiguous()
+
+            image_features = F.interpolate(
+                image_features.to(torch.float32),
+                size=(target_h, target_w),
+                mode="bilinear",
+                align_corners=False,
+            ).to(image_features.dtype)
+
+            # Permute the dimensions back to (b, target_h, target_w, dim)
+            image_features = image_features.permute(0, 2, 3, 1).contiguous()
+
+            # Flatten the spatial dimensions (target_h, target_w) into a single dimension
+            image_features = image_features.flatten(1, 2)
+
+        return image_features
+
+    def _forward(self, images, interpolate_token=576):
+        with torch.set_grad_enabled(self.unfreeze_mm_vision_tower):
+            image_features = self.vision_tower.forward(
+                images.to(device=self.device, dtype=self.dtype),
+                output_hidden_states=True,
+            ).hidden_states[-1]
+            interp_features = self.interpolate(image_features)
+            return interp_features

requirements.txt

@@ -1,10 +1,10 @@
-numpy==1.26.4
-datasets
-decord
-torch==2.1.2
-torchvision
-transformers==4.42.4
-safetensors
-pillow
-huggingface_hub
+numpy==1.26.4
+datasets
+decord
+torch==2.1.2
+torchvision
+transformers==4.42.4
+safetensors
+pillow
+huggingface_hub
 scikit-learn

test.py

@@ -1,25 +1,25 @@
-from datasets import load_dataset
-import decord
-
-# Load the dataset in streaming mode
-dataset = load_dataset("tcm03/EnTube", split="train", streaming=True)
-
-# Initialize counter and specify the max videos to process
-max_videos = 5
-video_count = 0
-
-# Stream and process videos
-for item in dataset:
-    video_reader = item['video']  # Decord VideoReader object
-    label = item['label']         # Label for the video
-
-    # Extract frames from the video
-    frames = []
-    for frame in video_reader:
-        frames.append(frame.asnumpy())  # Convert Decord frames to NumPy arrays
-
-    print(f"Processed video {video_count} with label {label}, extracted {len(frames)} frames")
-
-    video_count += 1
-    if video_count >= max_videos:
-        break
+from datasets import load_dataset
+import decord
+
+# Load the dataset in streaming mode
+dataset = load_dataset("tcm03/EnTube", split="train", streaming=True)
+
+# Initialize counter and specify the max videos to process
+max_videos = 5
+video_count = 0
+
+# Stream and process videos
+for item in dataset:
+    video_reader = item['video']  # Decord VideoReader object
+    label = item['label']         # Label for the video
+
+    # Extract frames from the video
+    frames = []
+    for frame in video_reader:
+        frames.append(frame.asnumpy())  # Convert Decord frames to NumPy arrays
+
+    print(f"Processed video {video_count} with label {label}, extracted {len(frames)} frames")
+
+    video_count += 1
+    if video_count >= max_videos:
+        break