Update xd-violence.py

xd-violence.py

@@ -1,6 +1,7 @@
 import urllib.parse
 
 import datasets
+import numpy as np
 import pandas as pd
 import requests
 
@@ -41,43 +42,38 @@ class XDViolence(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
         XDViolenceConfig(
             name="video",
-            description="Video dataset",
+            description="Video dataset.",
         ),
         XDViolenceConfig(
-            name="rgb",
-            description="RGB visual features of the video dataset",
+            name="i3d_rgb",
+            description="RGB features of the dataset extracted with pretrained I3D ResNet50 model.",
         ),
+        # TODO: Add swin_rgb features
+        # XDViolenceConfig(
+        #     name="swin_rgb",
+        #     description="RGB features of the dataset extracted with pretrained Video Swin Transformer model.",
+        # ),
     ]
 
     DEFAULT_CONFIG_NAME = "video"
     BUILDER_CONFIG_CLASS = XDViolenceConfig
 
-    CODE2LABEL = {
-        "A": "Normal",
-        "B1": "Fighting",
-        "B2": "Shooting",
-        "B4": "Riot",
-        "B5": "Abuse",
-        "B6": "Car accident",
-        "G": "Explosion",
-    }
-
-    LABEL2IDX = {
-        "Normal": 0,
-        "Fighting": 1,
-        "Shooting": 2,
-        "Riot": 3,
-        "Abuse": 4,
-        "Car accident": 5,
-        "Explosion": 6,
+    CODE2IDX = {
+        "A": 0,  # Normal
+        "B1": 1,  # Fighting
+        "B2": 2,  # Shooting
+        "B4": 3,  # Riot
+        "B5": 4,  # Abuse
+        "B6": 5,  # Car accident
+        "G": 6,  # Explosion
     }
 
     def _info(self):
-        if self.config.name == "rgb":
+        if self.config.name == "i3d_rgb":
             features = datasets.Features(
                 {
                     "id": datasets.Value("string"),
-                    "rgb_feats": datasets.Array3D(
+                    "feature": datasets.Array3D(
                         shape=(None, 5, 2048),
                         dtype="float32",  # (num_frames, num_crops, feature_dim) use 5 crops by default as of now
                     ),
@@ -144,161 +140,177 @@ class XDViolence(datasets.GeneratorBasedBuilder):
         )
 
     def _split_generators(self, dl_manager):
-        if self.config.name == "rgb":
-            raise NotImplementedError("rgb not implemented yet")
-        else:
-            # Download train and test list files
-            list_paths = {
-                "train": dl_manager.download_and_extract(
-                    urllib.parse.urljoin(_URL, "train_list.txt")
-                ),
-                "test": dl_manager.download_and_extract(
-                    urllib.parse.urljoin(_URL, "test_list.txt")
-                ),
-            }
-
-            # Download test annotation file
-            annotation_path = dl_manager.download_and_extract(
-                urllib.parse.urljoin(_URL, "test_annotations.txt")
+        # Download train list
+        train_list_path = dl_manager.download_and_extract(
+            urllib.parse.urljoin(_URL, "train_list.txt")
+        )
+        train_list = (
+            pd.read_csv(
+                train_list_path, header=None, sep=" ", usecols=[0], names=["id"]
+            )["id"]
+            .apply(lambda x: x.rstrip(".mp4"))
+            .tolist()
+        )
+        train_ids = [
+            x.split("/")[1] for x in train_list
+        ]  # remove subfolder prefix, e.g., "1-1004"
+
+        # Download test list
+        test_list_path = dl_manager.download_and_extract(
+            urllib.parse.urljoin(_URL, "test_list.txt")
+        )
+        test_list = (
+            pd.read_csv(
+                test_list_path, header=None, sep=" ", usecols=[0], names=["id"]
+            )["id"]
+            .apply(lambda x: x.rstrip(".mp4"))
+            .tolist()
+        )
+        test_ids = [x.split("/")[1] for x in test_list]
+
+        # Download test annotation file
+        test_annotations_path = dl_manager.download_and_extract(
+            urllib.parse.urljoin(_URL, "test_annotations.txt")
+        )
+
+        if self.config.name == "i3d_rgb":
+            # Download features
+            train_paths = dl_manager.download_and_extract(
+                [
+                    urllib.parse.quote(
+                        urllib.parse.urljoin(_URL, f"i3d_rgb/{x}.npy"), safe=":/"
+                    )
+                    for x in train_list
+                ]
+            )
+
+            test_paths = dl_manager.download_and_extract(
+                [
+                    urllib.parse.quote(
+                        urllib.parse.urljoin(_URL, f"i3d_rgb/{x}.npy"), safe=":/"
+                    )
+                    for x in test_list
+                ]
             )
 
+        else:
             # Download videos
-            video_urls = {
-                "train": pd.read_csv(
-                    list_paths["train"],
-                    header=None,
-                    sep=" ",
-                    usecols=[0],
-                    names=["id"],
-                )["id"]
-                .apply(
-                    lambda x: urllib.parse.quote(
-                        urllib.parse.urljoin(_URL, f"video/{x.split('.mp4')[0]}.mp4"),
-                        safe=":/",
+            train_paths = dl_manager.download_and_extract(
+                [
+                    urllib.parse.quote(
+                        urllib.parse.urljoin(_URL, f"video/{x}.mp4"), safe=":/"
                     )
-                )
-                .to_list(),
-                "test": pd.read_csv(
-                    list_paths["test"],
-                    header=None,
-                    sep=" ",
-                    usecols=[0],
-                    names=["id"],
-                )["id"]
-                .apply(
-                    lambda x: urllib.parse.quote(
-                        urllib.parse.urljoin(_URL, f"video/{x.split('.mp4')[0]}.mp4"),
-                        safe=":/",
+                    for x in train_list
+                ]
+            )
+
+            test_paths = dl_manager.download_and_extract(
+                [
+                    urllib.parse.quote(
+                        urllib.parse.urljoin(_URL, f"video/{x}.mp4"), safe=":/"
                     )
-                )
-                .to_list(),
-            }
-
-            video_paths = {
-                "train": dl_manager.download(video_urls["train"]),
-                "test": dl_manager.download(video_urls["test"]),
-            }
-
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "list_path": list_paths["train"],
-                        "frame_annotation_path": None,
-                        "video_paths": video_paths["train"],
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "list_path": list_paths["test"],
-                        "frame_annotation_path": annotation_path,
-                        "video_paths": video_paths["test"],
-                    },
-                ),
-            ]
+                    for x in test_list
+                ]
+            )
 
-    def _generate_examples(self, list_path, frame_annotation_path, video_paths):
-        if self.config.name == "rgb":
-            raise NotImplementedError("rgb not implemented yet")
-        else:
-            ann_data = self._read_list(list_path, frame_annotation_path)
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "ids": train_ids,
+                    "paths": train_paths,
+                    "annotations_path": None,
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "ids": test_ids,
+                    "paths": test_paths,
+                    "annotations_path": test_annotations_path,
+                },
+            ),
+        ]
 
-            for key, (path, annotation) in enumerate(zip(video_paths, ann_data)):
-                id = annotation["id"]
-                binary = annotation["binary_target"]
-                multilabel = annotation["multilabel_target"]
-                frame_annotations = annotation.get("frame_annotations", [])
+    def _generate_examples(self, ids, paths, annotations_path):
+        frame_annots_mapper = (
+            self._read_frame_annotations(annotations_path)
+            if annotations_path
+            else dict()
+        )
+        labels = [self._extract_labels(f_id) for f_id in ids]  # Extract labels
+
+        if self.config.name == "i3d_rgb":
+            for key, (f_id, f_path, f_label) in enumerate(zip(ids, paths, labels)):
+                binary, multilabel = f_label
+                frame_annotations = frame_annots_mapper.get(f_id, [])
+                feature = np.load(f_path)
 
                 yield (
                     key,
                     {
-                        "id": id,
-                        "path": path,
+                        "id": f_id,
+                        "feature": feature,
                         "binary_target": binary,
                         "multilabel_target": multilabel,
                         "frame_annotations": frame_annotations,
                     },
                 )
 
-    @staticmethod
-    def _read_list(list_path, frame_annotation_path):
-        file_list = pd.read_csv(
-            list_path, header=None, sep=" ", usecols=[0], names=["id"]
-        )
-        file_list["id"] = file_list["id"].apply(
-            lambda x: x.split("/")[1].split(".mp4")[0]
-        )
-        file_list["binary_target"], file_list["multilabel_target"] = zip(
-            *file_list["id"].apply(XDViolence._extract_labels)
-        )
-
-        if frame_annotation_path:  # test set
-            id2frame_annotation = {}
+        else:
+            for key, (f_id, f_path, f_label) in enumerate(zip(ids, paths, labels)):
+                binary, multilabel = f_label
+                frame_annotations = frame_annots_mapper.get(f_id, [])
 
-            url_components = urllib.parse.urlparse(frame_annotation_path)
-            is_url = url_components.scheme in ("http", "https")
-            if is_url:
-                with requests.get(frame_annotation_path, stream=True) as r:
-                    r.raise_for_status()
+                yield (
+                    key,
+                    {
+                        "id": f_id,
+                        "path": f_path,
+                        "binary_target": binary,
+                        "multilabel_target": multilabel,
+                        "frame_annotations": frame_annotations,
+                    },
+                )
 
-                    for line in r.iter_lines():
-                        parts = line.decode("utf-8").strip().split(" ")
-                        id = parts[0].split(".mp4")[0]
-                        frame_annotation = [
-                            {"start": parts[start_idx], "end": parts[start_idx + 1]}
-                            for start_idx in range(1, len(parts), 2)
-                        ]
+    def _read_frame_annotations(self, path):
+        mapper = {}
+        is_url = urllib.parse.urlparse(path).scheme in ("http", "https")
 
-                        id2frame_annotation[id] = frame_annotation
+        if is_url:
+            with requests.get(path, stream=True) as r:
+                r.raise_for_status()
 
-            else:
-                with open(frame_annotation_path, "r") as f:
-                    for line in f:
-                        parts = line.strip().split(" ")
+                for line in r.iter_lines():
+                    parts = line.decode("utf-8").strip().split(" ")
+                    f_id = parts[0].rstrip(".mp4")
+                    frame_annotations = [
+                        {"start": parts[start_idx], "end": parts[start_idx + 1]}
+                        for start_idx in range(1, len(parts), 2)
+                    ]
 
-                        id = parts[0].split(".mp4")[0]
-                        frame_annotation = [
-                            {"start": parts[start_idx], "end": parts[start_idx + 1]}
-                            for start_idx in range(1, len(parts), 2)
-                        ]
+                    mapper[f_id] = frame_annotations
 
-                        id2frame_annotation[id] = frame_annotation
+        else:
+            with open(path, "r") as f:
+                for line in f:
+                    parts = line.strip().split(" ")
+                    f_id = parts[0].rstrip(".mp4")
+                    frame_annotations = [
+                        {"start": parts[start_idx], "end": parts[start_idx + 1]}
+                        for start_idx in range(1, len(parts), 2)
+                    ]
 
-            file_list["frame_annotations"] = file_list["id"].apply(
-                lambda x: id2frame_annotation[x] if x in id2frame_annotation else []
-            )
+                    mapper[f_id] = frame_annotations
 
-        return file_list.to_dict("records")
+        return mapper
 
-    @classmethod
-    def _extract_labels(cls, video_id):
-        """Extracts labels from the video id."""
-        codes = video_id.split("_")[-1].split(".mp4")[0].split("-")
+    def _extract_labels(self, f_id):
+        """Extracts labels from a given file id."""
+        codes = f_id.split("_")[-1].split("-")
 
         binary = 1 if len(codes) > 1 else 0
-        multilabel = [
-            cls.LABEL2IDX[cls.CODE2LABEL[code]] for code in codes if code != "0"
-        ]
+
+        multilabel = [self.CODE2IDX[code] for code in codes if code != "0"]
 
         return binary, multilabel