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

onnx2tf/__init__.py

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

@@ -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.12.dist-info → onnx2tf-1.29.13.dist-info}/METADATA

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

{onnx2tf-1.29.12.dist-info → onnx2tf-1.29.13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx2tf/__init__.py,sha256=89EgFjqomm_s1GTO1Is-NN_4IBNeGFXu31Zcmotmbes,67
+onnx2tf/__init__.py,sha256=R3xcBajxe4r7F25_9nRmdMA34UcOfFELrQOkcpwQBDE,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
 onnx2tf/onnx2tf.py,sha256=yR8aKaEn01Q8dEeYDqHIsuZuG6l5TGQniHDlPiUROx4,152238
 onnx2tf/ops/Abs.py,sha256=V7btmCG_ZvK_qJovUsguq0ZMJ349mhNQ4FHSgzP_Yuo,4029
@@ -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,7 +51,7 @@ 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/Floor.py,sha256=8izJrNmw8wNmjF_YabIpLs4jm82J-gKcyAQbwV7Yqpc,3589
@@ -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=OvAwXUSYzB1l5H9ndzyhMdZ1mE3gNmiGe4LsGMyKhJc,258219
 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.13.dist-info/WHEEL,sha256=e_m4S054HL0hyR3CpOk-b7Q7fDX6BuFkgL5OjAExXas,80
+onnx2tf-1.29.13.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.13.dist-info/METADATA,sha256=ZiT1jQJBMmuRmdl73bUzvQlxXE5rm1pyrO-eWnxJIEw,154244
+onnx2tf-1.29.13.dist-info/RECORD,,