Correcting comments on pull requests_2

Author: gouda-youichi

tests_pytest/common_tests/core/common/quantization/test_manual_bitwidth_selection.py

@@ -8,7 +8,8 @@
 from model_compression_toolkit.core.common.graph.edge import Edge
 from tests_pytest.test_util.graph_builder_utils import build_node
 
-from model_compression_toolkit.target_platform_capabilities.constants import KERNEL_ATTR, BIAS_ATTR
+TEST_KERNEL = 'kernel'
+TEST_BIAS = 'bias'
 
 ### dummy layer classes
 class Conv2D:
@@ -29,11 +30,11 @@ class Dense:
 ### test model
 def get_test_graph():
     n1 = build_node('input', layer_class=InputLayer)
-    conv1 = build_node('conv1', layer_class=Conv2D)
+    conv1 = build_node('conv1', layer_class=Conv2D, canonical_weights={TEST_KERNEL: [1,2], TEST_BIAS: [3,4]})
     add1 = build_node('add1', layer_class=Add)
     conv2 = build_node('conv2', layer_class=Conv2D)
     bn1 = build_node('bn1', layer_class=BatchNormalization)
-    relu = build_node('relu1', layer_class=ReLU)
+    relu = build_node('relu1', layer_class=ReLU, canonical_weights={TEST_KERNEL: [1,2], TEST_BIAS: [3,4]})
     add2 = build_node('add2', layer_class=Add)
     flatten = build_node('flatten', layer_class=Flatten)
     fc = build_node('fc', layer_class=Dense)
@@ -55,41 +56,25 @@ def get_test_graph():
     return graph
 
 class TestBitWidthConfig:
-    # test case
-    setter_test_input_0 = {"activation": (None, None),
-                           "weights":    (None, None, None)}
-    setter_test_input_1 = {"activation": (NodeTypeFilter(ReLU), [16]),
-                           "weights":    (None, None, None)}
-    setter_test_input_2 = {"activation": (None, None),
-                           "weights":    (NodeNameFilter("conv2"), [8], KERNEL_ATTR)}
-    setter_test_input_3 = {"activation": (NodeTypeFilter(ReLU), [16]),
-                           "weights":    (NodeNameFilter("conv2"), [8], KERNEL_ATTR)}
-    setter_test_input_4 = {"activation": ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16, 8]),
-                           "weights":    ([NodeTypeFilter(Conv2D), NodeNameFilter("fc")], [16, 2], [KERNEL_ATTR, BIAS_ATTR])}
-
-    setter_test_expected_0 = {"activation": (None, None),
-                              "weights":    (None, None, None)}
-    setter_test_expected_1 = {"activation": ([NodeTypeFilter, ReLU, 16]),
-                              "weights":    (None, None, None)}
-    setter_test_expected_2 = {"activation": (None, None),
-                              "weights":    ([NodeNameFilter, "conv2", 8, KERNEL_ATTR]) }
-    setter_test_expected_3 = {"activation": ([NodeTypeFilter, ReLU, 16]),
-                              "weights":    ([NodeNameFilter, "conv2", 8, KERNEL_ATTR])}
-    setter_test_expected_4 = {"activation": ([NodeTypeFilter, ReLU, 16], [NodeNameFilter, "conv1", 8]),
-                              "weights":    ([NodeTypeFilter, Conv2D, 16, KERNEL_ATTR], [NodeNameFilter, "fc", 2, BIAS_ATTR])}
-
-
-    # test : BitWidthConfig set_manual_activation_bit_width, set_manual_weights_bit_width
+    # test case for set_manual_activation_bit_width
+    test_input_0 = (None, None)
+    test_input_1 = (NodeTypeFilter(ReLU), 16)
+    test_input_2 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16])
+    test_input_3 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16, 8])
+
+    test_expected_0 = ("The filters cannot be None.", None)
+    test_expected_1 = (NodeTypeFilter, ReLU, 16)
+    test_expected_2 = ([NodeTypeFilter, ReLU, 16], [NodeNameFilter, "conv1", 16])
+    test_expected_3 = ([NodeTypeFilter, ReLU, 16], [NodeNameFilter, "conv1", 8])
+
     @pytest.mark.parametrize(("inputs", "expected"), [
-        (setter_test_input_0, setter_test_expected_0),
-        (setter_test_input_1, setter_test_expected_1),
-        (setter_test_input_2, setter_test_expected_2),
-        (setter_test_input_3, setter_test_expected_3),
-        (setter_test_input_4, setter_test_expected_4),
+        (test_input_0, test_expected_0),
+        (test_input_1, test_expected_1),
+        (test_input_2, test_expected_2),
+        (test_input_3, test_expected_3),
     ])
-    def test_bit_width_config_setter(self, inputs, expected):
-
-        def check_param(mb_cfg, exp):
+    def test_set_manual_activation_bit_width(self, inputs, expected):
+        def check_param_for_activation(mb_cfg, exp):
             ### check setting config class (expected ManualBitWidthSelection)
             assert type(mb_cfg) == ManualBitWidthSelection
 
@@ -106,8 +91,40 @@ def check_param(mb_cfg, exp):
             else:
                 assert mb_cfg.filter is None
 
-        def check_param_for_weights(mb_cfg, exp):
-            ### check setting config class (expected ManualBitWidthSelection)
+        manual_bit_cfg = BitWidthConfig()
+        try:
+            manual_bit_cfg.set_manual_activation_bit_width(inputs[0], inputs[1])
+            ### check Activation
+            if len(manual_bit_cfg.manual_activation_bit_width_selection_list) == 1:
+                for a_mb_cfg in manual_bit_cfg.manual_activation_bit_width_selection_list:
+                    print(a_mb_cfg, expected)
+                    check_param_for_activation(a_mb_cfg, expected)
+            else:
+                for idx, a_mb_cfg in enumerate(manual_bit_cfg.manual_activation_bit_width_selection_list):
+                    check_param_for_activation(a_mb_cfg, expected[idx])
+        except Exception as e:
+            assert str(e) == expected[0]
+
+    # test case for set_manual_weights_bit_width
+    test_input_0 = (None, None, None)
+    test_input_1 = (NodeTypeFilter(ReLU), 16, TEST_KERNEL)
+    test_input_2 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16], [TEST_KERNEL])
+    test_input_3 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16, 8], [TEST_KERNEL, TEST_BIAS])
+
+    test_expected_0 = ("The filters cannot be None.", None, None)
+    test_expected_1 = (NodeTypeFilter, ReLU, 16, TEST_KERNEL)
+    test_expected_2 = ([NodeTypeFilter, ReLU, 16, TEST_KERNEL], [NodeNameFilter, "conv1", 16, TEST_KERNEL])
+    test_expected_3 = ([NodeTypeFilter, ReLU, 16, TEST_KERNEL], [NodeNameFilter, "conv1", 8, TEST_BIAS])
+
+    @pytest.mark.parametrize(("inputs", "expected"), [
+        (test_input_0, test_expected_0),
+        (test_input_1, test_expected_1),
+        (test_input_2, test_expected_2),
+        (test_input_3, test_expected_3),
+    ])
+    def test_set_manual_weights_bit_width(self, inputs, expected):
+        def check_param_weights(mb_cfg, exp):
+            ### check setting config class (expected ManualWeightsBitWidthSelection)
             assert type(mb_cfg) == ManualWeightsBitWidthSelection
 
             ### check setting filter for NodeFilter and NodeInfo
@@ -118,94 +135,81 @@ def check_param_for_weights(mb_cfg, exp):
                 elif isinstance(mb_cfg.filter, NodeNameFilter):
                     assert mb_cfg.filter.node_name == exp[1]
 
-                ### check setting bit_width
+                ### check setting bit_width and attr
                 assert mb_cfg.bit_width == exp[2]
                 assert mb_cfg.attr == exp[3]
             else:
                 assert mb_cfg.filter is None
 
-        activation = inputs["activation"]
-        weights = inputs["weights"]
+        manual_bit_cfg = BitWidthConfig()
+        try:
+            manual_bit_cfg.set_manual_weights_bit_width(inputs[0], inputs[1], inputs[2])
+            ### check weights
+            if len(manual_bit_cfg.manual_weights_bit_width_selection_list) == 1:
+                for a_mb_cfg in manual_bit_cfg.manual_weights_bit_width_selection_list:
+                    print(a_mb_cfg, expected)
+                    check_param_weights(a_mb_cfg, expected)
+            else:
+                for idx, a_mb_cfg in enumerate(manual_bit_cfg.manual_weights_bit_width_selection_list):
+                    check_param_weights(a_mb_cfg, expected[idx])
+        except Exception as e:
+            assert str(e) == expected[0]
 
-        activation_expected = expected["activation"]
-        weights_expected = expected["weights"]
+    # test case for get_nodes_to_manipulate_activation_bit_widths
+    test_input_0 = (NodeTypeFilter(ReLU), 16)
+    test_input_1 = (NodeNameFilter('relu1'), 16)
+    test_input_2 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16, 8])
 
-        manual_bit_cfg = BitWidthConfig()
+    test_expected_0 = ({"ReLU:relu1": 16})
+    test_expected_1 = ({"ReLU:relu1": 16})
+    test_expected_2 = ({"ReLU:relu1": 16, "Conv2D:conv1": 8})
 
-        manual_bit_cfg.set_manual_activation_bit_width(activation[0], activation[1])
-        manual_bit_cfg.set_manual_weights_bit_width(weights[0], weights[1], weights[2])
-
-        ### check got object instance
-        assert isinstance(manual_bit_cfg, BitWidthConfig)
-
-        ### check Activation
-        if len(manual_bit_cfg.manual_activation_bit_width_selection_list) == 1:
-            for a_mb_cfg in manual_bit_cfg.manual_activation_bit_width_selection_list:
-                check_param(a_mb_cfg, activation_expected)
-        else:
-            for idx, a_mb_cfg in enumerate(manual_bit_cfg.manual_activation_bit_width_selection_list):
-                check_param(a_mb_cfg, activation_expected[idx])
-
-        ### check Weights
-        if len(manual_bit_cfg.manual_weights_bit_width_selection_list) == 1:
-            for w_mb_cfg in manual_bit_cfg.manual_weights_bit_width_selection_list:
-                check_param_for_weights(w_mb_cfg, weights_expected)
-        else:
-            for idx, w_mb_cfg in enumerate(manual_bit_cfg.manual_weights_bit_width_selection_list):
-                check_param_for_weights(w_mb_cfg, weights_expected[idx])
-
-
-    ### test case
-    ### Note: setter inputs reuse getters test inputs
-    getter_test_expected_0 = {"activation":{},
-                              "weights": {}}
-    getter_test_expected_1 = {"activation":{"ReLU:relu1": 16},
-                              "weights": {}}
-    getter_test_expected_2 = {"activation":{},
-                              "weights": {"Conv2D:conv2": [8, KERNEL_ATTR]}}
-    getter_test_expected_3 = {"activation": {"ReLU:relu1": 16},
-                              "weights": {"Conv2D:conv2": [8, KERNEL_ATTR]}}
-    getter_test_expected_4 = {"activation": {"ReLU:relu1": 16, "Conv2D:conv1": 8},
-                              "weights": {"Conv2D:conv1": [16, KERNEL_ATTR], "Conv2D:conv2": [16, KERNEL_ATTR], "Dense:fc": [2, BIAS_ATTR]}}
-
-    # test : BitWidthConfig get_nodes_to_manipulate_bit_widths
     @pytest.mark.parametrize(("inputs", "expected"), [
-        (setter_test_input_0, getter_test_expected_0),
-        (setter_test_input_1, getter_test_expected_1),
-        (setter_test_input_2, getter_test_expected_2),
-        (setter_test_input_3, getter_test_expected_3),
-        (setter_test_input_4, getter_test_expected_4),
+        (test_input_0, test_expected_0),
+        (test_input_1, test_expected_1),
+        (test_input_2, test_expected_2),
     ])
-    def test_bit_width_config_getter(self, inputs, expected):
+    def test_get_nodes_to_manipulate_activation_bit_widths(self, inputs, expected):
+        fl_list = inputs[0] if isinstance(inputs[0], list) else [inputs[0]]
+        bw_list = inputs[1] if isinstance(inputs[1], list) else [inputs[1]]
+
+        mbws_config = []
+        for fl, bw in zip(fl_list, bw_list):
+            mbws_config.append(ManualBitWidthSelection(fl, bw))
+        manual_bit_cfg = BitWidthConfig(manual_activation_bit_width_selection_list=mbws_config)
 
         graph = get_test_graph()
+        get_manual_bit_dict_activation = manual_bit_cfg.get_nodes_to_manipulate_activation_bit_widths(graph)
+        for idx, (key, val) in enumerate(get_manual_bit_dict_activation.items()):
+            assert str(key) == list(expected.keys())[idx]
+            assert val == list(expected.values())[idx]
 
-        activation = inputs["activation"]
-        weights = inputs["weights"]
+    # test case for get_nodes_to_manipulate_weights_bit_widths
+    test_input_0 = (NodeTypeFilter(ReLU), 16, TEST_KERNEL)
+    test_input_1 = (NodeNameFilter('relu1'), 16, TEST_BIAS)
+    test_input_2 = ([NodeTypeFilter(ReLU), NodeNameFilter("conv1")], [16, 8], [TEST_KERNEL, TEST_BIAS])
 
-        activation_expected = expected["activation"]
-        weights_expected = expected["weights"]
+    test_expected_0 = ({"ReLU:relu1": [16, TEST_KERNEL]})
+    test_expected_1 = ({"ReLU:relu1": [16, TEST_BIAS]})
+    test_expected_2 = ({"ReLU:relu1": [16, TEST_KERNEL], "Conv2D:conv1": [8, TEST_BIAS]})
 
-        manual_bit_cfg = BitWidthConfig()
-        if activation[0] is not None:
-            manual_bit_cfg.set_manual_activation_bit_width(activation[0], activation[1])
-        if weights[0] is not None:
-            manual_bit_cfg.set_manual_weights_bit_width(weights[0], weights[1], weights[2])
+    @pytest.mark.parametrize(("inputs", "expected"), [
+        (test_input_0, test_expected_0),
+        (test_input_1, test_expected_1),
+        (test_input_2, test_expected_2),
+    ])
+    def test_get_nodes_to_manipulate_weights_bit_widths(self, inputs, expected):
+        fl_list = inputs[0] if isinstance(inputs[0], list) else [inputs[0]]
+        bw_list = inputs[1] if isinstance(inputs[1], list) else [inputs[1]]
+        at_list = inputs[2] if isinstance(inputs[2], list) else [inputs[2]]
 
-        get_manual_bit_dict_activation = manual_bit_cfg.get_nodes_to_manipulate_activation_bit_widths(graph)
-        get_manual_bit_dict_weights = manual_bit_cfg.get_nodes_to_manipulate_weights_bit_widths(graph)
+        manual_weights_bit_width_config = []
+        for fl, bw, at in zip(fl_list, bw_list, at_list):
+            manual_weights_bit_width_config.append(ManualWeightsBitWidthSelection(fl, bw, at))
+        manual_bit_cfg = BitWidthConfig(manual_weights_bit_width_selection_list=manual_weights_bit_width_config)
 
-        if activation[0] is not None:
-            for idx, (key, val) in enumerate(get_manual_bit_dict_activation.items()):
-                assert str(key) == list(activation_expected.keys())[idx]
-                assert val == list(activation_expected.values())[idx]
-        else:
-            assert get_manual_bit_dict_activation == activation_expected
-
-        if weights[0] is not None:
-            for idx, (key, val) in enumerate(get_manual_bit_dict_weights.items()):
-                assert str(key) == list(weights_expected.keys())[idx]
-                assert val[0] == list(weights_expected.values())[idx][0]
-                assert val[1] == list(weights_expected.values())[idx][1]
-        else:
-            assert get_manual_bit_dict_weights == weights_expected
+        graph = get_test_graph()
+        get_manual_bit_dict_weights = manual_bit_cfg.get_nodes_to_manipulate_weights_bit_widths(graph)
+        for idx, (key, val) in enumerate(get_manual_bit_dict_weights.items()):
+            assert str(key) == list(expected.keys())[idx]
+            assert val == list(expected.values())[idx]