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

eva/vision/models/networks/backbones/radiology/swin_unetr.py

@@ -0,0 +1,231 @@
+"""Encoder based on Swin UNETR."""
+
+from typing import List, Tuple
+
+import torch
+from monai.inferers.inferer import Inferer
+from monai.networks.blocks import unetr_block
+from monai.networks.nets import swin_unetr
+from monai.utils import misc
+from torch import nn
+
+from eva.vision.models.networks.backbones.registry import register_model
+
+
+@register_model("radiology/swin_unetr_encoder")
+class SwinUNETREncoder(nn.Module):
+    """Swin transformer encoder based on UNETR [0].
+
+    - [0] UNETR: Transformers for 3D Medical Image Segmentation
+      https://arxiv.org/pdf/2103.10504
+    """
+
+    def __init__(
+        self,
+        in_channels: int = 1,
+        feature_size: int = 48,
+        spatial_dims: int = 3,
+        out_indices: int | None = None,
+        inferer: Inferer | None = None,
+        use_v2: bool = True,
+    ) -> None:
+        """Build the UNETR encoder.
+
+        Args:
+            in_channels: Number of input channels.
+            feature_size: The dimension of network feature size.
+            spatial_dims: Number of spatial dimensions.
+            out_indices: Number of feature outputs. If None,
+                the aggregated feature vector is returned.
+            inferer: An optional MONAI `Inferer` for efficient
+                inference during evaluation.
+            use_v2: Whether to use SwinTransformerV2.
+        """
+        super().__init__()
+
+        self._in_channels = in_channels
+        self._feature_size = feature_size
+        self._spatial_dims = spatial_dims
+        self._out_indices = out_indices
+        self._inferer = inferer
+        self._use_v2 = use_v2
+
+        self._window_size = misc.ensure_tuple_rep(7, spatial_dims)
+        self._patch_size = misc.ensure_tuple_rep(2, spatial_dims)
+
+        self.swinViT = swin_unetr.SwinTransformer(
+            in_chans=in_channels,
+            embed_dim=feature_size,
+            window_size=self._window_size,
+            patch_size=self._patch_size,
+            depths=(2, 2, 2, 2),
+            num_heads=(3, 6, 12, 24),
+            mlp_ratio=4.0,
+            qkv_bias=True,
+            drop_rate=0.0,
+            attn_drop_rate=0.0,
+            drop_path_rate=0.0,
+            norm_layer=torch.nn.LayerNorm,
+            spatial_dims=spatial_dims,
+            use_v2=use_v2,
+        )
+        self.encoder1 = unetr_block.UnetrBasicBlock(
+            spatial_dims=spatial_dims,
+            in_channels=in_channels,
+            out_channels=feature_size,
+            kernel_size=3,
+            stride=1,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.encoder2 = unetr_block.UnetrBasicBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size,
+            out_channels=feature_size,
+            kernel_size=3,
+            stride=1,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.encoder3 = unetr_block.UnetrBasicBlock(
+            spatial_dims=spatial_dims,
+            in_channels=2 * feature_size,
+            out_channels=2 * feature_size,
+            kernel_size=3,
+            stride=1,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.encoder4 = unetr_block.UnetrBasicBlock(
+            spatial_dims=spatial_dims,
+            in_channels=4 * feature_size,
+            out_channels=4 * feature_size,
+            kernel_size=3,
+            stride=1,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.encoder10 = unetr_block.UnetrBasicBlock(
+            spatial_dims=spatial_dims,
+            in_channels=16 * feature_size,
+            out_channels=16 * feature_size,
+            kernel_size=3,
+            stride=1,
+            norm_name="instance",
+            res_block=True,
+        )
+        self._pool_op = (
+            nn.AdaptiveAvgPool3d(output_size=(1, 1, 1))
+            if spatial_dims == 3
+            else nn.AdaptiveAvgPool2d(output_size=(1, 1))
+        )
+
+    def _forward_features(self, tensor: torch.Tensor) -> List[torch.Tensor]:
+        """Extracts feature maps from the Swin Transformer and encoder blocks.
+
+        Args:
+            tensor: Input tensor of shape (B, C, T, H, W).
+
+        Returns:
+            List of feature maps from encoder stages.
+        """
+        hidden_states = self.swinViT(tensor)
+        enc0 = self.encoder1(tensor)
+        enc1 = self.encoder2(hidden_states[0])
+        enc2 = self.encoder3(hidden_states[1])
+        enc3 = self.encoder4(hidden_states[2])
+        dec4 = self.encoder10(hidden_states[4])
+        return [enc0, enc1, enc2, enc3, hidden_states[3], dec4]
+
+    def forward_features(self, tensor: torch.Tensor) -> List[torch.Tensor]:
+        """Computes feature maps using either standard forward pass or inference mode.
+
+        If in inference mode (`self.training` is False) and an inference method
+        (`self._inferer`) is available,  the `_inferer` is used to extract features.
+        Otherwise, `_forward_features` is called directly.
+
+        Args:
+            tensor: Input tensor of shape (B, C, T, H, W).
+
+        Returns:
+            List of feature maps from encoder stages.
+        """
+        if not self.training and self._inferer:
+            return self._inferer(inputs=tensor, network=self._forward_features)
+
+        return self._forward_features(tensor)
+
+    def forward_encoders(self, features: List[torch.Tensor]) -> torch.Tensor:
+        """Aggregates encoder features into a single feature vector.
+
+        Args:
+            features: List of feature maps from encoder stages.
+
+        Returns:
+            Aggregated feature vector (B, C').
+        """
+        batch_size = features[0].shape[0]
+        reduced_features = []
+        for patch_features in features[:4] + features[5:]:
+            hidden_features = self._pool_op(patch_features)
+            hidden_features_reduced = hidden_features.view(batch_size, -1)
+            reduced_features.append(hidden_features_reduced)
+        return torch.cat(reduced_features, dim=1)
+
+    def forward_head(self, features: List[torch.Tensor]) -> torch.Tensor:
+        """Casts last feature map into a single feature vector.
+
+        Args:
+            features: List of encoder feature maps.
+
+        Returns:
+            Aggregated feature vector (B, C').
+        """
+        last_feature_map = features[-1]
+        pooled_features = self._pool_op(last_feature_map)
+        return torch.flatten(pooled_features, 1)
+
+    def forward_embeddings(self, tensor: torch.Tensor) -> torch.Tensor:
+        """Computes the final aggregated feature vector.
+
+        Args:
+            tensor: Input tensor of shape (B, C, T, H, W).
+
+        Returns:
+            Aggregated feature vector of shape (B, C').
+        """
+        intermediates = self.forward_features(tensor)
+        return self.forward_encoders(intermediates)
+
+    def forward_intermediates(
+        self, tensor: torch.Tensor
+    ) -> Tuple[torch.Tensor, List[torch.Tensor]]:
+        """Computes encoder features and their embeddings.
+
+        Args:
+            tensor: Input tensor of shape (B, C, T, H, W).
+
+        Returns:
+            Aggregated feature vector and list of intermediate features.
+        """
+        features = self.forward_features(tensor)
+        embeddings = self.forward_encoders(features)
+        return embeddings, features
+
+    def forward(self, tensor: torch.Tensor) -> torch.Tensor | List[torch.Tensor]:
+        """Forward pass through the encoder.
+
+        If `self._out_indices` is None, it returns the aggregated feature vector.
+        Otherwise, it returns the intermediate feature maps up to the specified index.
+
+        Args:
+            tensor: Input tensor of shape (B, C, T, H, W).
+
+        Returns:
+            Aggregated feature vector or intermediate features.
+        """
+        if self._out_indices is None:
+            return self.forward_embeddings(tensor)
+
+        intermediates = self.forward_features(tensor)
+        return intermediates[-1 * self._out_indices :]

eva/vision/models/networks/backbones/radiology/voco.py

@@ -0,0 +1,75 @@
+"""VoCo Self-Supervised Encoders."""
+
+from typing_extensions import override
+
+from eva.core.models.wrappers import _utils
+from eva.vision.models.networks.backbones.radiology import swin_unetr
+from eva.vision.models.networks.backbones.registry import register_model
+
+
+class _VoCo(swin_unetr.SwinUNETREncoder):
+    """Base class for the VoCo self-supervised encoders."""
+
+    _checkpoint: str
+    """Path to the model state dict."""
+
+    _md5: str | None = None
+    """State dict MD5 validation code."""
+
+    def __init__(self, feature_size: int, out_indices: int | None = None) -> None:
+        """Initializes the model.
+
+        Args:
+            feature_size: Size of the last feature map of SwinUNETR.
+            out_indices: The number of feature maps from intermediate blocks
+                to be returned. If set to 1, only the last feature map is returned.
+        """
+        super().__init__(
+            in_channels=1,
+            feature_size=feature_size,
+            spatial_dims=3,
+            out_indices=out_indices,
+        )
+
+        self._load_checkpoint()
+
+    def _load_checkpoint(self) -> None:
+        """Loads the model checkpoint."""
+        state_dict = _utils.load_state_dict_from_url(self._checkpoint, md5=self._md5)
+        self.load_state_dict(state_dict)
+
+
+@register_model("radiology/voco_b")
+class VoCoB(_VoCo):
+    """VoCo Self-supervised pre-trained B model."""
+
+    _checkpoint = "https://huggingface.co/Luffy503/VoCo/resolve/main/VoCo_B_SSL_head.pt"
+    _md5 = "f80c4da2f81d700bdae3df188f2057eb"
+
+    @override
+    def __init__(self, out_indices: int | None = None) -> None:
+        super().__init__(feature_size=48, out_indices=out_indices)
+
+
+@register_model("radiology/voco_l")
+class VoCoL(_VoCo):
+    """VoCo Self-supervised pre-trained L model."""
+
+    _checkpoint = "https://huggingface.co/Luffy503/VoCo/resolve/main/VoCo_L_SSL_head.pt"
+    _md5 = "795095d1d43ef3808ec4c41798310136"
+
+    @override
+    def __init__(self, out_indices: int | None = None) -> None:
+        super().__init__(feature_size=96, out_indices=out_indices)
+
+
+@register_model("radiology/voco_h")
+class VoCoH(_VoCo):
+    """VoCo Self-supervised pre-trained H model."""
+
+    _checkpoint = "https://huggingface.co/Luffy503/VoCo/resolve/main/VoCo_H_SSL_head.pt"
+    _md5 = "76f95a474736b60bf5b8aad94643744d"
+
+    @override
+    def __init__(self, out_indices: int | None = None) -> None:
+        super().__init__(feature_size=192, out_indices=out_indices)

eva/vision/models/networks/decoders/segmentation/__init__.py

@@ -1,5 +1,6 @@
 """Segmentation decoder heads API."""
 
+from eva.vision.models.networks.decoders.segmentation.base import Decoder
 from eva.vision.models.networks.decoders.segmentation.decoder2d import Decoder2D
 from eva.vision.models.networks.decoders.segmentation.linear import LinearDecoder
 from eva.vision.models.networks.decoders.segmentation.semantic import (
@@ -7,13 +8,16 @@ from eva.vision.models.networks.decoders.segmentation.semantic import (
     ConvDecoderMS,
     ConvDecoderWithImage,
     SingleLinearDecoder,
+    SwinUNETRDecoder,
 )
 
 __all__ = [
+    "Decoder",
+    "Decoder2D",
     "ConvDecoder1x1",
     "ConvDecoderMS",
-    "SingleLinearDecoder",
     "ConvDecoderWithImage",
-    "Decoder2D",
     "LinearDecoder",
+    "SingleLinearDecoder",
+    "SwinUNETRDecoder",
 ]

eva/vision/models/networks/decoders/segmentation/linear.py

@@ -7,6 +7,7 @@ from torch import nn
 from torch.nn import functional
 
 from eva.vision.models.networks.decoders.segmentation import base
+from eva.vision.models.networks.decoders.segmentation.typings import DecoderInputs
 
 
 class LinearDecoder(base.Decoder):
@@ -104,22 +105,16 @@ class LinearDecoder(base.Decoder):
         """
         return functional.interpolate(logits, image_size, mode="bilinear")
 
-    def forward(
-        self,
-        features: List[torch.Tensor],
-        image_size: Tuple[int, int],
-    ) -> torch.Tensor:
+    def forward(self, decoder_inputs: DecoderInputs) -> torch.Tensor:
         """Maps the patch embeddings to a segmentation mask of the image size.
 
         Args:
-            features: List of multi-level image features of shape (batch_size,
-                hidden_size, n_patches_height, n_patches_width).
-            image_size: The target image size (height, width).
+            decoder_inputs: Inputs required by the decoder.
 
         Returns:
             Tensor containing scores for all of the classes with shape
             (batch_size, n_classes, image_height, image_width).
         """
-        patch_embeddings = self._forward_features(features)
+        patch_embeddings = self._forward_features(decoder_inputs.features)
         logits = self._forward_head(patch_embeddings)
-        return self._cls_seg(logits, image_size)
+        return self._cls_seg(logits, decoder_inputs.image_size)

eva/vision/models/networks/decoders/segmentation/semantic/__init__.py

@@ -5,8 +5,15 @@ from eva.vision.models.networks.decoders.segmentation.semantic.common import (
     ConvDecoderMS,
     SingleLinearDecoder,
 )
+from eva.vision.models.networks.decoders.segmentation.semantic.swin_unetr import SwinUNETRDecoder
 from eva.vision.models.networks.decoders.segmentation.semantic.with_image import (
     ConvDecoderWithImage,
 )
 
-__all__ = ["ConvDecoder1x1", "ConvDecoderMS", "SingleLinearDecoder", "ConvDecoderWithImage"]
+__all__ = [
+    "ConvDecoder1x1",
+    "ConvDecoderMS",
+    "ConvDecoderWithImage",
+    "SingleLinearDecoder",
+    "SwinUNETRDecoder",
+]

eva/vision/models/networks/decoders/segmentation/semantic/swin_unetr.py

@@ -0,0 +1,104 @@
+"""Decoder based on Swin UNETR."""
+
+from typing import List
+
+import torch
+from monai.networks.blocks import dynunet_block, unetr_block
+from torch import nn
+
+
+class SwinUNETRDecoder(nn.Module):
+    """Swin transformer decoder based on UNETR [0].
+
+    - [0] UNETR: Transformers for 3D Medical Image Segmentation
+      https://arxiv.org/pdf/2103.10504
+    """
+
+    def __init__(
+        self,
+        out_channels: int,
+        feature_size: int = 48,
+        spatial_dims: int = 3,
+    ) -> None:
+        """Builds the decoder.
+
+        Args:
+            out_channels: Number of output channels.
+            feature_size: Dimension of network feature size.
+            spatial_dims: Number of spatial dimensions.
+        """
+        super().__init__()
+
+        self.decoder5 = unetr_block.UnetrUpBlock(
+            spatial_dims=spatial_dims,
+            in_channels=16 * feature_size,
+            out_channels=8 * feature_size,
+            kernel_size=3,
+            upsample_kernel_size=2,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.decoder4 = unetr_block.UnetrUpBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size * 8,
+            out_channels=feature_size * 4,
+            kernel_size=3,
+            upsample_kernel_size=2,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.decoder3 = unetr_block.UnetrUpBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size * 4,
+            out_channels=feature_size * 2,
+            kernel_size=3,
+            upsample_kernel_size=2,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.decoder2 = unetr_block.UnetrUpBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size * 2,
+            out_channels=feature_size,
+            kernel_size=3,
+            upsample_kernel_size=2,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.decoder1 = unetr_block.UnetrUpBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size,
+            out_channels=feature_size,
+            kernel_size=3,
+            upsample_kernel_size=2,
+            norm_name="instance",
+            res_block=True,
+        )
+        self.out = dynunet_block.UnetOutBlock(
+            spatial_dims=spatial_dims,
+            in_channels=feature_size,
+            out_channels=out_channels,
+        )
+
+    def _forward_features(self, features: List[torch.Tensor]) -> torch.Tensor:
+        """Forward function for multi-level feature maps to a single one."""
+        enc0, enc1, enc2, enc3, hid3, dec4 = features
+        dec3 = self.decoder5(dec4, hid3)
+        dec2 = self.decoder4(dec3, enc3)
+        dec1 = self.decoder3(dec2, enc2)
+        dec0 = self.decoder2(dec1, enc1)
+        out = self.decoder1(dec0, enc0)
+        return self.out(out)
+
+    def forward(self, features: List[torch.Tensor]) -> torch.Tensor:
+        """Maps the patch embeddings to a segmentation mask.
+
+        Args:
+            features: List of multi-level intermediate features from
+                :class:`SwinUNETREncoder`.
+
+        Returns:
+            Tensor containing scores for all of the classes with shape
+            (batch_size, n_classes, image_height, image_width).
+        """
+        return self._forward_features(features)

eva/vision/utils/io/__init__.py

@@ -5,6 +5,7 @@ from eva.vision.utils.io.mat import read_mat, save_mat
 from eva.vision.utils.io.nifti import (
     fetch_nifti_axis_direction_code,
     fetch_nifti_shape,
+    nifti_to_array,
     read_nifti,
     save_array_as_nifti,
 )
@@ -16,6 +17,7 @@ __all__ = [
     "read_image_as_tensor",
     "fetch_nifti_shape",
     "fetch_nifti_axis_direction_code",
+    "nifti_to_array",
     "read_nifti",
     "save_array_as_nifti",
     "read_csv",

eva/vision/utils/io/nifti.py

@@ -1,3 +1,4 @@
+# type: ignore
 """NIfTI I/O related functions."""
 
 from typing import Any, Tuple
@@ -7,36 +8,63 @@ import numpy as np
 import numpy.typing as npt
 from nibabel import orientations
 
+from eva.core.utils.suppress_logs import SuppressLogs
 from eva.vision.utils.io import _utils
 
 
 def read_nifti(
-    path: str, slice_index: int | None = None, *, use_storage_dtype: bool = True
-) -> npt.NDArray[Any]:
+    path: str,
+    slice_index: int | None = None,
+    *,
+    orientation: str | None = None,
+    orientation_reference: str | None = None,
+) -> nib.nifti1.Nifti1Image:
     """Reads and loads a NIfTI image from a file path.
 
     Args:
         path: The path to the NIfTI file.
         slice_index: Whether to read only a slice from the file.
+        orientation: The orientation code to reorient the nifti image.
+        orientation_reference: Path to a NIfTI file which
+            will be used as a reference for the orientation
+            transform in case the file missing the pixdim array
+            in the NIfTI header.
         use_storage_dtype: Whether to cast the raw image
             array to the inferred type.
 
     Returns:
-        The image as a numpy array (height, width, channels).
+        The NIfTI image class instance.
 
     Raises:
         FileExistsError: If the path does not exist or it is unreachable.
         ValueError: If the input channel is invalid for the image.
     """
     _utils.check_file(path)
-    image_data: nib.Nifti1Image = nib.load(path)  # type: ignore
+    image_data = _load_nifti_silently(path)
     if slice_index is not None:
         image_data = image_data.slicer[:, :, slice_index : slice_index + 1]
+    if orientation:
+        image_data = _reorient(
+            image_data, orientation=orientation, reference_file=orientation_reference
+        )
 
-    image_array = image_data.get_fdata()
-    if use_storage_dtype:
-        image_array = image_array.astype(image_data.get_data_dtype())
+    return image_data
+
+
+def nifti_to_array(nii: nib.Nifti1Image, use_storage_dtype: bool = True) -> npt.NDArray[Any]:
+    """Converts a NIfTI image to a numpy array.
+
+    Args:
+        nii: The input NIfTI image.
+        use_storage_dtype: Whether to cast the raw image
+            array to the inferred type.
 
+    Returns:
+        The image as a numpy array (height, width, channels).
+    """
+    image_array = nii.get_fdata()
+    if use_storage_dtype:
+        image_array = image_array.astype(nii.get_data_dtype())
     return image_array
 
 
@@ -53,7 +81,7 @@ def save_array_as_nifti(
         filename: The name to save the image like.
         dtype: The data type to save the image.
     """
-    nifti_image = nib.Nifti1Image(array, affine=np.eye(4), dtype=dtype)  # type: ignore
+    nifti_image = nib.Nifti1Image(array, affine=np.eye(4), dtype=dtype)
     nifti_image.to_filename(filename)
 
 
@@ -71,8 +99,22 @@ def fetch_nifti_shape(path: str) -> Tuple[int]:
         ValueError: If the input channel is invalid for the image.
     """
     _utils.check_file(path)
-    image = nib.load(path)  # type: ignore
-    return image.header.get_data_shape()  # type: ignore
+    nii = _load_nifti_silently(path)
+    return nii.header.get_data_shape()  # type: ignore
+
+
+def fetch_nifti_orientation(path: str) -> npt.NDArray[Any]:
+    """Fetches the NIfTI image orientation.
+
+    Args:
+        path: The path to the NIfTI file.
+
+    Returns:
+        The array orientation.
+    """
+    _utils.check_file(path)
+    nii = _load_nifti_silently(path)
+    return nib.io_orientation(nii.affine)
 
 
 def fetch_nifti_axis_direction_code(path: str) -> str:
@@ -85,5 +127,43 @@ def fetch_nifti_axis_direction_code(path: str) -> str:
         The axis direction codes as string (e.g. "LAS").
     """
     _utils.check_file(path)
-    image_data: nib.Nifti1Image = nib.load(path)  # type: ignore
+    image_data: nib.Nifti1Image = nib.load(path)
     return "".join(orientations.aff2axcodes(image_data.affine))
+
+
+def _load_nifti_silently(path: str) -> nib.Nifti1Image:
+    """Reads a NIfTI image in silent mode."""
+    with SuppressLogs():
+        return nib.load(path)
+    raise ValueError(f"Failed to load NIfTI file: {path}")
+
+
+def _reorient(
+    nii: nib.Nifti1Image,
+    /,
+    orientation: str | tuple[str, str, str] = "RAS",
+    reference_file: str | None = None,
+) -> nib.Nifti1Image:
+    """Reorients a NIfTI image to a specified orientation.
+
+    Args:
+        nii: The input NIfTI image.
+        orientation: Desired orientation expressed as a
+            three-character string (e.g., "RAS") or a tuple
+            (e.g., ("R", "A", "S")).
+        reference_file: Path to a reference NIfTI file whose
+            orientation should be used if the input image lacks
+            a valid affine transformation.
+
+    Returns:
+        The reoriented NIfTI image.
+    """
+    affine_matrix, _ = nii.get_qform(coded=True)
+    orig_ornt = (
+        fetch_nifti_orientation(reference_file)
+        if reference_file and affine_matrix is None
+        else nib.io_orientation(nii.affine)
+    )
+    targ_ornt = orientations.axcodes2ornt(orientation)
+    transform = orientations.ornt_transform(orig_ornt, targ_ornt)
+    return nii.as_reoriented(transform)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaiko-eva
-Version: 0.2.0
+Version: 0.2.1
 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>
@@ -241,6 +241,7 @@ Requires-Dist: scikit-image>=0.24.0; extra == "vision"
 Requires-Dist: imagesize>=1.4.1; extra == "vision"
 Requires-Dist: scipy>=1.14.0; extra == "vision"
 Requires-Dist: monai>=1.3.2; extra == "vision"
+Requires-Dist: einops>=0.8.1; extra == "vision"
 Provides-Extra: all
 Requires-Dist: h5py>=3.10.0; extra == "all"
 Requires-Dist: nibabel>=4.0.1; extra == "all"
@@ -253,6 +254,7 @@ Requires-Dist: scikit-image>=0.24.0; extra == "all"
 Requires-Dist: imagesize>=1.4.1; extra == "all"
 Requires-Dist: scipy>=1.14.0; extra == "all"
 Requires-Dist: monai>=1.3.2; extra == "all"
+Requires-Dist: einops>=0.8.1; extra == "all"
 Description-Content-Type: text/markdown
 
 <div align="center">