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

tests/handlers/test_handler_prob_map_producer.py

@@ -0,0 +1,111 @@
+# 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 os
+import unittest
+from pathlib import Path
+
+import numpy as np
+import torch
+from ignite.engine import Engine
+from parameterized import parameterized
+
+from monai.data import DataLoader, Dataset, MetaTensor
+from monai.engines import Evaluator
+from monai.handlers import ProbMapProducer, ValidationHandler
+from monai.utils.enums import ProbMapKeys
+
+TEST_CASE_0 = ["temp_image_inference_output_1", 1]
+TEST_CASE_1 = ["temp_image_inference_output_2", 9]
+TEST_CASE_2 = ["temp_image_inference_output_3", 100]
+
+
+class TestDataset(Dataset):
+    __test__ = False  # indicate to pytest that this class is not intended for collection
+
+    def __init__(self, name, size):
+        super().__init__(
+            data=[
+                {
+                    "image": name,
+                    ProbMapKeys.COUNT.value: size,
+                    ProbMapKeys.SIZE.value: np.array([size + 1, size + 1]),
+                    ProbMapKeys.LOCATION.value: np.array([i, i + 1]),
+                }
+                for i in range(size)
+            ]
+        )
+        self.image_data = [
+            {
+                ProbMapKeys.NAME.value: name,
+                ProbMapKeys.COUNT.value: size,
+                ProbMapKeys.SIZE.value: np.array([size + 1, size + 1]),
+            }
+        ]
+
+    def __getitem__(self, index):
+        image = np.ones((3, 2, 2)) * index
+        metadata = {
+            ProbMapKeys.COUNT.value: self.data[index][ProbMapKeys.COUNT.value],
+            ProbMapKeys.NAME.value: self.data[index]["image"],
+            ProbMapKeys.SIZE.value: self.data[index][ProbMapKeys.SIZE.value],
+            ProbMapKeys.LOCATION.value: self.data[index][ProbMapKeys.LOCATION.value],
+        }
+
+        return {"image": MetaTensor(x=image, meta=metadata), "pred": index + 1}
+
+
+class TestEvaluator(Evaluator):
+    __test__ = False  # indicate to pytest that this class is not intended for collection
+
+    def _iteration(self, engine, batchdata):
+        return batchdata
+
+
+class TestHandlerProbMapGenerator(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_0, TEST_CASE_1, TEST_CASE_2])
+    def test_prob_map_generator(self, name, size):
+        # set up dataset
+        dataset = TestDataset(name, size)
+        batch_size = 2
+        data_loader = DataLoader(dataset, batch_size=batch_size)
+
+        # set up engine
+        def inference(engine, batch):
+            pass
+
+        engine = Engine(inference)
+
+        tests_path = Path(__file__).parents[1].as_posix()
+        # add ProbMapGenerator() to evaluator
+        output_dir = os.path.join(tests_path, "testing_data")
+        prob_map_gen = ProbMapProducer(output_dir=output_dir)
+
+        evaluator = TestEvaluator(
+            torch.device("cpu:0"), data_loader, np.ceil(size / batch_size), val_handlers=[prob_map_gen]
+        )
+
+        # set up validation handler
+        validation = ValidationHandler(interval=1, validator=None)
+        validation.attach(engine)
+        validation.set_validator(validator=evaluator)
+
+        engine.run(data_loader)
+
+        prob_map = np.load(os.path.join(output_dir, name + ".npy"))
+        self.assertListEqual(np.vstack(prob_map.nonzero()).T.tolist(), [[i, i + 1] for i in range(size)])
+        self.assertListEqual(prob_map[prob_map.nonzero()].tolist(), [i + 1 for i in range(size)])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_regression_metrics.py

@@ -0,0 +1,160 @@
+# 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
+from functools import partial
+
+import numpy as np
+import torch
+from ignite.engine import Engine
+
+from monai.handlers import MeanAbsoluteError, MeanSquaredError, PeakSignalToNoiseRatio, RootMeanSquaredError
+from monai.utils import set_determinism
+
+
+# define a numpy flatten function that only preserves batch dimension
+def flatten(data):
+    return np.reshape(data, [data.shape[0], -1])
+
+
+# define metrics computation truth functions to check our monai metrics against
+def msemetric_np(y_pred, y):
+    return np.mean((flatten(y_pred) - flatten(y)) ** 2)
+
+
+def maemetric_np(y_pred, y):
+    return np.mean(np.abs(flatten(y_pred) - flatten(y)))
+
+
+def rmsemetric_np(y_pred, y):
+    return np.mean(np.sqrt(np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)))
+
+
+def psnrmetric_np(max_val, y_pred, y):
+    mse = np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)
+    return np.mean(20 * np.log10(max_val) - 10 * np.log10(mse))
+
+
+class TestHandlerRegressionMetrics(unittest.TestCase):
+
+    def test_compute(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check + truth metric function in numpy
+        metrics = [
+            MeanSquaredError,
+            MeanAbsoluteError,
+            RootMeanSquaredError,
+            partial(PeakSignalToNoiseRatio, max_val=1.0),
+        ]
+        metrics_np = [msemetric_np, maemetric_np, rmsemetric_np, partial(psnrmetric_np, max_val=1.0)]
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for mt_fn, mt_fn_np in zip(metrics, metrics_np):
+            for batch in batch_dims:
+                for spatial in spatial_dims:
+                    for base in base_dims:
+                        mt_fn_obj = mt_fn(**{"save_details": False})
+
+                        # create random tensor
+                        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        mt_fn_obj.update([in_tensor_a1, in_tensor_b1])
+                        out_tensor_np1 = mt_fn_np(y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+
+                        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        mt_fn_obj.update([in_tensor_a2, in_tensor_b2])
+                        out_tensor_np2 = mt_fn_np(y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+
+                        out_tensor = mt_fn_obj.compute()
+                        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+                        np.testing.assert_allclose(out_tensor, out_tensor_np, atol=1e-4)
+
+    def test_compute_engine(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check + truth metric function in numpy
+        metrics_names = ["MSE", "MAE", "RMSE", "PSNR"]
+        metrics = [
+            MeanSquaredError,
+            MeanAbsoluteError,
+            RootMeanSquaredError,
+            partial(PeakSignalToNoiseRatio, max_val=1.0),
+        ]
+        metrics_np = [msemetric_np, maemetric_np, rmsemetric_np, partial(psnrmetric_np, max_val=1.0)]
+
+        def _val_func(engine, batch):
+            pass
+
+        # define variations in batch/base_dims/spatial_dims
+        batch_dims = [1, 2, 4, 16]
+        base_dims = [16, 32, 64]
+        spatial_dims = [2, 3, 4]
+
+        # iterate over all variations and check shapes for different reduction functions
+        for mt_fn_name, mt_fn, mt_fn_np in zip(metrics_names, metrics, metrics_np):
+            for batch in batch_dims:
+                for spatial in spatial_dims:
+                    for base in base_dims:
+                        mt_fn_obj = mt_fn()  # 'save_details' == True
+                        engine = Engine(_val_func)
+                        mt_fn_obj.attach(engine, mt_fn_name)
+
+                        # create random tensor
+                        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        mt_fn_obj.update([in_tensor_a1, in_tensor_b1])
+                        out_tensor_np1 = mt_fn_np(y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+
+                        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1)).to(device)
+                        mt_fn_obj.update([in_tensor_a2, in_tensor_b2])
+                        out_tensor_np2 = mt_fn_np(y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+
+                        out_tensor = mt_fn_obj.compute()
+                        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+                        np.testing.assert_allclose(out_tensor, out_tensor_np, atol=1e-4)
+
+    def test_ill_shape(self):
+        set_determinism(seed=123)
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # regression metrics to check + truth metric function in numpy
+        metrics = [
+            MeanSquaredError,
+            MeanAbsoluteError,
+            RootMeanSquaredError,
+            partial(PeakSignalToNoiseRatio, max_val=1.0),
+        ]
+        basedim = 10
+
+        # different shape for pred/target
+        with self.assertRaises((AssertionError, ValueError)):
+            in_tensor_a = torch.rand((basedim,)).to(device)
+            in_tensor_b = torch.rand((basedim, basedim)).to(device)
+            for mt_fn in metrics:
+                mt_fn().update([in_tensor_a, in_tensor_b])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_regression_metrics_dist.py

@@ -0,0 +1,245 @@
+# 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 ignite.engine import Engine
+
+from monai.handlers import MeanAbsoluteError, MeanSquaredError, PeakSignalToNoiseRatio, RootMeanSquaredError
+from monai.utils import set_determinism
+from tests.test_utils import DistCall, DistTestCase
+
+
+# define a numpy flatten function that only preserves batch dimension
+def flatten(data):
+    return np.reshape(data, [data.shape[0], -1])
+
+
+# define metrics computation truth functions to check our monai metrics against
+def msemetric_np(y_pred, y):
+    return np.mean((flatten(y_pred) - flatten(y)) ** 2)
+
+
+def maemetric_np(y_pred, y):
+    return np.mean(np.abs(flatten(y_pred) - flatten(y)))
+
+
+def rmsemetric_np(y_pred, y):
+    return np.mean(np.sqrt(np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)))
+
+
+def psnrmetric_np(max_val, y_pred, y):
+    mse = np.mean((flatten(y_pred) - flatten(y)) ** 2, axis=1)
+    return np.mean(20 * np.log10(max_val) - 10 * np.log10(mse))
+
+
+# define tensor size as (BATCH_SIZE, (BASE_DIM_SIZE,) * SPATIAL_DIM)
+# One tensor with following shape takes 4*32*32*32*32/(8*1000) = 512 MB on a single GPU
+# We have total of 2 tensors each on one GPU for following tests, so required GPU memory is 1024 MB on each GPU
+# The required GPU memory can be lowered by changing BASE_DIM_SIZE to another value e.g. BASE_DIM_SIZE=16 will
+# require 128 MB on each GPU
+BATCH_SIZE = 4
+BASE_DIM_SIZE = 32
+SPATIAL_DIM = 3
+
+
+class DistributedMeanSquaredError(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_compute(self):
+        set_determinism(123)
+        self._compute()
+
+    def _compute(self):
+        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available() else "cpu"
+        metric = MeanSquaredError()
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        metric.attach(engine, "MSE")
+
+        # get testing data
+        batch = BATCH_SIZE
+        base = BASE_DIM_SIZE
+        spatial = SPATIAL_DIM
+        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        if dist.get_rank() == 0:
+            y_pred = in_tensor_a1.to(device)
+            y = in_tensor_b1.to(device)
+            metric.update([y_pred, y])
+
+        if dist.get_rank() == 1:
+            y_pred = in_tensor_a2.to(device)
+            y = in_tensor_b2.to(device)
+            metric.update([y_pred, y])
+
+        out_tensor = metric.compute()
+
+        # do numpy functions to get ground truth referece
+        out_tensor_np1 = msemetric_np(y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+        out_tensor_np2 = msemetric_np(y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+        np.testing.assert_allclose(out_tensor, out_tensor_np, rtol=1e-04, atol=1e-04)
+
+
+class DistributedMeanAbsoluteError(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_compute(self):
+        set_determinism(123)
+        self._compute()
+
+    def _compute(self):
+        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available() else "cpu"
+        metric = MeanAbsoluteError()
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        metric.attach(engine, "MAE")
+
+        # get testing data
+        batch = BATCH_SIZE
+        base = BASE_DIM_SIZE
+        spatial = SPATIAL_DIM
+        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        if dist.get_rank() == 0:
+            y_pred = in_tensor_a1.to(device)
+            y = in_tensor_b1.to(device)
+            metric.update([y_pred, y])
+
+        if dist.get_rank() == 1:
+            y_pred = in_tensor_a2.to(device)
+            y = in_tensor_b2.to(device)
+            metric.update([y_pred, y])
+
+        out_tensor = metric.compute()
+
+        # do numpy functions to get ground truth referece
+        out_tensor_np1 = maemetric_np(y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+        out_tensor_np2 = maemetric_np(y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+        np.testing.assert_allclose(out_tensor, out_tensor_np, rtol=1e-04, atol=1e-04)
+
+
+class DistributedRootMeanSquaredError(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_compute(self):
+        set_determinism(123)
+        self._compute()
+
+    def _compute(self):
+        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available() else "cpu"
+        metric = RootMeanSquaredError()
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        metric.attach(engine, "RMSE")
+
+        # get testing data
+        batch = BATCH_SIZE
+        base = BASE_DIM_SIZE
+        spatial = SPATIAL_DIM
+        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        if dist.get_rank() == 0:
+            y_pred = in_tensor_a1.to(device)
+            y = in_tensor_b1.to(device)
+            metric.update([y_pred, y])
+
+        if dist.get_rank() == 1:
+            y_pred = in_tensor_a2.to(device)
+            y = in_tensor_b2.to(device)
+            metric.update([y_pred, y])
+
+        out_tensor = metric.compute()
+
+        # do numpy functions to get ground truth referece
+        out_tensor_np1 = rmsemetric_np(y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+        out_tensor_np2 = rmsemetric_np(y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+        np.testing.assert_allclose(out_tensor, out_tensor_np, rtol=1e-04, atol=1e-04)
+
+
+class DistributedPeakSignalToNoiseRatio(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2)
+    def test_compute(self):
+        set_determinism(123)
+        self._compute()
+
+    def _compute(self):
+        device = f"cuda:{dist.get_rank()}" if torch.cuda.is_available() else "cpu"
+        max_val = 1.0
+        metric = PeakSignalToNoiseRatio(max_val=max_val)
+
+        def _val_func(engine, batch):
+            pass
+
+        engine = Engine(_val_func)
+        metric.attach(engine, "PSNR")
+
+        # get testing data
+        batch = BATCH_SIZE
+        base = BASE_DIM_SIZE
+        spatial = SPATIAL_DIM
+        in_tensor_a1 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b1 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        in_tensor_a2 = torch.rand((batch,) + (base,) * (spatial - 1))
+        in_tensor_b2 = torch.rand((batch,) + (base,) * (spatial - 1))
+
+        if dist.get_rank() == 0:
+            y_pred = in_tensor_a1.to(device)
+            y = in_tensor_b1.to(device)
+            metric.update([y_pred, y])
+
+        if dist.get_rank() == 1:
+            y_pred = in_tensor_a2.to(device)
+            y = in_tensor_b2.to(device)
+            metric.update([y_pred, y])
+
+        out_tensor = metric.compute()
+
+        # do numpy functions to get ground truth referece
+        out_tensor_np1 = psnrmetric_np(max_val=max_val, y_pred=in_tensor_a1.cpu().numpy(), y=in_tensor_b1.cpu().numpy())
+        out_tensor_np2 = psnrmetric_np(max_val=max_val, y_pred=in_tensor_a2.cpu().numpy(), y=in_tensor_b2.cpu().numpy())
+        out_tensor_np = (out_tensor_np1 + out_tensor_np2) / 2.0
+
+        np.testing.assert_allclose(out_tensor, out_tensor_np, rtol=1e-04, atol=1e-04)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_rocauc.py

@@ -0,0 +1,48 @@
+# 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 monai.handlers import ROCAUC
+from monai.transforms import Activations, AsDiscrete
+
+
+class TestHandlerROCAUC(unittest.TestCase):
+
+    def test_compute(self):
+        auc_metric = ROCAUC()
+        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]
+        auc_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]
+
+        auc_metric.update([y_pred, y])
+
+        auc = auc_metric.compute()
+        np.testing.assert_allclose(0.75, auc)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/handlers/test_handler_rocauc_dist.py

@@ -0,0 +1,54 @@
+# 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 ROCAUC
+from monai.transforms import Activations, AsDiscrete
+from tests.test_utils import DistCall, DistTestCase
+
+
+class DistributedROCAUC(DistTestCase):
+    @DistCall(nnodes=1, nproc_per_node=2, node_rank=0)
+    def test_compute(self):
+        auc_metric = ROCAUC()
+        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]
+        auc_metric.update([y_pred, y])
+
+        result = auc_metric.compute()
+        np.testing.assert_allclose(0.66667, result, rtol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()