Restructure repo and refine annotation

.gitignore

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

annotate.py

@@ -1,90 +0,0 @@
-import json
-import os
-from typing import List, Union, Dict, Any, Callable
-import decord as de
-import argparse
-from concurrent.futures import ThreadPoolExecutor
-
-VideoAnnotation = Optional[Dict[str, Union[str, List[Dict[str, str]]]]]
-
-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:
-    vr = de.VideoReader(path, ctx=de.cpu(0), num_threads=1)
-    return int(len(vr) / vr.get_avg_fps())
-
-def filter_video(path: str, **kwargs) -> bool:
-    if 'max_duration' in kwargs:
-        return get_duration(path) <= kwargs['max_duration']
-    return True
-
-def annotate_video(
-    file_path: str,
-    **kwargs
-) -> VideoAnnotation:
-    if not video_filter(file_path, **kwargs):
-        return None
-    json_content: VideoAnnotation = {
-        'video': file_path,
-        'label': label,
-        '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': f'The engagement label of the video is {label}.'
-            }
-        ]
-    }
-    return json_content
-
-def dump_json(
-    folder_paths: List[str],
-    video_filter: Callable[[str, Any], bool] = lambda path: True,
-    **kwargs
-) -> List[VideoAnnotation]:
-    json_contents: List[VideoAnnotation] = []
-
-    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, file_name) # join on Windows cannot run not Linux
-            file_path: str = folder_path + file_name
-            json_content = annotate_video(file_path, **kwargs)
-            if json_content is not None:
-                json_contents.append(json_content)
-    
-    return json_contents
-
-if __name__ == "__main__":
-
-    parser = argparse.ArgumentParser(
-        prog = 'annotate',
-        description='Annotate video dataset with JSON format'
-    )
-    parser.add_argument('--output_file', type=str, default='EnTube.json', help='Output JSON file')
-    parser.add_argument('--max_duration', type=int, help='Maximum duration of video in seconds')
-    args = parser.parse_args()
-
-    folder_paths: List[str] = [
-        # os.path.join(os.getcwd(), '0'),
-        '0/', 
-        # os.path.join(os.getcwd(), '1'),
-        '1/',
-        # os.path.join(os.getcwd(), '2'),
-        '2/',
-    ]
-
-    json_contents: List[VideoAnnotation] = dump_json(folder_paths, filter_video, **vars(args))
-
-    with open(args.output_file, 'w') as f:
-        json.dump(json_contents, f, indent=4)

annotation/annotate.py

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,62 @@
+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