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

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

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

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

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

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

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