Fix tensorflow unit test redefinition issue (#1164)

Signed-off-by: lvliang-intel <liang1.lv@intel.com>

Author: lvliang-intel

test/adaptor/tensorflow_adaptor/test_tensorflow_graph_conv_fusion.py

@@ -279,7 +279,7 @@ def test_conv_squeeze_biasadd_relu_fusion(self):
             self.assertEqual(correct_conv_fusion, True)
 
     @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion(self):
+    def test_conv_biasadd_addv2_relu_fallback_fusion_1(self):
         x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
         top_relu = tf.nn.leaky_relu(x)
         paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
@@ -325,7 +325,7 @@ def test_conv_biasadd_addv2_relu_fallback_fusion(self):
             self.assertEqual(found_conv_fusion, True)
 
     @disable_random()
-    def test_conv_biasadd_addv2_relu_fallback_fusion(self):
+    def test_conv_biasadd_addv2_relu_fallback_fusion_2(self):
         x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
         top_relu = tf.nn.relu(x)
         paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])

test/tfnewapi/test_tensorflow_graph_conv_fusion.py

@@ -755,121 +755,5 @@ def test_single_deconv3d_fusion(self):
 
             self.assertEqual(found_deconv3d_fusion, True)
 
-    @disable_random()
-    def test_conv_fusion_with_max_pooling(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-
-        relu = tf.nn.relu(x)
-        pooling = tf.nn.max_pool(relu, ksize=1, strides=[1, 2, 2, 1], padding="SAME")
-        conv_weights = tf.compat.v1.get_variable("weight2", [3, 3, 16, 16],
-                                                   initializer=tf.compat.v1.random_normal_initializer())
-        conv = tf.nn.conv2d(pooling, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
-        biasadd = tf.compat.v1.layers.batch_normalization(conv, name='op_to_store')
-        out_name = biasadd.name.split(':')[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess,
-                input_graph_def=sess.graph_def,
-                output_node_names=[out_name])
-
-            from neural_compressor.experimental import Quantization, common
-            quantizer = Quantization('fake_yaml.yaml')
-            dataset = quantizer.dataset('dummy', shape=(100, 56, 56, 16), label=True)
-            quantizer.eval_dataloader = common.DataLoader(dataset)
-            quantizer.calib_dataloader = common.DataLoader(dataset)
-            quantizer.model = output_graph_def
-            output_graph = quantizer.fit()
-
-            quantized_pool_data_type = None
-            quantized_conv_data_type = None
-            for i in output_graph.graph_def.node:
-                if i.op.find("QuantizedMaxPool") != -1:
-                    quantized_pool_data_type = i.attr['T'].type
-                if i.op.find("QuantizedConv2D") != -1:
-                    quantized_conv_data_type = i.attr['Tinput'].type
-
-            self.assertNotEqual(quantized_pool_data_type, None)
-            self.assertEqual(quantized_pool_data_type, quantized_conv_data_type)
-
-    @disable_random()
-    def test_conv3d_addv2_relu_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
-        top_relu = tf.nn.relu(x)
-        conv3d_1_weights = tf.compat.v1.get_variable("weight_conv3d_1", [3, 3, 3, 16, 32],
-                                                 initializer=tf.compat.v1.random_normal_initializer())
-        conv3d_1 = tf.nn.conv3d(top_relu, conv3d_1_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=conv3d_1, y=tf.constant(np.random.randn(32), dtype=tf.float32), name='addv2')
-        relu = tf.nn.relu(add)
-        conv3d_2_weights = tf.compat.v1.get_variable("weight_conv3d_2", [3, 3, 3, 32, 1],
-                                                 initializer=tf.compat.v1.random_normal_initializer())
-        conv3d_2 = tf.nn.conv3d(relu, conv3d_2_weights, strides=[1, 2, 2, 2, 1], padding="SAME")
-
-        out_name = conv3d_2.name.split(':')[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess,
-                input_graph_def=sess.graph_def,
-                output_node_names=[out_name])
-            from neural_compressor.experimental import Quantization, common
-            quantizer = Quantization('fake_yaml.yaml')
-            dataset = quantizer.dataset('dummy', shape=(100, 128, 64, 64, 16), label=True)
-            quantizer.eval_dataloader = common.DataLoader(dataset)
-            quantizer.calib_dataloader = common.DataLoader(dataset)
-            quantizer.model = output_graph_def
-            output_graph = quantizer.fit()
-
-            found_conv_sumadd_fusion = False
-            found_conv_biasadd_fusion = False
-            for i in output_graph.graph_def.node:
-                if i.op == '_FusedQuantizedConv3D':
-                    if b'Sum' in i.attr['fused_ops'].list.s:
-                        found_conv_sumadd_fusion = True
-                    if i.attr['fused_ops'].list.s == [b'BiasAdd', b'Relu', b'Requantize']:
-                        found_conv_biasadd_fusion = True
-            self.assertEqual(found_conv_sumadd_fusion, False)
-            self.assertEqual(found_conv_biasadd_fusion, True)
-
-    # conv2d + dummybiasadd + addv2 fusion
-    @disable_random()
-    def test_conv_add_addn_non_const_fusion(self):
-        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
-        paddings = tf.constant([[0, 0], [1, 1], [1, 1], [0, 0]])
-        x_pad = tf.pad(x, paddings, "CONSTANT")
-        top_relu = tf.nn.relu(x_pad)
-        conv2d_1_weights = tf.compat.v1.get_variable("weight1", [3, 3, 16, 16],
-                                                 initializer=tf.compat.v1.random_normal_initializer())
-        conv2d_1 = tf.nn.conv2d(top_relu, conv2d_1_weights, strides=[1, 2, 2, 1], padding="SAME")
-        conv2d_2_weights = tf.compat.v1.get_variable("weight2", [3, 3, 16, 16],
-                                                 initializer=tf.compat.v1.random_normal_initializer())
-        conv2d_2 = tf.nn.conv2d(top_relu, conv2d_2_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add_1 = tf.raw_ops.AddV2(x=conv2d_1, y=conv2d_2, name='addv2_1')
-        conv2d_3_weights = tf.compat.v1.get_variable("weight3", [3, 3, 16, 16],
-                                                 initializer=tf.compat.v1.random_normal_initializer())
-        conv2d_3 = tf.nn.conv2d(top_relu, conv2d_3_weights, strides=[1, 2, 2, 1], padding="SAME")
-        add = tf.raw_ops.AddV2(x=add_1, y=conv2d_3, name='addv2_2')
-        out_name = add.name.split(':')[0]
-        with tf.compat.v1.Session() as sess:
-            sess.run(tf.compat.v1.global_variables_initializer())
-            output_graph_def = graph_util.convert_variables_to_constants(
-                sess=sess,
-                input_graph_def=sess.graph_def,
-                output_node_names=[out_name])
-            from neural_compressor.experimental import Quantization, common
-            quantizer = Quantization('fake_yaml.yaml')
-            dataset = quantizer.dataset('dummy', shape=(100, 56, 56, 16), label=True)
-            quantizer.eval_dataloader = common.DataLoader(dataset)
-            quantizer.calib_dataloader = common.DataLoader(dataset)
-            quantizer.model = output_graph_def
-            output_graph = quantizer.fit()
-
-            found_conv_fusion = False
-            for i in output_graph.graph_def.node:
-                if i.op == '_FusedQuantizedConv2D' and \
-                   i.attr['fused_ops'].list.s == [b'BiasAdd', b'Sum', b'Requantize']:
-                    found_conv_fusion = True
-            self.assertEqual(found_conv_fusion, True)
-
 if __name__ == '__main__':
     unittest.main()

test/tfnewapi/test_tensorflow_graph_conv_requantize_fusion.py

@@ -415,7 +415,7 @@ def test_conv3d_add_const_addn_relu_fusion(self):
                     if str(i.attr['fused_ops'].list.s) == str([b'BiasAdd', b'Sum', b'Relu']):
                         found_conv_biasadd_fusion = True
             self.assertEqual(found_conv_sumadd_fusion, True)
-            self.assertEqual(found_conv_biasadd_fusion, True)
+            self.assertEqual(found_conv_biasadd_fusion, False)
 
     @disable_random()
     def test_conv3d_add_addn_fusion(self):
@@ -562,8 +562,8 @@ def test_conv3d_add_fusion(self):
             self.assertEqual(found_conv_fusion, True)
 
     @disable_random()
-    def test_conv3d_add_const_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_fusion")
+    def test_conv3d_add_const_addn_relu_requantize_fusion(self):
+        logging.getLogger().info("test_conv3d_add_const_addn_relu_requantize_fusion")
         x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
         paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
         x_pad = tf.pad(x, paddings, "CONSTANT")

test/tfnewapi/test_tensorflow_graph_qdq_conv3d_fusion.py

@@ -521,8 +521,8 @@ def test_conv3d_add_fusion(self):
             self.assertEqual(found_conv_fusion, True)
 
     @disable_random()
-    def test_conv3d_add_const_addn_relu_fusion(self):
-        logging.getLogger().info("test_conv3d_add_const_addn_relu_fusion")
+    def test_conv3d_add_const_addn_relu_requantize_fusion(self):
+        logging.getLogger().info("test_conv3d_add_const_addn_relu_requantize_fusion")
         x = tf.compat.v1.placeholder(tf.float32, [1, 128, 64, 64, 16], name="input")
         paddings = tf.constant([[0, 0], [1, 1], [1, 1], [1, 1], [0, 0]])
         x_pad = tf.pad(x, paddings, "CONSTANT")