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

tests/integration/test_one_of.py

@@ -0,0 +1,283 @@
+# 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 copy import deepcopy
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+import monai.transforms.intensity.array as ia
+import monai.transforms.spatial.array as sa
+import monai.transforms.spatial.dictionary as sd
+from monai.data import MetaTensor
+from monai.transforms import (
+    InvertibleTransform,
+    OneOf,
+    RandScaleIntensity,
+    RandScaleIntensityd,
+    RandShiftIntensity,
+    RandShiftIntensityd,
+    Resize,
+    Resized,
+    Transform,
+)
+from monai.transforms.compose import Compose
+from monai.transforms.transform import MapTransform
+from monai.utils.enums import TraceKeys
+
+
+class X(Transform):
+
+    def __call__(self, x):
+        return x
+
+
+class Y(Transform):
+
+    def __call__(self, x):
+        return x
+
+
+class A(Transform):
+
+    def __call__(self, x):
+        return x + 1
+
+
+class B(Transform):
+
+    def __call__(self, x):
+        return x + 2
+
+
+class C(Transform):
+
+    def __call__(self, x):
+        return x + 3
+
+
+class MapBase(MapTransform):
+
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn, self.inv_fn = None, None
+
+    def __call__(self, data):
+        d = deepcopy(dict(data))
+        for key in self.key_iterator(d):
+            d[key] = self.fwd_fn(d[key])
+        return d
+
+
+class NonInv(MapBase):
+
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn = lambda x: x * 2
+
+
+class Inv(MapBase, InvertibleTransform):
+
+    def __call__(self, data):
+        d = deepcopy(dict(data))
+        for key in self.key_iterator(d):
+            d[key] = self.fwd_fn(d[key])
+            self.push_transform(d, key)
+        return d
+
+    def inverse(self, data):
+        d = deepcopy(dict(data))
+        for key in self.key_iterator(d):
+            d[key] = self.inv_fn(d[key])
+            self.pop_transform(d, key)
+        return d
+
+
+class InvA(Inv):
+
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn = lambda x: x + 1
+        self.inv_fn = lambda x: x - 1
+
+
+class InvB(Inv):
+
+    def __init__(self, keys):
+        super().__init__(keys)
+        self.fwd_fn = lambda x: x + 100
+        self.inv_fn = lambda x: x - 100
+
+
+TESTS = [((X(), Y(), X()), (1, 2, 1), (0.25, 0.5, 0.25))]
+
+KEYS = ["x", "y"]
+TEST_INVERSES = [
+    (OneOf((InvA(KEYS), InvB(KEYS))), True, True),
+    (OneOf((OneOf((InvA(KEYS), InvB(KEYS))), OneOf((InvB(KEYS), InvA(KEYS))))), True, False),
+    (OneOf((Compose((InvA(KEYS), InvB(KEYS))), Compose((InvB(KEYS), InvA(KEYS))))), True, False),
+    (OneOf((NonInv(KEYS), NonInv(KEYS))), False, False),
+]
+
+
+class TestOneOf(unittest.TestCase):
+
+    @parameterized.expand(TESTS)
+    def test_normalize_weights(self, transforms, input_weights, expected_weights):
+        tr = OneOf(transforms, input_weights)
+        self.assertTupleEqual(tr.weights, expected_weights)
+
+    def test_no_weights_arg(self):
+        p = OneOf((X(), Y(), X(), Y()))
+        expected_weights = (0.25,) * 4
+        self.assertTupleEqual(p.weights, expected_weights)
+
+    def test_len_and_flatten(self):
+        p1 = OneOf((X(), Y()), (1, 3))  # 0.25, 0.75
+        p2 = OneOf((Y(), Y()), (2, 2))  # 0.5. 0.5
+        p = OneOf((p1, p2, X()), (1, 2, 1))  # 0.25, 0.5, 0.25
+        expected_order = (X, Y, Y, Y, X)
+        expected_weights = (0.25 * 0.25, 0.25 * 0.75, 0.5 * 0.5, 0.5 * 0.5, 0.25)
+        self.assertEqual(len(p), len(expected_order))
+        self.assertTupleEqual(p.flatten().weights, expected_weights)
+
+    def test_compose_flatten_does_not_affect_one_of(self):
+        p = Compose([A(), B(), OneOf([C(), Inv(KEYS), Compose([X(), Y()])])])
+        f = p.flatten()
+
+        # in this case the flattened transform should be the same.
+
+        def _match(a, b):
+            self.assertEqual(type(a), type(b))
+            for a_, b_ in zip(a.transforms, b.transforms):
+                self.assertEqual(type(a_), type(b_))
+                if isinstance(a_, (Compose, OneOf)):
+                    _match(a_, b_)
+
+        _match(p, f)
+
+    @parameterized.expand(TEST_INVERSES)
+    def test_inverse(self, transform, invertible, use_metatensor):
+        data = {k: MetaTensor((i + 1) * 10.0) for i, k in enumerate(KEYS)}
+        fwd_data = transform(data)
+
+        if invertible:
+            for k in KEYS:
+                t = fwd_data[k].applied_operations[-1]
+                # make sure the OneOf index was stored
+                self.assertEqual(t[TraceKeys.CLASS_NAME], OneOf.__name__)
+                # make sure index exists and is in bounds
+                self.assertTrue(0 <= t[TraceKeys.EXTRA_INFO]["index"] < len(transform))
+
+        # call the inverse
+        fwd_inv_data = transform.inverse(fwd_data)
+
+        if invertible:
+            for k in KEYS:
+                # check data is same as original (and different from forward)
+                self.assertEqual(fwd_inv_data[k], data[k])
+                self.assertNotEqual(fwd_inv_data[k], fwd_data[k])
+        else:
+            # if not invertible, should not change the data
+            self.assertDictEqual(fwd_data, fwd_inv_data)
+
+    def test_inverse_compose(self):
+        transform = Compose(
+            [
+                Resized(keys="img", spatial_size=[100, 100, 100]),
+                OneOf(
+                    [
+                        RandScaleIntensityd(keys="img", factors=0.5, prob=1.0),
+                        RandShiftIntensityd(keys="img", offsets=0.5, prob=1.0),
+                    ]
+                ),
+                OneOf(
+                    [
+                        RandScaleIntensityd(keys="img", factors=0.5, prob=1.0),
+                        RandShiftIntensityd(keys="img", offsets=0.5, prob=1.0),
+                    ]
+                ),
+            ]
+        )
+        transform.set_random_state(seed=0)
+        result = transform({"img": np.ones((1, 101, 102, 103))})
+        result = transform.inverse(result)
+        # invert to the original spatial shape
+        self.assertTupleEqual(result["img"].shape, (1, 101, 102, 103))
+
+    def test_inverse_metatensor(self):
+        transform = Compose(
+            [
+                Resize(spatial_size=[100, 100, 100]),
+                OneOf([RandScaleIntensity(factors=0.5, prob=1.0), RandShiftIntensity(offsets=0.5, prob=1.0)]),
+                OneOf([RandScaleIntensity(factors=0.5, prob=1.0), RandShiftIntensity(offsets=0.5, prob=1.0)]),
+            ]
+        )
+        transform.set_random_state(seed=0)
+        result = transform(np.ones((1, 101, 102, 103)))
+        self.assertTupleEqual(result.shape, (1, 100, 100, 100))
+        result = transform.inverse(result)
+        self.assertTupleEqual(result.shape, (1, 101, 102, 103))
+
+    def test_one_of(self):
+        p = OneOf((A(), B(), C()), (1, 2, 1))
+        counts = [0] * 3
+        for _i in range(10000):
+            out = p(1.0)
+            counts[int(out - 2)] += 1
+        self.assertAlmostEqual(counts[0] / 10000, 0.25, delta=1.0)
+        self.assertAlmostEqual(counts[1] / 10000, 0.50, delta=1.0)
+        self.assertAlmostEqual(counts[2] / 10000, 0.25, delta=1.0)
+
+
+TEST_ONEOF_EXTENDED_TEST_CASES = [
+    [None, tuple()],
+    [None, (sa.Rotate(np.pi / 8),)],
+    [None, (sa.Flip(0), sa.Flip(1), sa.Rotate90(1), sa.Zoom(0.8), ia.NormalizeIntensity())],
+    [("a",), (sd.Rotated(("a",), np.pi / 8),)],
+]
+
+
+class TestOneOfAPITests(unittest.TestCase):
+
+    @staticmethod
+    def data_from_keys(keys):
+        if keys is None:
+            data = torch.unsqueeze(torch.tensor(np.arange(12 * 16).reshape(12, 16)), dim=0)
+        else:
+            data = {}
+            for i_k, k in enumerate(keys):
+                data[k] = torch.unsqueeze(torch.tensor(np.arange(12 * 16)).reshape(12, 16) + i_k * 192, dim=0)
+        return data
+
+    @parameterized.expand(TEST_ONEOF_EXTENDED_TEST_CASES)
+    def test_execute_change_start_end(self, keys, pipeline):
+        data = self.data_from_keys(keys)
+
+        c = OneOf(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+        with self.assertRaises(ValueError):
+            c(data, start=1)
+
+        c = OneOf(deepcopy(pipeline))
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+        with self.assertRaises(ValueError):
+            c(data, end=1)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_pad_collation.py

@@ -0,0 +1,124 @@
+# 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 random
+import unittest
+from functools import wraps
+
+import numpy as np
+import torch
+from parameterized import parameterized
+
+from monai.data import CacheDataset, DataLoader
+from monai.data.utils import decollate_batch, pad_list_data_collate
+from monai.transforms import (
+    BatchInverseTransform,
+    Compose,
+    PadListDataCollate,
+    RandRotate,
+    RandRotate90,
+    RandRotate90d,
+    RandRotated,
+    RandSpatialCrop,
+    RandSpatialCropd,
+    RandZoom,
+    RandZoomd,
+    ToTensor,
+)
+from monai.utils import set_determinism
+
+
+@wraps(pad_list_data_collate)
+def _testing_collate(x):
+    return pad_list_data_collate(batch=x, method="end", mode="constant")
+
+
+TESTS: list[tuple] = []
+
+for pad_collate in [_testing_collate, PadListDataCollate(method="end", mode="constant")]:
+    TESTS.append((dict, pad_collate, RandSpatialCropd("image", roi_size=[8, 7], random_size=True)))
+    TESTS.append((dict, pad_collate, RandRotated("image", prob=1, range_x=np.pi, keep_size=False, dtype=np.float64)))
+    TESTS.append((dict, pad_collate, RandZoomd("image", prob=1, min_zoom=1.1, max_zoom=2.0, keep_size=False)))
+    TESTS.append(
+        (dict, pad_collate, Compose([RandRotate90d("image", prob=1, max_k=3), RandRotate90d("image", prob=1, max_k=4)]))
+    )
+
+    TESTS.append((list, pad_collate, RandSpatialCrop(roi_size=[8, 7], random_size=True)))
+    TESTS.append((list, pad_collate, RandRotate(prob=1, range_x=np.pi, keep_size=False, dtype=np.float64)))
+    TESTS.append((list, pad_collate, RandZoom(prob=1, min_zoom=1.1, max_zoom=2.0, keep_size=False)))
+    TESTS.append((list, pad_collate, Compose([RandRotate90(prob=1, max_k=2), ToTensor()])))
+
+
+class _Dataset(torch.utils.data.Dataset):
+
+    def __init__(self, images, labels, transforms):
+        self.images = images
+        self.labels = labels
+        self.transform = transforms
+
+    def __len__(self):
+        return len(self.images)
+
+    def __getitem__(self, index):
+        return self.transform(self.images[index]), self.labels[index]
+
+
+class TestPadCollation(unittest.TestCase):
+
+    def setUp(self) -> None:
+        set_determinism(seed=0)
+        # image is non square to throw rotation errors
+        im = np.arange(0, 10 * 9).reshape(1, 10, 9)
+        num_elements = 20
+        self.dict_data = [{"image": im} for _ in range(num_elements)]
+        self.list_data = [im for _ in range(num_elements)]
+        self.list_labels = [random.randint(0, 1) for _ in range(num_elements)]
+
+    def tearDown(self) -> None:
+        set_determinism(None)
+
+    @parameterized.expand(TESTS)
+    def test_pad_collation(self, t_type, collate_method, transform):
+        if t_type is dict:
+            dataset = CacheDataset(self.dict_data, transform, progress=False)
+        else:
+            dataset = _Dataset(self.list_data, self.list_labels, transform)
+
+        # Default collation should raise an error
+        loader_fail = DataLoader(dataset, batch_size=10)
+        with self.assertRaises(RuntimeError):
+            for _ in loader_fail:
+                pass
+
+        # Padded collation shouldn't
+        loader = DataLoader(dataset, batch_size=10, collate_fn=collate_method)
+        # check collation in forward direction
+        for data in loader:
+            if t_type is dict:
+                shapes = []
+                decollated_data = decollate_batch(data)
+                for d in decollated_data:
+                    output = PadListDataCollate.inverse(d)
+                    shapes.append(output["image"].shape)
+                    self.assertTrue(len(output["image"].applied_operations), len(dataset.transform.transforms))
+                self.assertTrue(len(set(shapes)) > 1)  # inverted shapes must be different because of random xforms
+
+        if t_type is dict:
+            batch_inverse = BatchInverseTransform(dataset.transform, loader)
+            for data in loader:
+                output = batch_inverse(data)
+                self.assertEqual(output[0]["image"].shape, (1, 10, 9))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_reg_loss_integration.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 unittest
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from parameterized import parameterized
+
+from monai.losses import BendingEnergyLoss, GlobalMutualInformationLoss, LocalNormalizedCrossCorrelationLoss
+from tests.test_utils import SkipIfBeforePyTorchVersion
+
+TEST_CASES = [
+    [BendingEnergyLoss, {}, ["pred"], 3],
+    [LocalNormalizedCrossCorrelationLoss, {"kernel_size": 7, "kernel_type": "rectangular"}, ["pred", "target"]],
+    [LocalNormalizedCrossCorrelationLoss, {"kernel_size": 5, "kernel_type": "triangular"}, ["pred", "target"]],
+    [LocalNormalizedCrossCorrelationLoss, {"kernel_size": 3, "kernel_type": "gaussian"}, ["pred", "target"]],
+    [GlobalMutualInformationLoss, {"num_bins": 10}, ["pred", "target"]],
+    [GlobalMutualInformationLoss, {"kernel_type": "b-spline", "num_bins": 10}, ["pred", "target"]],
+]
+
+
+class TestRegLossIntegration(unittest.TestCase):
+    def setUp(self):
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        torch.manual_seed(0)
+        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu:0")
+
+    def tearDown(self):
+        torch.backends.cudnn.deterministic = False
+        torch.backends.cudnn.benchmark = True
+
+    @parameterized.expand(TEST_CASES)
+    @SkipIfBeforePyTorchVersion((1, 9))
+    def test_convergence(self, loss_type, loss_args, forward_args, pred_channels=1):
+        """
+        The goal of this test is to assess if the gradient of the loss function
+        is correct by testing if we can train a one layer neural network
+        to segment one image.
+        We verify that the loss is decreasing in almost all SGD steps.
+        """
+        learning_rate = 0.001
+        max_iter = 100
+
+        # define a simple 3d example
+        target = torch.rand((1, 1, 5, 5, 5), device=self.device)
+        image = 12 * target + 27
+        image = image.to(device=self.device)
+
+        # define a one layer model
+        class OnelayerNet(nn.Module):
+            def __init__(self):
+                super().__init__()
+                self.layer = nn.Sequential(
+                    nn.Conv3d(in_channels=1, out_channels=1, kernel_size=3, padding=1),
+                    nn.ReLU(),
+                    nn.Conv3d(in_channels=1, out_channels=pred_channels, kernel_size=3, padding=1),
+                )
+
+            def forward(self, x):
+                return self.layer(x)
+
+        # initialise the network
+        net = OnelayerNet().to(self.device)
+
+        # initialize the loss
+        loss = loss_type(**loss_args).to(self.device)
+
+        # initialize a SGD optimizer
+        optimizer = optim.Adam(net.parameters(), lr=learning_rate)
+
+        # declare first for pylint
+        init_loss = None
+
+        # train the network
+        for it in range(max_iter):
+            # set the gradient to zero
+            optimizer.zero_grad()
+
+            # forward pass
+            output = net(image)
+            loss_input = {"pred": output, "target": target}
+
+            loss_val = loss(**{k: loss_input[k] for k in forward_args})
+            if it == 0:
+                init_loss = loss_val
+
+            # backward pass
+            loss_val.backward()
+            optimizer.step()
+        self.assertGreater(init_loss, loss_val, "loss did not decrease")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/integration/test_retinanet_predict_utils.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 unittest
+
+import torch
+from parameterized import parameterized
+
+from monai.apps.detection.utils.predict_utils import ensure_dict_value_to_list_, predict_with_inferer
+from monai.inferers import SlidingWindowInferer
+
+TEST_CASE_1 = [  # 3D, batch 3, 2 input channel
+    {
+        "pretrained": False,
+        "spatial_dims": 3,
+        "n_input_channels": 2,
+        "num_classes": 3,
+        "conv1_t_size": 7,
+        "conv1_t_stride": (2, 2, 2),
+    },
+    (3, 2, 32, 64, 48),
+]
+
+TEST_CASE_2 = [  # 2D, batch 2, 1 input channel
+    {
+        "pretrained": False,
+        "spatial_dims": 2,
+        "n_input_channels": 1,
+        "num_classes": 3,
+        "conv1_t_size": [7, 7],
+        "conv1_t_stride": [2, 2],
+    },
+    (2, 1, 32, 64),
+]
+
+TEST_CASE_2_A = [  # 2D, batch 2, 1 input channel, shortcut type A
+    {
+        "pretrained": False,
+        "spatial_dims": 2,
+        "n_input_channels": 1,
+        "num_classes": 3,
+        "shortcut_type": "A",
+        "conv1_t_size": (7, 7),
+        "conv1_t_stride": 2,
+    },
+    (2, 1, 32, 64),
+]
+
+TEST_CASE_3 = [  # 1D, batch 1, 2 input channels
+    {
+        "pretrained": False,
+        "spatial_dims": 1,
+        "n_input_channels": 2,
+        "num_classes": 3,
+        "conv1_t_size": [3],
+        "conv1_t_stride": 1,
+    },
+    (1, 2, 32),
+]
+
+TEST_CASE_3_A = [  # 1D, batch 1, 2 input channels
+    {"pretrained": False, "spatial_dims": 1, "n_input_channels": 2, "num_classes": 3, "shortcut_type": "A"},
+    (1, 2, 32),
+]
+
+TEST_CASE_4 = [  # 2D, batch 2, 1 input channel
+    {"pretrained": False, "spatial_dims": 2, "n_input_channels": 1, "num_classes": 3, "feed_forward": False},
+    (2, 1, 32, 64),
+]
+
+TEST_CASES = []
+TEST_CASES = [TEST_CASE_1, TEST_CASE_2, TEST_CASE_2_A]
+
+TEST_CASES_TS = [TEST_CASE_1]
+
+
+class NaiveNetwork(torch.nn.Module):
+
+    def __init__(self, spatial_dims, num_classes, **kwargs):
+        super().__init__()
+        self.spatial_dims = spatial_dims
+        self.num_classes = num_classes
+        self.num_anchors = 1
+        self.cls_key = "cls"
+        self.box_reg_key = "box_reg"
+        self.size_divisible = 1
+
+    def forward(self, images):
+        out_cls_shape = (images.shape[0], self.num_classes * self.num_anchors) + images.shape[-self.spatial_dims :]
+        out_box_reg_shape = (images.shape[0], 2 * self.spatial_dims * self.num_anchors) + images.shape[
+            -self.spatial_dims :
+        ]
+        return {self.cls_key: torch.randn(out_cls_shape), self.box_reg_key: [torch.randn(out_box_reg_shape)]}
+
+
+class NaiveNetwork2(torch.nn.Module):
+
+    def __init__(self, spatial_dims, num_classes, **kwargs):
+        super().__init__()
+        self.spatial_dims = spatial_dims
+        self.num_classes = num_classes
+        self.num_anchors = 1
+        self.cls_key = "cls"
+        self.box_reg_key = "box_reg"
+        self.size_divisible = 1
+
+    def forward(self, images):
+        out_cls_shape = (images.shape[0], self.num_classes * self.num_anchors) + images.shape[-self.spatial_dims :]
+        out_box_reg_shape = (images.shape[0], 2 * self.spatial_dims * self.num_anchors) + images.shape[
+            -self.spatial_dims :
+        ]
+        return {self.cls_key: [torch.randn(out_cls_shape)] * 2, self.box_reg_key: [torch.randn(out_box_reg_shape)] * 2}
+
+
+class TestPredictor(unittest.TestCase):
+
+    @parameterized.expand(TEST_CASES)
+    def test_naive_predictor(self, input_param, input_shape):
+        net = NaiveNetwork(**input_param)
+        net2 = NaiveNetwork2(**input_param)
+        inferer = SlidingWindowInferer(roi_size=16, overlap=0.25, cache_roi_weight_map=True)
+        network_output_keys = ["cls", "box_reg"]
+
+        input_data = torch.randn(input_shape)
+
+        result = predict_with_inferer(input_data, net, network_output_keys, inferer=inferer)
+        self.assertTrue(len(result["cls"]) == 1)
+
+        result = net(input_data)
+        self.assertTrue(len(result["cls"]) == input_data.shape[0])
+        ensure_dict_value_to_list_(result)
+        self.assertTrue(len(result["cls"]) == 1)
+
+        result = predict_with_inferer(input_data, net2, network_output_keys, inferer=inferer)
+        self.assertTrue(len(result["cls"]) == 2)
+
+        result = net2(input_data)
+        self.assertTrue(len(result["cls"]) == 2)
+        ensure_dict_value_to_list_(result)
+        self.assertTrue(len(result["cls"]) == 2)
+
+
+if __name__ == "__main__":
+    unittest.main()