monai-weekly 1.5.dev2507__py3-none-any.whl → 1.5.dev2508__py3-none-any.whl

monai/__init__.py

@@ -136,4 +136,4 @@ except BaseException:
 
     if MONAIEnvVars.debug():
         raise
-__commit_id__ = "44add8d134f0cf0df6e4b0f5ffdd710474d211e5"
+__commit_id__ = "a7905909e785d1ef24103c32a2d3a5a36e1059a2"

monai/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-02-16T02:27:59+0000",
+ "date": "2025-02-23T02:28:09+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "bbd080bb9d263c06a0884a871b645a434e3d4cdd",
- "version": "1.5.dev2507"
+ "full-revisionid": "e55b5cbfbbba1800a968a9c06b2deaaa5c9bec54",
+ "version": "1.5.dev2508"
 }
 '''  # END VERSION_JSON
 

monai/handlers/__init__.py

@@ -11,6 +11,7 @@
 
 from __future__ import annotations
 
+from .average_precision import AveragePrecision
 from .checkpoint_loader import CheckpointLoader
 from .checkpoint_saver import CheckpointSaver
 from .classification_saver import ClassificationSaver

monai/handlers/average_precision.py

@@ -0,0 +1,53 @@
+# 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
+
+from collections.abc import Callable
+
+from monai.handlers.ignite_metric import IgniteMetricHandler
+from monai.metrics import AveragePrecisionMetric
+from monai.utils import Average
+
+
+class AveragePrecision(IgniteMetricHandler):
+    """
+    Computes Average Precision (AP).
+    accumulating predictions and the ground-truth during an epoch and applying `compute_average_precision`.
+
+    Args:
+        average: {``"macro"``, ``"weighted"``, ``"micro"``, ``"none"``}
+            Type of averaging performed if not binary classification. Defaults to ``"macro"``.
+
+            - ``"macro"``: calculate metrics for each label, and find their unweighted mean.
+                This does not take label imbalance into account.
+            - ``"weighted"``: calculate metrics for each label, and find their average,
+                weighted by support (the number of true instances for each label).
+            - ``"micro"``: calculate metrics globally by considering each element of the label
+                indicator matrix as a label.
+            - ``"none"``: the scores for each class are returned.
+
+        output_transform: callable to extract `y_pred` and `y` from `ignite.engine.state.output` then
+            construct `(y_pred, y)` pair, where `y_pred` and `y` can be `batch-first` Tensors or
+            lists of `channel-first` Tensors. the form of `(y_pred, y)` is required by the `update()`.
+            `engine.state` and `output_transform` inherit from the ignite concept:
+            https://pytorch.org/ignite/concepts.html#state, explanation and usage example are in the tutorial:
+            https://github.com/Project-MONAI/tutorials/blob/master/modules/batch_output_transform.ipynb.
+
+    Note:
+        Average Precision expects y to be comprised of 0's and 1's.
+        y_pred must either be probability estimates or confidence values.
+
+    """
+
+    def __init__(self, average: Average | str = Average.MACRO, output_transform: Callable = lambda x: x) -> None:
+        metric_fn = AveragePrecisionMetric(average=Average(average))
+        super().__init__(metric_fn=metric_fn, output_transform=output_transform, save_details=False)

monai/inferers/inferer.py

@@ -1202,15 +1202,16 @@ class LatentDiffusionInferer(DiffusionInferer):
 
         if self.autoencoder_latent_shape is not None:
             latent = torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(latent)], 0)
-            latent_intermediates = [
-                torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(l)], 0) for l in latent_intermediates
-            ]
+            if save_intermediates:
+                latent_intermediates = [
+                    torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(l)], 0)
+                    for l in latent_intermediates
+                ]
 
         decode = autoencoder_model.decode_stage_2_outputs
         if isinstance(autoencoder_model, SPADEAutoencoderKL):
             decode = partial(autoencoder_model.decode_stage_2_outputs, seg=seg)
         image = decode(latent / self.scale_factor)
-
         if save_intermediates:
             intermediates = []
             for latent_intermediate in latent_intermediates:
@@ -1727,9 +1728,11 @@ class ControlNetLatentDiffusionInferer(ControlNetDiffusionInferer):
 
         if self.autoencoder_latent_shape is not None:
             latent = torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(latent)], 0)
-            latent_intermediates = [
-                torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(l)], 0) for l in latent_intermediates
-            ]
+            if save_intermediates:
+                latent_intermediates = [
+                    torch.stack([self.autoencoder_resizer(i) for i in decollate_batch(l)], 0)
+                    for l in latent_intermediates
+                ]
 
         decode = autoencoder_model.decode_stage_2_outputs
         if isinstance(autoencoder_model, SPADEAutoencoderKL):

monai/metrics/__init__.py

@@ -12,6 +12,7 @@
 from __future__ import annotations
 
 from .active_learning_metrics import LabelQualityScore, VarianceMetric, compute_variance, label_quality_score
+from .average_precision import AveragePrecisionMetric, compute_average_precision
 from .confusion_matrix import ConfusionMatrixMetric, compute_confusion_matrix_metric, get_confusion_matrix
 from .cumulative_average import CumulativeAverage
 from .f_beta_score import FBetaScore

monai/metrics/average_precision.py

@@ -0,0 +1,187 @@
+# 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 warnings
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+
+import torch
+
+from monai.utils import Average, look_up_option
+
+from .metric import CumulativeIterationMetric
+
+
+class AveragePrecisionMetric(CumulativeIterationMetric):
+    """
+    Computes Average Precision (AP). AP is a useful metric to evaluate a classifier when the classes are
+    imbalanced. It can take values between 0.0 and 1.0, 1.0 being the best possible score.
+    It summarizes a Precision-Recall curve as the weighted mean of precisions achieved at each
+    threshold, with the increase in recall from the previous threshold used as the weight:
+
+    .. math::
+        \\text{AP} = \\sum_n (R_n - R_{n-1}) P_n
+        :label: ap
+
+    where :math:`P_n` and :math:`R_n` are the precision and recall at the :math:`n^{th}` threshold.
+
+    Referring to: `sklearn.metrics.average_precision_score
+    <https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score>`_.
+
+    The input `y_pred` and `y` can be a list of `channel-first` Tensor or a `batch-first` Tensor.
+
+    Example of the typical execution steps of this metric class follows :py:class:`monai.metrics.metric.Cumulative`.
+
+    Args:
+        average: {``"macro"``, ``"weighted"``, ``"micro"``, ``"none"``}
+            Type of averaging performed if not binary classification.
+            Defaults to ``"macro"``.
+
+            - ``"macro"``: calculate metrics for each label, and find their unweighted mean.
+                This does not take label imbalance into account.
+            - ``"weighted"``: calculate metrics for each label, and find their average,
+                weighted by support (the number of true instances for each label).
+            - ``"micro"``: calculate metrics globally by considering each element of the label
+                indicator matrix as a label.
+            - ``"none"``: the scores for each class are returned.
+
+    """
+
+    def __init__(self, average: Average | str = Average.MACRO) -> None:
+        super().__init__()
+        self.average = average
+
+    def _compute_tensor(self, y_pred: torch.Tensor, y: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:  # type: ignore[override]
+        return y_pred, y
+
+    def aggregate(self, average: Average | str | None = None) -> np.ndarray | float | npt.ArrayLike:
+        """
+        Typically `y_pred` and `y` are stored in the cumulative buffers at each iteration,
+        This function reads the buffers and computes the Average Precision.
+
+        Args:
+            average: {``"macro"``, ``"weighted"``, ``"micro"``, ``"none"``}
+                Type of averaging performed if not binary classification. Defaults to `self.average`.
+
+        """
+        y_pred, y = self.get_buffer()
+        # compute final value and do metric reduction
+        if not isinstance(y_pred, torch.Tensor) or not isinstance(y, torch.Tensor):
+            raise ValueError("y_pred and y must be PyTorch Tensor.")
+
+        return compute_average_precision(y_pred=y_pred, y=y, average=average or self.average)
+
+
+def _calculate(y_pred: torch.Tensor, y: torch.Tensor) -> float:
+    if not (y.ndimension() == y_pred.ndimension() == 1 and len(y) == len(y_pred)):
+        raise AssertionError("y and y_pred must be 1 dimension data with same length.")
+    y_unique = y.unique()
+    if len(y_unique) == 1:
+        warnings.warn(f"y values can not be all {y_unique.item()}, skip AP computation and return `Nan`.")
+        return float("nan")
+    if not y_unique.equal(torch.tensor([0, 1], dtype=y.dtype, device=y.device)):
+        warnings.warn(f"y values must be 0 or 1, but in {y_unique.tolist()}, skip AP computation and return `Nan`.")
+        return float("nan")
+
+    n = len(y)
+    indices = y_pred.argsort(descending=True)
+    y = y[indices].cpu().numpy()  # type: ignore[assignment]
+    y_pred = y_pred[indices].cpu().numpy()  # type: ignore[assignment]
+    npos = ap = tmp_pos = 0.0
+
+    for i in range(n):
+        y_i = cast(float, y[i])
+        if i + 1 < n and y_pred[i] == y_pred[i + 1]:
+            tmp_pos += y_i
+        else:
+            tmp_pos += y_i
+            npos += tmp_pos
+            ap += tmp_pos * npos / (i + 1)
+            tmp_pos = 0
+
+    return ap / npos
+
+
+def compute_average_precision(
+    y_pred: torch.Tensor, y: torch.Tensor, average: Average | str = Average.MACRO
+) -> np.ndarray | float | npt.ArrayLike:
+    """Computes Average Precision (AP). AP is a useful metric to evaluate a classifier when the classes are
+    imbalanced. It summarizes a Precision-Recall according to equation :eq:`ap`.
+    Referring to: `sklearn.metrics.average_precision_score
+    <https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score>`_.
+
+    Args:
+        y_pred: input data to compute, typical classification model output.
+            the first dim must be batch, if multi-classes, it must be in One-Hot format.
+            for example: shape `[16]` or `[16, 1]` for a binary data, shape `[16, 2]` for 2 classes data.
+        y: ground truth to compute AP metric, the first dim must be batch.
+            if multi-classes, it must be in One-Hot format.
+            for example: shape `[16]` or `[16, 1]` for a binary data, shape `[16, 2]` for 2 classes data.
+        average: {``"macro"``, ``"weighted"``, ``"micro"``, ``"none"``}
+            Type of averaging performed if not binary classification.
+            Defaults to ``"macro"``.
+
+            - ``"macro"``: calculate metrics for each label, and find their unweighted mean.
+                This does not take label imbalance into account.
+            - ``"weighted"``: calculate metrics for each label, and find their average,
+                weighted by support (the number of true instances for each label).
+            - ``"micro"``: calculate metrics globally by considering each element of the label
+                indicator matrix as a label.
+            - ``"none"``: the scores for each class are returned.
+
+    Raises:
+        ValueError: When ``y_pred`` dimension is not one of [1, 2].
+        ValueError: When ``y`` dimension is not one of [1, 2].
+        ValueError: When ``average`` is not one of ["macro", "weighted", "micro", "none"].
+
+    Note:
+        Average Precision expects y to be comprised of 0's and 1's. `y_pred` must be either prob. estimates or confidence values.
+
+    """
+    y_pred_ndim = y_pred.ndimension()
+    y_ndim = y.ndimension()
+    if y_pred_ndim not in (1, 2):
+        raise ValueError(
+            f"Predictions should be of shape (batch_size, num_classes) or (batch_size, ), got {y_pred.shape}."
+        )
+    if y_ndim not in (1, 2):
+        raise ValueError(f"Targets should be of shape (batch_size, num_classes) or (batch_size, ), got {y.shape}.")
+    if y_pred_ndim == 2 and y_pred.shape[1] == 1:
+        y_pred = y_pred.squeeze(dim=-1)
+        y_pred_ndim = 1
+    if y_ndim == 2 and y.shape[1] == 1:
+        y = y.squeeze(dim=-1)
+
+    if y_pred_ndim == 1:
+        return _calculate(y_pred, y)
+
+    if y.shape != y_pred.shape:
+        raise ValueError(f"data shapes of y_pred and y do not match, got {y_pred.shape} and {y.shape}.")
+
+    average = look_up_option(average, Average)
+    if average == Average.MICRO:
+        return _calculate(y_pred.flatten(), y.flatten())
+    y, y_pred = y.transpose(0, 1), y_pred.transpose(0, 1)
+    ap_values = [_calculate(y_pred_, y_) for y_pred_, y_ in zip(y_pred, y)]
+    if average == Average.NONE:
+        return ap_values
+    if average == Average.MACRO:
+        return np.mean(ap_values)
+    if average == Average.WEIGHTED:
+        weights = [sum(y_) for y_ in y]
+        return np.average(ap_values, weights=weights)  # type: ignore[no-any-return]
+    raise ValueError(f'Unsupported average: {average}, available options are ["macro", "weighted", "micro", "none"].')

monai/transforms/utility/array.py

@@ -66,7 +66,6 @@ from monai.utils import (
     optional_import,
 )
 from monai.utils.enums import TransformBackends
-from monai.utils.misc import is_module_ver_at_least
 from monai.utils.type_conversion import convert_to_dst_type, get_dtype_string, get_equivalent_dtype
 
 PILImageImage, has_pil = optional_import("PIL.Image", name="Image")
@@ -939,19 +938,10 @@ class LabelToMask(Transform):
             data = img[[*select_labels]]
         else:
             where: Callable = np.where if isinstance(img, np.ndarray) else torch.where  # type: ignore
-            if isinstance(img, np.ndarray) or is_module_ver_at_least(torch, (1, 8, 0)):
-                data = where(in1d(img, select_labels), True, False).reshape(img.shape)
-            # pre pytorch 1.8.0, need to use 1/0 instead of True/False
-            else:
-                data = where(
-                    in1d(img, select_labels), torch.tensor(1, device=img.device), torch.tensor(0, device=img.device)
-                ).reshape(img.shape)
+            data = where(in1d(img, select_labels), True, False).reshape(img.shape)
 
         if merge_channels or self.merge_channels:
-            if isinstance(img, np.ndarray) or is_module_ver_at_least(torch, (1, 8, 0)):
-                return data.any(0)[None]
-            # pre pytorch 1.8.0 compatibility
-            return data.to(torch.uint8).any(0)[None].to(bool)  # type: ignore
+            return data.any(0)[None]
 
         return data
 

monai/transforms/utils_pytorch_numpy_unification.py

@@ -18,7 +18,6 @@ import numpy as np
 import torch
 
 from monai.config.type_definitions import NdarrayOrTensor, NdarrayTensor
-from monai.utils.misc import is_module_ver_at_least
 from monai.utils.type_conversion import convert_data_type, convert_to_dst_type
 
 __all__ = [
@@ -215,10 +214,9 @@ def floor_divide(a: NdarrayOrTensor, b) -> NdarrayOrTensor:
         Element-wise floor division between two arrays/tensors.
     """
     if isinstance(a, torch.Tensor):
-        if is_module_ver_at_least(torch, (1, 8, 0)):
-            return torch.div(a, b, rounding_mode="floor")
         return torch.floor_divide(a, b)
-    return np.floor_divide(a, b)
+    else:
+        return np.floor_divide(a, b)
 
 
 def unravel_index(idx, shape) -> NdarrayOrTensor:

monai/utils/enums.py

@@ -213,7 +213,8 @@ class GridSamplePadMode(StrEnum):
 
 class Average(StrEnum):
     """
-    See also: :py:class:`monai.metrics.rocauc.compute_roc_auc`
+    See also: :py:class:`monai.metrics.rocauc.compute_roc_auc` or
+    :py:class:`monai.metrics.average_precision.compute_average_precision`
     """
 
     MACRO = "macro"
@@ -335,7 +336,7 @@ class CommonKeys(StrEnum):
     `LABEL` is the training or evaluation label of segmentation or classification task.
     `PRED` is the prediction data of model output.
     `LOSS` is the loss value of current iteration.
-    `INFO` is some useful information during training or evaluation, like loss value, etc.
+    `METADATA` is some useful information during training or evaluation, like loss value, etc.
 
     """
 

monai/utils/module.py

@@ -540,11 +540,11 @@ def version_leq(lhs: str, rhs: str) -> bool:
     """
 
     lhs, rhs = str(lhs), str(rhs)
-    pkging, has_ver = optional_import("packaging.Version")
+    pkging, has_ver = optional_import("packaging.version")
     if has_ver:
         try:
-            return cast(bool, pkging.version.Version(lhs) <= pkging.version.Version(rhs))
-        except pkging.version.InvalidVersion:
+            return cast(bool, pkging.Version(lhs) <= pkging.Version(rhs))
+        except pkging.InvalidVersion:
             return True
 
     lhs_, rhs_ = parse_version_strs(lhs, rhs)
@@ -567,12 +567,12 @@ def version_geq(lhs: str, rhs: str) -> bool:
 
     """
     lhs, rhs = str(lhs), str(rhs)
-    pkging, has_ver = optional_import("packaging.Version")
+    pkging, has_ver = optional_import("packaging.version")
 
     if has_ver:
         try:
-            return cast(bool, pkging.version.Version(lhs) >= pkging.version.Version(rhs))
-        except pkging.version.InvalidVersion:
+            return cast(bool, pkging.Version(lhs) >= pkging.Version(rhs))
+        except pkging.InvalidVersion:
             return True
 
     lhs_, rhs_ = parse_version_strs(lhs, rhs)

{monai_weekly-1.5.dev2507.dist-info → monai_weekly-1.5.dev2508.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: monai-weekly
-Version: 1.5.dev2507
+Version: 1.5.dev2508
 Summary: AI Toolkit for Healthcare Imaging
 Home-page: https://monai.io/
 Author: MONAI Consortium
@@ -176,12 +176,13 @@ Requires-Dist: pyamg>=5.0.0; extra == "pyamg"
 
 MONAI is a [PyTorch](https://pytorch.org/)-based, [open-source](https://github.com/Project-MONAI/MONAI/blob/dev/LICENSE) framework for deep learning in healthcare imaging, part of the [PyTorch Ecosystem](https://pytorch.org/ecosystem/).
 Its ambitions are as follows:
+
 - Developing a community of academic, industrial and clinical researchers collaborating on a common foundation;
 - Creating state-of-the-art, end-to-end training workflows for healthcare imaging;
 - Providing researchers with the optimized and standardized way to create and evaluate deep learning models.
 
-
 ## Features
+
 > _Please see [the technical highlights](https://docs.monai.io/en/latest/highlights.html) and [What's New](https://docs.monai.io/en/latest/whatsnew.html) of the milestone releases._
 
 - flexible pre-processing for multi-dimensional medical imaging data;
@@ -190,7 +191,6 @@ Its ambitions are as follows:
 - customizable design for varying user expertise;
 - multi-GPU multi-node data parallelism support.
 
-
 ## Installation
 
 To install [the current release](https://pypi.org/project/monai/), you can simply run:
@@ -211,30 +211,34 @@ Technical documentation is available at [docs.monai.io](https://docs.monai.io).
 
 ## Citation
 
-If you have used MONAI in your research, please cite us! The citation can be exported from: https://arxiv.org/abs/2211.02701.
+If you have used MONAI in your research, please cite us! The citation can be exported from: <https://arxiv.org/abs/2211.02701>.
 
 ## Model Zoo
+
 [The MONAI Model Zoo](https://github.com/Project-MONAI/model-zoo) is a place for researchers and data scientists to share the latest and great models from the community.
 Utilizing [the MONAI Bundle format](https://docs.monai.io/en/latest/bundle_intro.html) makes it easy to [get started](https://github.com/Project-MONAI/tutorials/tree/main/model_zoo) building workflows with MONAI.
 
 ## Contributing
+
 For guidance on making a contribution to MONAI, see the [contributing guidelines](https://github.com/Project-MONAI/MONAI/blob/dev/CONTRIBUTING.md).
 
 ## Community
+
 Join the conversation on Twitter/X [@ProjectMONAI](https://twitter.com/ProjectMONAI) or join our [Slack channel](https://forms.gle/QTxJq3hFictp31UM9).
 
 Ask and answer questions over on [MONAI's GitHub Discussions tab](https://github.com/Project-MONAI/MONAI/discussions).
 
 ## Links
-- Website: https://monai.io/
-- API documentation (milestone): https://docs.monai.io/
-- API documentation (latest dev): https://docs.monai.io/en/latest/
-- Code: https://github.com/Project-MONAI/MONAI
-- Project tracker: https://github.com/Project-MONAI/MONAI/projects
-- Issue tracker: https://github.com/Project-MONAI/MONAI/issues
-- Wiki: https://github.com/Project-MONAI/MONAI/wiki
-- Test status: https://github.com/Project-MONAI/MONAI/actions
-- PyPI package: https://pypi.org/project/monai/
-- conda-forge: https://anaconda.org/conda-forge/monai
-- Weekly previews: https://pypi.org/project/monai-weekly/
-- Docker Hub: https://hub.docker.com/r/projectmonai/monai
+
+- Website: <https://monai.io/>
+- API documentation (milestone): <https://docs.monai.io/>
+- API documentation (latest dev): <https://docs.monai.io/en/latest/>
+- Code: <https://github.com/Project-MONAI/MONAI>
+- Project tracker: <https://github.com/Project-MONAI/MONAI/projects>
+- Issue tracker: <https://github.com/Project-MONAI/MONAI/issues>
+- Wiki: <https://github.com/Project-MONAI/MONAI/wiki>
+- Test status: <https://github.com/Project-MONAI/MONAI/actions>
+- PyPI package: <https://pypi.org/project/monai/>
+- conda-forge: <https://anaconda.org/conda-forge/monai>
+- Weekly previews: <https://pypi.org/project/monai-weekly/>
+- Docker Hub: <https://hub.docker.com/r/projectmonai/monai>

{monai_weekly-1.5.dev2507.dist-info → monai_weekly-1.5.dev2508.dist-info}/RECORD

@@ -1,5 +1,5 @@
-monai/__init__.py,sha256=773rsAVt3jZqCe10F0eElVLVTKFM9c0OkK1V0gaKFC8,4095
-monai/_version.py,sha256=_sL2eD0srh-DWUHxTUQSdfhLUofNwyuUZWVUfPWHwnE,503
+monai/__init__.py,sha256=jHqt9Fx6mJlpL9TD8eihfJTg6IGs40j8bCpjE3PFrVI,4095
+monai/_version.py,sha256=sQZ38u2mKWN9p59gP2DeDhflJxmQX4ckQZtIE_MCnbg,503
 monai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monai/_extensions/__init__.py,sha256=NEBPreRhQ8H9gVvgrLr_y52_TmqB96u_u4VQmeNT93I,642
 monai/_extensions/loader.py,sha256=7SiKw36q-nOzH8CRbBurFrz7GM40GCu7rc93Tm8XpnI,3643
@@ -160,7 +160,8 @@ monai/fl/utils/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,57
 monai/fl/utils/constants.py,sha256=OjMAE17niYqQh7nz45SC6CXvkMa4-XZsIuoHUHqP7W0,1784
 monai/fl/utils/exchange_object.py,sha256=q41trOwBdog_g3k_Eh2EFnLufHJ1mj7nGyQ-ShuW5Mo,3527
 monai/fl/utils/filters.py,sha256=InXplYes52JJqtsNbePAPPAYS8am_uRO7UkBHyYyJCo,1633
-monai/handlers/__init__.py,sha256=laEkiuP-ew7UzuG89135uJvC73ocVbT0nQ_3xMLEhKc,2394
+monai/handlers/__init__.py,sha256=m6SDdtXAZ4ONLCCYrSgONuPaJOz7lewOAzOvZ3J9r14,2442
+monai/handlers/average_precision.py,sha256=FkIUP2mKqGvybnc_HxuuOdqPeq06wnZP_vwb8K-IhUg,2753
 monai/handlers/checkpoint_loader.py,sha256=Y0qNBq5b-GJ-XOJNjuslegCpIGPZYOdNs3PxzNYCCm8,7432
 monai/handlers/checkpoint_saver.py,sha256=z_w5HtNSeRM3QwHQIgQKqVodSYNy8dhL8KTBUzHuF0g,16047
 monai/handlers/classification_saver.py,sha256=CNzdU9GrKj8KEC42jaBy2rEgpd3mqgz-YZg4dr61Jyg,7605
@@ -194,7 +195,7 @@ monai/handlers/trt_handler.py,sha256=uWFdgC8QKRkcNwWfKIbQMdK6-MX_1ON0mKabeIn1ltI
 monai/handlers/utils.py,sha256=Ib1u-PLrtIkiLqTfREnrCWpN4af1btdNzkyMZuuuYyU,10239
 monai/handlers/validation_handler.py,sha256=NZO21c6zzXbmAgJZHkkdoZQSQIHwuxh94QD3PLUldGU,3674
 monai/inferers/__init__.py,sha256=K74t_RCeUPdEZvHzIPzVAwZ9DtmouLqhb3qDEmFBWs4,1107
-monai/inferers/inferer.py,sha256=aZwCmM6WGj49SHi_jIkQeGDstMz45frvM1Lomoeqzm4,92669
+monai/inferers/inferer.py,sha256=UNZpsb97qpl9c7ylNV32_jk52nsX77BqYySOl0XxDQw,92802
 monai/inferers/merger.py,sha256=dZm-FVyXPlFb59q4DG52mbtPm8Iy4cNFWv3un0Z8k0M,16262
 monai/inferers/splitter.py,sha256=_hTnFdvDNRckkA7ZGQehVsNZw83oXoGFWyk5VXNqgJg,21149
 monai/inferers/utils.py,sha256=dvZBCAjaPa8xXcJuXRzNQ-fBzteauzkKbxE5YZdGBGY,20374
@@ -220,8 +221,9 @@ monai/losses/sure_loss.py,sha256=PDDNNeZm8SLPRCDUPbc8o4--ribHnY4nbo8y55nRo0w,817
 monai/losses/tversky.py,sha256=uLuqCvsac8OabTJzKQEzAfAvlwrflYCh0s76rgbcVJ0,6955
 monai/losses/unified_focal_loss.py,sha256=rCj8IpueYH_UMrOUXU0tjbXIN4Uix3bGnRZQtRvl7Sg,10224
 monai/losses/utils.py,sha256=wrpKcEO0XhbFOHz_jJRqeAeIgpMiMxmepnRf31_DNRU,2786
-monai/metrics/__init__.py,sha256=DUjK3_qfGZbw0zCv6OJgMSL3AfiYN47aYqLsxn69-HU,2174
+monai/metrics/__init__.py,sha256=rIRTn5dsXPzGoRv7tZ2ipZ7IiHlNJ4TrZOG_aDDhw28,2255
 monai/metrics/active_learning_metrics.py,sha256=uKID2O4mnY-9P2ZzyT4sqJd2NfgzjSpNKpAwulWCozU,8211
+monai/metrics/average_precision.py,sha256=rQYfPAmE78np8E4UoDPk-DSVRtEVC2hAcj5w9Q6ZIqk,8454
 monai/metrics/confusion_matrix.py,sha256=Spb20jYPnbgGZfPKDQI36ePznPf1xujxhboNnW8HxdQ,15064
 monai/metrics/cumulative_average.py,sha256=8GGjHmiBboBikprg1380SsNn7RgzFIrHGWBYDBv6ebE,5636
 monai/metrics/f_beta_score.py,sha256=urI0J_tvl0qQ5-l2fgWV_jChbgpzLmgpRq125B3yxpw,3984
@@ -360,7 +362,7 @@ monai/transforms/transform.py,sha256=0eC_Gw7T2jBb589-3EHLh-8gJD687k2OVmrnMxaKs3o
 monai/transforms/utils.py,sha256=t4TMksfSzozyNqP-HJK-ZydvmImLFzxhks0yJnZTOYM,106430
 monai/transforms/utils_create_transform_ims.py,sha256=QEJVHsCZX7ZxsBArk6NjgCzSZuuokf8l1uFqiUZBBys,31155
 monai/transforms/utils_morphological_ops.py,sha256=tt0lRLLxmlnn9roUuPEBtqah6t7BH8ittxyDFuskkUI,6767
-monai/transforms/utils_pytorch_numpy_unification.py,sha256=3WZCCSRpvFo5ugdFYw9JzSL0SVA982CmvlZ7-FdE4ok,18855
+monai/transforms/utils_pytorch_numpy_unification.py,sha256=pM6-x-TAGVcQohSYirfTqiy2SQnPixcKKHTmTqtBbg0,18706
 monai/transforms/croppad/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
 monai/transforms/croppad/array.py,sha256=WeSAs4JNtNafFaIMLPi3-9NuuyCiTm19cq2oEOonKWQ,74632
 monai/transforms/croppad/batch.py,sha256=5ukcYk3VCDpk62AL5Q_jTqpXmSNTlw0UCUhDeAB4aV0,6138
@@ -396,17 +398,17 @@ monai/transforms/spatial/array.py,sha256=5EKivdPYCP4i4qYUlkK1RpYQFzaU_baYyzgubid
 monai/transforms/spatial/dictionary.py,sha256=t0SvEDSVNFUEw2fK66OVF20sqSzCNxil17HmvsMFBt8,133752
 monai/transforms/spatial/functional.py,sha256=IwS0witCqbGkyuxzu_R4Ztp90S0pg9hY1irG7feXqig,33886
 monai/transforms/utility/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
-monai/transforms/utility/array.py,sha256=Rjfe1UOesH8ulh8q4rI4IfbC2t0e1KFq4AasZ3UvOwY,81848
+monai/transforms/utility/array.py,sha256=Du3QA6m0io7mR51gUgaMwHBFNStdFmRxhaYmBCVy7BY,81215
 monai/transforms/utility/dictionary.py,sha256=iOFdTSekvkAsBbbfHeffcRsOKRtNcnt3N1cVuUarZ1s,80549
 monai/utils/__init__.py,sha256=2_AIpb1wqGMkmgoZ3r43muFTEsnMTCkPu3LtckipYHg,3793
 monai/utils/component_store.py,sha256=Fe9jbHgwwBBAeJAw0nI02Ae13v17wlwF6N9uUue8tJg,4525
 monai/utils/decorators.py,sha256=qhhdmJMjMfZIUM6x_VGUGF7kaq2cBUAam8WymAU_mhw,3156
 monai/utils/deprecate_utils.py,sha256=gKeEV4MsI51qeQ5gci2me_C-0e-tDwa3VZzd3XPQqLk,14759
 monai/utils/dist.py,sha256=7brB42CvdS8Jvr8Y7hfqov1uk6NNnYea9dYfgMYy0BY,8578
-monai/utils/enums.py,sha256=orCV7SGDajYtl3DhTTjbLDbayr6WxkMSw_bZ6yeGGTY,19513
+monai/utils/enums.py,sha256=jXtLaNDxG3BRBgLG2t13_S_G4iVWYHZO_GztykAtmXg,19594
 monai/utils/jupyter_utils.py,sha256=BYtj80LWQAYg5RWPj5g4j2AMCzLECvAcnZdXns0Ruw8,15651
 monai/utils/misc.py,sha256=R-sCS5u7SA8hX6e7x6WSc8FgLcNpqKFRRDMWxUd2wCo,31759
-monai/utils/module.py,sha256=RWDq_64WcfGtGGiNaywR70eyE9RN4bbaMXLLW7BEUj0,26135
+monai/utils/module.py,sha256=R37PpCNCcHQvjjZFbNjNyzWb3FURaKLxQucjhzQk0eU,26087
 monai/utils/nvtx.py,sha256=i9JBxR1uhW1ZCgLPLlTx8b907QlXkFzJyTBLMlFjhtU,6876
 monai/utils/ordering.py,sha256=0nlA5b5QpVCHbtiCbTC-YsqjTmjm0bub0IeJhGFBOes,8270
 monai/utils/profiling.py,sha256=V2_cSHgrcmVF48_G3nUi2-O6fnXsS89nSlb8jj58YLo,15937
@@ -504,7 +506,7 @@ tests/bundle/test_bundle_ckpt_export.py,sha256=VnpigCoBAAc2lo0rWOpVMg0IYGB6vbHXL
 tests/bundle/test_bundle_download.py,sha256=4wpnCXNYTwTHWNjuSZqnXpVzadxNRabmFaFM3LZ_TJU,20072
 tests/bundle/test_bundle_get_data.py,sha256=lQh321mev_7fsLXRg0Tq5uEjuQILethDHRKzB6VV0o4,3667
 tests/bundle/test_bundle_push_to_hf_hub.py,sha256=Zjl6xDwRKgkS6jvO5dzMBaTLEd4EXyMXp0_wzDNSY3g,1740
-tests/bundle/test_bundle_trt_export.py,sha256=GGlAUJO63R8v7tECluF-IW-8gjIJWblQaL9FYafdKMs,6336
+tests/bundle/test_bundle_trt_export.py,sha256=png-2SGjBSt46LXSz-PLprOXwJ0WkC_3YLR3Ibk_WBc,6344
 tests/bundle/test_bundle_utils.py,sha256=GTTS_5tEvV5qLad-aHeZXHDQLZcsDwi56Ldn5FnK2RE,4573
 tests/bundle/test_bundle_verify_metadata.py,sha256=OmcERLA5ht91cUDK9yYKXhpk-96yZcj4EBwZBk7zW3w,2660
 tests/bundle/test_bundle_verify_net.py,sha256=guCsyjb5op216AUUUQo97YY3p1-XcQEWINouxNX6F84,3383
@@ -529,6 +531,7 @@ tests/fl/monai_algo/test_fl_monai_algo_dist.py,sha256=Tq560TGvTmafEa5sDGax_chRlD
 tests/fl/utils/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
 tests/fl/utils/test_fl_exchange_object.py,sha256=rddodowFMAdNT9wquI0NHg0CSm5Xvk_v9Si-eJqyiow,2571
 tests/handlers/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
+tests/handlers/test_handler_average_precision.py,sha256=0cmgjzWxlfdZsUJB1NnSXfx3dmmDI6CbvIqggtc5rTY,2814
 tests/handlers/test_handler_checkpoint_loader.py,sha256=1dA4WYp-L6KxtzZIqUs--lNM4O-Anw2-s29QSdIOReU,8443
 tests/handlers/test_handler_checkpoint_saver.py,sha256=K3bxelElfETpQSXRovWZlxZZmkjY3hm_cJo8kjYCJ3I,6256
 tests/handlers/test_handler_classification_saver.py,sha256=vesCfTcAPkDAR7oAB_8kyeQrXpkrPQmdME9YBwPV7EE,2355
@@ -567,9 +570,9 @@ tests/handlers/test_trt_compile.py,sha256=p8Gr2CJmBo6gG8w7bGlAO--nDHtQvy9Ld3jtua
 tests/handlers/test_write_metrics_reports.py,sha256=oKGYR1plj1hSAu-ntbxkw_TD4O5hKPwVH_BS3MdHIbs,3027
 tests/inferers/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
 tests/inferers/test_avg_merger.py,sha256=lMR2PcNGFD6sfF6CjJTkahrAiMA5m5LUs5A11P6h8n0,5952
-tests/inferers/test_controlnet_inferers.py,sha256=deLRMcYoL2LoQp3sqhgxSNJJgIHx78kr_cIrUhJt3pY,46681
+tests/inferers/test_controlnet_inferers.py,sha256=SGluRyDlgwUJ8nm3BEWgXN3eb81fUGOaRXbLglC_ejc,49676
 tests/inferers/test_diffusion_inferer.py,sha256=1O2V_bEmifOZ4RvpbZgYUCooiJ97T73avaBuMJPpBs0,9992
-tests/inferers/test_latent_diffusion_inferer.py,sha256=QT_RTtV99oDvA6U-EDoAjxJwiOY9OWBuqhxyPKrQQSc,29722
+tests/inferers/test_latent_diffusion_inferer.py,sha256=atJjmfVznUq8z9EjohFIMyA0Q1XT1Ly0Zepf_1xPz5I,32274
 tests/inferers/test_patch_inferer.py,sha256=LkYXWVn71vWinP-OJsIvq3FPH3jr36T7nKRIH5PzaqY,9878
 tests/inferers/test_saliency_inferer.py,sha256=7miHRbA4yb_WGcxql6za9uXXoZlql_7y23f7IzsyIps,1949
 tests/inferers/test_slice_inferer.py,sha256=kzaJjjTnf2rAiR75l8A_J-Kie4NaLj2bogi-aJ5L5mk,1897
@@ -645,6 +648,7 @@ tests/losses/image_dissimilarity/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4o
 tests/losses/image_dissimilarity/test_global_mutual_information_loss.py,sha256=9xEX5BCEQ1s004QgcwYaAFwKTmlZjuVG8cIbK7Giwts,5692
 tests/losses/image_dissimilarity/test_local_normalized_cross_correlation_loss.py,sha256=Gs3zHnGWNZ50liU_tya4Z_6tCRKIWCtG59imAxXdKPI,6070
 tests/metrics/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
+tests/metrics/test_compute_average_precision.py,sha256=o5gYko4Ow87Ix1n_z6_HmfuTKmkZM__fDZQpjKNJNrA,4743
 tests/metrics/test_compute_confusion_matrix.py,sha256=dwiqMnp7T6KJLJ7qv6J5g_RDDrB6UiLAe-pgmVNSz7I,10669
 tests/metrics/test_compute_f_beta.py,sha256=xbCipeICoAXWZLgDFeDAa1KjDQxDTMVArNbtUYiCG3c,3286
 tests/metrics/test_compute_fid_metric.py,sha256=B9OZECl3CT1JKzG-2C_YaPFjgfvlFoS9vI1j8vBzWZg,1328
@@ -670,7 +674,7 @@ tests/metrics/test_surface_dice.py,sha256=CGCQt-ydMzaT2q1fFnzpKb6E-TPydym4vE_kdp
 tests/metrics/test_surface_distance.py,sha256=gkW0dai3vHjXubLNBilqFnV5Up-abSMgQ53v0iCTVeE,6237
 tests/networks/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
 tests/networks/test_bundle_onnx_export.py,sha256=_lEnAJhq7D2IOuVEdgBVsA8vySgs34FkfMrvNsCLfUg,2853
-tests/networks/test_convert_to_onnx.py,sha256=wHHraeN7uyrKwtjTcVOzW5Vk8_IrJsGdmA_-mTlPdYU,3669
+tests/networks/test_convert_to_onnx.py,sha256=h1Sjb0SZmiwwbx0_PrzeFDOE3-JRSp18qDS6G_PdD6g,3673
 tests/networks/test_convert_to_torchscript.py,sha256=NhrJMCfQtC0sftrhDjL28omS7VKzg_niRK0KtY5Mr_A,1636
 tests/networks/test_convert_to_trt.py,sha256=5TkuUvCPgW5mAvYUysRRrSjtSbDoDDAoJb2kJtuXOVk,2656
 tests/networks/test_save_state.py,sha256=_glX4irpJVqk2jnOJaVqYxsOQNX3oCauxlEXe2ly8Cg,2354
@@ -881,7 +885,7 @@ tests/transforms/test_generate_label_classes_crop_centers.py,sha256=E5DtL2s1sio1
 tests/transforms/test_generate_pos_neg_label_crop_centers.py,sha256=DdCbdYaTHL40crC5o440cpEt0xNLXzT-rVphaBH11HM,2516
 tests/transforms/test_generate_spatial_bounding_box.py,sha256=JxHt4BHmtGYIqyzGhWgkCB5_oJU2ro_737upVxWBPvI,3510
 tests/transforms/test_get_extreme_points.py,sha256=881LZMTms1tXRDtODIheZbKDXMVQ69ff78IvukoabGc,1700
-tests/transforms/test_gibbs_noise.py,sha256=pMNYS1-CqO_aO7qMEacftJ963m3ZbPTUSBCaMXqKC_w,2652
+tests/transforms/test_gibbs_noise.py,sha256=9TgOYhGz1P6-VJUXszuV9NgqhjF5FKCVcQuG_7o3jUI,2658
 tests/transforms/test_gibbs_noised.py,sha256=o9ZQVAyuHATbV9JHkeTy_pDLz5Mqg5ctMQawMmP71RQ,3228
 tests/transforms/test_grid_distortion.py,sha256=8dTQjWQ2_euNKN00xxZXqZk-cFSsKfpVpkNm-1-WytA,4472
 tests/transforms/test_grid_distortiond.py,sha256=bSLhB_LGQKXo5VqP9RCyJDSyiZi2er2W2Qdw7qDep9s,3492
@@ -1174,8 +1178,8 @@ tests/visualize/test_vis_gradcam.py,sha256=WpA-pvTB75eZs7JoIc5qyvOV9PwgkzWI8-Vow
 tests/visualize/utils/__init__.py,sha256=s9djSd6kvViPnFvMR11Dgd30Lv4oY6FaPJr4ZZJZLq0,573
 tests/visualize/utils/test_blend_images.py,sha256=RVs2p_8RWQDfhLHDNNtZaMig27v8o0km7XxNa-zWjKE,2274
 tests/visualize/utils/test_matshow3d.py,sha256=wXYj77L5Jvnp0f6DvL1rsi_-YlCxS0HJ9hiPmrbpuP8,5021
-monai_weekly-1.5.dev2507.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-monai_weekly-1.5.dev2507.dist-info/METADATA,sha256=DnZgxmNLCqJuH_bFGivUTSad3mzRzDaUM9rYd0ydUtY,11879
-monai_weekly-1.5.dev2507.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-monai_weekly-1.5.dev2507.dist-info/top_level.txt,sha256=hn2Y6P9xBf2R8faMeVMHhPMvrdDKxMsIOwMDYI0yTjs,12
-monai_weekly-1.5.dev2507.dist-info/RECORD,,
+monai_weekly-1.5.dev2508.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+monai_weekly-1.5.dev2508.dist-info/METADATA,sha256=y-KfkVBP9_LhTnQo37SKpjDYJYsdujQuCCQiZpKdSv8,11909
+monai_weekly-1.5.dev2508.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+monai_weekly-1.5.dev2508.dist-info/top_level.txt,sha256=hn2Y6P9xBf2R8faMeVMHhPMvrdDKxMsIOwMDYI0yTjs,12
+monai_weekly-1.5.dev2508.dist-info/RECORD,,

tests/bundle/test_bundle_trt_export.py

@@ -70,7 +70,7 @@ class TestTRTExport(unittest.TestCase):
     @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_4])
     @unittest.skipUnless(has_torchtrt and has_tensorrt, "Torch-TensorRT is required for conversion!")
     def test_trt_export(self, convert_precision, input_shape, dynamic_batch):
-        tests_dir = Path(__file__).resolve().parent
+        tests_dir = Path(__file__).resolve().parents[1]
         meta_file = os.path.join(tests_dir, "testing_data", "metadata.json")
         config_file = os.path.join(tests_dir, "testing_data", "inference.json")
         with tempfile.TemporaryDirectory() as tempdir:
@@ -108,7 +108,7 @@ class TestTRTExport(unittest.TestCase):
         has_onnx and has_torchtrt and has_tensorrt, "Onnx and TensorRT are required for onnx-trt conversion!"
     )
     def test_onnx_trt_export(self, convert_precision, input_shape, dynamic_batch):
-        tests_dir = Path(__file__).resolve().parent
+        tests_dir = Path(__file__).resolve().parents[1]
         meta_file = os.path.join(tests_dir, "testing_data", "metadata.json")
         config_file = os.path.join(tests_dir, "testing_data", "inference.json")
         with tempfile.TemporaryDirectory() as tempdir:

tests/handlers/test_handler_average_precision.py

@@ -0,0 +1,79 @@
+# 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 unittest
+
+import numpy as np
+import torch
+import torch.distributed as dist
+
+from monai.handlers import AveragePrecision
+from monai.transforms import Activations, AsDiscrete
+from tests.test_utils import DistCall, DistTestCase
+
+
+class TestHandlerAveragePrecision(unittest.TestCase):
+
+    def test_compute(self):
+        ap_metric = AveragePrecision()
+        act = Activations(softmax=True)
+        to_onehot = AsDiscrete(to_onehot=2)
+
+        y_pred = [torch.Tensor([0.1, 0.9]), torch.Tensor([0.3, 1.4])]
+        y = [torch.Tensor([0]), torch.Tensor([1])]
+        y_pred = [act(p) for p in y_pred]
+        y = [to_onehot(y_) for y_ in y]
+        ap_metric.update([y_pred, y])
+
+        y_pred = [torch.Tensor([0.2, 0.1]), torch.Tensor([0.1, 0.5])]
+        y = [torch.Tensor([0]), torch.Tensor([1])]
+        y_pred = [act(p) for p in y_pred]
+        y = [to_onehot(y_) for y_ in y]
+
+        ap_metric.update([y_pred, y])
+
+        ap = ap_metric.compute()
+        np.testing.assert_allclose(0.8333333, ap)
+
+
+class DistributedAveragePrecision(DistTestCase):
+
+    @DistCall(nnodes=1, nproc_per_node=2, node_rank=0)
+    def test_compute(self):
+        ap_metric = AveragePrecision()
+        act = Activations(softmax=True)
+        to_onehot = AsDiscrete(to_onehot=2)
+
+        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available() else "cpu"
+        if dist.get_rank() == 0:
+            y_pred = [torch.tensor([0.1, 0.9], device=device), torch.tensor([0.3, 1.4], device=device)]
+            y = [torch.tensor([0], device=device), torch.tensor([1], device=device)]
+
+        if dist.get_rank() == 1:
+            y_pred = [
+                torch.tensor([0.2, 0.1], device=device),
+                torch.tensor([0.1, 0.5], device=device),
+                torch.tensor([0.3, 0.4], device=device),
+            ]
+            y = [torch.tensor([0], device=device), torch.tensor([1], device=device), torch.tensor([1], device=device)]
+
+        y_pred = [act(p) for p in y_pred]
+        y = [to_onehot(y_) for y_ in y]
+        ap_metric.update([y_pred, y])
+
+        result = ap_metric.compute()
+        np.testing.assert_allclose(0.7778, result, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/inferers/test_controlnet_inferers.py

@@ -722,7 +722,7 @@ class LatentControlNetTestDiffusionSamplingInferer(unittest.TestCase):
 
     @parameterized.expand(LATENT_CNDM_TEST_CASES)
     @skipUnless(has_einops, "Requires einops")
-    def test_sample_shape(
+    def test_pred_shape(
         self,
         ae_model_type,
         autoencoder_params,
@@ -1165,7 +1165,7 @@ class LatentControlNetTestDiffusionSamplingInferer(unittest.TestCase):
 
     @parameterized.expand(LATENT_CNDM_TEST_CASES_DIFF_SHAPES)
     @skipUnless(has_einops, "Requires einops")
-    def test_sample_shape_different_latents(
+    def test_shape_different_latents(
         self,
         ae_model_type,
         autoencoder_params,
@@ -1242,6 +1242,84 @@ class LatentControlNetTestDiffusionSamplingInferer(unittest.TestCase):
             )
         self.assertEqual(prediction.shape, latent_shape)
 
+    @parameterized.expand(LATENT_CNDM_TEST_CASES_DIFF_SHAPES)
+    @skipUnless(has_einops, "Requires einops")
+    def test_sample_shape_different_latents(
+        self,
+        ae_model_type,
+        autoencoder_params,
+        dm_model_type,
+        stage_2_params,
+        controlnet_params,
+        input_shape,
+        latent_shape,
+    ):
+        stage_1 = None
+
+        if ae_model_type == "AutoencoderKL":
+            stage_1 = AutoencoderKL(**autoencoder_params)
+        if ae_model_type == "VQVAE":
+            stage_1 = VQVAE(**autoencoder_params)
+        if ae_model_type == "SPADEAutoencoderKL":
+            stage_1 = SPADEAutoencoderKL(**autoencoder_params)
+        if dm_model_type == "SPADEDiffusionModelUNet":
+            stage_2 = SPADEDiffusionModelUNet(**stage_2_params)
+        else:
+            stage_2 = DiffusionModelUNet(**stage_2_params)
+        controlnet = ControlNet(**controlnet_params)
+
+        device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        stage_1.to(device)
+        stage_2.to(device)
+        controlnet.to(device)
+        stage_1.eval()
+        stage_2.eval()
+        controlnet.eval()
+
+        noise = torch.randn(latent_shape).to(device)
+        mask = torch.randn(input_shape).to(device)
+        scheduler = DDPMScheduler(num_train_timesteps=10)
+        # We infer the VAE shape
+        if ae_model_type == "VQVAE":
+            autoencoder_latent_shape = [i // (2 ** (len(autoencoder_params["channels"]))) for i in input_shape[2:]]
+        else:
+            autoencoder_latent_shape = [i // (2 ** (len(autoencoder_params["channels"]) - 1)) for i in input_shape[2:]]
+
+        inferer = ControlNetLatentDiffusionInferer(
+            scheduler=scheduler,
+            scale_factor=1.0,
+            ldm_latent_shape=list(latent_shape[2:]),
+            autoencoder_latent_shape=autoencoder_latent_shape,
+        )
+        scheduler.set_timesteps(num_inference_steps=10)
+
+        if dm_model_type == "SPADEDiffusionModelUNet" or ae_model_type == "SPADEAutoencoderKL":
+            input_shape_seg = list(input_shape)
+            if "label_nc" in stage_2_params.keys():
+                input_shape_seg[1] = stage_2_params["label_nc"]
+            else:
+                input_shape_seg[1] = autoencoder_params["label_nc"]
+            input_seg = torch.randn(input_shape_seg).to(device)
+            prediction, _ = inferer.sample(
+                autoencoder_model=stage_1,
+                diffusion_model=stage_2,
+                controlnet=controlnet,
+                cn_cond=mask,
+                input_noise=noise,
+                seg=input_seg,
+                save_intermediates=True,
+            )
+        else:
+            prediction = inferer.sample(
+                autoencoder_model=stage_1,
+                diffusion_model=stage_2,
+                input_noise=noise,
+                controlnet=controlnet,
+                cn_cond=mask,
+                save_intermediates=False,
+            )
+        self.assertEqual(prediction.shape, input_shape)
+
     @skipUnless(has_einops, "Requires einops")
     def test_incompatible_spade_setup(self):
         stage_1 = SPADEAutoencoderKL(

tests/inferers/test_latent_diffusion_inferer.py

@@ -714,7 +714,7 @@ class TestDiffusionSamplingInferer(unittest.TestCase):
 
     @parameterized.expand(TEST_CASES_DIFF_SHAPES)
     @skipUnless(has_einops, "Requires einops")
-    def test_sample_shape_different_latents(
+    def test_shape_different_latents(
         self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape
     ):
         stage_1 = None
@@ -772,6 +772,66 @@ class TestDiffusionSamplingInferer(unittest.TestCase):
             )
         self.assertEqual(prediction.shape, latent_shape)
 
+    @parameterized.expand(TEST_CASES_DIFF_SHAPES)
+    @skipUnless(has_einops, "Requires einops")
+    def test_sample_shape_different_latents(
+        self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape
+    ):
+        stage_1 = None
+
+        if ae_model_type == "AutoencoderKL":
+            stage_1 = AutoencoderKL(**autoencoder_params)
+        if ae_model_type == "VQVAE":
+            stage_1 = VQVAE(**autoencoder_params)
+        if ae_model_type == "SPADEAutoencoderKL":
+            stage_1 = SPADEAutoencoderKL(**autoencoder_params)
+        if dm_model_type == "SPADEDiffusionModelUNet":
+            stage_2 = SPADEDiffusionModelUNet(**stage_2_params)
+        else:
+            stage_2 = DiffusionModelUNet(**stage_2_params)
+
+        device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        stage_1.to(device)
+        stage_2.to(device)
+        stage_1.eval()
+        stage_2.eval()
+
+        noise = torch.randn(latent_shape).to(device)
+        scheduler = DDPMScheduler(num_train_timesteps=10)
+        # We infer the VAE shape
+        if ae_model_type == "VQVAE":
+            autoencoder_latent_shape = [i // (2 ** (len(autoencoder_params["channels"]))) for i in input_shape[2:]]
+        else:
+            autoencoder_latent_shape = [i // (2 ** (len(autoencoder_params["channels"]) - 1)) for i in input_shape[2:]]
+
+        inferer = LatentDiffusionInferer(
+            scheduler=scheduler,
+            scale_factor=1.0,
+            ldm_latent_shape=list(latent_shape[2:]),
+            autoencoder_latent_shape=autoencoder_latent_shape,
+        )
+        scheduler.set_timesteps(num_inference_steps=10)
+
+        if dm_model_type == "SPADEDiffusionModelUNet" or ae_model_type == "SPADEAutoencoderKL":
+            input_shape_seg = list(input_shape)
+            if "label_nc" in stage_2_params.keys():
+                input_shape_seg[1] = stage_2_params["label_nc"]
+            else:
+                input_shape_seg[1] = autoencoder_params["label_nc"]
+            input_seg = torch.randn(input_shape_seg).to(device)
+            prediction, _ = inferer.sample(
+                autoencoder_model=stage_1,
+                diffusion_model=stage_2,
+                input_noise=noise,
+                save_intermediates=True,
+                seg=input_seg,
+            )
+        else:
+            prediction = inferer.sample(
+                autoencoder_model=stage_1, diffusion_model=stage_2, input_noise=noise, save_intermediates=False
+            )
+        self.assertEqual(prediction.shape, input_shape)
+
     @skipUnless(has_einops, "Requires einops")
     def test_incompatible_spade_setup(self):
         stage_1 = SPADEAutoencoderKL(

tests/metrics/test_compute_average_precision.py

@@ -0,0 +1,162 @@
+# 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 unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import decollate_batch
+from monai.metrics import AveragePrecisionMetric, compute_average_precision
+from monai.transforms import Activations, AsDiscrete, Compose, ToTensor
+
+_device = "cuda:0" if torch.cuda.is_available() else "cpu"
+TEST_CASE_1 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]], device=_device),
+    torch.tensor([[0], [0], [1], [1]], device=_device),
+    True,
+    2,
+    "macro",
+    0.41667,
+]
+
+TEST_CASE_2 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]], device=_device),
+    torch.tensor([[1], [1], [0], [0]], device=_device),
+    True,
+    2,
+    "micro",
+    0.85417,
+]
+
+TEST_CASE_3 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]], device=_device),
+    torch.tensor([[0], [1], [0], [1]], device=_device),
+    True,
+    2,
+    "macro",
+    0.83333,
+]
+
+TEST_CASE_4 = [
+    torch.tensor([[0.5], [0.5], [0.2], [8.3]]),
+    torch.tensor([[0], [1], [0], [1]]),
+    False,
+    None,
+    "macro",
+    0.83333,
+]
+
+TEST_CASE_5 = [torch.tensor([[0.5], [0.5], [0.2], [8.3]]), torch.tensor([0, 1, 0, 1]), False, None, "macro", 0.83333]
+
+TEST_CASE_6 = [torch.tensor([0.5, 0.5, 0.2, 8.3]), torch.tensor([0, 1, 0, 1]), False, None, "macro", 0.83333]
+
+TEST_CASE_7 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0], [1], [0], [1]]),
+    True,
+    2,
+    "none",
+    [0.83333, 0.83333],
+]
+
+TEST_CASE_8 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+    torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+    True,
+    None,
+    "weighted",
+    0.66667,
+]
+
+TEST_CASE_9 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5], [0.1, 0.5]]),
+    torch.tensor([[1, 0], [0, 1], [0, 0], [1, 1], [0, 1]]),
+    True,
+    None,
+    "micro",
+    0.71111,
+]
+
+TEST_CASE_10 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0], [0], [0], [0]]),
+    True,
+    2,
+    "macro",
+    float("nan"),
+]
+
+TEST_CASE_11 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[1], [1], [1], [1]]),
+    True,
+    2,
+    "macro",
+    float("nan"),
+]
+
+TEST_CASE_12 = [
+    torch.tensor([[0.1, 0.9], [0.3, 1.4], [0.2, 0.1], [0.1, 0.5]]),
+    torch.tensor([[0, 0], [1, 1], [2, 2], [3, 3]]),
+    True,
+    None,
+    "macro",
+    float("nan"),
+]
+
+ALL_TESTS = [
+    TEST_CASE_1,
+    TEST_CASE_2,
+    TEST_CASE_3,
+    TEST_CASE_4,
+    TEST_CASE_5,
+    TEST_CASE_6,
+    TEST_CASE_7,
+    TEST_CASE_8,
+    TEST_CASE_9,
+    TEST_CASE_10,
+    TEST_CASE_11,
+    TEST_CASE_12,
+]
+
+
+class TestComputeAveragePrecision(unittest.TestCase):
+
+    @parameterized.expand(ALL_TESTS)
+    def test_value(self, y_pred, y, softmax, to_onehot, average, expected_value):
+        y_pred_trans = Compose([ToTensor(), Activations(softmax=softmax)])
+        y_trans = Compose([ToTensor(), AsDiscrete(to_onehot=to_onehot)])
+        y_pred = torch.stack([y_pred_trans(i) for i in decollate_batch(y_pred)], dim=0)
+        y = torch.stack([y_trans(i) for i in decollate_batch(y)], dim=0)
+        result = compute_average_precision(y_pred=y_pred, y=y, average=average)
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+
+    @parameterized.expand(ALL_TESTS)
+    def test_class_value(self, y_pred, y, softmax, to_onehot, average, expected_value):
+        y_pred_trans = Compose([ToTensor(), Activations(softmax=softmax)])
+        y_trans = Compose([ToTensor(), AsDiscrete(to_onehot=to_onehot)])
+        y_pred = [y_pred_trans(i) for i in decollate_batch(y_pred)]
+        y = [y_trans(i) for i in decollate_batch(y)]
+        metric = AveragePrecisionMetric(average=average)
+        metric(y_pred=y_pred, y=y)
+        result = metric.aggregate()
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+        result = metric.aggregate(average=average)  # test optional argument
+        metric.reset()
+        np.testing.assert_allclose(expected_value, result, rtol=1e-5)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/test_convert_to_onnx.py

@@ -64,7 +64,7 @@ class TestConvertToOnnx(unittest.TestCase):
                 rtol=rtol,
                 atol=atol,
             )
-        self.assertTrue(isinstance(onnx_model, onnx.ModelProto))
+            self.assertTrue(isinstance(onnx_model, onnx.ModelProto))
 
     @parameterized.expand(TESTS_ORT)
     @SkipIfBeforePyTorchVersion((1, 12))

tests/transforms/test_gibbs_noise.py

@@ -21,14 +21,12 @@ from monai.data.synthetic import create_test_image_2d, create_test_image_3d
 from monai.transforms import GibbsNoise
 from monai.utils.misc import set_determinism
 from monai.utils.module import optional_import
-from tests.test_utils import TEST_NDARRAYS, assert_allclose
+from tests.test_utils import TEST_NDARRAYS, assert_allclose, dict_product
 
 _, has_torch_fft = optional_import("torch.fft", name="fftshift")
 
-TEST_CASES = []
-for shape in ((128, 64), (64, 48, 80)):
-    for input_type in TEST_NDARRAYS if has_torch_fft else [np.array]:
-        TEST_CASES.append((shape, input_type))
+params = {"shape": ((128, 64), (64, 48, 80)), "input_type": TEST_NDARRAYS if has_torch_fft else [np.array]}
+TEST_CASES = list(dict_product(format="list", **params))
 
 
 class TestGibbsNoise(unittest.TestCase):