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

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

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

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

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

{monai_weekly-1.7.dev2640 → monai_weekly-1.7.dev2642}/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.dev2640 → monai_weekly-1.7.dev2642}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-10-04T02:49:09+0000",
+ "date": "2026-10-18T02:14:29+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "e06f55fca00aba1d14a62c329e1f16d77b871297",
- "version": "1.7.dev2640"
+ "full-revisionid": "4835c649a66849125f1e656543264f5fa7d261c0",
+ "version": "1.7.dev2642"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2640 → monai_weekly-1.7.dev2642}/monai/apps/utils.py

@@ -30,6 +30,7 @@ from urllib.request import urlopen, urlretrieve
 
 from monai.config.type_definitions import PathLike
 from monai.utils import look_up_option, min_version, optional_import
+from monai.utils.deprecate_utils import warn_deprecated
 
 requests, has_requests = optional_import("requests")
 gdown, has_gdown = optional_import("gdown", "4.7.3")
@@ -177,6 +178,9 @@ def check_hash(filepath: PathLike, val: str | None = None, hash_type: str = "sha
             The supported hash types are `"md5"`, `"sha1"`, `"sha256"`, `"sha512"`.
             See also: :py:data:`monai.apps.utils.SUPPORTED_HASH_TYPES`.
 
+    .. versionchanged:: 1.7
+        The default `hash_type` changed from "md5" to "sha256" for stronger integrity verification.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes.
     """
     if val is None:
         warnings.warn(f"No hash value provided for {filepath}; file integrity is NOT verified.", stacklevel=2)
@@ -204,7 +208,7 @@ def download_url(
     url: str,
     filepath: PathLike = "",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     progress: bool = True,
     **gdown_kwargs: Any,
 ) -> None:
@@ -217,7 +221,7 @@ def download_url(
             If undefined, `os.path.basename(url)` will be used.
         hash_val: expected hash value to validate the downloaded file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
             The supported hash types are `"md5"`, `"sha1"`, `"sha256"`, `"sha512"`.
         progress: whether to display a progress bar.
         gdown_kwargs: other args for `gdown` except for the `url`, `output` and `quiet`.
@@ -234,7 +238,23 @@ def download_url(
         ContentTooShortError: See urllib.request.urlretrieve.
         IOError: See urllib.request.urlretrieve.
         HashCheckError: When the hash validation of the ``url`` downloaded file fails.
+
+    .. versionchanged:: 1.7
+        The default `hash_type` changed from "md5" to None for stronger integrity verification. If this is left None
+        when a `hash_val` value is provided, this will warn to explicitly set `hash_type` then choose sha256 hashing.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes and suppress the warning. In MONAI 1.8 the
+        default will be set to "sha256".
     """
+    if hash_val is not None and hash_type is None:
+        warn_deprecated(
+            "monai.apps.utils.download_url",
+            'Default `hash_type` value changed to `None` from "md5" in MONAI 1.7, '
+            "set to explicit value to suppress this warning. Defaulting to sha256 checking. In MONAI 1.8 the "
+            'default will be set to "sha256".',
+            stacklevel=3,
+        )
+        hash_type = "sha256"
+
     if not filepath:
         filepath = Path(".", _basename(url)).resolve()
         logger.info(f"Default downloading to '{filepath}'")
@@ -316,7 +336,7 @@ def extractall(
     filepath: PathLike,
     output_dir: PathLike = ".",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     file_type: str = "",
     has_base: bool = True,
 ) -> None:
@@ -329,7 +349,7 @@ def extractall(
         output_dir: target directory to save extracted files.
         hash_val: expected hash value to validate the compressed file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
         file_type: string of file type for decompressing. Leave it empty to infer the type from the filepath basename.
         has_base: whether the extracted files have a base folder. This flag is used when checking if the existing
             folder is a result of `extractall`, if it is, the extraction is skipped. For example, if A.zip is unzipped
@@ -340,7 +360,22 @@ def extractall(
         HashCheckError: When the hash validation of the ``filepath`` compressed file fails.
         NotImplementedError: When the ``filepath`` file extension is not one of [zip", "tar.gz", "tar"].
 
+    .. versionchanged:: 1.6.1
+        The default `hash_type` changed from "md5" to None for stronger integrity verification. If this is left None
+        when a `hash_val` value is provided, this will warn to explicitly set `hash_type` then choose sha256 hashing.
+        Pass `hash_type="md5"` explicitly to verify against MD5 hashes and suppress the warning. In MONAI 1.8 the
+        default will be set to "sha256".
     """
+    if hash_val is not None and hash_type is None:
+        warn_deprecated(
+            "monai.apps.utils.extractall",
+            'Default `hash_type` value changed to `None` from "md5" in MONAI 1.7, '
+            "set to an explicit value to suppress this warning. Defaulting to sha256 checking. In MONAI 1.8 the "
+            'default will be set to "sha256".',
+            stacklevel=3,
+        )
+        hash_type = "sha256"
+
     filepath = Path(filepath)
     if hash_val and not check_hash(filepath, hash_val, hash_type):
         raise HashCheckError(
@@ -395,7 +430,7 @@ def download_and_extract(
     filepath: PathLike = "",
     output_dir: PathLike = ".",
     hash_val: str | None = None,
-    hash_type: str = "sha256",
+    hash_type: str | None = None,
     file_type: str = "",
     has_base: bool = True,
     progress: bool = True,
@@ -411,7 +446,7 @@ def download_and_extract(
             default is the current directory.
         hash_val: expected hash value to validate the downloaded file.
             if None, skip hash validation.
-        hash_type: type of hash algorithm to use, default is `"sha256"`.
+        hash_type: type of hash algorithm to use, default is None which will select `"sha256"`.
         file_type: string of file type for decompressing. Leave it empty to infer the type from url's base file name.
         has_base: whether the extracted files have a base folder. This flag is used when checking if the existing
             folder is a result of `extractall`, if it is, the extraction is skipped. For example, if A.zip is unzipped

{monai_weekly-1.7.dev2640 → monai_weekly-1.7.dev2642}/monai/data/grid_dataset.py

@@ -257,6 +257,8 @@ class GridPatchDataset(IterableDataset):
             self.first_random = self.patch_transform.get_index_of_first(
                 lambda t: isinstance(t, RandomizableTrait) or not isinstance(t, Transform)
             )
+            if self.first_random is None:
+                self.first_random = len(self.patch_transform.transforms)
 
         if self.cache:
             if isinstance(data, Iterator):
@@ -279,7 +281,11 @@ class GridPatchDataset(IterableDataset):
         self.cache_num = min(int(self.set_num), int(len(mapping) * self.set_rate), len(mapping))
         self._hash_keys = list(mapping)[: self.cache_num]
         indices = list(mapping.values())[: self.cache_num]
-        self._cache, self._cache_other = zip(*self._fill_cache(indices))  # type: ignore
+        cache_items = self._fill_cache(indices)
+        if cache_items:
+            self._cache, self._cache_other = zip(*cache_items)  # type: ignore
+        else:
+            self._cache, self._cache_other = [], []
 
     def _fill_cache(self, indices=None) -> list:
         """
@@ -339,12 +345,9 @@ class GridPatchDataset(IterableDataset):
 
     def __iter__(self):
         if self.cache:
-            cache_index = None
             for image in super().__iter__():
                 key = self.hash_func(image)
-                if key in self._hash_keys:
-                    # if existing in cache, try to get the index in cache
-                    cache_index = self._hash_keys.index(key)
+                cache_index = self._hash_keys.index(key) if key in self._hash_keys else None
                 if cache_index is None:
                     # no cache for this index, execute all the transforms directly
                     yield from self._generate_patches(self.patch_iter(image))
@@ -354,11 +357,11 @@ class GridPatchDataset(IterableDataset):
                             "Cache buffer is not initialized, please call `set_data()` before epoch begins."
                         )
                     data = self._cache[cache_index]
-                    other = self._cache_other[cache_index]
 
                     # load data from cache and execute from the first random transform
                     data = deepcopy(data) if self.copy_cache else data
-                    yield from self._generate_patches(zip(data, other), start=self.first_random)
+                    cached_patches = zip(data, self._cache_other[cache_index]) if self.with_coordinates else zip(data)
+                    yield from self._generate_patches(cached_patches, start=self.first_random)
         else:
             for image in super().__iter__():
                 yield from self._generate_patches(self.patch_iter(image))

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

@@ -28,7 +28,8 @@ def create_test_image_2d(
     num_seg_classes: int = 5,
     channel_dim: int | None = None,
     random_state: np.random.RandomState | None = None,
-) -> tuple[np.ndarray, np.ndarray]:
+    return_instance_id: bool = False,
+) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Return a noisy 2D image with `num_objs` circles and a 2D mask image. The maximum and minimum radii of the circles
     are given as `rad_max` and `rad_min`. The mask will have `num_seg_classes` number of classes for segmentations labeled
@@ -48,9 +49,13 @@ def create_test_image_2d(
         channel_dim: if None, create an image without channel dimension, otherwise create
             an image with channel dimension as first dim or last dim. Defaults to `None`.
         random_state: the random generator to use. Defaults to `np.random`.
+        return_instance_id: if True, also return an instance ID mask where every generated
+            object is assigned a unique positive integer. Later objects overwrite earlier IDs
+            where they overlap, so fully covered objects may not appear in the mask. Defaults to `False`.
 
     Returns:
-        Randomised Numpy array with shape (`height`, `width`)
+        A tuple of image and segmentation label arrays. If `return_instance_id=True`, also returns
+        an instance ID array as the third element.
     """
 
     if rad_max <= rad_min:
@@ -62,9 +67,10 @@ def create_test_image_2d(
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")
 
     image = np.zeros((height, width))
+    instance_ids = np.zeros((height, width), dtype=np.int32) if return_instance_id else None
     rs: np.random.RandomState = np.random.random.__self__ if random_state is None else random_state  # type: ignore
 
-    for _ in range(num_objs):
+    for obj_id in range(1, num_objs + 1):
         x = rs.randint(rad_max, height - rad_max)
         y = rs.randint(rad_max, width - rad_max)
         rad = rs.randint(rad_min, rad_max)
@@ -75,6 +81,8 @@ def create_test_image_2d(
             image[circle] = np.ceil(rs.random() * num_seg_classes)
         else:
             image[circle] = rs.random() * 0.5 + 0.5
+        if instance_ids is not None:
+            instance_ids[circle] = obj_id
 
     labels = np.ceil(image).astype(np.int32, copy=False)
 
@@ -87,10 +95,16 @@ def create_test_image_2d(
         if channel_dim == 0:
             noisyimage = noisyimage[None]
             labels = labels[None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[None]
         else:
             noisyimage = noisyimage[..., None]
             labels = labels[..., None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[..., None]
 
+    if instance_ids is not None:
+        return noisyimage, labels, instance_ids
     return noisyimage, labels
 
 
@@ -105,7 +119,8 @@ def create_test_image_3d(
     num_seg_classes: int = 5,
     channel_dim: int | None = None,
     random_state: np.random.RandomState | None = None,
-) -> tuple[np.ndarray, np.ndarray]:
+    return_instance_id: bool = False,
+) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Return a noisy 3D image and segmentation.
 
@@ -122,9 +137,13 @@ def create_test_image_3d(
         channel_dim: if None, create an image without channel dimension, otherwise create
             an image with channel dimension as first dim or last dim. Defaults to `None`.
         random_state: the random generator to use. Defaults to `np.random`.
+        return_instance_id: if True, also return an instance ID mask where every generated
+            object is assigned a unique positive integer. Later objects overwrite earlier IDs
+            where they overlap, so fully covered objects may not appear in the mask. Defaults to `False`.
 
     Returns:
-        Randomised Numpy array with shape (`height`, `width`, `depth`)
+        A tuple of image and segmentation label arrays. If `return_instance_id=True`, also returns
+        an instance ID array as the third element.
 
     See also:
         :py:meth:`~create_test_image_2d`
@@ -139,9 +158,10 @@ def create_test_image_3d(
         raise ValueError(f"the minimal size {min_size} of the image should be larger than `2 * rad_max` 2x{rad_max}.")
 
     image = np.zeros((height, width, depth))
+    instance_ids = np.zeros((height, width, depth), dtype=np.int32) if return_instance_id else None
     rs: np.random.RandomState = np.random.random.__self__ if random_state is None else random_state  # type: ignore
 
-    for _ in range(num_objs):
+    for obj_id in range(1, num_objs + 1):
         x = rs.randint(rad_max, height - rad_max)
         y = rs.randint(rad_max, width - rad_max)
         z = rs.randint(rad_max, depth - rad_max)
@@ -153,6 +173,8 @@ def create_test_image_3d(
             image[circle] = np.ceil(rs.random() * num_seg_classes)
         else:
             image[circle] = rs.random() * 0.5 + 0.5
+        if instance_ids is not None:
+            instance_ids[circle] = obj_id
 
     labels = np.ceil(image).astype(np.int32, copy=False)
 
@@ -162,8 +184,17 @@ def create_test_image_3d(
     if channel_dim is not None:
         if not (isinstance(channel_dim, int) and channel_dim in (-1, 0, 3)):
             raise AssertionError("invalid channel dim.")
-        noisyimage, labels = (
-            (noisyimage[None], labels[None]) if channel_dim == 0 else (noisyimage[..., None], labels[..., None])
-        )
+        if channel_dim == 0:
+            noisyimage = noisyimage[None]
+            labels = labels[None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[None]
+        else:
+            noisyimage = noisyimage[..., None]
+            labels = labels[..., None]
+            if instance_ids is not None:
+                instance_ids = instance_ids[..., None]
 
+    if instance_ids is not None:
+        return noisyimage, labels, instance_ids
     return noisyimage, labels

{monai_weekly-1.7.dev2640 → monai_weekly-1.7.dev2642}/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.dev2640 → monai_weekly-1.7.dev2642}/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.dev2640 → monai_weekly-1.7.dev2642}/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.dev2640 → monai_weekly-1.7.dev2642}/monai/inferers/merger.py

@@ -307,7 +307,13 @@ class ZarrAvgMerger(Merger):
             self.value_store = zarr.storage.TempStore() if value_store is None else value_store  # type: ignore
             self.count_store = zarr.storage.TempStore() if count_store is None else count_store  # type: ignore
 
-        self.chunks = chunks
+        # zarr 3.3 rejects boolean chunk arguments; `None` there means auto-chunking,
+        # which is what `chunks=True` meant before. On zarr < 3.3 `None` instead means
+        # a single whole-shape chunk, so the substitution must not be applied there.
+        if chunks is True and version_geq(get_package_version("zarr"), "3.3.0"):
+            self.chunks: Sequence[int] | bool | None = None
+        else:
+            self.chunks = chunks
 
         # Initialize codecs/compressor attributes with proper types
         self.codecs: list | None = None

{monai_weekly-1.7.dev2640 → monai_weekly-1.7.dev2642}/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