monai-weekly 1.7.dev2639__tar.gz → 1.7.dev2640__tar.gz

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2639
+Version: 1.7.dev2640
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/__init__.py

@@ -136,4 +136,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "25847e7570361fc93261509943b21c1639ab9f04"
+__commit_id__ = "b229330ff12ea9a60b52f6ebfed256331aec71e0"

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-09-27T02:18:34+0000",
+ "date": "2026-10-04T02:49:09+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "5cfc144e2f41cc448085b59758dd2ab1d335f3d1",
- "version": "1.7.dev2639"
+ "full-revisionid": "e06f55fca00aba1d14a62c329e1f16d77b871297",
+ "version": "1.7.dev2640"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/apps/auto3dseg/bundle_gen.py

@@ -491,7 +491,7 @@ class BundleGen(AlgoGen):
         mlflow_tracking_uri: a tracking URI for MLflow server which could be local directory or address of
             the remote tracking Server; MLflow runs will be recorded locally in algorithms' model folder if
             the value is None.
-        mlfow_experiment_name: a string to specify the experiment name for MLflow server.
+        mlflow_experiment_name: a string to specify the experiment name for MLflow server.
     .. code-block:: bash
 
         python -m monai.apps.auto3dseg BundleGen generate --data_stats_filename="../algorithms/datastats.yaml"

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/apps/detection/metrics/matching.py

@@ -193,7 +193,7 @@ def _matching_no_gt(
 
     Args:
         iou_thresholds: defined which IoU thresholds should be evaluated
-        dt_scores: predicted scores
+        pred_scores: predicted scores
         max_detections: maximum number of allowed detections per image.
             This functions uses this parameter to stay consistent with
             the actual matching function which needs this limit.

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/apps/detection/transforms/dictionary.py

@@ -37,7 +37,6 @@ from monai.apps.detection.transforms.array import (
     StandardizeEmptyBox,
     ZoomBox,
 )
-from monai.apps.detection.transforms.box_ops import convert_box_to_mask
 from monai.config import KeysCollection, SequenceStr
 from monai.config.type_definitions import DtypeLike, NdarrayOrTensor
 from monai.data.box_utils import COMPUTE_DTYPE, BoxMode, clip_boxes_to_image
@@ -1154,10 +1153,13 @@ class RandCropBoxByPosNegLabeld(Randomizable, MapTransform):
             # As along as the cropped patch contains a box, it is considered as a foreground patch.
             # Positions within extended_boxes are crop centers for foreground patches
             extended_boxes_np = self.generate_fg_center_boxes_np(boxes, image_size)
-            mask_img = convert_box_to_mask(
-                extended_boxes_np, np.ones(extended_boxes_np.shape[0]), image_size, bg_label=0, ellipse_mask=False
-            )
-            mask_img = np.amax(mask_img, axis=0, keepdims=True)[0:1, ...]
+            spatial_dims = len(image_size)
+            mask_img = np.zeros((1,) + tuple(image_size), dtype=np.int16)
+            for b in range(extended_boxes_np.shape[0]):
+                slicing = (0,) + tuple(
+                    slice(extended_boxes_np[b, d], extended_boxes_np[b, d + spatial_dims]) for d in range(spatial_dims)
+                )
+                mask_img[slicing] = 1
             fg_indices_, bg_indices_ = map_binary_to_indices(mask_img, thresh_image, self.image_threshold)
         else:
             fg_indices_ = fg_indices

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/apps/pathology/transforms/post/dictionary.py

@@ -536,7 +536,7 @@ class HoVerNetInstanceMapPostProcessingd(Transform):
 
         for k in [self.instance_info_key, self.instance_map_key]:
             if k in d:
-                raise ValueError("The output key ['{k}'] already exists in the input dictionary!")
+                raise ValueError(f"The output key ['{k}'] already exists in the input dictionary!")
 
         d[self.instance_info_key], d[self.instance_map_key] = self.instance_map_post_process(
             d[self.nuclear_prediction_key], d[self.hover_map_key]
@@ -590,7 +590,7 @@ class HoVerNetNuclearTypePostProcessingd(Transform):
         )
         if self.return_type_map:
             if self.type_map_key in d:
-                raise ValueError("The output key ['{self.type_map_key}'] already exists in the input dictionary!")
+                raise ValueError(f"The output key ['{self.type_map_key}'] already exists in the input dictionary!")
             d[self.type_map_key] = type_map
 
         return d

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/data/dataset_summary.py

@@ -159,6 +159,8 @@ class DatasetSummary:
             label, *_ = convert_data_type(data=label, output_type=torch.Tensor)
 
             image_foreground = image[torch.where(label > foreground_threshold)]
+            if image_foreground.numel() == 0:
+                continue
 
             voxel_max.append(image_foreground.max().item())
             voxel_min.append(image_foreground.min().item())
@@ -166,6 +168,11 @@ class DatasetSummary:
             voxel_sum += image_foreground.sum()
             voxel_square_sum += torch.square(image_foreground).sum()
 
+        if voxel_ct == 0:
+            raise ValueError(
+                f"No foreground voxels found in any sample with {foreground_threshold=}; "
+                "set foreground_threshold=-1 to compute statistics over whole images."
+            )
         self.data_max, self.data_min = max(voxel_max), min(voxel_min)
         self.data_mean = (voxel_sum / voxel_ct).item()
         self.data_std = (torch.sqrt(voxel_square_sum / voxel_ct - self.data_mean**2)).item()
@@ -204,11 +211,17 @@ class DatasetSummary:
             label, *_ = convert_data_type(data=label, output_type=torch.Tensor)
 
             intensities = image[torch.where(label > foreground_threshold)].tolist()
-            if sampling_flag:
-                intensities = intensities[::interval]
-            all_intensities.append(intensities)
+            if intensities:
+                if sampling_flag:
+                    intensities = intensities[::interval]
+                all_intensities.append(intensities)
 
         all_intensities = list(chain(*all_intensities))
+        if not all_intensities:
+            raise ValueError(
+                f"No foreground voxels found in any sample with {foreground_threshold=}; "
+                "set foreground_threshold=-1 to compute statistics over whole images."
+            )
         self.data_min_percentile, self.data_max_percentile = np.percentile(
             all_intensities, [min_percentile, max_percentile]
         )

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/data/image_writer.py

@@ -266,12 +266,13 @@ class ImageWriter:
                 The output data type of this method is always ``np.float32``.
         """
         orig_type = type(data_array)
-        data_array = convert_to_tensor(data_array, track_meta=True)
+        # Add the channel dimension before setting the affine so spatial_ndim is inferred correctly.
+        data_array = convert_to_tensor(data_array, track_meta=True)[None]
         if affine is not None:
             data_array.affine = convert_to_tensor(affine, track_meta=False)  # type: ignore
         resampler = SpatialResample(mode=mode, padding_mode=padding_mode, align_corners=align_corners, dtype=dtype)
         output_array = resampler(
-            data_array[None], dst_affine=target_affine, spatial_size=output_spatial_shape  # type: ignore
+            data_array, dst_affine=target_affine, spatial_size=output_spatial_shape  # type: ignore
         )
         # convert back at the end
         if isinstance(output_array, MetaTensor):

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/data/synthetic.py

@@ -133,7 +133,7 @@ def create_test_image_3d(
     if rad_max <= rad_min:
         raise ValueError(f"`rad_min` {rad_min} should be less than `rad_max` {rad_max}.")
     if rad_min < 1:
-        raise ValueError("f`rad_min` {rad_min} should be no less than 1.")
+        raise ValueError(f"`rad_min` {rad_min} should be no less than 1.")
     min_size = min(height, width, depth)
     if min_size <= 2 * rad_max:
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/inferers/inferer.py

@@ -1251,7 +1251,7 @@ class DiffusionInferer(Inferer):
         given image. Code adapted from https://github.com/openai/improved-diffusion.
 
         Args:
-            input: the target images. It is assumed that this was uint8 values,
+            inputs: the target images. It is assumed that this was uint8 values,
                       rescaled to the range [-1, 1].
             means: the Gaussian mean Tensor.
             log_scales: the Gaussian log stddev Tensor.
@@ -1987,8 +1987,8 @@ class ControlNetLatentDiffusionInferer(ControlNetDiffusionInferer):
             and autoencoder_model.decoder.label_nc != diffusion_model.label_nc
         ):
             raise ValueError(
-                "If both autoencoder_model and diffusion_model implement SPADE, the number of semantic"
-                "labels for each must be compatible. Got {autoencoder_model.decoder.label_nc} and {diffusion_model.label_nc}"
+                "If both autoencoder_model and diffusion_model implement SPADE, the number of semantic "
+                f"labels for each must be compatible. Got {autoencoder_model.decoder.label_nc} and {diffusion_model.label_nc}"
             )
 
         if cn_cond.shape[2:] != input_noise.shape[2:]:

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/losses/barlow_twins.py

@@ -78,7 +78,7 @@ class BarlowTwinsLoss(_Loss):
         c = torch.mm(input_norm.t(), target_norm) / batch_size  # input_norm.t() is FxB, target_norm is BxF so c is FxF
 
         # loss
-        c_diff = (c - torch.eye(c.size(0), device=c.device)).pow_(2)  # FxF
+        c_diff = (c - torch.eye(c.size(0), dtype=c.dtype, device=c.device)).pow_(2)  # FxF
         c_diff[~torch.eye(c.size(0), device=c.device).bool()] *= lambd_tensor
 
         return c_diff.sum()

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/metrics/utils.py

@@ -12,7 +12,7 @@
 from __future__ import annotations
 
 import warnings
-from collections.abc import Iterable, Sequence
+from collections.abc import Sequence
 from functools import cache, partial
 from types import ModuleType
 from typing import Any, overload
@@ -515,23 +515,22 @@ def remap_instance_id(pred: torch.Tensor, by_size: bool = False) -> torch.Tensor
             value of the tensor should be an integer, and represents the prediction of its corresponding instance id.
         by_size: if True, largest instance will be assigned a smaller id.
 
+    Returns:
+        tensor of the same shape as ``pred`` with ids remapped to ``1..K`` (``torch.int`` dtype),
+        or ``pred`` unchanged (original dtype) when it contains no foreground ids.
     """
-    pred_id: Iterable[Any] = list(pred.unique())
-    # the original implementation has the limitation that if there is no 0 in pred, error will happen
-    pred_id = [i for i in pred_id if i != 0]
-
-    if not pred_id:
+    uniq, inverse = torch.unique(pred, return_inverse=True)
+    order = torch.nonzero(uniq != 0).flatten()
+    if order.numel() == 0:
         return pred
     if by_size:
-        instance_size = [(pred == instance_id).sum() for instance_id in pred_id]
-        pair_data = zip(pred_id, instance_size)
-        pair_list = sorted(pair_data, key=lambda x: x[1], reverse=True)
-        pred_id, _ = zip(*pair_list)
-
-    new_pred = torch.zeros_like(pred, dtype=torch.int)
-    for idx, instance_id in enumerate(pred_id):
-        new_pred[pred == instance_id] = idx + 1
-    return new_pred
+        counts = torch.bincount(inverse.flatten(), minlength=uniq.numel())[order]
+        # stable sort keeps ascending-id order for equal-size instances, matching the
+        # original python `sorted` tie-breaking
+        order = order[torch.argsort(counts, descending=True, stable=True)]
+    lut = torch.zeros(uniq.numel(), dtype=torch.int, device=pred.device)
+    lut[order] = torch.arange(1, order.numel() + 1, dtype=torch.int, device=pred.device)
+    return lut[inverse]
 
 
 def prepare_spacing(

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/networks/blocks/pos_embed_utils.py

@@ -150,7 +150,7 @@ def build_sincos_position_embedding(
             dim=1,
         )[None, :, :]
     else:
-        raise NotImplementedError("Spatial Dimension Size {spatial_dims} Not Implemented!")
+        raise NotImplementedError(f"Spatial Dimension Size {spatial_dims} Not Implemented!")
 
     pos_embed = nn.Parameter(pos_emb)
     pos_embed.requires_grad = False

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/networks/nets/patchgan_discriminator.py

@@ -126,7 +126,7 @@ class PatchDiscriminator(nn.Sequential):
         out_channels: number of output channels
         num_layers_d: number of Convolution layers (Conv + activation + normalisation + [dropout]) in the discriminator.
         kernel_size: kernel size of the convolution layers
-        act: activation type and arguments. Defaults to LeakyReLU.
+        activation: activation type and arguments. Defaults to LeakyReLU.
         norm: feature normalization type and arguments. Defaults to batch norm.
         bias: whether to have a bias term in convolution blocks. Defaults to False.
         padding: padding to be applied to the convolutional layers

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/networks/schedulers/ddpm.py

@@ -131,7 +131,7 @@ class DDPMScheduler(Scheduler):
 
         Args:
             timestep: current timestep.
-            x0: the noise-free input.
+            x_0: the noise-free input.
             x_t: the input noised to timestep t.
 
         Returns:

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/transforms/spatial/dictionary.py

@@ -1167,8 +1167,7 @@ class RandAffined(RandomizableTransform, MapTransform, InvertibleTransform, Lazy
         d = dict(data)
         first_key: Hashable = self.first_key(d)
         if first_key == ():
-            out: dict[Hashable, NdarrayOrTensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
 
         self.randomize(None)
         # all the keys share the same random Affine factor
@@ -1328,8 +1327,7 @@ class Rand2DElasticd(RandomizableTransform, MapTransform):
         first_key: Hashable = self.first_key(d)
 
         if first_key == ():
-            out: dict[Hashable, NdarrayOrTensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
 
         self.randomize(None)
         device = self.rand_2d_elastic.device
@@ -1479,8 +1477,7 @@ class Rand3DElasticd(RandomizableTransform, MapTransform):
         first_key: Hashable = self.first_key(d)
 
         if first_key == ():
-            out: dict[Hashable, torch.Tensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
 
         self.randomize(None)
         if isinstance(d[first_key], MetaTensor) and d[first_key].pending_operations:  # type: ignore
@@ -2144,8 +2141,7 @@ class RandZoomd(RandomizableTransform, MapTransform, InvertibleTransform, LazyTr
         d = dict(data)
         first_key: Hashable = self.first_key(d)
         if first_key == ():
-            out: dict[Hashable, torch.Tensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
 
         self.randomize(None)
 
@@ -2315,13 +2311,13 @@ class RandGridDistortiond(RandomizableTransform, MapTransform):
         d = dict(data)
         self.randomize(None)
         if not self._do_transform:
-            out: dict[Hashable, torch.Tensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            for key in self.key_iterator(d):
+                d[key] = convert_to_tensor(d[key], track_meta=get_track_meta())
+            return d
 
         first_key: Hashable = self.first_key(d)
         if first_key == ():
-            out = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
         if isinstance(d[first_key], MetaTensor) and d[first_key].pending_operations:  # type: ignore
             warnings.warn(f"data['{first_key}'] has pending operations, transform may return incorrect results.")
         self.rand_grid_distortion.randomize(d[first_key].shape[1:])
@@ -2643,8 +2639,7 @@ class RandSimulateLowResolutiond(RandomizableTransform, MapTransform):
         d = dict(data)
         first_key: Hashable = self.first_key(d)
         if first_key == ():
-            out: dict[Hashable, NdarrayOrTensor] = convert_to_tensor(d, track_meta=get_track_meta())
-            return out
+            return d
 
         self.randomize(None)
 

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai/transforms/spatial/functional.py

@@ -117,7 +117,9 @@ def spatial_resample(
     Args:
         img: data to be resampled, assuming `img` is channel-first.
         dst_affine: target affine matrix, if None, use the input affine matrix, effectively no resampling.
-        spatial_size: output spatial size, if the component is ``-1``, use the corresponding input spatial size.
+        spatial_size: output spatial size. Components set to ``-1`` or ``None`` use the corresponding input
+            spatial dimension. If the entire value is ``None``, the output size is computed automatically when
+            possible, otherwise the input spatial shape is used.
         mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers).
             Interpolation mode to calculate output values.
             See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html
@@ -135,6 +137,13 @@ def spatial_resample(
         dtype_pt: data `dtype` for resampling computation.
         lazy: a flag that indicates whether the operation should be performed lazily or not
         transform_info: a dictionary with the relevant information pertaining to an applied transform.
+
+    Returns:
+        torch.Tensor: The resampled output tensor, with metadata preserved when metadata tracking is enabled.
+
+    Raises:
+        ValueError: If the affine or spatial dimensions are invalid, or if the output spatial size cannot be
+            computed.
     """
     original_spatial_shape = img.peek_pending_shape() if isinstance(img, MetaTensor) else img.shape[1:]
     src_affine: torch.Tensor = img.peek_pending_affine() if isinstance(img, MetaTensor) else torch.eye(4)
@@ -156,7 +165,7 @@ def spatial_resample(
     elif spatial_size is None and spatial_rank > 1:  # auto spatial size
         spatial_size, _ = compute_shape_offset(in_spatial_size, src_affine, dst_affine)  # type: ignore
     spatial_size = torch.tensor(
-        fall_back_tuple(ensure_tuple(spatial_size)[:spatial_rank], in_spatial_size, lambda x: x >= 0)
+        fall_back_tuple(ensure_tuple(spatial_size)[:spatial_rank], in_spatial_size, lambda x: x is not None and x >= 0)
     )
     extra_info = {
         "dtype": str(dtype_pt)[6:],  # remove "torch": torch.float32 -> float32

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2640}/monai_weekly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2639
+Version: 1.7.dev2640
 Summary: AI Toolkit for Healthcare Imaging
 Author-email: MONAI Consortium <monai.contact@gmail.com>
 License: Apache License 2.0