onnx2tf 1.29.21__tar.gz → 1.29.22__tar.gz

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.21
+Version: 1.29.22
 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
@@ -365,7 +365,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.21
+  ghcr.io/pinto0309/onnx2tf:1.29.22
 
   or
 
@@ -373,7 +373,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.21
+  docker.io/pinto0309/onnx2tf:1.29.22
 
   or
 

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/README.md

@@ -323,7 +323,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.21
+  ghcr.io/pinto0309/onnx2tf:1.29.22
 
   or
 
@@ -331,7 +331,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.21
+  docker.io/pinto0309/onnx2tf:1.29.22
 
   or
 

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.21'
+__version__ = '1.29.22'

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/onnx2tf/ops/MaxPool.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
@@ -119,6 +120,59 @@ def make_node(
                     **kwargs,
                 )
 
+    # Guard: brute-force axis alignment between NCHW and NHWC when batch dim mismatches.
+    # Only trigger when shapes are fully known to avoid destabilizing existing behavior.
+    def _shape_matches(shape_a, shape_b):
+        if shape_a is None or shape_b is None or 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
+
+    def _best_perm_to_match(cur_shape, target_shape):
+        rank = len(cur_shape)
+        best_perm = None
+        best_cost = None
+        for perm in itertools.permutations(range(rank)):
+            permuted = [cur_shape[i] for i in perm]
+            if not _shape_matches(permuted, target_shape):
+                continue
+            cost = sum(abs(i - perm[i]) for i in range(rank))
+            if best_cost is None or cost < best_cost:
+                best_cost = cost
+                best_perm = perm
+        return best_perm
+
+    try:
+        current_shape = input_tensor.shape.as_list()
+    except Exception:
+        current_shape = None
+
+    if onnx_input_shape is not None and current_shape is not None:
+        onnx_shape = [
+            dim if isinstance(dim, int) else None for dim in onnx_input_shape
+        ]
+        cur_shape = [
+            dim if isinstance(dim, int) else None for dim in current_shape
+        ]
+        if len(onnx_shape) in (3, 4, 5) \
+            and len(cur_shape) == len(onnx_shape) \
+            and None not in onnx_shape \
+            and None not in cur_shape:
+            expected_shape = [onnx_shape[0]] + onnx_shape[2:] + [onnx_shape[1]]
+            if cur_shape[0] != onnx_shape[0] \
+                and not _shape_matches(cur_shape, expected_shape):
+                perm = _best_perm_to_match(cur_shape, expected_shape)
+                if perm is not None:
+                    input_tensor = transpose_with_flexing_deterrence(
+                        input_tensor=input_tensor,
+                        perm=list(perm),
+                        **kwargs,
+                    )
+
     filter = None
 
     auto_pad = graph_node.attrs.get('auto_pad', 'NOTSET')

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/onnx2tf/ops/ScatterElements.py

@@ -146,6 +146,48 @@ def make_node(
         axis=axis,
         indices=indices_tensor,
     )
+    indices_rank = None
+    if hasattr(indices_tensor, "shape") and indices_tensor.shape is not None:
+        try:
+            indices_rank = len(indices_tensor.shape)
+        except TypeError:
+            indices_rank = indices_tensor.shape.rank
+    updates_rank = updates_tensor_rank
+    broadcast_shape = None
+    pad_rank = 0
+
+    def _pad_and_broadcast(target_tensor, pad_rank, target_shape):
+        tensor = target_tensor
+        if isinstance(tensor, np.ndarray):
+            tensor = tf.convert_to_tensor(tensor)
+        if pad_rank <= 0:
+            return tf.broadcast_to(tensor, target_shape)
+        tensor_shape = tf.shape(tensor)
+        new_shape = tf.concat(
+            [tf.ones([pad_rank], dtype=tf.int32), tensor_shape],
+            axis=0,
+        )
+        tensor = tf.reshape(tensor, new_shape)
+        return tf.broadcast_to(tensor, target_shape)
+
+    updates_tensor_for_scatter = updates_tensor
+    if indices_rank is not None and updates_rank is not None and indices_rank != updates_rank:
+        if indices_rank > updates_rank:
+            broadcast_shape = tf.shape(indices_tensor)
+            pad_rank = indices_rank - updates_rank
+            updates_tensor_for_scatter = _pad_and_broadcast(
+                updates_tensor,
+                pad_rank,
+                broadcast_shape,
+            )
+        else:
+            broadcast_shape = tf.shape(updates_tensor)
+            pad_rank = updates_rank - indices_rank
+            indices_tensor = _pad_and_broadcast(
+                indices_tensor,
+                pad_rank,
+                broadcast_shape,
+            )
     sparsified_dense_idx_shape = updates_tensor_shape
 
     if None not in sparsified_dense_idx_shape:
@@ -160,6 +202,13 @@ def make_node(
         ]
 
     idx_tensors_per_axis = tf.meshgrid(*idx_tensors_per_axis, indexing='ij')
+    if indices_rank is not None \
+        and updates_rank is not None \
+        and indices_rank > updates_rank:
+        idx_tensors_per_axis = [
+            _pad_and_broadcast(idx_tensor, pad_rank, broadcast_shape)
+            for idx_tensor in idx_tensors_per_axis
+        ]
     idx_tensors_per_axis[axis] = indices_tensor
     dim_expanded_idx_tensors_per_axis = [
         tf.expand_dims(idx_tensor, axis=-1)
@@ -194,7 +243,7 @@ def make_node(
     )
 
     indices = tf.reshape(coordinate, [-1, input_tensor_rank])
-    updates = tf.reshape(updates_tensor, [-1])
+    updates = tf.reshape(updates_tensor_for_scatter, [-1])
     output = tf.tensor_scatter_nd_update(
         tensor=input_tensor,
         indices=indices,

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/onnx2tf/ops/Unique.py

@@ -14,6 +14,7 @@ from onnx2tf.utils.common_functions import (
     make_tf_node_info,
     get_replacement_parameter,
     pre_process_transpose,
+    convert_axis,
 )
 from onnx2tf.utils.logging import Color
 
@@ -69,8 +70,20 @@ def make_node(
         **kwargs,
     )
 
+    input_tensor_shape = input_tensor.shape
+    tensor_rank = len(input_tensor_shape) \
+        if input_tensor_shape != tf.TensorShape(None) else 1
+
     axis = graph_node.attrs.get('axis', None)
     sorted = graph_node.attrs.get('sorted', 1)
+    if axis is not None:
+        if isinstance(axis, np.ndarray) and axis.shape == ():
+            axis = int(axis)
+        axis = convert_axis(
+            axis=int(axis),
+            tensor_rank=tensor_rank,
+            before_op_output_shape_trans=before_op_output_shape_trans,
+        )
 
     # Preserving Graph Structure (Dict)
     for graph_node_output in graph_node_outputs:
@@ -101,17 +114,64 @@ def make_node(
 
     # tf unique returns unsorted tensor, need to sort if option is enabled
     if sorted:
-        # TODO: implement sort
-        error_msg = f'' + \
-                    Color.RED(f'WARNING:') + ' ' + \
-                    f'Sort option in Unique ops is not implemented yet.'
-        print(error_msg)
-        assert False, error_msg
-
-    tf_layers_dict[graph_node_outputs[0].name]['tf_node'] = y
-    tf_layers_dict[graph_node_outputs[1].name]['tf_node'] = indices
-    tf_layers_dict[graph_node_outputs[2].name]['tf_node'] = inverse_indices
-    tf_layers_dict[graph_node_outputs[3].name]['tf_node'] = count
+        # Sort unique outputs to match ONNX sorted behavior.
+        def _argsort_supported(dtype):
+            return dtype.is_floating or dtype.is_integer or dtype == tf.bool
+
+        y_rank = y.shape.rank
+        axis_ = axis
+        if axis_ is None:
+            axis_ = 0
+        if axis_ < 0 and y_rank is not None:
+            axis_ = axis_ + y_rank
+
+        def _lexsort_perm(flat_2d):
+            if not _argsort_supported(flat_2d.dtype):
+                return None
+            cols = flat_2d.shape[1]
+            if cols is None:
+                return None
+            order = tf.range(tf.shape(flat_2d)[0])
+            for col in reversed(range(cols)):
+                col_vals = tf.gather(flat_2d, order)[:, col]
+                if col_vals.dtype == tf.bool:
+                    col_vals = tf.cast(col_vals, tf.int32)
+                order = tf.gather(order, tf.argsort(col_vals, stable=True))
+            return order
+
+        order = None
+        if y_rank is not None and y_rank == 1:
+            if _argsort_supported(y.dtype):
+                sort_vals = y
+                if sort_vals.dtype == tf.bool:
+                    sort_vals = tf.cast(sort_vals, tf.int32)
+                order = tf.argsort(sort_vals, stable=True)
+        elif y_rank is not None and axis_ is not None and 0 <= axis_ < y_rank:
+            perm = [axis_] + [i for i in range(y_rank) if i != axis_]
+            y_t = tf.transpose(y, perm)
+            flat = tf.reshape(y_t, [tf.shape(y_t)[0], -1])
+            order = _lexsort_perm(flat)
+
+        if order is None:
+            warn_msg = f'' + \
+                       Color.YELLOW(f'WARNING:') + ' ' + \
+                       f'Unique sort fallback to unsorted due to dynamic shape or unsupported dtype.'
+            print(warn_msg)
+        else:
+            y = tf.gather(y, order, axis=axis_)
+            count = tf.gather(count, order)
+            indices = tf.gather(indices, order)
+            inv_order = tf.argsort(order)
+            inverse_indices = tf.gather(inv_order, inverse_indices)
+
+    if len(graph_node_outputs) >= 1:
+        tf_layers_dict[graph_node_outputs[0].name]['tf_node'] = y
+    if len(graph_node_outputs) >= 2:
+        tf_layers_dict[graph_node_outputs[1].name]['tf_node'] = indices
+    if len(graph_node_outputs) >= 3:
+        tf_layers_dict[graph_node_outputs[2].name]['tf_node'] = inverse_indices
+    if len(graph_node_outputs) >= 4:
+        tf_layers_dict[graph_node_outputs[3].name]['tf_node'] = count
 
     # Generation of Debug Info
     tf_outputs = {f"output{idx}": value for idx, value in enumerate([y, indices, inverse_indices, count])}

{onnx2tf-1.29.21 → onnx2tf-1.29.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "onnx2tf"
-version = "1.29.21"
+version = "1.29.22"
 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"