onnx2tf 1.29.18__py3-none-any.whl → 1.29.19__py3-none-any.whl

onnx2tf/__init__.py

@@ -1,3 +1,3 @@
 from onnx2tf.onnx2tf import convert, main
 
-__version__ = '1.29.18'
+__version__ = '1.29.19'

onnx2tf/ops/Col2Im.py

@@ -1,9 +1,9 @@
+import sys
 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,
@@ -14,57 +14,32 @@ from onnx2tf.utils.common_functions import (
     pre_process_transpose,
     post_process_transpose,
 )
+from onnx2tf.utils.logging import *
 
 
-class Col2ImLayer(tf_keras.layers.Layer):
-    def __init__(self):
-        super(Col2ImLayer, self).__init__()
+def _build_col2im_kernel(
+    *,
+    k_h,
+    k_w,
+    dilation_h,
+    dilation_w,
+    dtype,
+):
+    k_h = tf.cast(k_h, tf.int32)
+    k_w = tf.cast(k_w, tf.int32)
+    eff_k_h = (k_h - 1) * dilation_h + 1
+    eff_k_w = (k_w - 1) * dilation_w + 1
 
-    def call(
-        self,
-        input_tensor,
-        input_block_shape,
-        strides,
-        input_image_shape,
-        pads,
-        dilations,
-        output_shape = None,
-    ):
-        N, _, L = input_tensor.shape
-        if output_shape is not None:
-            C = tf.convert_to_tensor(output_shape[1])
-            output_shape = tf.convert_to_tensor([output_shape[0]] + [s for s in output_shape[2:]] + [output_shape[1]])
-        else:
-            C = tf.convert_to_tensor(input_tensor.shape[1] // (input_block_shape[0] * input_block_shape[1]))
-            output_shape = tf.convert_to_tensor([N] + input_image_shape + [C])
-        im = tf.TensorArray(input_tensor.dtype, size=N, dynamic_size=True)
-
-        def loop_over_l(n, im_n, l):
-            row_idx = tf.convert_to_tensor((l // ((input_image_shape[1] - (input_block_shape[1] - 1) * dilations[1] - 1 + strides[1]) // strides[1])) * strides[0])
-            col_idx = tf.convert_to_tensor((l % ((input_image_shape[1] - (input_block_shape[1] - 1) * dilations[1] - 1 + strides[1]) // strides[1])) * strides[1])
-
-            def loop_over_c(c, im_n):
-                patch_idx = tf.convert_to_tensor(c * input_block_shape[0] * input_block_shape[1])
-                patch = tf.reshape(input_tensor[n, patch_idx:patch_idx + input_block_shape[0] * input_block_shape[1], l], input_block_shape)
-                if dilations[0] > 1 or dilations[1] > 1:
-                    dilated_patch = tf.zeros([(input_block_shape[0] - 1) * dilations[0] + 1, (input_block_shape[1] - 1) * dilations[1] + 1], dtype=patch.dtype)
-                    for i in tf.range(input_block_shape[0]):
-                        for j in tf.range(input_block_shape[1]):
-                            dilated_patch = tf.tensor_scatter_nd_update(dilated_patch, [[i * dilations[0], j * dilations[1]]], [patch[i, j]])
-                    patch = dilated_patch
-                patch_shape = tf.shape(patch)
-                indices = tf.reshape(tf.stack(tf.meshgrid(row_idx + tf.range(patch_shape[0]), col_idx + tf.range(patch_shape[1]), c, indexing='ij'), axis=-1), [-1, 3])
-                updates = tf.reshape(patch, [-1])
-                return tf.tensor_scatter_nd_add(im_n, indices, updates)
-            return tf.reduce_sum(tf.map_fn(lambda c: loop_over_c(c, im_n), tf.range(C), dtype=im_n.dtype), axis=0)
-
-        def loop_over_n(n):
-            im_n = tf.zeros(output_shape[1:], dtype=input_tensor.dtype)
-            return tf.reduce_sum(tf.map_fn(lambda l: loop_over_l(n, im_n, l), tf.range(L), dtype=im_n.dtype), axis=0)
-
-        im = tf.map_fn(loop_over_n, tf.range(N), dtype=input_tensor.dtype)
-
-        return im[:, pads[0]:input_image_shape[0]-pads[2], pads[1]:input_image_shape[1]-pads[3], :]
+    ky = tf.reshape(tf.repeat(tf.range(k_h), k_w), tf.stack([k_h, k_w]))
+    kx = tf.reshape(tf.tile(tf.range(k_w), [k_h]), tf.stack([k_h, k_w]))
+
+    positions = ky * dilation_h * eff_k_w + kx * dilation_w
+    positions = tf.reshape(positions, [-1])
+    one_hot = tf.one_hot(positions, depth=eff_k_h * eff_k_w, dtype=dtype)
+    kernel = tf.reshape(one_hot, tf.stack([k_h * k_w, eff_k_h, eff_k_w]))
+    kernel = tf.transpose(kernel, [1, 2, 0])
+    kernel = tf.expand_dims(kernel, axis=2)
+    return kernel, eff_k_h, eff_k_w
 
 
 @print_node_info
@@ -114,10 +89,9 @@ def make_node(
     input_block_shape = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
         if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
 
-    spatial_size = len(input_image_shape)
-    dilations = graph_node.attrs.get('dilations', [1] * spatial_size)
-    pads = graph_node.attrs.get('pads', [0, 0] * spatial_size)
-    strides = graph_node.attrs.get('strides', [1] * spatial_size)
+    dilations = graph_node.attrs.get('dilations', [1, 1])
+    pads = graph_node.attrs.get('pads', [0, 0, 0, 0])
+    strides = graph_node.attrs.get('strides', [1, 1])
 
     # Preserving Graph Structure (Dict)
     tf_layers_dict[graph_node_output.name] = {
@@ -142,17 +116,87 @@ def make_node(
         tf_layers_dict[graph_node_output.name].pop('nhwc')
 
     # Generation of TF OP
-    col2im = Col2ImLayer()
-    tf_layers_dict[graph_node_output.name]['tf_node'] = \
-        col2im(
-            input_tensor=input_tensor,
-            input_block_shape=input_block_shape,
-            strides=strides,
-            input_image_shape=input_image_shape,
-            pads=pads,
-            dilations=dilations,
-            output_shape=shape,
-        )
+    original_dtype = input_tensor.dtype
+    compute_dtype = original_dtype
+    if original_dtype not in (tf.float16, tf.float32, tf.float64, tf.bfloat16):
+        if original_dtype in (tf.complex64, tf.complex128):
+            error('Col2Im does not support complex types in non-Flex implementation.')
+            sys.exit(1)
+        compute_dtype = tf.float32
+        input_tensor = tf.cast(input_tensor, compute_dtype)
+
+    input_image_shape = tf.cast(input_image_shape, tf.int32)
+    input_block_shape = tf.cast(input_block_shape, tf.int32)
+
+    if input_image_shape.shape is not None \
+        and input_image_shape.shape.rank is not None \
+        and input_image_shape.shape.rank != 1:
+        error('Col2Im supports only 2D image_shape input.')
+        sys.exit(1)
+
+    if input_block_shape.shape is not None \
+        and input_block_shape.shape.rank is not None \
+        and input_block_shape.shape.rank != 1:
+        error('Col2Im supports only 2D block_shape input.')
+        sys.exit(1)
+
+    k_h = input_block_shape[0]
+    k_w = input_block_shape[1]
+    h_img = input_image_shape[0]
+    w_img = input_image_shape[1]
+
+    stride_h, stride_w = strides
+    dilation_h, dilation_w = dilations
+    pad_top, pad_left, pad_bottom, pad_right = pads
+
+    kernel, eff_k_h, eff_k_w = _build_col2im_kernel(
+        k_h=k_h,
+        k_w=k_w,
+        dilation_h=dilation_h,
+        dilation_w=dilation_w,
+        dtype=compute_dtype,
+    )
+
+    h_pad = h_img + pad_top + pad_bottom
+    w_pad = w_img + pad_left + pad_right
+
+    out_h = tf.math.floordiv(h_pad - eff_k_h, stride_h) + 1
+    out_w = tf.math.floordiv(w_pad - eff_k_w, stride_w) + 1
+
+    input_shape = tf.shape(input_tensor)
+    n = input_shape[0]
+    ck = input_shape[1]
+    c = tf.math.floordiv(ck, k_h * k_w)
+
+    cols = tf.reshape(
+        input_tensor,
+        tf.stack([n, c, k_h * k_w, out_h, out_w]),
+    )
+    cols = tf.transpose(cols, [0, 1, 3, 4, 2])
+    cols = tf.reshape(cols, tf.stack([n * c, out_h, out_w, k_h * k_w]))
+
+    output_shape = tf.stack([n * c, h_pad, w_pad, 1])
+    output = tf.nn.conv2d_transpose(
+        cols,
+        kernel,
+        output_shape=output_shape,
+        strides=[1, stride_h, stride_w, 1],
+        padding='VALID',
+    )
+
+    output = tf.reshape(output, tf.stack([n, c, h_pad, w_pad]))
+    output = tf.transpose(output, [0, 2, 3, 1])
+
+    output = tf.slice(
+        output,
+        tf.stack([0, pad_top, pad_left, 0]),
+        tf.stack([-1, h_img, w_img, -1]),
+    )
+
+    if output.dtype != original_dtype:
+        output = tf.cast(output, original_dtype)
+
+    tf_layers_dict[graph_node_output.name]['tf_node'] = output
 
     # Post-process transpose
     before_trans_shape = tf_layers_dict[graph_node_output.name]['tf_node'].shape

onnx2tf/ops/DFT.py

@@ -0,0 +1,245 @@
+import sys
+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,
+)
+from onnx2tf.utils.logging import *
+
+
+def _normalize_axis(axis, rank):
+    axis = tf.cast(axis, tf.int32)
+    rank = tf.cast(rank, tf.int32)
+    return tf.where(axis < 0, axis + rank, axis)
+
+
+def _move_axis_to_last(x, axis):
+    rank = tf.rank(x)
+    axis = _normalize_axis(axis, rank)
+    range0 = tf.range(axis)
+    range1 = tf.range(axis + 1, rank)
+    perm = tf.concat([range0, range1, [axis]], axis=0)
+    x_t = tf.transpose(x, perm)
+    inv_perm = tf.argsort(perm)
+    return x_t, inv_perm
+
+
+def _pad_or_slice_last(x, length):
+    length = tf.cast(length, tf.int32)
+    current = tf.shape(x)[-1]
+
+    def _pad():
+        pad_amount = length - current
+        pad = tf.concat(
+            [
+                tf.zeros([tf.rank(x) - 1, 2], dtype=tf.int32),
+                tf.stack([[0, pad_amount]]),
+            ],
+            axis=0,
+        )
+        return tf.pad(x, pad)
+
+    def _slice():
+        return x[..., :length]
+
+    x = tf.cond(current < length, _pad, lambda: x)
+    x = tf.cond(current > length, _slice, lambda: x)
+    return x
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """DFT
+
+    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)
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans_1,
+    )
+    graph_node_input_2 = get_constant_or_variable(
+        graph_node.inputs[1],
+        before_op_output_shape_trans=False,
+    ) if len(graph_node.inputs) >= 2 else None
+    graph_node_input_3 = get_constant_or_variable(
+        graph_node.inputs[2],
+        before_op_output_shape_trans=False,
+    ) if len(graph_node.inputs) >= 3 else None
+
+    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_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    dft_length = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+    axis = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
+        if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
+
+    onesided = bool(graph_node.attrs.get('onesided', 0))
+    inverse = bool(graph_node.attrs.get('inverse', 0))
+
+    # 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_1.name]['nhwc'] \
+            if isinstance(graph_node_input_1, gs.Variable) \
+                and 'nhwc' in tf_layers_dict[graph_node_input_1.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 = tf.rank(input_tensor)
+    axis_attr = graph_node.attrs.get('axis', None)
+    if axis is None:
+        if axis_attr is not None:
+            axis = tf.constant(axis_attr, dtype=tf.int32)
+        else:
+            axis = tf.cast(input_rank - 2, tf.int32)
+    else:
+        axis = tf.cast(tf.reshape(axis, []), tf.int32)
+    axis = _normalize_axis(axis, input_rank)
+
+    dft_length_value = None
+    if dft_length is not None:
+        dft_length_value = tf.cast(tf.reshape(dft_length, []), tf.int32)
+
+    input_dtype = input_tensor.dtype
+    if input_dtype in (tf.float64,):
+        float_dtype = tf.float64
+        complex_dtype = tf.complex128
+    elif input_dtype in (tf.float32,):
+        float_dtype = tf.float32
+        complex_dtype = tf.complex64
+    elif input_dtype in (tf.float16, tf.bfloat16):
+        float_dtype = tf.float32
+        complex_dtype = tf.complex64
+    else:
+        error('DFT supports float/bfloat16 types only.')
+        sys.exit(1)
+
+    # Convert to complex tensor (drop last dim)
+    last_dim_static = input_tensor.shape[-1]
+    if last_dim_static is not None:
+        if last_dim_static == 1:
+            real = tf.squeeze(input_tensor, axis=-1)
+            imag = tf.zeros_like(real)
+        elif last_dim_static == 2:
+            real, imag = tf.unstack(input_tensor, axis=-1)
+        else:
+            error('DFT input last dimension must be 1 or 2.')
+            sys.exit(1)
+    else:
+        last_dim = tf.shape(input_tensor)[-1]
+        def _real_case():
+            real = tf.squeeze(input_tensor, axis=-1)
+            imag = tf.zeros_like(real)
+            return real, imag
+        def _complex_case():
+            real, imag = tf.unstack(input_tensor, axis=-1)
+            return real, imag
+        real, imag = tf.cond(
+            tf.equal(last_dim, 1),
+            _real_case,
+            _complex_case,
+        )
+
+    real = tf.cast(real, float_dtype)
+    imag = tf.cast(imag, float_dtype)
+    signal = tf.complex(real, imag)
+
+    signal_t, inv_perm = _move_axis_to_last(signal, axis)
+    signal_len = tf.shape(signal_t)[-1]
+
+    if onesided and inverse:
+        if last_dim_static == 1:
+            error('DFT onesided inverse supports only complex input.')
+            sys.exit(1)
+        if dft_length_value is None:
+            dft_length_value = tf.cast(signal_len * 2 - 2, tf.int32)
+        out_real = tf.signal.irfft(signal_t, fft_length=[dft_length_value])
+        out_real = tf.transpose(out_real, inv_perm)
+        output = tf.expand_dims(out_real, axis=-1)
+    elif onesided and not inverse:
+        if last_dim_static == 2:
+            error('DFT onesided forward supports only real input.')
+            sys.exit(1)
+        if dft_length_value is None:
+            dft_length_value = tf.cast(signal_len, tf.int32)
+        real_signal = tf.math.real(signal_t)
+        out_complex = tf.signal.rfft(real_signal, fft_length=[dft_length_value])
+        out_complex = tf.transpose(out_complex, inv_perm)
+        output = tf.stack([tf.math.real(out_complex), tf.math.imag(out_complex)], axis=-1)
+    else:
+        if dft_length_value is not None:
+            signal_t = _pad_or_slice_last(signal_t, dft_length_value)
+        if inverse:
+            out_complex = tf.signal.ifft(signal_t)
+        else:
+            out_complex = tf.signal.fft(signal_t)
+        out_complex = tf.transpose(out_complex, inv_perm)
+        output = tf.stack([tf.math.real(out_complex), tf.math.imag(out_complex)], axis=-1)
+
+    if output.dtype != input_dtype:
+        output = tf.cast(output, input_dtype)
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=output,
+        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': 'DFT',
+                'tf_inputs': {
+                    'input': input_tensor,
+                    'axis': axis,
+                    'dft_length': dft_length_value,
+                    'onesided': onesided,
+                    'inverse': inverse,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

onnx2tf/ops/DeformConv.py

@@ -0,0 +1,399 @@
+import sys
+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,
+    get_weights_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.logging import *
+
+INF_INDEX_VALUE: int = 4294967296
+
+
+def _to_int_tensor(value, name=None):
+    if isinstance(value, tf.Tensor):
+        return tf.cast(value, tf.int32)
+    return tf.constant(value, dtype=tf.int32, name=name)
+
+
+def _bilinear_sample_2d(
+    image,
+    coords,
+):
+    """
+    image: [N, H, W, C]
+    coords: [N, oH, oW, kH, kW, 2] in absolute coords (y, x)
+    """
+    coord_dtype = coords.dtype
+    h = tf.shape(image)[1]
+    w = tf.shape(image)[2]
+    h_f = tf.cast(h, coord_dtype)
+    w_f = tf.cast(w, coord_dtype)
+    max_y = h_f - 1.0
+    max_x = w_f - 1.0
+
+    y, x = tf.split(coords, num_or_size_splits=2, axis=-1)
+
+    y0 = tf.floor(y)
+    x0 = tf.floor(x)
+    y1 = y0 + 1.0
+    x1 = x0 + 1.0
+
+    dy = y - y0
+    dx = x - x0
+
+    w00 = (1.0 - dy) * (1.0 - dx)
+    w10 = dy * (1.0 - dx)
+    w11 = dy * dx
+    w01 = (1.0 - dy) * dx
+
+    def _in_bounds(y_idx, x_idx):
+        return tf.logical_and(
+            tf.logical_and(y_idx >= 0.0, y_idx <= max_y),
+            tf.logical_and(x_idx >= 0.0, x_idx <= max_x),
+        )
+
+    m00 = _in_bounds(y0, x0)
+    m10 = _in_bounds(y1, x0)
+    m11 = _in_bounds(y1, x1)
+    m01 = _in_bounds(y0, x1)
+
+    y0c = tf.clip_by_value(y0, 0.0, max_y)
+    x0c = tf.clip_by_value(x0, 0.0, max_x)
+    y1c = tf.clip_by_value(y1, 0.0, max_y)
+    x1c = tf.clip_by_value(x1, 0.0, max_x)
+
+    y0i = tf.cast(y0c, tf.int32)
+    x0i = tf.cast(x0c, tf.int32)
+    y1i = tf.cast(y1c, tf.int32)
+    x1i = tf.cast(x1c, tf.int32)
+
+    input_flat = tf.reshape(image, tf.stack([tf.shape(image)[0], h * w, tf.shape(image)[3]]))
+
+    def _gather(y_idx, x_idx):
+        linear = y_idx * w + x_idx
+        linear = tf.squeeze(linear, axis=-1)
+        return tf.gather(input_flat, linear, batch_dims=1)
+
+    v00 = _gather(y0i, x0i)
+    v10 = _gather(y1i, x0i)
+    v11 = _gather(y1i, x1i)
+    v01 = _gather(y0i, x1i)
+
+    m00 = tf.cast(m00, image.dtype)
+    m10 = tf.cast(m10, image.dtype)
+    m11 = tf.cast(m11, image.dtype)
+    m01 = tf.cast(m01, image.dtype)
+
+    output = w00 * m00 * v00 + w10 * m10 * v10 + w11 * m11 * v11 + w01 * m01 * v01
+    return output
+
+
+@print_node_info
+@inverted_operation_enable_disable
+@get_replacement_parameter
+def make_node(
+    *,
+    graph_node: gs.Node,
+    tf_layers_dict: dict,
+    **kwargs: dict,
+):
+    """DeformConv
+
+    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_3 = \
+        tf_layers_dict.get(graph_node.inputs[2].name, {}).get('before_op_output_shape_trans', True)
+    before_op_output_shape_trans_4 = \
+        tf_layers_dict.get(graph_node.inputs[3].name, {}).get('before_op_output_shape_trans', True) \
+            if len(graph_node.inputs) >= 4 else True
+    before_op_output_shape_trans_5 = \
+        tf_layers_dict.get(graph_node.inputs[4].name, {}).get('before_op_output_shape_trans', True) \
+            if len(graph_node.inputs) >= 5 else True
+
+    graph_node_input_1 = get_constant_or_variable(
+        graph_node.inputs[0],
+        before_op_output_shape_trans_1,
+    )
+
+    kernel_shape = graph_node.attrs.get('kernel_shape', [])
+    if kernel_shape == [] and graph_node.inputs[1].shape is not None:
+        kernel_shape = graph_node.inputs[1].shape[2:]
+    kernel_size = len(kernel_shape) if kernel_shape != [] else 2
+
+    graph_node_input_2 = get_weights_constant_or_variable(
+        const_or_var=graph_node.inputs[1],
+        kernel_size=kernel_size,
+    )
+    graph_node_input_3 = get_constant_or_variable(
+        graph_node.inputs[2],
+        before_op_output_shape_trans_3,
+    )
+    graph_node_input_4 = get_constant_or_variable(
+        graph_node.inputs[3],
+        before_op_output_shape_trans_4,
+    ) if len(graph_node.inputs) >= 4 else None
+    graph_node_input_5 = get_constant_or_variable(
+        graph_node.inputs[4],
+        before_op_output_shape_trans_5,
+    ) if len(graph_node.inputs) >= 5 else None
+
+    graph_node_output: gs.Variable = graph_node.outputs[0]
+    output_tensor_shape = graph_node_output.shape
+    dtype = graph_node_output.dtype
+
+    input_tensor = tf_layers_dict[graph_node_input_1.name]['tf_node'] \
+        if isinstance(graph_node_input_1, gs.Variable) else graph_node_input_1
+    weights = tf_layers_dict[graph_node_input_2.name]['tf_node'] \
+        if isinstance(graph_node_input_2, gs.Variable) else graph_node_input_2
+    offset = tf_layers_dict[graph_node_input_3.name]['tf_node'] \
+        if isinstance(graph_node_input_3, gs.Variable) else graph_node_input_3
+    bias = tf_layers_dict[graph_node_input_4.name]['tf_node'] \
+        if isinstance(graph_node_input_4, gs.Variable) else graph_node_input_4
+    mask = tf_layers_dict[graph_node_input_5.name]['tf_node'] \
+        if isinstance(graph_node_input_5, gs.Variable) else graph_node_input_5
+
+    input_tensor_shape = input_tensor.shape
+
+    if input_tensor_shape is not None and len(input_tensor_shape) != 4:
+        error('DeformConv currently supports only 2D inputs (N, C, H, W).')
+        sys.exit(1)
+
+    # Preserving Graph Structure (Dict)
+    tf_layers_dict[graph_node_output.name] = {
+        'optype': graph_node.op,
+        'shape': output_tensor_shape,
+        'dtype': dtype,
+        'nhwc': True,
+    }
+
+    # Pre-process transpose
+    input_tensor = pre_process_transpose(
+        value_before_transpose=input_tensor,
+        param_target='inputs',
+        param_name=graph_node.inputs[0].name,
+        **kwargs,
+    )
+    offset = pre_process_transpose(
+        value_before_transpose=offset,
+        param_target='inputs',
+        param_name=graph_node.inputs[2].name,
+        **kwargs,
+    )
+    if mask is not None:
+        mask = pre_process_transpose(
+            value_before_transpose=mask,
+            param_target='inputs',
+            param_name=graph_node.inputs[4].name,
+            **kwargs,
+        )
+
+    input_dtype = input_tensor.dtype
+    if weights is not None and weights.dtype != input_dtype:
+        weights = tf.cast(weights, input_dtype)
+    if offset is not None and offset.dtype != input_dtype:
+        offset = tf.cast(offset, input_dtype)
+    if bias is not None and bias.dtype != input_dtype:
+        bias = tf.cast(bias, input_dtype)
+    if mask is not None and mask.dtype != input_dtype:
+        mask = tf.cast(mask, input_dtype)
+
+    # Workaround to avoid as many conversion failures as possible
+    onnx_input_shape = [
+        dim if isinstance(dim, int) else None for dim in graph_node.inputs[0].shape
+    ] if graph_node.inputs[0].shape is not None else None
+    tf_input_shape = [
+        dim if isinstance(dim, int) else None for dim in input_tensor.shape
+    ]
+    if onnx_input_shape is not None \
+        and len(onnx_input_shape) > 1 and len(tf_input_shape) > 1 \
+        and onnx_input_shape == tf_input_shape:
+
+        shape_for_judging_skip = [
+            dim if dim is not None else INF_INDEX_VALUE for dim in onnx_input_shape[1:]
+        ]
+        if shape_for_judging_skip.count(shape_for_judging_skip[0]) != len(shape_for_judging_skip):
+            input_tensor = transpose_with_flexing_deterrence(
+                input_tensor=input_tensor,
+                perm=[0,2,3,1],
+                **kwargs,
+            )
+            offset = transpose_with_flexing_deterrence(
+                input_tensor=offset,
+                perm=[0,2,3,1],
+                **kwargs,
+            )
+            if mask is not None:
+                mask = transpose_with_flexing_deterrence(
+                    input_tensor=mask,
+                    perm=[0,2,3,1],
+                    **kwargs,
+                )
+
+    # Attributes
+    dilations = graph_node.attrs.get('dilations', [1, 1])
+    group = graph_node.attrs.get('group', 1)
+    offset_group = graph_node.attrs.get('offset_group', 1)
+    pads = graph_node.attrs.get('pads', [0, 0, 0, 0])
+    strides = graph_node.attrs.get('strides', [1, 1])
+
+    dilation_h, dilation_w = dilations
+    stride_h, stride_w = strides
+    pad_top, pad_left, pad_bottom, pad_right = pads
+
+    # Input prep
+    if pad_top != 0 or pad_bottom != 0 or pad_left != 0 or pad_right != 0:
+        input_tensor = tf.pad(
+            input_tensor,
+            paddings=[[0, 0], [pad_top, pad_bottom], [pad_left, pad_right], [0, 0]],
+        )
+
+    batch = tf.shape(input_tensor)[0]
+    in_h = tf.shape(input_tensor)[1]
+    in_w = tf.shape(input_tensor)[2]
+    in_c = tf.shape(input_tensor)[3]
+
+    offset_shape = tf.shape(offset)
+    out_h = offset_shape[1]
+    out_w = offset_shape[2]
+
+    # Kernel shape
+    if kernel_shape != []:
+        kh = _to_int_tensor(kernel_shape[0])
+        kw = _to_int_tensor(kernel_shape[1])
+    else:
+        kh = _to_int_tensor(tf.shape(weights)[0])
+        kw = _to_int_tensor(tf.shape(weights)[1])
+
+    # Base grid: [oH, oW, kH, kW, 2]
+    oy = tf.range(out_h, dtype=input_dtype) * tf.cast(stride_h, input_dtype)
+    ox = tf.range(out_w, dtype=input_dtype) * tf.cast(stride_w, input_dtype)
+    ky = tf.range(kh, dtype=input_dtype) * tf.cast(dilation_h, input_dtype)
+    kx = tf.range(kw, dtype=input_dtype) * tf.cast(dilation_w, input_dtype)
+
+    oy = tf.reshape(oy, tf.stack([out_h, 1, 1, 1]))
+    ox = tf.reshape(ox, tf.stack([1, out_w, 1, 1]))
+    ky = tf.reshape(ky, tf.stack([1, 1, kh, 1]))
+    kx = tf.reshape(kx, tf.stack([1, 1, 1, kw]))
+
+    y = oy + ky
+    x = ox + kx
+    target_shape = tf.stack([out_h, out_w, kh, kw])
+    y = tf.broadcast_to(y, target_shape)
+    x = tf.broadcast_to(x, target_shape)
+    base_grid = tf.stack([y, x], axis=-1)
+
+    # Offset reshape: [N, oH, oW, Goff, kH, kW, 2]
+    offset = tf.reshape(
+        offset,
+        tf.stack([batch, out_h, out_w, offset_group, kh, kw, 2]),
+    )
+
+    coords = base_grid[None, :, :, None, :, :, :] + offset
+    coords = tf.transpose(coords, [0, 3, 1, 2, 4, 5, 6])
+    coords = tf.reshape(coords, tf.stack([batch * offset_group, out_h, out_w, kh, kw, 2]))
+
+    # Input grouping for offset_group
+    c_per_offset = tf.math.floordiv(in_c, offset_group)
+    input_tensor = tf.reshape(
+        input_tensor,
+        tf.stack([batch, in_h, in_w, offset_group, c_per_offset]),
+    )
+    input_tensor = tf.transpose(input_tensor, [0, 3, 1, 2, 4])
+    input_tensor = tf.reshape(
+        input_tensor,
+        tf.stack([batch * offset_group, in_h, in_w, c_per_offset]),
+    )
+
+    sampled = _bilinear_sample_2d(input_tensor, coords)
+    sampled = tf.reshape(
+        sampled,
+        tf.stack([batch, offset_group, out_h, out_w, kh, kw, c_per_offset]),
+    )
+    sampled = tf.transpose(sampled, [0, 2, 3, 1, 4, 5, 6])
+
+    if mask is not None:
+        mask = tf.reshape(
+            mask,
+            tf.stack([batch, out_h, out_w, offset_group, kh, kw, 1]),
+        )
+        sampled = sampled * tf.cast(mask, sampled.dtype)
+
+    # Merge offset_group back to channel dim: [N, oH, oW, kH, kW, C]
+    sampled = tf.reshape(
+        sampled,
+        tf.stack([batch, out_h, out_w, kh, kw, in_c]),
+    )
+
+    # Grouped convolution via batched matmul
+    out_c = tf.shape(weights)[3]
+    c_per_group = tf.math.floordiv(in_c, group)
+    out_c_per_group = tf.math.floordiv(out_c, group)
+
+    cols = tf.reshape(sampled, tf.stack([batch * out_h * out_w, kh * kw * in_c]))
+    cols = tf.reshape(cols, tf.stack([batch * out_h * out_w, group, kh * kw * c_per_group]))
+    cols = tf.transpose(cols, [1, 0, 2])
+
+    weights = tf.reshape(weights, tf.stack([kh, kw, c_per_group, group, out_c_per_group]))
+    weights = tf.transpose(weights, [3, 0, 1, 2, 4])
+    weights = tf.reshape(weights, tf.stack([group, kh * kw * c_per_group, out_c_per_group]))
+
+    output = tf.matmul(cols, weights)
+    output = tf.transpose(output, [1, 0, 2])
+    output = tf.reshape(output, tf.stack([batch, out_h, out_w, out_c]))
+
+    if bias is not None:
+        output += tf.reshape(bias, tf.stack([1, 1, 1, out_c]))
+
+    if output.dtype != input_dtype:
+        output = tf.cast(output, input_dtype)
+
+    # Post-process transpose
+    tf_layers_dict[graph_node_output.name]['tf_node'] = post_process_transpose(
+        value_before_transpose=output,
+        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': 'DeformConv',
+                'tf_inputs': {
+                    'input_tensor': input_tensor,
+                    'weights': weights,
+                    'offset': offset,
+                    'bias': bias,
+                    'mask': mask,
+                    'strides': strides,
+                    'dilations': dilations,
+                    'pads': pads,
+                    'group': group,
+                    'offset_group': offset_group,
+                },
+                'tf_outputs': {
+                    'output': tf_layers_dict[graph_node_output.name]['tf_node'],
+                },
+            }
+        )

{onnx2tf-1.29.18.dist-info → onnx2tf-1.29.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx2tf
-Version: 1.29.18
+Version: 1.29.19
 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
@@ -137,11 +137,11 @@ https://github.com/PINTO0309/onnx2tf/wiki/model_status
   |Cos|:heavy_check_mark:|
   |CumProd|:heavy_check_mark:|
   |CumSum|:heavy_check_mark:|
-  |DeformConv|**Help wanted**|
+  |DeformConv|:white_check_mark:|
   |DepthToSpace|:heavy_check_mark:|
   |Det|:heavy_check_mark:|
   |DequantizeLinear|:heavy_check_mark:|
-  |DFT|**Help wanted**|
+  |DFT|:white_check_mark:|
   |Div|:heavy_check_mark:|
   |Dropout|:heavy_check_mark:|
   |DynamicQuantizeLinear|: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.18
+  ghcr.io/pinto0309/onnx2tf:1.29.19
 
   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.18
+  docker.io/pinto0309/onnx2tf:1.29.19
 
   or
 

{onnx2tf-1.29.18.dist-info → onnx2tf-1.29.19.dist-info}/RECORD

@@ -1,4 +1,4 @@
-onnx2tf/__init__.py,sha256=GJI-T9Q6ftbR-PwGyLk5t5_Iv3hvUC3prwy56yvn7vA,67
+onnx2tf/__init__.py,sha256=j0g0sP9V7WMAY5PXs_oOHLBgUSJ1dcjLILPUq39xOnU,67
 onnx2tf/__main__.py,sha256=2RSCQ7d4lc6CwD-rlGn9UicPFg-P5du7ZD_yh-kuBEU,57
 onnx2tf/onnx2tf.py,sha256=y8FewjpNYAFnUs0cjq6JzdYkiXQSm1o_sZ3PXLJzK64,161921
 onnx2tf/ops/Abs.py,sha256=V7btmCG_ZvK_qJovUsguq0ZMJ349mhNQ4FHSgzP_Yuo,4029
@@ -27,7 +27,7 @@ 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/Clip.py,sha256=K3Pgt9BXl5_rzg6s-kPFmwElL5COsvolRY1BUTo7UWw,8753
-onnx2tf/ops/Col2Im.py,sha256=MDqck00gURrbsroJAgUDkxmdsGyE9v2ez4NKdvdq5IY,7514
+onnx2tf/ops/Col2Im.py,sha256=8n66z3O59VJvJRlcrj93a5TLJ_qh-aSdR_-8SAQIlRo,7658
 onnx2tf/ops/Compress.py,sha256=NvDGr9gCNl-8YG41xDBfe3UvhRP03K-ktdtY_MoytBc,3667
 onnx2tf/ops/Concat.py,sha256=kDk7LN01nHuQyYnEPUEikSQ-M17jguAc-qFtCb9tg9I,38537
 onnx2tf/ops/ConcatFromSequence.py,sha256=z8pNmGQRGq9cxWORW330NZS_0zsmhFudLswMyPn8AXU,3086
@@ -40,6 +40,8 @@ onnx2tf/ops/Cos.py,sha256=0v5ZJZRzrswVEObyxf4f0RvnWMWZA4uCEdoeq_VE31s,3608
 onnx2tf/ops/Cosh.py,sha256=-L3QkQtiVBJIv1sSxbXtetVIwgI_2T4WC1O4t2aJ8Gc,3585
 onnx2tf/ops/CumProd.py,sha256=k4hTEQrkwS7vk7pEy2Btvy2y0o70NlWj1MgsNomfOPg,3957
 onnx2tf/ops/CumSum.py,sha256=SYKmD5r9Cm9gsCkJPNFoHigvvBO1PmRYRrVmn1HE78o,3954
+onnx2tf/ops/DFT.py,sha256=rL_w1z16N9Kkf0TyMbywOawld0qZ_g1QOD9npGYD_zY,8086
+onnx2tf/ops/DeformConv.py,sha256=tlhZDzNYAT093PkBDP4s6-EO-vnSdW_0KZTxtddjajM,13541
 onnx2tf/ops/DepthToSpace.py,sha256=BiyBZ88dmXQAkZ5Jc-Ddo-5Kn8dRYCnoik_XnOFzqXc,14449
 onnx2tf/ops/DequantizeLinear.py,sha256=1v43E1hUqO3g7N-PL1fy_cGj4oUgbphh7vXIGhUAyGc,6463
 onnx2tf/ops/Det.py,sha256=kxuHkpv_KNHkof0uBv2RLtr3G1uA76MFHyCiCYCBXkw,3590
@@ -209,7 +211,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.18.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
-onnx2tf-1.29.18.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
-onnx2tf-1.29.18.dist-info/METADATA,sha256=9JTkd8SawqhrnG2GYMLaI8rvpkmiUJMRUdGvEhbGSBE,154306
-onnx2tf-1.29.18.dist-info/RECORD,,
+onnx2tf-1.29.19.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+onnx2tf-1.29.19.dist-info/entry_points.txt,sha256=GuhvLu7ZlYECumbmoiFlKX0mFPtFi_Ti9L-E5yuQqKs,42
+onnx2tf-1.29.19.dist-info/METADATA,sha256=rSyPbOdWaW3QovkZCVvFg5zn_INzTCm8KN_rjZBah0Q,154312
+onnx2tf-1.29.19.dist-info/RECORD,,