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

tests/networks/layers/test_polyval.py

@@ -0,0 +1,55 @@
+# 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 polyval
+
+TEST_CASES = [
+    [[1.0, 2.5, -4.2], 5.0, 33.3],
+    [[2, 1, 0], 3.0, 21],
+    [[2, 1, 0], [3.0, 3.0], [21, 21]],
+    [torch.as_tensor([2, 1, 0]), [3.0, 3.0], [21, 21]],
+    [torch.as_tensor([2, 1, 0]), torch.as_tensor([3.0, 3.0]), [21, 21]],
+    [torch.as_tensor([2, 1, 0]), np.array([3.0, 3.0]), [21, 21]],
+    [[], np.array([3.0, 3.0]), [0, 0]],
+]
+
+
+class TestPolyval(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_floats(self, coef, x, expected):
+        result = polyval(coef, x)
+        np.testing.assert_allclose(result.cpu().numpy(), expected)
+
+    @parameterized.expand(TEST_CASES)
+    def test_gpu(self, coef, x, expected):
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        x = torch.as_tensor(x, dtype=torch.float, device=device)
+        x.requires_grad = True
+        coef = torch.as_tensor(coef, dtype=torch.float, device=device)
+        coef.requires_grad = True
+        result = polyval(coef, x)
+        if coef.shape[0] > 0:  # empty coef doesn't have grad
+            result.mean().backward()
+            np.testing.assert_allclose(coef.grad.shape, coef.shape)
+        np.testing.assert_allclose(result.cpu().detach().numpy(), expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_preset_filters.py

@@ -0,0 +1,136 @@
+# 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 ApplyFilter, EllipticalFilter, LaplaceFilter, MeanFilter, SharpenFilter
+
+TEST_CASES_MEAN = [(3, 3, torch.ones(3, 3, 3)), (2, 5, torch.ones(5, 5))]
+
+TEST_CASES_LAPLACE = [
+    (
+        3,
+        3,
+        torch.Tensor(
+            [
+                [[-1, -1, -1], [-1, -1, -1], [-1, -1, -1]],
+                [[-1, -1, -1], [-1, 26, -1], [-1, -1, -1]],
+                [[-1, -1, -1], [-1, -1, -1], [-1, -1, -1]],
+            ]
+        ),
+    ),
+    (2, 3, torch.Tensor([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]])),
+]
+
+TEST_CASES_ELLIPTICAL = [
+    (
+        3,
+        3,
+        torch.Tensor(
+            [[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]]
+        ),
+    ),
+    (2, 3, torch.Tensor([[0, 1, 0], [1, 1, 1], [0, 1, 0]])),
+]
+
+TEST_CASES_SHARPEN = [
+    (
+        3,
+        3,
+        torch.Tensor(
+            [
+                [[0, 0, 0], [0, -1, 0], [0, 0, 0]],
+                [[0, -1, 0], [-1, 7, -1], [0, -1, 0]],
+                [[0, 0, 0], [0, -1, 0], [0, 0, 0]],
+            ]
+        ),
+    ),
+    (2, 3, torch.Tensor([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])),
+]
+
+
+class _TestFilter:
+
+    def test_init(self, spatial_dims, size, expected):
+        test_filter = self.filter_class(spatial_dims=spatial_dims, size=size)
+        torch.testing.assert_allclose(expected, test_filter.filter)
+        self.assertIsInstance(test_filter, torch.nn.Module)
+
+    def test_forward(self):
+        test_filter = self.filter_class(spatial_dims=2, size=3)
+        input = torch.ones(1, 1, 5, 5)
+        _ = test_filter(input)
+
+
+class TestApplyFilter(unittest.TestCase):
+
+    def test_init_and_forward_2d(self):
+        filter_2d = torch.ones(3, 3)
+        image_2d = torch.ones(1, 3, 3)
+        apply_filter_2d = ApplyFilter(filter_2d)
+        out = apply_filter_2d(image_2d)
+        self.assertEqual(out.shape, image_2d.shape)
+
+    def test_init_and_forward_3d(self):
+        filter_2d = torch.ones(3, 3, 3)
+        image_2d = torch.ones(1, 3, 3, 3)
+        apply_filter_2d = ApplyFilter(filter_2d)
+        out = apply_filter_2d(image_2d)
+        self.assertEqual(out.shape, image_2d.shape)
+
+
+class MeanFilterTestCase(_TestFilter, unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.filter_class = MeanFilter
+
+    @parameterized.expand(TEST_CASES_MEAN)
+    def test_init(self, spatial_dims, size, expected):
+        super().test_init(spatial_dims, size, expected)
+
+
+class LaplaceFilterTestCase(_TestFilter, unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.filter_class = LaplaceFilter
+
+    @parameterized.expand(TEST_CASES_LAPLACE)
+    def test_init(self, spatial_dims, size, expected):
+        super().test_init(spatial_dims, size, expected)
+
+
+class EllipticalTestCase(_TestFilter, unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.filter_class = EllipticalFilter
+
+    @parameterized.expand(TEST_CASES_ELLIPTICAL)
+    def test_init(self, spatial_dims, size, expected):
+        super().test_init(spatial_dims, size, expected)
+
+
+class SharpenTestCase(_TestFilter, unittest.TestCase):
+
+    def setUp(self) -> None:
+        self.filter_class = SharpenFilter
+
+    @parameterized.expand(TEST_CASES_SHARPEN)
+    def test_init(self, spatial_dims, size, expected):
+        super().test_init(spatial_dims, size, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_savitzky_golay_filter.py

@@ -0,0 +1,141 @@
+# 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 SavitzkyGolayFilter
+from tests.test_utils import skip_if_no_cuda
+
+# Zero-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE = [
+    {"window_length": 3, "order": 1},
+    torch.Tensor([1.0]).unsqueeze(0).unsqueeze(0),  # Input data: Single value
+    torch.Tensor([1 / 3]).unsqueeze(0).unsqueeze(0),  # Expected output: With a window length of 3 and polyorder 1
+    # output should be equal to mean of 0, 1 and 0 = 1/3 (because input will be zero-padded and a linear fit performed)
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_1D = [
+    {"window_length": 3, "order": 1},
+    torch.Tensor([1.0, 1.0, 1.0]).unsqueeze(0).unsqueeze(0),  # Input data
+    torch.Tensor([2 / 3, 1.0, 2 / 3])
+    .unsqueeze(0)
+    .unsqueeze(0),  # Expected output: zero padded, so linear interpolation
+    # over length-3 windows will result in output of [2/3, 1, 2/3].
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_2 = [
+    {"window_length": 3, "order": 1},  # along default axis (2, first spatial dim)
+    torch.ones((3, 2)).unsqueeze(0).unsqueeze(0),
+    torch.Tensor([[2 / 3, 2 / 3], [1.0, 1.0], [2 / 3, 2 / 3]]).unsqueeze(0).unsqueeze(0),
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_3 = [
+    {"window_length": 3, "order": 1, "axis": 3},  # along axis 3 (second spatial dim)
+    torch.ones((2, 3)).unsqueeze(0).unsqueeze(0),
+    torch.Tensor([[2 / 3, 1.0, 2 / 3], [2 / 3, 1.0, 2 / 3]]).unsqueeze(0).unsqueeze(0),
+    1e-6,  # absolute tolerance
+]
+
+# Replicated-padding trivial tests
+
+TEST_CASE_SINGLE_VALUE_REP = [
+    {"window_length": 3, "order": 1, "mode": "replicate"},
+    torch.Tensor([1.0]).unsqueeze(0).unsqueeze(0),  # Input data: Single value
+    torch.Tensor([1.0]).unsqueeze(0).unsqueeze(0),  # Expected output: With a window length of 3 and polyorder 1
+    # output will be equal to mean of [1, 1, 1] = 1 (input will be nearest-neighbour-padded and a linear fit performed)
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_1D_REP = [
+    {"window_length": 3, "order": 1, "mode": "replicate"},
+    torch.Tensor([1.0, 1.0, 1.0]).unsqueeze(0).unsqueeze(0),  # Input data
+    torch.Tensor([1.0, 1.0, 1.0]).unsqueeze(0).unsqueeze(0),  # Expected output: zero padded, so linear interpolation
+    # over length-3 windows will result in output of [2/3, 1, 2/3].
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_2_REP = [
+    {"window_length": 3, "order": 1, "mode": "replicate"},  # along default axis (2, first spatial dim)
+    torch.ones((3, 2)).unsqueeze(0).unsqueeze(0),
+    torch.Tensor([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0]]).unsqueeze(0).unsqueeze(0),
+    1e-6,  # absolute tolerance
+]
+
+TEST_CASE_2D_AXIS_3_REP = [
+    {"window_length": 3, "order": 1, "axis": 3, "mode": "replicate"},  # along axis 3 (second spatial dim)
+    torch.ones((2, 3)).unsqueeze(0).unsqueeze(0),
+    torch.Tensor([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]).unsqueeze(0).unsqueeze(0),
+    1e-6,  # absolute tolerance
+]
+
+# Sine smoothing
+
+TEST_CASE_SINE_SMOOTH = [
+    {"window_length": 3, "order": 1},
+    # Sine wave with period equal to savgol window length (windowed to reduce edge effects).
+    torch.as_tensor(np.sin(2 * np.pi * 1 / 3 * np.arange(100)) * np.hanning(100)).unsqueeze(0).unsqueeze(0),
+    # Should be smoothed out to zeros
+    torch.zeros(100).unsqueeze(0).unsqueeze(0),
+    # tolerance chosen by examining output of SciPy.signal.savgol_filter when provided the above input
+    2e-2,  # absolute tolerance
+]
+
+
+class TestSavitzkyGolayCPU(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE, TEST_CASE_1D, TEST_CASE_2D_AXIS_2, TEST_CASE_2D_AXIS_3, TEST_CASE_SINE_SMOOTH]
+    )
+    def test_value(self, arguments, image, expected_data, atol, rtol=1e-5):
+        result = SavitzkyGolayFilter(**arguments)(image)
+        np.testing.assert_allclose(result, expected_data, atol=atol, rtol=rtol)
+
+
+class TestSavitzkyGolayCPUREP(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE_REP, TEST_CASE_1D_REP, TEST_CASE_2D_AXIS_2_REP, TEST_CASE_2D_AXIS_3_REP]
+    )
+    def test_value(self, arguments, image, expected_data, atol, rtol=1e-5):
+        result = SavitzkyGolayFilter(**arguments)(image)
+        np.testing.assert_allclose(result, expected_data, atol=atol, rtol=rtol)
+
+
+@skip_if_no_cuda
+class TestSavitzkyGolayGPU(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE, TEST_CASE_1D, TEST_CASE_2D_AXIS_2, TEST_CASE_2D_AXIS_3, TEST_CASE_SINE_SMOOTH]
+    )
+    def test_value(self, arguments, image, expected_data, atol, rtol=1e-5):
+        result = SavitzkyGolayFilter(**arguments)(image.to(device="cuda"))
+        np.testing.assert_allclose(result.cpu(), expected_data, atol=atol, rtol=rtol)
+
+
+@skip_if_no_cuda
+class TestSavitzkyGolayGPUREP(unittest.TestCase):
+    @parameterized.expand(
+        [TEST_CASE_SINGLE_VALUE_REP, TEST_CASE_1D_REP, TEST_CASE_2D_AXIS_2_REP, TEST_CASE_2D_AXIS_3_REP]
+    )
+    def test_value(self, arguments, image, expected_data, atol, rtol=1e-5):
+        result = SavitzkyGolayFilter(**arguments)(image.to(device="cuda"))
+        np.testing.assert_allclose(result.cpu(), expected_data, atol=atol, rtol=rtol)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_separable_filter.py

@@ -0,0 +1,87 @@
+# 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.networks.layers import separable_filtering
+
+
+class SeparableFilterTestCase(unittest.TestCase):
+
+    def test_1d(self):
+        a = torch.tensor([[list(range(10))]], dtype=torch.float)
+        out = separable_filtering(a, torch.tensor([-1, 0, 1]))
+        expected = np.array([[[1.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, -8.0]]])
+        np.testing.assert_allclose(out.cpu().numpy(), expected, rtol=1e-4)
+        if torch.cuda.is_available():
+            out = separable_filtering(a.cuda(), torch.tensor([-1, 0, 1]).cuda())
+            np.testing.assert_allclose(out.cpu().numpy(), expected, rtol=1e-4)
+
+    def test_2d(self):
+        a = torch.tensor([[[list(range(7)), list(range(7, 0, -1)), list(range(7))]]], dtype=torch.float)
+        expected = np.array(
+            [
+                [28.0, 28.0, 28.0, 28.0, 28.0, 28.0],
+                [30.0, 34.0, 38.0, 42.0, 46.0, 50.0],
+                [28.0, 28.0, 28.0, 28.0, 28.0, 28.0],
+            ]
+        )
+        expected = expected[None][None]
+        out = separable_filtering(a, [torch.tensor([1, 1, 1]), torch.tensor([2, 2])])
+        np.testing.assert_allclose(out.cpu().numpy(), expected, rtol=1e-4)
+        if torch.cuda.is_available():
+            out = separable_filtering(a.cuda(), [torch.tensor([1, 1, 1]).cuda(), torch.tensor([2, 2]).cuda()])
+            np.testing.assert_allclose(out.cpu().numpy(), expected, rtol=1e-4)
+
+    def test_3d(self):
+        a = torch.tensor(
+            [[list(range(7)), list(range(7)), list(range(7))], [list(range(7)), list(range(7)), list(range(7))]],
+            dtype=torch.float,
+        )
+        a = a[None][None]
+        a = a.expand(2, 3, -1, -1, -1)
+        expected = np.array(
+            [
+                [
+                    [4.0, 12.0, 24.0, 36.0, 48.0, 60.0, 44.0],
+                    [6.0, 18.0, 36.0, 54.0, 72.0, 90.0, 66.0],
+                    [4.0, 12.0, 24.0, 36.0, 48.0, 60.0, 44.0],
+                ],
+                [
+                    [4.0, 12.0, 24.0, 36.0, 48.0, 60.0, 44.0],
+                    [6.0, 18.0, 36.0, 54.0, 72.0, 90.0, 66.0],
+                    [4.0, 12.0, 24.0, 36.0, 48.0, 60.0, 44.0],
+                ],
+            ]
+        )
+        # testing shapes
+        k = torch.tensor([1, 1, 1])
+        for kernel in (k, [k] * 3):
+            out = separable_filtering(a, kernel)
+            np.testing.assert_allclose(out.cpu().numpy()[1][2], expected, rtol=1e-4)
+            if torch.cuda.is_available():
+                out = separable_filtering(
+                    a.cuda(), kernel.cuda() if isinstance(kernel, torch.Tensor) else [k.cuda() for k in kernel]
+                )
+                np.testing.assert_allclose(out.cpu().numpy()[0][1], expected, rtol=1e-4)
+
+    def test_wrong_args(self):
+        with self.assertRaisesRegex(TypeError, ""):
+            separable_filtering(((1, 1, 1, 2, 3, 2)), torch.ones((2,)))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_skip_connection.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 torch
+from parameterized import parameterized
+
+from monai.networks import eval_mode
+from monai.networks.layers import SkipConnection
+
+TEST_CASES_3D = []
+for type_1 in ("cat", "add", "mul"):
+    input_shape = (16, 10, 32, 24, 48)
+    if type_1 == "cat":
+        result_shape = (input_shape[0] * 2, *input_shape[1:])
+    else:
+        result_shape = input_shape
+    test_case = [{"dim": 0, "mode": type_1}, input_shape, result_shape]
+    TEST_CASES_3D.append(test_case)
+
+
+class TestSkipConnection(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES_3D)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = SkipConnection(submodule=torch.nn.Softmax(dim=1), **input_param)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_wrong_mode(self):
+        with self.assertRaises(ValueError):
+            SkipConnection(torch.nn.Softmax(dim=1), mode="test")(torch.randn(10, 10))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_vector_quantizer.py

@@ -0,0 +1,89 @@
+# 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 math import prod
+
+import torch
+from parameterized import parameterized
+
+from monai.networks.layers import EMAQuantizer, VectorQuantizer
+
+TEST_CASES = [
+    [{"spatial_dims": 2, "num_embeddings": 16, "embedding_dim": 8}, (1, 8, 4, 4), (1, 4, 4)],
+    [{"spatial_dims": 3, "num_embeddings": 16, "embedding_dim": 8}, (1, 8, 4, 4, 4), (1, 4, 4, 4)],
+]
+
+
+class TestEMA(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_ema_shape(self, input_param, input_shape, output_shape):
+        layer = EMAQuantizer(**input_param)
+        x = torch.randn(input_shape)
+        layer = layer.train()
+        outputs = layer(x)
+        self.assertEqual(outputs[0].shape, input_shape)
+        self.assertEqual(outputs[2].shape, output_shape)
+
+        layer = layer.eval()
+        outputs = layer(x)
+        self.assertEqual(outputs[0].shape, input_shape)
+        self.assertEqual(outputs[2].shape, output_shape)
+
+    @parameterized.expand(TEST_CASES)
+    def test_ema_quantize(self, input_param, input_shape, output_shape):
+        layer = EMAQuantizer(**input_param)
+        x = torch.randn(input_shape)
+        outputs = layer.quantize(x)
+        self.assertEqual(outputs[0].shape, (prod(input_shape[2:]), input_shape[1]))  # (HxW[xD], C)
+        self.assertEqual(outputs[1].shape, (prod(input_shape[2:]), input_param["num_embeddings"]))  # (HxW[xD], E)
+        self.assertEqual(outputs[2].shape, (input_shape[0],) + input_shape[2:])  # (1, H, W, [D])
+
+    def test_ema(self):
+        layer = EMAQuantizer(spatial_dims=2, num_embeddings=2, embedding_dim=2, epsilon=0, decay=0)
+        original_weight_0 = layer.embedding.weight[0].clone()
+        original_weight_1 = layer.embedding.weight[1].clone()
+        x_0 = original_weight_0
+        x_0 = x_0.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)
+        x_0 = x_0.repeat(1, 1, 1, 2) + 0.001
+
+        x_1 = original_weight_1
+        x_1 = x_1.unsqueeze(0).unsqueeze(-1).unsqueeze(-1)
+        x_1 = x_1.repeat(1, 1, 1, 2)
+
+        x = torch.cat([x_0, x_1], dim=0)
+        layer = layer.train()
+        _ = layer(x)
+
+        self.assertTrue(all(layer.embedding.weight[0] != original_weight_0))
+        self.assertTrue(all(layer.embedding.weight[1] == original_weight_1))
+
+
+class TestVectorQuantizer(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_vector_quantizer_shape(self, input_param, input_shape, output_shape):
+        layer = VectorQuantizer(EMAQuantizer(**input_param))
+        x = torch.randn(input_shape)
+        outputs = layer(x)
+        self.assertEqual(outputs[1].shape, input_shape)
+
+    @parameterized.expand(TEST_CASES)
+    def test_vector_quantizer_quantize(self, input_param, input_shape, output_shape):
+        layer = VectorQuantizer(EMAQuantizer(**input_param))
+        x = torch.randn(input_shape)
+        outputs = layer.quantize(x)
+        self.assertEqual(outputs.shape, output_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/layers/test_weight_init.py

@@ -0,0 +1,50 @@
+# 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 trunc_normal_
+
+TEST_CASES = [
+    [{"mean": 0.0, "std": 1.0, "a": 2, "b": 4}, (6, 12, 3, 1, 7)],
+    [{"mean": 0.3, "std": 0.6, "a": -1.0, "b": 1.3}, (1, 4, 4, 4)],
+    [{"mean": 0.1, "std": 0.4, "a": 1.3, "b": 1.8}, (5, 7, 7, 8, 9)],
+]
+
+TEST_ERRORS = [
+    [{"mean": 0.0, "std": 1.0, "a": 5, "b": 1.1}, (1, 1, 8, 8, 8)],
+    [{"mean": 0.3, "std": -0.1, "a": 1.0, "b": 2.0}, (8, 5, 2, 6, 9)],
+    [{"mean": 0.7, "std": 0.0, "a": 0.1, "b": 2.0}, (4, 12, 23, 17)],
+]
+
+
+class TestWeightInit(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_shape(self, input_param, input_shape):
+        im = torch.rand(input_shape)
+        trunc_normal_(im, **input_param)
+        self.assertEqual(im.shape, input_shape)
+
+    @parameterized.expand(TEST_ERRORS)
+    def test_ill_arg(self, input_param, input_shape):
+        with self.assertRaises(ValueError):
+            im = torch.rand(input_shape)
+            trunc_normal_(im, **input_param)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/__init__.py

@@ -0,0 +1,10 @@
+# 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.

tests/networks/nets/dints/__init__.py

@@ -0,0 +1,10 @@
+# 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.