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

tests/apps/test_mmar_download.py

@@ -0,0 +1,154 @@
+# 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 pathlib import Path
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai import __version__
+from monai.apps import download_mmar, load_from_mmar
+from monai.apps.mmars import MODEL_DESC
+from monai.apps.mmars.mmars import _get_val
+from monai.utils import version_leq
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+TEST_CASES = [["clara_pt_prostate_mri_segmentation"], ["clara_pt_covid19_ct_lesion_segmentation"]]
+TEST_EXTRACT_CASES = [
+    (
+        {"item": "clara_pt_prostate_mri_segmentation", "map_location": "cuda" if torch.cuda.is_available() else "cpu"},
+        "UNet",
+        np.array(
+            [
+                [[-0.0838, 0.0116, -0.0861], [-0.0792, 0.2216, -0.0301], [-0.0379, 0.0006, -0.0399]],
+                [[-0.0347, 0.0979, 0.0754], [0.1689, 0.3759, 0.2584], [-0.0698, 0.2740, 0.1414]],
+                [[-0.0772, 0.1046, -0.0103], [0.0917, 0.1942, 0.0284], [-0.0165, -0.0181, 0.0247]],
+            ]
+        ),
+    ),
+    (
+        {
+            "item": "clara_pt_covid19_ct_lesion_segmentation",
+            "map_location": "cuda" if torch.cuda.is_available() else "cpu",
+        },
+        "SegResNet",
+        np.array(
+            [
+                [
+                    [0.01671106, 0.08502351, -0.1766469],
+                    [-0.13039736, -0.06137804, 0.03924942],
+                    [0.02268324, 0.159056, -0.03485069],
+                ],
+                [
+                    [0.04788467, -0.09365353, -0.05802464],
+                    [-0.19500689, -0.13514304, -0.08191573],
+                    [0.0238207, 0.08029253, 0.10818923],
+                ],
+                [
+                    [-0.11541673, -0.10622888, 0.039689],
+                    [0.18462701, -0.0499289, 0.14309818],
+                    [0.00528282, 0.02152331, 0.1698219],
+                ],
+            ]
+        ),
+    ),
+    (
+        {
+            "item": "clara_pt_fed_learning_brain_tumor_mri_segmentation",
+            "map_location": "cuda" if torch.cuda.is_available() else "cpu",
+            "model_file": os.path.join("models", "server", "best_FL_global_model.pt"),
+        },
+        "SegResNet",
+        np.array(
+            [
+                [
+                    [0.01874463, 0.12237817, 0.09269974],
+                    [0.07691482, 0.00621202, -0.06682577],
+                    [-0.07718472, 0.08637864, -0.03222707],
+                ],
+                [
+                    [0.05117761, 0.07428649, -0.03053505],
+                    [0.11045473, 0.07083791, 0.06547518],
+                    [0.09555705, -0.03950734, -0.00819483],
+                ],
+                [
+                    [0.03704128, 0.062543, 0.0380853],
+                    [-0.02814676, -0.03078287, -0.01383446],
+                    [-0.08137762, 0.01385882, 0.01229484],
+                ],
+            ]
+        ),
+    ),
+    (
+        {
+            "item": "clara_pt_pathology_metastasis_detection",
+            "map_location": "cuda" if torch.cuda.is_available() else "cpu",
+        },
+        "TorchVisionFCModel",
+        np.array(
+            [
+                [-0.00540746, -0.00274996, -0.00837622, 0.05415914, 0.03555066, -0.00071636, -0.02325751],
+                [0.00564625, 0.00674562, -0.1098334, -0.2936509, -0.28384757, -0.13580588, -0.00737865],
+                [-0.02159783, 0.04615543, 0.29717407, 0.6001161, 0.53496915, 0.2528417, 0.04530451],
+                [0.0225903, -0.07556137, -0.3070122, -0.43984795, -0.26286602, -0.00172576, 0.05003437],
+                [-0.0320133, 0.00855468, 0.06824744, -0.04786247, -0.30358723, -0.3960023, -0.24895012],
+                [0.02412516, 0.03411723, 0.06513759, 0.24332047, 0.41664436, 0.38999054, 0.15957521],
+                [-0.01303542, -0.00166874, -0.01965466, -0.06620175, -0.15635538, -0.10023144, -0.01698002],
+            ]
+        ),
+    ),
+]
+
+
+@unittest.skip("deprecating mmar tests")
+class TestMMMARDownload(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    @skip_if_quick
+    def test_download(self, idx):
+        with skip_if_downloading_fails():
+            with self.assertLogs(level="INFO", logger="monai.apps"):
+                download_mmar(idx)
+            download_mmar(idx, progress=False)  # repeated to check caching
+            with tempfile.TemporaryDirectory() as tmp_dir:
+                download_mmar(idx, mmar_dir=tmp_dir, progress=False)
+                download_mmar(idx, mmar_dir=Path(tmp_dir), progress=False, version=1)  # repeated to check caching
+                self.assertTrue(os.path.exists(os.path.join(tmp_dir, idx)))
+
+    @parameterized.expand(TEST_EXTRACT_CASES)
+    @skip_if_quick
+    @unittest.skipIf(version_leq(__version__, "0.6"), "requires newer monai")
+    def test_load_ckpt(self, input_args, expected_name, expected_val):
+        with skip_if_downloading_fails():
+            output = load_from_mmar(**input_args)
+        self.assertEqual(output.__class__.__name__, expected_name)
+        x = next(output.parameters())  # verify the first element
+        np.testing.assert_allclose(x[0][0].detach().cpu().numpy(), expected_val, rtol=1e-3, atol=1e-3)
+
+    def test_unique(self):
+        # model ids are unique
+        keys = sorted(m["id"] for m in MODEL_DESC)
+        self.assertEqual(keys, sorted(set(keys)))
+
+    def test_search(self):
+        self.assertEqual(_get_val({"a": 1, "b": 2}, key="b"), 2)
+        self.assertEqual(_get_val({"a": {"c": {"c": 4}}, "b": {"c": 2}}, key="b"), {"c": 2})
+        self.assertEqual(_get_val({"a": {"c": 4}, "b": {"c": 2}}, key="c"), 4)
+        self.assertEqual(_get_val({"a": {"c": None}, "b": {"c": 2}}, key="c"), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/test_tciadataset.py

@@ -0,0 +1,123 @@
+# 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 unittest
+from pathlib import Path
+
+from monai.apps import TciaDataset
+from monai.apps.tcia import DCM_FILENAME_REGEX, TCIA_LABEL_DICT
+from monai.data import MetaTensor
+from monai.transforms import Compose, EnsureChannelFirstd, LoadImaged, ScaleIntensityd
+from tests.test_utils import skip_if_downloading_fails, skip_if_quick
+
+
+class TestTciaDataset(unittest.TestCase):
+    @skip_if_quick
+    def test_values(self):
+        testing_dir = Path(__file__).parents[1] / "testing_data"
+        download_len = 1
+        val_frac = 1.0
+        collection = "QIN-PROSTATE-Repeatability"
+
+        transform = Compose(
+            [
+                LoadImaged(
+                    keys=["image", "seg"],
+                    reader="PydicomReader",
+                    fname_regex=DCM_FILENAME_REGEX,
+                    label_dict=TCIA_LABEL_DICT[collection],
+                ),
+                EnsureChannelFirstd(keys="image", channel_dim="no_channel"),
+                ScaleIntensityd(keys="image"),
+            ]
+        )
+
+        def _test_dataset(dataset):
+            self.assertEqual(len(dataset), int(download_len * val_frac))
+            self.assertTrue("image" in dataset[0])
+            self.assertTrue("seg" in dataset[0])
+            self.assertTrue(isinstance(dataset[0]["image"], MetaTensor))
+            self.assertTupleEqual(dataset[0]["image"].shape, (1, 256, 256, 24))
+            self.assertTupleEqual(dataset[0]["seg"].shape, (256, 256, 24, 4))
+
+        with skip_if_downloading_fails():
+            data = TciaDataset(
+                root_dir=testing_dir,
+                collection=collection,
+                transform=transform,
+                section="validation",
+                download=True,
+                download_len=download_len,
+                copy_cache=False,
+                val_frac=val_frac,
+            )
+
+        _test_dataset(data)
+        data = TciaDataset(
+            root_dir=testing_dir,
+            collection=collection,
+            transform=transform,
+            section="validation",
+            download=False,
+            val_frac=val_frac,
+            runtime_cache=True,
+        )
+        _test_dataset(data)
+        self.assertTrue(
+            data[0]["image"].meta["filename_or_obj"].endswith("QIN-PROSTATE-Repeatability/PCAMPMRI-00015/1901/image")
+        )
+        self.assertTrue(
+            data[0]["seg"].meta["filename_or_obj"].endswith("QIN-PROSTATE-Repeatability/PCAMPMRI-00015/1901/seg")
+        )
+        # test validation without transforms
+        data = TciaDataset(
+            root_dir=testing_dir, collection=collection, section="validation", download=False, val_frac=val_frac
+        )
+        self.assertTupleEqual(data[0]["image"].shape, (256, 256, 24))
+        self.assertEqual(len(data), int(download_len * val_frac))
+        data = TciaDataset(
+            root_dir=testing_dir,
+            collection=collection,
+            section="validation",
+            download=False,
+            fname_regex=DCM_FILENAME_REGEX,
+            val_frac=val_frac,
+        )
+        self.assertTupleEqual(data[0]["image"].shape, (256, 256, 24))
+        self.assertEqual(len(data), download_len)
+        with self.assertWarns(UserWarning):
+            data = TciaDataset(
+                root_dir=testing_dir,
+                collection=collection,
+                section="validation",
+                fname_regex=".*",  # all files including 'LICENSE' is not a valid input
+                download=False,
+                val_frac=val_frac,
+            )[0]
+
+        shutil.rmtree(os.path.join(testing_dir, collection))
+        with self.assertRaisesRegex(RuntimeError, "^Cannot find dataset directory"):
+            TciaDataset(
+                root_dir=testing_dir,
+                collection=collection,
+                transform=transform,
+                section="validation",
+                download=False,
+                val_frac=val_frac,
+            )
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/vista3d/__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/apps/vista3d/test_point_based_window_inferer.py

@@ -0,0 +1,77 @@
+# 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.apps.vista3d.inferer import point_based_window_inferer
+from monai.networks import eval_mode
+from monai.networks.nets.vista3d import vista3d132
+from monai.utils import optional_import
+from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_quick
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+_, has_tqdm = optional_import("tqdm")
+
+TEST_CASES = [
+    [
+        {"encoder_embed_dim": 48, "in_channels": 1},
+        (1, 1, 64, 64, 64),
+        {
+            "roi_size": [32, 32, 32],
+            "point_coords": torch.tensor([[[1, 2, 3], [1, 2, 3]]], device=device),
+            "point_labels": torch.tensor([[1, 0]], device=device),
+        },
+    ],
+    [
+        {"encoder_embed_dim": 48, "in_channels": 1},
+        (1, 1, 64, 64, 64),
+        {
+            "roi_size": [32, 32, 32],
+            "point_coords": torch.tensor([[[1, 2, 3], [1, 2, 3]]], device=device),
+            "point_labels": torch.tensor([[1, 0]], device=device),
+            "class_vector": torch.tensor([1], device=device),
+        },
+    ],
+    [
+        {"encoder_embed_dim": 48, "in_channels": 1},
+        (1, 1, 64, 64, 64),
+        {
+            "roi_size": [32, 32, 32],
+            "point_coords": torch.tensor([[[1, 2, 3], [1, 2, 3]]], device=device),
+            "point_labels": torch.tensor([[1, 0]], device=device),
+            "class_vector": torch.tensor([1], device=device),
+            "point_start": 1,
+        },
+    ],
+]
+
+
+@SkipIfBeforePyTorchVersion((1, 11))
+@skip_if_quick
+class TestPointBasedWindowInferer(unittest.TestCase):
+    @parameterized.expand(TEST_CASES)
+    def test_vista3d(self, vista3d_params, inputs_shape, inferer_params):
+        vista3d = vista3d132(**vista3d_params).to(device)
+        with eval_mode(vista3d):
+            inferer_params["predictor"] = vista3d
+            inferer_params["inputs"] = torch.randn(*inputs_shape).to(device)
+            stitched_output = point_based_window_inferer(**inferer_params)
+            self.assertEqual(stitched_output.shape, inputs_shape)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/vista3d/test_vista3d_sampler.py

@@ -0,0 +1,100 @@
+# 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.apps.vista3d.sampler import sample_prompt_pairs
+
+label = torch.zeros([1, 1, 64, 64, 64])
+label[:, :, :10, :10, :10] = 1
+label[:, :, 20:30, 20:30, 20:30] = 2
+label[:, :, 30:40, 30:40, 30:40] = 3
+label1 = torch.zeros([1, 1, 64, 64, 64])
+
+TEST_VISTA_SAMPLE_PROMPT = [
+    [
+        {
+            "labels": label,
+            "label_set": [0, 1, 2, 3, 4],
+            "max_prompt": 5,
+            "max_foreprompt": 4,
+            "max_backprompt": 1,
+            "drop_label_prob": 0,
+            "drop_point_prob": 0,
+        },
+        [4, 4, 4, 4],
+    ],
+    [
+        {
+            "labels": label,
+            "label_set": [0, 1],
+            "max_prompt": 5,
+            "max_foreprompt": 4,
+            "max_backprompt": 1,
+            "drop_label_prob": 0,
+            "drop_point_prob": 1,
+        },
+        [2, None, None, 2],
+    ],
+    [
+        {
+            "labels": label,
+            "label_set": [0, 1, 2, 3, 4],
+            "max_prompt": 5,
+            "max_foreprompt": 4,
+            "max_backprompt": 1,
+            "drop_label_prob": 1,
+            "drop_point_prob": 0,
+        },
+        [None, 3, 3, 3],
+    ],
+    [
+        {
+            "labels": label1,
+            "label_set": [0, 1],
+            "max_prompt": 5,
+            "max_foreprompt": 4,
+            "max_backprompt": 1,
+            "drop_label_prob": 0,
+            "drop_point_prob": 1,
+        },
+        [1, None, None, 1],
+    ],
+    [
+        {
+            "labels": label1,
+            "label_set": [0, 1],
+            "max_prompt": 5,
+            "max_foreprompt": 4,
+            "max_backprompt": 0,
+            "drop_label_prob": 0,
+            "drop_point_prob": 1,
+        },
+        [None, None, None, None],
+    ],
+]
+
+
+class TestGeneratePrompt(unittest.TestCase):
+    @parameterized.expand(TEST_VISTA_SAMPLE_PROMPT)
+    def test_result(self, input_data, expected):
+        output = sample_prompt_pairs(**input_data)
+        result = [i.shape[0] if i is not None else None for i in output]
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/apps/vista3d/test_vista3d_transforms.py

@@ -0,0 +1,94 @@
+# 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 unittest.case import skipUnless
+
+import torch
+from parameterized import parameterized
+
+from monai.apps.vista3d.transforms import VistaPostTransformd, VistaPreTransformd
+from monai.utils import min_version
+from monai.utils.module import optional_import
+
+measure, has_measure = optional_import("skimage.measure", "0.14.2", min_version)
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+
+TEST_VISTA_PRETRANSFORM = [
+    [
+        {"label_prompt": [1], "points": [[0, 0, 0]], "point_labels": [1]},
+        {"label_prompt": [1], "points": [[0, 0, 0]], "point_labels": [3]},
+    ],
+    [
+        {"label_prompt": [2], "points": [[0, 0, 0]], "point_labels": [0]},
+        {"label_prompt": [2], "points": [[0, 0, 0]], "point_labels": [2]},
+    ],
+    [
+        {"label_prompt": [3], "points": [[0, 0, 0]], "point_labels": [0]},
+        {"label_prompt": [4, 5], "points": [[0, 0, 0]], "point_labels": [0]},
+    ],
+    [
+        {"label_prompt": [6], "points": [[0, 0, 0]], "point_labels": [0]},
+        {"label_prompt": [7, 8], "points": [[0, 0, 0]], "point_labels": [0]},
+    ],
+]
+
+
+pred1 = torch.zeros([2, 64, 64, 64])
+pred1[0, :10, :10, :10] = 1
+pred1[1, 20:30, 20:30, 20:30] = 1
+output1 = torch.zeros([1, 64, 64, 64])
+output1[:, :10, :10, :10] = 2
+output1[:, 20:30, 20:30, 20:30] = 3
+
+# -1 is needed since pred should be before sigmoid.
+pred2 = torch.zeros([1, 64, 64, 64]) - 1
+pred2[:, :10, :10, :10] = 1
+pred2[:, 20:30, 20:30, 20:30] = 1
+output2 = torch.zeros([1, 64, 64, 64])
+output2[:, 20:30, 20:30, 20:30] = 1
+
+TEST_VISTA_POSTTRANSFORM = [
+    [{"pred": pred1.to(device), "label_prompt": torch.tensor([2, 3]).to(device)}, output1.to(device)],
+    [
+        {
+            "pred": pred2.to(device),
+            "points": torch.tensor([[25, 25, 25]]).to(device),
+            "point_labels": torch.tensor([1]).to(device),
+        },
+        output2.to(device),
+    ],
+]
+
+
+class TestVistaPreTransformd(unittest.TestCase):
+    @parameterized.expand(TEST_VISTA_PRETRANSFORM)
+    def test_result(self, input_data, expected):
+        transform = VistaPreTransformd(keys="image", subclass={"3": [4, 5], "6": [7, 8]}, special_index=[1, 2])
+        result = transform(input_data)
+        self.assertEqual(result, expected)
+
+
+@skipUnless(has_measure, "skimage.measure required")
+class TestVistaPostTransformd(unittest.TestCase):
+    @parameterized.expand(TEST_VISTA_POSTTRANSFORM)
+    def test_result(self, input_data, expected):
+        transform = VistaPostTransformd(keys="pred")
+        result = transform(input_data)
+        self.assertEqual((result["pred"] == expected).all(), True)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/bundle/__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/bundle/test_bundle_ckpt_export.py

@@ -0,0 +1,107 @@
+# 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 json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from parameterized import parameterized
+
+from monai.bundle import ConfigParser
+from monai.data import load_net_with_metadata
+from monai.networks import save_state
+from tests.test_utils import command_line_tests, skip_if_windows
+
+TESTS_PATH = Path(__file__).parents[1]
+
+TEST_CASE_1 = ["", ""]
+
+TEST_CASE_2 = ["model", ""]
+
+TEST_CASE_3 = ["model", "True"]
+
+
+@skip_if_windows
+class TestCKPTExport(unittest.TestCase):
+
+    def setUp(self):
+        self.device = os.environ.get("CUDA_VISIBLE_DEVICES")
+        if not self.device:
+            os.environ["CUDA_VISIBLE_DEVICES"] = "0"  # default
+
+    def tearDown(self):
+        if self.device is not None:
+            os.environ["CUDA_VISIBLE_DEVICES"] = self.device
+        else:
+            del os.environ["CUDA_VISIBLE_DEVICES"]  # previously unset
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_export(self, key_in_ckpt, use_trace):
+        meta_file = os.path.join(TESTS_PATH, "testing_data", "metadata.json")
+        config_file = os.path.join(TESTS_PATH, "testing_data", "inference.json")
+        with tempfile.TemporaryDirectory() as tempdir:
+            def_args = {"meta_file": "will be replaced by `meta_file` arg"}
+            def_args_file = os.path.join(tempdir, "def_args.yaml")
+
+            ckpt_file = os.path.join(tempdir, "model.pt")
+            ts_file = os.path.join(tempdir, "model.ts")
+
+            parser = ConfigParser()
+            parser.export_config_file(config=def_args, filepath=def_args_file)
+            parser.read_config(config_file)
+            net = parser.get_parsed_content("network_def")
+            save_state(src=net if key_in_ckpt == "" else {key_in_ckpt: net}, path=ckpt_file)
+
+            cmd = ["coverage", "run", "-m", "monai.bundle", "ckpt_export", "network_def", "--filepath", ts_file]
+            cmd += ["--meta_file", meta_file, "--config_file", f"['{config_file}','{def_args_file}']", "--ckpt_file"]
+            cmd += [ckpt_file, "--key_in_ckpt", key_in_ckpt, "--args_file", def_args_file]
+            if use_trace == "True":
+                cmd += ["--use_trace", use_trace, "--input_shape", "[1, 1, 96, 96, 96]"]
+            command_line_tests(cmd)
+            self.assertTrue(os.path.exists(ts_file))
+
+            _, metadata, extra_files = load_net_with_metadata(
+                ts_file, more_extra_files=["inference.json", "def_args.json"]
+            )
+            self.assertIn("schema", metadata)
+            self.assertIn("meta_file", json.loads(extra_files["def_args.json"]))
+            self.assertIn("network_def", json.loads(extra_files["inference.json"]))
+
+    @parameterized.expand([TEST_CASE_1, TEST_CASE_2, TEST_CASE_3])
+    def test_default_value(self, key_in_ckpt, use_trace):
+        config_file = os.path.join(TESTS_PATH, "testing_data", "inference.json")
+        with tempfile.TemporaryDirectory() as tempdir:
+            def_args = {"meta_file": "will be replaced by `meta_file` arg"}
+            def_args_file = os.path.join(tempdir, "def_args.yaml")
+            ckpt_file = os.path.join(tempdir, "models/model.pt")
+            ts_file = os.path.join(tempdir, "models/model.ts")
+
+            parser = ConfigParser()
+            parser.export_config_file(config=def_args, filepath=def_args_file)
+            parser.read_config(config_file)
+            net = parser.get_parsed_content("network_def")
+            save_state(src=net if key_in_ckpt == "" else {key_in_ckpt: net}, path=ckpt_file)
+
+            # check with default value
+            cmd = ["coverage", "run", "-m", "monai.bundle", "ckpt_export", "--key_in_ckpt", key_in_ckpt]
+            cmd += ["--config_file", config_file, "--bundle_root", tempdir]
+            if use_trace == "True":
+                cmd += ["--use_trace", use_trace, "--input_shape", "[1, 1, 96, 96, 96]"]
+            command_line_tests(cmd)
+            self.assertTrue(os.path.exists(ts_file))
+
+
+if __name__ == "__main__":
+    unittest.main()