kaiko-eva 0.1.8__py3-none-any.whl → 0.2.1__py3-none-any.whl

eva/vision/data/datasets/classification/__init__.py

@@ -1,18 +1,27 @@
 """Image classification datasets API."""
 
 from eva.vision.data.datasets.classification.bach import BACH
+from eva.vision.data.datasets.classification.bracs import BRACS
+from eva.vision.data.datasets.classification.breakhis import BreaKHis
 from eva.vision.data.datasets.classification.camelyon16 import Camelyon16
 from eva.vision.data.datasets.classification.crc import CRC
+from eva.vision.data.datasets.classification.gleason_arvaniti import GleasonArvaniti
 from eva.vision.data.datasets.classification.mhist import MHIST
 from eva.vision.data.datasets.classification.panda import PANDA, PANDASmall
 from eva.vision.data.datasets.classification.patch_camelyon import PatchCamelyon
+from eva.vision.data.datasets.classification.unitopatho import UniToPatho
 from eva.vision.data.datasets.classification.wsi import WsiClassificationDataset
 
 __all__ = [
     "BACH",
+    "BreaKHis",
+    "BRACS",
+    "Camelyon16",
     "CRC",
+    "GleasonArvaniti",
     "MHIST",
     "PatchCamelyon",
+    "UniToPatho",
     "WsiClassificationDataset",
     "PANDA",
     "PANDASmall",

eva/vision/data/datasets/classification/bach.py

@@ -8,12 +8,11 @@ from torchvision import tv_tensors
 from torchvision.datasets import folder, utils
 from typing_extensions import override
 
-from eva.vision.data.datasets import _utils, _validators, structs
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _utils, _validators, structs, vision
 from eva.vision.utils import io
 
 
-class BACH(base.ImageClassification):
+class BACH(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """Dataset class for BACH images and corresponding targets."""
 
     _train_index_ranges: List[Tuple[int, int]] = [
@@ -125,7 +124,7 @@ class BACH(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         image_path, _ = self._samples[self._indices[index]]
         return io.read_image_as_tensor(image_path)
 

eva/vision/data/datasets/classification/bracs.py

@@ -0,0 +1,111 @@
+"""BRACS dataset class."""
+
+import os
+from typing import Callable, Dict, List, Literal, Tuple
+
+import torch
+from torchvision import tv_tensors
+from torchvision.datasets import folder
+from typing_extensions import override
+
+from eva.vision.data.datasets import _validators, vision
+from eva.vision.utils import io
+
+
+class BRACS(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
+    """Dataset class for BRACS images and corresponding targets."""
+
+    _expected_dataset_lengths: Dict[str, int] = {
+        "train": 3657,
+        "val": 312,
+        "test": 570,
+    }
+    """Expected dataset lengths for the splits and complete dataset."""
+
+    _license: str = "CC BY-NC 4.0 (https://creativecommons.org/licenses/by-nc/4.0/)"
+    """Dataset license."""
+
+    def __init__(
+        self,
+        root: str,
+        split: Literal["train", "val", "test"],
+        transforms: Callable | None = None,
+    ) -> None:
+        """Initializes the dataset.
+
+        Args:
+            root: Path to the root directory of the dataset.
+            split: Dataset split to use.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
+        """
+        super().__init__(transforms=transforms)
+
+        self._root = root
+        self._split = split
+
+        self._samples: List[Tuple[str, int]] = []
+
+    @property
+    @override
+    def classes(self) -> List[str]:
+        return ["0_N", "1_PB", "2_UDH", "3_FEA", "4_ADH", "5_DCIS", "6_IC"]
+
+    @property
+    @override
+    def class_to_idx(self) -> Dict[str, int]:
+        return {name: index for index, name in enumerate(self.classes)}
+
+    @override
+    def filename(self, index: int) -> str:
+        image_path, *_ = self._samples[index]
+        return os.path.relpath(image_path, self._dataset_path)
+
+    @override
+    def prepare_data(self) -> None:
+        _validators.check_dataset_exists(self._root, True)
+
+    @override
+    def configure(self) -> None:
+        self._samples = self._make_dataset()
+
+    @override
+    def validate(self) -> None:
+        _validators.check_dataset_integrity(
+            self,
+            length=self._expected_dataset_lengths[self._split],
+            n_classes=7,
+            first_and_last_labels=("0_N", "6_IC"),
+        )
+
+    @override
+    def load_data(self, index: int) -> tv_tensors.Image:
+        image_path, _ = self._samples[index]
+        return io.read_image_as_tensor(image_path)
+
+    @override
+    def load_target(self, index: int) -> torch.Tensor:
+        _, target = self._samples[index]
+        return torch.tensor(target, dtype=torch.long)
+
+    @override
+    def __len__(self) -> int:
+        return len(self._samples)
+
+    @property
+    def _dataset_path(self) -> str:
+        """Returns the full path of dataset directory."""
+        return os.path.join(self._root, "BRACS_RoI/latest_version")
+
+    def _make_dataset(self) -> List[Tuple[str, int]]:
+        """Builds the dataset for the specified split."""
+        dataset = folder.make_dataset(
+            directory=os.path.join(self._dataset_path, self._split),
+            class_to_idx=self.class_to_idx,
+            extensions=(".png"),
+        )
+        return dataset
+
+    def _print_license(self) -> None:
+        """Prints the dataset license."""
+        print(f"Dataset license: {self._license}")

eva/vision/data/datasets/classification/breakhis.py

@@ -0,0 +1,209 @@
+"""BreaKHis dataset class."""
+
+import functools
+import glob
+import os
+from typing import Any, Callable, Dict, List, Literal, Set
+
+import torch
+from torchvision import tv_tensors
+from torchvision.datasets import utils
+from typing_extensions import override
+
+from eva.vision.data.datasets import _validators, structs, vision
+from eva.vision.utils import io
+
+
+class BreaKHis(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
+    """Dataset class for BreaKHis images and corresponding targets."""
+
+    _resources: List[structs.DownloadResource] = [
+        structs.DownloadResource(
+            filename="BreaKHis_v1.tar.gz",
+            url="http://www.inf.ufpr.br/vri/databases/BreaKHis_v1.tar.gz",
+        ),
+    ]
+    """Dataset resources."""
+
+    _val_patient_ids: Set[str] = {
+        "18842D",
+        "19979",
+        "15275",
+        "15792",
+        "16875",
+        "3909",
+        "5287",
+        "16716",
+        "2773",
+        "5695",
+        "16184CD",
+        "23060CD",
+        "21998CD",
+        "21998EF",
+    }
+    """Patient IDs to use for dataset splits."""
+
+    _expected_dataset_lengths: Dict[str | None, int] = {
+        "train": 1132,
+        "val": 339,
+        None: 1471,
+    }
+    """Expected dataset lengths for the splits and complete dataset."""
+
+    _default_magnifications = ["40X"]
+    """Default magnification to use for images in train/val datasets."""
+
+    _license: str = "CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)"
+    """Dataset license."""
+
+    def __init__(
+        self,
+        root: str,
+        split: Literal["train", "val"] | None = None,
+        magnifications: List[Literal["40X", "100X", "200X", "400X"]] | None = None,
+        download: bool = False,
+        transforms: Callable | None = None,
+    ) -> None:
+        """Initialize the dataset.
+
+        The dataset is split into train and validation by taking into account
+        the patient IDs to avoid any data leakage.
+
+        Args:
+            root: Path to the root directory of the dataset. The dataset will
+                be downloaded and extracted here, if it does not already exist.
+            split: Dataset split to use. If `None`, the entire dataset is used.
+            magnifications: A list of the WSI magnifications to select. By default
+                only 40X images are used.
+            download: Whether to download the data for the specified split.
+                Note that the download will be executed only by additionally
+                calling the :meth:`prepare_data` method and if the data does
+                not yet exist on disk.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
+        """
+        super().__init__(transforms=transforms)
+
+        self._root = root
+        self._split = split
+        self._download = download
+
+        self._magnifications = magnifications or self._default_magnifications
+        self._indices: List[int] = []
+
+    @property
+    @override
+    def classes(self) -> List[str]:
+        return ["TA", "MC", "F", "DC"]
+
+    @property
+    @override
+    def class_to_idx(self) -> Dict[str, int]:
+        return {label: index for index, label in enumerate(self.classes)}
+
+    @property
+    def _dataset_path(self) -> str:
+        """Returns the path of the image data of the dataset."""
+        return os.path.join(self._root, "BreaKHis_v1", "histology_slides")
+
+    @functools.cached_property
+    def _image_files(self) -> List[str]:
+        """Return the list of image files in the dataset.
+
+        Returns:
+            List of image file paths.
+        """
+        image_files = []
+        for magnification in self._magnifications:
+            files_pattern = os.path.join(self._dataset_path, f"**/{magnification}", "*.png")
+            image_files.extend(list(glob.glob(files_pattern, recursive=True)))
+        return sorted(image_files)
+
+    @override
+    def filename(self, index: int) -> str:
+        image_path = self._image_files[self._indices[index]]
+        return os.path.relpath(image_path, self._dataset_path)
+
+    @override
+    def prepare_data(self) -> None:
+        if self._download:
+            self._download_dataset()
+        _validators.check_dataset_exists(self._root, True)
+
+    @override
+    def configure(self) -> None:
+        self._indices = self._make_indices()
+
+    @override
+    def validate(self) -> None:
+        _validators.check_dataset_integrity(
+            self,
+            length=self._expected_dataset_lengths[self._split],
+            n_classes=4,
+            first_and_last_labels=("TA", "DC"),
+        )
+
+    @override
+    def load_data(self, index: int) -> tv_tensors.Image:
+        image_path = self._image_files[self._indices[index]]
+        return io.read_image_as_tensor(image_path)
+
+    @override
+    def load_target(self, index: int) -> torch.Tensor:
+        class_name = self._extract_class(self._image_files[self._indices[index]])
+        return torch.tensor(self.class_to_idx[class_name], dtype=torch.long)
+
+    @override
+    def load_metadata(self, index: int) -> Dict[str, Any]:
+        return {"patient_id": self._extract_patient_id(self._image_files[self._indices[index]])}
+
+    @override
+    def __len__(self) -> int:
+        return len(self._indices)
+
+    def _download_dataset(self) -> None:
+        """Downloads the dataset."""
+        for resource in self._resources:
+            if os.path.isdir(self._dataset_path):
+                continue
+
+            self._print_license()
+            utils.download_and_extract_archive(
+                resource.url,
+                download_root=self._root,
+                filename=resource.filename,
+                remove_finished=True,
+            )
+
+    def _print_license(self) -> None:
+        """Prints the dataset license."""
+        print(f"Dataset license: {self._license}")
+
+    def _extract_patient_id(self, image_file: str) -> str:
+        """Extracts the patient ID from the image file name."""
+        return os.path.basename(image_file).split("-")[2]
+
+    def _extract_class(self, file: str) -> str:
+        return os.path.basename(file).split("-")[0].split("_")[-1]
+
+    def _make_indices(self) -> List[int]:
+        """Builds the dataset indices for the specified split."""
+        train_indices = []
+        val_indices = []
+
+        for index, image_file in enumerate(self._image_files):
+            if self._extract_class(image_file) not in self.classes:
+                continue
+            patient_id = self._extract_patient_id(image_file)
+            if patient_id in self._val_patient_ids:
+                val_indices.append(index)
+            else:
+                train_indices.append(index)
+
+        split_indices = {
+            "train": train_indices,
+            "val": val_indices,
+            None: train_indices + val_indices,
+        }
+
+        return split_indices[self._split]

eva/vision/data/datasets/classification/camelyon16.py

@@ -11,12 +11,11 @@ from torchvision import tv_tensors
 from torchvision.transforms.v2 import functional
 from typing_extensions import override
 
-from eva.vision.data.datasets import _validators, wsi
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _validators, vision, wsi
 from eva.vision.data.wsi.patching import samplers
 
 
-class Camelyon16(wsi.MultiWsiDataset, base.ImageClassification):
+class Camelyon16(wsi.MultiWsiDataset, vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """Dataset class for Camelyon16 images and corresponding targets."""
 
     _val_slides = [
@@ -195,10 +194,10 @@ class Camelyon16(wsi.MultiWsiDataset, base.ImageClassification):
 
     @override
     def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, torch.Tensor, Dict[str, Any]]:
-        return base.ImageClassification.__getitem__(self, index)
+        return vision.VisionDataset.__getitem__(self, index)
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         image_array = wsi.MultiWsiDataset.__getitem__(self, index)
         return functional.to_image(image_array)
 

eva/vision/data/datasets/classification/crc.py

@@ -8,12 +8,11 @@ from torchvision import tv_tensors
 from torchvision.datasets import folder, utils
 from typing_extensions import override
 
-from eva.vision.data.datasets import _validators, structs
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _validators, structs, vision
 from eva.vision.utils import io
 
 
-class CRC(base.ImageClassification):
+class CRC(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """Dataset class for CRC images and corresponding targets."""
 
     _train_resource: structs.DownloadResource = structs.DownloadResource(
@@ -117,7 +116,7 @@ class CRC(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         image_path, _ = self._samples[index]
         return io.read_image_as_tensor(image_path)
 

eva/vision/data/datasets/classification/gleason_arvaniti.py

@@ -0,0 +1,171 @@
+"""GleasonArvaniti dataset class."""
+
+import functools
+import glob
+import os
+from pathlib import Path
+from typing import Callable, Dict, List, Literal
+
+import pandas as pd
+import torch
+from loguru import logger
+from torchvision import tv_tensors
+from typing_extensions import override
+
+from eva.vision.data.datasets import _validators, vision
+from eva.vision.utils import io
+
+
+class GleasonArvaniti(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
+    """Dataset class for GleasonArvaniti images and corresponding targets."""
+
+    _expected_dataset_lengths: Dict[str | None, int] = {
+        "train": 15303,
+        "val": 2482,
+        "test": 4967,
+        None: 22752,
+    }
+    """Expected dataset lengths for the splits and complete dataset."""
+
+    _license: str = "CC0 1.0 Universal (https://creativecommons.org/publicdomain/zero/1.0/)"
+    """Dataset license."""
+
+    def __init__(
+        self,
+        root: str,
+        split: Literal["train", "val", "test"] | None = None,
+        transforms: Callable | None = None,
+    ) -> None:
+        """Initialize the dataset.
+
+        Args:
+            root: Path to the root directory of the dataset.
+            split: Dataset split to use. If `None`, the entire dataset is used.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
+        """
+        super().__init__(transforms=transforms)
+
+        self._root = root
+        self._split = split
+
+        self._indices: List[int] = []
+
+    @property
+    @override
+    def classes(self) -> List[str]:
+        return ["benign", "gleason_3", "gleason_4", "gleason_5"]
+
+    @property
+    @override
+    def class_to_idx(self) -> Dict[str, int]:
+        return {name: index for index, name in enumerate(self.classes)}
+
+    @functools.cached_property
+    def _image_files(self) -> List[str]:
+        """Return the list of image files in the dataset.
+
+        Returns:
+            List of image file paths.
+        """
+        subdirs = ["train_validation_patches_750", "test_patches_750/patho_1"]
+
+        image_files = []
+        for subdir in subdirs:
+            files_pattern = os.path.join(self._root, subdir, "**/*.jpg")
+            image_files += list(glob.glob(files_pattern, recursive=True))
+
+        return sorted(image_files)
+
+    @functools.cached_property
+    def _manifest(self) -> pd.DataFrame:
+        """Returns the train.csv & test.csv files as dataframe."""
+        df_train = pd.read_csv(os.path.join(self._root, "train.csv"))
+        df_val = pd.read_csv(os.path.join(self._root, "test.csv"))
+        df_train["split"], df_val["split"] = "train", "val"
+        return pd.concat([df_train, df_val], axis=0).set_index("image_id")
+
+    @override
+    def filename(self, index: int) -> str:
+        image_path = self._image_files[self._indices[index]]
+        return os.path.relpath(image_path, self._root)
+
+    @override
+    def prepare_data(self) -> None:
+        _validators.check_dataset_exists(self._root, download_available=False)
+        if not os.path.isdir(os.path.join(self._root, "train_validation_patches_750")):
+            raise FileNotFoundError(
+                f"`train_validation_patches_750` directory not found in {self._root}"
+            )
+        if not os.path.isdir(os.path.join(self._root, "test_patches_750")):
+            raise FileNotFoundError(f"`test_patches_750` directory not found in {self._root}")
+
+        if self._split == "test":
+            logger.warning(
+                "The test split currently leads to unstable evaluation results. "
+                "We recommend using the validation split instead."
+            )
+
+    @override
+    def configure(self) -> None:
+        self._indices = self._make_indices()
+
+    @override
+    def validate(self) -> None:
+        _validators.check_dataset_integrity(
+            self,
+            length=self._expected_dataset_lengths[self._split],
+            n_classes=4,
+            first_and_last_labels=("benign", "gleason_5"),
+        )
+
+    @override
+    def load_data(self, index: int) -> tv_tensors.Image:
+        image_path = self._image_files[self._indices[index]]
+        return io.read_image_as_tensor(image_path)
+
+    @override
+    def load_target(self, index: int) -> torch.Tensor:
+        target = self._extract_class(self._image_files[self._indices[index]])
+        return torch.tensor(target, dtype=torch.long)
+
+    @override
+    def __len__(self) -> int:
+        return len(self._indices)
+
+    def _print_license(self) -> None:
+        """Prints the dataset license."""
+        print(f"Dataset license: {self._license}")
+
+    def _extract_micro_array_id(self, file: str) -> str:
+        """Extracts the ID of the tissue micro array from the file name."""
+        return Path(file).stem.split("_")[0]
+
+    def _extract_class(self, file: str) -> int:
+        """Extracts the class label from the file name."""
+        return int(Path(file).stem.split("_")[-1])
+
+    def _make_indices(self) -> List[int]:
+        """Builds the dataset indices for the specified split."""
+        train_indices, val_indices, test_indices = [], [], []
+
+        for index, image_file in enumerate(self._image_files):
+            array_id = self._extract_micro_array_id(image_file)
+
+            if array_id == "ZT76":
+                val_indices.append(index)
+            elif array_id in {"ZT111", "ZT199", "ZT204"}:
+                train_indices.append(index)
+            elif "test_patches_750" in image_file:
+                test_indices.append(index)
+            else:
+                raise ValueError(f"Invalid microarray value found for file {image_file}")
+
+        split_indices = {
+            "train": train_indices,
+            "val": val_indices,
+            "test": test_indices,
+            None: train_indices + val_indices + test_indices,
+        }
+
+        return split_indices[self._split]

eva/vision/data/datasets/classification/mhist.py

@@ -7,12 +7,11 @@ import torch
 from torchvision import tv_tensors
 from typing_extensions import override
 
-from eva.vision.data.datasets import _validators
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _validators, vision
 from eva.vision.utils import io
 
 
-class MHIST(base.ImageClassification):
+class MHIST(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """MHIST dataset."""
 
     def __init__(
@@ -69,7 +68,7 @@ class MHIST(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         image_filename, _ = self._samples[index]
         image_path = os.path.join(self._dataset_path, image_filename)
         return io.read_image_as_tensor(image_path)

eva/vision/data/datasets/classification/panda.py

@@ -13,12 +13,11 @@ from torchvision.transforms.v2 import functional
 from typing_extensions import override
 
 from eva.core.data import splitting
-from eva.vision.data.datasets import _validators, structs, wsi
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _validators, structs, vision, wsi
 from eva.vision.data.wsi.patching import samplers
 
 
-class PANDA(wsi.MultiWsiDataset, base.ImageClassification):
+class PANDA(wsi.MultiWsiDataset, vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """Dataset class for PANDA images and corresponding targets."""
 
     _train_split_ratio: float = 0.7
@@ -121,10 +120,10 @@ class PANDA(wsi.MultiWsiDataset, base.ImageClassification):
 
     @override
     def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, torch.Tensor, Dict[str, Any]]:
-        return base.ImageClassification.__getitem__(self, index)
+        return vision.VisionDataset.__getitem__(self, index)
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         image_array = wsi.MultiWsiDataset.__getitem__(self, index)
         return functional.to_image(image_array)
 

eva/vision/data/datasets/classification/patch_camelyon.py

@@ -10,14 +10,13 @@ from torchvision.datasets import utils
 from torchvision.transforms.v2 import functional
 from typing_extensions import override
 
-from eva.vision.data.datasets import _validators, structs
-from eva.vision.data.datasets.classification import base
+from eva.vision.data.datasets import _validators, structs, vision
 
 _URL_TEMPLATE = "https://zenodo.org/records/2546921/files/{filename}.gz?download=1"
 """PatchCamelyon URL files templates."""
 
 
-class PatchCamelyon(base.ImageClassification):
+class PatchCamelyon(vision.VisionDataset[tv_tensors.Image, torch.Tensor]):
     """Dataset class for PatchCamelyon images and corresponding targets."""
 
     _train_resources: List[structs.DownloadResource] = [
@@ -127,7 +126,7 @@ class PatchCamelyon(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> tv_tensors.Image:
+    def load_data(self, index: int) -> tv_tensors.Image:
         return self._load_from_h5("x", index)
 
     @override