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

tests/networks/nets/test_autoencoder.py

@@ -0,0 +1,95 @@
+# 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 Act
+from monai.networks.nets import AutoEncoder
+from tests.test_utils import test_script_save
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+TEST_CASE_0 = [  # single channel 2D, batch 4, no residual
+    {
+        "spatial_dims": 2,
+        "in_channels": 1,
+        "out_channels": 1,
+        "channels": (4, 8, 16),
+        "strides": (2, 2, 2),
+        "num_res_units": 0,
+    },
+    (1, 1, 128, 128),
+    (1, 1, 128, 128),
+]
+
+TEST_CASE_1 = [  # single channel 2D, batch 4
+    {"spatial_dims": 2, "in_channels": 1, "out_channels": 1, "channels": (4, 8, 16), "strides": (2, 2, 2)},
+    (1, 1, 128, 128),
+    (1, 1, 128, 128),
+]
+
+TEST_CASE_2 = [  # 3-channel 2D, batch 4, LeakyReLU activation
+    {
+        "spatial_dims": 2,
+        "in_channels": 3,
+        "out_channels": 3,
+        "channels": (4, 8, 16),
+        "strides": (2, 2, 2),
+        "act": (Act.LEAKYRELU, {"negative_slope": 0.2}),
+    },
+    (1, 3, 128, 128),
+    (1, 3, 128, 128),
+]
+
+TEST_CASE_3 = [  # 4-channel 3D, batch 4
+    {"spatial_dims": 3, "in_channels": 4, "out_channels": 3, "channels": (4, 8, 16), "strides": (2, 2, 2)},
+    (1, 4, 128, 128, 128),
+    (1, 3, 128, 128, 128),
+]
+
+CASES = [TEST_CASE_0, TEST_CASE_1, TEST_CASE_2, TEST_CASE_3]
+
+
+TEST_CASE_FAIL = {  # 2-channel 2D, should fail because of stride/channel mismatch.
+    "spatial_dims": 2,
+    "in_channels": 2,
+    "out_channels": 2,
+    "channels": (4, 8, 16),
+    "strides": (2, 2),
+}
+
+
+class TestAutoEncoder(unittest.TestCase):
+    @parameterized.expand(CASES)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        net = AutoEncoder(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_script(self):
+        net = AutoEncoder(spatial_dims=2, in_channels=1, out_channels=1, channels=(4, 8), strides=(2, 2))
+        test_data = torch.randn(2, 1, 32, 32)
+        test_script_save(net, test_data)
+
+    def test_channel_stride_difference(self):
+        with self.assertRaises(ValueError):
+            AutoEncoder(**TEST_CASE_FAIL)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_autoencoderkl.py

@@ -0,0 +1,337 @@
+# 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 tempfile
+import unittest
+from unittest import skipUnless
+
+import torch
+from parameterized import parameterized
+
+from monai.apps import download_url
+from monai.networks import eval_mode
+from monai.networks.nets import AutoencoderKL
+from monai.utils import optional_import
+from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_downloading_fails, testing_data_config
+
+tqdm, has_tqdm = optional_import("tqdm", name="tqdm")
+_, has_einops = optional_import("einops")
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+
+CASES_NO_ATTENTION = [
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+            "with_decoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+            "with_decoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16, 16),
+        (1, 1, 16, 16, 16),
+        (1, 4, 4, 4, 4),
+    ],
+]
+
+CASES_ATTENTION = [
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": (1, 1, 2),
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, False),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+            "with_encoder_nonlocal_attn": False,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 2,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, True),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16),
+        (1, 1, 16, 16),
+        (1, 4, 4, 4),
+    ],
+    [
+        {
+            "spatial_dims": 3,
+            "in_channels": 1,
+            "out_channels": 1,
+            "channels": (4, 4, 4),
+            "latent_channels": 4,
+            "attention_levels": (False, False, True),
+            "num_res_blocks": 1,
+            "norm_num_groups": 4,
+        },
+        (1, 1, 16, 16, 16),
+        (1, 1, 16, 16, 16),
+        (1, 4, 4, 4, 4),
+    ],
+]
+
+if has_einops:
+    CASES = CASES_NO_ATTENTION + CASES_ATTENTION
+else:
+    CASES = CASES_NO_ATTENTION
+
+
+class TestAutoEncoderKL(unittest.TestCase):
+    @parameterized.expand(CASES)
+    def test_shape(self, input_param, input_shape, expected_shape, expected_latent_shape):
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device))
+            self.assertEqual(result[0].shape, expected_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+            self.assertEqual(result[2].shape, expected_latent_shape)
+
+    @parameterized.expand(CASES)
+    @SkipIfBeforePyTorchVersion((1, 11))
+    def test_shape_with_convtranspose_and_checkpointing(
+        self, input_param, input_shape, expected_shape, expected_latent_shape
+    ):
+        input_param = input_param.copy()
+        input_param.update({"use_checkpoint": True, "use_convtranspose": True})
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.forward(torch.randn(input_shape).to(device))
+            self.assertEqual(result[0].shape, expected_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+            self.assertEqual(result[2].shape, expected_latent_shape)
+
+    def test_model_channels_not_multiple_of_norm_num_group(self):
+        with self.assertRaises(ValueError):
+            AutoencoderKL(
+                spatial_dims=2,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False, False),
+                latent_channels=8,
+                num_res_blocks=1,
+                norm_num_groups=16,
+            )
+
+    def test_model_num_channels_not_same_size_of_attention_levels(self):
+        with self.assertRaises(ValueError):
+            AutoencoderKL(
+                spatial_dims=2,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False),
+                latent_channels=8,
+                num_res_blocks=1,
+                norm_num_groups=16,
+            )
+
+    def test_model_num_channels_not_same_size_of_num_res_blocks(self):
+        with self.assertRaises(ValueError):
+            AutoencoderKL(
+                spatial_dims=2,
+                in_channels=1,
+                out_channels=1,
+                channels=(24, 24, 24),
+                attention_levels=(False, False, False),
+                latent_channels=8,
+                num_res_blocks=(8, 8),
+                norm_num_groups=16,
+            )
+
+    def test_shape_reconstruction(self):
+        input_param, input_shape, expected_shape, _ = CASES[0]
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.reconstruct(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape)
+
+    @SkipIfBeforePyTorchVersion((1, 11))
+    def test_shape_reconstruction_with_convtranspose_and_checkpointing(self):
+        input_param, input_shape, expected_shape, _ = CASES[0]
+        input_param = input_param.copy()
+        input_param.update({"use_checkpoint": True, "use_convtranspose": True})
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.reconstruct(torch.randn(input_shape).to(device))
+            self.assertEqual(result.shape, expected_shape)
+
+    def test_shape_encode(self):
+        input_param, input_shape, _, expected_latent_shape = CASES[0]
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.encode(torch.randn(input_shape).to(device))
+            self.assertEqual(result[0].shape, expected_latent_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+
+    @SkipIfBeforePyTorchVersion((1, 11))
+    def test_shape_encode_with_convtranspose_and_checkpointing(self):
+        input_param, input_shape, _, expected_latent_shape = CASES[0]
+        input_param = input_param.copy()
+        input_param.update({"use_checkpoint": True, "use_convtranspose": True})
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.encode(torch.randn(input_shape).to(device))
+            self.assertEqual(result[0].shape, expected_latent_shape)
+            self.assertEqual(result[1].shape, expected_latent_shape)
+
+    def test_shape_sampling(self):
+        input_param, _, _, expected_latent_shape = CASES[0]
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.sampling(
+                torch.randn(expected_latent_shape).to(device), torch.randn(expected_latent_shape).to(device)
+            )
+            self.assertEqual(result.shape, expected_latent_shape)
+
+    @SkipIfBeforePyTorchVersion((1, 11))
+    def test_shape_sampling_convtranspose_and_checkpointing(self):
+        input_param, _, _, expected_latent_shape = CASES[0]
+        input_param = input_param.copy()
+        input_param.update({"use_checkpoint": True, "use_convtranspose": True})
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.sampling(
+                torch.randn(expected_latent_shape).to(device), torch.randn(expected_latent_shape).to(device)
+            )
+            self.assertEqual(result.shape, expected_latent_shape)
+
+    def test_shape_decode(self):
+        input_param, expected_input_shape, _, latent_shape = CASES[0]
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.decode(torch.randn(latent_shape).to(device))
+            self.assertEqual(result.shape, expected_input_shape)
+
+    @SkipIfBeforePyTorchVersion((1, 11))
+    def test_shape_decode_convtranspose_and_checkpointing(self):
+        input_param, expected_input_shape, _, latent_shape = CASES[0]
+        input_param = input_param.copy()
+        input_param.update({"use_checkpoint": True, "use_convtranspose": True})
+        net = AutoencoderKL(**input_param).to(device)
+        with eval_mode(net):
+            result = net.decode(torch.randn(latent_shape).to(device))
+            self.assertEqual(result.shape, expected_input_shape)
+
+    @skipUnless(has_einops, "Requires einops")
+    def test_compatibility_with_monai_generative(self):
+        # test loading weights from a model saved in MONAI Generative, version 0.2.3
+        with skip_if_downloading_fails():
+            net = AutoencoderKL(
+                spatial_dims=2,
+                in_channels=1,
+                out_channels=1,
+                channels=(4, 4, 4),
+                latent_channels=4,
+                attention_levels=(False, False, True),
+                num_res_blocks=1,
+                norm_num_groups=4,
+            ).to(device)
+
+            tmpdir = tempfile.mkdtemp()
+            key = "autoencoderkl_monai_generative_weights"
+            url = testing_data_config("models", key, "url")
+            hash_type = testing_data_config("models", key, "hash_type")
+            hash_val = testing_data_config("models", key, "hash_val")
+            filename = "autoencoderkl_monai_generative_weights.pt"
+
+            weight_path = os.path.join(tmpdir, filename)
+            download_url(url=url, filepath=weight_path, hash_val=hash_val, hash_type=hash_type)
+
+            net.load_old_state_dict(torch.load(weight_path), verbose=False)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_basic_unet.py

@@ -0,0 +1,102 @@
+# 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.nets import BasicUNet
+from tests.test_utils import test_script_save
+
+CASES_1D = []
+for mode in ["pixelshuffle", "nontrainable", "deconv", None]:
+    kwargs = {"spatial_dims": 1, "in_channels": 5, "out_channels": 8}
+    if mode is not None:
+        kwargs["upsample"] = mode  # type: ignore
+    CASES_1D.append([kwargs, (10, 5, 33), (10, 8, 33)])
+
+CASES_2D = []
+for mode in ["pixelshuffle", "nontrainable", "deconv"]:
+    for d1 in range(33, 64, 14):
+        for d2 in range(63, 33, -21):
+            in_channels, out_channels = 2, 3
+            CASES_2D.append(
+                [
+                    {
+                        "spatial_dims": 2,
+                        "in_channels": in_channels,
+                        "out_channels": out_channels,
+                        "features": (12, 12, 13, 14, 15, 16),
+                        "upsample": mode,
+                    },
+                    (2, in_channels, d1, d2),
+                    (2, out_channels, d1, d2),
+                ]
+            )
+CASES_3D = [
+    [  # single channel 3D, batch 2
+        {
+            "spatial_dims": 3,
+            "in_channels": 1,
+            "out_channels": 2,
+            "features": (16, 20, 21, 22, 23, 11),
+            "upsample": "pixelshuffle",
+        },
+        (2, 1, 33, 34, 35),
+        (2, 2, 33, 34, 35),
+    ],
+    [  # 2-channel 3D, batch 3
+        {
+            "spatial_dims": 3,
+            "in_channels": 2,
+            "out_channels": 7,
+            "features": (14, 15, 16, 17, 18, 11),
+            "upsample": "deconv",
+        },
+        (3, 2, 33, 37, 34),
+        (3, 7, 33, 37, 34),
+    ],
+    [  # 4-channel 3D, batch 5
+        {
+            "spatial_dims": 3,
+            "in_channels": 4,
+            "out_channels": 2,
+            "features": (14, 15, 16, 17, 18, 10),
+            "upsample": "nontrainable",
+        },
+        (5, 4, 34, 35, 37),
+        (5, 2, 34, 35, 37),
+    ],
+]
+
+
+class TestBasicUNET(unittest.TestCase):
+    @parameterized.expand(CASES_1D + CASES_2D + CASES_3D)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(input_param)
+        net = BasicUNet(**input_param).to(device)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device))
+        self.assertEqual(result.shape, expected_shape)
+
+    def test_script(self):
+        net = BasicUNet(spatial_dims=2, in_channels=1, out_channels=3)
+        test_data = torch.randn(16, 1, 32, 32)
+        test_script_save(net, test_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_basic_unetplusplus.py

@@ -0,0 +1,109 @@
+# 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.nets import BasicUNetPlusPlus
+from tests.test_utils import test_script_save
+
+CASES_1D = []
+for mode in ["pixelshuffle", "nontrainable", "deconv", None]:
+    kwargs = {"spatial_dims": 1, "in_channels": 5, "out_channels": 8}
+    if mode is not None:
+        kwargs["upsample"] = mode  # type: ignore
+    CASES_1D.append([kwargs, (10, 5, 33), (10, 8, 33)])
+
+CASES_2D = []
+for mode in ["pixelshuffle", "nontrainable", "deconv"]:
+    for d1 in range(33, 64, 14):
+        for d2 in range(63, 33, -21):
+            in_channels, out_channels = 2, 3
+            CASES_2D.append(
+                [
+                    {
+                        "spatial_dims": 2,
+                        "in_channels": in_channels,
+                        "out_channels": out_channels,
+                        "features": (12, 12, 13, 14, 15, 16),
+                        "upsample": mode,
+                    },
+                    (2, in_channels, d1, d2),
+                    (2, out_channels, d1, d2),
+                ]
+            )
+CASES_3D = [
+    [  # single channel 3D, batch 2
+        {
+            "spatial_dims": 3,
+            "in_channels": 1,
+            "out_channels": 2,
+            "features": (16, 20, 21, 22, 23, 11),
+            "upsample": "pixelshuffle",
+        },
+        (2, 1, 33, 34, 35),
+        (2, 2, 33, 34, 35),
+    ],
+    [  # 2-channel 3D, batch 3
+        {
+            "spatial_dims": 3,
+            "in_channels": 2,
+            "out_channels": 7,
+            "features": (14, 15, 16, 17, 18, 11),
+            "upsample": "deconv",
+        },
+        (3, 2, 33, 37, 34),
+        (3, 7, 33, 37, 34),
+    ],
+    [  # 4-channel 3D, batch 5
+        {
+            "spatial_dims": 3,
+            "in_channels": 4,
+            "out_channels": 2,
+            "features": (14, 15, 16, 17, 18, 10),
+            "upsample": "nontrainable",
+        },
+        (5, 4, 34, 35, 37),
+        (5, 2, 34, 35, 37),
+    ],
+]
+
+
+class TestBasicUNETPlusPlus(unittest.TestCase):
+    @parameterized.expand(CASES_1D + CASES_2D + CASES_3D)
+    def test_shape(self, input_param, input_shape, expected_shape):
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(input_param)
+        net = BasicUNetPlusPlus(**input_param).to(device)
+        with eval_mode(net):
+            result = net(torch.randn(input_shape).to(device))
+        self.assertEqual(result[0].shape, expected_shape)
+
+    def test_deep_supervision_shape(self):
+        net = BasicUNetPlusPlus(spatial_dims=2, deep_supervision=True, in_channels=3, out_channels=3)
+        test_data = torch.randn(16, 3, 32, 32)
+        with eval_mode(net):
+            result = net(test_data)
+        self.assertEqual(result[0].shape, test_data.shape)
+
+    def test_script(self):
+        net = BasicUNetPlusPlus(spatial_dims=2, deep_supervision=True, in_channels=1, out_channels=3)
+        test_data = torch.randn(16, 1, 32, 32)
+        test_script_save(net, test_data)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/networks/nets/test_bundle_init_bundle.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 os
+import tempfile
+import unittest
+
+import torch
+
+from monai.networks.nets import UNet
+from tests.test_utils import command_line_tests, skip_if_windows
+
+
+@skip_if_windows
+class TestBundleInit(unittest.TestCase):
+    def test_bundle(self):
+        with tempfile.TemporaryDirectory() as tempdir:
+            net = UNet(2, 1, 1, [4, 8], [2])
+            torch.save(net.state_dict(), tempdir + "/test.pt")
+
+            bundle_root = tempdir + "/test_bundle"
+
+            cmd = [
+                "coverage",
+                "run",
+                "-m",
+                "monai.bundle",
+                "init_bundle",
+                bundle_root,
+                tempdir + "/test.pt",
+                "--dataset_license",
+                "True",
+            ]
+            command_line_tests(cmd)
+
+            self.assertTrue(os.path.exists(bundle_root + "/configs/metadata.json"))
+            self.assertTrue(os.path.exists(bundle_root + "/configs/inference.json"))
+            self.assertTrue(os.path.exists(bundle_root + "/models/model.pt"))
+            self.assertTrue(os.path.exists(bundle_root + "/LICENSE"))
+            self.assertTrue(os.path.exists(bundle_root + "/docs/README.md"))
+            self.assertTrue(os.path.exists(bundle_root + "/docs/data_license.txt"))
+
+
+if __name__ == "__main__":
+    unittest.main()