onnx2tf 1.29.15__py3-none-any.whl → 1.29.16__py3-none-any.whl

onnx2tf/ops/QLinearMatMul.py

@@ -11,6 +11,47 @@ from onnx2tf.utils.common_functions import (
     make_tf_node_info,
 )
 
+def _get_qmin_qmax(dtype: tf.dtypes.DType):
+    if dtype == tf.uint8:
+        return 0.0, 255.0
+    if dtype == tf.int8:
+        return -128.0, 127.0
+    if dtype == tf.uint16:
+        return 0.0, 65535.0
+    if dtype == tf.int16:
+        return -32768.0, 32767.0
+    return None, None
+
+
+def _reshape_for_axis(
+    *,
+    value,
+    input_tensor,
+    axis: int,
+):
+    value_rank = len(value.shape)
+    input_rank = len(input_tensor.shape)
+    if value_rank == 1 and input_rank is not None:
+        shape = [1] * input_rank
+        shape[axis] = -1
+        return tf.reshape(value, shape)
+    return value
+
+
+def _reshape_for_output(
+    *,
+    value,
+    output_tensor,
+):
+    value_rank = len(value.shape)
+    output_rank = len(output_tensor.shape)
+    if value_rank == 1 and output_rank is not None and output_rank >= 2:
+        if output_tensor.shape[-2] == value.shape[0]:
+            shape = [1] * output_rank
+            shape[-2] = -1
+            return tf.reshape(value, shape)
+    return value
+
 
 @print_node_info
 @inverted_operation_enable_disable
@@ -76,12 +117,18 @@ def make_node(
 
     a = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
         if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    a_is_dequantized = False
+    if isinstance(graph_node_input_1, gs.Variable):
+        a_is_dequantized = tf_layers_dict.get(graph_node_input_1.name, {}).get('is_dequantized', False)
     a_scale = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
         if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
     a_zero_point = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
         if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
     b = tf_layers_dict[graph_node_input_4.name]['tf_node'] \
         if isinstance(graph_node_input_4, gs.Variable) else graph_node_input_4
+    b_is_dequantized = False
+    if isinstance(graph_node_input_4, gs.Variable):
+        b_is_dequantized = tf_layers_dict.get(graph_node_input_4.name, {}).get('is_dequantized', False)
     b_scale = tf_layers_dict[graph_node_input_5.name]['tf_node'] \
         if isinstance(graph_node_input_5, gs.Variable) else graph_node_input_5
     b_zero_point = tf_layers_dict[graph_node_input_6.name]['tf_node'] \
@@ -90,50 +137,60 @@ def make_node(
         if isinstance(graph_node_input_7, gs.Variable) else graph_node_input_7
     y_zero_point = tf_layers_dict[graph_node_input_8.name]['tf_node'] \
         if isinstance(graph_node_input_8, gs.Variable) else graph_node_input_8
-    y_dtype = y_zero_point.dtype if y_zero_point.dtype not in [tf.int8, tf.uint8] else tf.float32
+    y_dtype = y_zero_point.dtype
 
     # Preserving Graph Structure (Dict)
     tf_layers_dict[graph_node_output.name] = {
         'optype': graph_node.op,
         'shape': shape,
         'dtype': dtype,
+        'is_dequantized': True,
     }
 
     # Generation of TF OP
 
-    # reshape 1-D a_scale, a_zero_point, y_scale and
-    # y_zero_point so it can broadcast in arithmetic
-    # operations later
-    a_scale_shape = a_scale.shape
-    if a_scale_shape and a_scale_shape[0] > 1:
-        a_scale = tf.reshape(a_scale, [a_scale_shape[0], 1])
-        a_zero_point = tf.reshape(a_zero_point, [a_scale_shape[0], 1])
-    y_scale_shape = y_scale.shape
-    if y_scale_shape and y_scale_shape[0] > 1:
-        y_scale = tf.reshape(y_scale, [y_scale_shape[0], 1])
-        y_zero_point = tf.reshape(y_zero_point, [y_scale_shape[0], 1])
+    # reshape a_scale and a_zero_point to broadcast on row axis (second last)
+    a_scale = _reshape_for_axis(value=a_scale, input_tensor=a, axis=-2)
+    a_zero_point = _reshape_for_axis(value=a_zero_point, input_tensor=a, axis=-2)
+    # reshape b_scale and b_zero_point to broadcast on column axis (last)
+    b_scale = _reshape_for_axis(value=b_scale, input_tensor=b, axis=-1)
+    b_zero_point = _reshape_for_axis(value=b_zero_point, input_tensor=b, axis=-1)
 
     # cast all inputs to float32
     a = tf.cast(a, tf.float32)
+    a_scale = tf.cast(a_scale, tf.float32)
     a_zero_point = tf.cast(a_zero_point, tf.float32)
     b = tf.cast(b, tf.float32)
+    b_scale = tf.cast(b_scale, tf.float32)
     b_zero_point = tf.cast(b_zero_point, tf.float32)
+    y_scale = tf.cast(y_scale, tf.float32)
     y_zero_point = tf.cast(y_zero_point, tf.float32)
 
     # dequantize a and b
-    dequantized_a = tf.subtract(a, a_zero_point)
-    dequantized_a = tf.multiply(dequantized_a, a_scale)
-    dequantized_b = tf.subtract(b, b_zero_point)
-    dequantized_b = tf.multiply(dequantized_b, b_scale)
+    if a_is_dequantized:
+        dequantized_a = tf.cast(a, tf.float32)
+    else:
+        dequantized_a = tf.multiply(tf.subtract(a, a_zero_point), a_scale)
+
+    if b_is_dequantized:
+        dequantized_b = tf.cast(b, tf.float32)
+    else:
+        dequantized_b = tf.multiply(tf.subtract(b, b_zero_point), b_scale)
 
     # matmul
     x = tf.matmul(dequantized_a, dequantized_b)
 
-    # quantize x
-    y = tf.divide(x, y_scale)
-    y = tf.round(y)
+    # broadcast output scale/zero_point if needed
+    y_scale = _reshape_for_output(value=y_scale, output_tensor=x)
+    y_zero_point = _reshape_for_output(value=y_zero_point, output_tensor=x)
+
+    # quantize then dequantize to float32
+    y = tf.round(tf.divide(x, y_scale))
     y = tf.add(y, y_zero_point)
-    y = tf.saturate_cast(y, y_dtype)
+    qmin, qmax = _get_qmin_qmax(y_dtype)
+    if qmin is not None and qmax is not None:
+        y = tf.clip_by_value(y, qmin, qmax)
+    y = tf.multiply(tf.subtract(y, y_zero_point), y_scale)
 
     tf_layers_dict[graph_node_output.name]['tf_node'] = y
 

onnx2tf/ops/QuantizeLinear.py

@@ -11,6 +11,49 @@ from onnx2tf.utils.common_functions import (
     make_tf_node_info,
     convert_axis,
 )
+from onnx2tf.utils.enums import ONNX_DTYPES_TO_TF_DTYPES
+
+
+def _get_qmin_qmax(dtype: tf.dtypes.DType):
+    if dtype == tf.uint8:
+        return 0.0, 255.0
+    if dtype == tf.int8:
+        return -128.0, 127.0
+    if dtype == tf.uint16:
+        return 0.0, 65535.0
+    if dtype == tf.int16:
+        return -32768.0, 32767.0
+    return None, None
+
+
+def _expand_scale_or_zero_point(
+    *,
+    value,
+    input_tensor,
+    axis: int,
+    block_size: int,
+):
+    value_rank = len(value.shape)
+    input_rank = len(input_tensor.shape)
+
+    if value_rank == 0:
+        return value
+
+    if block_size > 0 and value_rank == input_rank:
+        if value.shape[axis] is None \
+            or input_tensor.shape[axis] is None \
+            or value.shape[axis] != input_tensor.shape[axis]:
+            expanded = tf.repeat(value, repeats=block_size, axis=axis)
+            expanded = tf.slice(expanded, [0] * input_rank, tf.shape(input_tensor))
+            return expanded
+        return value
+
+    if value_rank == 1 and input_rank is not None:
+        shape = [1] * input_rank
+        shape[axis] = -1
+        return tf.reshape(value, shape)
+
+    return value
 
 
 @print_node_info
@@ -60,12 +103,12 @@ def make_node(
 
     input_tensor = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
         if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
-    input_tensor_shape = input_tensor.shape
-    input_tensor_rank = len(input_tensor_shape)
+    input_nhwc = False
+    if isinstance(graph_node_input_1, gs.Variable):
+        input_nhwc = tf_layers_dict.get(graph_node_input_1.name, {}).get('nhwc', False)
+    input_tensor_rank = len(input_tensor.shape)
     y_scale = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
         if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
-    y_scale_shape = y_scale.shape
-    y_scale_rank = len(y_scale_shape)
     y_zero_point = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
         if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
 
@@ -81,6 +124,8 @@ def make_node(
         'optype': graph_node.op,
         'shape': shape,
         'dtype': dtype,
+        'is_dequantized': True,
+        'nhwc': input_nhwc,
     }
 
     # Generation of TF OP
@@ -88,51 +133,79 @@ def make_node(
         x=input_tensor,
         dtype=tf.float32,
     )
-    x_shape = input_tensor_shape
-    x_rank = input_tensor_rank
-    y_scale_shape = y_scale_shape
-
-    # Reshape process is needed for per-axis quantization
-    # when scale is a 1-D tensor
-    if y_scale_rank == 1:
-        shape_broadcast = list(
-            [1 for _ in range(axis)] \
-            + [x_shape[axis]] \
-            + [1 for _ in range(axis + 1, x_rank)]
-        )
-        y_scale = tf.reshape(
-            tensor=y_scale,
-            shape=shape_broadcast,
-        )
-    y = tf.divide(
-        x=input_tensor,
-        y=y_scale,
+
+    # If QuantizeLinear is immediately followed by Cast -> DequantizeLinear
+    # or DequantizeLinear only, bypass fake-quant to avoid generating
+    # Mul/Round/Min/Relu/Mul chains in TF/TFLite.
+    bypass_fake_quant = False
+    if graph_node.outputs and len(graph_node.outputs) > 0:
+        consumers = graph_node.outputs[0].outputs
+        if consumers:
+            bypass_fake_quant = True
+            for consumer in consumers:
+                if consumer.op == 'DequantizeLinear':
+                    continue
+                if consumer.op == 'Cast':
+                    cast_outs = consumer.outputs[0].outputs if consumer.outputs else []
+                    if not cast_outs or any(grand.op != 'DequantizeLinear' for grand in cast_outs):
+                        bypass_fake_quant = False
+                        break
+                else:
+                    bypass_fake_quant = False
+                    break
+
+    if bypass_fake_quant:
+        tf_layers_dict[graph_node_output.name]['tf_node'] = input_tensor
+        tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+            make_tf_node_info(
+                node_info={
+                    'tf_op_type': 'QuantizeLinear',
+                    'tf_inputs': {
+                        'x': input_tensor,
+                    },
+                    'tf_outputs': {
+                        'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                    },
+                }
+            )
+        return
+    y_scale = tf.cast(y_scale, tf.float32)
+
+    block_size = int(graph_node.attrs.get('block_size', 0))
+    y_scale = _expand_scale_or_zero_point(
+        value=y_scale,
+        input_tensor=input_tensor,
+        axis=axis,
+        block_size=block_size,
     )
-    y = tf.round(y)
 
-    if y_zero_point is not None:
-        y_dtype = y_zero_point.dtype if y_zero_point.dtype not in [tf.int8, tf.uint8] else tf.float32
-        y_zero_point = tf.cast(
-            x=y_zero_point,
-            dtype=tf.float32,
-        )
-        y_zero_point = tf.reshape(
-            tensor=y_zero_point,
-            shape=shape_broadcast,
-        ) if y_scale_rank == 1 else y_zero_point
-        y = tf.add(
-            x=y,
-            y=y_zero_point,
+    output_dtype_attr = int(graph_node.attrs.get('output_dtype', 0))
+    if y_zero_point is None:
+        output_dtype = ONNX_DTYPES_TO_TF_DTYPES.get(output_dtype_attr, tf.uint8) \
+            if output_dtype_attr != 0 else tf.uint8
+        y_zero_point = tf.zeros_like(y_scale)
+    else:
+        output_dtype = y_zero_point.dtype
+        y_zero_point = tf.cast(y_zero_point, tf.float32)
+        y_zero_point = _expand_scale_or_zero_point(
+            value=y_zero_point,
+            input_tensor=input_tensor,
+            axis=axis,
+            block_size=block_size,
         )
-    else:  # y_zero_point default dtype = uint8
-        y_dtype = tf.uint8
 
-    # Generation of TF OP
+    y = tf.round(tf.divide(input_tensor, y_scale))
+    y = tf.add(y, y_zero_point)
+
+    qmin, qmax = _get_qmin_qmax(output_dtype)
+    if qmin is not None and qmax is not None:
+        y = tf.clip_by_value(y, qmin, qmax)
+
+    # dequantize to float32 output
     tf_layers_dict[graph_node_output.name]['tf_node'] = \
-        tf.saturate_cast(
-            value=y,
-            dtype=y_dtype,
-            name=graph_node.name,
+        tf.multiply(
+            x=tf.subtract(y, y_zero_point),
+            y=y_scale,
         )
 
     # Generation of Debug Info

onnx2tf/ops/Split.py

@@ -124,6 +124,32 @@ def make_node(
         **kwargs,
     )
 
+    def _infer_split_axis_runtime(input_tensor, sum_split, fallback_axis):
+        if sum_split is None:
+            return tf.cast(fallback_axis, tf.int32)
+        shape = tf.shape(input_tensor)
+        eq = tf.equal(shape, tf.cast(sum_split, tf.int32))
+        mask = tf.cast(eq, tf.int32)
+        count = tf.reduce_sum(mask)
+        axis_from = tf.argmax(mask, axis=0, output_type=tf.int32)
+        fallback_axis_tensor = tf.cast(fallback_axis, tf.int32)
+        is_single = tf.cast(tf.equal(count, 1), tf.int32)
+        return axis_from * is_single + fallback_axis_tensor * (1 - is_single)
+
+    axis_for_split = axis
+    sum_split = None
+    split_list = None
+    if isinstance(split, np.ndarray):
+        split_list = list(split)
+    elif isinstance(split, (list, tuple)):
+        split_list = list(split)
+    if split_list is not None and len(split_list) > 1:
+        if len(split_list) == sum([1 for dim in split_list if isinstance(dim, (np.int64, int))]):
+            sum_split = int(np.sum(split_list))
+            axis_dim = input_tensor_shape[axis] if axis < len(input_tensor_shape) else None
+            if axis_dim is None or (isinstance(axis_dim, int) and axis_dim != sum_split):
+                axis_for_split = _infer_split_axis_runtime(input_tensor, sum_split, axis)
+
     # Generation of TF OP
     splited_tensors = None
     if (
@@ -225,18 +251,17 @@ def make_node(
                 num=None,
                 name=graph_node.name,
             )
-    elif isinstance(split, np.ndarray) \
+    elif isinstance(split, (list, tuple, np.ndarray)) \
         and len(list(split)) > 1 \
-        and np.prod(split) != 1 \
-        and isinstance(input_tensor_shape[axis], int) \
-        and len(split) == sum([1 for dim in split if isinstance(dim, np.int64) or isinstance(dim, int)]) \
-        and len(split) != sum([1 for dim in split if split[0] == dim]) \
-        and np.sum(split) == input_tensor_shape[axis]:
+        and (np.prod(split) != 1 if isinstance(split, np.ndarray) else True) \
+        and len(list(split)) == sum([1 for dim in list(split) if isinstance(dim, (np.int64, int))]) \
+        and len(list(split)) != sum([1 for dim in list(split) if list(split)[0] == dim]) \
+        and (not isinstance(input_tensor_shape[axis], int) or np.sum(list(split)) == input_tensor_shape[axis]):
         # Suppression of FlexSplitV generation
         # SplitV -> Strided_Slice
         splited_tensors = []
         begin_stock = []
-        for split_idx, split_dim in enumerate(split):
+        for split_idx, split_dim in enumerate(list(split)):
             begin_ = []
             end_ = []
             begin_mask_ = 0
@@ -269,7 +294,7 @@ def make_node(
             tf.split(
                 value=input_tensor,
                 num_or_size_splits=split,
-                axis=axis,
+                axis=axis_for_split,
                 num=num_outputs,
                 name=graph_node.name,
             )

{onnx2tf-1.29.15.dist-info → onnx2tf-1.29.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.15
+Version: 1.29.16
 Summary: Self-Created Tools to convert ONNX files (NCHW) to TensorFlow/TFLite/Keras format (NHWC). The purpose of this tool is to solve the massive Transpose extrapolation problem in onnx-tensorflow (onnx-tf).
 Keywords: onnx,tensorflow,tflite,keras,deep-learning,machine-learning
 Author: Katsuya Hyodo
@@ -364,7 +364,7 @@ Video speed is adjusted approximately 50 times slower than actual speed.
   docker run --rm -it \
   -v `pwd`:/workdir \
   -w /workdir \
-  ghcr.io/pinto0309/onnx2tf:1.29.15
+  ghcr.io/pinto0309/onnx2tf:1.29.16
 
   or
 
@@ -372,7 +372,7 @@ Video speed is adjusted approximately 50 times slower than actual speed.
   docker run --rm -it \
   -v `pwd`:/workdir \
   -w /workdir \
-  docker.io/pinto0309/onnx2tf:1.29.15
+  docker.io/pinto0309/onnx2tf:1.29.16
 
   or
 

{onnx2tf-1.29.15.dist-info → onnx2tf-1.29.16.dist-info}/RECORD

@@ -1,6 +1,6 @@
-onnx2tf/__init__.py,sha256=OazM0la-RBJsi-HQv3oIVGCRDNETzahP6Tlad2NZV5k,67
+onnx2tf/__init__.py,sha256=eUTDHQ-QolqzjE7OAU5EnMP1epQf_1sc4vD2dRt8Bj4,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
-onnx2tf/onnx2tf.py,sha256=O3B_ME8omswggw4xtjxxnC8_uaPHH3Ly8dwSv7w75no,157060
+onnx2tf/onnx2tf.py,sha256=y8FewjpNYAFnUs0cjq6JzdYkiXQSm1o_sZ3PXLJzK64,161921
 onnx2tf/ops/Abs.py,sha256=V7btmCG_ZvK_qJovUsguq0ZMJ349mhNQ4FHSgzP_Yuo,4029
 onnx2tf/ops/Acos.py,sha256=Fo8YkFKuWq8Fi2xUrBdKcAH1yJ8r5pjSD0wgLttTNdk,4003
 onnx2tf/ops/Acosh.py,sha256=ATQj2cT5JS_mTfXi0kXqJ1yzSZu5J0zHA5VjV3j7uKY,3588
@@ -29,7 +29,7 @@ onnx2tf/ops/Celu.py,sha256=9g7WNKo4G_jMtUXcoOfpNdLYqEsuyXLPkkyQZxDuL4U,3853
 onnx2tf/ops/Clip.py,sha256=K3Pgt9BXl5_rzg6s-kPFmwElL5COsvolRY1BUTo7UWw,8753
 onnx2tf/ops/Col2Im.py,sha256=MDqck00gURrbsroJAgUDkxmdsGyE9v2ez4NKdvdq5IY,7514
 onnx2tf/ops/Compress.py,sha256=NvDGr9gCNl-8YG41xDBfe3UvhRP03K-ktdtY_MoytBc,3667
-onnx2tf/ops/Concat.py,sha256=CKfJbiAwP7h9sFFVyueHJCbwMkUo3NXqkTuRc8v7Tw8,31215
+onnx2tf/ops/Concat.py,sha256=M0KSwymMIYR-YOIlylFe708TDdOvWNMxDE6V4UKE1MI,32570
 onnx2tf/ops/ConcatFromSequence.py,sha256=z8pNmGQRGq9cxWORW330NZS_0zsmhFudLswMyPn8AXU,3086
 onnx2tf/ops/Constant.py,sha256=BNZLzNI4rK9kXgVWwD-2RFsDsH7mMy7AY2JSgTNXIWk,10696
 onnx2tf/ops/ConstantOfShape.py,sha256=6eYm-niow-6fHVEyNyi81BdrVe3IbcdazCp2nySWExA,2331
@@ -41,11 +41,11 @@ onnx2tf/ops/Cosh.py,sha256=-L3QkQtiVBJIv1sSxbXtetVIwgI_2T4WC1O4t2aJ8Gc,3585
 onnx2tf/ops/CumProd.py,sha256=k4hTEQrkwS7vk7pEy2Btvy2y0o70NlWj1MgsNomfOPg,3957
 onnx2tf/ops/CumSum.py,sha256=SYKmD5r9Cm9gsCkJPNFoHigvvBO1PmRYRrVmn1HE78o,3954
 onnx2tf/ops/DepthToSpace.py,sha256=BiyBZ88dmXQAkZ5Jc-Ddo-5Kn8dRYCnoik_XnOFzqXc,14449
-onnx2tf/ops/DequantizeLinear.py,sha256=cNbGw4ITg_BsrXYkSb7fD05XEkQgz7v__-StQtvIvB4,5220
+onnx2tf/ops/DequantizeLinear.py,sha256=1v43E1hUqO3g7N-PL1fy_cGj4oUgbphh7vXIGhUAyGc,6463
 onnx2tf/ops/Det.py,sha256=kxuHkpv_KNHkof0uBv2RLtr3G1uA76MFHyCiCYCBXkw,3590
 onnx2tf/ops/Div.py,sha256=NyAsvCxI41hyBX_kiCEILHY6QQkas_o4wRY8zkDUiwk,16248
 onnx2tf/ops/Dropout.py,sha256=KZKVqlnbq875awsNvJaQRvkO3XgqxeAmjbikXymRCtA,5860
-onnx2tf/ops/DynamicQuantizeLinear.py,sha256=UGmN2nXBBQHXcNlorEQfnKDnnoOadt4TNzXox-Xki2U,4759
+onnx2tf/ops/DynamicQuantizeLinear.py,sha256=oLsj1cfzawPXo5TokfJOx-rR-Ls7OXDLLk_TLYtFgiA,4962
 onnx2tf/ops/Einsum.py,sha256=YBw0JmSglOVVje80RqmqIjgsc7V5SnYS6s1Ysa2NUPA,12369
 onnx2tf/ops/Elu.py,sha256=VDd5cKc1h-8nd0bVwWR_CkgfomrBl4NMbjRtAvkoNks,4025
 onnx2tf/ops/Equal.py,sha256=ni0gf7nJex8S-oG61bnHc_xn8LuMits3gM6IzGNT65w,4579
@@ -118,14 +118,14 @@ onnx2tf/ops/PRelu.py,sha256=pHbsffhb2rLZPPb9NdKUT4f5-lC0TXmbZVafookXo90,6314
 onnx2tf/ops/Pad.py,sha256=xZOkZK-53sXU-d0nADAjR1wOpKqfzHeJjTmzwon6G4A,11883
 onnx2tf/ops/Pow.py,sha256=DZjrWQSyLw_BPXrKyoTqT9KJIxPfNxnYVcoTDBagDgM,7056
 onnx2tf/ops/QLinearAdd.py,sha256=OssQI0pd8KXdnCC8urCPKP8bpcvSX0D76bS7q4-xMSY,5027
-onnx2tf/ops/QLinearConcat.py,sha256=ZAde6h_OZ35gROmenr__pjrrni310TmOqjYUEu_gXIo,4530
-onnx2tf/ops/QLinearConv.py,sha256=hgtvQdhy1Xsrdx-ThCT4L6v7zElWvgkt0-gJqdko8LY,12146
+onnx2tf/ops/QLinearConcat.py,sha256=TWYqxADiAq51kcGq2EA1K9FQnx5RgGFxPWHxMxbUz4M,13296
+onnx2tf/ops/QLinearConv.py,sha256=rRQGCf1pqC-hvsXRaN6BVZwzARb5JJNdu9R6Hb4nptU,11771
 onnx2tf/ops/QLinearLeakyRelu.py,sha256=8Egl-ACtsnBrdcrm8LHzyWJEhcBi1dMp4lEBsqEGWA4,4521
-onnx2tf/ops/QLinearMatMul.py,sha256=7OLXnwUoLAtpQRsK2w_RP_YXVwR0GQDyuLPGjVTnXOQ,5636
+onnx2tf/ops/QLinearMatMul.py,sha256=DCClPZKLyyef10ZogbZLbrByQuocUnAWDHVevAd_MmM,7477
 onnx2tf/ops/QLinearMul.py,sha256=QUqevMwVcDlSqAWlQ9ZTpNcvRlDXO1j3wWzEQZGEdq8,5056
 onnx2tf/ops/QLinearSigmoid.py,sha256=pV18RrqC64ADQQMaxJIO1iwrjbf2hpUVcvBQfntiBJ0,3931
 onnx2tf/ops/QLinearSoftmax.py,sha256=GtfT2gVH-V2j4NRqBbDFFfZWygp7TIjP662vo8k6dbU,4256
-onnx2tf/ops/QuantizeLinear.py,sha256=tYKnsWZ_LBSMteVOTi8UV3F_dyTiE9tK8IeOmZjitVM,4563
+onnx2tf/ops/QuantizeLinear.py,sha256=g_kZy7Ei4Ey_rGQWiSKDPaY9TOONegLxV1Jyt_gTP0k,7255
 onnx2tf/ops/RNN.py,sha256=55G5muM0BmJU9xIUU7hWsxhz5npisTfLJipR1w83ZDk,28143
 onnx2tf/ops/RandomNormal.py,sha256=g1HvpScrHBOffqPT6yhSV1y2fNx7klruD6Vkolfl0to,2013
 onnx2tf/ops/RandomNormalLike.py,sha256=BKguRxj48JhJ68Hce6xO8eE0OE-mTwnpymxBlV81ofw,2772
@@ -173,7 +173,7 @@ onnx2tf/ops/Softmax.py,sha256=CEnHcSm25v1QC4QVDg4fz1NooYY1v-Uq4GORd8dnnr8,14773
 onnx2tf/ops/Softplus.py,sha256=R44YMo8G2Ig15jBO6T2VOI6RhpUmjD70qvSCXFylU-Q,3605
 onnx2tf/ops/Softsign.py,sha256=2ZdKH3KVHZXDzyO7S8f-O_aqRugurbRxd1i2g_fwCos,3600
 onnx2tf/ops/SpaceToDepth.py,sha256=rWtPQNm2rErYs20gQyz-tFYsImAIUBGtdvfMVkJg5bo,2809
-onnx2tf/ops/Split.py,sha256=ukm7QZmSwYwUwGLbVGsOiCEB3YfrFMl0cozn1kwgCv0,10728
+onnx2tf/ops/Split.py,sha256=Z2UwbEBnG8nY3fED__ijgD9KikTuqPBv5ZjHEeoNURU,12103
 onnx2tf/ops/SplitToSequence.py,sha256=BS_JEd7DC7vuPfs5oRRW774mtlK--kqf9DJUalv-Agk,5062
 onnx2tf/ops/Sqrt.py,sha256=-xE8Tk_6unSR56k9g3R46lML4Nht5kQwqJT0JYkn5ko,3585
 onnx2tf/ops/Squeeze.py,sha256=FLIt2qjWh1IJyti1c4YHuepH2Fkxt40rnEKszzmwsnE,7980
@@ -199,7 +199,7 @@ onnx2tf/utils/enums.py,sha256=7c5TqetqB07VjyHoxJHfLgtqBqk9ZRyUF33fPOJR1IM,1649
 onnx2tf/utils/iterative_json_optimizer.py,sha256=qqeIxWGxrhcCYk8-ebWnblnOkzDCwi-nseipHzHR_bk,10436
 onnx2tf/utils/json_auto_generator.py,sha256=OC-SfKtUg7zUxaXTAg6kT0ShzIc3ByjDa3FNp173DtA,60302
 onnx2tf/utils/logging.py,sha256=yUCmPuJ_XiUItM3sZMcaMO24JErkQy7zZwVTYWAuiKg,1982
-onnx2tf-1.29.15.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-onnx2tf-1.29.15.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
-onnx2tf-1.29.15.dist-info/METADATA,sha256=pvIhTXrSp_ldpl6zX8fXfwfvCnOw7_W4K6FZhK7YeAI,154244
-onnx2tf-1.29.15.dist-info/RECORD,,
+onnx2tf-1.29.16.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+onnx2tf-1.29.16.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.16.dist-info/METADATA,sha256=2h83lAHOcFRpBz9nj2MaYmQZlNG74IdwlHkah1pZpeI,154244
+onnx2tf-1.29.16.dist-info/RECORD,,