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

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

@@ -1,6 +1,6 @@
-onnx2tf/__init__.py,sha256=0iOZ-E1Mv5pU4CHm_29h1gNBG_KtKmxjV5sHtV-0DKI,66
+onnx2tf/__init__.py,sha256=YcIMmqFje14SgZxYSfLRHbInf0F8cWXJjfwWrwz2mxg,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,14 @@ 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.11.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+onnx2tf-1.29.11.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.11.dist-info/METADATA,sha256=jeSTHVzVOoEkFVfyO6OVFniy_mrUfZKW9Gez1RYMkVM,154193
+onnx2tf-1.29.11.dist-info/RECORD,,

{onnx2tf-1.29.9.dist-info → onnx2tf-1.29.11.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.2)
+Generator: uv 0.9.27
 Root-Is-Purelib: true
 Tag: py3-none-any
-

onnx2tf-1.29.11.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+onnx2tf = onnx2tf:main
+

onnx2tf/ops/_Loop.py

@@ -1,306 +0,0 @@
-import re
-import sys
-import random
-random.seed(0)
-import numpy as np
-np.random.seed(0)
-import tensorflow as tf
-import tf_keras
-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,
-)
-from onnx2tf.utils.enums import NUMPY_DTYPES_TO_TF_DTYPES
-import importlib
-from onnx2tf.utils.logging import *
-
-
-class While_Loop_CustomLayer(tf_keras.layers.Layer):
-    def __init__(self):
-        super(While_Loop_CustomLayer, self).__init__()
-
-    def call(self, cond, body, loop_vars, shape_invariants, maximum_iterations):
-        return tf.while_loop(
-            cond=cond,
-            body=body,
-            loop_vars=loop_vars,
-            shape_invariants=shape_invariants,
-            maximum_iterations=maximum_iterations,
-        )
-
-
-@print_node_info
-@inverted_operation_enable_disable
-def make_node(
-    *,
-    graph_node: gs.Node,
-    tf_layers_dict: dict,
-    **kwargs: dict,
-):
-    """Loop
-
-    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_input_n_list = []
-    for graph_node_input in graph_node.inputs[2:]:
-        graph_node_input_n = get_constant_or_variable(
-            graph_node_input,
-            before_op_output_shape_trans,
-        )
-        graph_node_input_n_list.append(graph_node_input_n)
-
-    M = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
-        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
-    M = None if isinstance(M, str) and M == "" else M
-    M = tf.where(
-        tf.greater(M, tf.int32.max),
-        tf.constant(tf.int32.max, tf.int32),
-        tf.cast(M, tf.int32)
-    ) if M is not None else M
-    cond = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
-        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
-    cond_init = None if isinstance(cond, str) and cond == "" else tf.cast(cond, tf.bool)
-
-    v_init = [
-        tf_layers_dict[graph_node_input_n.name]['tf_node'] \
-            if isinstance(graph_node_input_n, gs.Variable) else graph_node_input_n \
-                for graph_node_input_n in graph_node_input_n_list
-    ]
-    v_shapes = [
-        tf.TensorShape([None for i in range(len(v.shape))]) for v in v_init
-    ]
-
-    body: gs.Graph = graph_node.attrs["body"]
-
-    iter_cnt_init = np.int64(0)
-
-    scan_outputs_start_index = 1 + len(v_init)
-    scan_outputs_init = [
-        tf.TensorArray(
-            dtype=body.outputs[i].dtype,
-            size=0,
-            dynamic_size=True
-        ) for i in range(scan_outputs_start_index, len(body.outputs))
-    ]
-    scan_outputs_shapes = [tf.TensorShape(None) for o in scan_outputs_init]
-
-    graph_node_output: gs.Variable = graph_node.outputs[0]
-    shape = graph_node_output.shape
-    dtype = graph_node_output.dtype
-
-    # Preserving Graph Structure (Dict)
-    tf_layers_dict[graph_node_output.name] = {
-        'optype': graph_node.op,
-        'shape': shape,
-        'dtype': dtype,
-    }
-
-    # Generation of TF OP
-    def run_subgraph(iter_cnt, cond, v, scan_outputs):
-        for body_input in body.inputs:
-            try:
-                op = importlib.import_module(f'onnx2tf.ops.Input')
-            except ModuleNotFoundError as ex:
-                error(
-                    f'{optype} OP is not yet implemented.'
-                )
-                sys.exit(1)
-            # substitution because saved_model does not allow colons
-            body_input.name = body_input.name.replace(':','__')
-            # Substitution because saved_model does not allow leading slashes in op names
-            if kwargs['output_signaturedefs']:
-                body_input.name = re.sub('^/', 'wa/', body_input.name)
-            op.make_node(
-                graph_input=body_input,
-                tf_layers_dict=tf_layers_dict,
-                keep_ncw_or_nchw_or_ncdhw_input_names=[],
-                keep_nwc_or_nhwc_or_ndhwc_input_names=[],
-                keep_shape_absolutely_input_names=[],
-                **kwargs,
-            )
-        for body_node in body.nodes:
-            optype = body_node.op
-            try:
-                op = importlib.import_module(f'onnx2tf.ops.{optype}')
-            except ModuleNotFoundError as ex:
-                error(
-                    f'{optype} OP is not yet implemented.'
-                )
-                sys.exit(1)
-            # substitution because saved_model does not allow colons
-            body_node.name = body_node.name.replace(':','__')
-            # Substitution because saved_model does not allow leading slashes in op names
-            if kwargs['output_signaturedefs']:
-                body_node.name = re.sub('^/', 'wa/', body_node.name)
-            op.make_node(
-                graph_node=body_node,
-                tf_layers_dict=tf_layers_dict,
-                **kwargs,
-            )
-            # Resister constant
-            for output in body.outputs:
-                if output.name not in tf_layers_dict and isinstance(output, gs.Constant):
-                    tf_layers_dict[output.name] = {
-                        'optype': 'Constant',
-                        'shape': output.values.shape,
-                        'dtype': output.values.dtype,
-                    }
-                    tf_layers_dict[output.name]['tf_node'] = \
-                        tf.constant(
-                            output.values,
-                            dtype=NUMPY_DTYPES_TO_TF_DTYPES[output.values.dtype],
-                        )
-        outputs = [tf_layers_dict[output.name]['tf_node'] for output in body.outputs]
-        for i in range(scan_outputs_start_index, len(outputs)):
-            s_index = i - scan_outputs_start_index
-            insert_index = scan_outputs[s_index].size()
-            scan_outputs[s_index] = scan_outputs[s_index].write(insert_index, outputs[i])
-        iter_cnt += 1
-        return iter_cnt, outputs[0], outputs[1:scan_outputs_start_index], scan_outputs
-
-    # for loop
-    # https://stackoverflow.com/questions/71635459/how-to-use-keras-symbolic-inputs-with-tf-while-loop
-    if M is not None and cond_init is None:
-        condition = lambda iter_cnt, cond, v, scan_outputs: True
-        while_loop_layer = While_Loop_CustomLayer()
-        iter_cnt_final, _, v_final, scan_outputs_final = while_loop_layer(
-            cond=condition,
-            body=run_subgraph,
-            loop_vars=[
-                iter_cnt_init,
-                "",
-                v_init,
-                scan_outputs_init,
-            ],
-            shape_invariants=[
-                tf.TensorShape([]),
-                tf.TensorShape(None),
-                v_shapes,
-                scan_outputs_shapes,
-            ],
-            maximum_iterations=M,
-        )
-    # while and do-while loop
-    # https://stackoverflow.com/questions/71635459/how-to-use-keras-symbolic-inputs-with-tf-while-loop
-    elif M is None and cond_init is not None:
-        condition = lambda iter_cnt, cond, v, scan_outputs: tf.reduce_all(tf.equal(cond, True))
-        while_loop_layer = While_Loop_CustomLayer()
-        iter_cnt_final, cond_final, v_final, scan_outputs_final = while_loop_layer(
-            cond=condition,
-            body=run_subgraph,
-            loop_vars=[
-                iter_cnt_init,
-                cond_init,
-                v_init,
-                scan_outputs_init,
-            ],
-            shape_invariants=[
-                tf.TensorShape([]),
-                tf.TensorShape(None),
-                v_shapes,
-                scan_outputs_shapes,
-            ],
-        )
-    # combine for loop and while loop together
-    # https://stackoverflow.com/questions/71635459/how-to-use-keras-symbolic-inputs-with-tf-while-loop
-    elif M is not None and cond_init is not None:
-        condition = lambda iter_cnt, cond, v, scan_outputs: tf.reduce_all(tf.equal(cond, True))
-        while_loop_layer = While_Loop_CustomLayer()
-        iter_cnt_final, cond_final, v_final, scan_outputs_final = while_loop_layer(
-            cond=condition,
-            body=run_subgraph,
-            loop_vars=[
-                tf.constant(iter_cnt_init, dtype=iter_cnt_init.dtype),
-                cond_init,
-                v_init,
-                scan_outputs_init,
-            ],
-            shape_invariants=[
-                tf.TensorShape([]),
-                tf.TensorShape(None),
-                v_shapes,
-                scan_outputs_shapes,
-            ],
-            maximum_iterations=M,
-        )
-    # M is None and cond is None
-    else:
-        error(
-            f'Both M and cond in Loop are not set at the same time ' +
-            f'Tensorflow.(PS. if you want to create a do-while loop ' +
-            f'then please set cond to True or 1)\n' +
-            f'graph_node.name: {graph_node.name}'
-        )
-        sys.exit(1)
-
-
-    if scan_outputs_start_index == len(body.outputs):
-        # there is no scan_output in the body graph
-        tf_layers_dict[graph_node_output.name]['tf_node'] =  v_final
-
-    else:
-        def true_fn():
-            return scan_outputs_final
-
-        def false_fn():
-            new_scan_outputs = []
-            for i in range(scan_outputs_start_index, len(body.outputs)):
-                exp_elem_shape = scan_outputs_init[i-scan_outputs_start_index].element_shape
-            elem_shape = []
-            for j in range(exp_elem_shape.rank):
-                shape_j = 0 if exp_elem_shape[j] is None else exp_elem_shape[j]
-                elem_shape.append(shape_j)
-            new_scan_outputs.append(
-                tf.TensorArray(
-                    dtype=body.outputs[i].dtype,
-                    size=0,
-                    element_shape=tf.TensorShape(elem_shape)
-                )
-            )
-            return new_scan_outputs
-
-        scan_out_final = tf.cond(tf.greater(iter_cnt_final, 0), true_fn, false_fn)
-        scan_outputs_tensors = [o.stack() for o in scan_out_final]
-        tf_layers_dict[graph_node_output.name]['tf_node'] = v_final + scan_outputs_tensors
-
-    # Generation of Debug Info
-    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
-        make_tf_node_info(
-            node_info={
-                'tf_op_type': tf.while_loop,
-                'tf_inputs': {
-                    'condition': condition,
-                    'M': M,
-                    'cond': cond_init,
-                    'v_initial': v_init,
-                },
-                'tf_outputs': {
-                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
-                },
-            }
-        )