onnx2tf 1.29.12__py3-none-any.whl → 1.29.14__py3-none-any.whl

onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.12'
+__version__ = '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/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/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/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/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'] = \

onnx2tf/utils/common_functions.py

@@ -896,6 +896,19 @@ def explicit_broadcast(
     const_or_var_2: Any
         gs.Variable or np.ndarray
     """
+    def _tf_broadcastable(shape_a, shape_b):
+        if shape_a is None or shape_b is None:
+            return False
+        if len(shape_a) != len(shape_b):
+            return False
+        for dim_a, dim_b in zip(shape_a, shape_b):
+            if dim_a is None or dim_b is None:
+                continue
+            if dim_a == dim_b or dim_a == 1 or dim_b == 1:
+                continue
+            return False
+        return True
+
     graph_node_input_name1 = None
     graph_node_input_name2 = None
     graph_node_input_shape1 = []
@@ -928,6 +941,29 @@ def explicit_broadcast(
     if graph_node_input_shape1 is None or graph_node_input_shape2 is None:
         return const_or_var_1, const_or_var_2
 
+    # If one operand is 1D and matches the last dimension of the other operand,
+    # align it to the last axis to avoid unintended transpose.
+    if len(const_or_var_1.shape) == 1 and len(const_or_var_2.shape) > 1:
+        dim_1 = const_or_var_1.shape[0]
+        dim_2_last = const_or_var_2.shape[-1]
+        if isinstance(dim_1, int) and isinstance(dim_2_last, int) and dim_1 == dim_2_last:
+            target_shape = [1] * (len(const_or_var_2.shape) - 1) + [dim_1]
+            if isinstance(const_or_var_1, np.ndarray):
+                const_or_var_1 = const_or_var_1.reshape(target_shape)
+            else:
+                const_or_var_1 = tf.reshape(const_or_var_1, target_shape)
+            return const_or_var_1, const_or_var_2
+    if len(const_or_var_2.shape) == 1 and len(const_or_var_1.shape) > 1:
+        dim_2 = const_or_var_2.shape[0]
+        dim_1_last = const_or_var_1.shape[-1]
+        if isinstance(dim_2, int) and isinstance(dim_1_last, int) and dim_2 == dim_1_last:
+            target_shape = [1] * (len(const_or_var_1.shape) - 1) + [dim_2]
+            if isinstance(const_or_var_2, np.ndarray):
+                const_or_var_2 = const_or_var_2.reshape(target_shape)
+            else:
+                const_or_var_2 = tf.reshape(const_or_var_2, target_shape)
+            return const_or_var_1, const_or_var_2
+
     # If either operand have shape of all 1's, do not broadcast and return as is
     shape_for_judging_skip_processing_1 = [
         i if i is not None else INF_INDEX_VALUE for i in const_or_var_1.shape
@@ -2403,6 +2439,179 @@ def shape_unmatched_special_avoidance_workaround(
             return input_tensor_1, input_tensor_2
     except:
         pass
+
+    def _normalize_shape(shape):
+        if shape is None:
+            return None
+        return [dim if isinstance(dim, int) else None for dim in shape]
+
+    def _broadcastable(shape_a, shape_b):
+        if shape_a is None or shape_b is None:
+            return False
+        if len(shape_a) != len(shape_b):
+            return False
+        for dim_a, dim_b in zip(shape_a[::-1], shape_b[::-1]):
+            if dim_a is None or dim_b is None:
+                continue
+            if dim_a != dim_b and dim_a != 1 and dim_b != 1:
+                return False
+        return True
+
+    def _match_score(shape_a, shape_b):
+        score = 0
+        for dim_a, dim_b in zip(shape_a, shape_b):
+            if dim_a is None or dim_b is None:
+                continue
+            if dim_a == dim_b:
+                score += 1
+        return score
+
+    def _shape_matches(shape_a, shape_b):
+        if shape_a is None or shape_b is None:
+            return False
+        if len(shape_a) != len(shape_b):
+            return False
+        for dim_a, dim_b in zip(shape_a, shape_b):
+            if dim_a is None or dim_b is None:
+                continue
+            if dim_a != dim_b:
+                return False
+        return True
+
+    # Generic layout-alignment for channel-first/last in 3D/4D/5D.
+    # Try a small set of canonical perms and apply the best one if it makes broadcasting possible.
+    try:
+        if hasattr(input_tensor_1, "shape") and hasattr(input_tensor_2, "shape"):
+            input_shape_1 = _normalize_shape(input_tensor_1.shape)
+            input_shape_2 = _normalize_shape(input_tensor_2.shape)
+            if input_shape_1 is not None and input_shape_2 is not None \
+                and len(input_shape_1) == len(input_shape_2) \
+                and len(input_shape_1) in (3, 4, 5):
+                if not _broadcastable(input_shape_1, input_shape_2):
+                    rank = len(input_shape_1)
+                    perm_cf2cl = [0] + list(range(2, rank)) + [1]
+                    perm_cl2cf = [0, rank - 1] + list(range(1, rank - 1))
+                    perms = []
+                    if perm_cf2cl != list(range(rank)):
+                        perms.append(perm_cf2cl)
+                    if perm_cl2cf != list(range(rank)) and perm_cl2cf != perm_cf2cl:
+                        perms.append(perm_cl2cf)
+
+                    onnx_shape_1 = _normalize_shape(
+                        graph_node_input_1.shape if hasattr(graph_node_input_1, "shape") else None
+                    )
+                    onnx_shape_2 = _normalize_shape(
+                        graph_node_input_2.shape if hasattr(graph_node_input_2, "shape") else None
+                    )
+
+                    candidates = []
+                    for idx, (shape, other_shape) in enumerate(
+                        [(input_shape_1, input_shape_2), (input_shape_2, input_shape_1)]
+                    ):
+                        for perm in perms:
+                            permuted = [shape[p] for p in perm]
+                            if _broadcastable(permuted, other_shape):
+                                score = _match_score(permuted, other_shape)
+                                # Prefer transposing the input whose ONNX shape matches current layout.
+                                if idx == 0 and _shape_matches(onnx_shape_1, shape):
+                                    score += 2
+                                if idx == 1 and _shape_matches(onnx_shape_2, shape):
+                                    score += 2
+                                candidates.append((score, idx, perm))
+
+                    if candidates:
+                        candidates.sort(reverse=True)
+                        best_score, best_idx, best_perm = candidates[0]
+                        # Avoid ambiguous ties.
+                        if len(candidates) == 1 or best_score > candidates[1][0]:
+                            if best_idx == 0:
+                                input_tensor_1 = \
+                                    transpose_with_flexing_deterrence(
+                                        input_tensor=input_tensor_1,
+                                        perm=best_perm,
+                                        **kwargs,
+                                    )
+                            else:
+                                input_tensor_2 = \
+                                    transpose_with_flexing_deterrence(
+                                        input_tensor=input_tensor_2,
+                                        perm=best_perm,
+                                        **kwargs,
+                                    )
+    except Exception:
+        pass
+
+    # Heuristic for 3D tensors where one input is (N,1,C) and the other is (N,C,W).
+    # Align by transposing the (N,C,W) tensor to (N,W,C).
+    try:
+        if hasattr(input_tensor_1, "shape") and hasattr(input_tensor_2, "shape"):
+            s1 = list(input_tensor_1.shape)
+            s2 = list(input_tensor_2.shape)
+            if len(s1) == len(s2) == 3:
+                # Normalize unknown dims to None
+                s1 = [dim if isinstance(dim, int) else None for dim in s1]
+                s2 = [dim if isinstance(dim, int) else None for dim in s2]
+                if s1[1] == 1 and s1[2] is not None and s2[1] == s1[2]:
+                    input_tensor_2 = \
+                        transpose_with_flexing_deterrence(
+                            input_tensor=input_tensor_2,
+                            perm=[0, 2, 1],
+                            **kwargs,
+                        )
+                elif s2[1] == 1 and s2[2] is not None and s1[1] == s2[2]:
+                    input_tensor_1 = \
+                        transpose_with_flexing_deterrence(
+                            input_tensor=input_tensor_1,
+                            perm=[0, 2, 1],
+                            **kwargs,
+                        )
+    except Exception:
+        pass
+
+    # Layout mismatch mitigation based on ONNX shapes:
+    # If one input matches ONNX layout and the other matches the transposed layout,
+    # transpose the ONNX-layout input to align with the transposed one.
+    try:
+        if hasattr(input_tensor_1, "shape") and hasattr(input_tensor_2, "shape"):
+            input_shape_1 = list(input_tensor_1.shape)
+            input_shape_2 = list(input_tensor_2.shape)
+            if len(input_shape_1) == len(input_shape_2) and len(input_shape_1) in (3, 4, 5):
+                onnx_shape_1 = None
+                onnx_shape_2 = None
+                if hasattr(graph_node_input_1, "shape") and graph_node_input_1.shape is not None:
+                    onnx_shape_1 = [
+                        dim if not isinstance(dim, str) else None for dim in graph_node_input_1.shape
+                    ]
+                if hasattr(graph_node_input_2, "shape") and graph_node_input_2.shape is not None:
+                    onnx_shape_2 = [
+                        dim if not isinstance(dim, str) else None for dim in graph_node_input_2.shape
+                    ]
+                if onnx_shape_1 is not None and onnx_shape_2 is not None:
+                    perm = [0] + list(range(2, len(input_shape_1))) + [1]
+                    permuted_onnx_shape_1 = [onnx_shape_1[p] for p in perm]
+                    permuted_onnx_shape_2 = [onnx_shape_2[p] for p in perm]
+
+                    in1_matches_onnx = _shape_matches(input_shape_1, onnx_shape_1)
+                    in1_matches_perm = _shape_matches(input_shape_1, permuted_onnx_shape_1)
+                    in2_matches_onnx = _shape_matches(input_shape_2, onnx_shape_2)
+                    in2_matches_perm = _shape_matches(input_shape_2, permuted_onnx_shape_2)
+
+                    if in1_matches_perm and in2_matches_onnx and not in2_matches_perm:
+                        input_tensor_2 = \
+                            transpose_with_flexing_deterrence(
+                                input_tensor=input_tensor_2,
+                                perm=perm,
+                                **kwargs,
+                            )
+                    elif in2_matches_perm and in1_matches_onnx and not in1_matches_perm:
+                        input_tensor_1 = \
+                            transpose_with_flexing_deterrence(
+                                input_tensor=input_tensor_1,
+                                perm=perm,
+                                **kwargs,
+                            )
+    except Exception:
+        pass
     # At least one True value for same_input_shape_as_onnx
     # At least one True value in nhwc_flags
     # same_input_shape_as_onnx == True and nhwc_flags == False and 3D or 4D or 5D tensor is NHWC transposed
@@ -3642,6 +3851,7 @@ def dummy_onnx_inference(
     enable_ort_output_memmap: bool = False,
     ort_output_memmap_dir: Optional[str] = None,
     shape_hints: Optional[List[str]] = None,
+    input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
 ) -> List[np.ndarray]:
     """Perform inference on ONNX subgraphs with an all-1 dummy tensor.
 
@@ -3678,6 +3888,9 @@ def dummy_onnx_inference(
         Directory to store memmap files. If not specified, a temporary
         directory is created and removed on exit.
 
+    input_datas_for_validation: Optional[Dict[str, np.ndarray]]
+        Optional dict to be filled with the input tensors used for inference.
+
     Returns
     ----------
     outputs: List[np.ndarray]
@@ -3873,6 +4086,9 @@ def dummy_onnx_inference(
                         perm=[0,3,1,2],
                     ).numpy().astype(input_dtype)
 
+    if input_datas_for_validation is not None:
+        input_datas_for_validation.update(input_datas)
+
     dtype_sizes = {
         np.dtype('float16'): 2,
         np.dtype('float32'): 4,
@@ -4014,6 +4230,7 @@ def dummy_tf_inference(
     verification_datas: Optional[List[np.ndarray]] = None,
     custom_input_op_name_np_data_path: Optional[str] = None,
     shape_hints: Optional[List[str]] = None,
+    input_datas_for_validation: Optional[Dict[str, np.ndarray]] = None,
     keep_shape_absolutely_input_names: Optional[List[str]] = None,
     keep_ncw_or_nchw_or_ncdhw_input_names: Optional[List[str]] = None,
     keep_nwc_or_nhwc_or_ndhwc_input_names: Optional[List[str]] = None,
@@ -4036,6 +4253,8 @@ def dummy_tf_inference(
 
     custom_input_op_name_np_data_path
         Path to Numpy file for custom data used for dummy inference
+    input_datas_for_validation: Optional[Dict[str, np.ndarray]]
+        Optional dict to be filled with the input tensors used for inference.
 
     Returns
     ----------
@@ -4174,6 +4393,10 @@ def dummy_tf_inference(
                         input_size,
                         dtype=TF_DTYPES_TO_NUMPY_DTYPES[input_dtype],
                     )
+
+    if input_datas_for_validation is not None:
+        input_datas_for_validation.update(input_datas)
+
     outputs = model(
         inputs={
             input.name: input_datas[input.name] for input in inputs

{onnx2tf-1.29.12.dist-info → onnx2tf-1.29.14.dist-info}/METADATA

@@ -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.dist-info → onnx2tf-1.29.14.dist-info}/RECORD

@@ -1,6 +1,6 @@
-onnx2tf/__init__.py,sha256=89EgFjqomm_s1GTO1Is-NN_4IBNeGFXu31Zcmotmbes,67
+onnx2tf/__init__.py,sha256=8dbSscURHL1ncvasA8yz2hU36oshMnPpVm9IcPYu_Vc,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
-onnx2tf/onnx2tf.py,sha256=yR8aKaEn01Q8dEeYDqHIsuZuG6l5TGQniHDlPiUROx4,152238
+onnx2tf/onnx2tf.py,sha256=O3B_ME8omswggw4xtjxxnC8_uaPHH3Ly8dwSv7w75no,157060
 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
@@ -14,7 +14,7 @@ onnx2tf/ops/Asinh.py,sha256=74ZzTEkpxZY4CGfJT2JJU-SHXYL5KZeUkWY2v7hsMMw,3588
 onnx2tf/ops/Atan.py,sha256=D24XDMxEwXFtJheQAr3V3IWOUOc6Q5M0-b_83bmGGMM,3981
 onnx2tf/ops/Atanh.py,sha256=VsUYopBWWPoo4gta1_aqvUL6NrVXuVkGid4SqDqYJ9Q,3588
 onnx2tf/ops/Attention.py,sha256=7TMOdPztVLtNKSzeozvaRxhUFVhACci8wvhn7ONKWrQ,21006
-onnx2tf/ops/AveragePool.py,sha256=kifQJZplqC2Px209BotbjXCPpRBQQsB8DlJYJTvJD78,20065
+onnx2tf/ops/AveragePool.py,sha256=3pf-DKS76aU1BR8jafOBbfpzkNWop9cHQSZVQjbecdY,22144
 onnx2tf/ops/BatchNormalization.py,sha256=_hlf2-5-j3MCJHEoE2oMNQ8YhCm7ad9h2fwPpTo3i7g,26624
 onnx2tf/ops/Bernoulli.py,sha256=PM0xS0n1q4bnT_9PnbcKW8_Qj8dJYYBQR8kb2X-wIp4,3670
 onnx2tf/ops/BitShift.py,sha256=a28_E9hwA8yfjvtsrSKCZCeeMPB5RBQbjB3cmaNGN6k,3861
@@ -51,9 +51,9 @@ onnx2tf/ops/Elu.py,sha256=VDd5cKc1h-8nd0bVwWR_CkgfomrBl4NMbjRtAvkoNks,4025
 onnx2tf/ops/Equal.py,sha256=ni0gf7nJex8S-oG61bnHc_xn8LuMits3gM6IzGNT65w,4579
 onnx2tf/ops/Erf.py,sha256=ayvSp8Pr9h-VYuIiMorwOC0r9aQ4i4S1Uvaho9R6PYo,4962
 onnx2tf/ops/Exp.py,sha256=MM_Osse7UbJgld2u0fGMcjniJCs40uDztuOodVUqWMU,3583
-onnx2tf/ops/Expand.py,sha256=MGsby7IhTqKv1K-1INQPHcI5l3Wx-jjJ1FnulpCZsag,14761
+onnx2tf/ops/Expand.py,sha256=u_LrCaWqb-Pdz2F8yWJUFx-E_SNE888pPmHP4-HGx2M,15339
 onnx2tf/ops/EyeLike.py,sha256=VHRlr_WpIGVpZSqfjN7zWQF6XT2KjNVJnjVccxB4P6U,5877
-onnx2tf/ops/Flatten.py,sha256=q5mhKynr3-HVEVih-vcFiFj26Whqi0WSSNn6ckdr0Ac,6556
+onnx2tf/ops/Flatten.py,sha256=RZZJF8RnZaUf_jCEdTgLppPa6FoeM7BLxHrIkHv1t5c,10292
 onnx2tf/ops/Floor.py,sha256=8izJrNmw8wNmjF_YabIpLs4jm82J-gKcyAQbwV7Yqpc,3589
 onnx2tf/ops/FusedConv.py,sha256=gslI50V3yvt4l0mmodnyHFAu0cORx1J_ZL5cE0rZ8qs,4523
 onnx2tf/ops/GRU.py,sha256=kBHiZlhlPIV2DQCoFYFHxCTwOATeguJy1MSfj2kxqDM,30732
@@ -168,7 +168,7 @@ onnx2tf/ops/Sign.py,sha256=rJNyo_YTLO5x4yoF_Z_wpaIX4dSOL-vdmKH0SbVDwJc,3585
 onnx2tf/ops/Sin.py,sha256=jrv76uQPIfB7UdLGf42MOlRUPM6fQ3GR6BvSybpptFo,3608
 onnx2tf/ops/Sinh.py,sha256=9zXIQWcZiZmu3RnQuQpW-PEgBLOKY51SY0OBu1B5eh8,3706
 onnx2tf/ops/Size.py,sha256=vFD5eae9Jko3tHbBtydj2d3T3tbb4r0xua7OIH40p9M,2665
-onnx2tf/ops/Slice.py,sha256=6V1r1Dugra5qhrByHH6aDf_0KfrPSpwJYkxTGO7H44M,25046
+onnx2tf/ops/Slice.py,sha256=ChqpC_l-c32aZzI7o2GP7SyRz142Gwo0ctc75nkXFvE,26788
 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
@@ -194,12 +194,12 @@ onnx2tf/ops/Where.py,sha256=MaCcY9g4mKZQqCgh4xtoylicP-xVu9f4boKiu_q9Ow8,7711
 onnx2tf/ops/Xor.py,sha256=2ceqxHSI1Wtez_CIh8gFfvcu45Xboqfyp1iy3v2vuIs,4590
 onnx2tf/ops/__init__.py,sha256=jnmUWWa-3dHzBZV9bmPzXu6eoz2dumJTzO7i8JdcgSM,25
 onnx2tf/utils/__init__.py,sha256=E9FM9He68VIASDnYp-OrxvHFVn55GzWqw2OEkCqn1zg,27
-onnx2tf/utils/common_functions.py,sha256=TWb_e6i2MjB7C4eh1FWHTIDVlr6-7NgSNcCKwKGhGg8,249765
+onnx2tf/utils/common_functions.py,sha256=j8bRC3RK5NlNAV9vwxj38DwDaaCLR2iprRdDjBgv_RA,260619
 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.12.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
-onnx2tf-1.29.12.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
-onnx2tf-1.29.12.dist-info/METADATA,sha256=Ddf7-_nYlEjEOlH3taykx6G5ULbARSgF7cuFlj7HD_0,154193
-onnx2tf-1.29.12.dist-info/RECORD,,
+onnx2tf-1.29.14.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+onnx2tf-1.29.14.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.14.dist-info/METADATA,sha256=TT-jjFuqKAE7Tyt9Crx-og515ebykFCODKhYQ-8T-x0,154244
+onnx2tf-1.29.14.dist-info/RECORD,,