onnx2tf 1.29.22__py3-none-any.whl → 1.29.24__py3-none-any.whl

onnx2tf/__init__.py

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

onnx2tf/ops/CenterCropPad.py

@@ -0,0 +1,192 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import tf_keras
+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,
+    convert_axis,
+)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """CenterCropPad
+
+    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 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    graph_node_shape = get_constant_or_variable(
+        graph_node.inputs[1],
+        False,
+    )
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    input_tensor = tf_layers_dict[graph_node_input.name]['tf_node'] \
+        if isinstance(graph_node_input, gs.Variable) else graph_node_input
+    target_shape = tf_layers_dict[graph_node_shape.name]['tf_node'] \
+        if isinstance(graph_node_shape, gs.Variable) else graph_node_shape
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+        'nhwc': tf_layers_dict[graph_node_input.name]['nhwc'] \
+            if isinstance(graph_node_input, gs.Variable) \
+                and 'nhwc' in tf_layers_dict[graph_node_input.name].keys() else False
+    }
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    input_rank = input_tensor.shape.rank
+    if input_rank is None:
+        input_rank = tf.rank(input_tensor)
+
+    axes = graph_node.attrs.get('axes', None)
+    if isinstance(axes, np.ndarray):
+        axes = axes.tolist()
+
+    if axes is None:
+        if isinstance(input_rank, int):
+            axes_list = list(range(input_rank))
+            if before_op_output_shape_trans:
+                axes_list = [
+                    convert_axis(
+                        axis=axis,
+                        tensor_rank=input_rank,
+                        before_op_output_shape_trans=before_op_output_shape_trans,
+                    ) for axis in axes_list
+                ]
+            axes_tensor = tf.constant(axes_list, dtype=tf.int32)
+        else:
+            rank_t = tf.cast(input_rank, tf.int32)
+            axes_tensor = tf.range(rank_t)
+            if before_op_output_shape_trans:
+                axes_tensor = tf.where(
+                    tf.equal(axes_tensor, 0),
+                    0,
+                    tf.where(tf.equal(axes_tensor, 1), rank_t - 1, axes_tensor - 1),
+                )
+    else:
+        if not isinstance(axes, list):
+            axes = [axes]
+        if isinstance(input_rank, int):
+            axes_conv = [
+                convert_axis(
+                    axis=axis,
+                    tensor_rank=input_rank,
+                    before_op_output_shape_trans=before_op_output_shape_trans,
+                ) for axis in axes
+            ]
+            axes_tensor = tf.constant(axes_conv, dtype=tf.int32)
+        else:
+            axes_tensor = tf.convert_to_tensor(axes, dtype=tf.int32)
+            if before_op_output_shape_trans:
+                rank_t = tf.cast(input_rank, tf.int32)
+                axes_tensor = tf.where(axes_tensor < 0, axes_tensor + rank_t, axes_tensor)
+                axes_tensor = tf.where(
+                    tf.equal(axes_tensor, 0),
+                    0,
+                    tf.where(tf.equal(axes_tensor, 1), rank_t - 1, axes_tensor - 1),
+                )
+
+    if isinstance(target_shape, list):
+        target_shape = tf.constant(np.asarray(target_shape, dtype=np.int32))
+    elif isinstance(target_shape, np.ndarray):
+        target_shape = tf.convert_to_tensor(target_shape.astype(np.int32))
+    else:
+        target_shape = tf.cast(target_shape, tf.int32)
+
+    input_shape = tf.shape(input_tensor, out_type=tf.int32)
+    target_shape_full = tf.tensor_scatter_nd_update(
+        input_shape,
+        tf.expand_dims(axes_tensor, axis=1),
+        target_shape,
+    )
+
+    diff = target_shape_full - input_shape
+
+    pad_before = tf.where(diff > 0, tf.math.floordiv(diff, 2), 0)
+    pad_after = tf.where(diff > 0, diff - tf.math.floordiv(diff, 2), 0)
+    crop_before = tf.where(diff < 0, tf.math.floordiv(-diff, 2), 0)
+    crop_after = tf.where(diff < 0, (-diff) - tf.math.floordiv(-diff, 2), 0)
+
+    begin = crop_before
+    size = input_shape - crop_before - crop_after
+    cropped = tf.slice(input_tensor, begin, size)
+
+    paddings = tf.stack([pad_before, pad_after], axis=1)
+    if input_tensor.dtype == tf.string:
+        pad_value = tf.constant('', dtype=tf.string)
+    else:
+        pad_value = tf.cast(0, input_tensor.dtype)
+
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.pad(
+            tensor=cropped,
+            paddings=paddings,
+            constant_values=pad_value,
+            name=graph_node.name,
+        )
+
+    # 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': 'CenterCropPad',
+                'tf_inputs': {
+                    'input': input_tensor,
+                    'shape': target_shape,
+                    'axes': axes,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/GroupNormalization.py

@@ -0,0 +1,234 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import tf_keras
+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,
+    transpose_with_flexing_deterrence,
+)
+from onnx2tf.utils.enums import NUMPY_DTYPES_TO_TF_DTYPES
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """GroupNormalization
+
+    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_3 = \
+        tf_layers_dict.get(graph_node.inputs[2].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 \
+        and before_op_output_shape_trans_3
+
+    graph_node_input = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    input_tensor = tf_layers_dict[graph_node_input.name]['tf_node'] \
+        if isinstance(graph_node_input, gs.Variable) else graph_node_input
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    scale = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans \
+            if graph_node.inputs[1].shape is not None and len(graph_node.inputs[1].shape) != 1 else False,
+        is_bias=True,
+    )
+    scale_dtype = NUMPY_DTYPES_TO_TF_DTYPES[scale.dtype] \
+        if isinstance(scale.dtype, np.dtype) else scale.dtype
+    scale = tf.convert_to_tensor(scale, dtype=scale_dtype) \
+        if isinstance(scale, np.ndarray) else scale
+
+    bias = get_constant_or_variable(
+        graph_node.inputs[2],
+        before_op_output_shape_trans \
+            if graph_node.inputs[2].shape is not None and len(graph_node.inputs[2].shape) != 1 else False,
+        is_bias=True,
+    )
+    bias_dtype = NUMPY_DTYPES_TO_TF_DTYPES[bias.dtype] \
+        if isinstance(bias.dtype, np.dtype) else bias.dtype
+    bias = tf.convert_to_tensor(bias, dtype=bias_dtype) \
+        if isinstance(bias, np.ndarray) else bias
+
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+    shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    epsilon = graph_node.attrs.get('epsilon', 1e-05)
+    num_groups = int(graph_node.attrs.get('num_groups', 1))
+    stash_type = int(graph_node.attrs.get('stash_type', 1))
+    opset = kwargs.get('opset', None)
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': shape,
+        'dtype': dtype,
+        'nhwc': tf_layers_dict[graph_node_input.name]['nhwc'] \
+            if isinstance(graph_node_input, gs.Variable) \
+                and 'nhwc' in tf_layers_dict[graph_node_input.name].keys() else False
+    }
+
+    input_rank = input_tensor.shape.rank
+    if input_rank is None:
+        input_rank = tf.rank(input_tensor)
+
+    channel_axis = -1 if before_op_output_shape_trans else 1
+    channel_axis_idx = channel_axis
+    if isinstance(input_rank, int):
+        channel_axis_idx = channel_axis if channel_axis >= 0 else input_rank + channel_axis
+
+    internal_perm = None
+    internal_inverse_perm = None
+    if isinstance(input_rank, int) and channel_axis_idx != (input_rank - 1):
+        perm = [i for i in range(input_rank) if i != channel_axis_idx] + [channel_axis_idx]
+        internal_perm = perm
+        internal_inverse_perm = [0] * input_rank
+        for i, p in enumerate(perm):
+            internal_inverse_perm[p] = i
+    elif not isinstance(input_rank, int) and channel_axis != -1:
+        rank_t = tf.cast(input_rank, tf.int32)
+        perm = tf.concat([
+            tf.range(channel_axis),
+            tf.range(channel_axis + 1, rank_t),
+            [channel_axis],
+        ], axis=0)
+        internal_perm = perm
+        internal_inverse_perm = tf.argsort(perm)
+
+    x = input_tensor
+    if internal_perm is not None:
+        x = transpose_with_flexing_deterrence(
+            input_tensor=x,
+            perm=internal_perm,
+            **kwargs,
+        )
+
+    input_dtype = x.dtype
+    calc_dtype = tf.float32 if stash_type == 1 else input_dtype
+    x = tf.cast(x, calc_dtype)
+
+    x_shape = tf.shape(x, out_type=tf.int32)
+    channels = x_shape[-1]
+    group_size = tf.math.floordiv(channels, num_groups)
+
+    group_shape = tf.stack([num_groups, group_size], axis=0)
+    new_shape = tf.concat([x_shape[:-1], group_shape], axis=0)
+    x_grouped = tf.reshape(x, new_shape)
+
+    rank_with_group = tf.rank(x_grouped)
+    spatial_axes = tf.range(1, rank_with_group - 2)
+    reduce_axes = tf.concat(
+        [spatial_axes, tf.expand_dims(rank_with_group - 1, axis=0)],
+        axis=0,
+    )
+
+    mean, variance = tf.nn.moments(x_grouped, axes=reduce_axes, keepdims=True)
+    x_norm = (x_grouped - mean) * tf.math.rsqrt(variance + tf.cast(epsilon, calc_dtype))
+    x_norm = tf.cast(x_norm, input_dtype)
+
+    if opset is not None and opset < 21:
+        rank_with_group = x_grouped.shape.rank
+        if rank_with_group is not None:
+            scale_shape = [1] * (rank_with_group - 2) + [num_groups, 1]
+            scale_group = tf.reshape(scale, scale_shape)
+            bias_group = tf.reshape(bias, scale_shape)
+        else:
+            rank_with_group = tf.rank(x_grouped)
+            prefix_ones = tf.fill([rank_with_group - 2], 1)
+            scale_shape = tf.concat(
+                [prefix_ones, tf.constant([num_groups, 1], dtype=tf.int32)],
+                axis=0,
+            )
+            scale_group = tf.reshape(scale, scale_shape)
+            bias_group = tf.reshape(bias, scale_shape)
+        x_norm = x_norm * tf.cast(scale_group, input_dtype) + tf.cast(bias_group, input_dtype)
+
+    x_norm = tf.reshape(x_norm, x_shape)
+
+    if opset is None or opset >= 21:
+        rank_out = x_norm.shape.rank
+        if rank_out is not None:
+            scale_reshape = tf.reshape(scale, [1] * (rank_out - 1) + [-1])
+            bias_reshape = tf.reshape(bias, [1] * (rank_out - 1) + [-1])
+        else:
+            rank_out = tf.rank(x_norm)
+            prefix_ones = tf.fill([rank_out - 1], 1)
+            scale_shape = tf.concat(
+                [prefix_ones, tf.constant([-1], dtype=tf.int32)],
+                axis=0,
+            )
+            scale_reshape = tf.reshape(scale, scale_shape)
+            bias_reshape = tf.reshape(bias, scale_shape)
+        x_norm = x_norm * tf.cast(scale_reshape, input_dtype) + tf.cast(bias_reshape, input_dtype)
+
+    if internal_inverse_perm is not None:
+        x_norm = transpose_with_flexing_deterrence(
+            input_tensor=x_norm,
+            perm=internal_inverse_perm,
+            **kwargs,
+        )
+
+    tf_layers_dict[graph_node_output.name]['tf_node'] = x_norm
+
+    # 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': 'GroupNormalization',
+                'tf_inputs': {
+                    'x': input_tensor,
+                    'scale': scale,
+                    'bias': bias,
+                    'num_groups': num_groups,
+                    'epsilon': epsilon,
+                    'stash_type': stash_type,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/Optional.py

@@ -0,0 +1,127 @@
+import random
+random.seed(0)
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import tf_keras
+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,
+)
+from onnx2tf.utils.enums import ONNX_DTYPES_TO_TF_DTYPES
+
+
+def _type_proto_to_spec(type_proto):
+    if type_proto is None:
+        return None
+
+    if hasattr(type_proto, 'optional_type') and type_proto.HasField('optional_type'):
+        return _type_proto_to_spec(type_proto.optional_type.elem_type)
+
+    if hasattr(type_proto, 'tensor_type') and type_proto.HasField('tensor_type'):
+        elem_type = type_proto.tensor_type.elem_type
+        tf_dtype = ONNX_DTYPES_TO_TF_DTYPES.get(elem_type, tf.float32)
+        dims = []
+        for dim in type_proto.tensor_type.shape.dim:
+            if dim.HasField('dim_value'):
+                dims.append(dim.dim_value)
+            else:
+                dims.append(None)
+        return tf.TensorSpec(shape=dims, dtype=tf_dtype)
+
+    if hasattr(type_proto, 'sequence_type') and type_proto.HasField('sequence_type'):
+        elem_spec = _type_proto_to_spec(type_proto.sequence_type.elem_type)
+        if isinstance(elem_spec, tf.TensorSpec):
+            elem_shape = list(elem_spec.shape)
+            return tf.RaggedTensorSpec(
+                shape=[None] + elem_shape,
+                dtype=elem_spec.dtype,
+                ragged_rank=1,
+            )
+    return None
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """Optional
+
+    Parameters
+    ----------
+    graph_node: gs.Node
+        graph_surgeon Node
+
+    tf_layers_dict: dict
+        optype, shape, dtype, tensorflow graph
+    """
+    graph_node_input = None
+    input_tensor = None
+    if len(graph_node.inputs) >= 1 and graph_node.inputs[0].name != '':
+        graph_node_input = get_constant_or_variable(
+            graph_node.inputs[0],
+            before_op_output_shape_trans=False,
+        )
+        input_tensor = tf_layers_dict[graph_node_input.name]['tf_node'] \
+            if isinstance(graph_node_input, gs.Variable) else graph_node_input
+
+    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,
+        'nhwc': tf_layers_dict[graph_node_input.name]['nhwc'] \
+            if isinstance(graph_node_input, gs.Variable) \
+                and 'nhwc' in tf_layers_dict[graph_node_input.name].keys() else False
+    }
+
+    # Generation of TF OP
+    if input_tensor is None:
+        type_proto = graph_node.attrs.get('type', None)
+        if type_proto is None and hasattr(dtype, 'HasField'):
+            type_proto = dtype
+        spec = _type_proto_to_spec(type_proto)
+        if spec is None:
+            spec = tf.TensorSpec(shape=None, dtype=tf.float32)
+        tf_layers_dict[graph_node_output.name]['tf_node'] = \
+            tf.experimental.Optional.empty(
+                element_spec=spec,
+            )
+    elif isinstance(input_tensor, tf.experimental.Optional):
+        tf_layers_dict[graph_node_output.name]['tf_node'] = input_tensor
+    else:
+        value = input_tensor
+        if isinstance(input_tensor, np.ndarray):
+            value = tf.convert_to_tensor(input_tensor)
+        tf_layers_dict[graph_node_output.name]['tf_node'] = \
+            tf.experimental.Optional.from_value(
+                value=value,
+                name=graph_node.name,
+            )
+
+    # Generation of Debug Info
+    tf_layers_dict[graph_node_output.name]['tf_node_info'] = \
+        make_tf_node_info(
+            node_info={
+                'tf_op_type': tf.experimental.Optional,
+                'tf_inputs': {
+                    'input': input_tensor,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/OptionalGetElement.py

@@ -63,24 +63,14 @@ def make_node(
     )
 
     # Generation of TF OP
-    if isinstance(input_tensor, np.ndarray):
+    if isinstance(input_tensor, tf.experimental.Optional):
+        optional = input_tensor
+    else:
         optional = \
             tf.experimental.Optional.from_value(
                 value=tf.convert_to_tensor(input_tensor),
                 name=graph_node.name,
             )
-    else:
-        converted_tenosr = tf.convert_to_tensor(input_tensor)
-        spec = None
-        if tf_keras.backend.is_keras_tensor(converted_tenosr):
-            spec = converted_tenosr.type_spec
-        else:
-            spec = tf.TensorSpec.from_tensor(converted_tenosr)
-
-        optional = \
-            tf.experimental.Optional.empty(
-                element_spec=spec,
-            )
     tf_layers_dict[graph_node_output.name]['tf_node'] = optional.get_value()
 
     # Post-process transpose

onnx2tf/ops/OptionalHasElement.py

@@ -63,24 +63,14 @@ def make_node(
     )
 
     # Generation of TF OP
-    if isinstance(input_tensor, np.ndarray):
+    if isinstance(input_tensor, tf.experimental.Optional):
+        optional = input_tensor
+    else:
         optional = \
             tf.experimental.Optional.from_value(
                 value=tf.convert_to_tensor(input_tensor),
                 name=graph_node.name,
             )
-    else:
-        converted_tenosr = tf.convert_to_tensor(input_tensor)
-        spec = None
-        if tf_keras.backend.is_keras_tensor(converted_tenosr):
-            spec = converted_tenosr.type_spec
-        else:
-            spec = tf.TensorSpec.from_tensor(converted_tenosr)
-
-        optional = \
-            tf.experimental.Optional.empty(
-                element_spec=spec,
-            )
     tf_layers_dict[graph_node_output.name]['tf_node'] = optional.has_value()
 
     # Post-process transpose

onnx2tf/ops/PRelu.py

@@ -124,22 +124,55 @@ def make_node(
         tf_layers_dict[graph_node_output.name].pop('nhwc')
 
     # Generation of TF OP
-    if replace_prelu_to_pseudo_prelu:
-        pos = tf.nn.relu(input_tensor)
-        neg = (input_tensor - abs(input_tensor)) * (slope * 0.5)
-        tf_layers_dict[graph_node_output.name]['tf_node'] = pos + neg
-    else:
+    shared_axes = None
+    input_shape = input_tensor.shape
+    slope_shape = slope.shape if hasattr(slope, 'shape') else None
+    if input_shape is not None and slope_shape is not None:
+        input_rank = len(input_shape)
+        if len(slope_shape) == input_rank - 1:
+            shared_axes = [
+                i + 1 for i, dim in enumerate(slope_shape)
+                if dim is not None and dim == 1
+            ]
+        elif len(slope_shape) == 1 and input_rank >= 3:
+            slope_dim = slope_shape[0]
+            channel_axis = None
+            if isinstance(slope_dim, int):
+                if input_shape[1] == slope_dim:
+                    channel_axis = 1
+                elif input_shape[-1] == slope_dim:
+                    channel_axis = input_rank - 1
+            if channel_axis is not None:
+                shared_axes = [ax for ax in range(1, input_rank) if ax != channel_axis]
+
+    if shared_axes is None:
         if slope.shape is not None \
             and len(slope.shape) > 0 \
             and sum([1 if dim is not None and dim == 1 else 0 for dim in slope.shape]) == len(slope.shape):
             shared_axes = [val + 1 for val in range(len(input_tensor.shape) - 1)]
         else:
-            shared_axes = [val + 1 for val in range(len(input_tensor.shape) - 2)]
-        tf_layers_dict[graph_node_output.name]['tf_node'] = \
-            PReLU(
-                weights=slope,
-                shared_axes=shared_axes,
-            )(input_tensor)
+            input_nhwc = tf_layers_dict.get(graph_node_output.name, {}).get('nhwc', False)
+            if input_nhwc:
+                shared_axes = [val + 1 for val in range(len(input_tensor.shape) - 2)]
+            else:
+                shared_axes = [val + 2 for val in range(len(input_tensor.shape) - 2)]
+
+    use_native_prelu = not replace_prelu_to_pseudo_prelu
+    if not use_native_prelu:
+        pos = tf.nn.relu(input_tensor)
+        neg = (input_tensor - abs(input_tensor)) * (slope * 0.5)
+        tf_layers_dict[graph_node_output.name]['tf_node'] = pos + neg
+    else:
+        try:
+            tf_layers_dict[graph_node_output.name]['tf_node'] = \
+                PReLU(
+                    weights=slope,
+                    shared_axes=shared_axes,
+                )(input_tensor)
+        except Exception:
+            pos = tf.nn.relu(input_tensor)
+            neg = (input_tensor - abs(input_tensor)) * (slope * 0.5)
+            tf_layers_dict[graph_node_output.name]['tf_node'] = pos + neg
 
     # Post-process transpose
     before_trans_shape = tf_layers_dict[graph_node_output.name]['tf_node'].shape

onnx2tf/ops/TfIdfVectorizer.py

@@ -0,0 +1,431 @@
+import random
+random.seed(0)
+import collections
+from enum import IntEnum
+import numpy as np
+np.random.seed(0)
+import tensorflow as tf
+import tf_keras
+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,
+)
+
+
+class IntMap(collections.UserDict):
+    def __init__(self):
+        super().__init__()
+        self.added_keys = []
+
+    def emplace(self, key, value):
+        if not isinstance(key, (int, str, bytes, np.bytes_)):
+            raise TypeError(f"key must be a int or str not {type(key)}.")
+        if not isinstance(value, NgramPart):
+            raise TypeError(f"value must be a NGramPart not {type(value)}.")
+        if key not in self:
+            self.added_keys.append(key)
+            self.data[key] = value
+        return self.data[key]
+
+    @property
+    def first_key(self):
+        if len(self) == 0:
+            raise ValueError("IntMap is empty.")
+        return self.added_keys[0]
+
+
+class NgramPart:
+    def __init__(self, nid: int):
+        self.id_ = nid  # 0 - means no entry, search for a bigger N
+        self._leafs_ = None
+
+    def init(self):
+        self._leafs_ = IntMap()
+
+    def empty(self):
+        return self._leafs_ is None
+
+    def has_leaves(self):
+        return self._leafs_ is not None and len(self._leafs_) > 0
+
+    @property
+    def leafs_(self):
+        if self._leafs_ is None:
+            raise RuntimeError("NgramPart was not initialized.")
+        return self._leafs_
+
+    def find(self, key):
+        if not self.has_leaves():
+            return None
+        if key in self._leafs_:
+            return key
+        return None
+
+    def emplace(self, key, value):
+        return self.leafs_.emplace(key, value)
+
+    def __getitem__(self, key):
+        return self._leafs_[key]
+
+
+class WeightingCriteria(IntEnum):
+    NONE = 0
+    TF = 1
+    IDF = 2
+    TFIDF = 3
+
+
+def populate_grams(
+    els,
+    els_index,
+    n_ngrams: int,
+    ngram_size: int,
+    ngram_id: int,
+    c,
+):
+    for _ngrams in range(n_ngrams, 0, -1):
+        n = 1
+        m = c
+        while els_index < len(els):
+            p = m.emplace(els[els_index], NgramPart(0))
+            if n == ngram_size:
+                p.id_ = ngram_id
+                ngram_id += 1
+                els_index += 1
+                break
+            if p.empty():
+                p.init()
+            m = p.leafs_
+            n += 1
+            els_index += 1
+    return ngram_id
+
+
+class _TfIdfVectorizerImpl:
+    def __init__(
+        self,
+        *,
+        max_gram_length,
+        max_skip_count,
+        min_gram_length,
+        mode,
+        ngram_counts,
+        ngram_indexes,
+        pool_int64s,
+        pool_strings,
+        weights,
+    ):
+        if mode == "TF":
+            self.weighting_criteria_ = WeightingCriteria.TF
+        elif mode == "IDF":
+            self.weighting_criteria_ = WeightingCriteria.IDF
+        elif mode == "TFIDF":
+            self.weighting_criteria_ = WeightingCriteria.TFIDF
+        else:
+            self.weighting_criteria_ = WeightingCriteria.NONE
+
+        self.min_gram_length_ = int(min_gram_length)
+        self.max_gram_length_ = int(max_gram_length)
+        self.max_skip_count_ = int(max_skip_count)
+        self.ngram_counts_ = list(ngram_counts)
+        self.ngram_indexes_ = list(ngram_indexes)
+        self.output_size_ = max(self.ngram_indexes_) + 1 if len(self.ngram_indexes_) > 0 else 0
+        self.weights_ = list(weights) if weights is not None else []
+        self.pool_int64s_ = list(pool_int64s) if pool_int64s is not None else []
+        self.pool_strings_ = list(pool_strings) if pool_strings is not None else []
+
+        self.int64_map_ = NgramPart(-10)
+        self.int64_map_.init()
+
+        total_items = len(self.pool_int64s_ or self.pool_strings_)
+        ngram_id = 1  # start with 1, 0 - means no n-gram
+        ngram_size = 1
+        for i in range(len(self.ngram_counts_)):
+            start_idx = self.ngram_counts_[i]
+            end_idx = (
+                self.ngram_counts_[i + 1]
+                if (i + 1) < len(self.ngram_counts_)
+                else total_items
+            )
+            items = end_idx - start_idx
+            if items > 0:
+                ngrams = items // ngram_size
+                if (
+                    ngram_size >= self.min_gram_length_
+                    and ngram_size <= self.max_gram_length_
+                ):
+                    ngram_id = populate_grams(
+                        self.pool_int64s_ or self.pool_strings_,
+                        start_idx,
+                        ngrams,
+                        ngram_size,
+                        ngram_id,
+                        self.int64_map_,
+                    )
+                else:
+                    ngram_id += ngrams
+            ngram_size += 1
+
+    def increment_count(self, ngram_id: int, row_num: int, frequencies: np.ndarray) -> None:
+        ngram_id -= 1
+        output_idx = row_num * self.output_size_ + self.ngram_indexes_[ngram_id]
+        frequencies[output_idx] += 1
+
+    def output_result(self, B: int, frequencies: np.ndarray) -> np.ndarray:
+        if B == 0:
+            output_dims = (self.output_size_,)
+            B = 1
+        else:
+            output_dims = (B, self.output_size_)
+
+        row_size = self.output_size_
+        total_dims = int(np.prod(output_dims))
+        Y = np.empty((total_dims,), dtype=np.float32)
+
+        w = self.weights_
+        if self.weighting_criteria_ == WeightingCriteria.TF:
+            for i, f in enumerate(frequencies):
+                Y[i] = f
+        elif self.weighting_criteria_ == WeightingCriteria.IDF:
+            if len(w) > 0:
+                p = 0
+                for _batch in range(B):
+                    for i in range(row_size):
+                        Y[p] = w[i] if frequencies[p] > 0 else 0
+                        p += 1
+            else:
+                p = 0
+                for f in frequencies:
+                    Y[p] = 1 if f > 0 else 0
+                    p += 1
+        elif self.weighting_criteria_ == WeightingCriteria.TFIDF:
+            if len(w) > 0:
+                p = 0
+                for _batch in range(B):
+                    for i in range(row_size):
+                        Y[p] = w[i] * frequencies[p]
+                        p += 1
+            else:
+                p = 0
+                for f in frequencies:
+                    Y[p] = f
+                    p += 1
+        else:
+            raise RuntimeError("Unexpected weighting_criteria.")
+
+        return Y.reshape(output_dims)
+
+    def compute_impl(self, X: np.ndarray, row_num: int, row_size: int, frequencies: np.ndarray) -> None:
+        X_flat = X[row_num] if len(X.shape) > 1 else X
+        row_begin = 0
+        row_end = row_begin + row_size
+
+        max_skip_distance = self.max_skip_count_ + 1
+        start_ngram_size = self.min_gram_length_
+
+        for skip_distance in range(1, max_skip_distance + 1):
+            ngram_start = row_begin
+            ngram_row_end = row_end
+
+            while ngram_start < ngram_row_end:
+                at_least_this = ngram_start + skip_distance * (start_ngram_size - 1)
+                if at_least_this >= ngram_row_end:
+                    break
+
+                ngram_item = ngram_start
+                int_map = self.int64_map_
+                ngram_size = 1
+                while (
+                    int_map.has_leaves()
+                    and ngram_size <= self.max_gram_length_
+                    and ngram_item < ngram_row_end
+                ):
+                    val = X_flat[ngram_item]
+                    hit = int_map.find(val)
+                    if hit is None:
+                        break
+                    hit = int_map[val].id_
+                    if ngram_size >= start_ngram_size and hit != 0:
+                        self.increment_count(hit, row_num, frequencies)
+                    int_map = int_map[val]
+                    ngram_size += 1
+                    ngram_item += skip_distance
+
+                ngram_start += 1
+
+            if start_ngram_size == 1:
+                start_ngram_size += 1
+                if start_ngram_size > self.max_gram_length_:
+                    break
+
+    def run(self, X: np.ndarray) -> np.ndarray:
+        total_items = int(np.prod(X.shape))
+
+        num_rows = 0
+        B = 0
+        C = 0
+        input_dims = X.shape
+        if len(input_dims) == 0:
+            num_rows = 1
+            C = 1
+            if total_items != 1:
+                raise ValueError(f"Unexpected total of items {total_items}.")
+        elif len(input_dims) == 1:
+            num_rows = 1
+            C = input_dims[0]
+        elif len(input_dims) == 2:
+            B = input_dims[0]
+            C = input_dims[1]
+            num_rows = B
+            if B < 1:
+                raise ValueError(
+                    f"Input shape must have either [C] or [B,C] dimensions with B > 0, B={B}, C={C}."
+                )
+        else:
+            raise ValueError(
+                f"Input shape must have either [C] or [B,C] dimensions with B > 0, B={B}, C={C}."
+            )
+
+        if num_rows * C != total_items:
+            raise ValueError(
+                f"Unexpected total of items, num_rows * C = {num_rows * C} != total_items = {total_items}."
+            )
+
+        frequencies = np.zeros((num_rows * self.output_size_,), dtype=np.int64)
+
+        if total_items == 0 or self.int64_map_.empty():
+            return self.output_result(B, frequencies)
+
+        for i in range(num_rows):
+            self.compute_impl(X, i, C, frequencies)
+
+        return self.output_result(B, frequencies)
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """TfIdfVectorizer
+
+    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 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans,
+    )
+    input_tensor = tf_layers_dict[graph_node_input.name]['tf_node'] \
+        if isinstance(graph_node_input, gs.Variable) else graph_node_input
+
+    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,
+        'nhwc': tf_layers_dict[graph_node_input.name]['nhwc'] \
+            if isinstance(graph_node_input, gs.Variable) \
+                and 'nhwc' in tf_layers_dict[graph_node_input.name].keys() else False
+    }
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+
+    max_gram_length = int(graph_node.attrs.get('max_gram_length', 1))
+    max_skip_count = int(graph_node.attrs.get('max_skip_count', 0))
+    min_gram_length = int(graph_node.attrs.get('min_gram_length', 1))
+    mode = graph_node.attrs.get('mode', 'TF')
+    ngram_counts = graph_node.attrs.get('ngram_counts', [])
+    ngram_indexes = graph_node.attrs.get('ngram_indexes', [])
+    pool_int64s = graph_node.attrs.get('pool_int64s', None)
+    pool_strings = graph_node.attrs.get('pool_strings', None)
+    weights = graph_node.attrs.get('weights', None)
+
+    impl = _TfIdfVectorizerImpl(
+        max_gram_length=max_gram_length,
+        max_skip_count=max_skip_count,
+        min_gram_length=min_gram_length,
+        mode=mode,
+        ngram_counts=ngram_counts,
+        ngram_indexes=ngram_indexes,
+        pool_int64s=pool_int64s,
+        pool_strings=pool_strings,
+        weights=weights,
+    )
+
+    def _tfidf_numpy(x):
+        return impl.run(x)
+
+    tf_layers_dict[graph_node_output.name]['tf_node'] = \
+        tf.numpy_function(
+            func=_tfidf_numpy,
+            inp=[input_tensor],
+            Tout=tf.float32,
+            name=graph_node.name,
+        )
+    if shape is not None:
+        tf_layers_dict[graph_node_output.name]['tf_node'] = \
+            tf.ensure_shape(
+                tf_layers_dict[graph_node_output.name]['tf_node'],
+                shape,
+            )
+
+    # 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': 'TfIdfVectorizer',
+                'tf_inputs': {
+                    'max_gram_length': max_gram_length,
+                    'max_skip_count': max_skip_count,
+                    'min_gram_length': min_gram_length,
+                    'mode': mode,
+                    'ngram_counts': ngram_counts,
+                    'ngram_indexes': ngram_indexes,
+                    'pool_int64s': pool_int64s,
+                    'pool_strings': pool_strings,
+                    'weights': weights,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

{onnx2tf-1.29.22.dist-info → onnx2tf-1.29.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.22
+Version: 1.29.24
 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
@@ -122,7 +122,7 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |Cast|:heavy_check_mark:|
   |Ceil|:heavy_check_mark:|
   |Celu|:heavy_check_mark:|
-  |CenterCropPad|**Help wanted**|
+  |CenterCropPad|:heavy_check_mark:|
   |Clip|:heavy_check_mark:|
   |Col2Im|:white_check_mark:|
   |Compress|:heavy_check_mark:|
@@ -166,7 +166,7 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |GreaterOrEqual|:heavy_check_mark:|
   |Greater|:heavy_check_mark:|
   |GridSample|:white_check_mark:|
-  |GroupNormalization|**Help wanted**|
+  |GroupNormalization|:heavy_check_mark:|
   |GRU|:heavy_check_mark:|
   |HammingWindow|:white_check_mark:|
   |HannWindow|:white_check_mark:|
@@ -210,7 +210,7 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |NegativeLogLikelihoodLoss|:heavy_check_mark:|
   |NonMaxSuppression|:heavy_check_mark:|
   |NonZero|:heavy_check_mark:|
-  |Optional|**Help wanted**|
+  |Optional|:heavy_check_mark:|
   |OptionalGetElement|:heavy_check_mark:|
   |OptionalHasElement|:heavy_check_mark:|
   |Not|:heavy_check_mark:|
@@ -291,7 +291,7 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |Tan|:heavy_check_mark:|
   |Tanh|:heavy_check_mark:|
   |TensorScatter|:heavy_check_mark:|
-  |TfIdfVectorizer|**Help wanted**|
+  |TfIdfVectorizer|:white_check_mark:|
   |ThresholdedRelu|:heavy_check_mark:|
   |Tile|:heavy_check_mark:|
   |TopK|:heavy_check_mark:|
@@ -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.22
+  ghcr.io/pinto0309/onnx2tf:1.29.24
 
   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.22
+  docker.io/pinto0309/onnx2tf:1.29.24
 
   or
 
@@ -493,13 +493,20 @@ onnx2tf -i resnet18-v1-7.onnx -v info
 # without input OP name.
 # Note that if there are multiple input OPs, the zero dimension of all input OPs is
 # forced to be rewritten.
-# The `-ois` option allows undefined dimensions in all dimensions, including
-# the zero dimensionality, to be overwritten to a static shape, but requires
+# The `-sh/--shape-hints` option provides shape hints for input tensors with undefined
+# dimensions, significantly improving the conversion success rate for models with dynamic
+# input shapes. Specifying this option in combination with the `-b` option will further
+# improve the success rate of model conversion. The `-sh` option does not change ONNX
+# input OPs to static shapes.
+# The `-ois/--overwrite_input_shape` option allows undefined dimensions in all dimensions,
+# including the zero dimensionality, to be overwritten to a static shape, but requires
 # the input OP name to be specified.
 # e.g. -ois data1:1,3,224,224 data2:1,255 data3:1,224,6
 wget https://github.com/PINTO0309/onnx2tf/releases/download/0.0.2/resnet18-v1-7.onnx
 onnx2tf -i resnet18-v1-7.onnx -b 1
 or
+onnx2tf -i resnet18-v1-7.onnx -sh data:1,3,224,224 -b 1
+or
 onnx2tf -i resnet18-v1-7.onnx -ois data:1,3,224,224
 
 # Suppress automatic transposition of input OPs from NCW, NCHW, NCDHW to NWC, NHWC, NDHWC.

{onnx2tf-1.29.22.dist-info → onnx2tf-1.29.24.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx2tf/__init__.py,sha256=EUJwryuQmTqI1Huqr9hrm1fJwxQqmGxUjAFgGvuB950,67
+onnx2tf/__init__.py,sha256=W5COczfCiRCsNJlBLly_Dss2ma8U9Wk7EMVTrBRezXY,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
 onnx2tf/onnx2tf.py,sha256=BC-BFMf8QUG7PtOvpwglhe1sc4FhTO8AMrdlxKUN5jc,208204
 onnx2tf/ops/Abs.py,sha256=V7btmCG_ZvK_qJovUsguq0ZMJ349mhNQ4FHSgzP_Yuo,4029
@@ -26,6 +26,7 @@ onnx2tf/ops/BlackmanWindow.py,sha256=o_wLhYAmMearuJNlSdUfDeQm7D6g_y_H21uG-foctbA
 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
+onnx2tf/ops/CenterCropPad.py,sha256=fQH_z4nSUCPPA1ar-VWzR2PHMYXLPvPKvN3EexzTOHg,6459
 onnx2tf/ops/Clip.py,sha256=K3Pgt9BXl5_rzg6s-kPFmwElL5COsvolRY1BUTo7UWw,8753
 onnx2tf/ops/Col2Im.py,sha256=8n66z3O59VJvJRlcrj93a5TLJ_qh-aSdR_-8SAQIlRo,7658
 onnx2tf/ops/Compress.py,sha256=NvDGr9gCNl-8YG41xDBfe3UvhRP03K-ktdtY_MoytBc,3667
@@ -71,6 +72,7 @@ onnx2tf/ops/Greater.py,sha256=fhMFF0fGt2c1W_rHCy0yKAXUYThLgBVnoFmCYLPD12Q,4585
 onnx2tf/ops/GreaterOrEqual.py,sha256=sfNBveEyoU2oIlFILKlZ3jopeCnnPH2ij4J08QtIX8I,4604
 onnx2tf/ops/GridSample.py,sha256=3THBiJcB9J5eFoobiwwqqQ-BJ0pr7xK9JyTCxXixLs0,31360
 onnx2tf/ops/GroupNorm.py,sha256=zMjgkTDhb8OySDa4ZBg-45rWQQ5dy3wmqAY-Aj7izac,12026
+onnx2tf/ops/GroupNormalization.py,sha256=-ZQUoZKJkEatVQ6qdHpzUpyCeJQWTqmwGjZgkYf_PDg,8453
 onnx2tf/ops/HammingWindow.py,sha256=PY6NVvzutmFKB8UyJYl2LcwqzZGhRMg0jot96m0isCc,2891
 onnx2tf/ops/HannWindow.py,sha256=vMvtn3JwjxUqPXTXdNzk3QjH87JFAEStwwEnIl_5jKY,2882
 onnx2tf/ops/HardSigmoid.py,sha256=KDP_t-Z70sDsHMOYxyJ7ZNH31zqkrViOKYCcRG5NJHc,3662
@@ -115,10 +117,11 @@ onnx2tf/ops/NonMaxSuppression.py,sha256=nHeiX5eMGQAq_51KoljNZGlZddJ89Oe7Yfe33xLh
 onnx2tf/ops/NonZero.py,sha256=2EYZFMNIejeqR2azHw0CT2mthiKuRPQepUafzeVE8Nk,2788
 onnx2tf/ops/Not.py,sha256=wn3nThGf4gtpQdHjP7OX2xlhyaNQGeHifjZ18O5shhg,3599
 onnx2tf/ops/OneHot.py,sha256=OThLm1MF1X75zx7gep_qdnRHsTRZX_tqZxjt6pAVi7E,6489
-onnx2tf/ops/OptionalGetElement.py,sha256=Qg8Lix1_rdGtVWC-UNC91ekx3ztB-5_UtWkg67M2Z5E,3031
-onnx2tf/ops/OptionalHasElement.py,sha256=fyZMPBWvLVohsm8J5FLMlYGBDr6HVq5lh9jL-yKp-tk,3031
+onnx2tf/ops/Optional.py,sha256=x8tVVrFyX9i8u04XPF-v7XK6cH5Ney6QKCMRcuOuGxU,4252
+onnx2tf/ops/OptionalGetElement.py,sha256=YTSx7cAc74aQXarG9ChAtfXOvZaxNedLH62DZe0c_uQ,2694
+onnx2tf/ops/OptionalHasElement.py,sha256=1QD94dVcoonou5u9H4Wp8gy93R7htY3P1u_XXhI5iWI,2694
 onnx2tf/ops/Or.py,sha256=7gyUSgbEVVQBp2t3G93pZlHNn0ejJfZ3rbSDOnFgUi0,4586
-onnx2tf/ops/PRelu.py,sha256=pHbsffhb2rLZPPb9NdKUT4f5-lC0TXmbZVafookXo90,6314
+onnx2tf/ops/PRelu.py,sha256=DxLBUgxQdO5IL1--xA5lbGq7dI-kr8UKn2Mf-4j8L5Q,7769
 onnx2tf/ops/Pad.py,sha256=xZOkZK-53sXU-d0nADAjR1wOpKqfzHeJjTmzwon6G4A,11883
 onnx2tf/ops/Pow.py,sha256=DZjrWQSyLw_BPXrKyoTqT9KJIxPfNxnYVcoTDBagDgM,7056
 onnx2tf/ops/QLinearAdd.py,sha256=OssQI0pd8KXdnCC8urCPKP8bpcvSX0D76bS7q4-xMSY,5027
@@ -194,6 +197,7 @@ onnx2tf/ops/Sum.py,sha256=wtI0SbGuNFxkLskBk68ZhOAg3XyrIx-9xGYy1GZCVSo,3073
 onnx2tf/ops/Tan.py,sha256=Ncig8clGvY7GWshqxRDRdcxjcbf_HTKGdpDw5ValrKI,3582
 onnx2tf/ops/Tanh.py,sha256=PIQUvxS_AIDufblC2vc573nse2UCRA9z5yWd7kB-51s,3585
 onnx2tf/ops/TensorScatter.py,sha256=9M1L8ys2FodscRZXdjme5NQYrCFX_nZH7wm8vx-PXcc,8176
+onnx2tf/ops/TfIdfVectorizer.py,sha256=q574eLsJYj1hOx4Pnh0X5TdNHBSLOwAok1liI-r2TAY,13868
 onnx2tf/ops/ThresholdedRelu.py,sha256=ArF3uRH7jN8kdYYDNcivJgv9UTFl5aqqSH2Qu79j4sY,3769
 onnx2tf/ops/Tile.py,sha256=xkprg6yTaykivcHFJ644opzVPctaeplu-Ed-OpS98Gg,12720
 onnx2tf/ops/TopK.py,sha256=f6OG-DcMWneXwSjIkmY935SPyOMD5tMteHnlQHoJwQo,6348
@@ -211,7 +215,7 @@ 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.22.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-onnx2tf-1.29.22.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
-onnx2tf-1.29.22.dist-info/METADATA,sha256=eWX7J2epMkaxU8YW1paH77k23Lw7K4i_7WsJC9f6-is,156067
-onnx2tf-1.29.22.dist-info/RECORD,,
+onnx2tf-1.29.24.dist-info/WHEEL,sha256=5DEXXimM34_d4Gx1AuF9ysMr1_maoEtGKjaILM3s4w4,80
+onnx2tf-1.29.24.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.24.dist-info/METADATA,sha256=rGGwnT0qMDRf78t__34bQ73PElC_VPkuFYJATdo76zk,156543
+onnx2tf-1.29.24.dist-info/RECORD,,

{onnx2tf-1.29.22.dist-info → onnx2tf-1.29.24.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.9.28
+Generator: uv 0.9.29
 Root-Is-Purelib: true
 Tag: py3-none-any