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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2639
+Version: 1.7.dev2641
 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.dev2641}/monai/__init__.py

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

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/monai/_extensions/loader.py

@@ -75,7 +75,9 @@ def load_module(
     source = glob(path.join(module_dir, "**", "*.cpp"), recursive=True)
     if torch.cuda.is_available():
         source += glob(path.join(module_dir, "**", "*.cu"), recursive=True)
-        platform_str += f"_{torch.version.cuda}"
+        # `torch.version.cuda` is None on a ROCm build, which would make every ROCm
+        # toolkit version share a single cache entry. Key on whichever is populated.
+        platform_str += f"_{torch.version.cuda or f'hip{torch.version.hip}'}"
 
     # Constructing compilation argument list.
     define_args = [] if not defines else [f"-D {key}={defines[key]}" for key in defines]

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

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

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/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.dev2641}/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.dev2641}/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.dev2641}/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.dev2641}/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.dev2641}/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.dev2641}/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.dev2641}/monai/data/utils.py

@@ -686,28 +686,40 @@ def worker_init_fn(worker_id: int) -> None:
     set_rnd(worker_info.dataset, seed=worker_info.seed)  # type: ignore[union-attr]
 
 
-def set_rnd(obj, seed: int) -> int:
+def set_rnd(obj, seed: int, _seen: set[int] | None = None) -> int:
     """
     Set seed or random state for all randomizable properties of obj.
 
     Args:
         obj: object to set seed or random state for.
         seed: set the random state with an integer seed.
+        _seen: internal set of already-visited object ids, used to guard against
+            infinite recursion on cyclic object graphs (e.g. OmegaConf/Hydra
+            configs whose child nodes back-reference their parent, see issue #8087).
     """
+    if _seen is None:
+        _seen = set()
     if isinstance(obj, (tuple, list)):  # ZipDataset.data is a list
-        _seed = seed
+        if id(obj) in _seen:
+            return seed
+        _seen.add(id(obj))
+        has_randomizable = False
         for item in obj:
-            _seed = set_rnd(item, seed=seed)
-        return seed if _seed == seed else seed + 1  # return a different seed if there are randomizable items
+            item_seed = set_rnd(item, seed=seed, _seen=_seen)
+            has_randomizable = has_randomizable or item_seed != seed
+        return seed + 1 if has_randomizable else seed
     if not hasattr(obj, "__dict__"):
         return seed  # no attribute
+    if id(obj) in _seen:
+        return seed  # already visited: avoid infinite recursion on cyclic references
+    _seen.add(id(obj))
     if hasattr(obj, "set_random_state"):
         obj.set_random_state(seed=seed % MAX_SEED)
         return seed + 1  # a different seed for the next component
     for key in obj.__dict__:
         if key.startswith("__"):  # skip the private methods
             continue
-        seed = set_rnd(obj.__dict__[key], seed=seed)
+        seed = set_rnd(obj.__dict__[key], seed=seed, _seen=_seen)
     return seed
 
 

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/monai/handlers/calibration.py

@@ -59,8 +59,8 @@ class CalibrationError(IgniteMetricHandler):
         - Guo, C., et al. "On Calibration of Modern Neural Networks." ICML 2017.
           https://proceedings.mlr.press/v70/guo17a.html
         - Barfoot, T., et al. "Average Calibration Losses for Reliable Uncertainty in
-          Medical Image Segmentation." arXiv:2506.03942v3, 2025.
-          https://arxiv.org/abs/2506.03942v3
+          Medical Image Segmentation." IEEE Transactions on Medical Imaging, 2026.
+          https://doi.org/10.1109/TMI.2026.3673118
 
     See Also:
         - :py:class:`~monai.metrics.CalibrationErrorMetric`: The underlying metric class.

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/monai/handlers/mlflow_handler.py

@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 import os
+import threading
 import time
 import warnings
 from collections.abc import Callable, Mapping, Sequence
@@ -43,6 +44,9 @@ MlflowException, _ = optional_import(
 )
 pandas, _ = optional_import("pandas", descriptor="Please install pandas for recording the dataset.")
 tqdm, _ = optional_import("tqdm", "4.47.0", min_version, "tqdm")
+SystemMetricsMonitor, has_system_metrics = optional_import(
+    "mlflow.system_metrics.system_metrics_monitor", name="SystemMetricsMonitor"
+)
 
 if TYPE_CHECKING:
     from ignite.engine import Engine
@@ -136,6 +140,19 @@ class MLFlowHandler:
             or the ``MLFLOW_TRACKING_URI`` environment variable), it defaults to an ``mlruns`` directory
             next to the database file; for other backends ``None`` lets MLflow decide based on the
             ``tracking_uri``. Has no effect if the experiment already exists.
+        log_system_metrics: whether to record system resource usage (CPU, memory, disk, network and GPU)
+            while the workflow runs, default to False. The metrics are sampled in a background thread by
+            MLflow itself and stored in the same run as the workflow metrics, under the `system/` prefix.
+            Requires `psutil`, and `pynvml` in addition for the GPU metrics. Note that MLflow reads the
+            run through the global tracking URI to sample it, so this points the global tracking URI
+            (and with it `MLFLOW_TRACKING_URI`, which later handlers read in preference to their own
+            argument) at `tracking_uri` while the run is sampled, and puts the previous value back
+            when sampling stops.
+        system_metrics_sampling_interval: seconds between two samples of the system metrics, default to
+            `None`, which keeps the MLflow default (10 seconds). Only used if `log_system_metrics` is True.
+        system_metrics_samples_before_logging: number of samples to aggregate before they are logged,
+            default to `None`, which keeps the MLflow default (1 sample). Only used if `log_system_metrics`
+            is True.
 
     For more details of MLFlow usage, please refer to: https://mlflow.org/docs/latest/index.html.
 
@@ -144,6 +161,10 @@ class MLFlowHandler:
     # parameters that are logged at the start of training
     default_tracking_params = ["max_epochs", "epoch_length"]
 
+    # runs whose system metrics are being sampled, so that handlers sharing a run sample it once
+    _monitored_run_ids: set[str] = set()
+    _system_metrics_lock = threading.Lock()
+
     def __init__(
         self,
         tracking_uri: str | None = None,
@@ -165,6 +186,9 @@ class MLFlowHandler:
         optimizer_param_names: str | Sequence[str] = "lr",
         close_on_complete: bool = False,
         artifact_location: str | None = None,
+        log_system_metrics: bool = False,
+        system_metrics_sampling_interval: int | None = None,
+        system_metrics_samples_before_logging: int | None = None,
     ) -> None:
         self.iteration_log = iteration_log
         self.epoch_log = epoch_log
@@ -210,11 +234,27 @@ class MLFlowHandler:
                 f"tracking_uri={effective_tracking_uri!r}. Use a SQLite URI "
                 "(sqlite:///<path>/mlruns.db) or a remote tracking URI instead."
             )
+        # The system metrics monitor reads the run through the global tracking uri,
+        # so remember the uri that was actually settled on rather than the argument.
+        self.tracking_uri = effective_tracking_uri
         # Only the argument is passed to the client; when `MLFLOW_TRACKING_URI` took priority it
         # is left None so MLflow resolves the environment variable itself.
         self.client = mlflow.MlflowClient(tracking_uri=None if env_tracking_uri else tracking_uri)
         self.run_finish_status = mlflow.entities.RunStatus.to_string(mlflow.entities.RunStatus.FINISHED)
         self.close_on_complete = close_on_complete
+        self.log_system_metrics = log_system_metrics
+        for name, value in (
+            ("system_metrics_sampling_interval", system_metrics_sampling_interval),
+            ("system_metrics_samples_before_logging", system_metrics_samples_before_logging),
+        ):
+            if value is not None and value <= 0:
+                raise ValueError(f"`{name}` must be a positive number, got {value}.")
+        self.system_metrics_sampling_interval = system_metrics_sampling_interval
+        self.system_metrics_samples_before_logging = system_metrics_samples_before_logging
+        self.system_metrics_monitor = None
+        self._monitored_run_id: str | None = None
+        self._previous_tracking_uri: str | None = None
+        self._tracking_uri_overridden = False
         self.experiment = None
         self.cur_run = None
         self.dataset_dict = dataset_dict
@@ -295,6 +335,81 @@ class MLFlowHandler:
         else:
             self._default_dataset_log(self.dataset_dict)
 
+        if self.log_system_metrics:
+            self._start_system_metrics_monitor()
+
+    def _start_system_metrics_monitor(self) -> None:
+        """
+        Start sampling the system resource usage of the current run, if it is not sampled yet.
+
+        A workflow attaches one handler per engine, and those handlers share a run, so the run is
+        sampled by the first handler that starts and left alone by the other ones.
+        """
+        if self.system_metrics_monitor is not None or self.cur_run is None:
+            return
+
+        if not has_system_metrics:
+            warnings.warn("Please install mlflow>=2.8.0 to record the system metrics.")
+            return
+
+        run_id = self.cur_run.info.run_id
+        with MLFlowHandler._system_metrics_lock:
+            if run_id in MLFlowHandler._monitored_run_ids:
+                return
+
+            kwargs = {}
+            if self.system_metrics_sampling_interval is not None:
+                kwargs["sampling_interval"] = self.system_metrics_sampling_interval
+            if self.system_metrics_samples_before_logging is not None:
+                kwargs["samples_before_logging"] = self.system_metrics_samples_before_logging
+
+            # mlflow reads the run to sample through the global tracking uri, not through
+            # the client, so it has to be pointed at ours for as long as we sample. Setting
+            # it also writes MLFLOW_TRACKING_URI, which every later handler reads in
+            # preference to its own argument, so the previous value is put back when
+            # sampling stops. `None` is a meaningful previous value, meaning it was unset,
+            # and passing it back to mlflow restores exactly that.
+            previous_tracking_uri = os.environ.get("MLFLOW_TRACKING_URI")
+            overridden = False
+            try:
+                if self.tracking_uri:
+                    mlflow.set_tracking_uri(self.tracking_uri)
+                    overridden = True
+                monitor = SystemMetricsMonitor(run_id, **kwargs)
+                monitor.start()
+            except Exception as e:
+                # a workflow should not fail because its resource usage cannot be recorded
+                if overridden:
+                    mlflow.set_tracking_uri(previous_tracking_uri)
+                warnings.warn(f"Failed to record the system metrics: {e}")
+                return
+            self._previous_tracking_uri = previous_tracking_uri
+            self._tracking_uri_overridden = overridden
+
+            MLFlowHandler._monitored_run_ids.add(run_id)
+            self.system_metrics_monitor = monitor
+            self._monitored_run_id = run_id
+
+    def _stop_system_metrics_monitor(self) -> None:
+        """
+        Stop sampling the system resource usage, if this handler is the one sampling it.
+        """
+        if self.system_metrics_monitor is None:
+            return
+
+        with MLFlowHandler._system_metrics_lock:
+            try:
+                self.system_metrics_monitor.finish()
+            except Exception as e:
+                warnings.warn(f"Failed to stop recording the system metrics: {e}")
+            if self._tracking_uri_overridden:
+                mlflow.set_tracking_uri(self._previous_tracking_uri)
+                self._tracking_uri_overridden = False
+            self._previous_tracking_uri = None
+            MLFlowHandler._monitored_run_ids.discard(self._monitored_run_id)
+            self.system_metrics_monitor = None
+            self._monitored_run_id = None
+
     def _set_experiment(self):
         experiment = self.experiment
         if not experiment:
@@ -394,6 +509,8 @@ class MLFlowHandler:
         """
         Handler for train or validation/evaluation completed Event.
         """
+        self._stop_system_metrics_monitor()
+
         if self.artifacts and self.cur_run:
             artifact_list = self._parse_artifacts()
             for artifact in artifact_list:
@@ -430,6 +547,8 @@ class MLFlowHandler:
         Stop current running logger of MLFlow and release local SQLite resources.
 
         """
+        self._stop_system_metrics_monitor()
+
         try:
             if self.cur_run:
                 self.client.set_terminated(self.cur_run.info.run_id, self.run_finish_status)

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/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.dev2641}/monai/losses/__init__.py

@@ -15,6 +15,7 @@ from .adversarial_loss import PatchAdversarialLoss
 from .aucm_loss import AUCMLoss
 from .barlow_twins import BarlowTwinsLoss
 from .boundary_loss import BoundaryLoss
+from .calibration import HardL1ACELoss, SoftL1ACELoss
 from .cldice import SoftclDiceLoss, SoftDiceclDiceLoss
 from .contrastive import ContrastiveLoss
 from .deform import BendingEnergyLoss, DiffusionLoss

{monai_weekly-1.7.dev2639 → monai_weekly-1.7.dev2641}/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()