This is an automated email from the ASF dual-hosted git repository.

mshr-h pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tvm.git


The following commit(s) were added to refs/heads/main by this push:
     new 81c7105481 [Relax][Frontend][ONNX] Add DFT operator converter (#20952)
81c7105481 is described below

commit 81c7105481c71b4d4a0df9046b736d3efbc05eec
Author: Chaitanya140904 <[email protected]>
AuthorDate: Tue Nov 17 16:01:24 2026 +0530

    [Relax][Frontend][ONNX] Add DFT operator converter (#20952)
    
    This PR adds support for the ONNX `DFT` operator in the Relax ONNX
    frontend, resolving #20960.
    
    ### Key Changes
    - In `python/tvm/relax/frontend/onnx/onnx_frontend.py`:
      - Implemented `DFT` op converter supporting opset 17 and 20.
    - Supports forward and inverse DFT, full spectrum and one-sided spectrum
    (`onesided=1`).
      - Supports both real (`[..., 1]`) and complex (`[..., 2]`) inputs.
    - Supports `axis` as attribute (opset 17) and `axis` as input tensor
    (opset 20).
      - Handles signal zero-padding and truncation with `dft_length`.
    - Formulates transform via matrix multiplication with precomputed
    trigonometric matrices (`C = cos(2*pi*n*k/N)`, `S = sin(2*pi*n*k/N)`)
    over Relax ops.
      - Registered `"DFT": DFT` in `_get_convert_map()`.
    - In `tests/python/relax/test_frontend_onnx.py`:
    - Added `test_dft` covering real forward full, real forward onesided,
    complex inverse, dft_length padding/truncating, axis=0, and opset 17/20,
    validated against ONNX Runtime.
    
    Closes #20960.
---
 python/tvm/relax/frontend/onnx/onnx_frontend.py | 173 +++++++++++++++++++++
 tests/python/relax/test_frontend_onnx.py        | 191 ++++++++++++++++++++++++
 2 files changed, 364 insertions(+)

diff --git a/python/tvm/relax/frontend/onnx/onnx_frontend.py 
b/python/tvm/relax/frontend/onnx/onnx_frontend.py
index 65103d786c..d786f9d653 100644
--- a/python/tvm/relax/frontend/onnx/onnx_frontend.py
+++ b/python/tvm/relax/frontend/onnx/onnx_frontend.py
@@ -6181,6 +6181,178 @@ class MatMulInteger(OnnxOpConverter):
         return relax.op.matmul(a, b, out_dtype="int32")  # Output is int32 per 
ONNX spec
 
 
+class DFT(OnnxOpConverter):
+    """Converts an onnx DFT node into an equivalent Relax expression."""
+
+    MAX_DFT_LENGTH = 4096
+
+    @classmethod
+    def _impl_v17(cls, bb, inputs, attr, params):
+        data = inputs[0]
+        inverse = int(attr.get("inverse", 0))
+        onesided = int(attr.get("onesided", 0))
+        axis = int(attr.get("axis", 1))
+
+        dft_length = inputs[1] if len(inputs) > 1 and inputs[1] is not None 
else None
+        return cls._dft(bb, data, dft_length, axis, inverse, onesided, params)
+
+    @classmethod
+    def _impl_v20(cls, bb, inputs, attr, params):
+        data = inputs[0]
+        inverse = int(attr.get("inverse", 0))
+        onesided = int(attr.get("onesided", 0))
+
+        dft_length = inputs[1] if len(inputs) > 1 and inputs[1] is not None 
else None
+
+        axis = -2
+        if len(inputs) > 2 and inputs[2] is not None:
+            axis_c = get_constant(inputs[2], params)
+            if isinstance(axis_c, tvm_tirx.ir.GenericConst):
+                axis = int(axis_c.value.numpy().item())
+            elif isinstance(axis_c, int | tvm_tirx.ir.IntImm):
+                axis = int(axis_c)
+            else:
+                raise NotImplementedError(
+                    "Dynamic or non-constant axis is currently not supported 
for DFT."
+                )
+        else:
+            axis = int(attr.get("axis", -2))
+
+        return cls._dft(bb, data, dft_length, axis, inverse, onesided, params)
+
+    @classmethod
+    def _dft(cls, bb, data, dft_length, axis, inverse, onesided, params):
+        data_norm = bb.normalize(data)
+        if hasattr(data_norm.ty, "ndim"):
+            ndim = data_norm.ty.ndim
+        else:
+            ndim = len(data_norm.ty.shape)
+
+        if axis < 0:
+            axis = ndim + axis
+
+        if axis < 0 or axis > ndim - 2:
+            raise ValueError(
+                f"DFT axis {axis} is out of valid range [0, {ndim - 2}] for 
input with rank {ndim}."
+            )
+
+        orig_len = int(data_norm.ty.shape[axis])
+
+        dft_len = orig_len
+        if dft_length is not None:
+            dft_len_c = get_constant(dft_length, params)
+            if isinstance(dft_len_c, tvm_tirx.ir.GenericConst):
+                dft_len = int(dft_len_c.value.numpy().item())
+            elif isinstance(dft_len_c, int | tvm_tirx.ir.IntImm):
+                dft_len = int(dft_len_c)
+            else:
+                raise NotImplementedError(
+                    "Dynamic or non-constant dft_length is currently not 
supported for DFT."
+                )
+
+            if dft_len <= 0:
+                raise ValueError(f"dft_length must be positive, but got 
{dft_len}")
+
+        if dft_len > cls.MAX_DFT_LENGTH:
+            raise ValueError(
+                f"DFT transform length {dft_len} exceeds maximum supported 
length "
+                f"{cls.MAX_DFT_LENGTH} for table-based DFT conversion."
+            )
+
+        if dft_len < orig_len:
+            data = relax.op.strided_slice(data, axes=[axis], begin=[0], 
end=[dft_len])
+        elif dft_len > orig_len:
+            pad_before = [0] * ndim
+            pad_after = [0] * ndim
+            pad_after[axis] = dft_len - orig_len
+            data = bb.emit_te(topi.nn.pad, data, pad_before, pad_after, 0.0)
+
+        data = bb.normalize(data)
+        dtype = data.ty.dtype.dtype
+        is_complex = int(data.ty.shape[-1]) == 2
+
+        if is_complex:
+            x_re = bb.normalize(relax.op.strided_slice(data, axes=[-1], 
begin=[0], end=[1]))
+            x_im = bb.normalize(relax.op.strided_slice(data, axes=[-1], 
begin=[1], end=[2]))
+            x_re = relax.op.squeeze(x_re, axis=[-1])
+            x_im = relax.op.squeeze(x_im, axis=[-1])
+        else:
+            x_re = relax.op.squeeze(data, axis=[-1])
+            x_im = None
+
+        rank_no_c = ndim - 1
+        perm = list(range(rank_no_c))
+        if axis != rank_no_c - 1:
+            perm[axis], perm[-1] = perm[-1], perm[axis]
+            x_re_t = relax.op.permute_dims(x_re, perm)
+            x_im_t = relax.op.permute_dims(x_im, perm) if is_complex else None
+        else:
+            x_re_t = x_re
+            x_im_t = x_im if is_complex else None
+
+        N = dft_len
+        K = (N // 2 + 1) if onesided else N
+
+        # Compute DFT coefficient phases in float64 to avoid overflow and 
phase rounding errors
+        n_arr = _np.arange(N, dtype=_np.float64)
+        k_arr = _np.arange(K, dtype=_np.float64)
+        W_arr = (2.0 * _np.pi / float(N)) * _np.outer(n_arr, k_arr)
+        C_np = _np.cos(W_arr).astype(dtype)
+        S_np = _np.sin(W_arr).astype(dtype)
+
+        C = relax.const(C_np, dtype)
+        S = relax.const(S_np, dtype)
+
+        # For float16 inputs, the unnormalized matmul intermediates can 
overflow before inverse
+        # normalization (e.g. two float16 samples of 40000 sum to 80000 == 
inf).  Promote to
+        # float32 for all matmuls and complex arithmetic; cast back to float16 
at the end.
+        compute_dtype = "float32" if dtype == "float16" else dtype
+        if compute_dtype != dtype:
+            x_re_t = relax.op.astype(x_re_t, compute_dtype)
+            if x_im_t is not None:
+                x_im_t = relax.op.astype(x_im_t, compute_dtype)
+            C = relax.const(C_np.astype("float32"), compute_dtype)
+            S = relax.const(S_np.astype("float32"), compute_dtype)
+
+        term_re1 = relax.op.matmul(x_re_t, C)
+        term_im1 = relax.op.matmul(x_re_t, S)
+
+        if is_complex:
+            term_re2 = relax.op.matmul(x_im_t, S)
+            term_im2 = relax.op.matmul(x_im_t, C)
+            if not inverse:
+                y_re_t = relax.op.add(term_re1, term_re2)
+                y_im_t = relax.op.subtract(term_im2, term_im1)
+            else:
+                inv_scale = relax.const(1.0 / float(N), compute_dtype)
+                y_re_t = relax.op.multiply(relax.op.subtract(term_re1, 
term_re2), inv_scale)
+                y_im_t = relax.op.multiply(relax.op.add(term_im1, term_im2), 
inv_scale)
+        else:
+            if not inverse:
+                y_re_t = term_re1
+                y_im_t = relax.op.negative(term_im1)
+            else:
+                inv_scale = relax.const(1.0 / float(N), compute_dtype)
+                y_re_t = relax.op.multiply(term_re1, inv_scale)
+                y_im_t = relax.op.multiply(term_im1, inv_scale)
+
+        # Cast back to the original dtype if we promoted to float32 for 
overflow safety
+        if compute_dtype != dtype:
+            y_re_t = relax.op.astype(y_re_t, dtype)
+            y_im_t = relax.op.astype(y_im_t, dtype)
+
+        if axis != rank_no_c - 1:
+            y_re = relax.op.permute_dims(y_re_t, perm)
+            y_im = relax.op.permute_dims(y_im_t, perm)
+        else:
+            y_re = y_re_t
+            y_im = y_im_t
+
+        y_re = relax.op.expand_dims(y_re, axis=-1)
+        y_im = relax.op.expand_dims(y_im, axis=-1)
+        return relax.op.concat([y_re, y_im], axis=-1)
+
+
 def _get_convert_map():
     return {
         # defs/experimental
@@ -6331,6 +6503,7 @@ def _get_convert_map():
         "Dropout": Dropout,
         "Resize": Resize,
         "Einsum": Einsum,
+        "DFT": DFT,
         "Range": Range,
         "OneHot": OneHot,
         "Unique": Unique,
diff --git a/tests/python/relax/test_frontend_onnx.py 
b/tests/python/relax/test_frontend_onnx.py
index 7f540a53f6..a6be0b132b 100644
--- a/tests/python/relax/test_frontend_onnx.py
+++ b/tests/python/relax/test_frontend_onnx.py
@@ -14731,5 +14731,196 @@ def test_quantizelinear_output_dtype_mismatch(opset):
         from_onnx(model, opset=opset, keep_params_in_input=True)
 
 
+def test_dft():
+    """Verify numerical correctness of DFT against ONNX Runtime."""
+
+    def verify_dft(
+        x,
+        dft_length=None,
+        axis=1,
+        inverse=0,
+        onesided=0,
+        opset=17,
+    ):
+        inputs_list = ["x"]
+        graph_inputs = [helper.make_tensor_value_info("x", TensorProto.FLOAT, 
list(x.shape))]
+        feed_inputs = {"x": x}
+
+        attrs = {"inverse": inverse, "onesided": onesided}
+        initializers = []
+        if opset < 20:
+            attrs["axis"] = axis
+            if dft_length is not None:
+                inputs_list.append("dft_length")
+                initializers.append(
+                    helper.make_tensor("dft_length", TensorProto.INT64, [], 
[dft_length])
+                )
+        else:
+            # opset 20: axis is 3rd input
+            if dft_length is not None:
+                inputs_list.append("dft_length")
+                initializers.append(
+                    helper.make_tensor("dft_length", TensorProto.INT64, [], 
[dft_length])
+                )
+            else:
+                inputs_list.append("")
+            inputs_list.append("axis")
+            initializers.append(helper.make_tensor("axis", TensorProto.INT64, 
[], [axis]))
+
+        node = helper.make_node("DFT", inputs=inputs_list, outputs=["y"], 
**attrs)
+
+        # Calculate expected output shape
+        y_shape = list(x.shape)
+        actual_axis = axis if axis >= 0 else len(x.shape) + axis
+        N = x.shape[actual_axis] if dft_length is None else dft_length
+        y_shape[actual_axis] = (N // 2 + 1) if onesided else N
+        y_shape[-1] = 2
+
+        graph = helper.make_graph(
+            [node],
+            "dft_test",
+            inputs=graph_inputs,
+            initializer=initializers,
+            outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, 
y_shape)],
+        )
+        model = helper.make_model(
+            graph, opset_imports=[helper.make_opsetid("", opset)], 
ir_version=10
+        )
+        check_correctness(model, inputs=feed_inputs, opset=opset, atol=1e-4)
+
+    # 1. Real input, forward, full
+    x_real = np.random.randn(2, 6, 1).astype(np.float32)
+    verify_dft(x_real, axis=1, inverse=0, onesided=0, opset=17)
+
+    # 2. Real input, forward, onesided
+    verify_dft(x_real, axis=1, inverse=0, onesided=1, opset=17)
+
+    # 3. Complex input, inverse
+    x_comp = np.random.randn(2, 6, 2).astype(np.float32)
+    verify_dft(x_comp, axis=1, inverse=1, onesided=0, opset=17)
+
+    # 4. dft_length padding
+    verify_dft(x_real, dft_length=8, axis=1, inverse=0, onesided=0, opset=17)
+
+    # 5. dft_length truncating
+    verify_dft(x_real, dft_length=4, axis=1, inverse=0, onesided=1, opset=17)
+
+    # 6. Axis = 0
+    x_axis0 = np.random.randn(4, 3, 1).astype(np.float32)
+    verify_dft(x_axis0, axis=0, inverse=0, onesided=0, opset=17)
+
+    # 7. Opset 20
+    verify_dft(x_real, axis=1, inverse=0, onesided=1, opset=20)
+
+
+def test_dft_validation_and_errors():
+    """Verify DFT parameter validation and unsupported dynamic inputs."""
+    # 1. Non-constant axis in opset 20
+    node = helper.make_node("DFT", inputs=["x", "", "axis"], outputs=["y"])
+    graph = helper.make_graph(
+        [node],
+        "test_dyn_axis",
+        inputs=[
+            helper.make_tensor_value_info("x", TensorProto.FLOAT, [4, 3, 1]),
+            helper.make_tensor_value_info("axis", TensorProto.INT64, []),
+        ],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [4, 3, 
2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
20)])
+    with pytest.raises(NotImplementedError, match="Dynamic or non-constant 
axis"):
+        from_onnx(model, opset=20, keep_params_in_input=True)
+
+    # 2. Non-constant dft_length
+    node = helper.make_node("DFT", inputs=["x", "dft_length"], outputs=["y"], 
axis=1)
+    graph = helper.make_graph(
+        [node],
+        "test_dyn_len",
+        inputs=[
+            helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 6, 1]),
+            helper.make_tensor_value_info("dft_length", TensorProto.INT64, []),
+        ],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2, 6, 
2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
17)])
+    with pytest.raises(NotImplementedError, match="Dynamic or non-constant 
dft_length"):
+        from_onnx(model, opset=17, keep_params_in_input=True)
+
+    # 3. Non-positive dft_length
+    node = helper.make_node("DFT", inputs=["x", "dft_length"], outputs=["y"], 
axis=1)
+    graph = helper.make_graph(
+        [node],
+        "test_neg_len",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [2, 6, 
1])],
+        initializer=[helper.make_tensor("dft_length", TensorProto.INT64, [], 
[0])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [2, 6, 
2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
17)])
+    with pytest.raises(ValueError, match="dft_length must be positive"):
+        from_onnx(model, opset=17, keep_params_in_input=True)
+
+    # 4. dft_length exceeding MAX_DFT_LENGTH (4096)
+    node = helper.make_node("DFT", inputs=["x", "dft_length"], outputs=["y"], 
axis=1)
+    graph = helper.make_graph(
+        [node],
+        "test_large_len",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT, [1, 
5000, 1])],
+        initializer=[helper.make_tensor("dft_length", TensorProto.INT64, [], 
[5000])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT, [1, 
5000, 2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
17)])
+    with pytest.raises(ValueError, match="exceeds maximum supported length"):
+        from_onnx(model, opset=17, keep_params_in_input=True)
+
+
+def test_dft_float16_precision():
+    """Verify that 512-point float16 DFT phases do not overflow or produce 
NaNs."""
+    N = 512
+    node = helper.make_node("DFT", inputs=["x"], outputs=["y"], axis=1)
+    graph = helper.make_graph(
+        [node],
+        "test_fp16_dft",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT16, [1, N, 
1])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT16, [1, 
N, 2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
17)])
+    x_val = np.ones((1, N, 1), dtype=np.float16) * 0.01
+    tvm_out = run_in_tvm(model, inputs={"x": x_val}, opset=17)
+    res = tvm_out[0].numpy() if isinstance(tvm_out, list | tuple) else 
tvm_out.numpy()
+    assert not np.isnan(res).any()
+    assert not np.isinf(res).any()
+    assert res.dtype == np.float16
+
+
+def test_dft_float16_inverse_overflow():
+    """Verify float16 inverse DFT does not overflow before normalization.
+
+    Two real float16 samples of 40000 have an unnormalized sum of 80000, which 
is
+    infinity in float16 (max representable ~65504).  The inverse normalization
+    divides by N=2 to recover 40000, but only if the intermediate arithmetic 
is kept
+    in float32.  Without the fix this test produces inf in the output.
+    """
+    # Build a minimal inverse DFT: N=2, complex input representing two 40000 
samples
+    N = 2
+    # Complex representation: [[40000+0j, 40000+0j]] shaped [1, N, 2]
+    x_cplx = np.zeros((1, N, 2), dtype=np.float16)
+    x_cplx[0, 0, 0] = 40000.0  # real
+    x_cplx[0, 1, 0] = 40000.0  # real
+
+    node = helper.make_node("DFT", inputs=["x"], outputs=["y"], inverse=1, 
axis=1)
+    graph = helper.make_graph(
+        [node],
+        "test_fp16_idft_overflow",
+        inputs=[helper.make_tensor_value_info("x", TensorProto.FLOAT16, [1, N, 
2])],
+        outputs=[helper.make_tensor_value_info("y", TensorProto.FLOAT16, [1, 
N, 2])],
+    )
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 
17)])
+    tvm_out = run_in_tvm(model, inputs={"x": x_cplx}, opset=17)
+    res = tvm_out[0].numpy() if isinstance(tvm_out, list | tuple) else 
tvm_out.numpy()
+    # The output should be finite and representable in float16
+    assert not np.isnan(res).any(), f"Got NaN in inverse float16 DFT output: 
{res}"
+    assert not np.isinf(res).any(), f"Got Inf in inverse float16 DFT output: 
{res}"
+    assert res.dtype == np.float16
+
+
 if __name__ == "__main__":
     tvm_tirx.testing.main()

Reply via email to