kaiko-eva 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

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

@@ -3,7 +3,8 @@
 import os
 from typing import Callable, Dict, List, Literal, Tuple
 
-import numpy as np
+import torch
+from torchvision import tv_tensors
 from torchvision.datasets import folder, utils
 from typing_extensions import override
 
@@ -52,8 +53,7 @@ class BACH(base.ImageClassification):
         root: str,
         split: Literal["train", "val"] | None = None,
         download: bool = False,
-        image_transforms: Callable | None = None,
-        target_transforms: Callable | None = None,
+        transforms: Callable | None = None,
     ) -> None:
         """Initialize the dataset.
 
@@ -68,15 +68,10 @@ class BACH(base.ImageClassification):
                 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.
-            image_transforms: A function/transform that takes in an image
-                and returns a transformed version.
-            target_transforms: A function/transform that takes in the target
-                and transforms it.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
         """
-        super().__init__(
-            image_transforms=image_transforms,
-            target_transforms=target_transforms,
-        )
+        super().__init__(transforms=transforms)
 
         self._root = root
         self._split = split
@@ -130,14 +125,14 @@ class BACH(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> np.ndarray:
+    def load_image(self, index: int) -> tv_tensors.Image:
         image_path, _ = self._samples[self._indices[index]]
-        return io.read_image(image_path)
+        return io.read_image_as_tensor(image_path)
 
     @override
-    def load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> torch.Tensor:
         _, target = self._samples[self._indices[index]]
-        return np.asarray(target, dtype=np.int64)
+        return torch.tensor(target, dtype=torch.long)
 
     @override
     def __len__(self) -> int:

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

@@ -3,32 +3,29 @@
 import abc
 from typing import Any, Callable, Dict, List, Tuple
 
-import numpy as np
+import torch
+from torchvision import tv_tensors
 from typing_extensions import override
 
 from eva.vision.data.datasets import vision
 
 
-class ImageClassification(vision.VisionDataset[Tuple[np.ndarray, np.ndarray]], abc.ABC):
+class ImageClassification(vision.VisionDataset[Tuple[tv_tensors.Image, torch.Tensor]], abc.ABC):
     """Image classification abstract dataset."""
 
     def __init__(
         self,
-        image_transforms: Callable | None = None,
-        target_transforms: Callable | None = None,
+        transforms: Callable | None = None,
     ) -> None:
         """Initializes the image classification dataset.
 
         Args:
-            image_transforms: A function/transform that takes in an image
-                and returns a transformed version.
-            target_transforms: A function/transform that takes in the target
-                and transforms it.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
         """
         super().__init__()
 
-        self._image_transforms = image_transforms
-        self._target_transforms = target_transforms
+        self._transforms = transforms
 
     @property
     def classes(self) -> List[str] | None:
@@ -38,19 +35,18 @@ class ImageClassification(vision.VisionDataset[Tuple[np.ndarray, np.ndarray]], a
     def class_to_idx(self) -> Dict[str, int] | None:
         """Returns a mapping of the class name to its target index."""
 
-    def load_metadata(self, index: int | None) -> Dict[str, Any] | List[Dict[str, Any]] | None:
+    def load_metadata(self, index: int) -> Dict[str, Any] | None:
         """Returns the dataset metadata.
 
         Args:
             index: The index of the data sample to return the metadata of.
-                If `None`, it will return the metadata of the current dataset.
 
         Returns:
             The sample metadata.
         """
 
     @abc.abstractmethod
-    def load_image(self, index: int) -> np.ndarray:
+    def load_image(self, index: int) -> tv_tensors.Image:
         """Returns the `index`'th image sample.
 
         Args:
@@ -61,7 +57,7 @@ class ImageClassification(vision.VisionDataset[Tuple[np.ndarray, np.ndarray]], a
         """
 
     @abc.abstractmethod
-    def load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> torch.Tensor:
         """Returns the `index`'th target sample.
 
         Args:
@@ -77,14 +73,15 @@ class ImageClassification(vision.VisionDataset[Tuple[np.ndarray, np.ndarray]], a
         raise NotImplementedError
 
     @override
-    def __getitem__(self, index: int) -> Tuple[np.ndarray, np.ndarray]:
+    def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, torch.Tensor, Dict[str, Any]]:
         image = self.load_image(index)
         target = self.load_target(index)
-        return self._apply_transforms(image, target)
+        image, target = self._apply_transforms(image, target)
+        return image, target, self.load_metadata(index) or {}
 
     def _apply_transforms(
-        self, image: np.ndarray, target: np.ndarray
-    ) -> Tuple[np.ndarray, np.ndarray]:
+        self, image: tv_tensors.Image, target: torch.Tensor
+    ) -> Tuple[tv_tensors.Image, torch.Tensor]:
         """Applies the transforms to the provided data and returns them.
 
         Args:
@@ -94,10 +91,6 @@ class ImageClassification(vision.VisionDataset[Tuple[np.ndarray, np.ndarray]], a
         Returns:
             A tuple with the image and the target transformed.
         """
-        if self._image_transforms is not None:
-            image = self._image_transforms(image)
-
-        if self._target_transforms is not None:
-            target = self._target_transforms(target)
-
+        if self._transforms is not None:
+            image, target = self._transforms(image, target)
         return image, target

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

@@ -0,0 +1,244 @@
+"""Camelyon16 dataset class."""
+
+import functools
+import glob
+import os
+from typing import Any, Callable, Dict, List, Literal, Tuple
+
+import pandas as pd
+import torch
+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.wsi.patching import samplers
+
+
+class Camelyon16(wsi.MultiWsiDataset, base.ImageClassification):
+    """Dataset class for Camelyon16 images and corresponding targets."""
+
+    _val_slides = [
+        "normal_010",
+        "normal_013",
+        "normal_016",
+        "normal_017",
+        "normal_019",
+        "normal_020",
+        "normal_025",
+        "normal_030",
+        "normal_031",
+        "normal_032",
+        "normal_052",
+        "normal_056",
+        "normal_057",
+        "normal_067",
+        "normal_076",
+        "normal_079",
+        "normal_085",
+        "normal_095",
+        "normal_098",
+        "normal_099",
+        "normal_101",
+        "normal_102",
+        "normal_105",
+        "normal_106",
+        "normal_109",
+        "normal_129",
+        "normal_132",
+        "normal_137",
+        "normal_142",
+        "normal_143",
+        "normal_148",
+        "normal_152",
+        "tumor_001",
+        "tumor_005",
+        "tumor_011",
+        "tumor_012",
+        "tumor_013",
+        "tumor_019",
+        "tumor_031",
+        "tumor_037",
+        "tumor_043",
+        "tumor_046",
+        "tumor_057",
+        "tumor_065",
+        "tumor_069",
+        "tumor_071",
+        "tumor_073",
+        "tumor_079",
+        "tumor_080",
+        "tumor_081",
+        "tumor_082",
+        "tumor_085",
+        "tumor_097",
+        "tumor_109",
+    ]
+    """Validation slide names, same as the ones in patch camelyon."""
+
+    def __init__(
+        self,
+        root: str,
+        sampler: samplers.Sampler,
+        split: Literal["train", "val", "test"] | None = None,
+        width: int = 224,
+        height: int = 224,
+        target_mpp: float = 0.5,
+        backend: str = "openslide",
+        image_transforms: Callable | None = None,
+        seed: int = 42,
+    ) -> None:
+        """Initializes the dataset.
+
+        Args:
+            root: Root directory of the dataset.
+            sampler: The sampler to use for sampling patch coordinates.
+            split: Dataset split to use. If `None`, the entire dataset is used.
+            width: Width of the patches to be extracted, in pixels.
+            height: Height of the patches to be extracted, in pixels.
+            target_mpp: Target microns per pixel (mpp) for the patches.
+            backend: The backend to use for reading the whole-slide images.
+            image_transforms: Transforms to apply to the extracted image patches.
+            seed: Random seed for reproducibility.
+        """
+        self._split = split
+        self._root = root
+        self._width = width
+        self._height = height
+        self._target_mpp = target_mpp
+        self._seed = seed
+
+        wsi.MultiWsiDataset.__init__(
+            self,
+            root=root,
+            file_paths=self._load_file_paths(split),
+            width=width,
+            height=height,
+            sampler=sampler,
+            target_mpp=target_mpp,
+            backend=backend,
+            image_transforms=image_transforms,
+        )
+
+    @property
+    @override
+    def classes(self) -> List[str]:
+        return ["normal", "tumor"]
+
+    @property
+    @override
+    def class_to_idx(self) -> Dict[str, int]:
+        return {"normal": 0, "tumor": 1}
+
+    @functools.cached_property
+    def annotations_test_set(self) -> Dict[str, str]:
+        """Loads the dataset labels."""
+        path = os.path.join(self._root, "testing/reference.csv")
+        reference_df = pd.read_csv(path, header=None)
+        return {k: v.lower() for k, v in reference_df[[0, 1]].itertuples(index=False)}
+
+    @functools.cached_property
+    def annotations(self) -> Dict[str, str]:
+        """Loads the dataset labels."""
+        annotations = {}
+        if self._split in ["test", None]:
+            path = os.path.join(self._root, "testing/reference.csv")
+            reference_df = pd.read_csv(path, header=None)
+            annotations.update(
+                {k: v.lower() for k, v in reference_df[[0, 1]].itertuples(index=False)}
+            )
+
+        if self._split in ["train", "val", None]:
+            annotations.update(
+                {
+                    self._get_id_from_path(file_path): self._get_class_from_path(file_path)
+                    for file_path in self._file_paths
+                    if "test" not in file_path
+                }
+            )
+        return annotations
+
+    @override
+    def prepare_data(self) -> None:
+        _validators.check_dataset_exists(self._root, False)
+
+        expected_directories = ["training/normal", "training/tumor", "testing/images"]
+        for resource in expected_directories:
+            if not os.path.isdir(os.path.join(self._root, resource)):
+                raise FileNotFoundError(f"'{resource}' not found in the root folder.")
+
+        if not os.path.isfile(os.path.join(self._root, "testing/reference.csv")):
+            raise FileNotFoundError("'reference.csv' file not found in the testing folder.")
+
+    @override
+    def validate(self) -> None:
+
+        expected_n_files = {
+            "train": 216,
+            "val": 54,
+            "test": 129,
+            None: 399,
+        }
+        _validators.check_number_of_files(
+            self._file_paths, expected_n_files[self._split], self._split
+        )
+        _validators.check_dataset_integrity(
+            self,
+            length=None,
+            n_classes=2,
+            first_and_last_labels=("normal", "tumor"),
+        )
+
+    @override
+    def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, torch.Tensor, Dict[str, Any]]:
+        return base.ImageClassification.__getitem__(self, index)
+
+    @override
+    def load_image(self, index: int) -> tv_tensors.Image:
+        image_array = wsi.MultiWsiDataset.__getitem__(self, index)
+        return functional.to_image(image_array)
+
+    @override
+    def load_target(self, index: int) -> torch.Tensor:
+        file_path = self._file_paths[self._get_dataset_idx(index)]
+        class_name = self.annotations[self._get_id_from_path(file_path)]
+        return torch.tensor(self.class_to_idx[class_name], dtype=torch.int64)
+
+    @override
+    def load_metadata(self, index: int) -> Dict[str, Any]:
+        return {"wsi_id": self.filename(index).split(".")[0]}
+
+    def _load_file_paths(self, split: Literal["train", "val", "test"] | None = None) -> List[str]:
+        """Loads the file paths of the corresponding dataset split."""
+        train_paths, val_paths = [], []
+        for path in glob.glob(os.path.join(self._root, "training/**/*.tif")):
+            if self._get_id_from_path(path) in self._val_slides:
+                val_paths.append(path)
+            else:
+                train_paths.append(path)
+        test_paths = glob.glob(os.path.join(self._root, "testing/images", "*.tif"))
+
+        match split:
+            case "train":
+                paths = train_paths
+            case "val":
+                paths = val_paths
+            case "test":
+                paths = test_paths
+            case None:
+                paths = train_paths + val_paths + test_paths
+            case _:
+                raise ValueError("Invalid split. Use 'train', 'val' or `None`.")
+        return sorted([os.path.relpath(path, self._root) for path in paths])
+
+    def _get_id_from_path(self, file_path: str) -> str:
+        """Extracts the slide ID from the file path."""
+        return os.path.basename(file_path).replace(".tif", "")
+
+    def _get_class_from_path(self, file_path: str) -> str:
+        """Extracts the class name from the file path."""
+        class_name = self._get_id_from_path(file_path).split("_")[0]
+        if class_name not in self.classes:
+            raise ValueError(f"Invalid class name '{class_name}' in file path '{file_path}'.")
+        return class_name

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

@@ -3,7 +3,8 @@
 import os
 from typing import Callable, Dict, List, Literal, Tuple
 
-import numpy as np
+import torch
+from torchvision import tv_tensors
 from torchvision.datasets import folder, utils
 from typing_extensions import override
 
@@ -37,8 +38,7 @@ class CRC(base.ImageClassification):
         root: str,
         split: Literal["train", "val"],
         download: bool = False,
-        image_transforms: Callable | None = None,
-        target_transforms: Callable | None = None,
+        transforms: Callable | None = None,
     ) -> None:
         """Initializes the dataset.
 
@@ -56,15 +56,10 @@ class CRC(base.ImageClassification):
                 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.
-            image_transforms: A function/transform that takes in an image
-                and returns a transformed version.
-            target_transforms: A function/transform that takes in the target
-                and transforms it.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
         """
-        super().__init__(
-            image_transforms=image_transforms,
-            target_transforms=target_transforms,
-        )
+        super().__init__(transforms=transforms)
 
         self._root = root
         self._split = split
@@ -122,14 +117,14 @@ class CRC(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> np.ndarray:
+    def load_image(self, index: int) -> tv_tensors.Image:
         image_path, _ = self._samples[index]
-        return io.read_image(image_path)
+        return io.read_image_as_tensor(image_path)
 
     @override
-    def load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> torch.Tensor:
         _, target = self._samples[index]
-        return np.asarray(target, dtype=np.int64)
+        return torch.tensor(target, dtype=torch.long)
 
     @override
     def __len__(self) -> int:

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

@@ -3,7 +3,8 @@
 import os
 from typing import Callable, Dict, List, Literal, Tuple
 
-import numpy as np
+import torch
+from torchvision import tv_tensors
 from typing_extensions import override
 
 from eva.vision.data.datasets import _validators
@@ -18,23 +19,17 @@ class MHIST(base.ImageClassification):
         self,
         root: str,
         split: Literal["train", "test"],
-        image_transforms: Callable | None = None,
-        target_transforms: Callable | 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.
-            image_transforms: A function/transform that takes in an image
-                and returns a transformed version.
-            target_transforms: A function/transform that takes in the target
-                and transforms it.
+            transforms: A function/transform which returns a transformed
+                version of the raw data samples.
         """
-        super().__init__(
-            image_transforms=image_transforms,
-            target_transforms=target_transforms,
-        )
+        super().__init__(transforms=transforms)
 
         self._root = root
         self._split = split
@@ -74,16 +69,16 @@ class MHIST(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> np.ndarray:
+    def load_image(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(image_path)
+        return io.read_image_as_tensor(image_path)
 
     @override
-    def load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> torch.Tensor:
         _, label = self._samples[index]
         target = self.class_to_idx[label]
-        return np.asarray(target, dtype=np.int64)
+        return torch.tensor(target, dtype=torch.float32)
 
     @override
     def __len__(self) -> int: