def test_power_synthesize_analyze(space1, space2):
np.random.seed(11)
p1 = ift.PowerSpace(space1)
fp1 = ift.PS_field(p1, _spec1)
p2 = ift.PowerSpace(space2)
fp2 = ift.PS_field(p2, _spec2)
outer = np.outer(fp1.to_global_data(), fp2.to_global_data())
fp = ift.Field.from_global_data((p1, p2), outer)
op1 = ift.create_power_operator((space1, space2), _spec1, 0)
op2 = ift.create_power_operator((space1, space2), _spec2, 1)
opfull = op2(op1)
samples = 500
sc1 = ift.StatCalculator()
sc2 = ift.StatCalculator()
for ii in range(samples):
sk = opfull.draw_sample()
sp = ift.power_analyze(sk, spaces=(0, 1), keep_phase_information=False)
sc1.add(sp.sum(spaces=1) / fp2.sum())
sc2.add(sp.sum(spaces=0) / fp1.sum())
assert_allclose(sc1.mean.local_data, fp1.local_data, rtol=0.2)
assert_allclose(sc2.mean.local_data, fp2.local_data, rtol=0.2)
def __init__(
self,
domain,
beta,
k,
grid,
power_spectrum=lambda q: 2/(q**4 + 1),
rho=1,
verbosity=0):
super().__init__()
self.beta = beta
self._domain = (domain, )
self.fft = nifty5.FFTOperator(self._domain)
self.h_space = self.fft.target[0]
self.grid = grid
self.k = k
self.rho = rho
B_h = nifty5.create_power_operator(
domain=self.h_space, power_spectrum=power_spectrum)
self.B = nifty5.SandwichOperator.make(self.fft, B_h)
# the diagonal operator rho*e^beta
rho_e_beta = np.zeros(domain.shape[0])
for i, pos in enumerate(self.grid):
rho_e_beta[pos] = (
self.rho*np.exp(self.beta.val[pos]))
rho_e_beta_field = nifty5.Field(domain=domain, val=rho_e_beta)
self.rho_e_beta_diag = nifty5.DiagonalOperator(
domain=self._domain,
diagonal=rho_e_beta_field)
def __init__(
self,
N_bins=1024,
power_spectrum_beta=lambda q: 1 / (q**4 + 1),
power_spectrum_f=lambda q: 1 / (q**4 + 1),
noise_var=0.1,
):
"""
N_bins : int
number of bins for the sample spaces
p_spec_beta : function
power spectrum for beta
p_spec_f : function
power spectrum for f
noise_var : scalar
the variance of the noise variable
"""
self.N_bins = N_bins
self.s_space = nifty5.RGSpace([N_bins], )
self.h_space = self.s_space.get_default_codomain()
self.p_space = nifty5.PowerSpace(self.h_space)
# covariance operator for the beta distribution
self.power_spectrum_beta = power_spectrum_beta
B_h = nifty5.create_power_operator(
self.h_space, power_spectrum=self.power_spectrum_beta)
fft = nifty5.FFTOperator(self.s_space)
self.B = nifty5.SandwichOperator.make(fft, B_h)
self.beta = self.B.draw_sample()
# numerical values for p(x|beta) = exp(beta(x)) / sum_z exp(beta(z))
self.p_x_val = np.exp(np.array(self.beta.to_global_data()))
self.p_x_val = (1 / np.sum(self.p_x_val)) * self.p_x_val
# get the covariance operator for the f distribution
self.power_spectrum_f = power_spectrum_f
F_h = nifty5.create_power_operator(
self.h_space, power_spectrum=self.power_spectrum_f)
self.F = nifty5.SandwichOperator.make(fft, F_h)
# sample the transformation function f
self.f = self.F.draw_sample()
self.f_val = np.array(self.f.to_global_data())
# set the noise variance
self.noise_var = noise_var
def __init__(
self,
position,
k,
x,
y,
x_indices,
s_space,
h_space,
p_space,
grid,
sigma_f=1,
noise_variance=0.01,
Lambda_modes_list=None,
term_factors=[1] * 11,
):
super().__init__(position=position)
self.domain = position.domain
self.k, self.x, self.y = k, x, y
self.x_indices = x_indices
self.N = len(self.x)
self.sigma_f = sigma_f
self.noise_variance = noise_variance
self.tau_f = position
self.s_space = s_space
self.h_space = h_space
self.p_space = p_space
self.len_p_space = self.p_space.shape[0]
self.grid = grid
self.fft = nifty5.FFTOperator(domain=self.s_space, target=self.h_space)
self.F_h = nifty5.create_power_operator(domain=self.h_space,
power_spectrum=nifty5.exp(
self.tau_f))
self.F = nifty5.SandwichOperator.make(self.fft, self.F_h)
self.F_matrix = probe_operator(self.F)
self.F_tilde = np.zeros((self.N, self.N))
for i in range(self.N):
for j in range(i + 1):
self.F_tilde[i, j] = self.F_matrix[x_indices[i], x_indices[j]]
if i != j:
self.F_tilde[j, i] = self.F_matrix[x_indices[i],
x_indices[j]]
self.noise_covariance = np.diag(
[self.noise_variance for i in range(self.N)])
self.G = np.linalg.inv(self.F_tilde + self.noise_covariance)
self.smoothness_operator_f = nifty5.SmoothnessOperator(
domain=self.p_space, logarithmic=True, strength=1 / self.sigma_f)
if Lambda_modes_list is None:
self.get_Lambda_modes(speedup=True)
else:
self.Lambda_modes_list = Lambda_modes_list
self.term_factors = term_factors
self.get_Lambdas()
def wf_test(signal, noise, signal_boost, npix = 400):
pixel_space = ift.RGSpace([npix, npix])
fourier_space = pixel_space.get_default_codomain()
signal_field = ift.Field.from_global_data(pixel_space, signal.astype(float))
HT = ift.HartleyOperator(fourier_space, target=pixel_space)
power_field = ift.power_analyze(HT.inverse(signal_field), binbounds=ift.PowerSpace.useful_binbounds(fourier_space, True))
Sh = ift.create_power_operator(fourier_space, power_spectrum=power_field)
R = HT
noise_field = ift.Field.from_global_data(pixel_space, noise.astype(float))
noise_power_field = ift.power_analyze(HT.inverse(noise_field), binbounds=ift.PowerSpace.useful_binbounds(fourier_space, True))
N = ift.create_power_operator(HT.domain, noise_power_field)
N_inverse = HT@[email protected]
amplify = len(signal_boost)
s_data = np.zeros((amplify, npix, npix))
m_data = np.zeros((amplify, npix, npix))
d_data = np.zeros((amplify, npix, npix))
for i in np.arange(amplify):
data = noise_field
# Wiener filtering the data
j = (R.adjoint @N_inverse.inverse)(data)
D_inv = R.adjoint @ N_inverse.inverse @ R + Sh.inverse
IC = ift.GradientNormController(iteration_limit=500, tol_abs_gradnorm=1e-3)
D = ift.InversionEnabler(D_inv, IC, approximation=Sh.inverse).inverse
m = D(j)
s_data[i,:,:] = (signal_field * signal_boost[i]).to_global_data()
m_data[i,:,:] = HT(m).to_global_data()
d_data[i,:,:] = data.to_global_data()
return (s_data, m_data, d_data)
def get_Lambda_modes(self, speedup=False):
# this is an array of matrices:
# Lambda_mode(z)_ij = (1/2pi) (cos(z(x_i-x_j)) + sin(z(x_i + x_j)) )
self.Lambda_modes_list = list()
if not False:
# conventional way
for k in range(self.len_p_space):
p_spec = np.zeros(self.len_p_space)
p_spec[k] = np.exp(self.tau_f.val[k])
p_spec[k] = 1
Lambda_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=nifty5.Field(domain=self.p_space,
val=p_spec))
Lambda_kernel = nifty5.SandwichOperator.make(
self.fft, Lambda_h)
Lambda_kernel_matrix = probe_operator(Lambda_kernel)
Lambda_modes = np.zeros((self.N, self.N))
for i in range(self.N):
for j in range(i + 1):
Lambda_modes[i, j] = Lambda_kernel_matrix[
self.x_indices[i], self.x_indices[j]]
if i != j:
Lambda_modes[j, i] = Lambda_kernel_matrix[
self.x_indices[i], self.x_indices[j]]
self.Lambda_modes_list.append(Lambda_modes)
else:
# based on the thought that we are just dealing with single
# fourier modes, we can calculate these directly
Lambda_modes = np.zeros((self.N, self.N))
for i in range(self.N):
for j in range(i + 1):
x_i_index = self.x_indices[i]
x_j_index = self.x_indices[j]
a = (self.grid_coordinates[x_i_index] -
self.grid_coordinates[x_j_index])
# dirty hack, if we take cos((x-y)*2*pi) we get the
# desired result
Lambda_modes[i, j] = np.cos(a * 2 * np.pi)
if i != j:
Lambda_modes[j, i] = np.cos(a * 2 * np.pi)
# use the relation cos(nx) = T_n(cos(x)) where T_n is the nth
# chebyhsev polynomial
for i, z in enumerate(self.p_space[0].k_lengths):
factor = 2 * self.len_s_space**(-2)
if i == 0:
factor = factor / 2
if i == (self.len_p_space - 1):
factor = factor / 2
z = int(z)
self.Lambda_modes_list.append(
factor *
np.polynomial.Chebyshev(coef=[0] * z + [1])(Lambda_modes))
def test_DiagonalOperator_power_analyze2(space1, space2):
np.random.seed(11)
fp1 = ift.PS_field(ift.PowerSpace(space1), _spec1)
fp2 = ift.PS_field(ift.PowerSpace(space2), _spec2)
S_1 = ift.create_power_operator((space1, space2), _spec1, 0)
S_2 = ift.create_power_operator((space1, space2), _spec2, 1)
S_full = S_2(S_1)
samples = 500
sc1 = ift.StatCalculator()
sc2 = ift.StatCalculator()
for ii in range(samples):
sk = S_full.draw_sample()
sp = ift.power_analyze(sk, spaces=(0, 1), keep_phase_information=False)
sc1.add(sp.sum(spaces=1) / fp2.sum())
sc2.add(sp.sum(spaces=0) / fp1.sum())
assert_allclose(sc1.mean.local_data, fp1.local_data, rtol=0.2)
assert_allclose(sc2.mean.local_data, fp2.local_data, rtol=0.2)
def __init__(
self,
position,
k,
grid,
sigma_beta=1,
rho=1,
mode='multifield',
single_fields=None,
term_factors=[1]*5,
):
super().__init__(position=position)
self.domain = position.domain
self.k = k
self.sigma_beta = sigma_beta
self.rho = rho
self.mode = mode
self.fields = single_fields
self.term_factors = term_factors
if mode == 'multifield':
self.beta = position.val['beta']
self.tau_beta = position.val['tau_beta']
else:
self.fields[mode] = position
self.beta = self.fields['beta']
self.tau_beta = self.fields['tau_beta']
self.s_space = self.beta.domain[0]
self.h_space = self.s_space.get_default_codomain()
self.p_space = self.tau_beta.domain
self.len_p_space = self.p_space.shape[0]
self.len_s_space = self.s_space.shape[0]
self.grid = grid
self.grid_coordinates = [i*self.s_space.distances[0] for i in range(
self.s_space.shape[0])]
# beta_vector is the R^N_bins vector with beta field values at the grid
# positions
self.beta_vector = np.array([self.beta.val[i] for i in self.grid])
self.fft = nifty5.FFTOperator(domain=self.s_space, target=self.h_space)
self.B_inv_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=nifty5.exp(-self.tau_beta))
self.B_inv = nifty5.SandwichOperator.make(self.fft, self.B_inv_h)
self.smoothness_operator_beta = nifty5.SmoothnessOperator(
domain=self.p_space,
strength=1/self.sigma_beta)
self.get_del_B()
def get_del_B(self):
self.del_B_inv_list = list()
for i in range(self.len_p_space):
p_spec = np.zeros(self.len_p_space)
p_spec[i] = np.exp(-self.tau_beta.val[i])
del_B_inv_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=nifty5.Field(
domain=self.p_space,
val=p_spec))
del_B_inv = nifty5.SandwichOperator.make(
self.fft, del_B_inv_h)
self.del_B_inv_list.append(del_B_inv)
def __init__(
self,
position,
k,
s_space,
power_spectrum_beta,
rho,
):
super().__init__(position=position)
self.k = k
self.rho = rho
self.power_spectrum_beta = power_spectrum_beta
self.N = k.sum()
self.beta = position
self.beta_arr = position.to_global_data()
self.s_space = s_space
self.fft = nifty5.FFTOperator(self.s_space)
self.h_space = self.fft.target[0]
# B in Fourier space:
self.B_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=power_spectrum_beta)
self.B = nifty5.SandwichOperator.make(self.fft, self.B_h)
prior_spectrum = lambda k: 1 / (10. + k**2.5)
data, ground_truth = generate_wf_data(position_space, prior_spectrum)
R = ift.GeometryRemover(position_space)
data_space = R.target
data = ift.from_global_data(data_space, data)
ground_truth = ift.from_global_data(position_space, ground_truth)
plot_WF('data', ground_truth, data)
N = ift.ScalingOperator(0.1, data_space)
harmonic_space = position_space.get_default_codomain()
HT = ift.HartleyOperator(harmonic_space, target=position_space)
S_h = ift.create_power_operator(harmonic_space, prior_spectrum)
S = HT @ S_h @ HT.adjoint
D_inv = S.inverse + R.adjoint @ N.inverse @ R
j = (R.adjoint @ N.inverse)(data)
IC = ift.GradientNormController(iteration_limit=100, tol_abs_gradnorm=1e-7)
D = ift.InversionEnabler(D_inv.inverse, IC, approximation=S)
m = D(j)
plot_WF('result', ground_truth, data, m)
S = ift.SandwichOperator.make(HT.adjoint, S_h)
D = ift.WienerFilterCurvature(R, N, S, IC, IC).inverse
N_samples = 10
def nifty_wf(signal, noise, y_map, npix = 400, pxsize = 1.5, kernel = 9.68, n = 10, smooth = False):
cmb_mocks = noise.shape[0]
A = (2*np.sqrt(2*np.log(2)))
if smooth is True:
signal_smooth = np.zeros((cmb_mocks, npix, npix))
noise_smooth = np.zeros((cmb_mocks, npix, npix))
for i in np.arange(cmb_mocks):
noise_data = ndimage.gaussian_filter(noise[i], sigma= kernel/A/pxsize, order=0, mode = "reflect", truncate = 10)
#signal_data = ndimage.gaussian_filter(signal[i], sigma= kernel/A/pxsize, order=0, mode = "reflect", truncate = 10)
signal_data = signal[i] #uncomment here if smoothing signal and noise
noise_smooth[i,:,:] = noise_data
signal_smooth[i,:,:] = signal_data
else:
noise_smooth = noise
signal_smooth = signal
pixel_space = ift.RGSpace([npix, npix])
fourier_space = pixel_space.get_default_codomain()
s_data = np.zeros((cmb_mocks, npix, npix))
m_data = np.zeros((cmb_mocks, npix, npix))
d_data = np.zeros((cmb_mocks, npix, npix))
for i in np.arange(cmb_mocks):
signal_field = ift.Field.from_global_data(pixel_space, signal_smooth.astype(float)) #[i] for mock_data
HT = ift.HartleyOperator(fourier_space, target=pixel_space)
power_field = ift.power_analyze(HT.inverse(signal_field), binbounds=ift.PowerSpace.useful_binbounds(fourier_space, True))
Sh = ift.create_power_operator(fourier_space, power_spectrum=power_field)
R = HT
noise_field = ift.Field.from_global_data(pixel_space, noise_smooth[i].astype(float))
noise_power_field = ift.power_analyze(HT.inverse(noise_field), binbounds=ift.PowerSpace.useful_binbounds(fourier_space, True))
N = ift.create_power_operator(HT.domain, noise_power_field)
N_inverse = HT@[email protected]
data = signal_field + noise_field # --->when using mock_data
# Wiener filtering the data
j = (R.adjoint @N_inverse.inverse)(data)
D_inv = R.adjoint @ N_inverse.inverse @ R + Sh.inverse
IC = ift.GradientNormController(iteration_limit=500, tol_abs_gradnorm=1e-3)
D = ift.InversionEnabler(D_inv, IC, approximation=Sh.inverse).inverse
m = D(j)
#s_data[i,:,:] = (signal_field).to_global_data()
m_data[i,:,:] = HT(m).to_global_data()
#d_data[i,:,:] = data.to_global_data()
#Squaring the filtered map and also taking the absoute val of filtered map
# uncomment here for no cross correlation
squared_m_data = np.zeros((cmb_mocks, npix, npix))
abs_m_data = np.zeros((cmb_mocks, npix, npix))
for i in np.arange(m_data.shape[0]):
squared_m_data[i,:,:] = m_data[i,:,:] * m_data[i,:,:]
abs_m_data[i,:,:] = np.abs(m_data[i,:,:])
#Stacking all filtered maps
stack1 = np.sum(squared_m_data, axis = 0)/m_data.shape[0]
stack2 = np.sum(abs_m_data, axis = 0)/m_data.shape[0]
return (m_data, squared_m_data, abs_m_data, stack1, stack2) #change here to return the right values ---->, stack_square, stack_abs
def __init__(
self,
position,
k,
x,
y,
grid,
sigma_f=1,
sigma_beta=1,
sigma_eta=1,
rho=1,
mode='multifield',
single_fields=None,
Lambda_modes_list=None,
term_factors=[1]*11,
):
super().__init__(position=position)
self.domain = position.domain
self.k, self.x, self.y = k, x, y
self.N = len(self.x)
self.sigma_beta = sigma_beta
self.sigma_f = sigma_f
self.sigma_eta = sigma_eta
self.rho = rho
self.mode = mode
self.fields = single_fields
if mode == 'multifield':
self.beta = position.val['beta']
self.tau_beta = position.val['tau_beta']
self.tau_f = position.val['tau_f']
self.eta = position.val['eta']
else:
self.fields[mode] = position
self.beta = self.fields['beta']
self.tau_beta = self.fields['tau_beta']
self.tau_f = self.fields['tau_f']
self.eta = self.fields['eta']
self.s_space = self.beta.domain[0]
self.h_space = self.s_space.get_default_codomain()
self.p_space = self.tau_f.domain
self.len_p_space = self.p_space.shape[0]
self.len_s_space = self.s_space.shape[0]
self.grid = grid
self.grid_coordinates = [i*self.s_space.distances[0] for i in range(
self.s_space.shape[0])]
# beta_vector is the R^N_bins vector with beta field values at the grid
# positions
self.beta_vector = np.array([self.beta.val[i] for i in self.grid])
self.fft = nifty5.FFTOperator(domain=self.s_space, target=self.h_space)
self.F_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=nifty5.exp(self.tau_f))
self.B_inv_h = nifty5.create_power_operator(
domain=self.h_space,
power_spectrum=nifty5.exp(-self.tau_beta))
self.B_inv = nifty5.SandwichOperator.make(self.fft, self.B_inv_h)
self.F = nifty5.SandwichOperator.make(self.fft, self.F_h)
self.F_matrix = probe_operator(self.F)
self.F_tilde = np.zeros((self.N, self.N))
for i in range(self.N):
for j in range(i+1):
self.F_tilde[i, j] = self.F_matrix[
self.x_indices[i], self.x_indices[j]]
if i != j:
self.F_tilde[j, i] = self.F_matrix[
self.x_indices[i], self.x_indices[j]]
self.exp_hat_eta_x = np.diag([np.exp(
self.eta.val[self.x_indices[i]]) for i in range(self.N)])
self.G = np.linalg.inv(self.F_tilde + self.exp_hat_eta_x)
self.smoothness_operator_f = nifty5.SmoothnessOperator(
domain=self.p_space,
strength=1/self.sigma_f)
self.smoothness_operator_beta = nifty5.SmoothnessOperator(
domain=self.p_space,
strength=1/self.sigma_beta)
# second derivative of eta
nabla_nabla_eta = np.zeros(self.eta.val.shape)
scipy.ndimage.laplace(
input=self.eta.val,
output=nabla_nabla_eta)
self.nabla_nabla_eta_field = nifty5.Field(
domain=self.s_space,
val=nabla_nabla_eta)
if Lambda_modes_list is None:
self.get_Lambda_modes(speedup=True)
else:
self.Lambda_modes_list = Lambda_modes_list
self.term_factors = term_factors
self.get_Lambdas()
self.get_del_B()
self.get_del_exp_eta_x()
position_space = ift.RGSpace([512, 512])
else:
# Sphere
position_space = ift.HPSpace(128)
# Define harmonic space and transform
harmonic_space = position_space.get_default_codomain()
HT = ift.HarmonicTransformOperator(harmonic_space, position_space)
position = ift.from_random('normal', harmonic_space)
# Define power spectrum and amplitudes
def sqrtpspec(k):
return 1. / (20. + k**2)
A = ift.create_power_operator(harmonic_space, sqrtpspec)
# Set up a sky operator and instrumental response
sky = ift.sigmoid(HT(A))
GR = ift.GeometryRemover(position_space)
R = GR
# Generate mock data
p = R(sky)
mock_position = ift.from_random('normal', harmonic_space)
tmp = p(mock_position).to_global_data().astype(np.float64)
data = np.random.binomial(1, tmp)
data = ift.Field.from_global_data(R.target, data)
# Compute likelihood and Hamiltonian
position = ift.from_random('normal', harmonic_space)
