monai-weekly 1.7.dev2626__tar.gz → 1.7.dev2627__tar.gz

{monai_weekly-1.7.dev2626/monai_weekly.egg-info → monai_weekly-1.7.dev2627}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monai-weekly
-Version: 1.7.dev2626
+Version: 1.7.dev2627
 Summary: AI Toolkit for Healthcare Imaging
 Home-page: https://project-monai.github.io/
 Author: MONAI Consortium

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/__init__.py

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

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-06-28T03:10:43+0000",
+ "date": "2026-07-05T03:07:50+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "859efd3e7cdbbdf09355d0e91258b5d9c15e2547",
- "version": "1.7.dev2626"
+ "full-revisionid": "9c37af81ef49b616038685d338f97726a0266440",
+ "version": "1.7.dev2627"
 }
 '''  # END VERSION_JSON
 

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/apps/nnunet/nnunetv2_runner.py

@@ -598,7 +598,11 @@ class nnUNetV2Runner:  # noqa: N801
 
         for _key, _value in kwargs.items():
             prefix = "-" if _key in {"p", "pretrained_weights"} else "--"
-            cmd += [f"{prefix}{_key}", str(_value)]
+            if isinstance(_value, bool):
+                if _value:
+                    cmd.append(f"{prefix}{_key}")
+            else:
+                cmd += [f"{prefix}{_key}", str(_value)]
 
         cmd_str: list[str] = [str(c) for c in cmd]
 
@@ -758,7 +762,7 @@ class nnUNetV2Runner:  # noqa: N801
             kwargs: this optional parameter allows you to specify additional arguments defined in the
                 ``train_single_model`` method.
         """
-        self.train_single_model(config=config, fold=fold, only_run_validation=True, **kwargs)
+        self.train_single_model(config=config, fold=fold, val=True, **kwargs)
 
     def validate(
         self, configs: tuple = (M.N_3D_FULLRES, M.N_2D, M.N_3D_LOWRES, M.N_3D_CASCADE_FULLRES), **kwargs: Any

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/apps/nnunet/utils.py

@@ -149,7 +149,6 @@ def create_new_dataset_json(
     """
     new_json_data: dict = {}
 
-    # modality = self.input_info.pop("modality")
     modality = ensure_tuple(modality)  # type: ignore
 
     new_json_data["channel_names"] = {}
@@ -161,18 +160,11 @@ def create_new_dataset_json(
     for _j in range(num_foreground_classes):
         new_json_data["labels"][f"class{_j + 1}"] = _j + 1
 
-    # new_json_data["numTraining"] = len(datalist_json["training"])
     new_json_data["numTraining"] = num_training_data
     new_json_data["file_ending"] = ".nii.gz"
 
     ConfigParser.export_config_file(
-        config=new_json_data,
-        # filepath=os.path.join(raw_data_foldername, "dataset.json"),
-        filepath=output_filepath,
-        fmt="json",
-        sort_keys=True,
-        indent=4,
-        ensure_ascii=False,
+        config=new_json_data, filepath=output_filepath, fmt="json", sort_keys=True, indent=4, ensure_ascii=False
     )
 
     return

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/apps/vista3d/transforms.py

@@ -160,8 +160,6 @@ class VistaPostTransformd(MapTransform):
                     pred = pred.argmax(0).unsqueeze(0).float() + 1.0
                     pred[is_bk] = 0.0
                 else:
-                    # AsDiscrete will remove NaN
-                    # pred = monai.transforms.AsDiscrete(threshold=0.5)(pred)
                     pred[pred > 0] = 1.0
                 if "label_prompt" in data and data["label_prompt"] is not None:
                     pred += 0.5  # inplace mapping to avoid cloning pred

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/auto3dseg/utils.py

@@ -284,7 +284,7 @@ def verify_report_format(report: dict, report_format: dict) -> bool:
 
         if isinstance(v_fmt, list) and isinstance(v, list):
             if len(v_fmt) != 1:
-                raise UserWarning("list length in report_format is not 1")
+                warnings.warn("list length in report_format is not 1", stacklevel=2)
             if len(v_fmt) > 0 and len(v) > 0:
                 return verify_report_format(v[0], v_fmt[0])
             else:

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/data/dataset.py

@@ -210,8 +210,12 @@ class PersistentDataset(Dataset):
 
         Cached data is expected to be tensors, primitives, or dictionaries keying to these values. Numpy arrays will
         be converted to tensors, however any other object type returned by transforms will not be loadable since
-        `torch.load` will be used with `weights_only=True` to prevent loading of potentially malicious objects.
-        Legacy cache files may not be loadable and may need to be recomputed.
+        `torch.load` will be used with `weights_only=True` by default to prevent loading of potentially malicious
+        objects. Legacy cache files may not be loadable and may need to be recomputed. MetaTensor objects can be saved
+        and loaded with their metadata preserved if `track_meta` is True, however the objects stored in the metadata
+        must be acceptable as serialisable by `torch.load` by default or if they have been white-listed with
+        `torch.serialization.add_safe_globals`. Any other object type may be stored but will fail to load and force
+        a cache recompute.
 
     Lazy Resampling:
         If you make use of the lazy resampling feature of `monai.transforms.Compose`, please refer to
@@ -245,8 +249,8 @@ class PersistentDataset(Dataset):
                 may share a common cache dir provided that the transforms pre-processing is consistent.
                 If `cache_dir` doesn't exist, will automatically create it.
                 If `cache_dir` is `None`, there is effectively no caching.
-            hash_func: a callable to compute hash from data items to be cached.
-                defaults to `monai.data.utils.pickle_hashing`.
+            hash_func: a callable to compute hash from data items to be cached, defaults to
+                `monai.data.utils.pickle_hashing` which uses sha256 (previously md5 so old caches will not work).
             pickle_module: string representing the module used for pickling metadata and objects,
                 default to `"pickle"`. due to the pickle limitation in multi-processing of Dataloader,
                 we can't use `pickle` as arg directly, so here we use a string name instead.
@@ -266,17 +270,12 @@ class PersistentDataset(Dataset):
                 When this is enabled, the traced transform instance IDs will be removed from the cached MetaTensors.
                 This is useful for skipping the transform instance checks when inverting applied operations
                 using the cached content and with re-created transform instances.
-            track_meta: whether to track the meta information, if `True`, will convert to `MetaTensor`.
-                default to `False`. Cannot be used with `weights_only=True`.
+            track_meta: whether to track the meta information, defaults to False. If `True`, converts to `MetaTensor`.
             weights_only: keyword argument passed to `torch.load` when reading cached files.
-                default to `True`. When set to `True`, `torch.load` restricts loading to tensors and
-                other safe objects. Setting this to `False` is required for loading `MetaTensor`
-                objects saved with `track_meta=True`, however this creates the possibility of remote
-                code execution through `torch.load` so be aware of the security implications of doing so.
-
-        Raises:
-            ValueError: When both `track_meta=True` and `weights_only=True`, since this combination
-                prevents cached MetaTensors from being reloaded and causes perpetual cache regeneration.
+                default to `True`. When `True`, `torch.load` restricts loading to tensors and other safe objects.
+                Setting to `False` should only be done if it's absolutely necessary to load unsafe pickled data,
+                eg. MetaTensor objects with unsafe objects in their metadata. Users must verify the safety of the data
+                they intend to load before doing so.
         """
         super().__init__(data=data, transform=transform)
         self.cache_dir = Path(cache_dir) if cache_dir is not None else None
@@ -292,11 +291,6 @@ class PersistentDataset(Dataset):
         if hash_transform is not None:
             self.set_transform_hash(hash_transform)
         self.reset_ops_id = reset_ops_id
-        if track_meta and weights_only:
-            raise ValueError(
-                "Invalid argument combination: `track_meta=True` cannot be used with `weights_only=True`. "
-                "To cache and reload MetaTensors, set `track_meta=True` and `weights_only=False`."
-            )
         self.track_meta = track_meta
         self.weights_only = weights_only
 
@@ -390,9 +384,9 @@ class PersistentDataset(Dataset):
         """
         hashfile = None
         if self.cache_dir is not None:
-            data_item_md5 = self.hash_func(item_transformed).decode("utf-8")
-            data_item_md5 += self.transform_hash
-            hashfile = self.cache_dir / f"{data_item_md5}.pt"
+            data_item_hash = self.hash_func(item_transformed).decode("utf-8")
+            data_item_hash += self.transform_hash
+            hashfile = self.cache_dir / f"{data_item_hash}.pt"
 
         if hashfile is not None and hashfile.is_file():  # cache hit
             try:
@@ -1624,9 +1618,9 @@ class GDSDataset(PersistentDataset):
         hashfile = None
         # compute a cache id
         if self.cache_dir is not None:
-            data_item_md5 = self.hash_func(item_transformed).decode("utf-8")
-            data_item_md5 += self.transform_hash
-            hashfile = self.cache_dir / f"{data_item_md5}.pt"
+            data_item_hash = self.hash_func(item_transformed).decode("utf-8")
+            data_item_hash += self.transform_hash
+            hashfile = self.cache_dir / f"{data_item_hash}.pt"
 
         if hashfile is not None and hashfile.is_file():  # cache hit
             with cp.cuda.Device(self.device):

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/data/image_reader.py

@@ -761,10 +761,10 @@ class PydicomReader(ImageReader):
         if "lastImagePositionPatient" in metadata:
             t1n, t2n, t3n = metadata["lastImagePositionPatient"]
             n = metadata[MetaKeys.SPATIAL_SHAPE][-1]
-            k1, k2, k3 = (t1n - sx) / (n - 1), (t2n - sy) / (n - 1), (t3n - sz) / (n - 1)
-            affine[0, 2] = k1
-            affine[1, 2] = k2
-            affine[2, 2] = k3
+            if n > 1:
+                affine[0, 2] = (t1n - sx) / (n - 1)
+                affine[1, 2] = (t2n - sy) / (n - 1)
+                affine[2, 2] = (t3n - sz) / (n - 1)
 
         if lps_to_ras:
             affine = orientation_ras_lps(affine)

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/data/utils.py

@@ -17,7 +17,6 @@ import logging
 import math
 import os
 import pickle
-import sys
 from collections import abc, defaultdict
 from collections.abc import Generator, Iterable, Mapping, Sequence, Sized
 from copy import deepcopy
@@ -1370,13 +1369,8 @@ def json_hashing(item) -> bytes:
 
     """
     # TODO: Find way to hash transforms content as part of the cache
-    cache_key = ""
-    if sys.version_info.minor < 9:
-        cache_key = hashlib.md5(json.dumps(item, sort_keys=True).encode("utf-8")).hexdigest()
-    else:
-        cache_key = hashlib.md5(
-            json.dumps(item, sort_keys=True).encode("utf-8"), usedforsecurity=False  # type: ignore
-        ).hexdigest()
+    dump = json.dumps(item, sort_keys=True).encode("utf-8")
+    cache_key = hashlib.sha256(dump, usedforsecurity=False).hexdigest()  # type: ignore
     return f"{cache_key}".encode()
 
 
@@ -1391,13 +1385,8 @@ def pickle_hashing(item, protocol=pickle.HIGHEST_PROTOCOL) -> bytes:
     Returns: the corresponding hash key
 
     """
-    cache_key = ""
-    if sys.version_info.minor < 9:
-        cache_key = hashlib.md5(pickle.dumps(sorted_dict(item), protocol=protocol)).hexdigest()
-    else:
-        cache_key = hashlib.md5(
-            pickle.dumps(sorted_dict(item), protocol=protocol), usedforsecurity=False  # type: ignore
-        ).hexdigest()
+    dump = pickle.dumps(sorted_dict(item), protocol=protocol)
+    cache_key = hashlib.sha256(dump, usedforsecurity=False).hexdigest()  # type: ignore
     return f"{cache_key}".encode()
 
 

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/inferers/merger.py

@@ -309,9 +309,6 @@ class ZarrAvgMerger(Merger):
 
         self.chunks = chunks
 
-        # Handle compressor/codecs based on zarr version
-        is_zarr_v3 = version_geq(get_package_version("zarr"), "3.0.0")
-
         # Initialize codecs/compressor attributes with proper types
         self.codecs: list | None = None
         self.value_codecs: list | None = None

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/losses/deform.py

@@ -44,9 +44,58 @@ def spatial_gradient(x: torch.Tensor, dim: int) -> torch.Tensor:
     return (x[slicing_s] - x[slicing_e]) / 2.0
 
 
+def spatial_gradient_squared(x: torch.Tensor, dim_1: int, dim_2: int) -> torch.Tensor:
+    """
+    Calculate the second-order partial derivative of ``x`` with respect to spatial dims
+    ``dim_1`` and ``dim_2`` using compact central finite differences.
+
+    For ``dim_1 == dim_2`` the pure second derivative uses the ``[1, -2, 1]`` stencil:
+    ``d2x[i] = x[i+1] - 2 * x[i] + x[i-1]``.
+
+    For ``dim_1 != dim_2`` the mixed partial uses the compact 4-point stencil:
+    ``d2x[i, j] = (x[i+1, j+1] - x[i+1, j-1] - x[i-1, j+1] + x[i-1, j-1]) / 4``.
+
+    Every spatial dimension is sliced to ``[1:-1]`` so the output shape is independent of
+    ``(dim_1, dim_2)``; this lets terms be summed together. Requires ``x.shape[d] > 2``
+    for every spatial dim ``d``.
+
+    Args:
+        x: the shape should be BCH(WD).
+        dim_1: first spatial dimension index.
+        dim_2: second spatial dimension index.
+
+    Returns:
+        Tensor with batch and channel axes preserved and every spatial axis sliced to
+        ``[1:-1]``.
+    """
+    slice_inner = slice(1, -1)
+    slice_plus = slice(2, None)
+    slice_minus = slice(None, -2)
+    slice_all = slice(None)
+
+    def _idx(overrides: dict) -> list:
+        out: list = [slice_all, slice_all]
+        for d in range(2, x.ndim):
+            out.append(overrides.get(d, slice_inner))
+        return out
+
+    if dim_1 == dim_2:
+        return x[_idx({dim_1: slice_plus})] - 2 * x[_idx({})] + x[_idx({dim_1: slice_minus})]
+    return (
+        x[_idx({dim_1: slice_plus, dim_2: slice_plus})]
+        - x[_idx({dim_1: slice_plus, dim_2: slice_minus})]
+        - x[_idx({dim_1: slice_minus, dim_2: slice_plus})]
+        + x[_idx({dim_1: slice_minus, dim_2: slice_minus})]
+    ) / 4.0
+
+
 class BendingEnergyLoss(_Loss):
     """
-    Calculate the bending energy based on second-order differentiation of ``pred`` using central finite difference.
+    Calculate the bending energy based on second-order differentiation of ``pred``.
+
+    Pure second derivatives use the compact ``[1, -2, 1]`` stencil; mixed partials use a
+    compact 4-point central scheme. Both span three voxels per axis, so each spatial
+    dimension of ``pred`` only needs to be greater than 2.
 
     For more information,
     see https://github.com/Project-MONAI/tutorials/blob/main/modules/bending_energy_diffusion_loss_notes.ipynb.
@@ -79,41 +128,41 @@ class BendingEnergyLoss(_Loss):
         Raises:
             ValueError: When ``self.reduction`` is not one of ["mean", "sum", "none"].
             ValueError: When ``pred`` is not 3-d, 4-d or 5-d.
-            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 4.
+            ValueError: When any spatial dimension of ``pred`` has size less than or equal to 2.
             ValueError: When the number of channels of ``pred`` does not match the number of spatial dimensions.
 
         """
         if pred.ndim not in [3, 4, 5]:
             raise ValueError(f"Expecting 3-d, 4-d or 5-d pred, instead got pred of shape {pred.shape}")
         for i in range(pred.ndim - 2):
-            if pred.shape[-i - 1] <= 4:
-                raise ValueError(f"All spatial dimensions must be > 4, got spatial dimensions {pred.shape[2:]}")
+            if pred.shape[-i - 1] <= 2:
+                raise ValueError(f"All spatial dimensions must be > 2, got spatial dimensions {pred.shape[2:]}")
         if pred.shape[1] != pred.ndim - 2:
             raise ValueError(
                 f"Number of vector components, i.e. number of channels of the input DDF, {pred.shape[1]}, "
                 f"does not match number of spatial dimensions, {pred.ndim - 2}"
             )
 
-        # first order gradient
-        first_order_gradient = [spatial_gradient(pred, dim) for dim in range(2, pred.ndim)]
-
         # spatial dimensions in a shape suited for broadcasting below
         if self.normalize:
             spatial_dims = torch.tensor(pred.shape, device=pred.device)[2:].reshape((1, -1) + (pred.ndim - 2) * (1,))
 
-        energy = torch.tensor(0)
-        for dim_1, g in enumerate(first_order_gradient):
-            dim_1 += 2
+        # Initialize on pred.device so a GPU `pred` does not get added to a CPU
+        # accumulator, and as a float so an integer-dtype `pred` still produces a
+        # floating-point energy (the compact pure-derivative stencil has no
+        # division, so a Long input would otherwise propagate as Long and fail
+        # `torch.mean` at the reduction step).
+        energy = torch.tensor(0.0, device=pred.device)
+        for dim_1 in range(2, pred.ndim):
+            d2 = spatial_gradient_squared(pred, dim_1, dim_1)
             if self.normalize:
-                g *= pred.shape[dim_1] / spatial_dims
-                energy = energy + (spatial_gradient(g, dim_1) * pred.shape[dim_1]) ** 2
-            else:
-                energy = energy + spatial_gradient(g, dim_1) ** 2
+                d2 = d2 * (pred.shape[dim_1] ** 2 / spatial_dims)
+            energy = energy + d2**2
             for dim_2 in range(dim_1 + 1, pred.ndim):
+                d2_mixed = spatial_gradient_squared(pred, dim_1, dim_2)
                 if self.normalize:
-                    energy = energy + 2 * (spatial_gradient(g, dim_2) * pred.shape[dim_2]) ** 2
-                else:
-                    energy = energy + 2 * spatial_gradient(g, dim_2) ** 2
+                    d2_mixed = d2_mixed * (pred.shape[dim_1] * pred.shape[dim_2] / spatial_dims)
+                energy = energy + 2 * d2_mixed**2
 
         if self.reduction == LossReduction.MEAN.value:
             energy = torch.mean(energy)  # the batch and channel average

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/losses/image_dissimilarity.py

@@ -232,7 +232,6 @@ class GlobalMutualInformationLoss(_Loss):
         sigma = torch.mean(bin_centers[1:] - bin_centers[:-1]) * sigma_ratio
         self.kernel_type = look_up_option(kernel_type, ["gaussian", "b-spline"])
         self.num_bins = num_bins
-        self.kernel_type = kernel_type
         # declared as buffers so they move with the module (e.g. ``.to(device)``); only populated for the
         # gaussian kernel, hence the ``Tensor`` annotation reflects the type at the use sites in that path.
         self.preterm: torch.Tensor | None

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/losses/nacl_loss.py

@@ -138,7 +138,7 @@ class NACLLoss(_Loss):
         if self.distance_type == "l1":
             loss_conf = utargets.sub(inputs).abs_().mean()
         elif self.distance_type == "l2":
-            loss_conf = utargets.sub(inputs).pow_(2).abs_().mean()
+            loss_conf = utargets.sub(inputs).pow_(2).mean()
 
         loss: torch.Tensor = loss_ce + self.alpha * loss_conf
 

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/metrics/__init__.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+from .absolute_volume_difference import AbsoluteVolumeDifferenceMetric, compute_absolute_volume_difference
 from .active_learning_metrics import LabelQualityScore, VarianceMetric, compute_variance, label_quality_score
 from .average_precision import AveragePrecisionMetric, compute_average_precision
 from .calibration import CalibrationErrorMetric, CalibrationReduction, calibration_binning

monai_weekly-1.7.dev2627/monai/metrics/absolute_volume_difference.py

@@ -0,0 +1,180 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import torch
+
+from monai.metrics.utils import do_metric_reduction, ignore_background
+from monai.utils import MetricReduction
+
+from .metric import CumulativeIterationMetric
+
+__all__ = ["AbsoluteVolumeDifferenceMetric", "compute_absolute_volume_difference"]
+
+
+class AbsoluteVolumeDifferenceMetric(CumulativeIterationMetric):
+    """
+    Compute the Absolute Volume Difference (AVD) between predicted and ground-truth
+    segmentation masks.
+
+    AVD measures the absolute difference in the number of foreground voxels between
+    prediction and ground truth, per class.  It is particularly useful for small-object
+    segmentation (e.g. retinal fluid in OCT volumes) where Dice score is known to be
+    overly sensitive to volume size and does not directly reflect volume discrepancies.
+
+    .. note::
+        For 2D inputs this computes the difference in foreground **areas** rather than
+        volumes.  In all cases the returned values are raw voxel/pixel counts and are
+        **not** scaled by the voxel/pixel spacing, so they are not expressed in the
+        physical units of the original image.
+
+    Reference:
+        Bogunovic et al. (2019). RETOUCH: The Retinal OCT Fluid Detection and
+        Segmentation Benchmark and Challenge.
+        IEEE Transactions on Medical Imaging, 38(8), 1858-1874.
+        https://ieeexplore.ieee.org/document/8653407
+
+    The inputs ``y_pred`` and ``y`` are expected to be binarized one-hot tensors with
+    shape BCHW[D].  If they contain continuous values (e.g. sigmoid outputs), binarize
+    them first with a suitable threshold transform.
+
+    The typical execution steps of this metric class follow
+    :py:class:`monai.metrics.metric.Cumulative`.
+
+    Example:
+
+    .. code-block:: python
+
+        import torch
+        from monai.metrics import AbsoluteVolumeDifferenceMetric
+
+        batch_size, n_classes = 4, 3
+        y_pred = torch.randint(0, 2, (batch_size, n_classes, 64, 64, 32)).float()
+        y      = torch.randint(0, 2, (batch_size, n_classes, 64, 64, 32)).float()
+
+        metric = AbsoluteVolumeDifferenceMetric(include_background=False)
+        metric(y_pred, y)                 # accumulate
+        result = metric.aggregate()       # shape: (n_classes - 1,) after mean reduction
+        metric.reset()
+
+    Args:
+        include_background: whether to include AVD computation on the first channel
+            (index 0), which is by convention assumed to be background.  Defaults to
+            ``True``.  Set to ``False`` when the background class dominates and you only
+            care about foreground classes (e.g. fluid sub-types in OCT).
+        reduction: defines how to aggregate per-batch-per-class results.  Available
+            modes are enumerated in :py:class:`monai.utils.enums.MetricReduction`.
+            Defaults to ``"mean"``.
+        get_not_nans: if ``True``, :meth:`aggregate` returns ``(metric, not_nans)``
+            where ``not_nans`` counts the number of valid (non-NaN) values.
+            Defaults to ``False``.
+        ignore_empty: if ``True``, cases where the ground-truth channel is entirely
+            empty (zero voxels) are excluded from aggregation by setting their value
+            to ``NaN``.  If ``False``, the raw absolute difference (equal to the
+            predicted volume for that class) is returned.  Defaults to ``True``.
+    """
+
+    def __init__(
+        self,
+        include_background: bool = True,
+        reduction: MetricReduction | str = MetricReduction.MEAN,
+        get_not_nans: bool = False,
+        ignore_empty: bool = True,
+    ) -> None:
+        super().__init__()
+        self.include_background = include_background
+        self.reduction = reduction
+        self.get_not_nans = get_not_nans
+        self.ignore_empty = ignore_empty
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> torch.Tensor:  # type: ignore[override]
+        """
+        Args:
+            y_pred: binarized prediction tensor, shape BCHW[D].
+            y: binarized ground-truth tensor, shape BCHW[D].
+
+        Raises:
+            ValueError: when ``y_pred`` has fewer than three dimensions.
+        """
+        if y_pred.ndimension() < 3:
+            raise ValueError(
+                f"y_pred should have at least 3 dimensions (batch, channel, spatial), got {y_pred.ndimension()}."
+            )
+        return compute_absolute_volume_difference(
+            y_pred=y_pred, y=y, include_background=self.include_background, ignore_empty=self.ignore_empty
+        )
+
+    def aggregate(
+        self, reduction: MetricReduction | str | None = None
+    ) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor]:
+        """
+        Execute reduction logic for the accumulated AVD values.
+
+        Args:
+            reduction: optional override for the reduction mode set at construction.
+        """
+        data = self.get_buffer()
+        if not isinstance(data, torch.Tensor):
+            raise ValueError("the data to aggregate must be a PyTorch Tensor.")
+
+        f, not_nans = do_metric_reduction(data, reduction or self.reduction)
+        return (f, not_nans) if self.get_not_nans else f
+
+
+def compute_absolute_volume_difference(
+    y_pred: torch.Tensor, y: torch.Tensor, include_background: bool = True, ignore_empty: bool = True
+) -> torch.Tensor:
+    """
+    Compute the Absolute Volume Difference (AVD) for a batch of segmentation predictions.
+
+    AVD is defined per class as::
+
+        AVD_c = | sum_{spatial}(y_pred_c) - sum_{spatial}(y_c) |
+
+    where the sum counts the number of foreground voxels in each channel.
+
+    Args:
+        y_pred: binarized prediction tensor with shape BCHW[D].
+        y: binarized ground-truth tensor with shape BCHW[D].
+        include_background: whether to include the first channel (background).
+            Defaults to ``True``.
+        ignore_empty: if ``True``, entries where the ground-truth channel contains no
+            foreground voxels are set to ``NaN`` so they are excluded during reduction.
+            Defaults to ``True``.
+
+    Returns:
+        AVD per batch item and per class, shape ``[batch_size, num_classes]``.
+
+    Raises:
+        ValueError: when ``y_pred`` and ``y`` have different shapes.
+    """
+    if y_pred.ndim < 3:
+        raise ValueError(f"y_pred should have at least 3 dimensions (batch, channel, spatial), got {y_pred.ndim}.")
+
+    if not include_background:
+        y_pred, y = ignore_background(y_pred=y_pred, y=y)
+
+    if y_pred.shape != y.shape:
+        raise ValueError(f"y_pred and y should have the same shape, got {y_pred.shape} and {y.shape}.")
+
+    # sum over all spatial dimensions; keep batch (dim 0) and channel (dim 1)
+    reduce_axis = list(range(2, y_pred.ndim))
+    vol_pred = torch.sum(y_pred, dim=reduce_axis)  # [B, C]
+    vol_true = torch.sum(y, dim=reduce_axis)  # [B, C]
+
+    avd = torch.abs(vol_pred - vol_true)  # [B, C]
+
+    if ignore_empty:
+        # mark cases with no ground-truth foreground as NaN
+        avd = torch.where(vol_true > 0, avd, torch.tensor(float("nan"), device=avd.device))
+
+    return avd

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/metrics/froc.py

@@ -11,7 +11,7 @@
 
 from __future__ import annotations
 
-from typing import Any, cast
+from typing import Any
 
 import numpy as np
 import torch
@@ -67,12 +67,14 @@ def compute_fp_tp_probs_nd(
 
     hittedlabel = evaluation_mask[tuple(coords.T)]
     fp_probs = probs[np.where(hittedlabel == 0)]
+    num_targets = 0
     for i in range(1, max_label + 1):
-        if i not in labels_to_exclude and i in hittedlabel:
-            tp_probs[i - 1] = probs[np.where(hittedlabel == i)].max()
+        if i not in labels_to_exclude:
+            num_targets += 1
+            if i in hittedlabel:
+                tp_probs[i - 1] = probs[np.where(hittedlabel == i)].max()
 
-    num_targets = max_label - len(labels_to_exclude)
-    return fp_probs, tp_probs, cast(int, num_targets)
+    return fp_probs, tp_probs, num_targets
 
 
 def compute_fp_tp_probs(

{monai_weekly-1.7.dev2626 → monai_weekly-1.7.dev2627}/monai/metrics/generalized_dice.py

@@ -181,7 +181,6 @@ def compute_generalized_dice(
     else:
         numer = 2.0 * (intersection * w)
         denom = denominator * w
-        y_pred_o = y_pred_o
 
     # Compute the score
     generalized_dice_score = numer / denom