Update rsna-2023-abdominal-trauma-detection.py

rsna-2023-abdominal-trauma-detection.py

@@ -1,278 +1,408 @@
-import urllib.parse
-
-import datasets
+import urllib
+import numpy as np
 import pandas as pd
-import requests
+import datasets
+from sklearn.model_selection import train_test_split
+
 
 _CITATION = """\
-@inproceedings{Wu2020not,
-    title={Not only Look, but also Listen: Learning Multimodal Violence Detection under Weak Supervision},
-    author={Wu, Peng and Liu, jing and Shi, Yujia and Sun, Yujia and Shao, Fangtao and Wu, Zhaoyang and Yang, Zhiwei},
-    booktitle={European Conference on Computer Vision (ECCV)},
-    year={2020}
+@InProceedings{huggingface:dataset,
+title = {RSNA 2023 Abdominal Trauma Detection Dataset},
+author={Hong Jia Herng},
+year={2023}
+}
+@misc{rsna-2023-abdominal-trauma-detection,
+    author = {Errol Colak, Hui-Ming Lin, Robyn Ball, Melissa Davis, Adam Flanders, Sabeena Jalal, Kirti Magudia, Brett Marinelli, Savvas Nicolaou, Luciano Prevedello, Jeff Rudie, George Shih, Maryam Vazirabad, John Mongan},
+    title = {RSNA 2023 Abdominal Trauma Detection},
+    publisher = {Kaggle},
+    year = {2023},
+    url = {https://kaggle.com/competitions/rsna-2023-abdominal-trauma-detection}
 }
 """
 
 _DESCRIPTION = """\
-Dataset for the paper "Not only Look, but also Listen: Learning Multimodal Violence Detection under Weak Supervision". \
-The dataset is downloaded from the authors' website (https://roc-ng.github.io/XD-Violence/). Hosting this dataset on HuggingFace \
-is just to make it easier for my own project to use this dataset. Please cite the original paper if you use this dataset.
+This dataset is the preprocessed version of the dataset from RSNA 2023 Abdominal Trauma Detection Kaggle Competition. 
+It is tailored for segmentation and classification tasks. It contains 3 different configs as described below:
+- segmentation: 206 instances where each instance includes a CT scan in NIfTI format, a segmentation mask in NIfTI format, and its relevant metadata (e.g., patient_id, series_id, incomplete_organ, aortic_hu, pixel_representation, bits_allocated, bits_stored)
+- classification: 4711 instances where each instance includes a CT scan in NIfTI format, target labels (e.g., extravasation, bowel, kidney, liver, spleen, any_injury), and its relevant metadata (e.g., patient_id, series_id, incomplete_organ, aortic_hu, pixel_representation, bits_allocated, bits_stored)
+- classification-with-mask: 206 instances where each instance includes a CT scan in NIfTI format, a segmentation mask in NIfTI format, target labels (e.g., extravasation, bowel, kidney, liver, spleen, any_injury), and its relevant metadata (e.g., patient_id, series_id, incomplete_organ, aortic_hu, pixel_representation, bits_allocated, bits_stored)
+
+All CT scans and segmentation masks had already been resampled with voxel spacing (2.0, 2.0, 3.0) and thus its reduced file size.
 """
 
-_NAME = "xd-violence"
+_NAME = "rsna-2023-abdominal-trauma-detection"
 
 _HOMEPAGE = f"https://huggingface.co/datasets/jherng/{_NAME}"
 
 _LICENSE = "MIT"
 
-_URL = f"https://huggingface.co/datasets/jherng/{_NAME}/resolve/main/data/"
+_URL = f"https://huggingface.co/datasets/jherng/{_NAME}/resolve/main/"
 
 
-class XDViolenceConfig(datasets.BuilderConfig):
+class RSNA2023AbdominalTraumaDetectionConfig(datasets.BuilderConfig):
     def __init__(self, **kwargs):
-        """BuilderConfig for XD-Violence.
-        Args:
-          **kwargs: keyword arguments forwarded to super.
-        """
-        super(XDViolenceConfig, self).__init__(**kwargs)
+        self.test_size = kwargs.pop("test_size", 0.1)
+        self.random_state = kwargs.pop("random_state", 42)
+        super(RSNA2023AbdominalTraumaDetectionConfig, self).__init__(**kwargs)
+
 
+class RSNA2023AbdominalTraumaDetection(datasets.GeneratorBasedBuilder):
+    VERSION = datasets.Version("1.0.0")
 
-class XDViolence(datasets.GeneratorBasedBuilder):
     BUILDER_CONFIGS = [
-        XDViolenceConfig(
-            name="video",
-            description="Video dataset",
+        RSNA2023AbdominalTraumaDetectionConfig(
+            name="segmentation",
+            version=VERSION,
+            description="This part of the dataset loads the CT scans, segmentation masks, and metadata.",
+        ),
+        RSNA2023AbdominalTraumaDetectionConfig(
+            name="classification",
+            version=VERSION,
+            description="This part of the dataset loads the CT scans, target labels, and metadata.",
         ),
-        XDViolenceConfig(
-            name="rgb",
-            description="RGB visual features of the video dataset",
+        RSNA2023AbdominalTraumaDetectionConfig(
+            name="classification-with-mask",
+            version=VERSION,
+            description="This part of the dataset loads the CT scans, segmentation masks, target labels, and metadata.",
         ),
     ]
 
-    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,
-    }
+    DEFAULT_CONFIG_NAME = "classification"  # It's not mandatory to have a default configuration. Just use one if it make sense.
+    BUILDER_CONFIG_CLASS = RSNA2023AbdominalTraumaDetectionConfig
 
     def _info(self):
-        if self.config.name == "rgb":
+        if self.config.name == "segmentation":
             features = datasets.Features(
                 {
-                    "id": datasets.Value("string"),
-                    "rgb_feats": datasets.Array3D(
-                        shape=(None, 5, 2048),
-                        dtype="float32",  # (num_frames, num_crops, feature_dim) use 5 crops by default as of now
+                    "img_path": datasets.Value("string"),
+                    "seg_path": datasets.Value("string"),
+                    "metadata": {
+                        "series_id": datasets.Value("int32"),
+                        "patient_id": datasets.Value("int32"),
+                        "incomplete_organ": datasets.Value("bool"),
+                        "aortic_hu": datasets.Value("float32"),
+                        "pixel_representation": datasets.Value("int32"),
+                        "bits_allocated": datasets.Value("int32"),
+                        "bits_stored": datasets.Value("int32"),
+                    },
+                }
+            )
+        elif self.config.name == "classification-with-mask":
+            features = datasets.Features(
+                {
+                    "img_path": datasets.Value("string"),
+                    "seg_path": datasets.Value("string"),
+                    "bowel": datasets.ClassLabel(
+                        num_classes=2, names=["healthy", "injury"]
                     ),
-                    "binary_target": datasets.ClassLabel(
-                        names=["Non-violence", "Violence"]
+                    "extravasation": datasets.ClassLabel(
+                        num_classes=2, names=["healthy", "injury"]
                     ),
-                    "multilabel_target": datasets.Sequence(
-                        datasets.ClassLabel(
-                            names=[
-                                "Normal",
-                                "Fighting",
-                                "Shooting",
-                                "Riot",
-                                "Abuse",
-                                "Car accident",
-                                "Explosion",
-                            ]
-                        )
+                    "kidney": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
                     ),
-                    "frame_annotations": datasets.Sequence(
-                        {
-                            "start": datasets.Value("int32"),
-                            "end": datasets.Value("int32"),
-                        }
+                    "liver": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
                     ),
+                    "spleen": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
+                    ),
+                    "any_injury": datasets.Value("bool"),
+                    "metadata": {
+                        "series_id": datasets.Value("int32"),
+                        "patient_id": datasets.Value("int32"),
+                        "incomplete_organ": datasets.Value("bool"),
+                        "aortic_hu": datasets.Value("float32"),
+                        "pixel_representation": datasets.Value("int32"),
+                        "bits_allocated": datasets.Value("int32"),
+                        "bits_stored": datasets.Value("int32"),
+                    },
                 }
             )
-        else:  # default = "video"
+
+        else:
             features = datasets.Features(
                 {
-                    "id": datasets.Value("string"),
-                    "path": datasets.Value("string"),
-                    "binary_target": datasets.ClassLabel(
-                        names=["Non-violence", "Violence"]
+                    "img_path": datasets.Value("string"),
+                    "bowel": datasets.ClassLabel(
+                        num_classes=2, names=["healthy", "injury"]
                     ),
-                    "multilabel_target": datasets.Sequence(
-                        datasets.ClassLabel(
-                            names=[
-                                "Normal",
-                                "Fighting",
-                                "Shooting",
-                                "Riot",
-                                "Abuse",
-                                "Car accident",
-                                "Explosion",
-                            ]
-                        )
+                    "extravasation": datasets.ClassLabel(
+                        num_classes=2, names=["healthy", "injury"]
                     ),
-                    "frame_annotations": datasets.Sequence(
-                        {
-                            "start": datasets.Value("int32"),
-                            "end": datasets.Value("int32"),
-                        }
+                    "kidney": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
                     ),
+                    "liver": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
+                    ),
+                    "spleen": datasets.ClassLabel(
+                        num_classes=3, names=["healthy", "low", "high"]
+                    ),
+                    "any_injury": datasets.Value("bool"),
+                    "metadata": {
+                        "series_id": datasets.Value("int32"),
+                        "patient_id": datasets.Value("int32"),
+                        "incomplete_organ": datasets.Value("bool"),
+                        "aortic_hu": datasets.Value("float32"),
+                        "pixel_representation": datasets.Value("int32"),
+                        "bits_allocated": datasets.Value("int32"),
+                        "bits_stored": datasets.Value("int32"),
+                    },
                 }
             )
 
         return datasets.DatasetInfo(
-            features=features,
             description=_DESCRIPTION,
+            features=features,
             homepage=_HOMEPAGE,
             license=_LICENSE,
             citation=_CITATION,
         )
 
     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")
-                ),
-            }
+        # segmentation: 206 segmentations and the relevant imgs, train_series_meta.csv, train_dicom_tags.parquet
+        # classification: 4711 all imgs, train.csv, train_series_meta.csv, train_dicom_tags.parquet
+        # classification-with-mask: 206 segmentations and the relevant imgs, train.csv, train_series_meta.csv, train_dicom_tags.parquet
+        series_meta_df = pd.read_csv(
+            dl_manager.download_and_extract(
+                urllib.parse.urljoin(_URL, "train_series_meta.csv")
+            )
+        )
+        series_meta_df["img_download_url"] = series_meta_df.apply(
+            lambda x: urllib.parse.urljoin(
+                _URL,
+                f"train_images/{int(x['patient_id'])}/{int(x['series_id'])}.nii.gz",
+            ),
+            axis=1,
+        )
+        series_meta_df["seg_download_url"] = series_meta_df.apply(
+            lambda x: urllib.parse.urljoin(
+                _URL, f"segmentations/{int(x['series_id'])}.nii.gz"
+            ),
+            axis=1,
+        )
+        if (
+            self.config.name == "classification-with-mask"
+            or self.config.name == "segmentation"
+        ):
+            series_meta_df = series_meta_df.loc[series_meta_df["has_segmentation"] == 1]
 
-            # Download test annotation file
-            annotation_path = dl_manager.download_and_extract(
-                urllib.parse.urljoin(_URL, "test_annotations.txt")
+            series_meta_df["img_cache_path"] = dl_manager.download(
+                series_meta_df["img_download_url"].tolist()
+            )
+            series_meta_df["seg_cache_path"] = dl_manager.download(
+                series_meta_df["seg_download_url"].tolist()
             )
 
-            # 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=":/",
-                    )
-                )
-                .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=":/",
-                    )
-                )
-                .to_list(),
-            }
+        else:
+            series_meta_df["img_cache_path"] = dl_manager.download(
+                series_meta_df["img_download_url"].tolist()
+            )
+            series_meta_df["seg_cache_path"] = None
 
-            video_paths = {
-                "train": dl_manager.download(video_urls["train"]),
-                "test": dl_manager.download(video_urls["test"]),
+        dicom_tags_df = datasets.load_dataset(
+            "parquet", data_files=urllib.parse.urljoin(_URL, "train_dicom_tags.parquet")
+        )["train"].to_pandas()[
+            [
+                "SeriesInstanceUID",
+                "PixelRepresentation",
+                "BitsAllocated",
+                "BitsStored",
+            ]
+        ]
+        dicom_tags_df["SeriesID"] = dicom_tags_df["SeriesInstanceUID"].apply(
+            lambda x: int(x.split(".")[-1])
+        )
+        dicom_tags_df = dicom_tags_df.drop(labels=["SeriesInstanceUID"], axis=1)
+        dicom_tags_df = dicom_tags_df.groupby(by=["SeriesID"], as_index=False).first()
+        dicom_tags_df = dicom_tags_df.rename(
+            columns={
+                "SeriesID": "series_id",
+                "PixelRepresentation": "pixel_representation",
+                "BitsAllocated": "bits_allocated",
+                "BitsStored": "bits_stored",
             }
+        )
+        series_meta_df = pd.merge(
+            left=series_meta_df, right=dicom_tags_df, how="inner", on="series_id"
+        )
 
-            # Function to read annotations
-            annotation_readers = {
-                "train": self._read_list,
-                "test": self._read_test_annotations,
-            }
+        self.labels_df = (
+            pd.read_csv(
+                dl_manager.download_and_extract(urllib.parse.urljoin(_URL, "train.csv"))
+            )
+            if self.config.name != "segmentation"
+            else None
+        )
 
-            return [
-                datasets.SplitGenerator(
-                    name=datasets.Split.TRAIN,
-                    gen_kwargs={
-                        "list_path": list_paths["train"],
-                        "frame_annotation_path": None,
-                        "video_paths": video_paths["train"],
-                        "annotation_reader": annotation_readers["train"],
-                    },
-                ),
-                datasets.SplitGenerator(
-                    name=datasets.Split.TEST,
-                    gen_kwargs={
-                        "list_path": list_paths["test"],
-                        "frame_annotation_path": annotation_path,
-                        "video_paths": video_paths["test"],
-                        "annotation_reader": annotation_readers["test"],
-                    },
-                ),
-            ]
+        train_series_meta_df, test_series_meta_df = train_test_split(
+            series_meta_df, test_size=self.config.test_size, random_state=self.config.random_state, shuffle=True
+        )
+
+        return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "filepaths": train_series_meta_df[
+                        [
+                            "series_id",
+                            "patient_id",
+                            "img_cache_path",
+                            "seg_cache_path",
+                            "incomplete_organ",
+                            "aortic_hu",
+                            "pixel_representation",
+                            "bits_allocated",
+                            "bits_stored",
+                        ]
+                    ].to_dict("records"),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "filepaths": test_series_meta_df[
+                        [
+                            "series_id",
+                            "patient_id",
+                            "img_cache_path",
+                            "seg_cache_path",
+                            "incomplete_organ",
+                            "aortic_hu",
+                            "pixel_representation",
+                            "bits_allocated",
+                            "bits_stored",
+                        ]
+                    ].to_dict("records"),
+                },
+            ),
+        ]
 
     def _generate_examples(
-        self, list_path, frame_annotation_path, video_paths, annotation_reader
+        self,
+        filepaths,
     ):
-        if self.config.name == "rgb":
-            raise NotImplementedError("rgb not implemented yet")
-        else:
-            ann_data = annotation_reader(list_path, frame_annotation_path)
+        if self.config.name == "segmentation":
+            for key, series_meta in enumerate(filepaths):
+                yield key, {
+                    "img_path": series_meta["img_cache_path"],
+                    "seg_path": series_meta["seg_cache_path"],
+                    "metadata": {
+                        "series_id": series_meta["series_id"],
+                        "patient_id": series_meta["patient_id"],
+                        "incomplete_organ": series_meta["incomplete_organ"],
+                        "aortic_hu": series_meta["aortic_hu"],
+                        "pixel_representation": series_meta["pixel_representation"],
+                        "bits_allocated": series_meta["bits_allocated"],
+                        "bits_stored": series_meta["bits_stored"],
+                    },
+                }
 
-            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", [])
+        elif self.config.name == "classification-with-mask":
+            for key, series_meta in enumerate(filepaths):
+                label_data = (
+                    self.labels_df.loc[
+                        self.labels_df["patient_id"] == series_meta["patient_id"]
+                    ]
+                    .iloc[0]
+                    .to_dict()
+                )
 
-                yield (
-                    key,
-                    {
-                        "id": id,
-                        "path": path,
-                        "binary_target": binary,
-                        "multilabel_target": multilabel,
-                        "frame_annotations": frame_annotations,
+                yield key, {
+                    "img_path": series_meta["img_cache_path"],
+                    "seg_path": series_meta["seg_cache_path"],
+                    "bowel": np.argmax(
+                        [label_data["bowel_healthy"], label_data["bowel_injury"]]
+                    ),
+                    "extravasation": np.argmax(
+                        [
+                            label_data["extravasation_healthy"],
+                            label_data["extravasation_injury"],
+                        ]
+                    ),
+                    "kidney": np.argmax(
+                        [
+                            label_data["kidney_healthy"],
+                            label_data["kidney_low"],
+                            label_data["kidney_high"],
+                        ]
+                    ),
+                    "liver": np.argmax(
+                        [
+                            label_data["liver_healthy"],
+                            label_data["liver_low"],
+                            label_data["liver_high"],
+                        ]
+                    ),
+                    "spleen": np.argmax(
+                        [
+                            label_data["spleen_healthy"],
+                            label_data["spleen_low"],
+                            label_data["spleen_high"],
+                        ]
+                    ),
+                    "any_injury": label_data["any_injury"],
+                    "metadata": {
+                        "series_id": series_meta["series_id"],
+                        "patient_id": series_meta["patient_id"],
+                        "incomplete_organ": series_meta["incomplete_organ"],
+                        "aortic_hu": series_meta["aortic_hu"],
+                        "pixel_representation": series_meta["pixel_representation"],
+                        "bits_allocated": series_meta["bits_allocated"],
+                        "bits_stored": series_meta["bits_stored"],
                     },
+                }
+        else:
+            for key, series_meta in enumerate(filepaths):
+                label_data = (
+                    self.labels_df.loc[
+                        self.labels_df["patient_id"] == series_meta["patient_id"]
+                    ]
+                    .iloc[0]
+                    .to_dict()
                 )
 
-    @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)
-        )
-
-        return file_list.to_dict("records")
-
-    @classmethod
-    def _extract_labels(cls, video_id):
-        """Extracts labels from the video id."""
-        codes = video_id.split("_")[-1].split(".mp4")[0].split("-")
-
-        binary = 1 if len(codes) > 1 else 0
-        multilabel = [
-            cls.LABEL2IDX[cls.CODE2LABEL[code]] for code in codes if code != "0"
-        ]
-
-        return binary, multilabel
+                yield key, {
+                    "img_path": series_meta["img_cache_path"],
+                    "bowel": np.argmax(
+                        [label_data["bowel_healthy"], label_data["bowel_injury"]]
+                    ),
+                    "extravasation": np.argmax(
+                        [
+                            label_data["extravasation_healthy"],
+                            label_data["extravasation_injury"],
+                        ]
+                    ),
+                    "kidney": np.argmax(
+                        [
+                            label_data["kidney_healthy"],
+                            label_data["kidney_low"],
+                            label_data["kidney_high"],
+                        ]
+                    ),
+                    "liver": np.argmax(
+                        [
+                            label_data["liver_healthy"],
+                            label_data["liver_low"],
+                            label_data["liver_high"],
+                        ]
+                    ),
+                    "spleen": np.argmax(
+                        [
+                            label_data["spleen_healthy"],
+                            label_data["spleen_low"],
+                            label_data["spleen_high"],
+                        ]
+                    ),
+                    "any_injury": label_data["any_injury"],
+                    "metadata": {
+                        "series_id": series_meta["series_id"],
+                        "patient_id": series_meta["patient_id"],
+                        "incomplete_organ": series_meta["incomplete_organ"],
+                        "aortic_hu": series_meta["aortic_hu"],
+                        "pixel_representation": series_meta["pixel_representation"],
+                        "bits_allocated": series_meta["bits_allocated"],
+                        "bits_stored": series_meta["bits_stored"],
+                    },
+                }