文档反馈

问题文档片段

问题文档片段包含公式时，显示为空格。

提交类型

issue

有点复杂...

找人问问吧。

PR

小问题，全程线上修改...

一键搞定！

请选择提交类型

问题类型

规范和低错类

- 规范和低错类：

- 错别字或拼写错误，标点符号使用错误、公式错误或显示异常。

- 链接错误、空单元格、格式错误。

- 英文中包含中文字符。

- 界面和描述不一致，但不影响操作。

- 表述不通顺，但不影响理解。

- 版本号不匹配：如软件包名称、界面版本号。

易用性

- 易用性：

- 关键步骤错误或缺失，无法指导用户完成任务。

- 缺少主要功能描述、关键词解释、必要前提条件、注意事项等。

- 描述内容存在歧义指代不明、上下文矛盾。

- 逻辑不清晰，该分类、分项、分步骤的没有给出。

正确性

- 正确性：

- 技术原理、功能、支持平台、参数类型、异常报错等描述和软件实现不一致。

- 原理图、架构图等存在错误。

- 命令、命令参数等错误。

- 代码片段错误。

- 命令无法完成对应功能。

- 界面错误，无法指导操作。

- 代码样例运行报错、运行结果不符。

风险提示

- 风险提示：

- 对重要数据或系统存在风险的操作，缺少安全提示。

内容合规

- 内容合规：

- 违反法律法规，涉及政治、领土主权等敏感词。

- 内容侵权。

请选择问题类型

问题描述

点击输入详细问题描述，以帮助我们快速定位问题。

文档反馈

mindspore.ops.FFTWithSize

class mindspore.ops.FFTWithSize(signal_ndim, inverse, real, norm='backward', onesided=True, signal_sizes=())[源代码]

傅里叶变换，可以对参数进行调整，以实现FFT/IFFT/RFFT/IRFFT。

对于FFT，它计算以下表达式：

X [ω_{1}, \dots, ω_{d}] = \sum_{n_{1} = 0}^{N_{1} - 1} \dots \sum_{n_{d} = 0}^{N_{d} - 1} x [n_{1}, \dots, n_{d}] e^{- j 2 π \sum_{i = 0}^{d} \frac{ω_{i} n_{i}}{N_{i}}},

其中， $d$ = signal_ndim 是信号的维度， $N_{i}$ 则是信号第 $i$ 个维度的大小。

对于IFFT，它计算以下表达式：

X [ω_{1}, \dots, ω_{d}] = \frac{1}{\prod_{i = 1}^{d} N_{i}} \sum_{n_{1} = 0}^{N_{1} - 1} \dots \sum_{n_{d} = 0}^{N_{d} - 1} x [n_{1}, \dots, n_{d}] e^{j 2 π \sum_{i = 0}^{d} \frac{ω_{i} n_{i}}{N_{i}}},

其中， $d$ = signal_ndim 是信号的维度， $N_{i}$ 则是信号第 $i$ 维的大小。

说明

FFT/IFFT要求complex64或complex128类型的输入，返回complex64或complex128类型的输出。
RFFT要求bool, uint8, int8, int16, int32, int64, float32或float64类型的输入，返回complex64或complex128类型的输出。
IRFFT要求complex64或complex128类型的输入，返回float32或float64类型的输出。

警告

这是一个实验性API，后续可能修改或删除。

参数：

signal_ndim (int) - 表示每个信号中的维数，控制着傅里叶变换的维数，其值只能为1、2或3。
inverse (bool) - 表示该操作是否为逆变换，用以选择FFT 和 RFFT 或 IFFT 和 IRFFT。
- 如果为 True ，则为IFFT 和 IRFFT。
- 如果为 False ，FFT 和 RFFT。
real (bool) - 表示该操作是否为实变换，与 inverse 共同决定具体的变换模式：
- inverse 为 False ， real 为 False ：对应FFT模式。
- inverse 为 True ， real 为 False ：对应IFFT模式。
- inverse 为 False ， real 为 True ：对应RFFT模式。
- inverse 为 True ， real 为 True ：对应IRFFT模式。
norm (str，可选) - 表示该操作的规范化方式，可选值：[ "backward" , "forward" , "ortho" ]。默认值： "backward" 。
- "backward"，正向变换不缩放，逆变换按 $1 / n$ 缩放，其中 n 表示输入 x 的元素数量。
- "ortho"，正向变换与逆变换均按 $1 / \sqrt{n}$ 缩放。
- "forward"，正向变换按 $1 / n$ 缩放，逆变换不缩放。
onesided (bool，可选) - 控制输入是否减半以避免冗余。默认值： True 。
signal_sizes (tuple，可选) - 原始信号的大小（RFFT变换之前的信号，不包含batch这一维），只有在IRFFT模式下和设置 onesided 为True时需要该参数，需要满足以下条件。默认值： () 。
- signal_sizes 的长度等于IRFFT的 signal_ndim ： $l e n (s i g n a l_s i z e s) = s i g n a l_n d i m$ 。
- signal_sizes 的最后一个维度除以2等于IRFFT输入的最后一个维度： $s i g n a l_s i z e [- 1] / 2 + 1 = x . s h a p e [- 1]$ 。
- 除了最后一个维度外， signal_sizes 的维度与输入shape完全相同： $s i g n a l_s i z e s [: - 1] = x . s h a p e [: - 1]$ 。

输入：

x (Tensor) - 输入Tensor的维数必须大于或等于 signal_ndim 。

输出：

Tensor，表示复数到复数、实数到复数或复数到实数傅里叶变换的结果。

异常：

TypeError - 如果FFT/IFFT/IRFF的输入类型不是以下类型之一：complex64、complex128。
TypeError - 如果输入的类型不是Tensor。
ValueError - 如果输入 x 的维度小于 signal_ndim 。
ValueError - 如果 signal_ndim 大于3或小于1。
ValueError - 如果 norm 取值不是"backward"、"forward"或"ortho"。

支持平台：

Ascend GPU CPU

样例：

>>> import mindspore
>>> import numpy as np
>>> from mindspore import Tensor, ops
>>> # case FFT: signal_ndim: 1, inverse: False, real: False.
>>> fft_in = Tensor(np.array([2, 1, 2]), mindspore.complex64)
>>> fft_net = ops.FFTWithSize(signal_ndim=1, inverse=False, real=False)
>>> fft_output = fft_net(fft_in)
>>> print(fft_output)
[5.        +0.j         0.5       +0.86602545j 0.50000006-0.8660255j ]
>>> # case IFFT: signal_ndim: 1, inverse: True, real: False.
>>> ifft_in = fft_output
>>> ifft_net = ops.FFTWithSize(signal_ndim=1, inverse=True, real=False)
>>> ifft_output = ifft_net(ifft_in)
>>> print(ifft_output)
[2.        -1.9868216e-08j 0.99999994+0.0000000e+00j
 1.9999999 +7.9472862e-08j]
>>> # case RFFT2D: signal_ndim: 2, inverse: False, real: True.
>>> rfft_in = Tensor(np.array([[2, 1, 2], [3, 1, 6]]), mindspore.float32)
>>> rfft_net = ops.FFTWithSize(signal_ndim=2, inverse=False, real=True)
>>> rfft_output = rfft_net(rfft_in)
>>> print(rfft_output)
[[ 1.5000000e+01+1.1920929e-07j -2.3841858e-07+5.1961522e+00j]
 [-5.0000000e+00-2.9802322e-08j  9.9999988e-01-3.4641016e+00j]]
>>> # case IRFFT2D: signal_ndim: 2, inverse: True, real: True.
>>> irfft_in = rfft_output
>>> irfft_net = ops.FFTWithSize(signal_ndim=2, inverse=True, real=True, signal_sizes=rfft_in.shape)
>>> irfft_output = irfft_net(irfft_in)
>>> print(irfft_output)
[[2.         1.         2.        ]
 [3.         0.99999994 5.9999995 ]]