Python 单精度rfft

我寻求单精度

rfft

来加速计算

scipy.fftpack.rfft执行此操作，但返回一个实数组，该数组将实部和虚部封装在同一轴上，需要进行后处理。我在下面实现了以获得标准的复杂数组，但是Numpy的
rfft
对于2D输入速度更快（但对于1D则较慢）。内存也是一个问题，OOM使用float64

scipy或其他库是否具有返回标准复杂数组的单精度
rfft
实现？（否则，下面可以做得更快吗？）


将numpy导入为np
从numpy.fft导入rfft
从scipy.fftpack导入rfft作为srfft
def rfft_sp（x）：#假设len（x）为偶数
xf=np.zeros（（len（x）//2+1，x.shape[1]），dtype='complex64'）
h=srfft（x，轴=0）
xf[0]=h[0]
xf[1::=h[1:：2]
xf[：1].imag=0
xf[-1:][.imag=0
xf[1:-1].imag=h[2:：2]
返回xf
x=np.random.randn（500100000）.astype（'float32'））
%timeit rfft_sp（x）
%timeit rfft（x，轴=0）

在我测试的机器上，使用scipy.fft.rfft并强制转换到
complex64
比您的实现更快：

import numpy as np
from numpy.fft import rfft
from scipy.fft import rfft as srfft
from scipy.fftpack import rfft as srfft2

def rfft_sp(x):  # assumes len(x) is even
    xf = np.zeros((len(x)//2 + 1, x.shape[1]), dtype='complex64')
    h = srfft2(x, axis=0)            
    xf[0] = h[0]
    xf[1:] = h[1::2]
    xf[:1].imag = 0
    xf[-1:].imag = 0
    xf[1:-1].imag = h[2::2]
    return xf

def rfft_cast(x):  
    h = srfft(x, axis=0)            
    return h.astype('complex64')


x = np.random.randn(500, 100000).astype('float32')

%timeit rfft(x, axis = 0 ) 
%timeit rfft_sp(x ) 
%timeit rfft_cast(x)

产生：

1.81 s ± 144 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.89 s ± 7.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.24 s ± 9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

关键在于：

将numpy导入为np
导入pyfftw
N=1000000
x=np.random.randn（500，N）.astype（'float32'））
a=pyfftw.empty_aligned（（500，N），dtype='float32'）
b=pyfftw.empty_aligned（（251，N），dtype='complex64'）
fft_object=pyfftw.FFTW（a，b，轴=（0，））
def prfft（x）：
a[：]=x
返回fft_对象（）
%timeit prfft（x）
%timeit np.fft.rfft（x，轴=0）

我验证了内存使用是单精度的（或者至少Numpy使用了更多）。
您期望什么样的性能（增加）？@anon01速度。10%，100%，1000%？对于
%timeit rfft_sp（x）；%，这些数字看起来相当相似timeit rfft（x，axis=0）
为什么坚持单精度？底层实现仍然是float64，存在内存问题，但我确认
scipy.fft
比
np.fft
快。
1.81 s ± 144 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.89 s ± 7.58 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
2.24 s ± 9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

>>> 3.25 s ± 94.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
>>> 5.71 s ± 72.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)