monai-weekly 1.7.dev2625__tar.gz → 1.7.dev2626__tar.gz

{monai_weekly-1.7.dev2625/monai_weekly.egg-info → monai_weekly-1.7.dev2626}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2625
+Version: 1.7.dev2626
 Summary: AI Toolkit for Healthcare Imaging
 Home-page: https://project-monai.github.io/
 Author: MONAI Consortium

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "15f50736067093ec3716dfebdf37fe454ef79189"
+__commit_id__ = "4ba89bd818a44395842f11f3316b5aaad48353a6"

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-21T03:12:46+0000",
+ "date": "2026-06-28T03:10:43+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "128f497c42f5eb7a57de6cd679ff5fe293f2b2de",
- "version": "1.7.dev2625"
+ "full-revisionid": "859efd3e7cdbbdf09355d0e91258b5d9c15e2547",
+ "version": "1.7.dev2626"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/data/__init__.py

@@ -71,7 +71,7 @@ from .itk_torch_bridge import (
     monai_to_itk_ddf,
 )
 from .meta_obj import MetaObj, get_track_meta, set_track_meta
-from .meta_tensor import MetaTensor
+from .meta_tensor import MetaTensor, get_spatial_ndim
 from .samplers import DistributedSampler, DistributedWeightedRandomSampler
 from .synthetic import create_test_image_2d, create_test_image_3d
 from .test_time_augmentation import TestTimeAugmentation

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/data/box_utils.py

@@ -1200,7 +1200,7 @@ def batched_nms(
     # from different classes do not overlap
     max_coordinate = boxes_t.max()
     offsets = labels_t.to(boxes_t) * (max_coordinate + 1)
-    boxes_for_nms = boxes + offsets[:, None]
+    boxes_for_nms = boxes_t + offsets[:, None]
     keep = non_max_suppression(boxes_for_nms, scores_t, nms_thresh, max_proposals, box_overlap_metric)
 
     # convert tensor back to numpy if needed

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/data/meta_obj.py

@@ -24,6 +24,9 @@ from monai.utils import TraceKeys, first, is_immutable
 
 _TRACK_META = True
 
+# Default number of spatial dimensions for medical imaging (3D volumetric data)
+_DEFAULT_SPATIAL_NDIM = 3
+
 __all__ = ["get_track_meta", "set_track_meta", "MetaObj"]
 
 
@@ -84,6 +87,7 @@ class MetaObj:
         self._applied_operations: list = MetaObj.get_default_applied_operations()
         self._pending_operations: list = MetaObj.get_default_applied_operations()  # the same default as applied_ops
         self._is_batch: bool = False
+        self._spatial_ndim: int = 3  # default: 3 spatial dimensions
 
     @staticmethod
     def flatten_meta_objs(*args: Iterable):

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/data/meta_tensor.py

@@ -13,22 +13,60 @@ from __future__ import annotations
 
 import functools
 import warnings
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from copy import deepcopy
+from numbers import Integral
 from typing import Any
 
 import numpy as np
 import torch
 
 import monai
-from monai.config.type_definitions import NdarrayTensor
-from monai.data.meta_obj import MetaObj, get_track_meta
-from monai.data.utils import affine_to_spacing, decollate_batch, list_data_collate, remove_extra_metadata
+from monai.config.type_definitions import NdarrayOrTensor, NdarrayTensor
+from monai.data.meta_obj import _DEFAULT_SPATIAL_NDIM, MetaObj, get_track_meta
+from monai.data.utils import affine_to_spacing, decollate_batch, is_no_channel, list_data_collate, remove_extra_metadata
 from monai.utils import look_up_option
 from monai.utils.enums import LazyAttr, MetaKeys, PostFix, SpaceKeys
 from monai.utils.type_conversion import convert_data_type, convert_to_dst_type, convert_to_numpy, convert_to_tensor
 
-__all__ = ["MetaTensor"]
+__all__ = ["MetaTensor", "get_spatial_ndim"]
+
+
+def _normalize_spatial_ndim(spatial_ndim: int, tensor_ndim: int, no_channel: bool = False) -> int:
+    """Clamp spatial dims to a valid range for the current tensor shape."""
+    limit = max(int(tensor_ndim), 1) if no_channel else max(int(tensor_ndim) - 1, 1)
+    return max(1, min(int(spatial_ndim), limit))
+
+
+def _has_explicit_no_channel(meta: Mapping | None) -> bool:
+    return (
+        isinstance(meta, Mapping)
+        and MetaKeys.ORIGINAL_CHANNEL_DIM in meta
+        and is_no_channel(meta[MetaKeys.ORIGINAL_CHANNEL_DIM])
+    )
+
+
+def get_spatial_ndim(img: NdarrayOrTensor) -> int:
+    """Return the number of spatial dimensions assuming channel-first layout.
+
+    Uses ``MetaTensor.spatial_ndim`` when available, otherwise falls back to
+    ``img.ndim - 1``.  Always assumes channel-first (``no_channel=False``)
+    because callers run after ``EnsureChannelFirst`` has already added one.
+    """
+    if isinstance(img, MetaTensor):
+        return _normalize_spatial_ndim(img.spatial_ndim, img.ndim)
+    return img.ndim - 1
+
+
+def _is_batch_only_index(index: Any) -> bool:
+    """True when indexing pattern selects only the batch axis (e.g., ``x[0]`` or ``x[0, ...]``)."""
+    if isinstance(index, (int, np.integer)):
+        return True
+    if not isinstance(index, Sequence) or not index:
+        return False
+    if not isinstance(index[0], (int, np.integer)):
+        return False
+    return all(i in (slice(None, None, None), Ellipsis, None) for i in index[1:])
 
 
 @functools.lru_cache(None)
@@ -111,6 +149,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         meta: dict | None = None,
         applied_operations: list | None = None,
         *args,
+        spatial_ndim: int | None = None,
         **kwargs,
     ) -> MetaTensor:
         _kwargs = {"device": kwargs.pop("device", None), "dtype": kwargs.pop("dtype", None)} if kwargs else {}
@@ -123,6 +162,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         meta: dict | None = None,
         applied_operations: list | None = None,
         *_args,
+        spatial_ndim: int | None = None,
         **_kwargs,
     ) -> None:
         """
@@ -134,6 +174,8 @@ class MetaTensor(MetaObj, torch.Tensor):
                 the list is typically maintained by `monai.transforms.TraceableTransform`.
                 See also: :py:class:`monai.transforms.TraceableTransform`
             _args: additional args (currently not in use in this constructor).
+            spatial_ndim: optional number of spatial dimensions. If ``None``, derived
+                from the affine matrix clamped by the tensor shape.
             _kwargs: additional kwargs (currently not in use in this constructor).
 
         Note:
@@ -158,6 +200,14 @@ class MetaTensor(MetaObj, torch.Tensor):
             self.affine = self.meta[MetaKeys.AFFINE]
         else:
             self.affine = self.get_default_affine()
+        # Initialize spatial_ndim from affine matrix (source of truth), clamped by tensor shape.
+        # This cached value is kept in sync via the affine setter for hot-path performance.
+        no_channel = _has_explicit_no_channel(self.meta)
+        if spatial_ndim is not None:
+            self.spatial_ndim = _normalize_spatial_ndim(spatial_ndim, self.ndim, no_channel=no_channel)
+        elif self.affine.ndim == 2:
+            self.spatial_ndim = _normalize_spatial_ndim(self.affine.shape[-1] - 1, self.ndim, no_channel=no_channel)
+
         # applied_operations
         if applied_operations is not None:
             self.applied_operations = applied_operations
@@ -237,6 +287,7 @@ class MetaTensor(MetaObj, torch.Tensor):
         if func == torch.Tensor.__getitem__:
             if idx > 0 or len(args) < 2 or len(args[0]) < 1:
                 return ret
+            full_idx = args[1]
             batch_idx = args[1][0] if isinstance(args[1], Sequence) else args[1]
             # if using e.g., `batch[:, -1]` or `batch[..., -1]`, then the
             # first element will be `slice(None, None, None)` and `Ellipsis`,
@@ -258,6 +309,8 @@ class MetaTensor(MetaObj, torch.Tensor):
                 ret_meta.is_batch = False
             if hasattr(ret_meta, "__dict__"):
                 ret.__dict__ = ret_meta.__dict__.copy()
+                if _is_batch_only_index(full_idx):
+                    ret.spatial_ndim = _normalize_spatial_ndim(ret.spatial_ndim, ret.ndim)
         # `unbind` is used for `next(iter(batch))`. Also for `decollate_batch`.
         # But we only want to split the batch if the `unbind` is along the 0th dimension.
         elif func == torch.Tensor.unbind:
@@ -467,15 +520,42 @@ class MetaTensor(MetaObj, torch.Tensor):
 
     @affine.setter
     def affine(self, d: NdarrayTensor) -> None:
-        """Set the affine."""
-        self.meta[MetaKeys.AFFINE] = torch.as_tensor(d, device=torch.device("cpu"), dtype=torch.float64)
+        """Set the affine.
+
+        When setting a non-batched affine matrix, automatically synchronizes the cached
+        spatial_ndim attribute to maintain consistency between the affine matrix (source of truth)
+        and the cached spatial dimension count.
+        """
+        a = torch.as_tensor(d, device=torch.device("cpu"), dtype=torch.float64)
+        self.meta[MetaKeys.AFFINE] = a
+        if a.ndim == 2:  # non-batched: sync spatial_ndim from affine (source of truth)
+            no_channel = _has_explicit_no_channel(self.meta)
+            self.spatial_ndim = _normalize_spatial_ndim(a.shape[-1] - 1, self.ndim, no_channel=no_channel)
+
+    @property
+    def spatial_ndim(self) -> int:
+        """Get the number of spatial dimensions.
+
+        This value is cached for hot-path performance and is kept in sync with the affine matrix
+        via the affine setter. The affine matrix is the source of truth for spatial dimensions.
+        """
+        return getattr(self, "_spatial_ndim", _DEFAULT_SPATIAL_NDIM)
+
+    @spatial_ndim.setter
+    def spatial_ndim(self, val: int) -> None:
+        """Set the number of spatial dimensions."""
+        if not isinstance(val, Integral):
+            raise TypeError(f"'val' must be an numbers.Integral type; got {type(val)}.")
+        if val < 1:
+            raise ValueError(f"spatial_ndim must be >= 1, got {val}")
+        self._spatial_ndim = int(val)
 
     @property
     def pixdim(self):
         """Get the spacing"""
         if self.is_batch:
-            return [affine_to_spacing(a) for a in self.affine]
-        return affine_to_spacing(self.affine)
+            return [affine_to_spacing(a, r=self.spatial_ndim) for a in self.affine]
+        return affine_to_spacing(self.affine, r=self.spatial_ndim)
 
     def peek_pending_shape(self):
         """
@@ -490,7 +570,7 @@ class MetaTensor(MetaObj, torch.Tensor):
 
     def peek_pending_affine(self):
         res = self.affine
-        r = len(res) - 1
+        r = res.shape[-1] - 1 if res.ndim >= 2 else self.spatial_ndim
         if r not in (2, 3):
             warnings.warn(f"Only 2d and 3d affine are supported, got {r}d input.")
         for p in self.pending_operations:
@@ -503,8 +583,10 @@ class MetaTensor(MetaObj, torch.Tensor):
         return res
 
     def peek_pending_rank(self):
-        a = self.pending_operations[-1].get(LazyAttr.AFFINE, None) if self.pending_operations else self.affine
-        return 1 if a is None else int(max(1, len(a) - 1))
+        if self.pending_operations:
+            a = self.pending_operations[-1].get(LazyAttr.AFFINE, None)
+            return 1 if a is None else int(max(1, len(a) - 1))
+        return self.spatial_ndim
 
     def new_empty(self, size, dtype=None, device=None, requires_grad=False):  # type: ignore[override]
         """

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/data/utils.py

@@ -31,7 +31,7 @@ import torch
 from torch.utils.data._utils.collate import default_collate
 
 from monai.config.type_definitions import NdarrayOrTensor, NdarrayTensor, PathLike
-from monai.data.meta_obj import MetaObj
+from monai.data.meta_obj import _DEFAULT_SPATIAL_NDIM, MetaObj
 from monai.utils import (
     MAX_SEED,
     BlendMode,
@@ -432,6 +432,9 @@ def collate_meta_tensor_fn(batch, *, collate_fn_map=None):
     collated.meta = default_collate(meta_dicts)
     collated.applied_operations = [i.applied_operations or TraceKeys.NONE for i in batch]
     collated.is_batch = True
+    collated.spatial_ndim = min(
+        min(getattr(t, "spatial_ndim", _DEFAULT_SPATIAL_NDIM) for t in batch), max(collated.ndim - 1, 1)
+    )
     return collated
 
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/adversarial_loss.py

@@ -129,7 +129,8 @@ class PatchAdversarialLoss(_Loss):
             target_is_real = True  # With generator, we always want this to be true!
             warnings.warn(
                 "Variable target_is_real has been set to False, but for_discriminator is set"
-                "to False. To optimise a generator, target_is_real must be set to True."
+                "to False. To optimise a generator, target_is_real must be set to True.",
+                stacklevel=2,
             )
 
         if not isinstance(input, list):

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/cldice.py

@@ -134,7 +134,8 @@ class SoftclDiceLoss(_Loss):
         Args:
             iter_: Number of iterations for skeletonization. Must be a non-negative integer. Defaults to 3.
             smooth_nr: a small constant added to the numerator to avoid zero. Defaults to 1.0.
-            smooth_dr: a small constant added to the denominator to avoid nan. Defaults to 1.0.
+            smooth_dr: a small constant added to the denominator of the individual precision /
+                sensitivity ratios and the internal Dice denominator to avoid nan. Defaults to 1.0.
             smooth: a small constant added to the denominator of the harmonic mean to avoid nan. Defaults to 1e-4.
             include_background: if False, channel index 0 (background category) is excluded from the calculation.
                 if the non-background segmentations are small compared to the total image size they can get overwhelmed

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/dice.py

@@ -156,7 +156,7 @@ class DiceLoss(_Loss):
         n_pred_ch = input.shape[1]
         if self.softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
@@ -165,13 +165,13 @@ class DiceLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 # if skipping background, removing first channel
                 target = target[:, 1:]
@@ -405,7 +405,7 @@ class GeneralizedDiceLoss(_Loss):
         n_pred_ch = input.shape[1]
         if self.softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
@@ -414,13 +414,13 @@ class GeneralizedDiceLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 # if skipping background, removing first channel
                 target = target[:, 1:]
@@ -987,7 +987,7 @@ class DiceFocalLoss(_Loss):
         if self.to_onehot_y:
             n_pred_ch = input.shape[1]
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
         dice_loss = self.dice(input, target)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/focal_loss.py

@@ -146,13 +146,13 @@ class FocalLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 # if skipping background, removing first channel
                 target = target[:, 1:]

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/hausdorff_loss.py

@@ -154,7 +154,7 @@ class HausdorffDTLoss(_Loss):
         n_pred_ch = input.shape[1]
         if self.softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
@@ -163,13 +163,13 @@ class HausdorffDTLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 # If skipping background, removing first channel
                 target = target[:, 1:]

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/image_dissimilarity.py

@@ -233,10 +233,14 @@ class GlobalMutualInformationLoss(_Loss):
         self.kernel_type = look_up_option(kernel_type, ["gaussian", "b-spline"])
         self.num_bins = num_bins
         self.kernel_type = kernel_type
+        # declared as buffers so they move with the module (e.g. ``.to(device)``); only populated for the
+        # gaussian kernel, hence the ``Tensor`` annotation reflects the type at the use sites in that path.
+        self.preterm: torch.Tensor | None
         self.bin_centers: torch.Tensor | None
+        self.register_buffer("preterm", None, persistent=False)
         self.register_buffer("bin_centers", None, persistent=False)
         if self.kernel_type == "gaussian":
-            self.preterm = 1 / (2 * sigma**2)
+            self.register_buffer("preterm", 1 / (2 * sigma**2), persistent=False)
             self.register_buffer("bin_centers", bin_centers[None, None, ...], persistent=False)
         self.smooth_nr = float(smooth_nr)
         self.smooth_dr = float(smooth_dr)
@@ -316,8 +320,8 @@ class GlobalMutualInformationLoss(_Loss):
         """
         img = torch.clamp(img, 0, 1)
         img = img.reshape(img.shape[0], -1, 1)  # (batch, num_sample, 1)
-        if self.bin_centers is None:
-            raise ValueError("bin_centers must be defined for gaussian parzen windowing.")
+        if self.bin_centers is None or self.preterm is None:
+            raise ValueError("bin_centers and preterm must be defined for gaussian parzen windowing.")
         weight = torch.exp(
             -self.preterm.to(img) * (img - self.bin_centers.to(img)) ** 2
         )  # (batch, num_sample, num_bin)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/mcc_loss.py

@@ -133,7 +133,7 @@ class MCCLoss(_Loss):
         n_pred_ch = input.shape[1]
         if self.softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
@@ -142,13 +142,13 @@ class MCCLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 target = target[:, 1:]
                 input = input[:, 1:]

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/perceptual.py

@@ -112,7 +112,7 @@ class PerceptualLoss(nn.Module):
                 )
             if not channel_wise:
                 warnings.warn(
-                    "MedicalNet networks supp, ort channel-wise loss. Consider setting channel_wise=True.", stacklevel=2
+                    "MedicalNet networks support channel-wise loss. Consider setting channel_wise=True.", stacklevel=2
                 )
 
         # Channel-wise only for MedicalNet
@@ -127,7 +127,8 @@ class PerceptualLoss(nn.Module):
             torch.hub.set_dir(cache_dir)
             # raise a warning that this may change the default cache dir for all torch.hub calls
             warnings.warn(
-                f"Setting cache_dir to {cache_dir}, this may change the default cache dir for all torch.hub calls."
+                f"Setting cache_dir to {cache_dir}, this may change the default cache dir for all torch.hub calls.",
+                stacklevel=2,
             )
 
         self.spatial_dims = spatial_dims

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/spatial_mask.py

@@ -55,16 +55,18 @@ class MaskedLoss(_Loss):
             mask: the shape should be B1H[WD] or 11H[WD].
         """
         if mask is None:
-            warnings.warn("No mask value specified for the MaskedLoss.")
+            warnings.warn("No mask value specified for the MaskedLoss.", stacklevel=2)
             return self.loss(input, target)
 
         if input.dim() != mask.dim():
-            warnings.warn(f"Dim of input ({input.shape}) is different from mask ({mask.shape}).")
+            warnings.warn(f"Dim of input ({input.shape}) is different from mask ({mask.shape}).", stacklevel=2)
         if input.shape[0] != mask.shape[0] and mask.shape[0] != 1:
             raise ValueError(f"Batch size of mask ({mask.shape}) must be one or equal to input ({input.shape}).")
         if target.dim() > 1:
             if mask.shape[1] != 1:
                 raise ValueError(f"Mask ({mask.shape}) must have only one channel.")
             if input.shape[2:] != mask.shape[2:]:
-                warnings.warn(f"Spatial size of input ({input.shape}) is different from mask ({mask.shape}).")
+                warnings.warn(
+                    f"Spatial size of input ({input.shape}) is different from mask ({mask.shape}).", stacklevel=2
+                )
         return self.loss(input * mask, target * mask)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/tversky.py

@@ -118,7 +118,7 @@ class TverskyLoss(_Loss):
         n_pred_ch = input.shape[1]
         if self.softmax:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `softmax=True` ignored.")
+                warnings.warn("single channel prediction, `softmax=True` ignored.", stacklevel=2)
             else:
                 input = torch.softmax(input, 1)
 
@@ -127,13 +127,13 @@ class TverskyLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 target = one_hot(target, num_classes=n_pred_ch)
 
         if not self.include_background:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `include_background=False` ignored.")
+                warnings.warn("single channel prediction, `include_background=False` ignored.", stacklevel=2)
             else:
                 # if skipping background, removing first channel
                 target = target[:, 1:]

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/losses/unified_focal_loss.py

@@ -58,7 +58,7 @@ class AsymmetricFocalTverskyLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 y_true = one_hot(y_true, num_classes=n_pred_ch)
 
@@ -122,7 +122,7 @@ class AsymmetricFocalLoss(_Loss):
 
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 y_true = one_hot(y_true, num_classes=n_pred_ch)
 
@@ -223,7 +223,7 @@ class AsymmetricUnifiedFocalLoss(_Loss):
         n_pred_ch = y_pred.shape[1]
         if self.to_onehot_y:
             if n_pred_ch == 1:
-                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.")
+                warnings.warn("single channel prediction, `to_onehot_y=True` ignored.", stacklevel=2)
             else:
                 y_true = one_hot(y_true, num_classes=n_pred_ch)
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/metrics/active_learning_metrics.py

@@ -137,7 +137,7 @@ def compute_variance(
     n_len = len(y_pred.shape)
 
     if n_len < 4 and spatial_map:
-        warnings.warn("Spatial map requires a 2D/3D image with N-repeats and C-channels")
+        warnings.warn("Spatial map requires a 2D/3D image with N-repeats and C-channels", stacklevel=2)
         return None
 
     # Create new shape list
@@ -190,7 +190,10 @@ def label_quality_score(
 
     n_len = len(y_pred.shape)
     if n_len < 4 and scalar_reduction == "none":
-        warnings.warn("Reduction set to None, Spatial map return requires a 2D/3D image of B-Batchsize and C-channels")
+        warnings.warn(
+            "Reduction set to None, Spatial map return requires a 2D/3D image of B-Batchsize and C-channels",
+            stacklevel=2,
+        )
         return None
 
     abs_diff_map = torch.abs(y_pred - y)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/metrics/average_precision.py

@@ -88,10 +88,12 @@ def _calculate(y_pred: torch.Tensor, y: torch.Tensor) -> float:
         raise AssertionError("y and y_pred must be 1 dimension data with same length.")
     y_unique = y.unique()
     if len(y_unique) == 1:
-        warnings.warn(f"y values can not be all {y_unique.item()}, skip AP computation and return `Nan`.")
+        warnings.warn(f"y values can not be all {y_unique.item()}, skip AP computation and return `Nan`.", stacklevel=2)
         return float("nan")
     if not y_unique.equal(torch.tensor([0, 1], dtype=y.dtype, device=y.device)):
-        warnings.warn(f"y values must be 0 or 1, but in {y_unique.tolist()}, skip AP computation and return `Nan`.")
+        warnings.warn(
+            f"y values must be 0 or 1, but in {y_unique.tolist()}, skip AP computation and return `Nan`.", stacklevel=2
+        )
         return float("nan")
 
     n = len(y)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/metrics/confusion_matrix.py

@@ -93,7 +93,7 @@ class ConfusionMatrixMetric(CumulativeIterationMetric):
             raise ValueError("y_pred should have at least two dimensions.")
         if dims == 2 or (dims == 3 and y_pred.shape[-1] == 1):
             if self.compute_sample:
-                warnings.warn("As for classification task, compute_sample should be False.")
+                warnings.warn("As for classification task, compute_sample should be False.", stacklevel=2)
                 self.compute_sample = False
 
         return get_confusion_matrix(y_pred=y_pred, y=y, include_background=self.include_background)

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/metrics/cumulative_average.py

@@ -154,7 +154,7 @@ class CumulativeAverage:
         # account for possible non-finite numbers in val and replace them with 0s
         nfin = torch.isfinite(val)
         if not torch.all(nfin):
-            warnings.warn(f"non-finite inputs received: val: {val}, count: {count}")
+            warnings.warn(f"non-finite inputs received: val: {val}, count: {count}", stacklevel=2)
             count = torch.where(nfin, count, torch.zeros_like(count))
             val = torch.where(nfin, val, torch.zeros_like(val))
 

{monai_weekly-1.7.dev2625 → monai_weekly-1.7.dev2626}/monai/metrics/rocauc.py

@@ -77,10 +77,14 @@ def _calculate(y_pred: torch.Tensor, y: torch.Tensor) -> float:
         raise AssertionError("y and y_pred must be 1 dimension data with same length.")
     y_unique = y.unique()
     if len(y_unique) == 1:
-        warnings.warn(f"y values can not be all {y_unique.item()}, skip AUC computation and return `Nan`.")
+        warnings.warn(
+            f"y values can not be all {y_unique.item()}, skip AUC computation and return `Nan`.", stacklevel=2
+        )
         return float("nan")
     if not y_unique.equal(torch.tensor([0, 1], dtype=y.dtype, device=y.device)):
-        warnings.warn(f"y values must be 0 or 1, but in {y_unique.tolist()}, skip AUC computation and return `Nan`.")
+        warnings.warn(
+            f"y values must be 0 or 1, but in {y_unique.tolist()}, skip AUC computation and return `Nan`.", stacklevel=2
+        )
         return float("nan")
 
     n = len(y)