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

tests/integration/test_integration_gpu_customization.py

@@ -0,0 +1,159 @@
+# 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 nibabel as nib
+import numpy as np
+import torch
+
+from monai.apps.auto3dseg import AlgoEnsembleBestByFold, AlgoEnsembleBestN, AlgoEnsembleBuilder, BundleGen, DataAnalyzer
+from monai.bundle.config_parser import ConfigParser
+from monai.data import create_test_image_3d
+from monai.utils import optional_import
+from monai.utils.enums import AlgoKeys
+from tests.test_utils import (
+    SkipIfBeforePyTorchVersion,
+    get_testing_algo_template_path,
+    skip_if_downloading_fails,
+    skip_if_no_cuda,
+    skip_if_quick,
+)
+
+_, has_tb = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+
+num_images_perfold = max(torch.cuda.device_count(), 4)
+num_images_per_batch = 2
+
+fake_datalist: dict[str, list[dict]] = {
+    "testing": [{"image": "val_001.fake.nii.gz"}, {"image": "val_002.fake.nii.gz"}],
+    "training": [
+        {
+            "fold": f,
+            "image": f"tr_image_{(f * num_images_perfold + idx):03d}.nii.gz",
+            "label": f"tr_label_{(f * num_images_perfold + idx):03d}.nii.gz",
+        }
+        for f in range(num_images_per_batch + 1)
+        for idx in range(num_images_perfold)
+    ],
+}
+
+train_param = (
+    {
+        "num_images_per_batch": num_images_per_batch,
+        "num_epochs": 2,
+        "num_epochs_per_validation": 1,
+        "num_warmup_epochs": 1,
+        "use_pretrain": False,
+        "pretrained_path": "",
+    }
+    if torch.cuda.is_available()
+    else {}
+)
+
+pred_param = {"files_slices": slice(0, 1), "mode": "mean", "sigmoid": True}
+
+
+@skip_if_quick
+@SkipIfBeforePyTorchVersion((1, 11, 1))  # module 'torch.cuda' has no attribute 'mem_get_info'
+@unittest.skipIf(not has_tb, "no tensorboard summary writer")
+class TestEnsembleGpuCustomization(unittest.TestCase):
+    def setUp(self) -> None:
+        self.test_dir = tempfile.TemporaryDirectory()
+
+    @skip_if_no_cuda
+    def test_ensemble_gpu_customization(self) -> None:
+        test_path = self.test_dir.name
+
+        dataroot = os.path.join(test_path, "dataroot")
+        work_dir = os.path.join(test_path, "workdir")
+
+        da_output_yaml = os.path.join(work_dir, "datastats.yaml")
+        data_src_cfg = os.path.join(work_dir, "data_src_cfg.yaml")
+
+        if not os.path.isdir(dataroot):
+            os.makedirs(dataroot)
+
+        if not os.path.isdir(work_dir):
+            os.makedirs(work_dir)
+
+        # Generate a fake dataset
+        for d in fake_datalist["testing"] + fake_datalist["training"]:
+            im, seg = create_test_image_3d(24, 24, 24, rad_max=10, num_seg_classes=1)
+            nib_image = nib.Nifti1Image(im, affine=np.eye(4))
+            image_fpath = os.path.join(dataroot, d["image"])
+            nib.save(nib_image, image_fpath)
+
+            if "label" in d:
+                nib_image = nib.Nifti1Image(seg, affine=np.eye(4))
+                label_fpath = os.path.join(dataroot, d["label"])
+                nib.save(nib_image, label_fpath)
+
+        # write to a json file
+        fake_json_datalist = os.path.join(dataroot, "fake_input.json")
+        ConfigParser.export_config_file(fake_datalist, fake_json_datalist)
+
+        da = DataAnalyzer(fake_json_datalist, dataroot, output_path=da_output_yaml)
+        da.get_all_case_stats()
+
+        data_src = {
+            "name": "fake_data",
+            "task": "segmentation",
+            "modality": "MRI",
+            "datalist": fake_json_datalist,
+            "dataroot": dataroot,
+            "multigpu": False,
+            "class_names": ["label_class"],
+        }
+
+        ConfigParser.export_config_file(data_src, data_src_cfg)
+
+        with skip_if_downloading_fails():
+            bundle_generator = BundleGen(
+                algo_path=work_dir,
+                data_stats_filename=da_output_yaml,
+                data_src_cfg_name=data_src_cfg,
+                templates_path_or_url=get_testing_algo_template_path(),
+            )
+
+        gpu_customization_specs = {
+            "universal": {"num_trials": 1, "range_num_images_per_batch": [1, 2], "range_num_sw_batch_size": [1, 2]}
+        }
+        bundle_generator.generate(
+            work_dir, num_fold=1, gpu_customization=True, gpu_customization_specs=gpu_customization_specs
+        )
+        history = bundle_generator.get_history()
+
+        for algo_dict in history:
+            algo = algo_dict[AlgoKeys.ALGO]
+            algo.train(train_param)
+
+        builder = AlgoEnsembleBuilder(history, data_src_cfg)
+        builder.set_ensemble_method(AlgoEnsembleBestN(n_best=2))
+        ensemble = builder.get_ensemble()
+        preds = ensemble(pred_param)
+        self.assertTupleEqual(preds[0].shape, (2, 24, 24, 24))
+
+        builder.set_ensemble_method(AlgoEnsembleBestByFold(1))
+        ensemble = builder.get_ensemble()
+        for algo in ensemble.get_algo_ensemble():
+            print(algo[AlgoKeys.ID])
+
+    def tearDown(self) -> None:
+        self.test_dir.cleanup()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_integration_lazy_samples.py

@@ -0,0 +1,219 @@
+# 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
+from glob import glob
+
+import nibabel as nib
+import numpy as np
+import torch
+
+import monai
+import monai.transforms as mt
+from monai.data import create_test_image_3d, decollate_batch
+from monai.transforms.utils import has_status_keys
+from monai.utils import TraceStatusKeys, set_determinism
+from tests.test_utils import HAS_CUPY, DistTestCase, SkipIfBeforePyTorchVersion, skip_if_quick
+
+
+def _no_op(x):
+    return x
+
+
+def run_training_test(root_dir, device="cuda:0", cachedataset=0, readers=(None, None), num_workers=4, lazy=True):
+    print(f"test case: {locals()}")
+    images = sorted(glob(os.path.join(root_dir, "img*.nii.gz")))
+    segs = sorted(glob(os.path.join(root_dir, "seg*.nii.gz")))
+    train_files = [{"img": img, "seg": seg} for img, seg in zip(images[:20], segs[:20])]
+    device = "cuda:0" if HAS_CUPY and torch.cuda.is_available() else "cpu"  # mode 0 and cuda requires CUPY
+    num_workers = 0 if torch.cuda.is_available() else num_workers
+
+    # define transforms for image and segmentation
+    lazy_kwargs = {
+        "img": {"mode": "bilinear", "device": device, "padding_mode": "border", "dtype": torch.float32},
+        "seg": {"mode": 0, "device": device, "padding_mode": "nearest", "dtype": torch.uint8},
+    }
+    train_transforms = mt.Compose(
+        [
+            mt.LoadImaged(keys=["img", "seg"], reader=readers[0], image_only=True),
+            mt.EnsureChannelFirstd(keys=["img", "seg"]),
+            mt.Spacingd(
+                keys=["img", "seg"],
+                pixdim=[1.2, 0.8, 0.7],
+                mode=["bilinear", 0],
+                padding_mode=("border", "nearest"),
+                dtype=np.float32,
+            ),
+            mt.Orientationd(keys=["img", "seg"], axcodes="ARS"),
+            mt.RandRotate90d(keys=["img", "seg"], prob=1.0, spatial_axes=(1, 2)),
+            mt.ScaleIntensityd(keys="img"),
+            mt.ApplyPendingd(keys=["seg"]),
+            mt.RandCropByPosNegLabeld(
+                keys=["img", "seg"], label_key="seg", spatial_size=[76, 82, 80], pos=1, neg=1, num_samples=4
+            ),
+            mt.RandRotate90d(keys=["img", "seg"], prob=0.8, spatial_axes=(0, 2)),
+            mt.RandZoomd(
+                keys=["img", "seg"], prob=1.0, min_zoom=1.0, max_zoom=1.0, mode=("trilinear", 0), keep_size=True
+            ),
+            mt.ResizeWithPadOrCropD(keys=["img", "seg"], spatial_size=[80, 72, 80]),
+            mt.Rotated(keys=["img", "seg"], angle=[np.pi / 2, np.pi / 2, 0], mode="nearest", keep_size=False),
+            mt.Lambdad(keys=["img"], func=_no_op),
+        ],
+        lazy=lazy,
+        overrides=lazy_kwargs,
+        log_stats=num_workers > 0,
+    )
+
+    # create a training data loader
+    if cachedataset == 2:
+        train_ds = monai.data.CacheDataset(
+            data=train_files, transform=train_transforms, cache_rate=0.8, runtime_cache=False, num_workers=0
+        )
+    elif cachedataset == 3:
+        train_ds = monai.data.LMDBDataset(data=train_files, transform=train_transforms, cache_dir=root_dir)
+    else:
+        train_ds = monai.data.Dataset(data=train_files, transform=train_transforms)
+
+    # create UNet, DiceLoss and Adam optimizer
+    model = monai.networks.nets.UNet(
+        spatial_dims=3, in_channels=1, out_channels=1, channels=(2, 2, 2, 2), strides=(2, 2, 2), num_res_units=2
+    ).to(device)
+    optimizer = torch.optim.Adam(model.parameters(), 5e-4)
+    loss_function = monai.losses.DiceLoss(sigmoid=True)
+
+    saver = mt.SaveImage(
+        output_dir=os.path.join(root_dir, "output"),
+        dtype=np.float32,
+        output_ext=".nii.gz",
+        output_postfix=f"seg_{lazy}_{num_workers}",
+        mode="bilinear",
+        resample=False,
+        separate_folder=False,
+        print_log=False,
+    )
+    inverter = mt.Invertd(
+        keys="seg", orig_keys="img", transform=mt.Compose(train_transforms.transforms[-5:]), to_tensor=True
+    )
+
+    # use batch_size=2 to load images and use RandCropByPosNegLabeld to generate 2 x 4 images for network training
+    _g = torch.Generator()
+    _g.manual_seed(0)
+    set_determinism(0)
+    train_loader = monai.data.DataLoader(
+        train_ds, batch_size=1, shuffle=True, num_workers=num_workers, generator=_g, persistent_workers=num_workers > 0
+    )
+    all_coords = set()
+    batch_data = None
+    for epoch in range(5):
+        print("-" * 10)
+        print(f"Epoch {epoch + 1}/5")
+        for step, batch_data in enumerate(train_loader, start=1):
+            inputs, labels = batch_data["img"].to(device), batch_data["seg"].to(device)
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = loss_function(outputs, labels)
+            loss.backward()
+            optimizer.step()
+            epoch_len = len(train_ds) // train_loader.batch_size
+            print(f"{step}/{epoch_len}, train_loss:{loss.item():0.4f}")
+
+            for item, in_img, in_seg in zip(outputs, inputs, labels):  # this decollates the batch, pt 1.9+
+                item.copy_meta_from(in_img)
+                np.testing.assert_array_equal(item.pending_operations, [])
+                np.testing.assert_array_equal(in_seg.pending_operations, [])
+                ops = [0]
+                if len(item.applied_operations) > 1:
+                    found = False
+                    for idx, n in enumerate(item.applied_operations):  # noqa
+                        if n["class"] == "RandCropByPosNegLabel":
+                            found = True
+                            break
+                    if found:
+                        ops = item.applied_operations[idx]["extra_info"]["extra_info"]["cropped"]
+                img_name = os.path.basename(item.meta["filename_or_obj"])
+                coords = f"{img_name} - {ops}"
+                print(coords)
+                # np.testing.assert_allclose(coords in all_coords, False)
+                all_coords.add(coords)
+                saver(item)  # just testing the saving
+                saver(in_img)
+                saver(in_seg)
+    invertible, reasons = has_status_keys(batch_data, TraceStatusKeys.PENDING_DURING_APPLY)
+    inverted = [inverter(b_data) for b_data in decollate_batch(batch_data)]  # expecting no error
+
+    return ops
+
+
+@skip_if_quick
+@SkipIfBeforePyTorchVersion((1, 11))
+class IntegrationLazyResampling(DistTestCase):
+    def setUp(self):
+        monai.config.print_config()
+        set_determinism(seed=0)
+
+        self.data_dir = tempfile.mkdtemp()
+        for i in range(3):
+            im, seg = create_test_image_3d(128, 128, 128, num_seg_classes=1, channel_dim=-1)
+            n = nib.Nifti1Image(im, np.eye(4))
+            nib.save(n, os.path.join(self.data_dir, f"img{i:d}.nii.gz"))
+            n = nib.Nifti1Image(seg, np.eye(4))
+            nib.save(n, os.path.join(self.data_dir, f"seg{i:d}.nii.gz"))
+
+        self.device = "cuda:0" if torch.cuda.is_available() else "cpu:0"
+
+    def tearDown(self):
+        set_determinism(seed=None)
+        shutil.rmtree(self.data_dir)
+
+    def train_and_infer(self, idx=0):
+        results = []
+        _readers = (None, None)
+        _w = 2
+        if idx == 1:
+            _readers = ("itkreader", "itkreader")
+            _w = 1
+        elif idx == 2:
+            _readers = ("itkreader", "nibabelreader")
+            _w = 0
+
+        results_expected = run_training_test(
+            self.data_dir, device=self.device, cachedataset=0, readers=_readers, num_workers=_w, lazy=False
+        )
+        results = run_training_test(
+            self.data_dir, device=self.device, cachedataset=idx, readers=_readers, num_workers=_w, lazy=True
+        )
+        self.assertFalse(np.allclose(results, [0]))
+        self.assertFalse(np.allclose(results_expected, [0]))
+        np.testing.assert_allclose(results, results_expected)
+        lazy_files = glob(os.path.join(self.data_dir, "output", "*_True_*.nii.gz"))
+        regular_files = glob(os.path.join(self.data_dir, "output", "*_False_*.nii.gz"))
+        diffs = []
+        for a, b in zip(sorted(lazy_files), sorted(regular_files)):
+            img_lazy = mt.LoadImage(image_only=True)(a)
+            img_regular = mt.LoadImage(image_only=True)(b)
+            diff = np.size(img_lazy) - np.sum(np.isclose(img_lazy, img_regular, atol=1e-4))
+            diff_rate = diff / np.size(img_lazy)
+            diffs.append(diff_rate)
+            np.testing.assert_allclose(diff_rate, 0.0, atol=0.03)
+        print("volume diff:", diffs)
+
+    def test_training(self):
+        for i in range(4):
+            self.train_and_infer(i)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_integration_nnunetv2_runner.py

@@ -0,0 +1,96 @@
+# 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 nibabel as nib
+import numpy as np
+
+from monai.apps.nnunet import nnUNetV2Runner
+from monai.bundle.config_parser import ConfigParser
+from monai.data import create_test_image_3d
+from monai.utils import optional_import
+from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_downloading_fails, skip_if_no_cuda, skip_if_quick
+
+_, has_tb = optional_import("torch.utils.tensorboard", name="SummaryWriter")
+_, has_nnunet = optional_import("nnunetv2")
+
+sim_datalist: dict[str, list[dict]] = {
+    "testing": [{"image": "val_001.fake.nii.gz"}, {"image": "val_002.fake.nii.gz"}],
+    "training": [
+        {"fold": 0, "image": "tr_image_001.fake.nii.gz", "label": "tr_label_001.fake.nii.gz"},
+        {"fold": 0, "image": "tr_image_002.fake.nii.gz", "label": "tr_label_002.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_003.fake.nii.gz", "label": "tr_label_003.fake.nii.gz"},
+        {"fold": 1, "image": "tr_image_004.fake.nii.gz", "label": "tr_label_004.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_005.fake.nii.gz", "label": "tr_label_005.fake.nii.gz"},
+        {"fold": 2, "image": "tr_image_006.fake.nii.gz", "label": "tr_label_006.fake.nii.gz"},
+        {"fold": 3, "image": "tr_image_007.fake.nii.gz", "label": "tr_label_007.fake.nii.gz"},
+        {"fold": 3, "image": "tr_image_008.fake.nii.gz", "label": "tr_label_008.fake.nii.gz"},
+        {"fold": 4, "image": "tr_image_009.fake.nii.gz", "label": "tr_label_009.fake.nii.gz"},
+        {"fold": 4, "image": "tr_image_010.fake.nii.gz", "label": "tr_label_010.fake.nii.gz"},
+    ],
+}
+
+
+@skip_if_quick
+@SkipIfBeforePyTorchVersion((1, 13, 0))
+@unittest.skipIf(not has_tb, "no tensorboard summary writer")
+@unittest.skipIf(not has_nnunet, "no nnunetv2")
+class TestnnUNetV2Runner(unittest.TestCase):
+    def setUp(self) -> None:
+        self.test_dir = tempfile.TemporaryDirectory()
+        test_path = self.test_dir.name
+
+        sim_dataroot = os.path.join(test_path, "dataroot")
+        if not os.path.isdir(sim_dataroot):
+            os.makedirs(sim_dataroot)
+
+        # Generate a fake dataset
+        for d in sim_datalist["testing"] + sim_datalist["training"]:
+            im, seg = create_test_image_3d(24, 24, 24, rad_max=10, num_seg_classes=2)
+            nib_image = nib.Nifti1Image(im, affine=np.eye(4))
+            image_fpath = os.path.join(sim_dataroot, d["image"])
+            nib.save(nib_image, image_fpath)
+
+            if "label" in d:
+                nib_image = nib.Nifti1Image(seg, affine=np.eye(4))
+                label_fpath = os.path.join(sim_dataroot, d["label"])
+                nib.save(nib_image, label_fpath)
+
+        sim_json_datalist = os.path.join(sim_dataroot, "sim_input.json")
+        ConfigParser.export_config_file(sim_datalist, sim_json_datalist)
+
+        data_src_cfg = os.path.join(test_path, "data_src_cfg.yaml")
+        data_src = {"modality": "CT", "datalist": sim_json_datalist, "dataroot": sim_dataroot}
+
+        ConfigParser.export_config_file(data_src, data_src_cfg)
+        self.data_src_cfg = data_src_cfg
+        self.test_path = test_path
+
+    @skip_if_no_cuda
+    def test_nnunetv2runner(self) -> None:
+        runner = nnUNetV2Runner(input_config=self.data_src_cfg, trainer_class_name="nnUNetTrainer_1epoch")
+        with skip_if_downloading_fails():
+            runner.run(run_train=False, run_find_best_configuration=False, run_predict_ensemble_postprocessing=False)
+            runner.train(configs="3d_fullres")
+            runner.find_best_configuration(configs="3d_fullres")
+            runner.predict_ensemble_postprocessing()
+
+    def tearDown(self) -> None:
+        self.test_dir.cleanup()
+
+
+if __name__ == "__main__":
+    unittest.main()