def test_interpolation():
for i in range(NREPEAT):
fcoefs_amp, fcoefs_mu, fcoefs_sig \
= random_filtercoefs(numBands, numCoefs)
lines_mu, lines_sig = random_linecoefs(numLines)
var_C, var_L, alpha_C, alpha_L, alpha_T = random_hyperparams()
norms = np.sqrt(2*np.pi) * np.sum(fcoefs_amp * fcoefs_sig, axis=1)
print('Failed with params:', var_C, var_L, alpha_C, alpha_L, alpha_T)
kern = Photoz_kernel(fcoefs_amp, fcoefs_mu, fcoefs_sig,
lines_mu, lines_sig, var_C, var_L,
alpha_C, alpha_L, alpha_T)
for j in range(numBands):
X = np.vstack((np.repeat(j, kern.nz),
kern.redshiftGrid,
np.repeat(1, kern.nz),
np.repeat(0, kern.nz))).T
assert X.shape[0] == kern.nz
assert X.shape[1] == 4
Kfull = kern.K(X)
Kdiag = kern.Kdiag(X)
assert np.allclose(np.diag(Kfull), Kdiag, rtol=relative_accuracy)
b1 = kern.roundband(X[:, 0])
fz1 = (1. + X[:, 1])
kern.construct_interpolators()
kern.update_kernelparts(X)
ts = (kern.nz, kern.nz)
KC, KL = np.zeros(ts), np.zeros(ts)
D_alpha_C, D_alpha_L, D_alpha_z\
= np.zeros(ts), np.zeros(ts), np.zeros(ts)
kernelparts(kern.nz, kern.nz, numCoefs, numLines,
alpha_C, alpha_L,
fcoefs_amp, fcoefs_mu, fcoefs_sig,
lines_mu, lines_sig,
norms, b1, fz1, b1, fz1,
True, KL, KC,
D_alpha_C, D_alpha_L, D_alpha_z)
assert np.allclose(KL, kern.KL, rtol=relative_accuracy)
assert np.allclose(KC, kern.KC, rtol=relative_accuracy)
assert np.allclose(D_alpha_C, kern.D_alpha_C,
rtol=relative_accuracy)
assert np.allclose(D_alpha_L, kern.D_alpha_L,
rtol=relative_accuracy)
def update_kernelparts(self, X, X2=None):
"""
Update the precomputed parts of the kernel.
X is an array of size (nobj, 3) containing the GP inputs.
The column order is band, redshift, and luminosity.
"""
if X2 is None:
X2 = X
NO1, NO2 = X.shape[0], X2.shape[0]
b1 = self.roundband(X[:, 0])
b2 = self.roundband(X2[:, 0])
fz1 = 1 + X[:, 1]
fz2 = 1 + X2[:, 1]
fzgrid = 1 + self.redshiftGrid
self.KL, self.KC, self.D_alpha_C, self.D_alpha_L, self.D_alpha_z =\
np.zeros((NO1, NO2)), np.zeros((NO1, NO2)),\
np.zeros((NO1, NO2)), np.zeros((NO1, NO2)),\
np.zeros((NO1, NO2))
if self.use_interpolators:
p1s = np.zeros(NO1, dtype=int)
p2s = np.zeros(NO2, dtype=int)
find_positions(NO1, self.nz, fz1, p1s, fzgrid)
find_positions(NO2, self.nz, fz2, p2s, fzgrid)
kernel_parts_interp(NO1, NO2, self.KC, b1, fz1, p1s, b2, fz2, p2s,
fzgrid, self.KC_grid)
kernel_parts_interp(NO1, NO2, self.D_alpha_C, b1, fz1, p1s, b2,
fz2, p2s, fzgrid, self.D_alpha_C_grid)
if self.numLines > 0:
kernel_parts_interp(NO1, NO2, self.KL, b1, fz1, p1s, b2, fz2,
p2s, fzgrid, self.KL_grid)
kernel_parts_interp(NO1, NO2, self.D_alpha_L, b1, fz1, p1s, b2,
fz2, p2s, fzgrid, self.D_alpha_L_grid)
else: # not use interpolators
kernelparts(NO1, NO2, self.numCoefs, self.numLines, self.alpha_C,
self.alpha_L, self.fcoefs_amp, self.fcoefs_mu,
self.fcoefs_sig, self.lines_mu[:self.numLines],
self.lines_sig[:self.numLines], self.norms, b1, fz1,
b2, fz2, True, self.KL, self.KC, self.D_alpha_C,
self.D_alpha_L, self.D_alpha_z)
self.Zprefac = (1+X[:, 1:2]) * (1+X2[None, :, 1]) /\
(self.fourpi * self.g_AB * self.DL_z(X[:, 1:2]) *
self.DL_z(X2[None, :, 1]))
def test_interpolation():
for i in range(NREPEAT):
fcoefs_amp, fcoefs_mu, fcoefs_sig \
= random_filtercoefs(numBands, numCoefs)
lines_mu, lines_sig = random_linecoefs(numLines)
var_C, var_L, alpha_C, alpha_L, alpha_T = random_hyperparams()
norms = np.sqrt(2 * np.pi) * np.sum(fcoefs_amp * fcoefs_sig, axis=1)
print('Failed with params:', var_C, var_L, alpha_C, alpha_L, alpha_T)
kern = Photoz_kernel(fcoefs_amp, fcoefs_mu, fcoefs_sig, lines_mu,
lines_sig, var_C, var_L, alpha_C, alpha_L,
alpha_T)
for j in range(numBands):
X = np.vstack((np.repeat(j, kern.nz), kern.redshiftGrid,
np.repeat(1, kern.nz), np.repeat(0, kern.nz))).T
assert X.shape[0] == kern.nz
assert X.shape[1] == 4
Kfull = kern.K(X)
Kdiag = kern.Kdiag(X)
assert np.allclose(np.diag(Kfull), Kdiag, rtol=relative_accuracy)
b1 = kern.roundband(X[:, 0])
fz1 = (1. + X[:, 1])
kern.construct_interpolators()
kern.update_kernelparts(X)
ts = (kern.nz, kern.nz)
KC, KL = np.zeros(ts), np.zeros(ts)
D_alpha_C, D_alpha_L, D_alpha_z\
= np.zeros(ts), np.zeros(ts), np.zeros(ts)
kernelparts(kern.nz, kern.nz, numCoefs, numLines, alpha_C, alpha_L,
fcoefs_amp, fcoefs_mu, fcoefs_sig, lines_mu, lines_sig,
norms, b1, fz1, b1, fz1, True, KL, KC, D_alpha_C,
D_alpha_L, D_alpha_z)
assert np.allclose(KL, kern.KL, rtol=relative_accuracy)
assert np.allclose(KC, kern.KC, rtol=relative_accuracy)
assert np.allclose(D_alpha_C,
kern.D_alpha_C,
rtol=relative_accuracy)
assert np.allclose(D_alpha_L,
kern.D_alpha_L,
rtol=relative_accuracy)
t_constr += (t2 - t1)
t1 = time.time()
kern.update_kernelparts(X, X2)
t2 = time.time()
t_interp += (t2 - t1)
t1 = time.time()
assert X.shape[0] == size
ts = (size, size)
KC, KL = np.zeros(ts), np.zeros(ts)
D_alpha_C, D_alpha_L, D_alpha_z\
= np.zeros(ts), np.zeros(ts), np.zeros(ts)
kernelparts(size, size, numCoefs, numLines,
alpha_C, alpha_L,
fcoefs_amp, fcoefs_mu, fcoefs_sig,
lines_mu, lines_sig,
norms, b1, fz1, b2, fz2,
True, KL, KC, D_alpha_C, D_alpha_L, D_alpha_z)
t2 = time.time()
t_raw += (t2 - t1)
relerr1 += np.abs(kern.KC/KC - 1.) / NREPEAT
relerr2 += np.abs(kern.KL/KL - 1.) / NREPEAT
relerr3 += np.abs(kern.D_alpha_C/D_alpha_C - 1.) / NREPEAT
relerr4 += np.abs(kern.D_alpha_L/D_alpha_L - 1.) / NREPEAT
print('Relative error on KC:', relerr1.mean(), relerr1.std())
print('Relative error on KL:', relerr2.mean(), relerr2.std())
print('Relative error on D_alpha_C:', relerr3.mean(), relerr3.std())
print('Relative error on D_alpha_L:', relerr4.mean(), relerr4.std())
print("=> kernelparts (raw): %s s" % (t_raw / NREPEAT))
def construct_interpolators(self):
"""
Construct interpolation scheme for the kernel.
This significantly speeds up calculations by computing and storing
the kernel evaluated on a grid, for later interpolation.
"""
bands = np.arange(self.numBands).astype(int)
fzgrid = 1 + self.redshiftGrid
ts = (self.numBands, self.numBands, self.nz, self.nz)
self.KC_grid, self.KL_grid = np.zeros(ts), np.zeros(ts)
self.D_alpha_C_grid, self.D_alpha_L_grid, self.D_alpha_z_grid\
= np.zeros(ts), np.zeros(ts), np.zeros(ts)
for b1 in range(self.numBands):
for b2 in range(self.numBands):
b1_grid = np.repeat(b1, self.nz).astype(int)
b2_grid = np.repeat(b2, self.nz).astype(int)
kernelparts(self.nz, self.nz, self.numCoefs, self.numLines,
self.alpha_C, self.alpha_L, self.fcoefs_amp,
self.fcoefs_mu, self.fcoefs_sig,
self.lines_mu[:self.numLines],
self.lines_sig[:self.numLines], self.norms,
b1_grid, fzgrid, b2_grid, fzgrid, True,
self.KL_grid[b1, b2, :, :], self.KC_grid[b1,
b2, :, :],
self.D_alpha_C_grid[b1, b2, :, :],
self.D_alpha_L_grid[b1, b2, :, :],
self.D_alpha_z_grid[b1, b2, :, :])
bands = np.arange(self.numBands).astype(int)
fzgrid = 1 + self.redshiftGrid
self.KL_diag_interp = np.empty(self.numBands, dtype=interp1d)
self.KC_diag_interp = np.empty(self.numBands, dtype=interp1d)
self.D_alpha_C_diag_interp = np.empty(self.numBands, dtype=interp1d)
self.D_alpha_L_diag_interp = np.empty(self.numBands, dtype=interp1d)
for b1 in range(self.numBands):
ts = (self.nz, )
KC_grid, KL_grid = np.zeros(ts), np.zeros(ts)
D_alpha_C_grid, D_alpha_L_grid, D_alpha_z_grid\
= np.zeros(ts), np.zeros(ts), np.zeros(ts)
b1_grid = np.repeat(b1, self.nz).astype(int)
kernelparts_diag(self.nz, self.numCoefs, self.numLines,
self.alpha_C, self.alpha_L, self.fcoefs_amp,
self.fcoefs_mu, self.fcoefs_sig,
self.lines_mu[:self.numLines],
self.lines_sig[:self.numLines], self.norms,
b1_grid, fzgrid, True, KL_grid, KC_grid,
D_alpha_C_grid, D_alpha_L_grid)
self.KL_diag_interp[b1] = interp1d(fzgrid,
KL_grid,
kind=kind,
assume_sorted=True,
bounds_error=False,
fill_value="extrapolate")
self.KC_diag_interp[b1] = interp1d(fzgrid,
KC_grid,
kind=kind,
assume_sorted=True,
bounds_error=False,
fill_value="extrapolate")
self.D_alpha_C_diag_interp[b1] = interp1d(fzgrid,
D_alpha_C_grid,
kind=kind,
assume_sorted=True,
bounds_error=False,
fill_value="extrapolate")
self.D_alpha_L_diag_interp[b1] = interp1d(fzgrid,
D_alpha_L_grid,
kind=kind,
assume_sorted=True,
bounds_error=False,
fill_value="extrapolate")
