| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| """ |
| A collection of dictionary-based wrappers around the "vanilla" transforms for model output tensors |
| defined in :py:class:`monai.transforms.utility.array`. |
| |
| Class names are ended with 'd' to denote dictionary-based transforms. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import warnings |
| from collections.abc import Callable, Hashable, Iterable, Mapping, Sequence |
| from copy import deepcopy |
| from typing import Any |
|
|
| import numpy as np |
| import torch |
|
|
| from monai import config |
| from monai.config.type_definitions import KeysCollection, NdarrayOrTensor, PathLike |
| from monai.data.csv_saver import CSVSaver |
| from monai.data.meta_tensor import MetaTensor |
| from monai.transforms.inverse import InvertibleTransform |
| from monai.transforms.post.array import ( |
| Activations, |
| AsDiscrete, |
| DistanceTransformEDT, |
| FillHoles, |
| KeepLargestConnectedComponent, |
| LabelFilter, |
| LabelToContour, |
| MeanEnsemble, |
| ProbNMS, |
| RemoveSmallObjects, |
| SobelGradients, |
| VoteEnsemble, |
| ) |
| from monai.transforms.transform import MapTransform |
| from monai.transforms.utility.array import ToTensor |
| from monai.transforms.utils import allow_missing_keys_mode, convert_applied_interp_mode |
| from monai.utils import PostFix, convert_to_tensor, ensure_tuple, ensure_tuple_rep |
|
|
| __all__ = [ |
| "ActivationsD", |
| "ActivationsDict", |
| "Activationsd", |
| "AsDiscreteD", |
| "AsDiscreteDict", |
| "AsDiscreted", |
| "Ensembled", |
| "EnsembleD", |
| "EnsembleDict", |
| "FillHolesD", |
| "FillHolesDict", |
| "FillHolesd", |
| "InvertD", |
| "InvertDict", |
| "Invertd", |
| "KeepLargestConnectedComponentD", |
| "KeepLargestConnectedComponentDict", |
| "KeepLargestConnectedComponentd", |
| "RemoveSmallObjectsD", |
| "RemoveSmallObjectsDict", |
| "RemoveSmallObjectsd", |
| "LabelFilterD", |
| "LabelFilterDict", |
| "LabelFilterd", |
| "LabelToContourD", |
| "LabelToContourDict", |
| "LabelToContourd", |
| "MeanEnsembleD", |
| "MeanEnsembleDict", |
| "MeanEnsembled", |
| "ProbNMSD", |
| "ProbNMSDict", |
| "ProbNMSd", |
| "SaveClassificationD", |
| "SaveClassificationDict", |
| "SaveClassificationd", |
| "SobelGradientsD", |
| "SobelGradientsDict", |
| "SobelGradientsd", |
| "VoteEnsembleD", |
| "VoteEnsembleDict", |
| "VoteEnsembled", |
| "DistanceTransformEDTd", |
| "DistanceTransformEDTD", |
| "DistanceTransformEDTDict", |
| ] |
|
|
| DEFAULT_POST_FIX = PostFix.meta() |
|
|
|
|
| class Activationsd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.AddActivations`. |
| Add activation layers to the input data specified by `keys`. |
| """ |
|
|
| backend = Activations.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| sigmoid: Sequence[bool] | bool = False, |
| softmax: Sequence[bool] | bool = False, |
| other: Sequence[Callable] | Callable | None = None, |
| allow_missing_keys: bool = False, |
| **kwargs, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to model output and label. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| sigmoid: whether to execute sigmoid function on model output before transform. |
| it also can be a sequence of bool, each element corresponds to a key in ``keys``. |
| softmax: whether to execute softmax function on model output before transform. |
| it also can be a sequence of bool, each element corresponds to a key in ``keys``. |
| other: callable function to execute other activation layers, |
| for example: `other = torch.tanh`. it also can be a sequence of Callable, each |
| element corresponds to a key in ``keys``. |
| allow_missing_keys: don't raise exception if key is missing. |
| kwargs: additional parameters to `torch.softmax` (used when ``softmax=True``). |
| Defaults to ``dim=0``, unrecognized parameters will be ignored. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.sigmoid = ensure_tuple_rep(sigmoid, len(self.keys)) |
| self.softmax = ensure_tuple_rep(softmax, len(self.keys)) |
| self.other = ensure_tuple_rep(other, len(self.keys)) |
| self.converter = Activations() |
| self.converter.kwargs = kwargs |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key, sigmoid, softmax, other in self.key_iterator(d, self.sigmoid, self.softmax, self.other): |
| d[key] = self.converter(d[key], sigmoid, softmax, other) |
| return d |
|
|
|
|
| class AsDiscreted(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.AsDiscrete`. |
| """ |
|
|
| backend = AsDiscrete.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| argmax: Sequence[bool] | bool = False, |
| to_onehot: Sequence[int | None] | int | None = None, |
| threshold: Sequence[float | None] | float | None = None, |
| rounding: Sequence[str | None] | str | None = None, |
| allow_missing_keys: bool = False, |
| **kwargs, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to model output and label. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| argmax: whether to execute argmax function on input data before transform. |
| it also can be a sequence of bool, each element corresponds to a key in ``keys``. |
| to_onehot: if not None, convert input data into the one-hot format with specified number of classes. |
| defaults to ``None``. it also can be a sequence, each element corresponds to a key in ``keys``. |
| threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold value. |
| defaults to ``None``. it also can be a sequence, each element corresponds to a key in ``keys``. |
| rounding: if not None, round the data according to the specified option, |
| available options: ["torchrounding"]. it also can be a sequence of str or None, |
| each element corresponds to a key in ``keys``. |
| allow_missing_keys: don't raise exception if key is missing. |
| kwargs: additional parameters to ``AsDiscrete``. |
| ``dim``, ``keepdim``, ``dtype`` are supported, unrecognized parameters will be ignored. |
| These default to ``0``, ``True``, ``torch.float`` respectively. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.argmax = ensure_tuple_rep(argmax, len(self.keys)) |
| self.to_onehot = [] |
| for flag in ensure_tuple_rep(to_onehot, len(self.keys)): |
| if isinstance(flag, bool): |
| raise ValueError("`to_onehot=True/False` is deprecated, please use `to_onehot=num_classes` instead.") |
| self.to_onehot.append(flag) |
|
|
| self.threshold = [] |
| for flag in ensure_tuple_rep(threshold, len(self.keys)): |
| if isinstance(flag, bool): |
| raise ValueError("`threshold_values=True/False` is deprecated, please use `threshold=value` instead.") |
| self.threshold.append(flag) |
|
|
| self.rounding = ensure_tuple_rep(rounding, len(self.keys)) |
| self.converter = AsDiscrete() |
| self.converter.kwargs = kwargs |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key, argmax, to_onehot, threshold, rounding in self.key_iterator( |
| d, self.argmax, self.to_onehot, self.threshold, self.rounding |
| ): |
| d[key] = self.converter(d[key], argmax, to_onehot, threshold, rounding) |
| return d |
|
|
|
|
| class KeepLargestConnectedComponentd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.KeepLargestConnectedComponent`. |
| """ |
|
|
| backend = KeepLargestConnectedComponent.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| applied_labels: Sequence[int] | int | None = None, |
| is_onehot: bool | None = None, |
| independent: bool = True, |
| connectivity: int | None = None, |
| num_components: int = 1, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be transformed. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| applied_labels: Labels for applying the connected component analysis on. |
| If given, voxels whose value is in this list will be analyzed. |
| If `None`, all non-zero values will be analyzed. |
| is_onehot: if `True`, treat the input data as OneHot format data, otherwise, not OneHot format data. |
| default to None, which treats multi-channel data as OneHot and single channel data as not OneHot. |
| independent: whether to treat ``applied_labels`` as a union of foreground labels. |
| If ``True``, the connected component analysis will be performed on each foreground label independently |
| and return the intersection of the largest components. |
| If ``False``, the analysis will be performed on the union of foreground labels. |
| default is `True`. |
| connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
| Accepted values are ranging from 1 to input.ndim. If ``None``, a full |
| connectivity of ``input.ndim`` is used. for more details: |
| https://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.label. |
| num_components: The number of largest components to preserve. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.converter = KeepLargestConnectedComponent( |
| applied_labels=applied_labels, |
| is_onehot=is_onehot, |
| independent=independent, |
| connectivity=connectivity, |
| num_components=num_components, |
| ) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.converter(d[key]) |
| return d |
|
|
|
|
| class RemoveSmallObjectsd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.RemoveSmallObjectsd`. |
| |
| Args: |
| min_size: objects smaller than this size (in number of voxels; or surface area/volume value |
| in whatever units your image is if by_measure is True) are removed. |
| connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
| Accepted values are ranging from 1 to input.ndim. If ``None``, a full |
| connectivity of ``input.ndim`` is used. For more details refer to linked scikit-image |
| documentation. |
| independent_channels: Whether or not to consider channels as independent. If true, then |
| conjoining islands from different labels will be removed if they are below the threshold. |
| If false, the overall size islands made from all non-background voxels will be used. |
| by_measure: Whether the specified min_size is in number of voxels. if this is True then min_size |
| represents a surface area or volume value of whatever units your image is in (mm^3, cm^2, etc.) |
| default is False. e.g. if min_size is 3, by_measure is True and the units of your data is mm, |
| objects smaller than 3mm^3 are removed. |
| pixdim: the pixdim of the input image. if a single number, this is used for all axes. |
| If a sequence of numbers, the length of the sequence must be equal to the image dimensions. |
| """ |
|
|
| backend = RemoveSmallObjects.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| min_size: int = 64, |
| connectivity: int = 1, |
| independent_channels: bool = True, |
| by_measure: bool = False, |
| pixdim: Sequence[float] | float | np.ndarray | None = None, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| super().__init__(keys, allow_missing_keys) |
| self.converter = RemoveSmallObjects(min_size, connectivity, independent_channels, by_measure, pixdim) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.converter(d[key]) |
| return d |
|
|
|
|
| class LabelFilterd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.LabelFilter`. |
| """ |
|
|
| backend = LabelFilter.backend |
|
|
| def __init__( |
| self, keys: KeysCollection, applied_labels: Sequence[int] | int, allow_missing_keys: bool = False |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be transformed. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| applied_labels: Label(s) to filter on. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.converter = LabelFilter(applied_labels) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.converter(d[key]) |
| return d |
|
|
|
|
| class FillHolesd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.FillHoles`. |
| """ |
|
|
| backend = FillHoles.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| applied_labels: Iterable[int] | int | None = None, |
| connectivity: int | None = None, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| """ |
| Initialize the connectivity and limit the labels for which holes are filled. |
| |
| Args: |
| keys: keys of the corresponding items to be transformed. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| applied_labels (Optional[Union[Iterable[int], int]], optional): Labels for which to fill holes. Defaults to None, |
| that is filling holes for all labels. |
| connectivity (int, optional): Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
| Accepted values are ranging from 1 to input.ndim. Defaults to a full |
| connectivity of ``input.ndim``. |
| allow_missing_keys: don't raise exception if key is missing. |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.converter = FillHoles(applied_labels=applied_labels, connectivity=connectivity) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.converter(d[key]) |
| return d |
|
|
|
|
| class LabelToContourd(MapTransform): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.LabelToContour`. |
| """ |
|
|
| backend = LabelToContour.backend |
|
|
| def __init__(self, keys: KeysCollection, kernel_type: str = "Laplace", allow_missing_keys: bool = False) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be transformed. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| kernel_type: the method applied to do edge detection, default is "Laplace". |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| self.converter = LabelToContour(kernel_type=kernel_type) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.converter(d[key]) |
| return d |
|
|
|
|
| class Ensembled(MapTransform): |
| """ |
| Base class of dictionary-based ensemble transforms. |
| |
| """ |
|
|
| backend = list(set(VoteEnsemble.backend) & set(MeanEnsemble.backend)) |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| ensemble: Callable[[Sequence[NdarrayOrTensor] | NdarrayOrTensor], NdarrayOrTensor], |
| output_key: str | None = None, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be stack and execute ensemble. |
| if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. |
| output_key: the key to store ensemble result in the dictionary. |
| ensemble: callable method to execute ensemble on specified data. |
| if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| Raises: |
| TypeError: When ``ensemble`` is not ``callable``. |
| ValueError: When ``len(keys) > 1`` and ``output_key=None``. Incompatible values. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| if not callable(ensemble): |
| raise TypeError(f"ensemble must be callable but is {type(ensemble).__name__}.") |
| self.ensemble = ensemble |
| if len(self.keys) > 1 and output_key is None: |
| raise ValueError("Incompatible values: len(self.keys) > 1 and output_key=None.") |
| self.output_key = output_key if output_key is not None else self.keys[0] |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| items: list[NdarrayOrTensor] | NdarrayOrTensor |
| if len(self.keys) == 1 and self.keys[0] in d: |
| items = d[self.keys[0]] |
| else: |
| items = [d[key] for key in self.key_iterator(d)] |
|
|
| if len(items) > 0: |
| d[self.output_key] = self.ensemble(items) |
|
|
| return d |
|
|
|
|
| class MeanEnsembled(Ensembled): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.MeanEnsemble`. |
| """ |
|
|
| backend = MeanEnsemble.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| output_key: str | None = None, |
| weights: Sequence[float] | NdarrayOrTensor | None = None, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be stack and execute ensemble. |
| if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. |
| output_key: the key to store ensemble result in the dictionary. |
| if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. |
| weights: can be a list or tuple of numbers for input data with shape: [E, C, H, W[, D]]. |
| or a Numpy ndarray or a PyTorch Tensor data. |
| the `weights` will be added to input data from highest dimension, for example: |
| 1. if the `weights` only has 1 dimension, it will be added to the `E` dimension of input data. |
| 2. if the `weights` has 2 dimensions, it will be added to `E` and `C` dimensions. |
| it's a typical practice to add weights for different classes: |
| to ensemble 3 segmentation model outputs, every output has 4 channels(classes), |
| so the input data shape can be: [3, 4, H, W, D]. |
| and add different `weights` for different classes, so the `weights` shape can be: [3, 4]. |
| for example: `weights = [[1, 2, 3, 4], [4, 3, 2, 1], [1, 1, 1, 1]]`. |
| |
| """ |
| ensemble = MeanEnsemble(weights=weights) |
| super().__init__(keys, ensemble, output_key) |
|
|
|
|
| class VoteEnsembled(Ensembled): |
| """ |
| Dictionary-based wrapper of :py:class:`monai.transforms.VoteEnsemble`. |
| """ |
|
|
| backend = VoteEnsemble.backend |
|
|
| def __init__(self, keys: KeysCollection, output_key: str | None = None, num_classes: int | None = None) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to be stack and execute ensemble. |
| if only 1 key provided, suppose it's a PyTorch Tensor with data stacked on dimension `E`. |
| output_key: the key to store ensemble result in the dictionary. |
| if only 1 key provided in `keys`, `output_key` can be None and use `keys` as default. |
| num_classes: if the input is single channel data instead of One-Hot, we can't get class number |
| from channel, need to explicitly specify the number of classes to vote. |
| |
| """ |
| ensemble = VoteEnsemble(num_classes=num_classes) |
| super().__init__(keys, ensemble, output_key) |
|
|
|
|
| class ProbNMSd(MapTransform): |
| """ |
| Performs probability based non-maximum suppression (NMS) on the probabilities map via |
| iteratively selecting the coordinate with highest probability and then move it as well |
| as its surrounding values. The remove range is determined by the parameter `box_size`. |
| If multiple coordinates have the same highest probability, only one of them will be |
| selected. |
| |
| Args: |
| spatial_dims: number of spatial dimensions of the input probabilities map. |
| Defaults to 2. |
| sigma: the standard deviation for gaussian filter. |
| It could be a single value, or `spatial_dims` number of values. Defaults to 0.0. |
| prob_threshold: the probability threshold, the function will stop searching if |
| the highest probability is no larger than the threshold. The value should be |
| no less than 0.0. Defaults to 0.5. |
| box_size: the box size (in pixel) to be removed around the pixel with the maximum probability. |
| It can be an integer that defines the size of a square or cube, |
| or a list containing different values for each dimensions. Defaults to 48. |
| |
| Return: |
| a list of selected lists, where inner lists contain probability and coordinates. |
| For example, for 3D input, the inner lists are in the form of [probability, x, y, z]. |
| |
| Raises: |
| ValueError: When ``prob_threshold`` is less than 0.0. |
| ValueError: When ``box_size`` is a list or tuple, and its length is not equal to `spatial_dims`. |
| ValueError: When ``box_size`` has a less than 1 value. |
| |
| """ |
|
|
| backend = ProbNMS.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| spatial_dims: int = 2, |
| sigma: Sequence[float] | float | Sequence[torch.Tensor] | torch.Tensor = 0.0, |
| prob_threshold: float = 0.5, |
| box_size: int | Sequence[int] = 48, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| super().__init__(keys, allow_missing_keys) |
| self.prob_nms = ProbNMS( |
| spatial_dims=spatial_dims, sigma=sigma, prob_threshold=prob_threshold, box_size=box_size |
| ) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]): |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.prob_nms(d[key]) |
| return d |
|
|
|
|
| class Invertd(MapTransform): |
| """ |
| Utility transform to invert the previously applied transforms. |
| |
| Taking the ``transform`` previously applied on ``orig_keys``, this ``Invertd`` will apply the inverse of it |
| to the data stored at ``keys``. |
| |
| ``Invertd``'s output will also include a copy of the metadata |
| dictionary (originally from ``orig_meta_keys`` or the metadata of ``orig_keys``), |
| with the relevant fields inverted and stored at ``meta_keys``. |
| |
| A typical usage is to apply the inverse of the preprocessing (``transform=preprocessings``) on |
| input ``orig_keys=image`` to the model predictions ``keys=pred``. |
| |
| A detailed usage example is available in the tutorial: |
| https://github.com/Project-MONAI/tutorials/blob/master/3d_segmentation/torch/unet_inference_dict.py |
| |
| Note: |
| |
| - The output of the inverted data and metadata will be stored at ``keys`` and ``meta_keys`` respectively. |
| - To correctly invert the transforms, the information of the previously applied transforms should be |
| available at ``{orig_keys}_transforms``, and the original metadata at ``orig_meta_keys``. |
| (``meta_key_postfix`` is an optional string to conveniently construct "meta_keys" and/or "orig_meta_keys".) |
| see also: :py:class:`monai.transforms.TraceableTransform`. |
| - The transform will not change the content in ``orig_keys`` and ``orig_meta_key``. |
| These keys are only used to represent the data status of ``key`` before inverting. |
| |
| """ |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| transform: InvertibleTransform, |
| orig_keys: KeysCollection | None = None, |
| meta_keys: KeysCollection | None = None, |
| orig_meta_keys: KeysCollection | None = None, |
| meta_key_postfix: str = DEFAULT_POST_FIX, |
| nearest_interp: bool | Sequence[bool] = True, |
| to_tensor: bool | Sequence[bool] = True, |
| device: str | torch.device | Sequence[str | torch.device] | None = None, |
| post_func: Callable | Sequence[Callable] | None = None, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| """ |
| Args: |
| keys: the key of expected data in the dict, the inverse of ``transforms`` will be applied on it in-place. |
| It also can be a list of keys, will apply the inverse transform respectively. |
| transform: the transform applied to ``orig_key``, its inverse will be applied on ``key``. |
| orig_keys: the key of the original input data in the dict. These keys default to `self.keys` if not set. |
| the transform trace information of ``transforms`` should be stored at ``{orig_keys}_transforms``. |
| It can also be a list of keys, each matches the ``keys``. |
| meta_keys: The key to output the inverted metadata dictionary. |
| The metadata is a dictionary optionally containing: filename, original_shape. |
| It can be a sequence of strings, maps to ``keys``. |
| If None, will try to create a metadata dict with the default key: `{key}_{meta_key_postfix}`. |
| orig_meta_keys: the key of the metadata of original input data. |
| The metadata is a dictionary optionally containing: filename, original_shape. |
| It can be a sequence of strings, maps to the `keys`. |
| If None, will try to create a metadata dict with the default key: `{orig_key}_{meta_key_postfix}`. |
| This metadata dict will also be included in the inverted dict, stored in `meta_keys`. |
| meta_key_postfix: if `orig_meta_keys` is None, use `{orig_key}_{meta_key_postfix}` to fetch the |
| metadata from dict, if `meta_keys` is None, use `{key}_{meta_key_postfix}`. Default: ``"meta_dict"``. |
| nearest_interp: whether to use `nearest` interpolation mode when inverting the spatial transforms, |
| default to `True`. If `False`, use the same interpolation mode as the original transform. |
| It also can be a list of bool, each matches to the `keys` data. |
| to_tensor: whether to convert the inverted data into PyTorch Tensor first, default to `True`. |
| It also can be a list of bool, each matches to the `keys` data. |
| device: if converted to Tensor, move the inverted results to target device before `post_func`, |
| default to None, it also can be a list of string or `torch.device`, each matches to the `keys` data. |
| post_func: post processing for the inverted data, should be a callable function. |
| It also can be a list of callable, each matches to the `keys` data. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| if not isinstance(transform, InvertibleTransform): |
| raise ValueError("transform is not invertible, can't invert transform for the data.") |
| self.transform = transform |
| self.orig_keys = ensure_tuple_rep(orig_keys, len(self.keys)) if orig_keys is not None else self.keys |
| self.meta_keys = ensure_tuple_rep(None, len(self.keys)) if meta_keys is None else ensure_tuple(meta_keys) |
| if len(self.keys) != len(self.meta_keys): |
| raise ValueError("meta_keys should have the same length as keys.") |
| self.orig_meta_keys = ensure_tuple_rep(orig_meta_keys, len(self.keys)) |
| self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys)) |
| self.nearest_interp = ensure_tuple_rep(nearest_interp, len(self.keys)) |
| self.to_tensor = ensure_tuple_rep(to_tensor, len(self.keys)) |
| self.device = ensure_tuple_rep(device, len(self.keys)) |
| self.post_func = ensure_tuple_rep(post_func, len(self.keys)) |
| self._totensor = ToTensor() |
|
|
| def __call__(self, data: Mapping[Hashable, Any]) -> dict[Hashable, Any]: |
| d = dict(data) |
| for ( |
| key, |
| orig_key, |
| meta_key, |
| orig_meta_key, |
| meta_key_postfix, |
| nearest_interp, |
| to_tensor, |
| device, |
| post_func, |
| ) in self.key_iterator( |
| d, |
| self.orig_keys, |
| self.meta_keys, |
| self.orig_meta_keys, |
| self.meta_key_postfix, |
| self.nearest_interp, |
| self.to_tensor, |
| self.device, |
| self.post_func, |
| ): |
| if isinstance(d[key], MetaTensor): |
| if orig_key not in d: |
| warnings.warn(f"transform info of `{orig_key}` is not available in MetaTensor {key}.") |
| continue |
| else: |
| transform_key = InvertibleTransform.trace_key(orig_key) |
| if transform_key not in d: |
| warnings.warn(f"transform info of `{orig_key}` is not available or no InvertibleTransform applied.") |
| continue |
|
|
| orig_meta_key = orig_meta_key or f"{orig_key}_{meta_key_postfix}" |
| if orig_key in d and isinstance(d[orig_key], MetaTensor): |
| transform_info = d[orig_key].applied_operations |
| meta_info = d[orig_key].meta |
| else: |
| transform_info = d[InvertibleTransform.trace_key(orig_key)] |
| meta_info = d.get(orig_meta_key, {}) |
| if nearest_interp: |
| transform_info = convert_applied_interp_mode( |
| trans_info=transform_info, mode="nearest", align_corners=None |
| ) |
|
|
| inputs = d[key] |
| if isinstance(inputs, torch.Tensor): |
| inputs = inputs.detach() |
|
|
| if not isinstance(inputs, MetaTensor): |
| inputs = convert_to_tensor(inputs, track_meta=True) |
| inputs.applied_operations = deepcopy(transform_info) |
| inputs.meta = deepcopy(meta_info) |
|
|
| |
| input_dict = {orig_key: inputs} |
| if config.USE_META_DICT: |
| input_dict[InvertibleTransform.trace_key(orig_key)] = transform_info |
| input_dict[PostFix.meta(orig_key)] = meta_info |
| with allow_missing_keys_mode(self.transform): |
| inverted = self.transform.inverse(input_dict) |
|
|
| |
| inverted_data = inverted[orig_key] |
| if to_tensor and not isinstance(inverted_data, MetaTensor): |
| inverted_data = self._totensor(inverted_data) |
| if isinstance(inverted_data, np.ndarray) and device is not None and torch.device(device).type != "cpu": |
| raise ValueError(f"Inverted data with type of 'numpy.ndarray' support device='cpu', got {device}.") |
| if isinstance(inverted_data, torch.Tensor): |
| inverted_data = inverted_data.to(device=device) |
| d[key] = post_func(inverted_data) if callable(post_func) else inverted_data |
| |
| if InvertibleTransform.trace_key(orig_key) in d: |
| d[InvertibleTransform.trace_key(orig_key)] = inverted_data.applied_operations |
| |
| if orig_meta_key in d: |
| meta_key = meta_key or f"{key}_{meta_key_postfix}" |
| d[meta_key] = inverted.get(orig_meta_key) |
| return d |
|
|
|
|
| class SaveClassificationd(MapTransform): |
| """ |
| Save the classification results and metadata into CSV file or other storage. |
| |
| """ |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| meta_keys: KeysCollection | None = None, |
| meta_key_postfix: str = DEFAULT_POST_FIX, |
| saver: CSVSaver | None = None, |
| output_dir: PathLike = "./", |
| filename: str = "predictions.csv", |
| delimiter: str = ",", |
| overwrite: bool = True, |
| flush: bool = True, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| """ |
| Args: |
| keys: keys of the corresponding items to model output, this transform only supports 1 key. |
| See also: :py:class:`monai.transforms.compose.MapTransform` |
| meta_keys: explicitly indicate the key of the corresponding metadata dictionary. |
| for example, for data with key `image`, the metadata by default is in `image_meta_dict`. |
| the metadata is a dictionary object which contains: filename, original_shape, etc. |
| it can be a sequence of string, map to the `keys`. |
| if None, will try to construct meta_keys by `key_{meta_key_postfix}`. |
| will extract the filename of input image to save classification results. |
| meta_key_postfix: `key_{postfix}` was used to store the metadata in `LoadImaged`. |
| so need the key to extract the metadata of input image, like filename, etc. default is `meta_dict`. |
| for example, for data with key `image`, the metadata by default is in `image_meta_dict`. |
| the metadata is a dictionary object which contains: filename, original_shape, etc. |
| this arg only works when `meta_keys=None`. if no corresponding metadata, set to `None`. |
| saver: the saver instance to save classification results, if None, create a CSVSaver internally. |
| the saver must provide `save(data, meta_data)` and `finalize()` APIs. |
| output_dir: if `saver=None`, specify the directory to save the CSV file. |
| filename: if `saver=None`, specify the name of the saved CSV file. |
| delimiter: the delimiter character in the saved file, default to "," as the default output type is `csv`. |
| to be consistent with: https://docs.python.org/3/library/csv.html#csv.Dialect.delimiter. |
| overwrite: if `saver=None`, indicate whether to overwriting existing CSV file content, if True, |
| will clear the file before saving. otherwise, will append new content to the CSV file. |
| flush: if `saver=None`, indicate whether to write the cache data to CSV file immediately |
| in this transform and clear the cache. default to True. |
| If False, may need user to call `saver.finalize()` manually or use `ClassificationSaver` handler. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
| super().__init__(keys, allow_missing_keys) |
| if len(self.keys) != 1: |
| raise ValueError("only 1 key is allowed when saving the classification result.") |
| self.saver = saver or CSVSaver( |
| output_dir=output_dir, filename=filename, overwrite=overwrite, flush=flush, delimiter=delimiter |
| ) |
| self.flush = flush |
| self.meta_keys = ensure_tuple_rep(meta_keys, len(self.keys)) |
| self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys)) |
|
|
| def __call__(self, data): |
| d = dict(data) |
| for key, meta_key, meta_key_postfix in self.key_iterator(d, self.meta_keys, self.meta_key_postfix): |
| if meta_key is None and meta_key_postfix is not None: |
| meta_key = f"{key}_{meta_key_postfix}" |
| meta_data = d[meta_key] if meta_key is not None else None |
| self.saver.save(data=d[key], meta_data=meta_data) |
| if self.flush: |
| self.saver.finalize() |
|
|
| return d |
|
|
| def get_saver(self): |
| """ |
| If want to write content into file, may need to call `finalize` of saver when epoch completed. |
| Or users can also get the cache content from `saver` instead of writing into file. |
| |
| """ |
| return self.saver |
|
|
|
|
| class SobelGradientsd(MapTransform): |
| """Calculate Sobel horizontal and vertical gradients of a grayscale image. |
| |
| Args: |
| keys: keys of the corresponding items to model output. |
| kernel_size: the size of the Sobel kernel. Defaults to 3. |
| spatial_axes: the axes that define the direction of the gradient to be calculated. It calculate the gradient |
| along each of the provide axis. By default it calculate the gradient for all spatial axes. |
| normalize_kernels: if normalize the Sobel kernel to provide proper gradients. Defaults to True. |
| normalize_gradients: if normalize the output gradient to 0 and 1. Defaults to False. |
| padding_mode: the padding mode of the image when convolving with Sobel kernels. Defaults to `"reflect"`. |
| Acceptable values are ``'zeros'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. |
| See ``torch.nn.Conv1d()`` for more information. |
| dtype: kernel data type (torch.dtype). Defaults to `torch.float32`. |
| new_key_prefix: this prefix be prepended to the key to create a new key for the output and keep the value of |
| key intact. By default not prefix is set and the corresponding array to the key will be replaced. |
| allow_missing_keys: don't raise exception if key is missing. |
| |
| """ |
|
|
| backend = SobelGradients.backend |
|
|
| def __init__( |
| self, |
| keys: KeysCollection, |
| kernel_size: int = 3, |
| spatial_axes: Sequence[int] | int | None = None, |
| normalize_kernels: bool = True, |
| normalize_gradients: bool = False, |
| padding_mode: str = "reflect", |
| dtype: torch.dtype = torch.float32, |
| new_key_prefix: str | None = None, |
| allow_missing_keys: bool = False, |
| ) -> None: |
| super().__init__(keys, allow_missing_keys) |
| self.transform = SobelGradients( |
| kernel_size=kernel_size, |
| spatial_axes=spatial_axes, |
| normalize_kernels=normalize_kernels, |
| normalize_gradients=normalize_gradients, |
| padding_mode=padding_mode, |
| dtype=dtype, |
| ) |
| self.new_key_prefix = new_key_prefix |
| self.kernel_diff = self.transform.kernel_diff |
| self.kernel_smooth = self.transform.kernel_smooth |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> dict[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| new_key = key if self.new_key_prefix is None else self.new_key_prefix + key |
| d[new_key] = self.transform(d[key]) |
|
|
| return d |
|
|
|
|
| class DistanceTransformEDTd(MapTransform): |
| """ |
| Applies the Euclidean distance transform on the input. |
| Either GPU based with CuPy / cuCIM or CPU based with scipy. |
| To use the GPU implementation, make sure cuCIM is available and that the data is a `torch.tensor` on a GPU device. |
| |
| Note that the results of the libraries can differ, so stick to one if possible. |
| For details, check out the `SciPy`_ and `cuCIM`_ documentation and / or :func:`monai.transforms.utils.distance_transform_edt`. |
| |
| |
| Note on the input shape: |
| Has to be a channel first array, must have shape: (num_channels, H, W [,D]). |
| Can be of any type but will be converted into binary: 1 wherever image equates to True, 0 elsewhere. |
| Input gets passed channel-wise to the distance-transform, thus results from this function will differ |
| from directly calling ``distance_transform_edt()`` in CuPy or SciPy. |
| |
| Args: |
| keys: keys of the corresponding items to be transformed. |
| allow_missing_keys: don't raise exception if key is missing. |
| sampling: Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank -1; |
| if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied. |
| |
| .. _SciPy: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.distance_transform_edt.html |
| .. _cuCIM: https://docs.rapids.ai/api/cucim/nightly/api/#cucim.core.operations.morphology.distance_transform_edt |
| |
| |
| """ |
|
|
| backend = DistanceTransformEDT.backend |
|
|
| def __init__( |
| self, keys: KeysCollection, allow_missing_keys: bool = False, sampling: None | float | list[float] = None |
| ) -> None: |
| super().__init__(keys, allow_missing_keys) |
| self.sampling = sampling |
| self.distance_transform = DistanceTransformEDT(sampling=self.sampling) |
|
|
| def __call__(self, data: Mapping[Hashable, NdarrayOrTensor]) -> Mapping[Hashable, NdarrayOrTensor]: |
| d = dict(data) |
| for key in self.key_iterator(d): |
| d[key] = self.distance_transform(img=d[key]) |
|
|
| return d |
|
|
|
|
| ActivationsD = ActivationsDict = Activationsd |
| AsDiscreteD = AsDiscreteDict = AsDiscreted |
| FillHolesD = FillHolesDict = FillHolesd |
| InvertD = InvertDict = Invertd |
| KeepLargestConnectedComponentD = KeepLargestConnectedComponentDict = KeepLargestConnectedComponentd |
| RemoveSmallObjectsD = RemoveSmallObjectsDict = RemoveSmallObjectsd |
| LabelFilterD = LabelFilterDict = LabelFilterd |
| LabelToContourD = LabelToContourDict = LabelToContourd |
| MeanEnsembleD = MeanEnsembleDict = MeanEnsembled |
| ProbNMSD = ProbNMSDict = ProbNMSd |
| SaveClassificationD = SaveClassificationDict = SaveClassificationd |
| VoteEnsembleD = VoteEnsembleDict = VoteEnsembled |
| EnsembleD = EnsembleDict = Ensembled |
| SobelGradientsD = SobelGradientsDict = SobelGradientsd |
| DistanceTransformEDTD = DistanceTransformEDTDict = DistanceTransformEDTd |
|
|
