onnx2tf 1.29.11__tar.gz → 1.29.13__tar.gz

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.11
+Version: 1.29.13
 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.11
+  ghcr.io/pinto0309/onnx2tf:1.29.13
 
   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.11
+  docker.io/pinto0309/onnx2tf:1.29.13
 
   or
 

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/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.11
+  ghcr.io/pinto0309/onnx2tf:1.29.13
 
   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.11
+  docker.io/pinto0309/onnx2tf:1.29.13
 
   or
 

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.11'
+__version__ = '1.29.13'

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/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.11 → onnx2tf-1.29.13}/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.11 → onnx2tf-1.29.13}/onnx2tf/ops/MatMul.py

@@ -444,19 +444,68 @@ def make_node(
         onnx_output_shape = [
             dim if not isinstance(dim, str) else None for dim in onnx_output_shape
         ]
+
+        def _shape_match(a_shape, b_shape):
+            if len(a_shape) != len(b_shape):
+                return False
+            for a_dim, b_dim in zip(a_shape, b_shape):
+                if a_dim is None or b_dim is None:
+                    continue
+                if a_dim != b_dim:
+                    return False
+            return True
+
+        # Squeeze unit dims if ONNX output rank is smaller.
+        if len(post_matmul_shape) > len(onnx_output_shape):
+            squeeze_axes = []
+            tmp_shape = list(post_matmul_shape)
+            while len(tmp_shape) > len(onnx_output_shape) and tmp_shape[-1] == 1:
+                squeeze_axes.append(len(tmp_shape) - 1)
+                tmp_shape.pop()
+            if squeeze_axes and len(tmp_shape) == len(onnx_output_shape) \
+                and _shape_match(tmp_shape, onnx_output_shape):
+                tf_layers_dict[graph_node_output.name]['tf_node'] = \
+                    tf.squeeze(
+                        input=tf_layers_dict[graph_node_output.name]['tf_node'],
+                        axis=squeeze_axes,
+                    )
+                post_matmul_shape = list(tf_layers_dict[graph_node_output.name]['tf_node'].shape)
+                post_matmul_shape_none_count = sum(
+                    [1 if dim is None else 0 for dim in post_matmul_shape]
+                )
+            else:
+                leading_ones = 0
+                tmp_shape = list(post_matmul_shape)
+                while len(tmp_shape) > len(onnx_output_shape) and tmp_shape and tmp_shape[0] == 1:
+                    leading_ones += 1
+                    tmp_shape.pop(0)
+                if leading_ones and len(tmp_shape) == len(onnx_output_shape) \
+                    and _shape_match(tmp_shape, onnx_output_shape):
+                    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+                        tf.squeeze(
+                            input=tf_layers_dict[graph_node_output.name]['tf_node'],
+                            axis=list(range(leading_ones)),
+                        )
+                    post_matmul_shape = list(tf_layers_dict[graph_node_output.name]['tf_node'].shape)
+                    post_matmul_shape_none_count = sum(
+                        [1 if dim is None else 0 for dim in post_matmul_shape]
+                    )
+
         onnx_output_shape_none_count = sum([1 if dim is None else 0 for dim in onnx_output_shape])
-        if post_matmul_shape_none_count == onnx_output_shape_none_count:
+        if post_matmul_shape_none_count == onnx_output_shape_none_count \
+            and post_matmul_shape != list(onnx_output_shape):
             post_transpose_perm = []
             for dim in onnx_output_shape:
                 idx = post_matmul_shape.index(dim)
                 post_transpose_perm.append(idx)
                 post_matmul_shape[idx] = -999
 
-            tf_layers_dict[graph_node_output.name]['tf_node'] = \
-                tf.transpose(
-                    a=tf_layers_dict[graph_node_output.name]['tf_node'],
-                    perm=post_transpose_perm,
-                )
+            if len(post_transpose_perm) == len(post_matmul_shape):
+                tf_layers_dict[graph_node_output.name]['tf_node'] = \
+                    tf.transpose(
+                        a=tf_layers_dict[graph_node_output.name]['tf_node'],
+                        perm=post_transpose_perm,
+                    )
 
     # Post-process transpose
     tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/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-1.29.11 → onnx2tf-1.29.13}/onnx2tf/utils/common_functions.py

@@ -2403,6 +2403,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

{onnx2tf-1.29.11 → onnx2tf-1.29.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "onnx2tf"
-version = "1.29.11"
+version = "1.29.13"
 description = "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)."
 readme = "README.md"
 requires-python = ">=3.10.12"
@@ -21,6 +21,7 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Operating System :: Unix",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
@@ -57,6 +58,8 @@ Issues = "https://github.com/PINTO0309/onnx2tf/issues"
 override-dependencies = [
     "onnx==1.19.0",
     "onnxsim==0.4.36",
+    "ml-dtypes==0.5.1",
+    "numpy==1.26.4",
 ]
 
 [tool.uv.build-backend]