kaiko-eva 0.0.2__py3-none-any.whl → 0.1.1__py3-none-any.whl

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:

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

@@ -0,0 +1,184 @@
+"""PANDA 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.datasets import utils
+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.wsi.patching import samplers
+
+
+class PANDA(wsi.MultiWsiDataset, base.ImageClassification):
+    """Dataset class for PANDA images and corresponding targets."""
+
+    _train_split_ratio: float = 0.7
+    """Train split ratio."""
+
+    _val_split_ratio: float = 0.15
+    """Validation split ratio."""
+
+    _test_split_ratio: float = 0.15
+    """Test split ratio."""
+
+    _resources: List[structs.DownloadResource] = [
+        structs.DownloadResource(
+            filename="train_with_noisy_labels.csv",
+            url="https://raw.githubusercontent.com/analokmaus/kaggle-panda-challenge-public/master/train.csv",
+            md5="5e4bfc78bda9603d2e2faf3ed4b21dfa",
+        )
+    ]
+    """Download resources."""
+
+    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._seed = seed
+
+        self._download_resources()
+
+        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 ["0", "1", "2", "3", "4", "5"]
+
+    @functools.cached_property
+    def annotations(self) -> pd.DataFrame:
+        """Loads the dataset labels."""
+        path = os.path.join(self._root, "train_with_noisy_labels.csv")
+        return pd.read_csv(path, index_col="image_id")
+
+    @override
+    def prepare_data(self) -> None:
+        _validators.check_dataset_exists(self._root, False)
+
+        if not os.path.isdir(os.path.join(self._root, "train_images")):
+            raise FileNotFoundError("'train_images' directory not found in the root folder.")
+        if not os.path.isfile(os.path.join(self._root, "train_with_noisy_labels.csv")):
+            raise FileNotFoundError("'train.csv' file not found in the root folder.")
+
+    def _download_resources(self) -> None:
+        """Downloads the dataset resources."""
+        for resource in self._resources:
+            utils.download_url(resource.url, self._root, resource.filename, resource.md5)
+
+    @override
+    def validate(self) -> None:
+        _validators.check_dataset_integrity(
+            self,
+            length=None,
+            n_classes=6,
+            first_and_last_labels=("0", "5"),
+        )
+
+    @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)]
+        return torch.tensor(self._get_target_from_path(file_path), 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."""
+        image_dir = os.path.join(self._root, "train_images")
+        file_paths = sorted(glob.glob(os.path.join(image_dir, "*.tiff")))
+        file_paths = [os.path.relpath(path, self._root) for path in file_paths]
+        if len(file_paths) != len(self.annotations):
+            raise ValueError(
+                f"Expected {len(self.annotations)} images, found {len(file_paths)} in {image_dir}."
+            )
+        file_paths = self._filter_noisy_labels(file_paths)
+        targets = [self._get_target_from_path(file_path) for file_path in file_paths]
+
+        train_indices, val_indices, test_indices = splitting.stratified_split(
+            samples=file_paths,
+            targets=targets,
+            train_ratio=self._train_split_ratio,
+            val_ratio=self._val_split_ratio,
+            test_ratio=self._test_split_ratio,
+            seed=self._seed,
+        )
+
+        match split:
+            case "train":
+                return [file_paths[i] for i in train_indices]
+            case "val":
+                return [file_paths[i] for i in val_indices]
+            case "test":
+                return [file_paths[i] for i in test_indices or []]
+            case None:
+                return file_paths
+            case _:
+                raise ValueError("Invalid split. Use 'train', 'val', 'test' or `None`.")
+
+    def _filter_noisy_labels(self, file_paths: List[str]):
+        is_noisy_filter = self.annotations["noise_ratio_10"] == 0
+        non_noisy_image_ids = set(self.annotations.loc[~is_noisy_filter].index)
+        filtered_file_paths = [
+            file_path
+            for file_path in file_paths
+            if self._get_id_from_path(file_path) in non_noisy_image_ids
+        ]
+        return filtered_file_paths
+
+    def _get_target_from_path(self, file_path: str) -> int:
+        return self.annotations.loc[self._get_id_from_path(file_path), "isup_grade"]
+
+    def _get_id_from_path(self, file_path: str) -> str:
+        return os.path.basename(file_path).replace(".tiff", "")

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

@@ -4,8 +4,10 @@ import os
 from typing import Callable, Dict, List, Literal
 
 import h5py
-import numpy as np
+import torch
+from torchvision import tv_tensors
 from torchvision.datasets import utils
+from torchvision.transforms.v2 import functional
 from typing_extensions import override
 
 from eva.vision.data.datasets import _validators, structs
@@ -70,8 +72,7 @@ class PatchCamelyon(base.ImageClassification):
         root: str,
         split: Literal["train", "val", "test"],
         download: bool = False,
-        image_transforms: Callable | None = None,
-        target_transforms: Callable | None = None,
+        transforms: Callable | None = None,
     ) -> None:
         """Initializes the dataset.
 
@@ -82,15 +83,10 @@ class PatchCamelyon(base.ImageClassification):
             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.
-            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
@@ -131,13 +127,13 @@ class PatchCamelyon(base.ImageClassification):
         )
 
     @override
-    def load_image(self, index: int) -> np.ndarray:
+    def load_image(self, index: int) -> tv_tensors.Image:
         return self._load_from_h5("x", index)
 
     @override
-    def load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> torch.Tensor:
         target = self._load_from_h5("y", index).squeeze()
-        return np.asarray(target, dtype=np.int64)
+        return torch.tensor(target, dtype=torch.float32)
 
     @override
     def __len__(self) -> int:
@@ -162,7 +158,7 @@ class PatchCamelyon(base.ImageClassification):
         self,
         data_key: Literal["x", "y"],
         index: int | None = None,
-    ) -> np.ndarray:
+    ) -> tv_tensors.Image:
         """Load data or targets from an HDF5 file.
 
         Args:
@@ -176,7 +172,8 @@ class PatchCamelyon(base.ImageClassification):
         h5_file = self._h5_file(data_key)
         with h5py.File(h5_file, "r") as file:
             data = file[data_key]
-            return data[:] if index is None else data[index]  # type: ignore
+            image_array = data[:] if index is None else data[index]  # type: ignore
+            return functional.to_image(image_array)  # type: ignore
 
     def _fetch_dataset_length(self) -> int:
         """Fetches the dataset split length from its HDF5 file."""