onnx2tf 1.29.9__py3-none-any.whl → 1.29.10__py3-none-any.whl

onnx2tf/ops/LpPool.py

@@ -0,0 +1,296 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    remove_dilations,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+    calc_tf_pooling_pads,
+    calc_extra_padding_with_ceil,
+    transpose_with_flexing_deterrence,
+)
+from onnx2tf.utils.logging import *
+
+INF_INDEX_VALUE: int = 4294967296
+
+
+def _kernel_size_const(kernel_shape, dtype):
+    if isinstance(kernel_shape, (list, tuple, np.ndarray)):
+        size = 1
+        for k in kernel_shape:
+            size *= int(k)
+        return tf.cast(size, dtype)
+    if tf.is_tensor(kernel_shape):
+        return tf.cast(tf.reduce_prod(kernel_shape), dtype)
+    return tf.cast(int(kernel_shape), dtype)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """LpPool
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        tf_layers_dict.get(graph_node.inputs[0].name, {}).get('before_op_output_shape_trans', True)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1
+
+    graph_node_input = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    input_tensor = tf_layers_dict[graph_node_input.name]['tf_node'] \
+        if isinstance(graph_node_input, gs.Variable) else graph_node_input
+    input_tensor_shape = input_tensor.shape
+    input_tensor_rank = len(input_tensor_shape)
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    # Workaround to avoid as many conversion failures as possible
+    # for models with useless Transpose immediately before them.
+    # If the input geometry of the ONNX and the input geometry of the TF model match,
+    # the input geometry on the TF model side is forcibly transposed to the NWC or NHWC or NDHWC format.
+    # However, if all dimensions of CW or CHW or CDHW have the same value,
+    # the forced transposition process is skipped because it may destroy the structure of the model.
+    onnx_input_shape = [
+        dim if isinstance(dim, int) else None for dim in graph_node.inputs[0].shape
+    ] if graph_node.inputs[0].shape is not None else None
+    tf_input_shape = [
+        dim if isinstance(dim, int) else None for dim in input_tensor_shape
+    ]
+    if onnx_input_shape is not None \
+        and len(onnx_input_shape) > 1 and len(tf_input_shape) > 1 \
+        and onnx_input_shape == tf_input_shape:
+
+        shape_for_judging_skip = [
+            dim if dim is not None else INF_INDEX_VALUE for dim in onnx_input_shape[1:]
+        ]
+        if shape_for_judging_skip.count(shape_for_judging_skip[0]) != len(shape_for_judging_skip):
+            if len(onnx_input_shape) == 3:
+                # 1D
+                input_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=input_tensor,
+                    perm=[0,2,1],
+                    **kwargs,
+                )
+            elif len(onnx_input_shape) == 4:
+                # 2D
+                input_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=input_tensor,
+                    perm=[0,2,3,1],
+                    **kwargs,
+                )
+            elif len(onnx_input_shape) == 5:
+                # 3D
+                input_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=input_tensor,
+                    perm=[0,2,3,4,1],
+                    **kwargs,
+                )
+
+    auto_pad = graph_node.attrs.get('auto_pad', 'NOTSET')
+    ceil_mode = bool(graph_node.attrs.get('ceil_mode', 0))
+    kernel_shape = graph_node.attrs['kernel_shape']
+    spatial_size = len(kernel_shape)
+    dilations = graph_node.attrs.get('dilations', [1] * spatial_size)
+    pads = graph_node.attrs.get('pads', [0] * spatial_size * 2)
+    strides = graph_node.attrs.get('strides', [1] * spatial_size)
+    p = float(graph_node.attrs.get('p', 2))
+
+    input_tensor_shape = input_tensor.shape.as_list()
+    is_known_shape = None not in input_tensor_shape[1:]
+
+    # default tensorflow action is 'SAME_UPPER' mode (extra padding in the end for odd numbers)
+    # explicit pad layer is added for tensorflow incompatible cases
+    tf_pad_mode = 'VALID'
+    is_explicit_padding = False
+    dilated_kernel_shape = kernel_shape
+    if dilations != [1] * spatial_size:
+        dilated_kernel_shape = [(k - 1) * d for k, d in zip(kernel_shape, dilations)]
+
+    tf_pads = calc_tf_pooling_pads(
+        input_shape=input_tensor_shape,
+        kernel=dilated_kernel_shape,
+        strides=strides,
+        input_tensor=input_tensor,
+    )
+
+    # onnx padding value is ignored if auto_pad is not 'NOTSET'
+    if auto_pad == 'NOTSET':
+
+        # check if onnx padding is same with tensorflow padding mode 'SAME'
+        # this is to avoid flex operations since tflite has no builtin pooling with manual padding value
+        if is_known_shape and pads != [0] * spatial_size * 2 and tf_pads == pads:
+            auto_pad = 'SAME_UPPER'
+            tf_pad_mode = 'SAME'
+
+        else:
+            auto_pad = 'VALID'
+            is_explicit_padding = True
+
+            # extra padding may be needed for ceiling
+            # this padding is added to end side (right, bottom) only
+            if ceil_mode:
+                extra_pads = \
+                    calc_extra_padding_with_ceil(
+                        input_shape=input_tensor_shape[1:-1],
+                        kernel=kernel_shape,
+                        pads=pads,
+                        dilations=dilations,
+                        strides=strides,
+                    )
+                pads = pads[:len(pads) // 2] + [p + e for p, e in zip(pads[len(pads) // 2:], extra_pads)]
+
+            tf_pads = pads
+
+    elif auto_pad == 'SAME_UPPER':
+        tf_pad_mode = 'SAME'
+
+    elif auto_pad == 'SAME_LOWER':
+        is_explicit_padding = True
+
+    elif auto_pad == 'VALID':
+        tf_pads = [0] * spatial_size * 2
+
+    else:
+        error_msg = Color.RED(f'ERROR:') + ' ' + \
+                    f'Wrong auto_pad parameter in LpPool: {auto_pad}.'
+        raise ValueError(error_msg)
+
+    # add extra pad layer if needed
+    if is_explicit_padding and tf_pads != [0] * spatial_size * 2:
+        warn(
+            f'Tensorflow incompatible padding detected. ' \
+            f'Extra pad layer is inserted automatically. '
+        )
+
+        if auto_pad == 'SAME_LOWER':
+            # switch the order of pads
+            tf_pads = [i for tup in zip(tf_pads[len(tf_pads) // 2:], tf_pads[:len(tf_pads) // 2]) for i in tup]
+
+        # convert to tensorflow padding format
+        tf_pads = \
+            [[0, 0]] + \
+            [list(i) for i in zip(tf_pads[:len(tf_pads) // 2], tf_pads[len(tf_pads) // 2:])] + \
+            [[0, 0]]
+
+        padded_tensor = tf.pad(
+            tensor=input_tensor,
+            paddings=tf_pads,
+            mode='CONSTANT',
+            constant_values=0.0,
+        )
+
+    else:
+        padded_tensor = input_tensor
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+        'nhwc': True,
+    }
+
+    # Generation of TF OP
+    tf_op_type = None
+    abs_p_tensor = tf.pow(tf.abs(padded_tensor), p) if p != 1.0 else tf.abs(padded_tensor)
+    kernel_size_const = _kernel_size_const(kernel_shape, abs_p_tensor.dtype)
+
+    if spatial_size < 4 and (strides == [1] * spatial_size or dilations == [1] * spatial_size):
+        pooled_tensor = tf.nn.pool(
+            input=abs_p_tensor,
+            window_shape=kernel_shape,
+            dilations=dilations,
+            strides=strides,
+            padding=tf_pad_mode.upper(),
+            pooling_type='AVG',
+        )
+        tf_op_type = tf.nn.pool
+    else:
+        # TODO: Dilated LpPool with strides is broken for 3D and above, need to be fixed
+        if spatial_size >= 3:
+            error_msg = Color.RED(f'ERROR:') + ' ' \
+                        f'Dilated LpPool with strides is not supported for 3D and above for now. '
+            print(error_msg)
+            raise NotImplementedError(error_msg)
+
+        abs_p_tensor = remove_dilations(
+            input_tensor=abs_p_tensor,
+            kernel_shape=kernel_shape,
+            spatial_size=spatial_size,
+            strides=strides,
+            dilations=dilations,
+        )
+        pooled_tensor = tf.nn.pool(
+            input=abs_p_tensor,
+            window_shape=kernel_shape,
+            strides=kernel_shape,
+            padding='VALID',
+            pooling_type='AVG',
+        )
+        tf_op_type = tf.nn.pool
+
+    pooled_tensor = pooled_tensor * kernel_size_const
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.pow(pooled_tensor, 1.0 / p) if p != 1.0 else pooled_tensor
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf_op_type,
+                'tf_inputs': {
+                    'input': input_tensor,
+                    'kernel_shape': kernel_shape,
+                    'strides': strides,
+                    'dilations': dilations,
+                    'padding': tf_pads if tf_pad_mode != 'same' else tf_pad_mode,
+                    'ceil_mode': ceil_mode,
+                    'p': p,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/MaxRoiPool.py

@@ -0,0 +1,236 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+    transpose_with_flexing_deterrence,
+)
+from onnx2tf.utils.logging import *
+
+INF_INDEX_VALUE: int = 4294967296
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """MaxRoiPool
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        tf_layers_dict.get(graph_node.inputs[0].name, {}).get('before_op_output_shape_trans', True)
+    before_op_output_shape_trans_2 = \
+        tf_layers_dict.get(graph_node.inputs[1].name, {}).get('before_op_output_shape_trans', True)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1 and before_op_output_shape_trans_2
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_input_2 = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    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
+    rois = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    # Workaround to avoid as many conversion failures as possible
+    # for models with useless Transpose immediately before them.
+    # If the input geometry of the ONNX and the input geometry of the TF model match,
+    # the input geometry on the TF model side is forcibly transposed to the NHWC format.
+    # However, if all dimensions of CHW have the same value,
+    # the forced transposition process is skipped because it may destroy the structure of the model.
+    onnx_input_shape = [
+        dim if isinstance(dim, int) else None for dim in graph_node.inputs[0].shape
+    ] if graph_node.inputs[0].shape is not None else None
+    tf_input_shape = [
+        dim if isinstance(dim, int) else None for dim in input_tensor.shape
+    ]
+    if onnx_input_shape is not None \
+        and len(onnx_input_shape) > 1 and len(tf_input_shape) > 1 \
+        and onnx_input_shape == tf_input_shape:
+
+        shape_for_judging_skip = [
+            dim if dim is not None else INF_INDEX_VALUE for dim in onnx_input_shape[1:]
+        ]
+        if shape_for_judging_skip.count(shape_for_judging_skip[0]) != len(shape_for_judging_skip):
+            if len(onnx_input_shape) == 4:
+                # 2D
+                input_tensor = transpose_with_flexing_deterrence(
+                    input_tensor=input_tensor,
+                    perm=[0,2,3,1],
+                    **kwargs,
+                )
+
+    pooled_shape = graph_node.attrs.get('pooled_shape', None)
+    if pooled_shape is None or len(pooled_shape) != 2:
+        error_msg = \
+            Color.RED(f'ERROR:') + ' ' + \
+            f'pooled_shape is required for MaxRoiPool. ' \
+            f'graph_node.name: {graph_node.name}, pooled_shape: {pooled_shape}'
+        print(error_msg)
+        raise ValueError(error_msg)
+
+    pooled_h = int(pooled_shape[0])
+    pooled_w = int(pooled_shape[1])
+    spatial_scale = float(graph_node.attrs.get('spatial_scale', 1.0))
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+        'nhwc': True,
+    }
+
+    # Generation of TF OP
+    rois = tf.cast(rois, tf.float32)
+    if rois.shape.rank == 1:
+        rois = tf.expand_dims(rois, axis=0)
+
+    channels_static = input_tensor.shape[-1]
+    channel_spec = tf.TensorSpec(
+        shape=(channels_static,) if channels_static is not None else (None,),
+        dtype=input_tensor.dtype,
+    )
+    row_spec = tf.TensorSpec(
+        shape=(pooled_w, channels_static) if channels_static is not None else (pooled_w, None),
+        dtype=input_tensor.dtype,
+    )
+    roi_spec = tf.TensorSpec(
+        shape=(pooled_h, pooled_w, channels_static) if channels_static is not None else (pooled_h, pooled_w, None),
+        dtype=input_tensor.dtype,
+    )
+
+    def roi_pool_single(roi):
+        batch_idx = tf.cast(roi[0], tf.int32)
+        x1, y1, x2, y2 = tf.unstack(roi[1:5])
+        x1 = x1 * spatial_scale
+        y1 = y1 * spatial_scale
+        x2 = x2 * spatial_scale
+        y2 = y2 * spatial_scale
+
+        roi_start_w = tf.cast(tf.round(x1), tf.int32)
+        roi_start_h = tf.cast(tf.round(y1), tf.int32)
+        roi_end_w = tf.cast(tf.round(x2), tf.int32)
+        roi_end_h = tf.cast(tf.round(y2), tf.int32)
+
+        height = tf.shape(input_tensor)[1]
+        width = tf.shape(input_tensor)[2]
+
+        roi_start_w = tf.clip_by_value(roi_start_w, 0, width)
+        roi_start_h = tf.clip_by_value(roi_start_h, 0, height)
+        roi_end_w = tf.clip_by_value(roi_end_w, 0, width)
+        roi_end_h = tf.clip_by_value(roi_end_h, 0, height)
+
+        roi_width = tf.maximum(roi_end_w - roi_start_w + 1, 1)
+        roi_height = tf.maximum(roi_end_h - roi_start_h + 1, 1)
+
+        bin_size_h = tf.cast(roi_height, tf.float32) / tf.cast(pooled_h, tf.float32)
+        bin_size_w = tf.cast(roi_width, tf.float32) / tf.cast(pooled_w, tf.float32)
+
+        channels_dynamic = tf.shape(input_tensor)[-1]
+        zero = tf.zeros([channels_dynamic], dtype=input_tensor.dtype)
+
+        def pool_bin(ph, pw):
+            ph_f = tf.cast(ph, tf.float32)
+            pw_f = tf.cast(pw, tf.float32)
+            hstart = tf.cast(tf.floor(ph_f * bin_size_h), tf.int32) + roi_start_h
+            hend = tf.cast(tf.ceil((ph_f + 1.0) * bin_size_h), tf.int32) + roi_start_h
+            wstart = tf.cast(tf.floor(pw_f * bin_size_w), tf.int32) + roi_start_w
+            wend = tf.cast(tf.ceil((pw_f + 1.0) * bin_size_w), tf.int32) + roi_start_w
+
+            hstart = tf.clip_by_value(hstart, 0, height)
+            hend = tf.clip_by_value(hend, 0, height)
+            wstart = tf.clip_by_value(wstart, 0, width)
+            wend = tf.clip_by_value(wend, 0, width)
+
+            is_empty = tf.logical_or(hend <= hstart, wend <= wstart)
+
+            def do_max():
+                region = input_tensor[batch_idx, hstart:hend, wstart:wend, :]
+                return tf.reduce_max(region, axis=[0,1])
+
+            return tf.cond(is_empty, lambda: zero, do_max)
+
+        def pool_row(ph):
+            return tf.map_fn(
+                lambda pw: pool_bin(ph, pw),
+                tf.range(pooled_w),
+                fn_output_signature=channel_spec,
+            )
+
+        return tf.map_fn(
+            pool_row,
+            tf.range(pooled_h),
+            fn_output_signature=row_spec,
+        )
+
+    pooled_tensor = tf.map_fn(
+        roi_pool_single,
+        rois,
+        fn_output_signature=roi_spec,
+    )
+
+    tf_layers_dict[graph_node_output.name]['tf_node'] = pooled_tensor
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': 'MaxRoiPool',
+                'tf_inputs': {
+                    'input': input_tensor,
+                    'rois': rois,
+                    'pooled_shape': pooled_shape,
+                    'spatial_scale': spatial_scale,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/utils/common_functions.py

@@ -276,6 +276,8 @@ def make_tf_node_info(**kwargs):
 def print_node_info(func):
     @wraps(func)
     def print_wrapper_func(*args, **kwargs):
+        if kwargs.get('suppress_log', False):
+            return func(*args, **kwargs)
         input_onnx_file_path: str = kwargs.get('input_onnx_file_path', None)
         graph_input: gs.Variable = kwargs.get('graph_input', None)
         graph_node: gs.Variable = kwargs.get('graph_node', None)
@@ -4051,6 +4053,7 @@ def dummy_tf_inference(
             for idx, dim in enumerate(input_size):
                 if idx == 0 and input_sizes[0][0] is not None \
                     and len(input_sizes[0]) == len(input_size) \
+                    and len(input_size) >= 2 \
                     and dim is None:
                     # Batch size assignment for input OPs
                     new_input_size.append(input_sizes[0][0])

{onnx2tf-1.29.9.dist-info → onnx2tf-1.29.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.9
+Version: 1.29.10
 Summary: Self-Created Tools to convert ONNX files (NCHW) to TensorFlow/TFLite/Keras format (NHWC).
 Home-page: https://github.com/PINTO0309/onnx2tf
 Author: Katsuya Hyodo
@@ -182,16 +182,16 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |Less|:heavy_check_mark:|
   |Log|:heavy_check_mark:|
   |LogSoftmax|:heavy_check_mark:|
-  |Loop|**Help wanted**|
+  |Loop|:heavy_check_mark:|
   |LpNormalization|:heavy_check_mark:|
-  |LpPool|**Help wanted**|
+  |LpPool|:heavy_check_mark:|
   |LRN|:heavy_check_mark:|
   |LSTM|:heavy_check_mark:|
   |MatMul|:heavy_check_mark:|
   |MatMulInteger|:heavy_check_mark:|
   |MaxPool|:heavy_check_mark:|
   |Max|:heavy_check_mark:|
-  |MaxRoiPool|**Help wanted**|
+  |MaxRoiPool|:heavy_check_mark:|
   |MaxUnpool|:heavy_check_mark:|
   |Mean|:heavy_check_mark:|
   |MeanVarianceNormalization|:heavy_check_mark:|
@@ -359,7 +359,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.9
+  ghcr.io/pinto0309/onnx2tf:1.29.10
 
   or
 
@@ -367,7 +367,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.9
+  docker.io/pinto0309/onnx2tf:1.29.10
 
   or
 

{onnx2tf-1.29.9.dist-info → onnx2tf-1.29.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
-onnx2tf/__init__.py,sha256=0iOZ-E1Mv5pU4CHm_29h1gNBG_KtKmxjV5sHtV-0DKI,66
+onnx2tf/__init__.py,sha256=E1LYdyUQ9pnnydTNI6NtTfnt7AZXaoxY42NlhsS5Jr0,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
-onnx2tf/onnx2tf.py,sha256=wdBA-lgCEu-ZfUAKIUQgLe8hSP8ifE7rS6nWAq6iF6o,151519
+onnx2tf/onnx2tf.py,sha256=yR8aKaEn01Q8dEeYDqHIsuZuG6l5TGQniHDlPiUROx4,152238
 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
@@ -75,7 +75,7 @@ onnx2tf/ops/HardSigmoid.py,sha256=KDP_t-Z70sDsHMOYxyJ7ZNH31zqkrViOKYCcRG5NJHc,36
 onnx2tf/ops/HardSwish.py,sha256=nEng3LCDQYMZ4XhFZ7pXKGyRsM2_waowi8PlZt_f6Ck,3994
 onnx2tf/ops/Hardmax.py,sha256=tiMch3Tuc8Rvy52hgGSfqfOVyXaEsnxYplRMy7vtpyA,4398
 onnx2tf/ops/Identity.py,sha256=egudADqdhe4BiunYHUTh-AlDAkPpRESRT2eG0Q4rBts,2425
-onnx2tf/ops/If.py,sha256=d1CD5R3-UuhO35XwLsVCtWhUvJJg6LKh5OKTmYrGBh8,6966
+onnx2tf/ops/If.py,sha256=Z3VEMm1mOKomYl1Mw58shc83kNPZsYs-wvhse7PlfTY,7062
 onnx2tf/ops/Input.py,sha256=aRZQ4uLWmMS3q317wZO68qqks8p3QDOINhTEObAhvvY,16225
 onnx2tf/ops/InstanceNormalization.py,sha256=gUixsJ1105tt8UGwoLLdZ4V95GiZwzHm_jJMugqQ1yQ,11997
 onnx2tf/ops/Inverse.py,sha256=YsRs0mpZg6dXWXnM1-UU5PcaUvrUqLmDDCNFpirXqp4,4595
@@ -89,11 +89,14 @@ onnx2tf/ops/Less.py,sha256=YZp5u3cUMU9Gcv_JVqPSIeuaIzVlU0hKy0PnvE6BXFo,4576
 onnx2tf/ops/LessOrEqual.py,sha256=9Lc8qaYUPVC6yZoQluNqcdHnvpUbfWBOI4Ow38RRAJo,4595
 onnx2tf/ops/Log.py,sha256=UZebF3SGq85BnoPgYyN2j-zzFRp67fJnYPNyu33W55o,3582
 onnx2tf/ops/LogSoftmax.py,sha256=j2nhYY7__8ViLFJVLA5tS98QEvGS1gTIW0QCdnZWUPQ,3923
+onnx2tf/ops/Loop.py,sha256=I32CWoex8FMXm9KE2aomADB4jK5BzaMoAKvtPnBJy6A,14593
 onnx2tf/ops/LpNormalization.py,sha256=Uu15HgxFNXb6gNMgdTJyf0SLPaLbcbkOYqY_4hMBxNA,3153
+onnx2tf/ops/LpPool.py,sha256=96eI1FaDgW0M_USWBCHFedvtojHTLL28_lb3mcEV55A,10470
 onnx2tf/ops/MatMul.py,sha256=KHhRyQCyxe6845f-AOI1UJzA3rGTssG6eyKmDw0oegs,21466
 onnx2tf/ops/MatMulInteger.py,sha256=qHqzdJNI9SeJDbW8pR90baYCdGN6FdOez4hi9EzwXoc,6538
 onnx2tf/ops/Max.py,sha256=w5nMciO_6ApYUobHuwMGuS3xhuza7eSvKDRhvMPgAuo,3256
 onnx2tf/ops/MaxPool.py,sha256=_JC4eqBTh-qLkZCMG8RZhthRZ8D2d821zaFMWeGMEWc,15775
+onnx2tf/ops/MaxRoiPool.py,sha256=RYZyjnINqJd6k7KLFJ-D9iHjA2vR-m7WvhrumD9cmDk,8490
 onnx2tf/ops/MaxUnpool.py,sha256=dGIEvC45rFuWoeG1S9j4sjEdEUqiWs_xdY5DZH6X7b4,5743
 onnx2tf/ops/Mean.py,sha256=xfTjKpQntJB8uXAkgDLS77oLXy2yQh1Hlz0K2GltMh0,3132
 onnx2tf/ops/MeanVarianceNormalization.py,sha256=Ne53jlDgAJZ9yhzKOWR-0LnjDdM-fg7DYmRytoP-4IA,3743
@@ -189,18 +192,16 @@ onnx2tf/ops/Unsqueeze.py,sha256=UJun_DYfg7aQaHoeAvWlB85oRtDWq2lP7kvb0njcaC0,1221
 onnx2tf/ops/Upsample.py,sha256=SX3N_wZHD8G5Z0PLcPgX1ZCzOdct-uTzxKeMhhzeBOw,5304
 onnx2tf/ops/Where.py,sha256=MaCcY9g4mKZQqCgh4xtoylicP-xVu9f4boKiu_q9Ow8,7711
 onnx2tf/ops/Xor.py,sha256=2ceqxHSI1Wtez_CIh8gFfvcu45Xboqfyp1iy3v2vuIs,4590
-onnx2tf/ops/_Loop.py,sha256=eo5sNfrfOnKV6_I737AWsM5LJTY9DVOxQEvhanxtP4g,11322
-onnx2tf/ops/__Loop.py,sha256=ClwMcbNS4hqUtW_pzwjMa9Cqg7ONvz9aplke55A0uJ0,19704
 onnx2tf/ops/__init__.py,sha256=jnmUWWa-3dHzBZV9bmPzXu6eoz2dumJTzO7i8JdcgSM,25
 onnx2tf/utils/__init__.py,sha256=E9FM9He68VIASDnYp-OrxvHFVn55GzWqw2OEkCqn1zg,27
-onnx2tf/utils/common_functions.py,sha256=o9a4g56OdQKocODzBp2Uxesves_Tl-Iizh5r4Okmu6Q,249631
+onnx2tf/utils/common_functions.py,sha256=TWb_e6i2MjB7C4eh1FWHTIDVlr6-7NgSNcCKwKGhGg8,249765
 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.9.dist-info/licenses/LICENSE,sha256=5v_Kxihy8i6mzHVl349ikSREaIdsl9YeUnX1KBDLD2w,1070
-onnx2tf-1.29.9.dist-info/licenses/LICENSE_onnx-tensorflow,sha256=gK4GtS9S5YcyINu6uuNNWdo-kBClyEM4MFLFGiNTeRM,11231
-onnx2tf-1.29.9.dist-info/METADATA,sha256=_Rhg96G54IqDYqigqKQjYlFIzp3SRB2wpRrt03eeZ1w,153504
-onnx2tf-1.29.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-onnx2tf-1.29.9.dist-info/top_level.txt,sha256=WgfPiEy3f6vZ_FOpAIEA2CF3TCx1eYrhGw93Ih6b9Fw,8
-onnx2tf-1.29.9.dist-info/RECORD,,
+onnx2tf-1.29.10.dist-info/licenses/LICENSE,sha256=5v_Kxihy8i6mzHVl349ikSREaIdsl9YeUnX1KBDLD2w,1070
+onnx2tf-1.29.10.dist-info/licenses/LICENSE_onnx-tensorflow,sha256=gK4GtS9S5YcyINu6uuNNWdo-kBClyEM4MFLFGiNTeRM,11231
+onnx2tf-1.29.10.dist-info/METADATA,sha256=LMFqdTpJPlqtKrJ0jmOeQh5PKMyUy_XDbSPDcARueyE,153516
+onnx2tf-1.29.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+onnx2tf-1.29.10.dist-info/top_level.txt,sha256=WgfPiEy3f6vZ_FOpAIEA2CF3TCx1eYrhGw93Ih6b9Fw,8
+onnx2tf-1.29.10.dist-info/RECORD,,