theano.gpuarray.fft
– Fast Fourier Transforms¶
Performs Fast Fourier Transforms (FFT) on the GPU.
FFT gradients are implemented as the opposite Fourier transform of the output gradients.
Note
You must install scikitcuda to compute Fourier transforms on the GPU.
Warning
The real and imaginary parts of the Fourier domain arrays are stored as a pair of float32 arrays, emulating complex64. Since theano has limited support for complex number operations, care must be taken to manually implement operations such as gradients.

theano.gpuarray.fft.
cuirfft
(inp, norm=None, is_odd=False)[source]¶ Performs the inverse fast Fourier Transform with realvalued output on the GPU.
The input is a variable of dimensions (m, …, n//2+1, 2) with type float32 representing the nontrivial elements of m realvalued Fourier transforms of initial size (…, n). The real and imaginary parts are stored as a pair of float32 arrays.
The output is a realvalued float32 variable of dimensions (m, …, n) giving the m inverse FFTs.
Parameters:  inp – Array of float32 of size (m, …, n//2+1, 2), containing m inputs with n//2+1 nontrivial elements on the last dimension and real and imaginary parts stored as separate arrays.
 norm ({None, 'ortho', 'no_norm'}) – Normalization of transform. Following numpy, default None normalizes only the inverse transform by n, ‘ortho’ yields the unitary transform ( forward and inverse). In addition, ‘no_norm’ leaves the transform unnormalized.
 is_odd ({True, False}) – Set to True to get a real inverse transform output with an odd last dimension of length (N1)*2 + 1 for an input last dimension of length N.

theano.gpuarray.fft.
curfft
(inp, norm=None)[source]¶ Performs the fast Fourier transform of a realvalued input on the GPU.
The input must be a realvalued float32 variable of dimensions (m, …, n). It performs FFTs of size (…, n) on m batches.
The output is a GpuArray of dimensions (m, …, n//2+1, 2). The second to last dimension of the output contains the n//2+1 nontrivial elements of the realvalued FFTs. The real and imaginary parts are stored as a pair of float32 arrays.
Parameters:  inp – Array of realvalued float32 of size (m, …, n), containing m inputs of size (…, n).
 norm ({None, 'ortho', 'no_norm'}) – Normalization of transform. Following numpy, default None normalizes only the inverse transform by n, ‘ortho’ yields the unitary transform ( forward and inverse). In addition, ‘no_norm’ leaves the transform unnormalized.
For example, the code below performs the real input FFT of a box function, which is a sinc function.
The absolute value is plotted, since the phase oscillates due to the box function being
shifted to the middle of the array. The Theano flag device=cuda{0,1...}
must be used.
import numpy as np
import theano
import theano.tensor as tt
from theano.gpuarray import fft
x = tt.matrix('x', dtype='float32')
rfft = fft.curfft(x, norm='ortho')
f_rfft = theano.function([x], rfft)
N = 1024
box = np.zeros((1, N), dtype='float32')
box[:, N/210: N/2+10] = 1
out = f_rfft(box)
c_out = np.asarray(out[0, :, 0] + 1j*out[0, :, 1])
abs_out = abs(c_out)