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()