8185 test refactor 2 (#8405)

Fixes #8185

### Description

This PR solves items 2 and 3 on #8185 for a few test folders.
I would merge these and proceed with the same type of change in other
files if @ericspod approves.

I would like to keep these PRs small, so even if they have the same
pattern of changes, merging them bit by bit would make them more
manageable.

A few sentences describing the changes proposed in this pull request.

### Types of changes
<!--- Put an `x` in all the boxes that apply, and remove the not
applicable items -->
- [x] Non-breaking change (fix or new feature that would not break
existing functionality).
- [ ] Breaking change (fix or new feature that would cause existing
functionality to change).
- [ ] New tests added to cover the changes.
- [x] Integration tests passed locally by running `./runtests.sh -f -u
--net --coverage`.
- [x] Quick tests passed locally by running `./runtests.sh --quick
--unittests --disttests`.
- [ ] In-line docstrings updated.
- [ ] Documentation updated, tested `make html` command in the `docs/`
folder.

---------

Signed-off-by: R. Garcia-Dias <[email protected]>
Signed-off-by: Rafael Garcia-Dias <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Eric Kerfoot <[email protected]>

Author: 3 people

CONTRIBUTING.md

@@ -20,7 +20,7 @@
 from monai.networks import eval_mode
 from monai.networks.nets import resnet10, resnet18, resnet34, resnet50, resnet101, resnet152, resnet200
 from monai.utils import ensure_tuple, optional_import
-from tests.test_utils import SkipIfBeforePyTorchVersion, skip_if_quick, test_onnx_save, test_script_save
+from tests.test_utils import SkipIfBeforePyTorchVersion, dict_product, skip_if_quick, test_onnx_save, test_script_save
 
 _, has_torchvision = optional_import("torchvision")
 
@@ -86,15 +86,12 @@
     (2, 1, 32, 64),
 ]
 
-TEST_CASES = []
-for case in [TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_2_A, TEST_CASE_3_A]:
-    for model in [resnet10, resnet18, resnet34, resnet50, resnet101, resnet152, resnet200]:
-        TEST_CASES.append([model, *case])
+# Create all test case combinations using dict_product
+CASE_LIST = [TEST_CASE_1, TEST_CASE_2, TEST_CASE_3, TEST_CASE_2_A, TEST_CASE_3_A]
+MODEL_LIST = [resnet10, resnet18, resnet34, resnet50, resnet101, resnet152, resnet200]
 
-TEST_CASES_TS = []
-for case in [TEST_CASE_1]:
-    for model in [resnet10, resnet18, resnet34, resnet50, resnet101, resnet152, resnet200]:
-        TEST_CASES_TS.append([model, *case])
+TEST_CASES = [[params["model"], *params["case"]] for params in dict_product(model=MODEL_LIST, case=CASE_LIST)]
+TEST_CASES_TS = [[params["model"], *params["case"]] for params in dict_product(model=MODEL_LIST, case=[TEST_CASE_1])]
 
 
 @SkipIfBeforePyTorchVersion((1, 12))

tests/apps/detection/networks/test_retinanet.py

@@ -32,13 +32,13 @@
 from monai.data.utils import decollate_batch, list_data_collate
 from monai.transforms import BorderPadd, Compose, DivisiblePadd, FromMetaTensord, ToMetaTensord
 from monai.utils.enums import PostFix
-from tests.test_utils import TEST_DEVICES, SkipIfBeforePyTorchVersion, assert_allclose, skip_if_no_cuda
+from tests.test_utils import TEST_DEVICES, SkipIfBeforePyTorchVersion, assert_allclose, dict_product, skip_if_no_cuda
 
 DTYPES = [[torch.float32], [torch.float64], [torch.float16], [torch.int64], [torch.int32], [None]]
-TESTS = []
-for _device in TEST_DEVICES:
-    for _dtype in DTYPES:
-        TESTS.append((*_device, *_dtype))  # type: ignore
+
+# Replace nested loops with dict_product
+
+TESTS = [(*params["device"], *params["dtype"]) for params in dict_product(device=TEST_DEVICES, dtype=DTYPES)]
 
 
 def rand_string(min_len=5, max_len=10):

tests/data/meta_tensor/test_meta_tensor.py

@@ -20,28 +20,18 @@
 from monai.networks import eval_mode
 from monai.networks.blocks.cablock import CABlock, FeedForward
 from monai.utils import optional_import
-from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose
+from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose, dict_product
 
 einops, has_einops = optional_import("einops")
 
-
-TEST_CASES_CAB = []
-for spatial_dims in [2, 3]:
-    for dim in [32, 64, 128]:
-        for num_heads in [2, 4, 8]:
-            for bias in [True, False]:
-                test_case = [
-                    {
-                        "spatial_dims": spatial_dims,
-                        "dim": dim,
-                        "num_heads": num_heads,
-                        "bias": bias,
-                        "flash_attention": False,
-                    },
-                    (2, dim, *([16] * spatial_dims)),
-                    (2, dim, *([16] * spatial_dims)),
-                ]
-                TEST_CASES_CAB.append(test_case)
+TEST_CASES_CAB = [
+    [
+        {**params, "flash_attention": False},
+        (2, params["dim"], *([16] * params["spatial_dims"])),
+        (2, params["dim"], *([16] * params["spatial_dims"])),
+    ]
+    for params in dict_product(spatial_dims=[2, 3], dim=[32, 64, 128], num_heads=[2, 4, 8], bias=[True, False])
+]
 
 
 TEST_CASES_FEEDFORWARD = [
@@ -53,7 +43,6 @@
 
 
 class TestFeedForward(unittest.TestCase):
-
     @parameterized.expand(TEST_CASES_FEEDFORWARD)
     def test_shape(self, input_param, input_shape):
         net = FeedForward(**input_param)
@@ -69,7 +58,6 @@ def test_gating_mechanism(self):
 
 
 class TestCABlock(unittest.TestCase):
-
     @parameterized.expand(TEST_CASES_CAB)
     @skipUnless(has_einops, "Requires einops")
     def test_shape(self, input_param, input_shape, expected_shape):

tests/networks/blocks/test_CABlock.py

@@ -22,30 +22,28 @@
 from monai.networks.blocks.crossattention import CrossAttentionBlock
 from monai.networks.layers.factories import RelPosEmbedding
 from monai.utils import optional_import
-from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose
+from tests.test_utils import SkipIfBeforePyTorchVersion, assert_allclose, dict_product
 
 einops, has_einops = optional_import("einops")
 
-TEST_CASE_CABLOCK = []
-for dropout_rate in np.linspace(0, 1, 4):
-    for hidden_size in [360, 480, 600, 768]:
-        for num_heads in [4, 6, 8, 12]:
-            for rel_pos_embedding in [None, RelPosEmbedding.DECOMPOSED]:
-                for input_size in [(16, 32), (8, 8, 8)]:
-                    for flash_attn in [True, False]:
-                        test_case = [
-                            {
-                                "hidden_size": hidden_size,
-                                "num_heads": num_heads,
-                                "dropout_rate": dropout_rate,
-                                "rel_pos_embedding": rel_pos_embedding if not flash_attn else None,
-                                "input_size": input_size,
-                                "use_flash_attention": flash_attn,
-                            },
-                            (2, 512, hidden_size),
-                            (2, 512, hidden_size),
-                        ]
-                        TEST_CASE_CABLOCK.append(test_case)
+TEST_CASE_CABLOCK = [
+    [
+        {
+            **{k: v for k, v in params.items() if k not in ["rel_pos_embedding_val"]},
+            "rel_pos_embedding": params["rel_pos_embedding_val"] if not params["use_flash_attention"] else None,
+        },
+        (2, 512, params["hidden_size"]),
+        (2, 512, params["hidden_size"]),
+    ]
+    for params in dict_product(
+        dropout_rate=np.linspace(0, 1, 4),
+        hidden_size=[360, 480, 600, 768],
+        num_heads=[4, 6, 8, 12],
+        rel_pos_embedding_val=[None, RelPosEmbedding.DECOMPOSED],
+        input_size=[(16, 32), (8, 8, 8)],
+        use_flash_attention=[True, False],
+    )
+]
 
 
 class TestResBlock(unittest.TestCase):

tests/networks/blocks/test_crossattention.py

@@ -18,58 +18,55 @@
 
 from monai.networks import eval_mode
 from monai.networks.blocks.dynunet_block import UnetBasicBlock, UnetResBlock, UnetUpBlock, get_padding
-from tests.test_utils import test_script_save
+from tests.test_utils import dict_product, test_script_save
 
 TEST_CASE_RES_BASIC_BLOCK = []
-for spatial_dims in range(2, 4):
-    for kernel_size in [1, 3]:
-        for stride in [1, 2]:
-            for norm_name in [("GROUP", {"num_groups": 16}), ("batch", {"track_running_stats": False}), "instance"]:
-                for in_size in [15, 16]:
-                    padding = get_padding(kernel_size, stride)
-                    if not isinstance(padding, int):
-                        padding = padding[0]
-                    out_size = int((in_size + 2 * padding - kernel_size) / stride) + 1
-                    test_case = [
-                        {
-                            "spatial_dims": spatial_dims,
-                            "in_channels": 16,
-                            "out_channels": 16,
-                            "kernel_size": kernel_size,
-                            "norm_name": norm_name,
-                            "act_name": ("leakyrelu", {"inplace": True, "negative_slope": 0.1}),
-                            "stride": stride,
-                        },
-                        (1, 16, *([in_size] * spatial_dims)),
-                        (1, 16, *([out_size] * spatial_dims)),
-                    ]
-                    TEST_CASE_RES_BASIC_BLOCK.append(test_case)
+for params in dict_product(
+    spatial_dims=range(2, 4),
+    kernel_size=[1, 3],
+    stride=[1, 2],
+    norm_name=[("GROUP", {"num_groups": 16}), ("batch", {"track_running_stats": False}), "instance"],
+    in_size=[15, 16],
+):
+    padding = get_padding(params["kernel_size"], params["stride"])
+    if not isinstance(padding, int):
+        padding = padding[0]
+    out_size = int((params["in_size"] + 2 * padding - params["kernel_size"]) / params["stride"]) + 1
+    test_case = [
+        {
+            **{k: v for k, v in params.items() if k != "in_size"},
+            "in_channels": 16,
+            "out_channels": 16,
+            "act_name": ("leakyrelu", {"inplace": True, "negative_slope": 0.1}),
+        },
+        (1, 16, *([params["in_size"]] * params["spatial_dims"])),
+        (1, 16, *([out_size] * params["spatial_dims"])),
+    ]
+    TEST_CASE_RES_BASIC_BLOCK.append(test_case)
 
 TEST_UP_BLOCK = []
 in_channels, out_channels = 4, 2
-for spatial_dims in range(2, 4):
-    for kernel_size in [1, 3]:
-        for stride in [1, 2]:
-            for norm_name in ["batch", "instance"]:
-                for in_size in [15, 16]:
-                    for trans_bias in [True, False]:
-                        out_size = in_size * stride
-                        test_case = [
-                            {
-                                "spatial_dims": spatial_dims,
-                                "in_channels": in_channels,
-                                "out_channels": out_channels,
-                                "kernel_size": kernel_size,
-                                "norm_name": norm_name,
-                                "stride": stride,
-                                "upsample_kernel_size": stride,
-                                "trans_bias": trans_bias,
-                            },
-                            (1, in_channels, *([in_size] * spatial_dims)),
-                            (1, out_channels, *([out_size] * spatial_dims)),
-                            (1, out_channels, *([in_size * stride] * spatial_dims)),
-                        ]
-                        TEST_UP_BLOCK.append(test_case)
+for params in dict_product(
+    spatial_dims=range(2, 4),
+    kernel_size=[1, 3],
+    stride=[1, 2],
+    norm_name=["batch", "instance"],
+    in_size=[15, 16],
+    trans_bias=[True, False],
+):
+    out_size = params["in_size"] * params["stride"]
+    test_case = [
+        {
+            **{k: v for k, v in params.items() if k != "in_size"},
+            "in_channels": in_channels,
+            "out_channels": out_channels,
+            "upsample_kernel_size": params["stride"],
+        },
+        (1, in_channels, *([params["in_size"]] * params["spatial_dims"])),
+        (1, out_channels, *([out_size] * params["spatial_dims"])),
+        (1, out_channels, *([params["in_size"] * params["stride"]] * params["spatial_dims"])),
+    ]
+    TEST_UP_BLOCK.append(test_case)
 
 
 class TestResBasicBlock(unittest.TestCase):

tests/networks/blocks/test_dynunet_block.py

@@ -21,58 +21,41 @@
 from monai.networks import eval_mode
 from monai.networks.blocks.patchembedding import PatchEmbed, PatchEmbeddingBlock
 from monai.utils import optional_import
-from tests.test_utils import SkipIfBeforePyTorchVersion
+from tests.test_utils import SkipIfBeforePyTorchVersion, dict_product
 
 einops, has_einops = optional_import("einops")
 
-TEST_CASE_PATCHEMBEDDINGBLOCK = []
-for dropout_rate in (0.5,):
-    for in_channels in [1, 4]:
-        for hidden_size in [96, 288]:
-            for img_size in [32, 64]:
-                for patch_size in [8, 16]:
-                    for num_heads in [8, 12]:
-                        for proj_type in ["conv", "perceptron"]:
-                            for pos_embed_type in ["none", "learnable", "sincos"]:
-                                # for classification in (False, True):  # TODO: add classification tests
-                                for nd in (2, 3):
-                                    test_case = [
-                                        {
-                                            "in_channels": in_channels,
-                                            "img_size": (img_size,) * nd,
-                                            "patch_size": (patch_size,) * nd,
-                                            "hidden_size": hidden_size,
-                                            "num_heads": num_heads,
-                                            "proj_type": proj_type,
-                                            "pos_embed_type": pos_embed_type,
-                                            "dropout_rate": dropout_rate,
-                                        },
-                                        (2, in_channels, *([img_size] * nd)),
-                                        (2, (img_size // patch_size) ** nd, hidden_size),
-                                    ]
-                                    if nd == 2:
-                                        test_case[0]["spatial_dims"] = 2  # type: ignore
-                                    TEST_CASE_PATCHEMBEDDINGBLOCK.append(test_case)
-
-TEST_CASE_PATCHEMBED = []
-for patch_size in [2]:
-    for in_chans in [1, 4]:
-        for img_size in [96]:
-            for embed_dim in [6, 12]:
-                for norm_layer in [nn.LayerNorm]:
-                    for nd in [2, 3]:
-                        test_case = [
-                            {
-                                "patch_size": (patch_size,) * nd,
-                                "in_chans": in_chans,
-                                "embed_dim": embed_dim,
-                                "norm_layer": norm_layer,
-                                "spatial_dims": nd,
-                            },
-                            (2, in_chans, *([img_size] * nd)),
-                            (2, embed_dim, *([img_size // patch_size] * nd)),
-                        ]
-                        TEST_CASE_PATCHEMBED.append(test_case)
+
+TEST_CASE_PATCHEMBEDDINGBLOCK = [
+    [
+        params,
+        (2, params["in_channels"], *([params["img_size"]] * params["spatial_dims"])),
+        (2, (params["img_size"] // params["patch_size"]) ** params["spatial_dims"], params["hidden_size"]),
+    ]
+    for params in dict_product(
+        dropout_rate=[0.5],
+        in_channels=[1, 4],
+        hidden_size=[96, 288],
+        img_size=[32, 64],
+        patch_size=[8, 16],
+        num_heads=[8, 12],
+        proj_type=["conv", "perceptron"],
+        pos_embed_type=["none", "learnable", "sincos"],
+        spatial_dims=[2, 3],
+    )
+]
+
+img_size = 96
+TEST_CASE_PATCHEMBED = [
+    [
+        params,
+        (2, params["in_chans"], *([img_size] * params["spatial_dims"])),
+        (2, params["embed_dim"], *([img_size // params["patch_size"]]) * params["spatial_dims"]),
+    ]
+    for params in dict_product(
+        patch_size=[2], in_chans=[1, 4], embed_dim=[6, 12], norm_layer=[nn.LayerNorm], spatial_dims=[2, 3]
+    )
+]
 
 
 @SkipIfBeforePyTorchVersion((1, 11, 1))

tests/networks/blocks/test_patchembedding.py

@@ -18,27 +18,24 @@
 
 from monai.networks import eval_mode
 from monai.networks.blocks.segresnet_block import ResBlock
-
-TEST_CASE_RESBLOCK = []
-for spatial_dims in range(2, 4):
-    for in_channels in range(1, 4):
-        for kernel_size in [1, 3]:
-            for norm in [("group", {"num_groups": 1}), "batch", "instance"]:
-                test_case = [
-                    {
-                        "spatial_dims": spatial_dims,
-                        "in_channels": in_channels,
-                        "kernel_size": kernel_size,
-                        "norm": norm,
-                    },
-                    (2, in_channels, *([16] * spatial_dims)),
-                    (2, in_channels, *([16] * spatial_dims)),
-                ]
-                TEST_CASE_RESBLOCK.append(test_case)
+from tests.test_utils import dict_product
+
+TEST_CASE_RESBLOCK = [
+    [
+        params,
+        (2, params["in_channels"], *([16] * params["spatial_dims"])),
+        (2, params["in_channels"], *([16] * params["spatial_dims"])),
+    ]
+    for params in dict_product(
+        spatial_dims=range(2, 4),
+        in_channels=range(1, 4),
+        kernel_size=[1, 3],
+        norm=[("group", {"num_groups": 1}), "batch", "instance"],
+    )
+]
 
 
 class TestResBlock(unittest.TestCase):
-
     @parameterized.expand(TEST_CASE_RESBLOCK)
     def test_shape(self, input_param, input_shape, expected_shape):
         net = ResBlock(**input_param)