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

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

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

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

@@ -86,6 +86,7 @@ from .utils.module import load_submodules  # noqa: E402
 # *.so files and folder "_C" may not exist when the cpp extensions are not compiled
 excludes = "|".join(
     [
+        "(.*(nvimgcodec_pydicom_plugin)$)",
         "(^(monai.handlers))",
         "(^(monai.bundle))",
         "(^(monai.fl))",
@@ -136,4 +137,4 @@ except Exception:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "8de81226c971dd27b5826d4bd60849d46aae9ff2"
+__commit_id__ = "4f150a8f26664d1452a8e420d118f4541597f686"

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-10-18T02:14:29+0000",
+ "date": "2026-10-25T02:15:18+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "4835c649a66849125f1e656543264f5fa7d261c0",
- "version": "1.7.dev2642"
+ "full-revisionid": "08aa7d448a8733b13dadffc2f153f7bcb56f41cf",
+ "version": "1.7.dev2643"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/apps/detection/transforms/dictionary.py

@@ -258,7 +258,6 @@ class AffineBoxToImageCoordinated(MapTransform, InvertibleTransform):
     Args:
         box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
         box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
-        remove_empty: whether to remove the boxes that are actually empty
         allow_missing_keys: don't raise exception if key is missing.
         image_meta_key: explicitly indicate the key of the corresponding metadata dictionary.
             for example, for data with key `image`, the metadata by default is in `image_meta_dict`.
@@ -347,7 +346,6 @@ class AffineBoxToWorldCoordinated(AffineBoxToImageCoordinated):
     Args:
         box_keys: Keys to pick box data for transformation. The box mode is assumed to be ``StandardMode``.
         box_ref_image_keys: The single key that represents the reference image to which ``box_keys`` are attached.
-        remove_empty: whether to remove the boxes that are actually empty
         allow_missing_keys: don't raise exception if key is missing.
         image_meta_key: explicitly indicate the key of the corresponding metadata dictionary.
             for example, for data with key `image`, the metadata by default is in `image_meta_dict`.

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/apps/mmars/mmars.py

@@ -9,7 +9,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """
-Utilities for accessing Nvidia MMARs
+Deprecated utilities for accessing Nvidia MMARs. Use MONAI Bundles instead.
 
 See Also:
     - https://docs.nvidia.com/clara/clara-train-sdk/pt/mmar.html
@@ -18,18 +18,13 @@ See Also:
 from __future__ import annotations
 
 import json
-import os
-import warnings
 from collections.abc import Mapping
 from pathlib import Path
 from typing import Any
 
-import torch
-
-import monai.networks.nets as monai_nets
-from monai.apps.utils import download_and_extract, logger
+from monai.apps.utils import download_and_extract
 from monai.config.type_definitions import PathLike
-from monai.networks.utils import copy_model_state
+from monai.utils.deprecate_utils import DeprecatedError, deprecated
 from monai.utils.module import optional_import
 
 from .model_desc import MODEL_DESC
@@ -38,8 +33,21 @@ from .model_desc import RemoteMMARKeys as Keys
 __all__ = ["get_model_spec", "download_mmar", "load_from_mmar"]
 
 
-def get_model_spec(idx: int | str) -> dict | Any:
-    """get model specification by `idx`. `idx` could be index of the constant tuple of dict or the actual model ID."""
+def _get_model_spec(idx: int | str) -> dict | Any:
+    """
+    Look up a model specification without emitting a deprecation warning.
+
+    Args:
+        idx: An index into ``MODEL_DESC`` or a model ID. Negative indices count from the end.
+            Model IDs ignore case and leading or trailing whitespace.
+
+    Returns:
+        The matching model specification. Unknown IDs and inputs other than integers or strings
+        are returned unchanged.
+
+    Raises:
+        IndexError: If an integer index is outside the range of ``MODEL_DESC``.
+    """
     if isinstance(idx, int):
         return MODEL_DESC[idx]
     if isinstance(idx, str):
@@ -50,6 +58,21 @@ def get_model_spec(idx: int | str) -> dict | Any:
     return idx
 
 
+@deprecated(
+    since="1.7.0",
+    removed="1.9.0",
+    msg_suffix="NVIDIA Clara MMAR support is deprecated. Please use MONAI Bundles instead.",
+)
+def get_model_spec(idx: int | str) -> dict | Any:
+    """
+    Get a model specification by index or model ID.
+
+    .. deprecated:: 1.7.0
+        NVIDIA Clara MMAR support will be removed in version 1.9.0. Use MONAI Bundles instead.
+    """
+    return _get_model_spec(idx)
+
+
 def _get_all_ngc_models(pattern, page_index=0, page_size=50):
     url = "https://api.ngc.nvidia.com/v2/search/catalog/resources/MODEL"
     query_dict = {
@@ -99,16 +122,20 @@ def _get_ngc_url(model_name: str, version: str, model_prefix: str = "") -> str:
     return f"https://api.ngc.nvidia.com/v2/models/{model_prefix}{model_name}/versions/{version}/zip"
 
 
-def _get_ngc_doc_url(model_name: str, model_prefix: str = "") -> str:
-    return f"https://ngc.nvidia.com/catalog/models/{model_prefix}{model_name}"
-
-
+@deprecated(
+    since="1.7.0",
+    removed="1.9.0",
+    msg_suffix="NVIDIA Clara MMAR support is deprecated. Please use MONAI Bundles instead.",
+)
 def download_mmar(
     item: str | Mapping, mmar_dir: PathLike | None = None, progress: bool = True, api: bool = True, version: int = -1
 ) -> Path:
     """
     Download and extract Medical Model Archive (MMAR) from Nvidia Clara Train.
 
+    .. deprecated:: 1.7.0
+        NVIDIA Clara MMAR support will be removed in version 1.9.0. Use MONAI Bundles instead.
+
     See Also:
         - https://docs.nvidia.com/clara/
         - Nvidia NGC Registry CLI
@@ -165,7 +192,7 @@ def download_mmar(
         return model_dir_list[0]
 
     if not isinstance(item, Mapping):
-        item = get_model_spec(item)
+        item = _get_model_spec(item)
     ver = item.get(Keys.VERSION, 1)
     if version > 0:
         ver = str(version)
@@ -185,6 +212,11 @@ def download_mmar(
     return model_dir
 
 
+@deprecated(
+    since="1.7.0",
+    removed="1.9.0",
+    msg_suffix="NVIDIA Clara MMAR support is deprecated. Please use MONAI Bundles instead.",
+)
 def load_from_mmar(
     item: Mapping | str | int,
     mmar_dir: PathLike | None = None,
@@ -198,117 +230,31 @@ def load_from_mmar(
     model_file: PathLike | None = None,
 ) -> Any:
     """
-    Download and extract Medical Model Archive (MMAR) model weights from Nvidia Clara Train.
+    Disabled loader for NVIDIA Clara Medical Model Archive (MMAR) models.
+
+    .. deprecated:: 1.7.0
+        Loading MMAR models is disabled for security reasons. This function will be removed
+        in version 1.9.0. Use MONAI Bundles instead.
+
+    Every call raises :class:`monai.utils.DeprecatedError` before downloading or
+    loading a model. The arguments are kept for compatibility and are ignored.
+    Their former meanings are listed below.
 
     Args:
         item: the corresponding model item from `MODEL_DESC`.
-        mmar_dir: : target directory to store the MMAR, default is mmars subfolder under `torch.hub get_dir()`.
+        mmar_dir: target directory to store the MMAR, default is mmars subfolder under `torch.hub get_dir()`.
         progress: whether to display a progress bar when downloading the content.
         version: version number of the MMAR. Set it to `-1` to use `item[Keys.VERSION]`.
         map_location: pytorch API parameter for `torch.load` or `torch.jit.load`.
         pretrained: whether to load the pretrained weights after initializing a network module.
         weights_only: whether to load only the weights instead of initializing the network module and assign weights.
         model_key: a key to search in the model file or config file for the model dictionary.
-            Currently this function assumes that the model dictionary has
+            The model dictionary was expected to have
             `{"[name|path]": "test.module", "args": {'kw': 'test'}}`.
-        api: whether to query NGC API to get model infomation.
+        api: whether to query NGC API to get model information.
         model_file: the relative path to the model file within an MMAR.
 
-    Examples::
-        >>> from monai.apps import load_from_mmar
-        >>> unet_model = load_from_mmar("clara_pt_prostate_mri_segmentation_1", mmar_dir=".", map_location="cpu")
-        >>> print(unet_model)
-
-    See Also:
-        https://docs.nvidia.com/clara/
-    """
-    if api:
-        item = {Keys.NAME: get_model_spec(item)[Keys.NAME] if isinstance(item, int) else f"{item}"}
-    if not isinstance(item, Mapping):
-        item = get_model_spec(item)
-    model_dir = download_mmar(item=item, mmar_dir=mmar_dir, progress=progress, version=version, api=api)
-    if model_file is None:
-        model_file = os.path.join("models", "model.pt")
-    _model_file = model_dir / item.get(Keys.MODEL_FILE, model_file)
-    logger.info(f'\n*** "{item.get(Keys.NAME)}" available at {model_dir}.')
-
-    # loading with `torch.jit.load`
-    if _model_file.name.endswith(".ts"):
-        if not pretrained:
-            warnings.warn("Loading a ScriptModule, 'pretrained' option ignored.")
-        if weights_only:
-            warnings.warn("Loading a ScriptModule, 'weights_only' option ignored.")
-        return torch.jit.load(_model_file, map_location=map_location)
-
-    # loading with `torch.load`
-    model_dict = torch.load(_model_file, map_location=map_location, weights_only=True)
-    if weights_only:
-        return model_dict.get(model_key, model_dict)  # model_dict[model_key] or model_dict directly
-
-    # 1. search `model_dict['train_config]` for model config spec.
-    model_config = _get_val(dict(model_dict).get("train_conf", {}), key=model_key, default={})
-    if not model_config or not isinstance(model_config, Mapping):
-        # 2. search json CONFIG_FILE for model config spec.
-        json_path = model_dir / item.get(Keys.CONFIG_FILE, os.path.join("config", "config_train.json"))
-        with open(json_path) as f:
-            conf_dict = json.load(f)
-        conf_dict = dict(conf_dict)
-        model_config = _get_val(conf_dict, key=model_key, default={})
-    if not model_config:
-        # 3. search `model_dict` for model config spec.
-        model_config = _get_val(dict(model_dict), key=model_key, default={})
-
-    if not (model_config and isinstance(model_config, Mapping)):
-        raise ValueError(
-            f"Could not load model config dictionary from config: {item.get(Keys.CONFIG_FILE)}, "
-            f"or from model file: {item.get(Keys.MODEL_FILE)}."
-        )
-
-    # parse `model_config` for model class and model parameters
-    if model_config.get("name"):  # model config section is a "name"
-        model_name = model_config["name"]
-        model_cls = monai_nets.__dict__[model_name]
-    elif model_config.get("path"):  # model config section is a "path"
-        # https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html
-        model_module, model_name = model_config.get("path", ".").rsplit(".", 1)
-        model_cls, has_cls = optional_import(module=model_module, name=model_name)
-        if not has_cls:
-            raise ValueError(
-                f"Could not load MMAR model config {model_config.get('path', '')}, "
-                f"Please make sure MMAR's sub-folders in '{model_dir}' is on the PYTHONPATH."
-                "See also: https://docs.nvidia.com/clara/clara-train-sdk/pt/byom.html"
-            )
-    else:
-        raise ValueError(f"Could not load model config {model_config}.")
-
-    logger.info(f"*** Model: {model_cls}")
-    model_kwargs = model_config.get("args", None)
-    if model_kwargs:
-        model_inst = model_cls(**model_kwargs)
-        logger.info(f"*** Model params: {model_kwargs}")
-    else:
-        model_inst = model_cls()
-    if pretrained:
-        _, changed, unchanged = copy_model_state(model_inst, model_dict.get(model_key, model_dict), inplace=True)
-        if not (changed and not unchanged):  # not all model_inst variables are changed
-            logger.warning(f"*** Loading model state -- unchanged: {len(unchanged)}, changed: {len(changed)}.")
-    logger.info("\n---")
-    doc_url = item.get(Keys.DOC) or _get_ngc_doc_url(item[Keys.NAME], model_prefix="nvidia:med:")
-    logger.info(f"For more information, please visit {doc_url}\n")
-    return model_inst
-
-
-def _get_val(input_dict: Mapping, key: str = "model", default: Any | None = None) -> Any | None:
-    """
-    Search for the item with `key` in `config_dict`.
-    Returns: the first occurrence of `key` in a breadth first search.
+    Raises:
+        DeprecatedError: always, because MMAR loading is disabled for security reasons.
     """
-    if key in input_dict:
-        return input_dict[key]
-    for sub_dict in input_dict:
-        val = input_dict[sub_dict]
-        if isinstance(val, Mapping):
-            found_val = _get_val(val, key=key, default=None)
-            if found_val is not None:
-                return found_val
-    return default
+    raise DeprecatedError("load_from_mmar is disabled for security reasons. Please use MONAI Bundles instead.")

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/apps/mmars/model_desc.py

@@ -20,19 +20,31 @@ from __future__ import annotations
 import os
 from typing import Any
 
+from monai.utils.deprecate_utils import deprecated
+
 __all__ = ["MODEL_DESC", "RemoteMMARKeys"]
 
 
+@deprecated(
+    since="1.7.0",
+    removed="1.9.0",
+    msg_suffix="NVIDIA Clara MMAR support is deprecated. Please use MONAI Bundles instead.",
+)
 class RemoteMMARKeys:
     """
     Data keys used for loading MMAR.
     ID must uniquely define an MMAR.
+
+    .. deprecated:: 1.7.0
+        NVIDIA Clara MMAR support will be removed in version 1.9.0. Use MONAI Bundles instead.
+        Reading these constants or ``MODEL_DESC`` does not emit a warning; both will be removed
+        with the MMAR module in version 1.9.0.
     """
 
     ID = "id"  # unique MMAR
     NAME = "name"  # MMAR name for readability
     URL = "url"  # remote location of the MMAR, see also: `monai.apps.mmars.mmars._get_ngc_url`
-    DOC = "doc"  # documentation page of the remote model, see also: `monai.apps.mmars.mmars._get_ngc_doc_url`
+    DOC = "doc"  # documentation page of the remote model
     FILE_TYPE = "file_type"  # type of the compressed MMAR
     HASH_TYPE = "hash_type"  # hashing method for the compressed MMAR
     HASH_VAL = "hash_val"  # hashing value for the compressed MMAR

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/apps/pathology/transforms/post/dictionary.py

@@ -178,7 +178,6 @@ class GenerateInstanceBorderd(Transform):
         border_key: the output key where instance border map is written. Defaults to `"border"`.
         kernel_size: the size of the Sobel kernel. Defaults to 21.
         dtype: target data content type to convert, default is np.float32.
-        allow_missing_keys: don't raise exception if key is missing.
 
     Raises:
         ValueError: when the `hover_map` has only one value.
@@ -259,7 +258,6 @@ class GenerateWatershedMarkersd(Transform):
         min_object_size: objects smaller than this size are removed. Defaults to 10.
         postprocess_fn: execute additional post transformation on marker. Defaults to None.
         dtype: target data content type to convert, default is np.uint8.
-        allow_missing_keys: don't raise exception if key is missing.
     """
 
     backend = GenerateWatershedMarkers.backend

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/data/image_reader.py

@@ -1087,7 +1087,7 @@ class NvImgCodecPydicomReader(PydicomReader):
     Load DICOM images using Pydicom with GPU-accelerated decompression via nvImageCodec.
 
     This reader extends :py:class:`PydicomReader` and registers the nvImageCodec pydicom
-    decoder plugin on initialization. The plugin accelerates decoding of compressed pixel data
+    decoder plugin lazily on first use. The plugin accelerates decoding of compressed pixel data
     for JPEG, JPEG 2000, and HTJ2K transfer syntaxes when CUDA, CuPy and ``nvidia-nvimgcodec`` are available.
 
     If nvImageCodec is not available, a warning is issued and the reader falls back to the
@@ -1117,8 +1117,8 @@ class NvImgCodecPydicomReader(PydicomReader):
 
         This reader only declares ``@require_pkg(pkg_name="pydicom")`` so that :py:class:`monai.transforms.LoadImage`
         can register it without hard-failing when GPU dependencies are missing. ``pydicom`` is required to construct
-        the reader; nvimgcodec, CUDA, and CuPy availability is checked at runtime with a warning issued and fallback to
-        default pydicom decoders if missing.
+        the reader; nvImageCodec, CUDA, and CuPy availability is checked when a DICOM file is verified or read.
+        If the plugin is unavailable or registration fails, the reader falls back to the default pydicom decoders.
 
     Args:
         channel_dim: the channel dimension of the input image, default is None.
@@ -1159,6 +1159,14 @@ class NvImgCodecPydicomReader(PydicomReader):
             to_gpu=False,
             **kwargs,
         )
+
+        self._nvimgcodec_available = False
+        self._setup_done = False
+
+    def _ensure_setup(self) -> None:
+        """Import and register the nvImageCodec plugin on first use only."""
+        if self._setup_done:
+            return
         from monai.data.nvimgcodec_pydicom_plugin import is_nvimgcodec_available, register_as_decoder_plugin
 
         self._nvimgcodec_available = is_nvimgcodec_available()
@@ -1167,14 +1175,28 @@ class NvImgCodecPydicomReader(PydicomReader):
                 "NvImgCodecPydicomReader: nvImageCodec decoder plugin did not register successfully. "
                 "Falling back to default pydicom decoders."
             )
+        self._setup_done = True
 
     def verify_suffix(self, filename: Sequence[PathLike] | PathLike) -> bool:
         """
         Verify whether the specified file or files are DICOM and nvImageCodec is available.
         """
-        if not has_pydicom or not self._nvimgcodec_available:
+        if not has_pydicom or not is_dicom_path(filename):
             return False
-        return is_dicom_path(filename)
+        self._ensure_setup()
+        return self._nvimgcodec_available
+
+    def read(self, data: Sequence[PathLike] | PathLike, **kwargs):
+        """Read image data using the configured reader.
+
+        Args:
+            data: Input image data or file path.
+            **kwargs: Additional arguments passed to the underlying reader.
+
+        Returns:
+            The image data returned by the underlying reader."""
+        self._ensure_setup()
+        return super().read(data, **kwargs)
 
 
 @require_pkg(pkg_name="nibabel")

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/data/nvimgcodec_pydicom_plugin.py

@@ -66,7 +66,7 @@ def is_nvimgcodec_available() -> bool:
 def register_as_decoder_plugin(module_path: str | None = None) -> bool:
     """Register the nvImageCodec pydicom decoder plugin."""
     if not is_nvimgcodec_available():
-        _logger.warning("nvImageCodec is not available; skipping pydicom decoder plugin registration.")
+        _logger.debug("nvImageCodec is not available; skipping pydicom decoder plugin registration.")
         return False
     if not has_pydicom_plugin:
         return False

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/inferers/merger.py

@@ -241,6 +241,7 @@ class ZarrAvgMerger(Merger):
             If True, chunk shape will be guessed from `shape` and `dtype`.
             If False, it will be set to `shape`, i.e., single chunk for the whole array.
             If an int, the chunk size in each dimension will be given by the value of `chunks`.
+        thread_locking: whether to use thread locking during aggregation. Default is True.
     """
 
     @deprecated_arg(
@@ -286,24 +287,28 @@ class ZarrAvgMerger(Merger):
         self.value_dtype = value_dtype
         self.count_dtype = count_dtype
         self.store = store
-        self.tmpdir: TemporaryDirectory | None
+        # Use separate tmpdir attributes so both TemporaryDirectory objects remain alive
+        # for the full lifetime of this instance. Previously a single `self.tmpdir` was
+        # overwritten when both value_store and count_store were None, causing the first
+        # TemporaryDirectory to be garbage-collected immediately.
+        self.value_tmpdir: TemporaryDirectory | None = None
+        self.count_tmpdir: TemporaryDirectory | None = None
 
         # Handle zarr v3 vs older versions
         is_zarr_v3 = version_geq(get_package_version("zarr"), "3.0.0")
 
         if is_zarr_v3:
             if value_store is None:
-                self.tmpdir = TemporaryDirectory()
-                self.value_store = zarr.storage.LocalStore(self.tmpdir.name)  # type: ignore
+                self.value_tmpdir = TemporaryDirectory()
+                self.value_store = zarr.storage.LocalStore(self.value_tmpdir.name)  # type: ignore
             else:
                 self.value_store = value_store  # type: ignore
             if count_store is None:
-                self.tmpdir = TemporaryDirectory()
-                self.count_store = zarr.storage.LocalStore(self.tmpdir.name)  # type: ignore
+                self.count_tmpdir = TemporaryDirectory()
+                self.count_store = zarr.storage.LocalStore(self.count_tmpdir.name)  # type: ignore
             else:
                 self.count_store = count_store  # type: ignore
         else:
-            self.tmpdir = None
             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
 
@@ -325,7 +330,6 @@ class ZarrAvgMerger(Merger):
             if codecs is not None:
                 self.codecs = codecs
             elif compressor is not None:
-                # Convert compressor to codec format
                 if isinstance(compressor, (list, tuple)):
                     self.codecs = compressor
                 else:
@@ -354,19 +358,22 @@ class ZarrAvgMerger(Merger):
                 self.count_codecs = None
         else:
             # For zarr v2, use compressors
-            if codecs is not None:
-                # If codecs are specified in v2, use the first codec as compressor
-                self.codecs = codecs[0] if isinstance(codecs, (list, tuple)) else codecs
+            if isinstance(codecs, (list, tuple)):
+                self.codecs = codecs[0] if codecs else None
+            elif codecs is not None:
+                self.codecs = codecs
             else:
                 self.codecs = compressor  # type: ignore[assignment]
-
-            if value_codecs is not None:
-                self.value_codecs = value_codecs[0] if isinstance(value_codecs, (list, tuple)) else value_codecs
+            if isinstance(value_codecs, (list, tuple)):
+                self.value_codecs = value_codecs[0] if value_codecs else None
+            elif value_codecs is not None:
+                self.value_codecs = value_codecs
             else:
                 self.value_codecs = value_compressor  # type: ignore[assignment]
-
-            if count_codecs is not None:
-                self.count_codecs = count_codecs[0] if isinstance(count_codecs, (list, tuple)) else count_codecs
+            if isinstance(count_codecs, (list, tuple)):
+                self.count_codecs = count_codecs[0] if count_codecs else None
+            elif count_codecs is not None:
+                self.count_codecs = count_codecs
             else:
                 self.count_codecs = count_compressor  # type: ignore[assignment]
 

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/metrics/active_learning_metrics.py

@@ -79,8 +79,6 @@ class LabelQualityScore(Metric):
     with uncertainty
     Args:
         include_background: Whether to include the background of the spatial image or channel 0 of the 1-D vector
-        spatial_map: Boolean, if set to True, spatial map of variance will be returned corresponding to i/p image
-        dimensions
         scalar_reduction: reduction type of the metric, either 'sum' or 'mean' can be used
 
     """

{monai_weekly-1.7.dev2642 → monai_weekly-1.7.dev2643}/monai/metrics/confusion_matrix.py

@@ -43,12 +43,18 @@ class ConfusionMatrixMetric(CumulativeIterationMetric):
             ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
             ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
             ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
-            ``"informedness"``, ``"markedness"``]
+            ``"informedness"``, ``"markedness"``, ``"positive likelihood ratio"``,
+            ``"negative likelihood ratio"``, ``"diagnostic odds ratio"``]
             Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
             and you can also input those names instead.
             Except for input only one metric, multiple metrics are also supported via input a sequence of metric names, such as
             ("sensitivity", "precision", "recall"), if ``compute_sample`` is ``True``, multiple ``f`` and ``not_nans`` will be
             returned with the same order as input names when calling the class.
+            Note that for the likelihood-ratio family — ``"positive likelihood ratio"`` (``LR+ = tpr / fpr``),
+            ``"negative likelihood ratio"`` (``LR- = fnr / tnr``) and ``"diagnostic odds ratio"``
+            (``DOR = (tp * tn) / (fp * fn)``) — a zero denominator yields ``NaN`` (e.g. ``LR+`` is undefined
+            when the false positive rate is ``0``, and ``DOR`` when either ``fp`` or ``fn`` is ``0``),
+            following the same convention as the other ratio-based metrics.
         compute_sample: when reducing, if ``True``, each sample's metric will be computed based on each confusion matrix first.
             if ``False``, compute reduction on the confusion matrices first, defaults to ``False``.
         reduction: define mode of reduction to the metrics, will only apply reduction on `not-nan` values,
@@ -63,6 +69,7 @@ class ConfusionMatrixMetric(CumulativeIterationMetric):
             Voxels with this label are excluded from the score, which is useful for padding, unlabeled regions,
             or boundary artifacts. For federated or aggregated settings, ensure all clients use the same
             ignore_index to keep score values comparable.
+            For a single-channel binary target, ignoring channel 0 excludes locations where the target is 1.
 
     """
 
@@ -153,11 +160,19 @@ def get_confusion_matrix(
             The values should be binarized.
         y: ground truth to compute the metric. It must be one-hot format and first dim is batch.
             The values should be binarized.
+            A single channel is a binary membership indicator, not a map of class IDs.
         include_background: whether to include metric computation on the first channel of
             the predicted output. Defaults to True.
         ignore_index: single integer class index (or sentinel value) to ignore from the metric computation.
-            If ignore_index refers to a valid class channel, that channel is excluded. If it is outside the
-            class range, ignored regions are inferred from spatial locations where all label channels are zero.
+            For a valid class index, voxels belonging to that channel are excluded from all classes' counts.
+            The existing channel-exclusion behavior is retained for multi-channel targets. With a single-channel
+            binary target, ignore_index=0 excludes locations where the target is 1 without zeroing the channel.
+            Counts at valid single-channel locations do not depend on include_background. Out-of-range values use all-zero
+            locations for multi-channel targets and direct value comparison for single-channel targets.
+
+    Returns:
+        Tensor of shape [B, C, 4], containing true positive, false positive, true negative, and false negative
+        counts, in that order, for each sample and evaluated channel.
 
     Raises:
         ValueError: when `y_pred` and `y` have different shapes.
@@ -173,17 +188,23 @@ def get_confusion_matrix(
     # get confusion matrix related metric
     batch_size, n_class = y_pred.shape[:2]
 
-    # Create spatial mask if ignore_index is provided
-    if ignore_index is not None and 0 <= ignore_index < (y_pred.shape[1] + (0 if include_background else 1)):
+    # Single-channel targets need spatial exclusion only, preserving errors at valid locations.
+    if (
+        ignore_index is not None
+        and original_y.shape[1] > 1
+        and 0 <= ignore_index < (y_pred.shape[1] + (0 if include_background else 1))
+    ):
         ignore_channel = ignore_index if include_background else ignore_index - 1
         if 0 <= ignore_channel < y_pred.shape[1]:
             y_pred = y_pred.clone()
             y = y.clone()
             y_pred[:, ignore_channel] = 0
             y[:, ignore_channel] = 0
-        mask = None
+    if ignore_index is not None and 0 <= ignore_index < original_y.shape[1]:
+        # Every channel represents binary membership; comparison also supports boolean targets.
+        mask = (original_y[:, ignore_index : ignore_index + 1] == 0).float()
     else:
-        mask = create_ignore_mask(original_y if ignore_index is not None else y, ignore_index)
+        mask = create_ignore_mask(original_y, ignore_index)
 
     # convert to [BNS], where S is the number of pixels for one sample.
     y_pred = y_pred.reshape(batch_size, n_class, -1)
@@ -226,7 +247,8 @@ def compute_confusion_matrix_metric(metric_name: str, confusion_matrix: torch.Te
             ``"miss rate"``, ``"fall out"``, ``"false discovery rate"``, ``"false omission rate"``,
             ``"prevalence threshold"``, ``"threat score"``, ``"accuracy"``, ``"balanced accuracy"``,
             ``"f1 score"``, ``"matthews correlation coefficient"``, ``"fowlkes mallows index"``,
-            ``"informedness"``, ``"markedness"``]
+            ``"informedness"``, ``"markedness"``, ``"positive likelihood ratio"``,
+            ``"negative likelihood ratio"``, ``"diagnostic odds ratio"``]
             Some of the metrics have multiple aliases (as shown in the wikipedia page aforementioned),
             and you can also input those names instead.
         confusion_matrix: Please see the doc string of the function ``get_confusion_matrix`` for more details.
@@ -304,6 +326,19 @@ def compute_confusion_matrix_metric(metric_name: str, confusion_matrix: torch.Te
         npv = torch.where((tn + fn) > 0, tn / (tn + fn), nan_tensor)
         numerator = ppv + npv - 1.0
         denominator = 1.0
+    elif metric == "plr":
+        # LR+ = sensitivity / (1 - specificity) = tpr / fpr; fpr == 0 yields NaN
+        tpr = torch.where(p > 0, tp / p, nan_tensor)
+        fpr = torch.where(n > 0, fp / n, nan_tensor)
+        numerator, denominator = tpr, fpr
+    elif metric == "nlr":
+        # LR- = (1 - sensitivity) / specificity = fnr / tnr; tnr == 0 yields NaN
+        fnr = torch.where(p > 0, fn / p, nan_tensor)
+        tnr = torch.where(n > 0, tn / n, nan_tensor)
+        numerator, denominator = fnr, tnr
+    elif metric == "dor":
+        # DOR = (LR+) / (LR-) = (tp * tn) / (fp * fn); fp * fn == 0 yields NaN
+        numerator, denominator = tp * tn, fp * fn
     else:
         raise NotImplementedError("the metric is not implemented.")
 
@@ -360,4 +395,10 @@ def check_confusion_matrix_metric_name(metric_name: str) -> str:
         return "bm"
     if metric_name in ["markedness", "deltap", "mk"]:
         return "mk"
+    if metric_name in ["positive_likelihood_ratio", "plr", "lr+"]:
+        return "plr"
+    if metric_name in ["negative_likelihood_ratio", "nlr", "lr-"]:
+        return "nlr"
+    if metric_name in ["diagnostic_odds_ratio", "dor"]:
+        return "dor"
     raise NotImplementedError("the metric is not implemented.")