monai-weekly 1.5.dev2506__py3-none-any.whl → 1.5.dev2507__py3-none-any.whl

monai/__init__.py

@@ -136,4 +136,4 @@ except BaseException:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "8dcb9dc0e594059d87ce9882c20fe5a59340a6b2"
+__commit_id__ = "44add8d134f0cf0df6e4b0f5ffdd710474d211e5"

monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-02-09T02:26:31+0000",
+ "date": "2025-02-16T02:27:59+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "5d0616a0fd56273619eb40ed1e6a22683d697f60",
- "version": "1.5.dev2506"
+ "full-revisionid": "bbd080bb9d263c06a0884a871b645a434e3d4cdd",
+ "version": "1.5.dev2507"
 }
 '''  # END VERSION_JSON
 

monai/apps/auto3dseg/transforms.py

@@ -18,7 +18,6 @@ import numpy as np
 import torch
 
 from monai.config import KeysCollection
-from monai.networks.utils import pytorch_after
 from monai.transforms import MapTransform
 from monai.utils.misc import ImageMetaKey
 
@@ -74,9 +73,7 @@ class EnsureSameShaped(MapTransform):
                             f", the metadata was not updated {filename}."
                         )
                     d[key] = torch.nn.functional.interpolate(
-                        input=d[key].unsqueeze(0),
-                        size=image_shape,
-                        mode="nearest-exact" if pytorch_after(1, 11) else "nearest",
+                        input=d[key].unsqueeze(0), size=image_shape, mode="nearest-exact"
                     ).squeeze(0)
                 else:
                     raise ValueError(

monai/data/utils.py

@@ -50,7 +50,6 @@ from monai.utils import (
     issequenceiterable,
     look_up_option,
     optional_import,
-    pytorch_after,
 )
 
 pd, _ = optional_import("pandas")
@@ -450,12 +449,9 @@ def collate_meta_tensor_fn(batch, *, collate_fn_map=None):
     Collate a sequence of meta tensor into a single batched metatensor. This is called by `collage_meta_tensor`
     and so should not be used as a collate function directly in dataloaders.
     """
-    if pytorch_after(1, 13):
-        from torch.utils.data._utils.collate import collate_tensor_fn  # imported here for pylint/mypy issues
+    from torch.utils.data._utils.collate import collate_tensor_fn  # imported here for pylint/mypy issues
 
-        collated = collate_tensor_fn(batch)
-    else:
-        collated = default_collate(batch)
+    collated = collate_tensor_fn(batch)
 
     meta_dicts = [i.meta or TraceKeys.NONE for i in batch]
     common_ = set.intersection(*[set(d.keys()) for d in meta_dicts if isinstance(d, dict)])
@@ -494,18 +490,15 @@ def list_data_collate(batch: Sequence):
         Need to use this collate if apply some transforms that can generate batch data.
 
     """
+    from torch.utils.data._utils.collate import default_collate_fn_map
 
-    if pytorch_after(1, 13):
-        # needs to go here to avoid circular import
-        from torch.utils.data._utils.collate import default_collate_fn_map
-
-        from monai.data.meta_tensor import MetaTensor
+    from monai.data.meta_tensor import MetaTensor
 
-        default_collate_fn_map.update({MetaTensor: collate_meta_tensor_fn})
+    default_collate_fn_map.update({MetaTensor: collate_meta_tensor_fn})
     elem = batch[0]
     data = [i for k in batch for i in k] if isinstance(elem, list) else batch
     key = None
-    collate_fn = default_collate if pytorch_after(1, 13) else collate_meta_tensor
+    collate_fn = default_collate
     try:
         if config.USE_META_DICT:
             data = pickle_operations(data)  # bc 0.9.0

monai/inferers/utils.py

@@ -31,11 +31,10 @@ from monai.utils import (
     fall_back_tuple,
     look_up_option,
     optional_import,
-    pytorch_after,
 )
 
 tqdm, _ = optional_import("tqdm", name="tqdm")
-_nearest_mode = "nearest-exact" if pytorch_after(1, 11) else "nearest"
+_nearest_mode = "nearest-exact"
 
 __all__ = ["sliding_window_inference"]
 

monai/losses/dice.py

@@ -25,7 +25,7 @@ from monai.losses.focal_loss import FocalLoss
 from monai.losses.spatial_mask import MaskedLoss
 from monai.losses.utils import compute_tp_fp_fn
 from monai.networks import one_hot
-from monai.utils import DiceCEReduction, LossReduction, Weight, look_up_option, pytorch_after
+from monai.utils import DiceCEReduction, LossReduction, Weight, look_up_option
 
 
 class DiceLoss(_Loss):
@@ -738,12 +738,7 @@ class DiceCELoss(_Loss):
             batch=batch,
             weight=dice_weight,
         )
-        if pytorch_after(1, 10):
-            self.cross_entropy = nn.CrossEntropyLoss(
-                weight=weight, reduction=reduction, label_smoothing=label_smoothing
-            )
-        else:
-            self.cross_entropy = nn.CrossEntropyLoss(weight=weight, reduction=reduction)
+        self.cross_entropy = nn.CrossEntropyLoss(weight=weight, reduction=reduction, label_smoothing=label_smoothing)
         self.binary_cross_entropy = nn.BCEWithLogitsLoss(pos_weight=weight, reduction=reduction)
         if lambda_dice < 0.0:
             raise ValueError("lambda_dice should be no less than 0.0.")
@@ -751,7 +746,6 @@ class DiceCELoss(_Loss):
             raise ValueError("lambda_ce should be no less than 0.0.")
         self.lambda_dice = lambda_dice
         self.lambda_ce = lambda_ce
-        self.old_pt_ver = not pytorch_after(1, 10)
 
     def ce(self, input: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
         """
@@ -764,12 +758,6 @@ class DiceCELoss(_Loss):
         if n_pred_ch != n_target_ch and n_target_ch == 1:
             target = torch.squeeze(target, dim=1)
             target = target.long()
-        elif self.old_pt_ver:
-            warnings.warn(
-                f"Multichannel targets are not supported in this older Pytorch version {torch.__version__}. "
-                "Using argmax (as a workaround) to convert target to a single channel."
-            )
-            target = torch.argmax(target, dim=1)
         elif not torch.is_floating_point(target):
             target = target.to(dtype=input.dtype)
 

monai/losses/ds_loss.py

@@ -17,8 +17,6 @@ import torch
 import torch.nn.functional as F
 from torch.nn.modules.loss import _Loss
 
-from monai.utils import pytorch_after
-
 
 class DeepSupervisionLoss(_Loss):
     """
@@ -42,7 +40,7 @@ class DeepSupervisionLoss(_Loss):
         self.loss = loss
         self.weight_mode = weight_mode
         self.weights = weights
-        self.interp_mode = "nearest-exact" if pytorch_after(1, 11) else "nearest"
+        self.interp_mode = "nearest-exact"
 
     def get_weights(self, levels: int = 1) -> list[float]:
         """

monai/networks/layers/simplelayers.py

@@ -31,7 +31,6 @@ from monai.utils import (
     issequenceiterable,
     look_up_option,
     optional_import,
-    pytorch_after,
 )
 
 _C, _ = optional_import("monai._C")
@@ -293,14 +292,7 @@ def apply_filter(x: torch.Tensor, kernel: torch.Tensor, **kwargs) -> torch.Tenso
     x = x.view(1, kernel.shape[0], *spatials)
     conv = [F.conv1d, F.conv2d, F.conv3d][n_spatial - 1]
     if "padding" not in kwargs:
-        if pytorch_after(1, 10):
-            kwargs["padding"] = "same"
-        else:
-            # even-sized kernels are not supported
-            kwargs["padding"] = [(k - 1) // 2 for k in kernel.shape[2:]]
-    elif kwargs["padding"] == "same" and not pytorch_after(1, 10):
-        # even-sized kernels are not supported
-        kwargs["padding"] = [(k - 1) // 2 for k in kernel.shape[2:]]
+        kwargs["padding"] = "same"
 
     if "stride" not in kwargs:
         kwargs["stride"] = 1
@@ -372,11 +364,7 @@ class SavitzkyGolayFilter(nn.Module):
         a = idx ** torch.arange(order + 1, dtype=torch.float, device="cpu").reshape(-1, 1)
         y = torch.zeros(order + 1, dtype=torch.float, device="cpu")
         y[0] = 1.0
-        return (
-            torch.lstsq(y, a).solution.squeeze()  # type: ignore
-            if not pytorch_after(1, 11)
-            else torch.linalg.lstsq(a, y).solution.squeeze()
-        )
+        return torch.linalg.lstsq(a, y).solution.squeeze()
 
 
 class HilbertTransform(nn.Module):

monai/networks/utils.py

@@ -31,7 +31,7 @@ import torch.nn as nn
 from monai.apps.utils import get_logger
 from monai.config import PathLike
 from monai.utils.misc import ensure_tuple, save_obj, set_determinism
-from monai.utils.module import look_up_option, optional_import, pytorch_after
+from monai.utils.module import look_up_option, optional_import
 from monai.utils.type_conversion import convert_to_dst_type, convert_to_tensor
 
 onnx, _ = optional_import("onnx")
@@ -676,15 +676,6 @@ def convert_to_onnx(
                 torch_versioned_kwargs["verify"] = verify
                 verify = False
         else:
-            if not pytorch_after(1, 10):
-                if "example_outputs" not in kwargs:
-                    # https://github.com/pytorch/pytorch/blob/release/1.9/torch/onnx/__init__.py#L182
-                    raise TypeError(
-                        "example_outputs is required in scripting mode before PyTorch 1.10."
-                        "Please provide example outputs or use trace mode to export onnx model."
-                    )
-                torch_versioned_kwargs["example_outputs"] = kwargs["example_outputs"]
-                del kwargs["example_outputs"]
             mode_to_export = torch.jit.script(model, **kwargs)
 
         if torch.is_tensor(inputs) or isinstance(inputs, dict):
@@ -746,8 +737,7 @@ def convert_to_onnx(
         # compare onnx/ort and PyTorch results
         for r1, r2 in zip(torch_out, onnx_out):
             if isinstance(r1, torch.Tensor):
-                assert_fn = torch.testing.assert_close if pytorch_after(1, 11) else torch.testing.assert_allclose
-                assert_fn(r1.cpu(), convert_to_tensor(r2, dtype=r1.dtype), rtol=rtol, atol=atol)  # type: ignore
+                torch.testing.assert_close(r1.cpu(), convert_to_tensor(r2, dtype=r1.dtype), rtol=rtol, atol=atol)  # type: ignore
 
     return onnx_model
 
@@ -817,8 +807,7 @@ def convert_to_torchscript(
         # compare TorchScript and PyTorch results
         for r1, r2 in zip(torch_out, torchscript_out):
             if isinstance(r1, torch.Tensor) or isinstance(r2, torch.Tensor):
-                assert_fn = torch.testing.assert_close if pytorch_after(1, 11) else torch.testing.assert_allclose
-                assert_fn(r1, r2, rtol=rtol, atol=atol)  # type: ignore
+                torch.testing.assert_close(r1, r2, rtol=rtol, atol=atol)  # type: ignore
 
     return script_module
 
@@ -1031,8 +1020,7 @@ def convert_to_trt(
         # compare TorchScript and PyTorch results
         for r1, r2 in zip(torch_out, trt_out):
             if isinstance(r1, torch.Tensor) or isinstance(r2, torch.Tensor):
-                assert_fn = torch.testing.assert_close if pytorch_after(1, 11) else torch.testing.assert_allclose
-                assert_fn(r1, r2, rtol=rtol, atol=atol)  # type: ignore
+                torch.testing.assert_close(r1, r2, rtol=rtol, atol=atol)  # type: ignore
 
     return trt_model
 

monai/transforms/compose.py

@@ -47,7 +47,7 @@ __all__ = ["Compose", "OneOf", "RandomOrder", "SomeOf", "execute_compose"]
 def execute_compose(
     data: NdarrayOrTensor | Sequence[NdarrayOrTensor] | Mapping[Any, NdarrayOrTensor],
     transforms: Sequence[Any],
-    map_items: bool = True,
+    map_items: bool | int = True,
     unpack_items: bool = False,
     start: int = 0,
     end: int | None = None,
@@ -65,8 +65,13 @@ def execute_compose(
     Args:
         data: a tensor-like object to be transformed
         transforms: a sequence of transforms to be carried out
-        map_items: whether to apply transform to each item in the input `data` if `data` is a list or tuple.
-            defaults to `True`.
+        map_items: controls whether to apply a transformation to each item in `data`. If `data` is a list or tuple,
+            it can behave as follows:
+            - Defaults to True, which is equivalent to `map_items=1`, meaning the transformation will be applied
+              to the first level of items in `data`.
+            - If an integer is provided, it specifies the maximum level of nesting to which the transformation
+              should be recursively applied. This allows treating multi-sample transforms applied after another
+              multi-sample transform while controlling how deep the mapping goes.
         unpack_items: whether to unpack input `data` with `*` as parameters for the callable function of transform.
             defaults to `False`.
         start: the index of the first transform to be executed. If not set, this defaults to 0
@@ -205,8 +210,14 @@ class Compose(Randomizable, InvertibleTransform, LazyTransform):
 
     Args:
         transforms: sequence of callables.
-        map_items: whether to apply transform to each item in the input `data` if `data` is a list or tuple.
-            defaults to `True`.
+        map_items: controls whether to apply a transformation to each item in `data`. If `data` is a list or tuple,
+            it can behave as follows:
+
+                - Defaults to True, which is equivalent to `map_items=1`, meaning the transformation will be applied
+                  to the first level of items in `data`.
+                - If an integer is provided, it specifies the maximum level of nesting to which the transformation
+                  should be recursively applied. This allows treating multi-sample transforms applied after another
+                  multi-sample transform while controlling how deep the mapping goes.
         unpack_items: whether to unpack input `data` with `*` as parameters for the callable function of transform.
             defaults to `False`.
         log_stats: this optional parameter allows you to specify a logger by name for logging of pipeline execution.
@@ -227,7 +238,7 @@ class Compose(Randomizable, InvertibleTransform, LazyTransform):
     def __init__(
         self,
         transforms: Sequence[Callable] | Callable | None = None,
-        map_items: bool = True,
+        map_items: bool | int = True,
         unpack_items: bool = False,
         log_stats: bool | str = False,
         lazy: bool | None = False,
@@ -238,9 +249,9 @@ class Compose(Randomizable, InvertibleTransform, LazyTransform):
         if transforms is None:
             transforms = []
 
-        if not isinstance(map_items, bool):
+        if not isinstance(map_items, (bool, int)):
             raise ValueError(
-                f"Argument 'map_items' should be boolean. Got {type(map_items)}."
+                f"Argument 'map_items' should be boolean or int. Got {type(map_items)}."
                 "Check brackets when passing a sequence of callables."
             )
 
@@ -391,8 +402,14 @@ class OneOf(Compose):
         transforms: sequence of callables.
         weights: probabilities corresponding to each callable in transforms.
             Probabilities are normalized to sum to one.
-        map_items: whether to apply transform to each item in the input `data` if `data` is a list or tuple.
-            defaults to `True`.
+        map_items: controls whether to apply a transformation to each item in `data`. If `data` is a list or tuple,
+            it can behave as follows:
+
+                - Defaults to True, which is equivalent to `map_items=1`, meaning the transformation will be applied
+                  to the first level of items in `data`.
+                - If an integer is provided, it specifies the maximum level of nesting to which the transformation
+                  should be recursively applied. This allows treating multi-sample transforms applied after another
+                  multi-sample transform while controlling how deep the mapping goes.
         unpack_items: whether to unpack input `data` with `*` as parameters for the callable function of transform.
             defaults to `False`.
         log_stats: this optional parameter allows you to specify a logger by name for logging of pipeline execution.
@@ -414,7 +431,7 @@ class OneOf(Compose):
         self,
         transforms: Sequence[Callable] | Callable | None = None,
         weights: Sequence[float] | float | None = None,
-        map_items: bool = True,
+        map_items: bool | int = True,
         unpack_items: bool = False,
         log_stats: bool | str = False,
         lazy: bool | None = False,

monai/transforms/croppad/array.py

@@ -56,7 +56,6 @@ from monai.utils import (
     ensure_tuple_rep,
     fall_back_tuple,
     look_up_option,
-    pytorch_after,
 )
 
 __all__ = [
@@ -392,11 +391,7 @@ class Crop(InvertibleTransform, LazyTransform):
                 roi_center_t = convert_to_tensor(data=roi_center, dtype=torch.int16, wrap_sequence=True, device="cpu")
                 roi_size_t = convert_to_tensor(data=roi_size, dtype=torch.int16, wrap_sequence=True, device="cpu")
                 _zeros = torch.zeros_like(roi_center_t)
-                half = (
-                    torch.divide(roi_size_t, 2, rounding_mode="floor")
-                    if pytorch_after(1, 8)
-                    else torch.floor_divide(roi_size_t, 2)
-                )
+                half = torch.divide(roi_size_t, 2, rounding_mode="floor")
                 roi_start_t = torch.maximum(roi_center_t - half, _zeros)
                 roi_end_t = torch.maximum(roi_start_t + roi_size_t, roi_start_t)
             else:

monai/transforms/io/array.py

@@ -11,7 +11,6 @@
 """
 A collection of "vanilla" transforms for IO functions.
 """
-
 from __future__ import annotations
 
 import inspect

monai/transforms/transform.py

@@ -101,12 +101,12 @@ def _apply_transform(
 def apply_transform(
     transform: Callable[..., ReturnType],
     data: Any,
-    map_items: bool = True,
+    map_items: bool | int = True,
     unpack_items: bool = False,
     log_stats: bool | str = False,
     lazy: bool | None = None,
     overrides: dict | None = None,
-) -> list[ReturnType] | ReturnType:
+) -> list[Any] | ReturnType:
     """
     Transform `data` with `transform`.
 
@@ -117,8 +117,13 @@ def apply_transform(
     Args:
         transform: a callable to be used to transform `data`.
         data: an object to be transformed.
-        map_items: whether to apply transform to each item in `data`,
-            if `data` is a list or tuple. Defaults to True.
+        map_items: controls whether to apply a transformation to each item in `data`. If `data` is a list or tuple,
+            it can behave as follows:
+            - Defaults to True, which is equivalent to `map_items=1`, meaning the transformation will be applied
+              to the first level of items in `data`.
+            - If an integer is provided, it specifies the maximum level of nesting to which the transformation
+              should be recursively applied. This allows treating multi-sample transforms applied after another
+              multi-sample transform while controlling how deep the mapping goes.
         unpack_items: whether to unpack parameters using `*`. Defaults to False.
         log_stats: log errors when they occur in the processing pipeline. By default, this is set to False, which
             disables the logger for processing pipeline errors. Setting it to None or True will enable logging to the
@@ -136,8 +141,12 @@ def apply_transform(
         Union[List[ReturnType], ReturnType]: The return type of `transform` or a list thereof.
     """
     try:
-        if isinstance(data, (list, tuple)) and map_items:
-            return [_apply_transform(transform, item, unpack_items, lazy, overrides, log_stats) for item in data]
+        map_items_ = int(map_items) if isinstance(map_items, bool) else map_items
+        if isinstance(data, (list, tuple)) and map_items_ > 0:
+            return [
+                apply_transform(transform, item, map_items_ - 1, unpack_items, log_stats, lazy, overrides)
+                for item in data
+            ]
         return _apply_transform(transform, data, unpack_items, lazy, overrides, log_stats)
     except Exception as e:
         # if in debug mode, don't swallow exception so that the breakpoint

monai/transforms/utils.py

@@ -68,7 +68,6 @@ from monai.utils import (
     look_up_option,
     min_version,
     optional_import,
-    pytorch_after,
     unsqueeze_left,
     unsqueeze_right,
 )
@@ -2255,7 +2254,7 @@ def _to_torch_resample_interp_mode(interp_mode):
     if ret is not None:
         return ret
     _mapping = {
-        SplineMode.ZERO: InterpolateMode.NEAREST_EXACT if pytorch_after(1, 11) else InterpolateMode.NEAREST,
+        SplineMode.ZERO: InterpolateMode.NEAREST_EXACT,
         SplineMode.ONE: InterpolateMode.LINEAR,
         SplineMode.THREE: InterpolateMode.BICUBIC,
     }

monai/utils/tf32.py

@@ -60,16 +60,6 @@ def detect_default_tf32() -> bool:
         if not has_ampere_or_later():
             return False
 
-        from monai.utils.module import pytorch_after
-
-        if pytorch_after(1, 7, 0) and not pytorch_after(1, 12, 0):
-            warnings.warn(
-                "torch.backends.cuda.matmul.allow_tf32 = True by default.\n"
-                "  This value defaults to True when PyTorch version in [1.7, 1.11] and may affect precision.\n"
-                "  See https://docs.monai.io/en/latest/precision_accelerating.html#precision-and-accelerating"
-            )
-            may_enable_tf32 = True
-
         override_tf32_env_vars = {"NVIDIA_TF32_OVERRIDE": "1"}  # TORCH_ALLOW_TF32_CUBLAS_OVERRIDE not checked #6907
         for name, override_val in override_tf32_env_vars.items():
             if os.environ.get(name) == override_val:

monai/visualize/class_activation_maps.py

@@ -22,7 +22,7 @@ import torch.nn.functional as F
 
 from monai.config import NdarrayTensor
 from monai.transforms import ScaleIntensity
-from monai.utils import ensure_tuple, pytorch_after
+from monai.utils import ensure_tuple
 from monai.visualize.visualizer import default_upsampler
 
 __all__ = ["CAM", "GradCAM", "GradCAMpp", "ModelWithHooks", "default_normalizer"]
@@ -83,13 +83,10 @@ class ModelWithHooks:
                 continue
             _registered.append(name)
             if self.register_backward:
-                if pytorch_after(1, 8):
-                    if "inplace" in mod.__dict__ and mod.__dict__["inplace"]:
-                        # inplace=True causes errors for register_full_backward_hook
-                        mod.__dict__["inplace"] = False
-                    mod.register_full_backward_hook(self.backward_hook(name))
-                else:
-                    mod.register_backward_hook(self.backward_hook(name))
+                if "inplace" in mod.__dict__ and mod.__dict__["inplace"]:
+                    # inplace=True causes errors for register_full_backward_hook
+                    mod.__dict__["inplace"] = False
+                mod.register_full_backward_hook(self.backward_hook(name))
             if self.register_forward:
                 mod.register_forward_hook(self.forward_hook(name))
         if self.target_layers and (len(_registered) != len(self.target_layers)):

{monai_weekly-1.5.dev2506.dist-info → monai_weekly-1.5.dev2507.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: monai-weekly
-Version: 1.5.dev2506
+Version: 1.5.dev2507
 Summary: AI Toolkit for Healthcare Imaging
 Home-page: https://monai.io/
 Author: MONAI Consortium
@@ -29,7 +29,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8
 License-File: LICENSE
-Requires-Dist: torch>=1.9
+Requires-Dist: torch>=1.13.1
 Requires-Dist: numpy<2.0,>=1.24
 Provides-Extra: all
 Requires-Dist: nibabel; extra == "all"