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

tests/networks/layers/test_gmm.py

@@ -0,0 +1,314 @@
+# 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 shutil
+import tempfile
+import unittest
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai._extensions import load_module
+from monai.networks.layers import GaussianMixtureModel
+from tests.test_utils import skip_if_darwin, skip_if_no_cuda, skip_if_quick, skip_if_windows
+
+TEST_CASES = [
+    [
+        # Case Description
+        "2 batches, 1 dimensions, 1 channels, 2 classes, 2 mixtures",
+        # Class Count
+        2,
+        # Mixture Count
+        1,
+        # Features
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [1, 1, 0, 0, 1]
+            ],
+            # Batch 1
+            [
+                # Channel 0
+                [0, 0.2, 1, 0.8, 0.5]
+            ],
+        ],
+        # Labels
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [1, -1, 0, -1, 1]
+            ],
+            # Batch 1
+            [
+                # Channel 0
+                [1, 1, 0, 0, -1]
+            ],
+        ],
+        # Expected
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [0, 0, 1, 1, 0],
+                # Channel 1
+                [1, 1, 0, 0, 1],
+            ],
+            # Batch 1
+            [
+                # Channel 0
+                [0, 0, 1, 1, 0.5],
+                # Channel 1
+                [1, 1, 0, 0, 0.5],
+            ],
+        ],
+    ],
+    [
+        # Case Description
+        "1 batches, 1 dimensions, 5 channels, 2 classes, 1 mixtures",
+        # Class Count
+        2,
+        # Mixture Count
+        1,
+        # Features
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [1.0, 0.9, 0.0, 0.0, 0.0],
+                # Channel 1
+                [0.0, 0.0, 0.3, 0.3, 0.4],
+                # Channel 2
+                [0.9, 0.8, 0.0, 0.0, 0.0],
+                # Channel 3
+                [0.7, 0.9, 0.0, 0.0, 0.0],
+                # Channel 4
+                [0.2, 0.1, 0.2, 0.2, 0.1],
+            ]
+        ],
+        # Labels
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [0, 0, -1, 1, 1]
+            ]
+        ],
+        # Expected
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [1, 1, 0, 0, 0],
+                # Channel 1
+                [0, 0, 1, 1, 1],
+            ]
+        ],
+    ],
+    [
+        # Case Description
+        "1 batches, 2 dimensions, 2 channels, 4 classes, 4 mixtures",
+        # Class Count
+        4,
+        # Mixture Count
+        1,
+        # Features
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [
+                    [0.8, 0.8, 0.0, 0.0, 0.0],
+                    [1.0, 0.9, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.8, 0.9],
+                    [0.0, 0.0, 0.0, 0.9, 1.0],
+                ],
+                # Channel 1
+                [
+                    [0.8, 0.8, 0.0, 0.0, 0.0],
+                    [0.7, 0.7, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.4, 0.5, 0.0, 0.0, 0.0],
+                    [0.7, 0.6, 0.0, 0.0, 0.0],
+                ],
+            ]
+        ],
+        # Labels
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [[-1, 1, -1, 0, -1], [1, -1, -1, -1, -1], [-1, -1, 0, -1, -1], [2, 2, -1, 3, -1], [-1, -1, -1, -1, 3]]
+            ]
+        ],
+        # Expected
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [
+                    [0.0, 0.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 1.0, 1.0],
+                    [1.0, 1.0, 1.0, 1.0, 1.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0],
+                ],
+                # Channel 1
+                [
+                    [1.0, 1.0, 0.0, 0.0, 0.0],
+                    [1.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                ],
+                # Channel 2
+                [
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [1.0, 1.0, 0.0, 0.0, 0.0],
+                    [1.0, 1.0, 0.0, 0.0, 0.0],
+                ],
+                # Channel 3
+                [
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 1.0],
+                    [0.0, 0.0, 0.0, 1.0, 1.0],
+                ],
+            ]
+        ],
+    ],
+    [
+        # Case Description
+        "1 batches, 3 dimensions, 1 channels, 2 classes, 1 mixtures",
+        # Class Count
+        2,
+        # Mixture Count
+        1,
+        # Features
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [
+                    # Slice 0
+                    [[0.7, 0.6, 0.0], [0.5, 0.4, 0.0], [0.0, 0.0, 0.0]],
+                    # Slice 1
+                    [[0.5, 0.6, 0.0], [0.4, 0.3, 0.0], [0.0, 0.0, 0.0]],
+                    # Slice 2
+                    [[0.3, 0.3, 0.0], [0.2, 0.1, 0.0], [0.0, 0.0, 0.0]],
+                ]
+            ]
+        ],
+        # Labels
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [
+                    # Slice 0
+                    [[0, -1, -1], [0, -1, -1], [-1, -1, 1]],
+                    # Slice 1
+                    [[0, 0, -1], [-1, -1, 1], [-1, 1, 1]],
+                    # Slice 2
+                    [[0, -1, -1], [-1, -1, -1], [-1, -1, -1]],
+                ]
+            ]
+        ],
+        # Expected
+        [
+            # Batch 0
+            [
+                # Channel 0
+                [
+                    # Slice 0
+                    [[1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+                    # Slice 1
+                    [[1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+                    # Slice 2
+                    [[1.0, 1.0, 0.0], [1.0, 1.0, 0.0], [0.0, 0.0, 0.0]],
+                ],
+                # Channel 1
+                [
+                    # Slice 0
+                    [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],
+                    # Slice 1
+                    [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],
+                    # Slice 2
+                    [[0.0, 0.0, 1.0], [0.0, 0.0, 1.0], [1.0, 1.0, 1.0]],
+                ],
+            ]
+        ],
+    ],
+]
+
+
+@skip_if_quick
+class GMMTestCase(unittest.TestCase):
+    def setUp(self):
+        self._var = os.environ.get("TORCH_EXTENSIONS_DIR")
+        self.tempdir = tempfile.mkdtemp()
+        os.environ["TORCH_EXTENSIONS_DIR"] = self.tempdir
+
+    def tearDown(self) -> None:
+        if self._var is None:
+            os.environ.pop("TORCH_EXTENSIONS_DIR", None)
+        else:
+            os.environ["TORCH_EXTENSIONS_DIR"] = f"{self._var}"
+        shutil.rmtree(self.tempdir)
+
+    @parameterized.expand(TEST_CASES)
+    @skip_if_no_cuda
+    def test_cuda(self, test_case_description, mixture_count, class_count, features, labels, expected):
+        # Device to run on
+        device = torch.device("cuda")
+
+        # Create tensors
+        features_tensor = torch.tensor(features, dtype=torch.float32, device=device)
+        labels_tensor = torch.tensor(labels, dtype=torch.int32, device=device)
+
+        # Create GMM
+        gmm = GaussianMixtureModel(features_tensor.size(1), mixture_count, class_count, verbose_build=True)
+        # reload GMM to confirm the build
+        _ = GaussianMixtureModel(features_tensor.size(1), mixture_count, class_count, verbose_build=False)
+        # reload quietly
+        _ = GaussianMixtureModel(features_tensor.size(1), mixture_count, class_count, verbose_build=True)
+
+        # Apply GMM
+        gmm.learn(features_tensor, labels_tensor)
+        results_tensor = gmm.apply(features_tensor)
+
+        # Read back results
+        results = results_tensor.cpu().numpy()
+
+        # Ensure result are as expected
+        np.testing.assert_allclose(results, expected, atol=1e-3)
+
+    @skip_if_darwin
+    @skip_if_windows
+    def test_load(self):
+        if not torch.cuda.is_available():
+            with self.assertRaisesRegex(ImportError, ".*symbol.*"):  # expecting import error if no cuda
+                load_module("gmm", {"CHANNEL_COUNT": 2, "MIXTURE_COUNT": 2, "MIXTURE_SIZE": 3}, verbose_build=True)
+        else:
+            load_module("gmm", {"CHANNEL_COUNT": 2, "MIXTURE_COUNT": 2, "MIXTURE_SIZE": 3}, verbose_build=True)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_grid_pull.py

@@ -0,0 +1,93 @@
+# 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.networks.layers import grid_pull
+from monai.networks.utils import meshgrid_ij
+from monai.utils import optional_import
+from tests.test_utils import skip_if_no_cpp_extension
+from tests.testing_data.cpp_resample_answers import Expected_1D_GP_bwd, Expected_1D_GP_fwd
+
+BType, has_b_type = optional_import("monai._C", name="BoundType")
+PType, has_p_type = optional_import("monai._C", name="InterpolationType")
+
+
+def make_grid(shape, dtype=None, device=None, requires_grad=True):
+    ranges = [torch.arange(float(s), dtype=dtype, device=device, requires_grad=requires_grad) for s in shape]
+    grid = torch.stack(meshgrid_ij(*ranges), dim=-1)
+    return grid[None]
+
+
+# 1D combinations of bounds/interpolations
+bounds = set(BType.__members__.values()) if has_b_type else []
+interps = set(PType.__members__.values()) if has_p_type else []
+device = "cuda" if torch.cuda.is_available() else "cpu"
+TEST_1D_GP = []
+for bound in bounds:
+    for interp in interps:
+        if not Expected_1D_GP_fwd or not Expected_1D_GP_bwd:
+            break  # skip if the testing data are unavailable
+        expected_val = Expected_1D_GP_fwd.pop(0)
+
+        for input_g in (True, False):
+            for grid_g in (True, False):
+                expected_grad = Expected_1D_GP_bwd.pop(0)
+                test_case = [
+                    {
+                        "input": torch.arange(10, dtype=torch.float, requires_grad=input_g, device=device).reshape(
+                            (1, 1, 10)
+                        ),
+                        "grid": make_grid((20,), dtype=torch.float, device=device, requires_grad=grid_g) + 0.5,
+                        "interpolation": interp,
+                        "bound": bound,
+                    },
+                    {"val": torch.tensor([[expected_val]]), "device": device, "grad": torch.tensor(expected_grad)},
+                ]
+                TEST_1D_GP.append(test_case)
+
+
+@skip_if_no_cpp_extension
+class TestGridPull(unittest.TestCase):
+    @parameterized.expand(TEST_1D_GP, skip_on_empty=True)
+    def test_grid_pull(self, input_param, expected):
+        result = grid_pull(**input_param)
+        if input_param["input"].requires_grad:
+            input_param["input"].retain_grad()
+        if input_param["grid"].requires_grad:
+            input_param["grid"].retain_grad()
+        if input_param["input"].requires_grad or input_param["grid"].requires_grad:
+            result.sum().backward()
+
+        grads = []
+        if input_param["input"].requires_grad:
+            grads.append(input_param["input"].grad.view(-1))
+        if input_param["grid"].requires_grad:
+            grads.append(input_param["grid"].grad.view(-1))
+        if not grads:
+            grads = torch.tensor(0.0, device=result.device)
+        elif len(grads) == 1:
+            grads = grads[0]
+        else:
+            grads = torch.cat(grads, dim=0)
+        self.assertTrue(f"{result.device}".startswith(expected["device"]))
+        np.testing.assert_allclose(result.detach().cpu().numpy(), expected["val"].cpu().numpy(), rtol=1e-4, atol=1e-4)
+        np.testing.assert_allclose(grads.detach().cpu().numpy(), expected["grad"].cpu().numpy(), rtol=1e-4, atol=1e-4)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_hilbert_transform.py

@@ -0,0 +1,131 @@
+# 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.networks.layers import HilbertTransform
+from monai.utils import OptionalImportError
+from tests.test_utils import SkipIfModule, SkipIfNoModule
+
+
+def create_expected_numpy_output(input_datum, **kwargs):
+    x = np.fft.fft(input_datum.cpu().numpy(), **kwargs)
+    f = np.fft.fftfreq(x.shape[kwargs["axis"]])
+    u = np.heaviside(f, 0.5)
+    new_dims_before = kwargs["axis"]
+    new_dims_after = len(x.shape) - kwargs["axis"] - 1
+    for _ in range(new_dims_before):
+        u = np.expand_dims(u, 0)
+    for _ in range(new_dims_after):
+        u = np.expand_dims(u, -1)
+    ht = np.fft.ifft(x * 2 * u, axis=kwargs["axis"])
+
+    return ht
+
+
+cpu = torch.device("cpu")
+n_samples = 500
+hann_windowed_sine = np.sin(2 * np.pi * 10 * np.linspace(0, 1, n_samples)) * np.hanning(n_samples)
+
+# CPU TEST DATA
+
+cpu_input_data = {}
+cpu_input_data["1D"] = torch.as_tensor(hann_windowed_sine, device=cpu)[None, None]
+cpu_input_data["2D"] = torch.as_tensor(np.stack([hann_windowed_sine] * 10, axis=1), device=cpu)[None, None]
+cpu_input_data["3D"] = torch.as_tensor(
+    np.stack([np.stack([hann_windowed_sine] * 10, axis=1)] * 10, axis=2), device=cpu
+)[None, None]
+cpu_input_data["1D 2CH"] = torch.as_tensor(np.stack([hann_windowed_sine] * 10, axis=1), device=cpu)[None]
+cpu_input_data["2D 2CH"] = torch.as_tensor(
+    np.stack([np.stack([hann_windowed_sine] * 10, axis=1)] * 10, axis=2), device=cpu
+)[None]
+
+# SINGLE-CHANNEL CPU VALUE TESTS
+
+TEST_CASE_1D_SINE_CPU = [
+    {},  # args (empty, so use default)
+    cpu_input_data["1D"],  # Input data: Random 1D signal
+    create_expected_numpy_output(cpu_input_data["1D"], axis=2),  # Expected output: FFT of signal
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASE_2D_SINE_CPU = [
+    {},  # args (empty, so use default)
+    cpu_input_data["2D"],  # Input data: Random 1D signal
+    create_expected_numpy_output(cpu_input_data["2D"], axis=2),  # Expected output: FFT of signal
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASE_3D_SINE_CPU = [
+    {},  # args (empty, so use default)
+    cpu_input_data["3D"],  # Input data: Random 1D signal
+    create_expected_numpy_output(cpu_input_data["3D"], axis=2),
+    1e-5,  # absolute tolerance
+]
+
+# MULTICHANNEL CPU VALUE TESTS, PROCESS ALONG FIRST SPATIAL AXIS
+
+TEST_CASE_1D_2CH_SINE_CPU = [
+    {},  # args (empty, so use default)
+    cpu_input_data["1D 2CH"],  # Input data: Random 1D signal
+    create_expected_numpy_output(cpu_input_data["1D 2CH"], axis=2),
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASE_2D_2CH_SINE_CPU = [
+    {},  # args (empty, so use default)
+    cpu_input_data["2D 2CH"],  # Input data: Random 1D signal
+    create_expected_numpy_output(cpu_input_data["2D 2CH"], axis=2),
+    1e-5,  # absolute tolerance
+]
+
+TEST_CASES_CPU = [
+    TEST_CASE_1D_SINE_CPU,
+    TEST_CASE_2D_SINE_CPU,
+    TEST_CASE_3D_SINE_CPU,
+    TEST_CASE_1D_2CH_SINE_CPU,
+    TEST_CASE_2D_2CH_SINE_CPU,
+]
+
+# GPU TEST DATA
+
+if torch.cuda.is_available():
+    gpu = torch.device("cuda")
+    TEST_CASES_GPU = [[args, image.to(gpu), exp_data, atol] for args, image, exp_data, atol in TEST_CASES_CPU]
+else:
+    TEST_CASES_GPU = []
+
+# TESTS CHECKING PADDING, AXIS SELECTION ETC ARE COVERED BY test_detect_envelope.py
+
+
+@SkipIfNoModule("torch.fft")
+class TestHilbertTransformCPU(unittest.TestCase):
+    @parameterized.expand(TEST_CASES_CPU + TEST_CASES_GPU)
+    def test_value(self, arguments, image, expected_data, atol):
+        result = HilbertTransform(**arguments)(image)
+        result = np.squeeze(result.cpu().numpy())
+        np.testing.assert_allclose(result, expected_data.squeeze(), atol=atol)
+
+
+@SkipIfModule("torch.fft")
+class TestHilbertTransformNoFFTMod(unittest.TestCase):
+    def test_no_fft_module_error(self):
+        self.assertRaises(OptionalImportError, HilbertTransform(), torch.randn(1, 1, 10))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_lltm.py

@@ -0,0 +1,62 @@
+# 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 torch
+from parameterized import parameterized
+
+from monai.networks.layers import LLTM
+from tests.test_utils import SkipIfNoModule, assert_allclose, is_tf32_env
+
+_rtol = 0.001 if is_tf32_env() else 0.0001
+
+TEST_CASE_1 = [
+    {"input_features": 32, "state_size": 2},
+    torch.tensor([[-0.1622, 0.1663], [0.5465, 0.0459], [-0.1436, 0.6171], [0.3632, -0.0111]]),
+    torch.tensor([[-1.3773, 0.3348], [0.8353, 1.3064], [-0.2179, 4.1739], [1.3045, -0.1444]]),
+]
+
+
+class TestLLTM(unittest.TestCase):
+    @parameterized.expand([TEST_CASE_1])
+    @SkipIfNoModule("monai._C")
+    def test_value(self, input_param, expected_h, expected_c):
+        torch.manual_seed(0)
+        x = torch.randn(4, 32)
+        h = torch.randn(4, 2)
+        c = torch.randn(4, 2)
+        new_h, new_c = LLTM(**input_param)(x, (h, c))
+        (new_h.sum() + new_c.sum()).backward()
+
+        assert_allclose(new_h, expected_h, rtol=0.0001, atol=1e-04)
+        assert_allclose(new_c, expected_c, rtol=0.0001, atol=1e-04)
+
+    @parameterized.expand([TEST_CASE_1])
+    @SkipIfNoModule("monai._C")
+    def test_value_cuda(self, input_param, expected_h, expected_c):
+        device = torch.device("cuda:0") if torch.cuda.is_available() else torch.device("cpu:0")
+        torch.manual_seed(0)
+        x = torch.randn(4, 32).to(device)
+        h = torch.randn(4, 2).to(device)
+        c = torch.randn(4, 2).to(device)
+        lltm = LLTM(**input_param).to(device)
+        new_h, new_c = lltm(x, (h, c))
+        (new_h.sum() + new_c.sum()).backward()
+
+        assert_allclose(new_h, expected_h.to(device), rtol=_rtol, atol=0.001)
+        assert_allclose(new_c, expected_c.to(device), rtol=_rtol, atol=0.001)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_median_filter.py

@@ -0,0 +1,52 @@
+# 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.networks.layers import MedianFilter
+
+
+class MedianFilterTestCase(unittest.TestCase):
+
+    @parameterized.expand([(torch.ones(1, 1, 2, 3, 5), [1, 2, 4]), (torch.ones(1, 1, 4, 3, 4), 1)])  # 3d_big  # 3d
+    def test_3d(self, input_tensor, radius):
+        filter = MedianFilter(radius).to(torch.device("cpu:0"))
+
+        expected = input_tensor.numpy()
+        output = filter(input_tensor).cpu().numpy()
+
+        np.testing.assert_allclose(output, expected, rtol=1e-5)
+
+    def test_3d_radii(self):
+        a = torch.ones(1, 1, 4, 3, 2)
+        g = MedianFilter([3, 2, 1]).to(torch.device("cpu:0"))
+
+        expected = a.numpy()
+        out = g(a).cpu().numpy()
+        np.testing.assert_allclose(out, expected, rtol=1e-5)
+        if torch.cuda.is_available():
+            g = MedianFilter([3, 2, 1]).to(torch.device("cuda:0"))
+            np.testing.assert_allclose(g(a.cuda()).cpu().numpy(), expected, rtol=1e-2)
+
+    def test_wrong_args(self):
+        with self.assertRaisesRegex(ValueError, ""):
+            MedianFilter([3, 2]).to(torch.device("cpu:0"))
+        MedianFilter([3, 2, 1]).to(torch.device("cpu:0"))  # test init
+
+
+if __name__ == "__main__":
+    unittest.main()