Fix pylint errors and add tensorflow version dependencies

Author: dheerajperi

tests/test_backend.py

@@ -1916,7 +1916,8 @@ def graph_validator(g):
             return True
 
         self._run_test_case(func_fusedbn, [_OUTPUT], {_INPUT: x_val}, rtol=1e-05, graph_validator=graph_validator)
-    
+
+    @check_tf_min_version("1.15", "not supported in tf-2.0")
     @check_opset_min_version(10, "quantize_and_dequantize")
     def test_qdq_unsigned_input(self):
         x_shape = [3, 3, 2]
@@ -1925,7 +1926,8 @@ def func(x):
             x_ = quantize_and_dequantize(x, 1.0, 6.0, signed_input=False, narrow_range=False, range_given=True)
             return tf.identity(x_, name=_TFOUTPUT)
         _ = self._run_test_case(func, [_OUTPUT], {_INPUT: x_val})
-    
+
+    @check_tf_min_version("1.15", "not supported in tf-2.0")
     @check_opset_min_version(10, "quantize_and_dequantize")
     def test_qdq_signed_input(self):
         x_shape = [3, 3, 2]
@@ -1934,7 +1936,7 @@ def func(x):
             x_ = quantize_and_dequantize(x, -6.0, 6.0, signed_input=True, narrow_range=True, range_given=True)
             return tf.identity(x_, name=_TFOUTPUT)
         _ = self._run_test_case(func, [_OUTPUT], {_INPUT: x_val})
-    
+
     @skip_caffe2_backend()
     @check_opset_min_version(7, "resize_nearest_neighbor")
     def test_resize_nearest_neighbor(self):

tf2onnx/rewriter/quantization_ops_rewriter.py

@@ -5,23 +5,17 @@
 tf2onnx.rewriter - rewrite tensorflow QuantizeAndDequantizeV3 op
 """
 
-from tf2onnx.graph_matcher import OpTypePattern, GraphMatcher
-
 import numpy as np
-import struct
-
-
-from tf2onnx.handler import tf_op
+from tf2onnx.graph_matcher import OpTypePattern, GraphMatcher
 from tf2onnx import utils
-from tf2onnx import constants
 
 # pylint: disable=missing-docstring
 
 def extract_numpy_array(node):
     return np.frombuffer(node.attr["value"].t.raw_data, dtype="float32")
 
 def create_qdq_nodes(g, match_results):
-    
+
     for match in match_results:
         qdq_node = match.get_op('output')
         qdq_node_output_dtype = g.get_dtype(qdq_node.output[0])
@@ -30,51 +24,63 @@ def create_qdq_nodes(g, match_results):
         # Get the attributes of qdq node
         narrow_range = qdq_node.attr['narrow_range'].i
         signed_input = qdq_node.attr['signed_input'].i
-        
-        min_quantized, max_quantized = [-127,127]
+
+        min_quantized, max_quantized = [-127, 127]
         if not narrow_range and signed_input:
             min_quantized = -128
-        
+
         if not signed_input:
-            min_quantized, max_quantized = [0,255]
-        
+            min_quantized, max_quantized = [0, 255]
+
         # Get the min and max value of the inputs to QDQ op
         min_value = extract_numpy_array(qdq_node.inputs[1])
         max_value = extract_numpy_array(qdq_node.inputs[2])
-        
+
         # Calculate scales from the min and max values
         scale_from_min_side = min_quantized/min_value if min_quantized*min_value > 0 else max_quantized
         scale_from_max_side = max_quantized/max_value if max_quantized*max_value > 0 else max_quantized
-        
+
         if scale_from_min_side < scale_from_max_side:
             scale = scale_from_min_side
         else:
             scale = scale_from_max_side
-            
+
         assert scale > 0
-        
+
         if signed_input:
             zero_point = np.int8(0)
         else:
             zero_point = np.uint8(0)
-        
+
         # Split it into QuantizeLinear and DequantizeLinear and remove the QDQ node reference
-        y_quant_scale = g.make_const(name=utils.make_name("y_quant_scale"), np_val = 1/scale)
+        y_quant_scale = g.make_const(name=utils.make_name("y_quant_scale"), np_val=1/scale)
         y_zero_point = g.make_const(name=utils.make_name("y_zero_point"), np_val=zero_point)
-        quant_node = g.make_node(op_type = "QuantizeLinear", inputs=[qdq_node.input[0], y_quant_scale.output[0], y_zero_point.output[0]], shapes=[qdq_node_output_shape], dtypes=[qdq_node_output_dtype], name=utils.make_name("QuantLinearNode"))
+        quant_node = g.make_node(op_type="QuantizeLinear",
+                                 inputs=[qdq_node.input[0], y_quant_scale.output[0],
+                                         y_zero_point.output[0]],
+                                 shapes=[qdq_node_output_shape],
+                                 dtypes=[qdq_node_output_dtype],
+                                 name=utils.make_name("QuantLinearNode"))
+
         g.set_shape(quant_node.output[0], qdq_node_output_shape)
-        
+
         g.remove_node(qdq_node.name)
 
-        y_dequant_scale = g.make_const(name=utils.make_name("y_dequant_scale"), np_val = 1/scale)
+        y_dequant_scale = g.make_const(name=utils.make_name("y_dequant_scale"), np_val=1/scale)
         y_inv_zero_point = g.make_const(name=utils.make_name("y_inv_zero_point"), np_val=zero_point)
-        dequant_node = g.make_node(op_type = "DequantizeLinear", inputs=[quant_node.output[0], y_dequant_scale.output[0], y_inv_zero_point.output[0]], outputs = [qdq_node.output[0]], shapes=[qdq_node_output_shape], dtypes=[qdq_node_output_dtype], name=utils.make_name("DequantLinearNode"))
+        dequant_node = g.make_node(op_type="DequantizeLinear",
+                                   inputs=[quant_node.output[0], y_dequant_scale.output[0],
+                                           y_inv_zero_point.output[0]],
+                                   outputs=[qdq_node.output[0]],
+                                   shapes=[qdq_node_output_shape],
+                                   dtypes=[qdq_node_output_dtype],
+                                   name=utils.make_name("DequantLinearNode"))
         g.set_shape(dequant_node.output[0], qdq_node_output_shape)
-    
+
     return g.get_nodes()
 
 def rewrite_quantize_and_dequantize(g, ops):
-    
+
     pattern_for_qdq_v2 = \
         OpTypePattern('QuantizeAndDequantizeV2', name='output', inputs=[
             OpTypePattern("*"),
@@ -88,7 +94,7 @@ def rewrite_quantize_and_dequantize(g, ops):
             OpTypePattern(None),
             OpTypePattern(None),
         ])
-    
+
     # Match all the patterns for QDQ ops
     patterns = [pattern_for_qdq_v3, pattern_for_qdq_v2]
     match_results = []
@@ -97,4 +103,4 @@ def rewrite_quantize_and_dequantize(g, ops):
         results = list(matcher.match_ops(ops))
         match_results.extend(results)
 
-    return create_qdq_nodes(g, match_results)
+    return create_qdq_nodes(g, match_results)