onnx2tf 1.29.23__tar.gz → 1.29.24__tar.gz

{onnx2tf-1.29.23 → onnx2tf-1.29.24}/PKG-INFO

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

{onnx2tf-1.29.23 → onnx2tf-1.29.24}/README.md

@@ -80,7 +80,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:|
@@ -124,7 +124,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:|
@@ -168,7 +168,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:|
@@ -249,7 +249,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:|
@@ -323,7 +323,7 @@ Video speed is adjusted approximately 50 times slower than actual speed.
   docker run --rm -it \
   -v `pwd`:/workdir \
   -w /workdir \
-  ghcr.io/pinto0309/onnx2tf:1.29.23
+  ghcr.io/pinto0309/onnx2tf:1.29.24
 
   or
 
@@ -331,7 +331,7 @@ Video speed is adjusted approximately 50 times slower than actual speed.
   docker run --rm -it \
   -v `pwd`:/workdir \
   -w /workdir \
-  docker.io/pinto0309/onnx2tf:1.29.23
+  docker.io/pinto0309/onnx2tf:1.29.24
 
   or
 

{onnx2tf-1.29.23 → onnx2tf-1.29.24}/onnx2tf/__init__.py

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

onnx2tf-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-1.29.24/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-1.29.24/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-1.29.23 → onnx2tf-1.29.24}/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