onnx2tf 1.29.12__tar.gz → 1.29.14__tar.gz

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.12
+Version: 1.29.14
 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
@@ -13,6 +13,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: requests==2.32.5
@@ -363,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.12
+  ghcr.io/pinto0309/onnx2tf:1.29.14
 
   or
 
@@ -371,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.12
+  docker.io/pinto0309/onnx2tf:1.29.14
 
   or
 

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/README.md

@@ -322,7 +322,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.12
+  ghcr.io/pinto0309/onnx2tf:1.29.14
 
   or
 
@@ -330,7 +330,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.12
+  docker.io/pinto0309/onnx2tf:1.29.14
 
   or
 

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.12'
+__version__ = '1.29.14'

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/onnx2tf.py

@@ -62,6 +62,73 @@ from onnx2tf.utils.enums import (
 from onnx2tf.utils.logging import *
 from sng4onnx import generate as op_name_auto_generate
 
+def apply_nonzero_passthrough(
+    *,
+    graph: gs.Graph,
+    onnx_tensor_infos: Optional[Dict[str, np.ndarray]],
+    onnx_input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
+    update_graph_shape: bool = False,
+) -> None:
+    if onnx_tensor_infos is None:
+        return
+    for graph_node in graph.nodes:
+        if graph_node.op != 'NonZero':
+            continue
+        if len(graph_node.inputs) == 0 or len(graph_node.outputs) == 0:
+            continue
+        nonzero_input = graph_node.inputs[0]
+        nonzero_output = graph_node.outputs[0]
+        passthrough_tensor = None
+        input_name = nonzero_input.name
+
+        if input_name in onnx_tensor_infos:
+            passthrough_tensor = onnx_tensor_infos[input_name]
+        elif onnx_input_datas_for_validation and input_name in onnx_input_datas_for_validation:
+            passthrough_tensor = onnx_input_datas_for_validation[input_name]
+        elif hasattr(nonzero_input, 'values'):
+            passthrough_tensor = nonzero_input.values
+
+        if passthrough_tensor is not None:
+            onnx_tensor_infos[nonzero_output.name] = passthrough_tensor
+            if update_graph_shape and hasattr(passthrough_tensor, 'shape'):
+                nonzero_output.shape = list(passthrough_tensor.shape)
+
+def apply_nonzero_passthrough_tf(
+    *,
+    graph: gs.Graph,
+    tf_layers_dict: Dict[str, Any],
+    tf_tensor_infos: Optional[Dict[str, np.ndarray]],
+    tf_input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
+) -> None:
+    if tf_tensor_infos is None:
+        return
+    for graph_node in graph.nodes:
+        if graph_node.op != 'NonZero':
+            continue
+        if len(graph_node.inputs) == 0 or len(graph_node.outputs) == 0:
+            continue
+        input_name = graph_node.inputs[0].name
+        output_name = graph_node.outputs[0].name
+        input_info = tf_layers_dict.get(input_name)
+        output_info = tf_layers_dict.get(output_name)
+        if input_info is None or output_info is None:
+            continue
+        input_tf_node = input_info.get('tf_node')
+        output_tf_node = output_info.get('tf_node')
+        if input_tf_node is None or output_tf_node is None:
+            continue
+        input_tf_name = input_tf_node.name
+        output_tf_name = output_tf_node.name
+        passthrough_tensor = None
+
+        if input_tf_name in tf_tensor_infos:
+            passthrough_tensor = tf_tensor_infos[input_tf_name]
+        elif tf_input_datas_for_validation and input_tf_name in tf_input_datas_for_validation:
+            passthrough_tensor = tf_input_datas_for_validation[input_tf_name]
+
+        if passthrough_tensor is not None:
+            tf_tensor_infos[output_tf_name] = passthrough_tensor
+
 def convert(
     input_onnx_file_path: Optional[str] = '',
     onnx_graph: Optional[onnx.ModelProto] = None,
@@ -1113,6 +1180,7 @@ def convert(
         # Used to verify the output error of each OP in the TensorFlow model.
         full_ops_output_names = []
         onnx_tensor_infos_for_validation = None
+        onnx_input_datas_for_validation = {}
         for graph_node in graph.nodes:
             full_ops_output_names_sub = []
             for graph_node_output in graph_node.outputs:
@@ -1132,6 +1200,7 @@ def convert(
                     enable_ort_output_memmap=onnxruntime_output_memmap,
                     ort_output_memmap_dir=onnxruntime_output_memmap_dir,
                     shape_hints=shape_hints if (check_onnx_tf_outputs_elementwise_close or check_onnx_tf_outputs_elementwise_close_full) else None,
+                    input_datas_for_validation=onnx_input_datas_for_validation,
                 )
             """
             onnx_tensor_infos_for_validation:
@@ -1148,12 +1217,20 @@ def convert(
                         in zip(full_ops_output_names, onnx_outputs_for_validation)
             }
             del onnx_outputs_for_validation
+
+            apply_nonzero_passthrough(
+                graph=graph,
+                onnx_tensor_infos=onnx_tensor_infos_for_validation,
+                onnx_input_datas_for_validation=onnx_input_datas_for_validation,
+                update_graph_shape=True,
+            )
         except Exception as ex:
             warn(
                 f'The optimization process for shape estimation is skipped ' +
                 f'because it contains OPs that cannot be inferred by the standard onnxruntime.'
             )
             warn(f'{ex}')
+            onnx_input_datas_for_validation = None
         additional_parameters['onnx_tensor_infos_for_validation'] = onnx_tensor_infos_for_validation
         additional_parameters['test_data_nhwc'] = test_data_nhwc
         additional_parameters['custom_input_op_name_np_data_path'] = custom_input_op_name_np_data_path
@@ -2061,6 +2138,7 @@ def convert(
             dummy_onnx_outputs = None
             try:
                 # ONNX dummy inference
+                onnx_input_datas_for_validation = {}
                 dummy_onnx_outputs: List[np.ndarray] = \
                     dummy_onnx_inference(
                         onnx_graph=onnx_graph,
@@ -2072,6 +2150,7 @@ def convert(
                         enable_ort_output_memmap=onnxruntime_output_memmap,
                         ort_output_memmap_dir=onnxruntime_output_memmap_dir,
                         shape_hints=shape_hints,
+                        input_datas_for_validation=onnx_input_datas_for_validation,
                     )
             except Exception as ex:
                 warn(
@@ -2081,6 +2160,7 @@ def convert(
                 warn(f'{ex}')
             else:
                 # TF dummy inference
+                tf_input_datas_for_validation = {}
                 tf_tensor_infos: Dict[Any] = \
                     dummy_tf_inference(
                         model=model,
@@ -2088,6 +2168,7 @@ def convert(
                         test_data_nhwc=test_data_nhwc,
                         custom_input_op_name_np_data_path=custom_input_op_name_np_data_path,
                         shape_hints=shape_hints,
+                        input_datas_for_validation=tf_input_datas_for_validation,
                         keep_shape_absolutely_input_names=keep_shape_absolutely_input_names,
                         keep_ncw_or_nchw_or_ncdhw_input_names=keep_ncw_or_nchw_or_ncdhw_input_names,
                         keep_nwc_or_nhwc_or_ndhwc_input_names=keep_nwc_or_nhwc_or_ndhwc_input_names,
@@ -2097,6 +2178,17 @@ def convert(
                     output_name: dummy_onnx_output \
                         for output_name, dummy_onnx_output in zip(ops_output_names, dummy_onnx_outputs)
                 }
+                apply_nonzero_passthrough(
+                    graph=graph,
+                    onnx_tensor_infos=onnx_tensor_infos,
+                    onnx_input_datas_for_validation=onnx_input_datas_for_validation,
+                )
+                apply_nonzero_passthrough_tf(
+                    graph=graph,
+                    tf_layers_dict=tf_layers_dict,
+                    tf_tensor_infos=tf_tensor_infos,
+                    tf_input_datas_for_validation=tf_input_datas_for_validation,
+                )
                 """
                 np.allclose(
                     dummy_onnx_outputs,
@@ -2326,6 +2418,7 @@ def convert(
                 # Initial accuracy check
                 try:
                     # ONNX dummy inference
+                    onnx_input_datas_for_validation = {}
                     dummy_onnx_outputs: List[np.ndarray] = \
                         dummy_onnx_inference(
                             onnx_graph=onnx_graph,
@@ -2337,9 +2430,11 @@ def convert(
                             enable_ort_output_memmap=onnxruntime_output_memmap,
                             ort_output_memmap_dir=onnxruntime_output_memmap_dir,
                             shape_hints=shape_hints,
+                            input_datas_for_validation=onnx_input_datas_for_validation,
                         )
 
                     # TF dummy inference
+                    tf_input_datas_for_validation = {}
                     tf_tensor_infos: Dict[Any] = \
                         dummy_tf_inference(
                             model=validation_model,
@@ -2347,6 +2442,7 @@ def convert(
                             test_data_nhwc=test_data_nhwc,
                             custom_input_op_name_np_data_path=custom_input_op_name_np_data_path,
                             shape_hints=shape_hints,
+                            input_datas_for_validation=tf_input_datas_for_validation,
                             keep_shape_absolutely_input_names=keep_shape_absolutely_input_names,
                             keep_ncw_or_nchw_or_ncdhw_input_names=keep_ncw_or_nchw_or_ncdhw_input_names,
                             keep_nwc_or_nhwc_or_ndhwc_input_names=keep_nwc_or_nhwc_or_ndhwc_input_names,
@@ -2357,6 +2453,17 @@ def convert(
                         output_name: dummy_onnx_output \
                             for output_name, dummy_onnx_output in zip(ops_output_names, dummy_onnx_outputs)
                     }
+                    apply_nonzero_passthrough(
+                        graph=graph,
+                        onnx_tensor_infos=onnx_tensor_infos,
+                        onnx_input_datas_for_validation=onnx_input_datas_for_validation,
+                    )
+                    apply_nonzero_passthrough_tf(
+                        graph=graph,
+                        tf_layers_dict=tf_layers_dict,
+                        tf_tensor_infos=tf_tensor_infos,
+                        tf_input_datas_for_validation=tf_input_datas_for_validation,
+                    )
 
                     input_names = [k.name for k in inputs]
                     for k, v in tf_layers_dict.items():

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/ops/AveragePool.py

@@ -370,6 +370,12 @@ def make_node(
                 paddings=tf_pads,
                 mode='CONSTANT',
             )
+            if input_tensor_shape is not None and len(input_tensor_shape) == spatial_size + 2:
+                # Preserve known batch/channel dims since dynamic paddings erase shape info.
+                padded_tensor = tf.ensure_shape(
+                    padded_tensor,
+                    [input_tensor_shape[0]] + [None] * spatial_size + [input_tensor_shape[-1]],
+                )
         else:
             if auto_pad == 'SAME_LOWER':
                 # switch the order of pads
@@ -468,6 +474,49 @@ def make_node(
         print(error_msg)
         raise AssertionError(error_msg)
 
+    # Dynamic shape compensation for count_include_pad=False with explicit padding.
+    # Use pooled mask to compute valid element counts per window.
+    if not is_known_shape and is_explicit_padding and not count_include_pad:
+        mask = tf.ones_like(input_tensor, dtype=pooled_tensor.dtype)
+        if tf_pads is not None:
+            if tf.is_tensor(tf_pads):
+                mask = tf.pad(
+                    tensor=mask,
+                    paddings=tf_pads,
+                    mode='CONSTANT',
+                )
+            elif tf_pads != [0] * spatial_size * 2:
+                mask = tf.pad(
+                    tensor=mask,
+                    paddings=tf_pads,
+                    mode='CONSTANT',
+                )
+        if len(kernel_shape) == 1:
+            mask_pooled = AveragePooling1D(
+                pool_size=kernel_shape,
+                strides=strides,
+                padding=tf_pad_mode.upper(),
+            )(mask)
+        elif len(kernel_shape) == 2:
+            mask_pooled = AveragePooling2D(
+                pool_size=kernel_shape,
+                strides=strides,
+                padding=tf_pad_mode.upper(),
+            )(mask)
+        else:
+            mask_pooled = AveragePooling3D(
+                pool_size=kernel_shape,
+                strides=strides,
+                padding=tf_pad_mode.upper(),
+            )(mask)
+        kernel_volume = float(np.prod(kernel_shape))
+        count_valid = mask_pooled * tf.cast(kernel_volume, dtype=mask_pooled.dtype)
+        multiplier = tf.math.divide_no_nan(
+            tf.cast(kernel_volume, dtype=mask_pooled.dtype),
+            count_valid,
+        )
+        pooled_tensor = pooled_tensor * multiplier
+
     # tensorflow average pooling needs extra process to get same output with onnx
     # https://github.com/PINTO0309/onnx2tf/issues/124
     if average_multiplier is not None:

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/ops/Expand.py

@@ -48,6 +48,7 @@ def make_node(
         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)
+    # Data layout follows input[0]; shape vector (input[1]) should align to it.
     before_op_output_shape_trans = \
         before_op_output_shape_trans_1 \
         and before_op_output_shape_trans_2
@@ -58,7 +59,7 @@ def make_node(
     )
     graph_node_input_2 = get_constant_or_variable(
         graph_node.inputs[1],
-        before_op_output_shape_trans,
+        before_op_output_shape_trans_1,
     )
     graph_node_output: gs.Variable = graph_node.outputs[0]
     shape = graph_node_output.shape
@@ -106,6 +107,16 @@ def make_node(
         **kwargs,
     )
 
+    # If shape is dynamic (Tensor) and input was transposed to NHWC/NWC/NDHWC,
+    # align the shape vector order to TensorFlow's layout.
+    if before_op_output_shape_trans_1 \
+        and tf.is_tensor(input_tensor_shape) \
+        and input_tensor_rank > 2:
+        shape_rank = input_tensor_shape.shape.rank
+        if shape_rank == 1 or shape_rank is None:
+            perm = [0] + list(range(2, input_tensor_rank)) + [1]
+            input_tensor_shape = tf.gather(input_tensor_shape, perm)
+
     tf_type = None
     if \
         (

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/ops/Flatten.py

@@ -1,6 +1,7 @@
 import random
 random.seed(0)
 import numpy as np
+import itertools
 np.random.seed(0)
 import tensorflow as tf
 import tf_keras
@@ -13,6 +14,8 @@ from onnx2tf.utils.common_functions import (
     print_node_info,
     inverted_operation_enable_disable,
     make_tf_node_info,
+    dummy_tf_inference,
+    get_tf_model_inputs,
     pre_process_transpose,
     post_process_transpose,
     transpose_with_flexing_deterrence,
@@ -84,6 +87,109 @@ def make_node(
         **kwargs,
     )
 
+    # Param replacement
+    input_tensor = replace_parameter(
+        value_before_replacement=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    perm = [
+        convert_axis(
+            axis=idx,
+            tensor_rank=input_tensor_rank,
+            before_op_output_shape_trans=before_op_output_shape_trans,
+        ) for idx in range(input_tensor_rank)
+    ]
+
+    # Brute-force transpose to match ONNX dummy inference outputs when available.
+    onnx_tensor_infos_for_validation = kwargs.get('onnx_tensor_infos_for_validation', None)
+    test_data_nhwc: np.ndarray = kwargs.get('test_data_nhwc', None)
+    custom_input_op_name_np_data_path: str = kwargs.get('custom_input_op_name_np_data_path', None)
+    disable_strict_mode: bool = kwargs.get('disable_strict_mode', False)
+    if not disable_strict_mode \
+        and onnx_tensor_infos_for_validation is not None \
+        and onnx_tensor_infos_for_validation.get(graph_node_output.name, None) is not None:
+        validation_input = None
+        if isinstance(input_tensor, np.ndarray):
+            validation_input = input_tensor
+        elif hasattr(input_tensor, 'numpy'):
+            try:
+                validation_input = input_tensor.numpy()
+            except Exception:
+                validation_input = None
+        else:
+            try:
+                tf_model_inputs = get_tf_model_inputs(tf_layers_dict=tf_layers_dict)
+                val_model = tf_keras.Model(
+                    inputs=tf_model_inputs,
+                    outputs=[input_tensor],
+                )
+                tf_pre_tensor_infos = dummy_tf_inference(
+                    model=val_model,
+                    inputs=tf_model_inputs,
+                    test_data_nhwc=test_data_nhwc,
+                    custom_input_op_name_np_data_path=custom_input_op_name_np_data_path,
+                )
+                if len(tf_pre_tensor_infos) >= 1:
+                    validation_input = list(tf_pre_tensor_infos.values())[0]
+                del val_model
+            except Exception:
+                validation_input = None
+        if validation_input is None:
+            onnx_input_name = graph_node.inputs[0].name
+            if onnx_tensor_infos_for_validation.get(onnx_input_name, None) is not None:
+                validation_input = onnx_tensor_infos_for_validation[onnx_input_name]
+
+        onnx_output = onnx_tensor_infos_for_validation.get(graph_node_output.name, None)
+        if validation_input is not None and onnx_output is not None:
+            rank = len(validation_input.shape)
+            if rank <= 6:
+                perm_candidates = itertools.permutations(range(rank))
+            else:
+                perm_candidates = [perm]
+
+            def _flatten_np(arr, axis):
+                if axis == 0:
+                    return arr.reshape(1, -1)
+                if axis >= arr.ndim:
+                    return arr.reshape(-1, 1)
+                return arr.reshape(
+                    int(np.prod(arr.shape[:axis])),
+                    int(np.prod(arr.shape[axis:])),
+                )
+
+            matched_perm = None
+            matched_axis = None
+            for cand in perm_candidates:
+                try:
+                    cand_arr = np.transpose(validation_input, cand)
+                    for axis_candidate in range(0, rank + 1):
+                        cand_flat = _flatten_np(cand_arr, axis_candidate)
+                        if cand_flat.shape != onnx_output.shape:
+                            continue
+                        if np.allclose(cand_flat, onnx_output, rtol=0.0, atol=0.0, equal_nan=True):
+                            matched_perm = list(cand)
+                            matched_axis = axis_candidate
+                            break
+                    if matched_perm is not None:
+                        break
+                except Exception:
+                    continue
+            if matched_perm is not None:
+                perm = matched_perm
+                if matched_axis is not None:
+                    axis = matched_axis
+
     # Generation of TF OP
     cal_shape = None
     if axis == 0:
@@ -134,30 +240,6 @@ def make_node(
         has_str_outputshape = True in [True for dim in output_shape if isinstance(dim, str)]
         has_undefined_outputshape = has_none_outputshape or has_str_outputshape
     cal_shape = cal_shape if has_undefined_outputshape else output_shape
-
-    # Param replacement
-    input_tensor = replace_parameter(
-        value_before_replacement=input_tensor,
-        param_target='inputs',
-        param_name=graph_node.inputs[0].name,
-        **kwargs,
-    )
-
-    # Pre-process transpose
-    input_tensor = pre_process_transpose(
-        value_before_transpose=input_tensor,
-        param_target='inputs',
-        param_name=graph_node.inputs[0].name,
-        **kwargs,
-    )
-
-    perm = [
-        convert_axis(
-            axis=idx,
-            tensor_rank=input_tensor_rank,
-            before_op_output_shape_trans=before_op_output_shape_trans,
-        ) for idx in range(input_tensor_rank)
-    ]
     input_tensor = transpose_with_flexing_deterrence(
         input_tensor=input_tensor,
         perm=list(perm) if perm is not None else None,

{onnx2tf-1.29.12 → onnx2tf-1.29.14}/onnx2tf/ops/Slice.py

@@ -434,7 +434,23 @@ def make_node(
                 dtype=tf.int32,
             )
             if hasattr(begin_mask_, '_inferred_value') and begin_mask_._inferred_value == [None]:
-                begin_mask_ = 0
+                axes_list = None
+                if axes is not None:
+                    if isinstance(axes, (list, tuple)):
+                        axes_list = list(axes)
+                    elif isinstance(axes, np.ndarray):
+                        axes_list = axes.tolist() if axes.ndim > 0 else [int(axes)]
+                    elif tf.is_tensor(axes):
+                        if hasattr(axes, 'numpy'):
+                            axes_list = axes.numpy().tolist()
+                        elif hasattr(axes, '_inferred_value') and axes._inferred_value not in (None, [None]):
+                            axes_list = list(axes._inferred_value)
+                if axes_list is not None:
+                    begin_mask_ = sum(
+                        1 << axis for axis in range(input_tensor_rank) if axis not in axes_list
+                    )
+                else:
+                    begin_mask_ = 0
 
             ##### end_mask
             end_bit_mask = tf.constant([2**idx for idx in range(input_tensor_rank)], dtype=tf.int32)
@@ -446,7 +462,23 @@ def make_node(
                 dtype=tf.int32,
             )
             if hasattr(end_mask_, '_inferred_value') and end_mask_._inferred_value == [None]:
-                end_mask_ = 0
+                axes_list = None
+                if axes is not None:
+                    if isinstance(axes, (list, tuple)):
+                        axes_list = list(axes)
+                    elif isinstance(axes, np.ndarray):
+                        axes_list = axes.tolist() if axes.ndim > 0 else [int(axes)]
+                    elif tf.is_tensor(axes):
+                        if hasattr(axes, 'numpy'):
+                            axes_list = axes.numpy().tolist()
+                        elif hasattr(axes, '_inferred_value') and axes._inferred_value not in (None, [None]):
+                            axes_list = list(axes._inferred_value)
+                if axes_list is not None:
+                    end_mask_ = sum(
+                        1 << axis for axis in range(input_tensor_rank) if axis not in axes_list
+                    )
+                else:
+                    end_mask_ = 0
 
             # strided_slice
             tf_layers_dict[graph_node_output.name]['tf_node'] = \