onnx2tf 1.29.2__py3-none-any.whl → 1.29.4__py3-none-any.whl

onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.2'
+__version__ = '1.29.4'

onnx2tf/onnx2tf.py

@@ -1246,8 +1246,8 @@ def convert(
                 # Attach it to the exception for later use
                 ex.onnx_op_name = error_onnx_op_name
 
-            # If no replacement file was provided, try to generate one automatically
-            if not param_replacement_file and input_onnx_file_path:
+            # If no replacement file was provided, optionally try to generate one automatically
+            if not param_replacement_file and input_onnx_file_path and auto_generate_json_on_error:
                 info('')
                 info(Color.REVERSE(f'Attempting automatic JSON generation due to conversion error'), '=' * 30)
                 if error_onnx_op_name:
@@ -1313,6 +1313,11 @@ def convert(
                     warn(
                         f'Conversion failed and automatic JSON generation could not find a solution after {attempt} attempts.'
                     )
+            elif not param_replacement_file and input_onnx_file_path and not auto_generate_json_on_error:
+                warn(
+                    'Conversion failed. Automatic JSON generation on error is disabled by default.\n' +
+                    'Re-run with --auto_generate_json_on_error or provide a parameter replacement JSON file.'
+                )
             # Re-raise the original error
             raise ex
 

onnx2tf/ops/AveragePool.py

@@ -168,6 +168,46 @@ def make_node(
     )
 
     if not is_known_shape:
+        def build_tf_pads_from_begin_end(pads_begin, pads_end):
+            pads_begin = tf.cast(pads_begin, tf.int32)
+            pads_end = tf.cast(pads_end, tf.int32)
+            spatial_pads = tf.stack([pads_begin, pads_end], axis=1)
+            return tf.concat(
+                [
+                    tf.zeros((1, 2), dtype=tf.int32),
+                    spatial_pads,
+                    tf.zeros((1, 2), dtype=tf.int32),
+                ],
+                axis=0,
+            )
+
+        def calc_extra_padding_with_ceil_dynamic(input_tensor, pads, kernel_shape, dilations, strides):
+            input_shape = tf.shape(input_tensor)
+            input_spatial = input_shape[1:-1]
+            pads_begin = tf.constant(pads[:len(pads) // 2], dtype=tf.int32)
+            pads_end = tf.constant(pads[len(pads) // 2:], dtype=tf.int32)
+            pads_along_axis = pads_begin + pads_end
+            k = tf.constant(kernel_shape, dtype=tf.int32)
+            d = tf.constant(dilations, dtype=tf.int32)
+            s = tf.constant(strides, dtype=tf.int32)
+
+            numerator = input_spatial + pads_along_axis - d * (k - 1) - 1
+            output_spatial = tf.cast(
+                tf.math.ceil(
+                    tf.cast(numerator, tf.float32) / tf.cast(s, tf.float32) + 1.0
+                ),
+                tf.int32,
+            )
+            last_stride_starts = (output_spatial - 1) * s
+            last_stride_validity = last_stride_starts < (input_spatial + pads_begin)
+
+            extra_pads = tf.where(
+                last_stride_validity,
+                last_stride_starts + (k - 1) * d + 1 - (input_spatial + pads_along_axis),
+                tf.zeros_like(input_spatial),
+            )
+            return extra_pads
+
         def compute_output_spatial_shape_from_tensor(input_tensor, pads, kernel_shape, dilations, strides, ceil_mode=False):
             input_shape = tf.shape(input_tensor)  # Get dynamic shape
             input_spatial = input_shape[1:-1]  # Extract spatial dimensions only (NHWC format)
@@ -223,18 +263,32 @@ def make_node(
 
             # extra padding to end side (right, bottom) may be needed when ceil_mode is True
             # this extra padding should not be counted as padding when count_include_pad is True
-            if ceil_mode:
-                extra_pads = \
-                    calc_extra_padding_with_ceil(
-                        input_shape=input_tensor_shape[1:-1],
-                        kernel=kernel_shape,
+            if not is_known_shape:
+                pads_begin = tf.constant(pads[:len(pads) // 2], dtype=tf.int32)
+                pads_end = tf.constant(pads[len(pads) // 2:], dtype=tf.int32)
+                if ceil_mode:
+                    extra_pads = calc_extra_padding_with_ceil_dynamic(
+                        input_tensor=input_tensor,
                         pads=pads,
+                        kernel_shape=kernel_shape,
                         dilations=dilations,
                         strides=strides,
                     )
-                pads = pads[:len(pads) // 2] + [p + e for p, e in zip(pads[len(pads) // 2:], extra_pads)]
-
-            tf_pads = pads
+                    pads_end = pads_end + extra_pads
+                tf_pads = build_tf_pads_from_begin_end(pads_begin, pads_end)
+            else:
+                if ceil_mode:
+                    extra_pads = \
+                        calc_extra_padding_with_ceil(
+                            input_shape=input_tensor_shape[1:-1],
+                            kernel=kernel_shape,
+                            pads=pads,
+                            dilations=dilations,
+                            strides=strides,
+                        )
+                    pads = pads[:len(pads) // 2] + [p + e for p, e in zip(pads[len(pads) // 2:], extra_pads)]
+
+                tf_pads = pads
 
     elif auto_pad == 'SAME_UPPER':
         tf_pad_mode = 'SAME'
@@ -305,36 +359,42 @@ def make_node(
     # 1. when extra padding layer is added and count_include_pad is False
     # 2. when extra padding layer is not added and count_include_pad is True
     # 3. when last stride has extra padding due to ceil_mode and count_include_pad is True
-    if is_explicit_padding and tf_pads != [0] * spatial_size * 2:
+    if is_explicit_padding:
         warn(
             f'Tensorflow incompatible padding detected. ' \
             f'Extra pad layer is inserted automatically. '
         )
-
-        if auto_pad == 'SAME_LOWER':
-            # switch the order of pads
-            tf_pads = [i for tup in zip(tf_pads[len(tf_pads) // 2:], tf_pads[:len(tf_pads) // 2]) for i in tup]
-
-        if not count_include_pad and need_multiplier:
-            average_multiplier = []
-            for k, non_zero_count in zip(kernel_shape, non_zero_counts):
-                multiplier = [k / n if n != 0 else 1 for n in non_zero_count]
-                average_multiplier.append(multiplier)
-
-        # convert to tensorflow padding format
-        tf_pads = \
-            [[0, 0]] + \
-            [list(i) for i in zip(tf_pads[:len(tf_pads) // 2], tf_pads[len(tf_pads) // 2:])] + \
-            [[0, 0]]
-
-        if spatial_size == 1 and kernel_shape[0] > input_tensor_shape[1]:
-            padded_tensor = input_tensor
-        else:
+        if not is_known_shape:
             padded_tensor = tf.pad(
                 tensor=input_tensor,
                 paddings=tf_pads,
                 mode='CONSTANT',
             )
+        else:
+            if auto_pad == 'SAME_LOWER':
+                # switch the order of pads
+                tf_pads = [i for tup in zip(tf_pads[len(tf_pads) // 2:], tf_pads[:len(tf_pads) // 2]) for i in tup]
+
+            if not count_include_pad and need_multiplier:
+                average_multiplier = []
+                for k, non_zero_count in zip(kernel_shape, non_zero_counts):
+                    multiplier = [k / n if n != 0 else 1 for n in non_zero_count]
+                    average_multiplier.append(multiplier)
+
+            # convert to tensorflow padding format
+            tf_pads = \
+                [[0, 0]] + \
+                [list(i) for i in zip(tf_pads[:len(tf_pads) // 2], tf_pads[len(tf_pads) // 2:])] + \
+                [[0, 0]]
+
+            if spatial_size == 1 and kernel_shape[0] > input_tensor_shape[1]:
+                padded_tensor = input_tensor
+            else:
+                padded_tensor = tf.pad(
+                    tensor=input_tensor,
+                    paddings=tf_pads,
+                    mode='CONSTANT',
+                )
 
     else:
         padded_tensor = input_tensor
@@ -345,7 +405,7 @@ def make_node(
                 multiplier = [n / k for n in non_zero_count]
                 average_multiplier.append(multiplier)
 
-    if count_include_pad and extra_pads != [0] * spatial_size:
+    if count_include_pad and is_known_shape and extra_pads != [0] * spatial_size:
         # extra padding in last stride should not be included in averaging
         if average_multiplier is None:
             average_multiplier = []
@@ -370,7 +430,7 @@ def make_node(
     # Generation of TF OP
     tf_op_type = None
     if len(kernel_shape) == 1:
-        if kernel_shape[0] > padded_tensor.shape[1]:
+        if padded_tensor.shape[1] is not None and kernel_shape[0] > padded_tensor.shape[1]:
             pooled_tensor = AveragePooling1D(
                 pool_size=[padded_tensor.shape[1]],
                 strides=[padded_tensor.shape[1]],

onnx2tf/ops/BitwiseAnd.py

@@ -0,0 +1,115 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """BitwiseAnd
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        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)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1 \
+        and before_op_output_shape_trans_2
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_input_2 = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+    }
+
+    # Generation of TF OP
+    input_tensor_1 = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    input_tensor_2 = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+
+    # Pre-process transpose
+    input_tensor_1 = pre_process_transpose(
+        value_before_transpose=input_tensor_1,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+    input_tensor_2 = pre_process_transpose(
+        value_before_transpose=input_tensor_2,
+        param_target='inputs',
+        param_name=graph_node.inputs[1].name,
+        **kwargs,
+    )
+
+    tf_op_type = None
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.bitwise.bitwise_and(
+            x=input_tensor_1,
+            y=input_tensor_2,
+            name=graph_node.name,
+        )
+    tf_op_type = tf.bitwise.bitwise_and
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf_op_type,
+                'tf_inputs': {
+                    'x': input_tensor_1,
+                    'y': input_tensor_2,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/BitwiseNot.py

@@ -0,0 +1,98 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """BitwiseNot
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        tf_layers_dict.get(graph_node.inputs[0].name, {}).get('before_op_output_shape_trans', True)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+    }
+
+    # Generation of TF OP
+    input_tensor_1 = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+
+    # Pre-process transpose
+    input_tensor_1 = pre_process_transpose(
+        value_before_transpose=input_tensor_1,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    tf_op_type = None
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.bitwise.invert(
+            x=input_tensor_1,
+            name=graph_node.name,
+        )
+    tf_op_type = tf.bitwise.invert
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf_op_type,
+                'tf_inputs': {
+                    'x': input_tensor_1,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/BitwiseOr.py

@@ -0,0 +1,115 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """BitwiseOr
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        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)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1 \
+        and before_op_output_shape_trans_2
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_input_2 = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+    }
+
+    # Generation of TF OP
+    input_tensor_1 = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    input_tensor_2 = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+
+    # Pre-process transpose
+    input_tensor_1 = pre_process_transpose(
+        value_before_transpose=input_tensor_1,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+    input_tensor_2 = pre_process_transpose(
+        value_before_transpose=input_tensor_2,
+        param_target='inputs',
+        param_name=graph_node.inputs[1].name,
+        **kwargs,
+    )
+
+    tf_op_type = None
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.bitwise.bitwise_or(
+            x=input_tensor_1,
+            y=input_tensor_2,
+            name=graph_node.name,
+        )
+    tf_op_type = tf.bitwise.bitwise_or
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf_op_type,
+                'tf_inputs': {
+                    'x': input_tensor_1,
+                    'y': input_tensor_2,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/BitwiseXor.py

@@ -0,0 +1,115 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import onnx_graphsurgeon as gs
+from onnx2tf.utils.common_functions import (
+    get_constant_or_variable,
+    print_node_info,
+    inverted_operation_enable_disable,
+    make_tf_node_info,
+    get_replacement_parameter,
+    pre_process_transpose,
+    post_process_transpose,
+)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """BitwiseXor
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    before_op_output_shape_trans_1 = \
+        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)
+    before_op_output_shape_trans = \
+        before_op_output_shape_trans_1 \
+        and before_op_output_shape_trans_2
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_input_2 = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+    }
+
+    # Generation of TF OP
+    input_tensor_1 = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    input_tensor_2 = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+
+    # Pre-process transpose
+    input_tensor_1 = pre_process_transpose(
+        value_before_transpose=input_tensor_1,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+    input_tensor_2 = pre_process_transpose(
+        value_before_transpose=input_tensor_2,
+        param_target='inputs',
+        param_name=graph_node.inputs[1].name,
+        **kwargs,
+    )
+
+    tf_op_type = None
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.bitwise.bitwise_xor(
+            x=input_tensor_1,
+            y=input_tensor_2,
+            name=graph_node.name,
+        )
+    tf_op_type = tf.bitwise.bitwise_xor
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=tf_layers_dict[graph_node_output.name]['tf_node'],
+        param_target='outputs',
+        param_name=graph_node.outputs[0].name,
+        **kwargs,
+    )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf_op_type,
+                'tf_inputs': {
+                    'x': input_tensor_1,
+                    'y': input_tensor_2,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

{onnx2tf-1.29.2.dist-info → onnx2tf-1.29.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.2
+Version: 1.29.4
 Summary: Self-Created Tools to convert ONNX files (NCHW) to TensorFlow/TFLite/Keras format (NHWC).
 Home-page: https://github.com/PINTO0309/onnx2tf
 Author: Katsuya Hyodo
@@ -106,10 +106,10 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |BatchNormalization|:heavy_check_mark:|
   |Bernoulli|:heavy_check_mark:|
   |BitShift|:heavy_check_mark:|
-  |BitwiseAnd|**Help wanted**|
-  |BitwiseNot|**Help wanted**|
-  |BitwiseOr|**Help wanted**|
-  |BitwiseXor|**Help wanted**|
+  |BitwiseAnd|:heavy_check_mark:|
+  |BitwiseNot|:heavy_check_mark:|
+  |BitwiseOr|:heavy_check_mark:|
+  |BitwiseXor|:heavy_check_mark:|
   |Cast|:heavy_check_mark:|
   |Ceil|:heavy_check_mark:|
   |Celu|:heavy_check_mark:|
@@ -345,7 +345,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.2
+  ghcr.io/pinto0309/onnx2tf:1.29.4
 
   or
 
@@ -353,7 +353,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.2
+  docker.io/pinto0309/onnx2tf:1.29.4
 
   or
 
@@ -2077,9 +2077,9 @@ optional arguments:
     which can take a very long time depending on the model complexity.
 
   -agje, --auto_generate_json_on_error
-    Attempts to generate a parameter replacement JSON when accuracy validation finds errors
-    greater than 1e-2. Useful for quickly capturing fixes during -cotof runs.
-    Disabled by default to avoid unexpected file generation.
+    Attempts to generate a parameter replacement JSON when conversion fails or when accuracy
+    validation finds errors greater than 1e-2. Useful for quickly capturing fixes during
+    -cotof runs. Disabled by default to avoid unexpected file generation.
 
   -dms, --disable_model_save
     Does not save the converted model. For CIs RAM savings.
@@ -2518,8 +2518,8 @@ convert(
       Default: False
 
     auto_generate_json_on_error: Optional[bool]
-      When accuracy validation detects errors greater than 1e-2, attempts to generate
-      a parameter replacement JSON as a best-effort fix.
+      When conversion fails or accuracy validation detects errors greater than 1e-2,
+      attempts to generate a parameter replacement JSON as a best-effort fix.
       Default: False
 
     check_gpu_delegate_compatibility: Optional[bool]

{onnx2tf-1.29.2.dist-info → onnx2tf-1.29.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
-onnx2tf/__init__.py,sha256=XiJqjkSHI6QAj_uhuuHUb9C9a1UT1jlqkKPHin_kgWU,66
+onnx2tf/__init__.py,sha256=pluvSdvaC9nePqUVOCSAuPcchjfddyLkq1cJnhohl5w,66
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
-onnx2tf/onnx2tf.py,sha256=XZBqVn1Q_qmPmrYw_Dz30vRWJ8uaJURkbUSo_8rZrjk,151116
+onnx2tf/onnx2tf.py,sha256=wdBA-lgCEu-ZfUAKIUQgLe8hSP8ifE7rS6nWAq6iF6o,151519
 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
@@ -12,10 +12,14 @@ onnx2tf/ops/Asin.py,sha256=2djUjTaOzXM6t4Qb-EEMZY-pm1rJl24cgcrep2i_6aQ,4003
 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/AveragePool.py,sha256=X2uMuo1CnPBpeqXbCkG-hMBmmUFGry-Xu4EXLg2aoIw,17297
+onnx2tf/ops/AveragePool.py,sha256=kifQJZplqC2Px209BotbjXCPpRBQQsB8DlJYJTvJD78,20065
 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
+onnx2tf/ops/BitwiseAnd.py,sha256=snmmVzVwLxhWh0aKyaskScBvefncGyW7ZPVrmbugazk,3456
+onnx2tf/ops/BitwiseNot.py,sha256=QuFUyK24JGrEOKYu-6lRi9uZLz4MKVtBwUqzDdqtBKA,2721
+onnx2tf/ops/BitwiseOr.py,sha256=WSswhA3qmp3OJ4iIibl_2ps-tZEyfKI7B19GiFH7Uik,3453
+onnx2tf/ops/BitwiseXor.py,sha256=d1WoshWdfcoQnYrdaxafRleipy1d0AKleTgh0G7lZlw,3456
 onnx2tf/ops/Cast.py,sha256=M0LRClHPgZ_8NubwME6ipKrAqcY9aKC5ihQXCkTkNkM,4601
 onnx2tf/ops/Ceil.py,sha256=0-jaueltpQSwpOIDUmy9DdTy98qN-XimYu5cHVPnUIs,3586
 onnx2tf/ops/Celu.py,sha256=9g7WNKo4G_jMtUXcoOfpNdLYqEsuyXLPkkyQZxDuL4U,3853
@@ -190,9 +194,9 @@ 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.2.dist-info/licenses/LICENSE,sha256=5v_Kxihy8i6mzHVl349ikSREaIdsl9YeUnX1KBDLD2w,1070
-onnx2tf-1.29.2.dist-info/licenses/LICENSE_onnx-tensorflow,sha256=gK4GtS9S5YcyINu6uuNNWdo-kBClyEM4MFLFGiNTeRM,11231
-onnx2tf-1.29.2.dist-info/METADATA,sha256=x_nPx4ypPex9jfMHIPDvjT7LS8-bWke3CWugzi7n404,153189
-onnx2tf-1.29.2.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-onnx2tf-1.29.2.dist-info/top_level.txt,sha256=WgfPiEy3f6vZ_FOpAIEA2CF3TCx1eYrhGw93Ih6b9Fw,8
-onnx2tf-1.29.2.dist-info/RECORD,,
+onnx2tf-1.29.4.dist-info/licenses/LICENSE,sha256=5v_Kxihy8i6mzHVl349ikSREaIdsl9YeUnX1KBDLD2w,1070
+onnx2tf-1.29.4.dist-info/licenses/LICENSE_onnx-tensorflow,sha256=gK4GtS9S5YcyINu6uuNNWdo-kBClyEM4MFLFGiNTeRM,11231
+onnx2tf-1.29.4.dist-info/METADATA,sha256=HYGQZOLfX2Hvk0xSg3t8Dfd376S7WlGyAc16CEfQztM,153246
+onnx2tf-1.29.4.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+onnx2tf-1.29.4.dist-info/top_level.txt,sha256=WgfPiEy3f6vZ_FOpAIEA2CF3TCx1eYrhGw93Ih6b9Fw,8
+onnx2tf-1.29.4.dist-info/RECORD,,