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

eva/core/data/datasets/classification/embeddings.py

@@ -12,7 +12,7 @@ class EmbeddingsClassificationDataset(embeddings_base.EmbeddingsDataset[torch.Te
     """Embeddings dataset class for classification tasks."""
 
     @override
-    def _load_embeddings(self, index: int) -> torch.Tensor:
+    def load_embeddings(self, index: int) -> torch.Tensor:
         filename = self.filename(index)
         embeddings_path = os.path.join(self._root, filename)
         tensor = torch.load(embeddings_path, map_location="cpu")
@@ -25,7 +25,7 @@ class EmbeddingsClassificationDataset(embeddings_base.EmbeddingsDataset[torch.Te
         return tensor.squeeze(0)
 
     @override
-    def _load_target(self, index: int) -> torch.Tensor:
+    def load_target(self, index: int) -> torch.Tensor:
         target = self._data.at[index, self._column_mapping["target"]]
         return torch.tensor(target, dtype=torch.int64)
 

eva/core/data/datasets/classification/multi_embeddings.py

@@ -66,7 +66,7 @@ class MultiEmbeddingsClassificationDataset(embeddings_base.EmbeddingsDataset[tor
         self._multi_ids = list(self._data[self._column_mapping["multi_id"]].unique())
 
     @override
-    def _load_embeddings(self, index: int) -> torch.Tensor:
+    def load_embeddings(self, index: int) -> torch.Tensor:
         """Loads and stacks all embedding corresponding to the `index`'th multi_id."""
         # Get all embeddings for the given index (multi_id)
         multi_id = self._multi_ids[index]
@@ -89,7 +89,7 @@ class MultiEmbeddingsClassificationDataset(embeddings_base.EmbeddingsDataset[tor
         return embeddings
 
     @override
-    def _load_target(self, index: int) -> np.ndarray:
+    def load_target(self, index: int) -> np.ndarray:
         """Returns the target corresponding to the `index`'th multi_id.
 
         This method assumes that all the embeddings corresponding to the same `multi_id`

eva/core/data/datasets/embeddings.py

@@ -98,12 +98,12 @@ class EmbeddingsDataset(base.Dataset, Generic[TargetType]):
         Returns:
             A data sample and its target.
         """
-        embeddings = self._load_embeddings(index)
-        target = self._load_target(index)
+        embeddings = self.load_embeddings(index)
+        target = self.load_target(index)
         return self._apply_transforms(embeddings, target)
 
     @abc.abstractmethod
-    def _load_embeddings(self, index: int) -> torch.Tensor:
+    def load_embeddings(self, index: int) -> torch.Tensor:
         """Returns the `index`'th embedding sample.
 
         Args:
@@ -114,7 +114,7 @@ class EmbeddingsDataset(base.Dataset, Generic[TargetType]):
         """
 
     @abc.abstractmethod
-    def _load_target(self, index: int) -> TargetType:
+    def load_target(self, index: int) -> TargetType:
         """Returns the `index`'th target sample.
 
         Args:

eva/core/data/samplers/classification/balanced.py

@@ -4,6 +4,7 @@ from collections import defaultdict
 from typing import Dict, Iterator, List
 
 import numpy as np
+from loguru import logger
 from typing_extensions import override
 
 from eva.core.data import datasets
@@ -33,6 +34,7 @@ class BalancedSampler(SamplerWithDataSource[int]):
         self._replacement = replacement
         self._class_indices: Dict[int, List[int]] = defaultdict(list)
         self._random_generator = np.random.default_rng(seed)
+        self._indices: List[int] = []
 
     def __len__(self) -> int:
         """Returns the total number of samples."""
@@ -44,18 +46,7 @@ class BalancedSampler(SamplerWithDataSource[int]):
         Returns:
             Iterator yielding dataset indices.
         """
-        indices = []
-
-        for class_idx in self._class_indices:
-            class_indices = self._class_indices[class_idx]
-            sampled_indices = self._random_generator.choice(
-                class_indices, size=self._num_samples, replace=self._replacement
-            ).tolist()
-            indices.extend(sampled_indices)
-
-        self._random_generator.shuffle(indices)
-
-        return iter(indices)
+        return iter(self._indices)
 
     @override
     def set_dataset(self, data_source: datasets.MapDataset):
@@ -72,13 +63,13 @@ class BalancedSampler(SamplerWithDataSource[int]):
         self._make_indices()
 
     def _make_indices(self):
-        """Builds indices for each class in the dataset."""
+        """Samples the indices for each class in the dataset."""
         self._class_indices.clear()
-
-        for idx in tqdm(
-            range(len(self.data_source)), desc="Fetching class indices for balanced sampler"
-        ):
-            _, target, _ = DataSample(*self.data_source[idx])
+        for idx in tqdm(range(len(self.data_source)), desc="Fetching class indices for sampler"):
+            if hasattr(self.data_source, "load_target"):
+                target = self.data_source.load_target(idx)  # type: ignore
+            else:
+                _, target, _ = DataSample(*self.data_source[idx])
             if target is None:
                 raise ValueError("The dataset must return non-empty targets.")
             if target.numel() != 1:
@@ -94,3 +85,13 @@ class BalancedSampler(SamplerWithDataSource[int]):
                         f"Class {class_idx} has only {len(indices)} samples, "
                         f"which is less than the required {self._num_samples} samples."
                     )
+
+        self._indices = []
+        for class_idx in self._class_indices:
+            class_indices = self._class_indices[class_idx]
+            sampled_indices = self._random_generator.choice(
+                class_indices, size=self._num_samples, replace=self._replacement
+            ).tolist()
+            self._indices.extend(sampled_indices)
+        self._random_generator.shuffle(self._indices)
+        logger.debug(f"Sampled indices: {self._indices}")

eva/core/loggers/utils/wandb.py

@@ -0,0 +1,33 @@
+# type: ignore
+"""Utility functions for logging with Weights & Biases."""
+
+from typing import Any, Dict
+
+from loguru import logger
+
+
+def rename_active_run(name: str) -> None:
+    """Renames the current run."""
+    import wandb
+
+    if wandb.run:
+        wandb.run.name = name
+        wandb.run.save()
+    else:
+        logger.warning("No active wandb run found that could be renamed.")
+
+
+def init_run(name: str, init_kwargs: Dict[str, Any]) -> None:
+    """Initializes a new run. If there is an active run, it will be renamed and reused."""
+    import wandb
+
+    init_kwargs["name"] = name
+    rename_active_run(name)
+    wandb.init(**init_kwargs)
+
+
+def finish_run() -> None:
+    """Finish the current run."""
+    import wandb
+
+    wandb.finish()

eva/core/models/modules/head.py

@@ -1,4 +1,4 @@
-""""Neural Network Head Module."""
+"""Neural Network Head Module."""
 
 from typing import Any, Callable, Dict
 

eva/core/trainers/functional.py

@@ -39,7 +39,7 @@ def run_evaluation_session(
             base_trainer,
             base_model,
             datamodule,
-            run_id=f"run_{run_index}",
+            run_id=run_index,
             verbose=not verbose,
         )
         recorder.update(validation_scores, test_scores)
@@ -51,7 +51,7 @@ def run_evaluation(
     base_model: modules.ModelModule,
     datamodule: datamodules.DataModule,
     *,
-    run_id: str | None = None,
+    run_id: int | None = None,
     verbose: bool = True,
 ) -> Tuple[_EVALUATE_OUTPUT, _EVALUATE_OUTPUT | None]:
     """Fits and evaluates a model out-of-place.
@@ -61,7 +61,6 @@ def run_evaluation(
         base_model: The model module to use but not modify.
         datamodule: The data module.
         run_id: The run id to be appended to the output log directory.
-            If `None`, it will use the log directory of the trainer as is.
         verbose: Whether to print the validation and test metrics
             in the end of the training.
 
@@ -70,8 +69,12 @@ def run_evaluation(
     """
     trainer, model = _utils.clone(base_trainer, base_model)
     model.configure_model()
-    trainer.setup_log_dirs(run_id or "")
-    return fit_and_validate(trainer, model, datamodule, verbose=verbose)
+
+    trainer.init_logger_run(run_id)
+    results = fit_and_validate(trainer, model, datamodule, verbose=verbose)
+    trainer.finish_logger_run(run_id)
+
+    return results
 
 
 def fit_and_validate(

eva/core/trainers/trainer.py

@@ -12,6 +12,7 @@ from typing_extensions import override
 
 from eva.core import loggers as eva_loggers
 from eva.core.data import datamodules
+from eva.core.loggers.utils import wandb as wandb_utils
 from eva.core.models import modules
 from eva.core.trainers import _logging, functional
 
@@ -53,7 +54,7 @@ class Trainer(pl_trainer.Trainer):
         self._session_id: str = _logging.generate_session_id()
         self._log_dir: str = self.default_log_dir
 
-        self.setup_log_dirs()
+        self.init_logger_run(0)
 
     @property
     def default_log_dir(self) -> str:
@@ -65,31 +66,45 @@ class Trainer(pl_trainer.Trainer):
     def log_dir(self) -> str | None:
         return self.strategy.broadcast(self._log_dir)
 
-    def setup_log_dirs(self, subdirectory: str = "") -> None:
-        """Setups the logging directory of the trainer and experimental loggers in-place.
+    def init_logger_run(self, run_id: int | None) -> None:
+        """Setup the loggers & log directories when starting a new run.
 
         Args:
-            subdirectory: Whether to append a subdirectory to the output log.
+            run_id: The id of the current run.
         """
+        subdirectory = f"run_{run_id}" if run_id is not None else ""
         self._log_dir = os.path.join(self.default_root_dir, self._session_id, subdirectory)
 
         enabled_loggers = []
-        if isinstance(self.loggers, list) and len(self.loggers) > 0:
-            for logger in self.loggers:
-                if isinstance(logger, (pl_loggers.CSVLogger, pl_loggers.TensorBoardLogger)):
-                    if not cloud_io._is_local_file_protocol(self.default_root_dir):
-                        loguru.logger.warning(
-                            f"Skipped {type(logger).__name__} as remote storage is not supported."
-                        )
-                        continue
-                    else:
-                        logger._root_dir = self.default_root_dir
-                        logger._name = self._session_id
-                        logger._version = subdirectory
-                enabled_loggers.append(logger)
+        for logger in self.loggers or []:
+            if isinstance(logger, (pl_loggers.CSVLogger, pl_loggers.TensorBoardLogger)):
+                if not cloud_io._is_local_file_protocol(self.default_root_dir):
+                    loguru.logger.warning(
+                        f"Skipped {type(logger).__name__} as remote storage is not supported."
+                    )
+                    continue
+                else:
+                    logger._root_dir = self.default_root_dir
+                    logger._name = self._session_id
+                    logger._version = subdirectory
+            elif isinstance(logger, pl_loggers.WandbLogger):
+                task_name = self.default_root_dir.split("/")[-1]
+                run_name = os.getenv("WANDB_RUN_NAME", f"{task_name}_{self._session_id}")
+                wandb_utils.init_run(f"{run_name}_{run_id}", logger._wandb_init)
+            enabled_loggers.append(logger)
 
         self._loggers = enabled_loggers or [eva_loggers.DummyLogger(self._log_dir)]
 
+    def finish_logger_run(self, run_id: int | None) -> None:
+        """Finish the current run in the enabled loggers.
+
+        Args:
+            run_id: The id of the current run.
+        """
+        for logger in self.loggers or []:
+            if isinstance(logger, pl_loggers.WandbLogger):
+                wandb_utils.finish_run()
+
     def run_evaluation_session(
         self,
         model: modules.ModelModule,

eva/vision/data/datasets/__init__.py

@@ -2,12 +2,16 @@
 
 from eva.vision.data.datasets.classification import (
     BACH,
+    BRACS,
     CRC,
     MHIST,
     PANDA,
+    BreaKHis,
     Camelyon16,
+    GleasonArvaniti,
     PANDASmall,
     PatchCamelyon,
+    UniToPatho,
     WsiClassificationDataset,
 )
 from eva.vision.data.datasets.segmentation import (
@@ -26,12 +30,16 @@ from eva.vision.data.datasets.wsi import MultiWsiDataset, WsiDataset
 __all__ = [
     "BACH",
     "BCSS",
+    "BreaKHis",
+    "BRACS",
     "CRC",
+    "GleasonArvaniti",
     "MHIST",
     "PANDA",
     "PANDASmall",
     "Camelyon16",
     "PatchCamelyon",
+    "UniToPatho",
     "WsiClassificationDataset",
     "CoNSeP",
     "EmbeddingsSegmentationDataset",

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/bracs.py

@@ -0,0 +1,112 @@
+"""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
+from eva.vision.data.datasets.classification import base
+from eva.vision.utils import io
+
+
+class BRACS(base.ImageClassification):
+    """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_image(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,210 @@
+"""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
+from eva.vision.data.datasets.classification import base
+from eva.vision.utils import io
+
+
+class BreaKHis(base.ImageClassification):
+    """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_image(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/gleason_arvaniti.py

@@ -0,0 +1,172 @@
+"""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
+from eva.vision.data.datasets.classification import base
+from eva.vision.utils import io
+
+
+class GleasonArvaniti(base.ImageClassification):
+    """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_image(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/unitopatho.py

@@ -0,0 +1,159 @@
+"""UniToPatho dataset class."""
+
+import functools
+import glob
+import os
+from typing import Callable, Dict, List, Literal
+
+import pandas as pd
+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.utils import io
+
+
+class UniToPatho(base.ImageClassification):
+    """Dataset class for UniToPatho images and corresponding targets."""
+
+    _expected_dataset_lengths: Dict[str | None, int] = {
+        "train": 6270,
+        "val": 2399,
+        None: 8669,
+    }
+    """Expected dataset lengths for the splits and complete dataset."""
+
+    _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,
+        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.
+            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 ["HP", "NORM", "TA.HG", "TA.LG", "TVA.HG", "TVA.LG"]
+
+    @property
+    @override
+    def class_to_idx(self) -> Dict[str, int]:
+        return {"HP": 0, "NORM": 1, "TA.HG": 2, "TA.LG": 3, "TVA.HG": 4, "TVA.LG": 5}
+
+    @property
+    def _dataset_path(self) -> str:
+        """Returns the path of the image data of the dataset."""
+        return os.path.join(self._root, "800")
+
+    @functools.cached_property
+    def _image_files(self) -> List[str]:
+        """Return the list of image files in the dataset.
+
+        Returns:
+            List of image file paths.
+        """
+        files_pattern = os.path.join(self._dataset_path, "**/*.png")
+        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._dataset_path, "train.csv"))
+        df_val = pd.read_csv(os.path.join(self._dataset_path, "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._dataset_path)
+
+    @override
+    def prepare_data(self) -> None:
+        _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=6,
+            first_and_last_labels=("HP", "TVA.LG"),
+        )
+
+    @override
+    def load_image(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_image_id(self, image_file: str) -> str:
+        """Extracts the image_id from the file name."""
+        return os.path.basename(image_file)
+
+    def _extract_class(self, file: str) -> int:
+        image_id = self._extract_image_id(file)
+        return int(self._manifest.at[image_id, "top_label"])
+
+    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):
+            image_id = self._extract_image_id(image_file)
+            split = self._manifest.at[image_id, "split"]
+
+            if split == "train":
+                train_indices.append(index)
+            elif split == "val":
+                val_indices.append(index)
+            else:
+                raise ValueError(f"Invalid split value found: {split}")
+
+        split_indices = {
+            "train": train_indices,
+            "val": val_indices,
+            None: train_indices + val_indices,
+        }
+
+        return split_indices[self._split]

eva/vision/data/datasets/segmentation/embeddings.py

@@ -14,7 +14,7 @@ class EmbeddingsSegmentationDataset(embeddings_base.EmbeddingsDataset[tv_tensors
     """Embeddings segmentation dataset."""
 
     @override
-    def _load_embeddings(self, index: int) -> List[torch.Tensor]:
+    def load_embeddings(self, index: int) -> List[torch.Tensor]:
         filename = self.filename(index)
         embeddings_path = os.path.join(self._root, filename)
         embeddings = torch.load(embeddings_path, map_location="cpu")
@@ -23,7 +23,7 @@ class EmbeddingsSegmentationDataset(embeddings_base.EmbeddingsDataset[tv_tensors
         return [tensor.squeeze(0) for tensor in embeddings]
 
     @override
-    def _load_target(self, index: int) -> tv_tensors.Mask:
+    def load_target(self, index: int) -> tv_tensors.Mask:
         filename = self._data.at[index, self._column_mapping["target"]]
         mask_path = os.path.join(self._root, filename)
         semantic_labels = torch.load(mask_path, map_location="cpu")

eva/vision/models/networks/backbones/pathology/mahmood.py

@@ -1,11 +1,9 @@
 """Pathology FMs from MahmoodLab."""
 
-import os
-from pathlib import Path
 from typing import Tuple
 
-import huggingface_hub
-from loguru import logger
+import timm
+import torch
 from torch import nn
 
 from eva.vision.models import wrappers
@@ -18,7 +16,6 @@ def mahmood_uni(
     dynamic_img_size: bool = True,
     out_indices: int | Tuple[int, ...] | None = None,
     hf_token: str | None = None,
-    download_dir: str = os.path.join(str(Path.home()), ".cache/eva"),
 ) -> nn.Module:
     """Initializes UNI model from MahmoodLab.
 
@@ -27,29 +24,59 @@ def mahmood_uni(
             the grid size (interpolate abs and/or ROPE pos) in the forward pass.
         out_indices: Whether and which multi-level patch embeddings to return.
         hf_token: HuggingFace token to download the model.
-        download_dir: Directory to download the model checkpoint.
 
     Returns:
         The model instance.
     """
-    checkpoint_path = os.path.join(download_dir, "pytorch_model.bin")
-    if not os.path.exists(checkpoint_path):
-        logger.info(f"Downloading the model checkpoint to {download_dir} ...")
-        os.makedirs(download_dir, exist_ok=True)
-        _utils.huggingface_login(hf_token)
-        huggingface_hub.hf_hub_download(
-            "MahmoodLab/UNI",
-            filename="pytorch_model.bin",
-            local_dir=download_dir,
-            force_download=True,
-        )
+    _utils.huggingface_login(hf_token)
 
     return wrappers.TimmModel(
-        model_name="vit_large_patch16_224",
+        model_name="hf-hub:MahmoodLab/uni",
+        pretrained=True,
         out_indices=out_indices,
         model_kwargs={
             "init_values": 1e-5,
             "dynamic_img_size": dynamic_img_size,
         },
-        checkpoint_path=checkpoint_path,
+    )
+
+
+@register_model("pathology/mahmood_uni2_h")
+def mahmood_uni2_h(
+    dynamic_img_size: bool = True,
+    out_indices: int | Tuple[int, ...] | None = None,
+    hf_token: str | None = None,
+) -> nn.Module:
+    """Initializes UNI model from MahmoodLab.
+
+    Args:
+        dynamic_img_size: Support different input image sizes by allowing to change
+            the grid size (interpolate abs and/or ROPE pos) in the forward pass.
+        out_indices: Whether and which multi-level patch embeddings to return.
+        hf_token: HuggingFace token to download the model.
+
+    Returns:
+        The model instance.
+    """
+    _utils.huggingface_login(hf_token)
+
+    return wrappers.TimmModel(
+        model_name="hf-hub:MahmoodLab/UNI2-h",
+        pretrained=True,
+        out_indices=out_indices,
+        model_kwargs={
+            "img_size": 224,
+            "patch_size": 14,
+            "depth": 24,
+            "num_heads": 24,
+            "init_values": 1e-5,
+            "embed_dim": 1536,
+            "mlp_ratio": 2.66667 * 2,
+            "num_classes": 0,
+            "no_embed_class": True,
+            "mlp_layer": timm.layers.SwiGLUPacked,
+            "act_layer": torch.nn.SiLU,
+            "reg_tokens": 8,
+            "dynamic_img_size": dynamic_img_size,
+        },
     )

{kaiko_eva-0.1.8.dist-info → kaiko_eva-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaiko-eva
-Version: 0.1.8
+Version: 0.2.0
 Summary: Evaluation Framework for oncology foundation models.
 Keywords: machine-learning,evaluation-framework,oncology,foundation-models
 Author-Email: Ioannis Gatopoulos <ioannis@kaiko.ai>, =?utf-8?q?Nicolas_K=C3=A4nzig?= <nicolas@kaiko.ai>, Roman Moser <roman@kaiko.ai>

{kaiko_eva-0.1.8.dist-info → kaiko_eva-0.2.0.dist-info}/RECORD

@@ -25,14 +25,14 @@ eva/core/data/datamodules/schemas.py,sha256=rzcf3uow6T6slVSwxEGDVmpi3QUvkiDoT_gC
 eva/core/data/datasets/__init__.py,sha256=jWPxT3gjQjwS6HqVZAb7KhMgzgklPgHeH51iPxDh_Tg,493
 eva/core/data/datasets/base.py,sha256=BLzlRFuByhrGmI7NFwn7-Tw0vpSYSRhl2Y65iX4KaMw,2526
 eva/core/data/datasets/classification/__init__.py,sha256=wJ2jD9YODftt-dMcMf0TbCjJt47qXYBKkD4-XXajvRQ,340
-eva/core/data/datasets/classification/embeddings.py,sha256=bgBVQyGxlxVCvGjmwNB52E360QwzrhGZQ44rPNFR4k8,1110
-eva/core/data/datasets/classification/multi_embeddings.py,sha256=j_o0MH2gwn_y3rNFXEUzNg6WErlG3Rq_vn5Og1Yk7J0,4603
+eva/core/data/datasets/classification/embeddings.py,sha256=hBO6dIRHAhoCaYb3ANc9fgvdBjyQNKPTrIhjc9y8-Ys,1108
+eva/core/data/datasets/classification/multi_embeddings.py,sha256=4hQy4741NDKqWCpm3kGq7aC28DF5gcwUuIpYhnbTyeM,4601
 eva/core/data/datasets/dataset.py,sha256=tA6Wd_7vqOE9GsukSWrgN9zaZKtKCHaE58SqIfWxWdg,124
-eva/core/data/datasets/embeddings.py,sha256=zNEO8KxqiOopcN_lTjwtEAm9xbnYDSjOE8X2-iZQIhU,5545
+eva/core/data/datasets/embeddings.py,sha256=0y7Fa4zHr4Y0mcB9pyP26YaeTPtetwVf_n6fnkTcgp0,5541
 eva/core/data/datasets/typings.py,sha256=KSmckjsU64pGV-8uSLkD1HmvPKYlyypngiRx9yy4RDs,383
 eva/core/data/samplers/__init__.py,sha256=rRrKtg4l6YoziD3M0MkctQvX1NdRxaQa5sm6RHH_jXc,315
 eva/core/data/samplers/classification/__init__.py,sha256=gvv7BH4lG9JlkMaTOnaL0f4k1ghiVBgrH64bh1-rreQ,147
-eva/core/data/samplers/classification/balanced.py,sha256=YE6InKu12Jnu7AObi_gjKLzeHAFlQsbJVrggeA8X4DU,3517
+eva/core/data/samplers/classification/balanced.py,sha256=MGTHt-WQaQKiJ5A1D_P6HJ6YzPTD-ERhc0R7rNMFqfg,3788
 eva/core/data/samplers/random.py,sha256=znl0Z9a-X-3attP-EH9jwwo83n40FXW_JzOLNZAml_c,1252
 eva/core/data/samplers/sampler.py,sha256=0DOLUzFoweqEubuO1A4bZBRU0AWFoWGWrO3pawRT-eI,877
 eva/core/data/splitting/__init__.py,sha256=VQJ8lfakbv6y2kAk3VDtITAvh7kcZo3H1JwJBc5jT08,198
@@ -55,6 +55,7 @@ eva/core/loggers/log/image.py,sha256=iUwntQCdRNLtkSdqu8CvV34l06zPYVo4NAW2gUeiJIM
 eva/core/loggers/log/parameters.py,sha256=7Xi-I5gQvEVv71d58bwdZ-Hb4287NXxaUyMfriq_KDU,1634
 eva/core/loggers/log/utils.py,sha256=k4Q7uKpAQctfDv0EEYPnPv6wt9LnckEeqGvbYSLfKO0,415
 eva/core/loggers/loggers.py,sha256=igHxdxJSotWSg6nEOKnfFuBszzblHgi8T7sBrE00FEs,166
+eva/core/loggers/utils/wandb.py,sha256=GdwzEeFTAng5kl_kIVRxKL7rvwqyicQHSaZS8VSMXvU,747
 eva/core/losses/__init__.py,sha256=D-Mp9fUFFFoH9YYWntVH3B839zHS3GjFJzkbQThzj6Y,118
 eva/core/losses/cross_entropy.py,sha256=Sunz7ogDAJpGvZtuk9cAxKZJBO08CKIEvbCoewEvees,862
 eva/core/metrics/__init__.py,sha256=-9Qch4npEQpy3oF6NUhh9WinCmFBFe0D2eEYCR0S0xU,558
@@ -72,7 +73,7 @@ eva/core/metrics/structs/schemas.py,sha256=ZaSrx0j_NfIwT7joMUD1LyrKdAXTLaeSzWYTH
 eva/core/metrics/structs/typings.py,sha256=qJd-FiD2IhJgBeo8FyP0vpVUIH4RKb1k6zYvHtjUA04,388
 eva/core/models/__init__.py,sha256=T6Fo886LxMj-Y58_ylzkPkFSnFR2aISiMIbuO_weC4s,430
 eva/core/models/modules/__init__.py,sha256=QJWJ42BceXZBzDGgk5FHBcCaRrB9egTFKVF6gDsBYfM,255
-eva/core/models/modules/head.py,sha256=Wza8IFAXFl_DwVnNqYKproI06iS-oIuUlGjRE6jAKXw,5185
+eva/core/models/modules/head.py,sha256=2rPlo2Osuq77gjrJmvQKCvNTaawvQRirK2CM2o24_xs,5184
 eva/core/models/modules/inference.py,sha256=ih-0Rr2oNf2N6maiXPOW7XH5KVwUT1_MOxnJKOhJ1uQ,978
 eva/core/models/modules/module.py,sha256=LtjYxTZb7UY0owonmt_yQ5EySw3sX-xD9HLN2io8EK4,6697
 eva/core/models/modules/typings.py,sha256=yFMJCE4Nrfd8VEXU1zk8p6Sz5M7UslwitYPVC2OPLSY,776
@@ -96,8 +97,8 @@ eva/core/trainers/__init__.py,sha256=jhsKJF7HAae7EOiG3gKIAHH_h3dZlTE2JRcCHJmOzJc
 eva/core/trainers/_logging.py,sha256=gi4FqPy2GuVmh0WZY6mYwF7zMPvnoFA050B0XdCP6PU,2571
 eva/core/trainers/_recorder.py,sha256=y6i5hfXftWjeV3eQHmMjUOkWumnZ2QNv_u275LLmvPA,7702
 eva/core/trainers/_utils.py,sha256=M3h8lVhUmkeSiEXpX9hRdMvThGFCnTP15gv-hd1CZkc,321
-eva/core/trainers/functional.py,sha256=7OK2BNfX4_amHsyucr1ZNQRG3RgVKoagzd1zNN4nU3U,4472
-eva/core/trainers/trainer.py,sha256=HJNSfTG0k4j2ShqZzuUUSxnSu8NrwJ4karhvAto2Zn0,4229
+eva/core/trainers/functional.py,sha256=rLtQZw8TcAa4NYIf901TmoQiJDNm4RGVLN-64nku3Jo,4445
+eva/core/trainers/trainer.py,sha256=a3OwLWOZKDqxayrd0ugUmxJKyQx6XDb4GHtdL8-AEV0,4826
 eva/core/utils/__init__.py,sha256=cndVBvtYxEW7hykH39GCNVI86zkXNn8Lw2A0sUJHS04,237
 eva/core/utils/clone.py,sha256=qcThZOuAs1cs0uV3BL5eKeM2VIBjuRPBe1t-NiUFM5Y,569
 eva/core/utils/io/__init__.py,sha256=Py03AmoxhmTHkro6CzNps27uXKkXPzdA18mG97xHhWI,172
@@ -116,17 +117,21 @@ eva/vision/callbacks/loggers/batch/__init__.py,sha256=DVYP7Aonbi4wg_ERHRj_8kb87E
 eva/vision/callbacks/loggers/batch/base.py,sha256=hcAd5iiHvjZ0DIf4Qt4ENT54D6ky_1OO4rKQZqeo-1k,3628
 eva/vision/callbacks/loggers/batch/segmentation.py,sha256=GYh2kfexW5pUZ0BdApYJI3e8xsuNkjIzkj5jnuKtHR4,6886
 eva/vision/data/__init__.py,sha256=aoKPmX8P2Q2k2W3nlq8vFU41FV6Sze-0SDuWtU-ETh4,111
-eva/vision/data/datasets/__init__.py,sha256=COhMRB9QJcjfbmfpRcYEztDwN9pl7IJNiH29pCZo4CA,908
+eva/vision/data/datasets/__init__.py,sha256=wvbkhBv_yS7hHMdMR-QpNHMkGoGzSL0L33XaXUwXTpM,1040
 eva/vision/data/datasets/_utils.py,sha256=epPcaYE4w2_LtUKLLQJh6qQxUNVBe22JA06k4WUerYQ,1430
 eva/vision/data/datasets/_validators.py,sha256=77WZj8ewsuxUjW5WegJ-7zDuR6WdF5JbaOYdywhKIK4,2594
-eva/vision/data/datasets/classification/__init__.py,sha256=T2eg8k3xxd_Pdbrr7TGYICSo7BVOTMOs1bL-rLnMmro,693
+eva/vision/data/datasets/classification/__init__.py,sha256=5fOGZxKGPeMCf3Jd9qAOYADPrkZnYg97_QE4DC79AMI,1074
 eva/vision/data/datasets/classification/bach.py,sha256=kZba1dQlJWZAmA03akJ4fVUU-y9W8ezOwlgs2zL-QrE,5432
 eva/vision/data/datasets/classification/base.py,sha256=Ci0HoOhOuHwICTi1TUGA1PwZe642RywolTVfMhKrFHk,2772
+eva/vision/data/datasets/classification/bracs.py,sha256=e9SqnQ_HVm9ypQiwsFi5tbngqs0yEZsfVBk3pt91W80,3347
+eva/vision/data/datasets/classification/breakhis.py,sha256=_rzGx5IgJSW73es7Gusr_oOzI1jHCPhRH8yRvqcmuqw,6905
 eva/vision/data/datasets/classification/camelyon16.py,sha256=sChvRo0jbOVUMJvfpsFxgFOsYgci3v9wjeMBEjUysJU,8287
 eva/vision/data/datasets/classification/crc.py,sha256=8qjz9OklLg1gAr46RKZdlClmlO9awwfp0dkTs8v5jTE,5670
+eva/vision/data/datasets/classification/gleason_arvaniti.py,sha256=CCXeBA3dlic7ZRiarf4_f76qkct8PMNM_tCfz3IRUPA,5893
 eva/vision/data/datasets/classification/mhist.py,sha256=xzShPncSfAV6Q5ojfimeq748MfA0n77fGWa9EpdRzYU,3055
 eva/vision/data/datasets/classification/panda.py,sha256=BU_gDoX3ZSDUugwaO2n0XSZhzseK1rkPoHMRoJLGL84,7303
 eva/vision/data/datasets/classification/patch_camelyon.py,sha256=fElKteZKx4M6AjylnhhgNH1jewHegWc1K8h4FFKp0gE,7171
+eva/vision/data/datasets/classification/unitopatho.py,sha256=vC-dFbhETfDD9paTeQ73Dg1vLPWsK12AfpiBFznESaM,5151
 eva/vision/data/datasets/classification/wsi.py,sha256=x3mQ8iwyiSdfQOjJuV7_cd8-LRjjhY9tjtzuD8O87Lg,4099
 eva/vision/data/datasets/segmentation/__init__.py,sha256=hGNr7BM_StxvmlOKWWfHp615qgsrB6BB3qMOiYhE0Og,791
 eva/vision/data/datasets/segmentation/_total_segmentator.py,sha256=DTaQaAisY7j1h0-zYk1_81Sr4b3D9PTMieYX0PMPtIc,3127
@@ -134,7 +139,7 @@ eva/vision/data/datasets/segmentation/_utils.py,sha256=ps1qpuEkPgvwUw6H-KKaLaYqD
 eva/vision/data/datasets/segmentation/base.py,sha256=11IMODMB7KJ8Bs5p7MyOsBXCyPFJXfYcDLAIMitUwEk,3023
 eva/vision/data/datasets/segmentation/bcss.py,sha256=NHjHd1tgIfIw6TxsZTGb63iMEwXFbWX_JAwRT5WVsj4,8274
 eva/vision/data/datasets/segmentation/consep.py,sha256=Pw3LvVIK2scj_ys7rVNRb9B8snP8HlDIAbaI3v6ObQk,6056
-eva/vision/data/datasets/segmentation/embeddings.py,sha256=0KaadzPxN6OrKNnFu3YsGBFkG6XqqvkOZYUhERPwL4A,1220
+eva/vision/data/datasets/segmentation/embeddings.py,sha256=RsTuAwGEJPnWPY7q3pwcjmqtEj0wtRBNRBD4a0RcGtA,1218
 eva/vision/data/datasets/segmentation/lits.py,sha256=cBRU5lkiTMAi_ZwyDQUN3ODyXUlLtuMWFLPDajcZnOo,7194
 eva/vision/data/datasets/segmentation/lits_balanced.py,sha256=s5kPfqB41Vkcm5Jh34mLAO0NweMSIlV2fMXJsRjJsF8,3384
 eva/vision/data/datasets/segmentation/monusac.py,sha256=OTWHAD1b48WeT6phVf466w_nJUOGdBCGKWiWw68PAdw,8423
@@ -194,7 +199,7 @@ eva/vision/models/networks/backbones/pathology/gigapath.py,sha256=mfGXtKhY7XLpKQ
 eva/vision/models/networks/backbones/pathology/histai.py,sha256=X_we3U7GK91RrXyOX2PJB-YFDF2ozdL2fzZhNxm9SVU,1914
 eva/vision/models/networks/backbones/pathology/kaiko.py,sha256=GSdBG4WXrs1PWB2hr-sy_dFe2riwpPKwHx71esDoVfE,3952
 eva/vision/models/networks/backbones/pathology/lunit.py,sha256=ku4lr9pWeeHatHN4x4OVgwlve9sVqiRqIbgI0PXLiqg,2160
-eva/vision/models/networks/backbones/pathology/mahmood.py,sha256=me8DXf9nsEegDmltP8f7ZnG89xYVEKzZLKfVzMZjWDs,1832
+eva/vision/models/networks/backbones/pathology/mahmood.py,sha256=VYoVWrMNkoaEqa0och-GbwGd0VISQmbtzk1dSBZ1M0I,2464
 eva/vision/models/networks/backbones/pathology/owkin.py,sha256=uWJV5fgY7UZX6ilgGzkPY9fnlOiF03W7E8rc9TmlHGg,1231
 eva/vision/models/networks/backbones/pathology/paige.py,sha256=MjOLgdEKk8tdAIpCiHelasGwPE7xgzaooW6EE7IsuEE,1642
 eva/vision/models/networks/backbones/registry.py,sha256=anjILtEHHB6Ltwiw22h1bsgWtIjh_l5_fkPh87K7-d0,1631
@@ -225,8 +230,8 @@ eva/vision/utils/io/image.py,sha256=IdOkr5MYqhYHz8U9drZ7wULTM3YHwCWSjZlu_Qdl4GQ,
 eva/vision/utils/io/mat.py,sha256=qpGifyjmpE0Xhv567Si7-zxKrgkgE0sywP70cHiLFGU,808
 eva/vision/utils/io/nifti.py,sha256=4YoKjKuoNdE0qY7tYB_WlnSsYAx2oBzZRZXczc_8HAU,2555
 eva/vision/utils/io/text.py,sha256=qYgfo_ZaDZWfG02NkVVYzo5QFySqdCCz5uLA9d-zXtI,701
-kaiko_eva-0.1.8.dist-info/METADATA,sha256=rjAETMOw3T9oYRqiWvzsedU0hFHFa6ivyZfiS0WCjKA,24899
-kaiko_eva-0.1.8.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-kaiko_eva-0.1.8.dist-info/entry_points.txt,sha256=6CSLu9bmQYJSXEg8gbOzRhxH0AGs75BB-vPm3VvfcNE,88
-kaiko_eva-0.1.8.dist-info/licenses/LICENSE,sha256=e6AEzr7j_R-PYr2qLO-JwLn8y70jbVD3U2mxbRmwcI4,11338
-kaiko_eva-0.1.8.dist-info/RECORD,,
+kaiko_eva-0.2.0.dist-info/METADATA,sha256=CTFbtAErERl1SU0--56Y5-d1tXrr1vBNtNVkaV3orrA,24899
+kaiko_eva-0.2.0.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+kaiko_eva-0.2.0.dist-info/entry_points.txt,sha256=6CSLu9bmQYJSXEg8gbOzRhxH0AGs75BB-vPm3VvfcNE,88
+kaiko_eva-0.2.0.dist-info/licenses/LICENSE,sha256=e6AEzr7j_R-PYr2qLO-JwLn8y70jbVD3U2mxbRmwcI4,11338
+kaiko_eva-0.2.0.dist-info/RECORD,,