Improve other tests

Author: garciadias

tests/networks/blocks/test_segresnet_block.py

@@ -22,12 +22,7 @@
 
 TEST_CASE_RESBLOCK = [
     [
-        {
-            "spatial_dims": params["spatial_dims"],
-            "in_channels": params["in_channels"],
-            "kernel_size": params["kernel_size"],
-            "norm": params["norm"],
-        },
+        params,
         (2, params["in_channels"], *([16] * params["spatial_dims"])),
         (2, params["in_channels"], *([16] * params["spatial_dims"])),
     ]
@@ -41,7 +36,6 @@
 
 
 class TestResBlock(unittest.TestCase):
-
     @parameterized.expand(TEST_CASE_RESBLOCK)
     def test_shape(self, input_param, input_shape, expected_shape):
         net = ResBlock(**input_param)

tests/networks/blocks/test_transformerblock.py

@@ -26,13 +26,7 @@
 einops, has_einops = optional_import("einops")
 TEST_CASE_TRANSFORMERBLOCK = [
     [
-        {
-            "hidden_size": params["hidden_size"],
-            "num_heads": params["num_heads"],
-            "mlp_dim": params["mlp_dim"],
-            "dropout_rate": params["dropout_rate"],
-            "with_cross_attention": params["with_cross_attention"],
-        },
+        params,
         (2, 512, params["hidden_size"]),
         (2, 512, params["hidden_size"]),
     ]

tests/networks/blocks/test_unetr_block.py

@@ -32,27 +32,15 @@ def _get_out_size(params):
     return int((in_size + 2 * padding - kernel_size) / stride) + 1
 
 
-TEST_CASE_UNETR_BASIC_BLOCK = [
-    [
-        {
-            "spatial_dims": params["spatial_dims"],
-            "in_channels": 16,
-            "out_channels": 16,
-            "kernel_size": params["kernel_size"],
-            "norm_name": params["norm_name"],
-            "stride": params["stride"],
-        },
-        (1, 16, *([params["in_size"]] * params["spatial_dims"])),
-        (1, 16, *([_get_out_size(params)] * params["spatial_dims"])),
-    ]
-    for params in dict_product(
-        spatial_dims=range(1, 4),
-        kernel_size=[1, 3],
-        stride=[2],
-        norm_name=[("GROUP", {"num_groups": 16}), ("batch", {"track_running_stats": False}), "instance"],
-        in_size=[15, 16],
-    )
-]
+norm_names = [("GROUP", {"num_groups": 16}), ("batch", {"track_running_stats": False}), "instance"]
+param_dicts = dict_product(spatial_dims=range(1, 4), kernel_size=[1, 3], stride=[2], norm_name=norm_names, in_size=[15, 16])
+TEST_CASE_UNETR_BASIC_BLOCK = []
+for params in param_dicts:
+    input_param = {**{k: v for k, v in params.items() if k != "in_size"}, "in_channels": 16, "out_channels": 16}
+    input_shape = (1, 16, *([params["in_size"]] * params["spatial_dims"]))
+    expected_shape = (1, 16, *([_get_out_size(params)] * params["spatial_dims"]))
+    TEST_CASE_UNETR_BASIC_BLOCK.append([input_param, input_shape, expected_shape])
+
 
 TEST_UP_BLOCK = [
     [

tests/networks/nets/test_segresnet.py

@@ -48,10 +48,7 @@
 TEST_CASE_SEGRESNET_2 = [
     [
         {
-            "spatial_dims": params["spatial_dims"],
-            "init_filters": params["init_filters"],
-            "out_channels": params["out_channels"],
-            "upsample_mode": params["upsample_mode"],
+            **params,
         },
         (2, 1, *([16] * params["spatial_dims"])),
         (2, params["out_channels"], *([16] * params["spatial_dims"])),
@@ -64,13 +61,9 @@
 TEST_CASE_SEGRESNET_VAE = [
     [
         {
-            "spatial_dims": params["spatial_dims"],
-            "init_filters": params["init_filters"],
-            "out_channels": params["out_channels"],
-            "upsample_mode": params["upsample_mode"],
+            **params,
             "act": ("leakyrelu", {"inplace": True, "negative_slope": 0.01}),
             "input_image_size": ([16] * params["spatial_dims"]),
-            "vae_estimate_std": params["vae_estimate_std"],
         },
         (2, 1, *([16] * params["spatial_dims"])),
         (2, params["out_channels"], *([16] * params["spatial_dims"])),

tests/networks/nets/test_vit.py

@@ -21,31 +21,19 @@
 from tests.test_utils import SkipIfBeforePyTorchVersion, dict_product, skip_if_quick, test_script_save
 
 TEST_CASE_Vit = [
-    (
-        [
-            {
-                "in_channels": params["in_channels"],
-                "img_size": (params["img_size"],) * params["nd"],
-                "patch_size": (params["patch_size"],) * params["nd"],
-                "hidden_size": params["hidden_size"],
-                "mlp_dim": params["mlp_dim"],
-                "num_layers": params["num_layers"],
-                "num_heads": params["num_heads"],
-                "proj_type": params["proj_type"],
-                "classification": params["classification"],
-                "num_classes": params["num_classes"],
-                "dropout_rate": params["dropout_rate"],
-                **({"spatial_dims": 2} if params["nd"] == 2 else {}),
-                **({"post_activation": False} if params["nd"] == 2 and params["classification"] else {}),
-            },
-            (2, params["in_channels"], *([params["img_size"]] * params["nd"])),
-            (
-                (2, params["num_classes"])
-                if params["classification"]
-                else (2, (params["img_size"] // params["patch_size"]) ** params["nd"], params["hidden_size"])
-            ),
-        ]
-    )
+    ([
+        {
+            **{k: v for k, v in params.items() if k not in ["nd"]},
+            **({"spatial_dims": 2} if params["nd"] == 2 else {}),
+            **({"post_activation": False} if params["nd"] == 2 and params["classification"] else {}),
+        },
+        (2, params["in_channels"], *([params["img_size"]] * params["nd"])),
+        (
+            (2, params["num_classes"])
+            if params["classification"]
+            else (2, (params["img_size"] // params["patch_size"]) ** params["nd"], params["hidden_size"])
+        ),
+    ])
     for params in dict_product(
         dropout_rate=[0.6],
         in_channels=[4],
@@ -72,15 +60,13 @@ def test_shape(self, input_param, input_shape, expected_shape):
             result, _ = net(torch.randn(input_shape))
             self.assertEqual(result.shape, expected_shape)
 
-    @parameterized.expand(
-        [
-            (1, (128, 128, 128), (16, 16, 16), 128, 3072, 12, 12, "conv", False, 5.0),
-            (1, (32, 32, 32), (64, 64, 64), 512, 3072, 12, 8, "perceptron", False, 0.3),
-            (1, (96, 96, 96), (8, 8, 8), 512, 3072, 12, 14, "conv", False, 0.3),
-            (1, (97, 97, 97), (4, 4, 4), 768, 3072, 12, 8, "perceptron", True, 0.3),
-            (4, (96, 96, 96), (16, 16, 16), 768, 3072, 12, 12, "perc", False, 0.3),
-        ]
-    )
+    @parameterized.expand([
+        (1, (128, 128, 128), (16, 16, 16), 128, 3072, 12, 12, "conv", False, 5.0),
+        (1, (32, 32, 32), (64, 64, 64), 512, 3072, 12, 8, "perceptron", False, 0.3),
+        (1, (96, 96, 96), (8, 8, 8), 512, 3072, 12, 14, "conv", False, 0.3),
+        (1, (97, 97, 97), (4, 4, 4), 768, 3072, 12, 8, "perceptron", True, 0.3),
+        (4, (96, 96, 96), (16, 16, 16), 768, 3072, 12, 12, "perc", False, 0.3),
+    ])
     def test_ill_arg(
         self,
         in_channels,

tests/transforms/spatial/test_spatial_resampled.py

@@ -42,30 +42,26 @@
 ]
 
 for dst, expct in zip(destinations_3d, expected_3d):
-    TESTS.extend(
+    TESTS.extend([
         [
-            [
-                np.arange(12).reshape((1, 2, 2, 3)) + 1.0,  # data
-                *params["device"],
-                dst,
-                {
-                    "dst_keys": "dst_affine",
-                    "dtype": params["dtype"],
-                    "align_corners": params["align"],
-                    "mode": params["interp_mode"],
-                    "padding_mode": params["padding_mode"],
-                },
-                expct,
-            ]
-            for params in dict_product(
-                device=TEST_DEVICES,
-                align=[True, False],
-                dtype=[torch.float32, torch.float64],
-                interp_mode=["nearest", "bilinear"],
-                padding_mode=["zeros", "border", "reflection"],
-            )
+            np.arange(12).reshape((1, 2, 2, 3)) + 1.0,  # data
+            *params["device"],
+            dst,
+            {
+                **{k: v for k, v in params.items() if k not in ["device", "interp_mode"]},
+                "dst_keys": "dst_affine",
+                "padding_mode": "zeros",
+            },
+            expct,
         ]
-    )
+        for params in dict_product(
+            device=TEST_DEVICES,
+            align_corners=[True, False],
+            dtype=[torch.float32, torch.float64],
+            interp_mode=["nearest", "bilinear"],
+            padding_mode=["zeros", "border", "reflection"],
+        )
+    ])
 
 destinations_2d = [
     torch.tensor([[1.0, 0.0, 0.0], [0.0, -1.0, 1.0], [0.0, 0.0, 1.0]]),  # flip the second
@@ -75,29 +71,25 @@
 expected_2d = [torch.tensor([[[2.0, 1.0], [4.0, 3.0]]]), torch.tensor([[[3.0, 4.0], [1.0, 2.0]]])]
 
 for dst, expct in zip(destinations_2d, expected_2d):
-    TESTS.extend(
+    TESTS += [
         [
-            [
-                np.arange(4).reshape((1, 2, 2)) + 1.0,  # data
-                *params["device"],
-                dst,
-                {
-                    "dst_keys": "dst_affine",
-                    "dtype": params["dtype"],
-                    "align_corners": params["align"],
-                    "mode": params["interp_mode"],
-                    "padding_mode": "zeros",
-                },
-                expct,
-            ]
-            for params in dict_product(
-                device=TEST_DEVICES,
-                align=[False, True],
-                dtype=[torch.float32, torch.float64],
-                interp_mode=["nearest", "bilinear"],
-            )
+            np.arange(4).reshape((1, 2, 2)) + 1.0,  # data
+            *params.pop("device"),
+            dst,
+            {
+                **{k: v for k, v in params.items() if k not in ["align", "interp_mode"]},
+                "dst_keys": "dst_affine",
+                "padding_mode": "zeros",
+            },
+            expct,
         ]
-    )
+        for params in dict_product(
+            device=TEST_DEVICES,
+            align=[False, True],
+            dtype=[torch.float32, torch.float64],
+            interp_mode=["nearest", "bilinear"],
+        )
+    ]
 
 
 class TestSpatialResample(unittest.TestCase):

tests/transforms/utility/test_splitdimd.py

@@ -23,12 +23,7 @@
 from monai.transforms.utility.dictionary import SplitDimd
 from tests.test_utils import TEST_NDARRAYS, assert_allclose, dict_product, make_nifti_image, make_rand_affine
 
-TESTS = [
-    (params["keepdim"], params["p"], params["update_meta"], params["list_output"])
-    for params in dict_product(
-        p=TEST_NDARRAYS, keepdim=[True, False], update_meta=[True, False], list_output=[True, False]
-    )
-]
+TESTS = list(dict_product(keepdim=[True, False], p=TEST_NDARRAYS, update_meta=[True, False], list_output=[True, False]))
 
 
 class TestSplitDimd(unittest.TestCase):
@@ -44,9 +39,8 @@ def setUpClass(cls) -> None:
         cls.data = loader(data)
 
     @parameterized.expand(TESTS)
-    def test_correct(self, keepdim, im_type, update_meta, list_output):
+    def test_correct(self, keepdim, _, update_meta, list_output):
         data = deepcopy(self.data)
-        data["i"] = im_type(data["i"])
         arr = data["i"]
         for dim in range(arr.ndim):
             out = SplitDimd("i", dim=dim, keepdim=keepdim, update_meta=update_meta, list_output=list_output)(data)