def fourier_poisson(tensor, times=1):
""" Inverse operation to `fourier_laplace`. """
frequencies = math.fft(math.to_complex(tensor))
k = fftfreq(math.staticshape(tensor)[1:-1], mode='square')
fft_laplace = -(2 * np.pi)**2 * k
fft_laplace[(0, ) * math.ndims(k)] = np.inf
inv_fft_laplace = 1 / fft_laplace
inv_fft_laplace[(0, ) * math.ndims(k)] = 0
return math.real(math.ifft(frequencies * inv_fft_laplace**times))
def fourier_laplace(tensor, times=1):
"""
Applies the spatial laplce operator to the given tensor with periodic boundary conditions.
*Note:* The results of `fourier_laplace` and `laplace` are close but not identical.
This implementation computes the laplace operator in Fourier space.
The result for periodic fields is exact, i.e. no numerical instabilities can occur, even for higher-order derivatives.
:param tensor: tensor, assumed to have periodic boundary conditions
:param times: number of times the laplace operator is applied. The computational cost is independent of this parameter.
:return: tensor of same shape as `tensor`
"""
frequencies = math.fft(math.to_complex(tensor))
k = fftfreq(math.staticshape(tensor)[1:-1], mode='square')
fft_laplace = -(2 * np.pi)**2 * k
return math.real(math.ifft(frequencies * fft_laplace**times))
def frequency_loss(tensor, frequency_falloff=100, reduce_batches=True):
"""
Instead of minimizing each entry of the tensor, minimize the frequencies of the tensor, emphasizing lower frequencies over higher ones.
:param reduce_batches: whether to reduce the batch dimension of the loss by adding the losses along the first dimension
:param tensor: typically actual - target
:param frequency_falloff: large values put more emphasis on lower frequencies, 1.0 weights all frequencies equally.
:return: scalar loss value
"""
if struct.isstruct(tensor):
all_tensors = struct.flatten(tensor)
return sum(
frequency_loss(tensor, frequency_falloff, reduce_batches)
for tensor in all_tensors)
diff_fft = abs_square(math.fft(tensor))
k = fftfreq(tensor.shape[1:-1], mode='absolute')
weights = math.exp(-0.5 * k**2 * frequency_falloff**2)
return l1_loss(diff_fft * weights, reduce_batches=reduce_batches)
def fourier_laplace(tensor):
frequencies = math.fft(math.to_complex(tensor))
k = fftfreq(math.staticshape(tensor)[1:-1], mode='square')
fft_laplace = -(2 * np.pi)**2 * k
return math.real(math.ifft(frequencies * fft_laplace))