Support Conv2D biasadd sigmoid fusion (#1133)

Author: lvliang-intel

neural_compressor/adaptor/inteltensorflow.yaml

@@ -212,6 +212,8 @@
         'Dequantize + Conv2D + Relu6 + QuantizeV2',
         'Dequantize + Conv2D + BiasAdd + LeakyRelu + QuantizeV2',
         'Dequantize + Conv2D + LeakyRelu + QuantizeV2',
+        'Dequantize + Conv2D + BiasAdd + Sigmoid + QuantizeV2',
+        'Dequantize + Conv2D + Sigmoid + QuantizeV2',
         'Dequantize + Conv2D + BiasAdd + LeakyRelu + AddV2 + QuantizeV2',
         'Dequantize + Conv2D + LeakyRelu + AddV2 + QuantizeV2',
         'Dequantize + Conv2D + Add + QuantizeV2',

neural_compressor/adaptor/tf_utils/graph_rewriter/int8/fuse_conv_requantize.py

@@ -285,6 +285,16 @@ def do_transformation(self):
                             dtype_map_dict[requantize_node.attr['out_type'].type])
                         Helper.set_attr_dtype(new_node, "Tsummand", \
                             dtype_map_dict[requantize_node.attr['out_type'].type])
+                    elif str(quantized_node.attr['fused_ops'].list.s) == str([b"BiasAdd", b"Sigmoid"]):
+                        self.fused_ops= [b"BiasAdd", b"Sigmoid", b"Requantize"]
+                        Helper.set_attr_type_list(new_node, 'Thost_outputs', [
+                                              requantize_node.attr['out_type'].type,
+                                              dtypes.float32.as_datatype_enum,
+                                              dtypes.float32.as_datatype_enum ])
+                        Helper.set_attr_dtype(new_node, "out_type", \
+                            dtype_map_dict[requantize_node.attr['out_type'].type])
+                        Helper.set_attr_dtype(new_node, "Tsummand", \
+                            dtype_map_dict[requantize_node.attr['out_type'].type])
                     elif str(quantized_node.attr['fused_ops'].list.s) == str([b"BiasAdd"]):
                         self.fused_ops= [b"BiasAdd", b"Requantize"]
                         Helper.set_attr_type_list(new_node, 'Thost_outputs', [

neural_compressor/adaptor/tf_utils/quantize_graph/qdq/fuse_qdq_conv.py

@@ -52,6 +52,8 @@ def __init__(self, **kwargs):
                 'DequantizeConv2DEluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
                 'DequantizeConv2DBiasAddLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
                 'DequantizeConv2DLeakyReluQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
+                'DequantizeConv2DBiasAddSigmoidQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
+                'DequantizeConv2DSigmoidQuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
                 'DequantizeConv2DBiasAddLeakyReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
                 'DequantizeConv2DLeakyReluAddV2QuantizeV2': self.apply_newly_conv_biasadd_addn_relu_fusion,
                 'DequantizeConv2DAddRelu6QuantizeV2': self.apply_newly_conv_biasadd_relu_fusion,
@@ -813,6 +815,8 @@ def apply_newly_conv_biasadd_relu_fusion(self, match_node_name):
         # Dequantize + Conv2D + Elu + QuantizeV2
         # Dequantize + Conv2D + BiasAdd + LeakyRelu + QuantizeV2
         # Dequantize + Conv2D + LeakyRelu + QuantizeV2
+        # Dequantize + Conv2D + BiasAdd + Sigmoid + QuantizeV2
+        # Dequantize + Conv2D + Sigmoid + QuantizeV2
         # Dequantize + Conv2D + Add + Relu6 + QuantizeV2
         # Dequantize + Conv2D + Add + Relu + QuantizeV2
         # Dequantize + DepthwiseConv2dNative + Add + Relu6 + QuantizeV2
@@ -826,7 +830,7 @@ def apply_newly_conv_biasadd_relu_fusion(self, match_node_name):
         matched_node = self.node_name_mapping[match_node_name[1]]
 
         second_node = self.node_name_mapping[match_node_name[2]].node
-        if second_node.op in ('Relu', 'Relu6', 'LeakyRelu', 'Elu'):
+        if second_node.op in ('Relu', 'Relu6', 'LeakyRelu', 'Elu', 'Sigmoid'):
              new_match_node_name = self._insert_dummy_biasadd(match_node_name, matched_node)
              return self.apply_newly_conv_biasadd_relu_fusion(new_match_node_name)
 
@@ -882,6 +886,7 @@ def apply_newly_conv_biasadd_relu_fusion(self, match_node_name):
                     [bias_node_name] + all_input_names[2:] + control_inputs
                 is_leakyrelu = self.node_name_mapping[relu_node_name].node.op == "LeakyRelu"
                 is_elu = self.node_name_mapping[relu_node_name].node.op == "Elu"
+                is_sigmoid = self.node_name_mapping[relu_node_name].node.op == "Sigmoid"
 
                 node_op = '_QuantizedDepthwiseConv2D'
                 if node.op == 'Conv2D':
@@ -911,7 +916,9 @@ def apply_newly_conv_biasadd_relu_fusion(self, match_node_name):
                 if is_leakyrelu:
                     fused_ops = [b'BiasAdd', b'LeakyRelu']
                 if is_elu:
-                    fused_ops = [b'BiasAdd', b'Elu'] 
+                    fused_ops = [b'BiasAdd', b'Elu']
+                if is_sigmoid:
+                    fused_ops = [b'BiasAdd', b'Sigmoid']
                 helper.set_attr_string_list(quantized_conv_node, 'fused_ops', fused_ops)
                 helper.set_attr_type_list(quantized_conv_node, 'Thost_inputs', [
                     input_data_type.as_datatype_enum,

test/tfnewapi/test_tensorflow_graph_qdq_conv_fusion.py

@@ -853,6 +853,38 @@ def test_conv_biasadd_elu_fusion(self):
                     break
             self.assertEqual(found_conv_fusion, True)
 
+    # fuse conv + biasadd + sigmoid
+    @disable_random()
+    def test_conv_biasadd_sigmoid_fusion(self):
+        x = tf.compat.v1.placeholder(tf.float32, [1, 56, 56, 16], name="input")
+        conv_weights = tf.compat.v1.get_variable("weight", [3, 3, 16, 16],
+                                                 initializer=tf.compat.v1.random_normal_initializer())
+        conv = tf.nn.conv2d(x, conv_weights, strides=[1, 2, 2, 1], padding="VALID")
+        normed = tf.compat.v1.layers.batch_normalization(conv)
+
+        sigmoid = tf.math.sigmoid(normed, name='op_to_store')
+
+        out_name = sigmoid.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 = True
+
+            for i in output_graph.graph_def.node:
+                if i.op == 'Sigmoid':
+                    found_conv_fusion = False
+                    break
+            self.assertEqual(found_conv_fusion, True)
 
 if __name__ == '__main__':
     unittest.main()