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

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

@@ -1,96 +0,0 @@
-"""Base for image classification datasets."""
-
-import abc
-from typing import Any, Callable, Dict, List, Tuple
-
-import torch
-from torchvision import tv_tensors
-from typing_extensions import override
-
-from eva.vision.data.datasets import vision
-
-
-class ImageClassification(vision.VisionDataset[Tuple[tv_tensors.Image, torch.Tensor]], abc.ABC):
-    """Image classification abstract dataset."""
-
-    def __init__(
-        self,
-        transforms: Callable | None = None,
-    ) -> None:
-        """Initializes the image classification dataset.
-
-        Args:
-            transforms: A function/transform which returns a transformed
-                version of the raw data samples.
-        """
-        super().__init__()
-
-        self._transforms = transforms
-
-    @property
-    def classes(self) -> List[str] | None:
-        """Returns the list with names of the dataset names."""
-
-    @property
-    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) -> Dict[str, Any] | None:
-        """Returns the dataset metadata.
-
-        Args:
-            index: The index of the data sample to return the metadata of.
-
-        Returns:
-            The sample metadata.
-        """
-
-    @abc.abstractmethod
-    def load_image(self, index: int) -> tv_tensors.Image:
-        """Returns the `index`'th image sample.
-
-        Args:
-            index: The index of the data sample to load.
-
-        Returns:
-            The image as a numpy array.
-        """
-
-    @abc.abstractmethod
-    def load_target(self, index: int) -> torch.Tensor:
-        """Returns the `index`'th target sample.
-
-        Args:
-            index: The index of the data sample to load.
-
-        Returns:
-            The sample target as an array.
-        """
-
-    @abc.abstractmethod
-    @override
-    def __len__(self) -> int:
-        raise NotImplementedError
-
-    @override
-    def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, torch.Tensor, Dict[str, Any]]:
-        image = self.load_image(index)
-        target = self.load_target(index)
-        image, target = self._apply_transforms(image, target)
-        return image, target, self.load_metadata(index) or {}
-
-    def _apply_transforms(
-        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:
-            image: The desired image.
-            target: The target of the image.
-
-        Returns:
-            A tuple with the image and the target transformed.
-        """
-        if self._transforms is not None:
-            image, target = self._transforms(image, target)
-        return image, target

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

@@ -1,96 +0,0 @@
-"""Base for image segmentation datasets."""
-
-import abc
-from typing import Any, Callable, Dict, List, Tuple
-
-from torchvision import tv_tensors
-from typing_extensions import override
-
-from eva.vision.data.datasets import vision
-
-
-class ImageSegmentation(vision.VisionDataset[Tuple[tv_tensors.Image, tv_tensors.Mask]], abc.ABC):
-    """Image segmentation abstract dataset."""
-
-    def __init__(self, transforms: Callable | None = None) -> None:
-        """Initializes the image segmentation base class.
-
-        Args:
-            transforms: A function/transforms that takes in an
-                image and a label and returns the transformed versions of both.
-        """
-        super().__init__()
-
-        self._transforms = transforms
-
-    @property
-    def classes(self) -> List[str] | None:
-        """Returns the list with names of the dataset names."""
-
-    @property
-    def class_to_idx(self) -> Dict[str, int] | None:
-        """Returns a mapping of the class name to its target index."""
-
-    @abc.abstractmethod
-    def load_image(self, index: int) -> tv_tensors.Image:
-        """Loads and returns the `index`'th image sample.
-
-        Args:
-            index: The index of the data sample to load.
-
-        Returns:
-            An image torchvision tensor (channels, height, width).
-        """
-
-    @abc.abstractmethod
-    def load_mask(self, index: int) -> tv_tensors.Mask:
-        """Returns the `index`'th target masks sample.
-
-        Args:
-            index: The index of the data sample target masks to load.
-
-        Returns:
-            The semantic mask as a (H x W) shaped tensor with integer
-            values which represent the pixel class id.
-        """
-
-    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
-    @override
-    def __len__(self) -> int:
-        raise NotImplementedError
-
-    @override
-    def __getitem__(self, index: int) -> Tuple[tv_tensors.Image, tv_tensors.Mask, Dict[str, Any]]:
-        image = self.load_image(index)
-        mask = self.load_mask(index)
-        metadata = self.load_metadata(index) or {}
-        image_tensor, mask_tensor = self._apply_transforms(image, mask)
-        return image_tensor, mask_tensor, metadata
-
-    def _apply_transforms(
-        self, image: tv_tensors.Image, mask: tv_tensors.Mask
-    ) -> Tuple[tv_tensors.Image, tv_tensors.Mask]:
-        """Applies the transforms to the provided data and returns them.
-
-        Args:
-            image: The desired image.
-            mask: The target segmentation mask.
-
-        Returns:
-            A tuple with the image and the masks transformed.
-        """
-        if self._transforms is not None:
-            image, mask = self._transforms(image, mask)
-
-        return image, mask

eva/vision/data/transforms/common/resize_and_clamp.py

@@ -1,51 +0,0 @@
-"""Specialized transforms for resizing, clamping and range normalizing."""
-
-from typing import Callable, Sequence, Tuple
-
-from torchvision.transforms import v2
-
-from eva.vision.data.transforms import normalization
-
-
-class ResizeAndClamp(v2.Compose):
-    """Resizes, crops, clamps and normalizes an input image."""
-
-    def __init__(
-        self,
-        size: int | Sequence[int] = 224,
-        clamp_range: Tuple[int, int] = (-1024, 1024),
-        mean: Sequence[float] = (0.0, 0.0, 0.0),
-        std: Sequence[float] = (1.0, 1.0, 1.0),
-    ) -> None:
-        """Initializes the transform object.
-
-        Args:
-            size: Desired output size of the crop. If size is an `int` instead
-                of sequence like (h, w), a square crop (size, size) is made.
-            clamp_range: The lower and upper bound to clamp the pixel values.
-            mean: Sequence of means for each image channel.
-            std: Sequence of standard deviations for each image channel.
-        """
-        self._size = size
-        self._clamp_range = clamp_range
-        self._mean = mean
-        self._std = std
-
-        super().__init__(transforms=self._build_transforms())
-
-    def _build_transforms(self) -> Sequence[Callable]:
-        """Builds and returns the list of transforms."""
-        transforms = [
-            v2.Resize(size=self._size),
-            v2.CenterCrop(size=self._size),
-            normalization.Clamp(out_range=self._clamp_range),
-            normalization.RescaleIntensity(
-                in_range=self._clamp_range,
-                out_range=(0.0, 1.0),
-            ),
-            v2.Normalize(
-                mean=self._mean,
-                std=self._std,
-            ),
-        ]
-        return transforms

eva/vision/data/transforms/normalization/__init__.py

@@ -1,6 +0,0 @@
-"""Normalization related transformations."""
-
-from eva.vision.data.transforms.normalization.clamp import Clamp
-from eva.vision.data.transforms.normalization.rescale_intensity import RescaleIntensity
-
-__all__ = ["Clamp", "RescaleIntensity"]

eva/vision/data/transforms/normalization/clamp.py

@@ -1,43 +0,0 @@
-"""Image clamp transform."""
-
-import functools
-from typing import Any, Dict, Tuple
-
-import torch
-import torchvision.transforms.v2 as torch_transforms
-from torchvision import tv_tensors
-from typing_extensions import override
-
-
-class Clamp(torch_transforms.Transform):
-    """Clamps all elements in input into a specific range."""
-
-    def __init__(self, out_range: Tuple[int, int]) -> None:
-        """Initializes the transform.
-
-        Args:
-            out_range: The lower and upper bound of the range to
-                be clamped to.
-        """
-        super().__init__()
-
-        self._out_range = out_range
-
-    @functools.singledispatchmethod
-    @override
-    def _transform(self, inpt: Any, params: Dict[str, Any]) -> Any:
-        return inpt
-
-    @_transform.register(torch.Tensor)
-    def _(self, inpt: torch.Tensor, params: Dict[str, Any]) -> Any:
-        return torch.clamp(inpt, min=self._out_range[0], max=self._out_range[1])
-
-    @_transform.register(tv_tensors.Image)
-    def _(self, inpt: tv_tensors.Image, params: Dict[str, Any]) -> Any:
-        inpt_clamp = torch.clamp(inpt, min=self._out_range[0], max=self._out_range[1])
-        return tv_tensors.wrap(inpt_clamp, like=inpt)
-
-    @_transform.register(tv_tensors.BoundingBoxes)
-    @_transform.register(tv_tensors.Mask)
-    def _(self, inpt: tv_tensors.BoundingBoxes | tv_tensors.Mask, params: Dict[str, Any]) -> Any:
-        return inpt

eva/vision/data/transforms/normalization/functional/__init__.py

@@ -1,5 +0,0 @@
-"""Functional normalization related transformations API."""
-
-from eva.vision.data.transforms.normalization.functional.rescale_intensity import rescale_intensity
-
-__all__ = ["rescale_intensity"]

eva/vision/data/transforms/normalization/functional/rescale_intensity.py

@@ -1,28 +0,0 @@
-"""Intensity level functions."""
-
-import sys
-from typing import Tuple
-
-import torch
-
-
-def rescale_intensity(
-    image: torch.Tensor,
-    in_range: Tuple[float, float] | None = None,
-    out_range: Tuple[float, float] = (0.0, 1.0),
-) -> torch.Tensor:
-    """Stretches or shrinks the image intensity levels.
-
-    Args:
-        image: The image tensor as float-type.
-        in_range: The input data range. If `None`, it will
-            fetch the min and max of the input image.
-        out_range: The desired intensity range of the output.
-
-    Returns:
-        The image tensor after stretching or shrinking its intensity levels.
-    """
-    imin, imax = in_range or (image.min(), image.max())
-    omin, omax = out_range
-    image_scaled = (image - imin) / (imax - imin + sys.float_info.epsilon)
-    return image_scaled * (omax - omin) + omin

eva/vision/data/transforms/normalization/rescale_intensity.py

@@ -1,53 +0,0 @@
-"""Intensity level scaling transform."""
-
-import functools
-from typing import Any, Dict, Tuple
-
-import torch
-import torchvision.transforms.v2 as torch_transforms
-from torchvision import tv_tensors
-from typing_extensions import override
-
-from eva.vision.data.transforms.normalization import functional
-
-
-class RescaleIntensity(torch_transforms.Transform):
-    """Stretches or shrinks the image intensity levels."""
-
-    def __init__(
-        self,
-        in_range: Tuple[float, float] | None = None,
-        out_range: Tuple[float, float] = (0.0, 1.0),
-    ) -> None:
-        """Initializes the transform.
-
-        Args:
-            in_range: The input data range. If `None`, it will
-                fetch the min and max of the input image.
-            out_range: The desired intensity range of the output.
-        """
-        super().__init__()
-
-        self._in_range = in_range
-        self._out_range = out_range
-
-    @functools.singledispatchmethod
-    @override
-    def _transform(self, inpt: Any, params: Dict[str, Any]) -> Any:
-        return inpt
-
-    @_transform.register(torch.Tensor)
-    def _(self, inpt: torch.Tensor, params: Dict[str, Any]) -> Any:
-        return functional.rescale_intensity(
-            inpt, in_range=self._in_range, out_range=self._out_range
-        )
-
-    @_transform.register(tv_tensors.Image)
-    def _(self, inpt: tv_tensors.Image, params: Dict[str, Any]) -> Any:
-        scaled_inpt = functional.rescale_intensity(inpt, out_range=self._out_range)
-        return tv_tensors.wrap(scaled_inpt, like=inpt)
-
-    @_transform.register(tv_tensors.BoundingBoxes)
-    @_transform.register(tv_tensors.Mask)
-    def _(self, inpt: tv_tensors.BoundingBoxes | tv_tensors.Mask, params: Dict[str, Any]) -> Any:
-        return inpt

eva/vision/metrics/segmentation/BUILD

@@ -1 +0,0 @@
-python_sources()

eva/vision/models/networks/backbones/torchhub/__init__.py

@@ -1,5 +0,0 @@
-"""torch.hub backbones API."""
-
-from eva.vision.models.networks.backbones.torchhub.backbones import torch_hub_model
-
-__all__ = ["torch_hub_model"]

eva/vision/models/networks/backbones/torchhub/backbones.py

@@ -1,61 +0,0 @@
-"""torch.hub backbones."""
-
-import functools
-from typing import Tuple
-
-import torch
-from loguru import logger
-from torch import nn
-
-from eva.core.models import wrappers
-from eva.vision.models.networks.backbones.registry import BackboneModelRegistry
-
-HUB_REPOS = ["facebookresearch/dinov2:main", "kaiko-ai/towards_large_pathology_fms"]
-"""List of torch.hub repositories for which to add the models to the registry."""
-
-
-def torch_hub_model(
-    model_name: str,
-    repo_or_dir: str,
-    checkpoint_path: str | None = None,
-    pretrained: bool = False,
-    out_indices: int | Tuple[int, ...] | None = None,
-    **kwargs,
-) -> nn.Module:
-    """Initializes any ViT model from torch.hub with weights from a specified checkpoint.
-
-    Args:
-        model_name: The name of the model to load.
-        repo_or_dir: The torch.hub repository or local directory to load the model from.
-        checkpoint_path: The path to the checkpoint file.
-        pretrained: If set to `True`, load pretrained model weights if available.
-        out_indices: Whether and which multi-level patch embeddings to return.
-        **kwargs: Additional arguments to pass to the model
-
-    Returns:
-        The VIT model instance.
-    """
-    logger.info(
-        f"Loading torch.hub model {model_name} from {repo_or_dir}"
-        + (f"using checkpoint {checkpoint_path}" if checkpoint_path else "")
-    )
-
-    return wrappers.TorchHubModel(
-        model_name=model_name,
-        repo_or_dir=repo_or_dir,
-        pretrained=pretrained,
-        checkpoint_path=checkpoint_path or "",
-        out_indices=out_indices,
-        model_kwargs=kwargs,
-    )
-
-
-BackboneModelRegistry._registry.update(
-    {
-        f"torchhub/{repo}:{model_name}": functools.partial(
-            torch_hub_model, model_name=model_name, repo_or_dir=repo
-        )
-        for repo in HUB_REPOS
-        for model_name in torch.hub.list(repo, verbose=False)
-    }
-)