def testMask(sp, dtype):
# Create mask
f = ift.from_random('normal', sp).to_global_data()
mask = np.zeros_like(f)
mask[f > 0] = 1
mask = ift.Field.from_global_data(sp, mask)
# Test MaskOperator
_check_repr(ift.MaskOperator(mask))
def testMask(sp, dtype):
# Create mask
f = ift.from_random('normal', sp).to_global_data()
mask = np.zeros_like(f)
mask[f > 0] = 1
mask = ift.Field.from_global_data(sp, mask)
# Test MaskOperator
op = ift.MaskOperator(mask)
ift.extra.consistency_check(op, dtype, dtype)
def test_value_inserter(sp, seed):
np.random.seed(seed)
ind = tuple([np.random.randint(0, ss - 1) for ss in sp.shape])
op = ift.ValueInserter(sp, ind)
f = ift.from_random('normal', ift.UnstructuredDomain((1,)))
inp = f.to_global_data()[0]
ret = op(f).to_global_data()
assert_(ret[ind] == inp)
assert_(np.sum(ret) == inp)
def test_WF_curvature(space):
np.random.seed(42)
starting_point = ift.Field.from_random('normal', domain=space)*10
required_result = ift.full(space, 1.)
s = ift.Field.from_random('uniform', domain=space) + 0.5
S = ift.DiagonalOperator(s)
r = ift.Field.from_random('uniform', domain=space)
R = ift.DiagonalOperator(r)
n = ift.Field.from_random('uniform', domain=space) + 0.5
N = ift.DiagonalOperator(n)
all_diag = 1./s + r**2/n
curv = ift.WienerFilterCurvature(R, N, S, iteration_controller=IC,
iteration_controller_sampling=IC)
m = curv.inverse(required_result)
assert_allclose(
m.local_data,
1./all_diag.local_data,
rtol=1e-3,
atol=1e-3)
curv.draw_sample()
curv.draw_sample(from_inverse=True)
if len(space.shape) == 1:
R = ift.ValueInserter(space, [0])
n = ift.from_random('uniform', R.domain) + 0.5
N = ift.DiagonalOperator(n)
all_diag = 1./s + R(1/n)
curv = ift.WienerFilterCurvature(R.adjoint, N, S,
iteration_controller=IC,
iteration_controller_sampling=IC)
m = curv.inverse(required_result)
assert_allclose(
m.local_data,
1./all_diag.local_data,
rtol=1e-3,
atol=1e-3)
curv.draw_sample()
curv.draw_sample(from_inverse=True)
def test_value(s):
Regrid = ift.RegriddingOperator(s, s.shape)
f = ift.from_random('normal', Regrid.domain)
assert_allclose(f.to_global_data(), Regrid(f).to_global_data())
def testOuter(fdomain, domain):
f = ift.from_random('normal', fdomain)
_check_repr(ift.OuterProduct(f, domain))
def make_random_mask():
# Random mask for spherical mode
mask = ift.from_random('pm1', position_space)
mask = (mask + 1) / 2
return mask.to_global_data()
def testOuter(fdomain, domain):
f = ift.from_random('normal', fdomain)
op = ift.OuterProduct(f, domain)
ift.extra.consistency_check(op)
def plot_prior_samples_2d(n_samps,
signal,
R,
correlated_field,
A,
likelihood,
N=None):
samples, pspecmin, pspecmax = [], np.inf, 0
pspec = A * A
for _ in range(n_samps):
ss = ift.from_random('normal', signal.domain)
samples.append(ss)
foo = pspec.force(ss).to_global_data()
pspecmin = min([min(foo), pspecmin])
pspecmax = max([max(foo), pspecmin])
fig, ax = plt.subplots(nrows=n_samps,
ncols=5,
figsize=(2 * 5, 2 * n_samps))
for ii, sample in enumerate(samples):
cf = correlated_field(sample)
signal_response = R @ signal
sg = signal(sample)
sr = (R.adjoint @ R @ signal)(sample)
if likelihood == 'gauss':
data = signal_response(sample) + N.draw_sample()
elif likelihood == 'poisson':
rate = signal_response(sample).to_global_data()
data = ift.from_global_data(signal_response.target,
np.random.poisson(rate))
elif likelihood == 'bernoulli':
rate = signal_response(sample).to_global_data()
data = ift.from_global_data(signal_response.target,
np.random.binomial(1, rate))
else:
raise ValueError('likelihood type not implemented')
data = R.adjoint(data + 0.)
As = pspec.force(sample)
ax[ii, 0].plot(As.domain[0].k_lengths, As.to_global_data())
ax[ii, 0].set_ylim(pspecmin, pspecmax)
ax[ii, 0].set_yscale('log')
ax[ii, 0].set_xscale('log')
ax[ii, 0].get_xaxis().set_visible(False)
ax[ii, 1].imshow(cf.to_global_data(), aspect='auto')
ax[ii, 1].get_xaxis().set_visible(False)
ax[ii, 1].get_yaxis().set_visible(False)
ax[ii, 2].imshow(sg.to_global_data(), aspect='auto')
ax[ii, 2].get_xaxis().set_visible(False)
ax[ii, 2].get_yaxis().set_visible(False)
ax[ii, 3].imshow(sr.to_global_data(), aspect='auto')
ax[ii, 3].get_xaxis().set_visible(False)
ax[ii, 3].get_yaxis().set_visible(False)
ax[ii, 4].imshow(data.to_global_data(), cmap='viridis', aspect='auto')
ax[ii, 4].get_xaxis().set_visible(False)
ax[ii, 4].yaxis.tick_right()
ax[ii, 4].get_yaxis().set_visible(False)
if ii == 0:
ax[0, 0].set_title('power spectrum')
ax[0, 1].set_title('correlated field')
ax[0, 2].set_title('signal')
ax[0, 3].set_title('signal Response')
ax[0, 4].set_title('synthetic data')
ax[n_samps - 1, 0].get_xaxis().set_visible(True)
plt.tight_layout()
plt.savefig('prior_samples_{}.png'.format(likelihood))
plt.close('all')
def testBinary(type1, type2, space, seed):
dom1 = ift.MultiDomain.make({'s1': space})
dom2 = ift.MultiDomain.make({'s2': space})
# FIXME Remove this?
_make_linearization(type1, dom1, seed)
_make_linearization(type2, dom2, seed)
dom = ift.MultiDomain.union((dom1, dom2))
select_s1 = ift.ducktape(None, dom1, "s1")
select_s2 = ift.ducktape(None, dom2, "s2")
model = select_s1 * select_s2
pos = ift.from_random("normal", dom)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
model = select_s1 + select_s2
pos = ift.from_random("normal", dom)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
model = select_s1.scale(3.)
pos = ift.from_random("normal", dom1)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
model = ift.ScalingOperator(2.456, space)(select_s1 * select_s2)
pos = ift.from_random("normal", dom)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
model = ift.sigmoid(2.456 * (select_s1 * select_s2))
pos = ift.from_random("normal", dom)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
pos = ift.from_random("normal", dom)
model = ift.OuterProduct(pos['s1'], ift.makeDomain(space))
ift.extra.check_jacobian_consistency(model, pos['s2'], ntries=20)
model = select_s1**2
pos = ift.from_random("normal", dom1)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
model = select_s1.clip(-1, 1)
pos = ift.from_random("normal", dom1)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
f = ift.from_random("normal", space)
model = select_s1.clip(f - 0.1, f + 1.)
pos = ift.from_random("normal", dom1)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
if isinstance(space, ift.RGSpace):
model = ift.FFTOperator(space)(select_s1 * select_s2)
pos = ift.from_random("normal", dom)
ift.extra.check_jacobian_consistency(model, pos, ntries=20)
mode = 2
if mode == 0:
# One-dimensional regular grid
position_space = ift.RGSpace(1024)
elif mode == 1:
# Two-dimensional regular grid
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)
def test_func():
f1 = ift.from_random("normal", domain=dom, dtype=np.complex128)
assert_allclose(
ift.log(ift.exp((f1)))["d1"].local_data, f1["d1"].local_data)
def test_vdot():
f1 = ift.from_random("normal", domain=dom, dtype=np.complex128)
f2 = ift.from_random("normal", domain=dom, dtype=np.complex128)
assert_allclose(f1.vdot(f2), np.conj(f2.vdot(f1)))
# Apply a nonlinearity
signal = ift.sigmoid(correlated_field)
# Build the line-of-sight response and define signal response
LOS_starts, LOS_ends = random_los(100) if mode == 0 else radial_los(100)
R = ift.LOSResponse(position_space, starts=LOS_starts, ends=LOS_ends)
signal_response = R(signal)
# Specify noise
data_space = R.target
noise = .001
N = ift.ScalingOperator(noise, data_space)
# Generate mock signal and data
mock_position = ift.from_random('normal', signal_response.domain)
data = signal_response(mock_position) + N.draw_sample()
# Minimization parameters
ic_sampling = ift.GradientNormController(iteration_limit=100)
ic_newton = ift.GradInfNormController(
name='Newton', tol=1e-7, iteration_limit=35)
minimizer = ift.NewtonCG(ic_newton)
# Set up likelihood and information Hamiltonian
likelihood = ift.GaussianEnergy(mean=data, covariance=N)(signal_response)
H = ift.StandardHamiltonian(likelihood, ic_sampling)
initial_mean = ift.MultiField.full(H.domain, 0.)
mean = initial_mean
pd = ift.PowerDistributor(harmonic_space, p_space)
a = ift.PS_field(p_space, sqrtpspec)
A = pd(a)
# Define sky operator
sky = ift.exp(HT(ift.makeOp(A)))
M = ift.DiagonalOperator(exposure)
GR = ift.GeometryRemover(position_space)
# Define instrumental response
R = GR(M)
# Generate mock data and define likelihood operator
d_space = R.target[0]
lamb = R(sky)
mock_position = ift.from_random('normal', domain)
data = lamb(mock_position)
data = np.random.poisson(data.to_global_data().astype(np.float64))
data = ift.Field.from_global_data(d_space, data)
likelihood = ift.PoissonianEnergy(data)(lamb)
# Settings for minimization
ic_newton = ift.DeltaEnergyController(name='Newton',
iteration_limit=100,
tol_rel_deltaE=1e-8)
minimizer = ift.NewtonCG(ic_newton)
# Compute MAP solution by minimizing the information Hamiltonian
H = ift.StandardHamiltonian(likelihood)
initial_position = ift.from_random('normal', domain)
H = ift.EnergyAdapter(initial_position, H, want_metric=True)
