def create_gp(params):
# GP parameters
s2 = np.exp(params["log_s2"])
taux = np.exp(params["log_taux"])
tauy = np.exp(params["log_tauy"])
gpx = GP(s2 * ExpSquaredKernel(taux))
gpy = GP(s2 * ExpSquaredKernel(tauy))
return gpx, gpy
def test_gp_mean(N=50, seed=1234):
np.random.seed(seed)
x = np.random.uniform(0, 5)
y = 5 + np.sin(x)
gp = GP(10. * kernels.ExpSquaredKernel(1.3), mean=5.0, fit_mean=True)
gp.compute(x)
check_gradient(gp, y)
def test_dtype(seed=123):
np.random.seed(seed)
kernel = 0.1 * kernels.ExpSquaredKernel(1.5)
kernel.pars = [1, 2]
gp = GP(kernel)
x = np.random.rand(100)
gp.compute(x, 1e-2)
def test_apply_inverse(solver, seed=1234, N=201, yerr=0.1):
np.random.seed(seed)
# Set up the solver.
kernel = 1.0 * kernels.ExpSquaredKernel(0.5)
kwargs = dict()
if solver == HODLRSolver:
kwargs["tol"] = 1e-10
gp = GP(kernel, solver=solver, **kwargs)
# Sample some data.
x = np.sort(np.random.rand(N))
y = gp.sample(x)
gp.compute(x, yerr=yerr)
K = gp.get_matrix(x)
K[np.diag_indices_from(K)] += yerr**2
b1 = np.linalg.solve(K, y)
b2 = gp.apply_inverse(y)
assert np.allclose(b1, b2)
y = gp.sample(x, size=5).T
b1 = np.linalg.solve(K, y)
b2 = gp.apply_inverse(y)
assert np.allclose(b1, b2)
def test_repeated_prediction_cache():
kernel = kernels.ExpSquaredKernel(1.0)
gp = GP(kernel)
x = np.array((-1, 0, 1))
gp.compute(x)
t = np.array((-.5, .3, 1.2))
y = x / x.std()
mu0, mu1 = (gp.predict(y, t, return_cov=False) for _ in range(2))
assert np.array_equal(mu0, mu1), \
"Identical training data must give identical predictions " \
"(problem with GP cache)."
y2 = 2 * y
mu2 = gp.predict(y2, t, return_cov=False)
assert not np.array_equal(mu0, mu2), \
"Different training data must give different predictions " \
"(problem with GP cache)."
a0 = gp._alpha
gp.kernel[0] += 0.1
gp.recompute()
gp._compute_alpha(y2, True)
a1 = gp._alpha
assert not np.allclose(a0, a1), \
"Different kernel parameters must give different alphas " \
"(problem with GP cache)."
mu, cov = gp.predict(y2, t)
_, var = gp.predict(y2, t, return_var=True)
assert np.allclose(np.diag(cov), var), \
"The predictive variance must be equal to the diagonal of the " \
"predictive covariance."
def _general_metric(metric, N=100, ndim=3):
kernel = 0.1 * kernels.ExpSquaredKernel(metric, ndim=ndim)
x = np.random.rand(N, ndim)
M0 = kernel.get_value(x)
gp = GP(kernel)
M1 = gp.get_matrix(x)
assert np.allclose(M0, M1)
# Compute the expected matrix.
M2 = np.empty((N, N))
for i in range(N):
for j in range(N):
r = x[i] - x[j]
r2 = np.dot(r, np.linalg.solve(metric, r))
M2[i, j] = 0.1 * np.exp(-0.5 * r2)
if not np.allclose(M0, M2):
print(M0)
print()
print(M2)
print()
print(M0 - M2)
print()
print(M0 / M2)
L = np.linalg.cholesky(metric)
i = N - 1
j = N - 2
r = x[j] - x[i]
print(x[i], x[j])
print("r = ", r)
print("L.r = ", np.dot(L, r))
assert np.allclose(M0, M2)
def __init__(self,
data=None,
param={},
bounds={},
fixed=[],
group=None,
**kwargs):
"""
:param data:
:param param:
:param bounds:
:param group:
"""
self.data = []
self.param, self.param_name, self.param_bounds = np.array(
[]), np.array([]), []
self.Ndata = 0
self.index_param_indiv = []
self.index_bounds_indiv = []
self.index_param_common = []
self.index_bounds_common = []
self.group_indiv = []
self.fixed = []
self.group_common = []
self.detrendvar = {}
self._varind = 0
self.gp = GP(solver=BasicSolver)
self._mcmc_parinit_optimized = False
self.add_data(data, param, bounds, fixed, group, **kwargs)
def plotsample_QP(p, t, y, tsel, ysel):
kern, sig = kern_QP(p)
gp = GP(kern)
yerr = np.ones(len(ysel)) * sig
gp.compute(tsel, yerr)
mu = gp.sample_conditional(ysel, t)
pl.plot(t, mu, color='c', alpha=0.3)
return
def test_gp_callable_mean(N=50, seed=1234):
np.random.seed(seed)
x = np.random.uniform(0, 5)
y = 5 + np.sin(x)
mean = CallableModel(lambda x: 5.0 * x)
gp = GP(10. * kernels.ExpSquaredKernel(1.3), mean=mean)
gp.compute(x)
check_gradient(gp, y)
def test_pickle(solver, success, N=50, seed=123):
np.random.seed(seed)
kernel = 0.1 * kernels.ExpSquaredKernel(1.5)
kernel.pars = [1, 2]
gp = GP(kernel, solver=solver)
x = np.random.rand(100)
gp.compute(x, 1e-2)
s = pickle.dumps(gp, -1)
gp = pickle.loads(s)
if success:
gp.compute = _fake_compute
gp.lnlikelihood(np.sin(x))
def test_gp_callable_white_noise(N=50, seed=1234):
np.random.seed(seed)
x = np.random.uniform(0, 5)
y = 5 + np.sin(x)
gp = GP(10. * kernels.ExpSquaredKernel(1.3),
mean=5.0,
white_noise=LinearWhiteNoise(-6, 0.01),
fit_white_noise=True)
gp.compute(x)
check_gradient(gp, y)
gp.freeze_parameter("white_noise:m")
check_gradient(gp, y)
def create(self,
rseed=0,
ldcs=None,
wnsigma=None,
rnsigma=None,
rntscale=0.5,
nights=1):
ldcs = ldcs if ldcs is not None else self.ldcs
seed(rseed)
self.time = linspace(-0.5 * float(self.t_total_d),
0.5 * float(self.t_total_d), self.n_exp)
self.time = (tile(self.time, [nights, 1]) +
(self.p * arange(nights))[:, newaxis]).ravel()
self.npt = self.time.size
self.transit = zeros([self.npt, 4])
for i, (ldc, c) in enumerate(zip(ldcs, self.contamination)):
self.transit[:, i] = MA().evaluate(self.time,
self.k0,
ldc,
0,
self.p,
self.a,
self.i,
c=c)
# White noise
# -----------
if wnsigma is not None:
self.wnoise = multivariate_normal(
zeros(atleast_2d(self.transit).shape[1]),
diag(wnsigma)**2, self.npt)
else:
self.wnoise = zeros_like(self.transit)
# Red noise
# ---------
if rnsigma and with_george:
self.gp = GP(rnsigma**2 * ExpKernel(rntscale))
self.gp.compute(self.time)
self.rnoise = self.gp.sample(self.time, self.npb).T
self.rnoise -= self.rnoise.mean(0)
else:
self.rnoise = zeros_like(self.transit)
# Final light curve
# -----------------
self.time_h = Qty(self.time, 'd').rescale('h')
self.flux = self.transit + self.wnoise + self.rnoise
return self.time_h, self.flux
def test_bounds():
kernel = 10 * kernels.ExpSquaredKernel(1.0, metric_bounds=[(None, 4.0)])
kernel += 0.5 * kernels.RationalQuadraticKernel(log_alpha=0.1, metric=5.0)
gp = GP(kernel, white_noise=LinearWhiteNoise(1.0, 0.1))
# Test bounds length.
assert len(gp.get_parameter_bounds()) == len(gp.get_parameter_vector())
gp.freeze_all_parameters()
gp.thaw_parameter("white_noise:m")
assert len(gp.get_parameter_bounds()) == len(gp.get_parameter_vector())
# Test invalid bounds specification.
with pytest.raises(ValueError):
kernels.ExpSine2Kernel(gamma=0.1, log_period=5.0, bounds=[10.0])
def test_axis_algined_metric(seed=1234, N=100, ndim=3):
np.random.seed(seed)
kernel = 0.1 * kernels.ExpSquaredKernel(np.ones(ndim), ndim=ndim)
x = np.random.rand(N, ndim)
M0 = kernel.get_value(x)
gp = GP(kernel)
M1 = gp.get_matrix(x)
assert np.allclose(M0, M1)
# Compute the expected matrix.
M2 = 0.1 * np.exp(-0.5 * np.sum(
(x[None, :, :] - x[:, None, :])**2, axis=-1))
assert np.allclose(M0, M2)
def test_predict_single(solver, seed=1234, N=201, yerr=0.1):
np.random.seed(seed)
# Set up the solver.
kernel = 1.0 * kernels.ExpSquaredKernel(0.5)
kwargs = dict()
if solver == HODLRSolver:
kwargs["tol"] = 1e-8
gp = GP(kernel, solver=solver, **kwargs)
x = np.sort(np.random.rand(N))
y = gp.sample(x)
gp.compute(x, yerr=yerr)
mu0, var0 = gp.predict(y, [0.0], return_var=True)
mu, var = gp.predict(y, [0.0, 1.0], return_var=True)
_, cov = gp.predict(y, [0.0, 1.0])
assert np.allclose(mu0, mu[0])
assert np.allclose(var0, var[0])
assert np.allclose(var0, cov[0, 0])
def __init__(self, mean, covariance, points, lnlikes, quiet=True):
self.mean = mean
self.cov = covariance
#Let's try only interpolating over points that are
#better than, say, 10-ish sigma
dof = len(self.mean)
inds = np.fabs(np.max(lnlikes) - lnlikes) < 100 * dof
print(inds)
print(lnlikes)
self.points = points[inds]
self.lnlikes_true = lnlikes[inds]
self.lnlike_max = np.max(lnlikes[inds])
self.lnlikes = lnlikes[inds] - self.lnlike_max #max is now at 0
self.x = self._transform_data(self.points)
print(max(self.lnlikes), min(self.lnlikes))
_guess = 4.5 #kernel length guess
kernel = kernels.ExpSquaredKernel(metric=_guess, ndim=dof)
lnPmin = np.min(self.lnlikes)
gp = GP(kernel, mean=lnPmin - np.fabs(lnPmin * 3))
gp.compute(self.x)
def neg_ln_likelihood(p):
gp.set_parameter_vector(p)
return -gp.log_likelihood(self.lnlikes)
def grad_neg_ln_likelihood(p):
gp.set_parameter_vector(p)
return -gp.grad_log_likelihood(self.lnlikes)
result = minimize(neg_ln_likelihood,
gp.get_parameter_vector(),
jac=grad_neg_ln_likelihood)
if not quiet:
print(result)
gp.set_parameter_vector(result.x)
self.gp = gp
def test_gradient(solver, white_noise, seed=123, N=305, ndim=3, eps=1.32e-3):
np.random.seed(seed)
# Set up the solver.
kernel = 1.0 * kernels.ExpSquaredKernel(0.5, ndim=ndim)
kwargs = dict()
if white_noise is not None:
kwargs = dict(white_noise=white_noise, fit_white_noise=True)
if solver == HODLRSolver:
kwargs["tol"] = 1e-8
gp = GP(kernel, solver=solver, **kwargs)
# Sample some data.
x = np.random.rand(N, ndim)
x = x[np.argsort(x[:, 0])]
y = gp.sample(x)
gp.compute(x, yerr=0.1)
# Compute the initial gradient.
grad0 = gp.grad_log_likelihood(y)
vector = gp.get_parameter_vector()
for i, v in enumerate(vector):
# Compute the centered finite difference approximation to the gradient.
vector[i] = v + eps
gp.set_parameter_vector(vector)
lp = gp.lnlikelihood(y)
vector[i] = v - eps
gp.set_parameter_vector(vector)
lm = gp.lnlikelihood(y)
vector[i] = v
gp.set_parameter_vector(vector)
grad = 0.5 * (lp - lm) / eps
assert np.abs(grad - grad0[i]) < 5 * eps, \
"Gradient computation failed in dimension {0} ({1})\n{2}" \
.format(i, solver.__name__, np.abs(grad - grad0[i]))
def add_spots(self,QP=[5e-5,0.5,30.,28.]):
"""
This attribute add stellar variability using a Quasi-periodic Kernel
The activity is added using a george Kernel
"""
if not hasattr(self,'flux_spots'):
A = QP[0]
le = QP[1]
lp = QP[2]
P = QP[3]
from george import kernels, GP
k = A * kernels.ExpSine2Kernel(gamma=1./2/lp,log_period=np.log(P)) * \
kernels.ExpSquaredKernel(metric=le)
gp = GP(k)
self.flux_spots = 1 + gp.sample(self.time)
self.flux = self.flux * self.flux_spots
self.spots = True
def test_parameters():
kernel = 10 * kernels.ExpSquaredKernel(1.0)
kernel += 0.5 * kernels.RationalQuadraticKernel(log_alpha=0.1, metric=5.0)
gp = GP(kernel, white_noise=LinearWhiteNoise(1.0, 0.1))
n = len(gp.get_parameter_vector())
assert n == len(gp.get_parameter_names())
assert n - 2 == len(kernel.get_parameter_names())
gp.freeze_parameter(gp.get_parameter_names()[0])
assert n - 1 == len(gp.get_parameter_names())
assert n - 1 == len(gp.get_parameter_vector())
gp.freeze_all_parameters()
assert len(gp.get_parameter_names()) == 0
assert len(gp.get_parameter_vector()) == 0
gp.kernel.thaw_all_parameters()
gp.white_noise.thaw_all_parameters()
assert n == len(gp.get_parameter_vector())
assert n == len(gp.get_parameter_names())
assert np.allclose(kernel[0], np.log(10.))
def plotpred_QP(p, t, y):
kern, sig = kern_QP(p)
gp = GP(kern)
yerr = np.ones(len(y)) * sig
gp.compute(t, yerr)
mu, cov = gp.predict(y, t)
sigma = np.diag(cov)
sigma = np.sqrt(sigma**2 + yerr**2)
pl.fill_between(t, mu + 2 * sigma, mu - 2 * sigma, \
color='c', alpha=0.3)
pl.plot(t, mu, color='c', lw=2)
nper = (len(p) - 1) / 4
# if nper > 1:
# cols = ['c','m','y','k']
# for i in range(nper):
# p1 = np.append(p[i*4:i*4+4], p[-1])
# k1, sig = kern_QP(p1)
# b = gp.solver.apply_inverse(y)
# X = np.transpose([t])
# K1 = k1.value(t, t)
# mu1 = np.dot(K1, b)
# col = np.roll(cols, -i)[0]
# pl.plot(t, mu, color = col, lw = 2)
return
def test_prediction(solver, seed=42):
"""Basic sanity checks for GP regression."""
np.random.seed(seed)
kernel = kernels.ExpSquaredKernel(1.0)
kwargs = dict()
if solver == HODLRSolver:
kwargs["tol"] = 1e-8
gp = GP(kernel, solver=solver, white_noise=0.0, **kwargs)
x0 = np.linspace(-10, 10, 500)
x = np.sort(np.random.uniform(-10, 10, 300))
gp.compute(x)
y = np.sin(x)
mu, cov = gp.predict(y, x0)
Kstar = gp.get_matrix(x0, x)
K = gp.get_matrix(x)
K[np.diag_indices_from(K)] += 1.0
mu0 = np.dot(Kstar, np.linalg.solve(K, y))
print(np.abs(mu - mu0).max())
assert np.allclose(mu, mu0)
def __init__(self, target, datasets, filters, model='pb_independent_k', fit_wn=True, **kwargs):
super().__init__(target, datasets, filters, model, **kwargs)
pbl = [LParameter('bl_{:d}'.format(i), 'baseline', '', N(1, 1e-2), bounds=(-inf,inf)) for i in range(self.nlc)]
self.ps.thaw()
self.ps.add_lightcurve_block('baseline', 1, self.nlc, pbl)
self.ps.freeze()
self._slbl = self.ps.blocks[-1].slice
self._stbl = self.ps.blocks[-1].start
self.logwnvar = log(array(self.wn) ** 2)
self._create_kernel()
self.covariates = [cv[:, self.covids] for cv in self.covariates]
self.freeze = []
self.standardize = []
self.gps = [GP(self._create_kernel(),
mean=0., fit_mean=False,
white_noise=0.8*wn, fit_white_noise=fit_wn) for wn in self.logwnvar]
# Freeze the GP hyperparameters marked as frozen in _create_kernel
for gp in self.gps:
pars = gp.get_parameter_names()
[gp.freeze_parameter(pars[i]) for i in self.freeze]
# Standardize the covariates marked to be standardized in _create_kernel
for c in self.covariates:
for i in self.standardize:
c[:,i] = (c[:,i] - c[:,i].min()) / c[:,i].ptp()
self.compute_always = False
self.compute_gps()
self.de = None
self.gphpres = None
self.gphps = None
def train(self, kernel=None):
"""Train a Gaussian Process to interpolate the log-likelihood
of the training samples.
Args:
kernel (george.kernels.Kernel object): kernel to use, or any
acceptable object that can be accepted by the george.GP object
"""
inds = self.training_inds
x = self.chain_rotated_regularized[inds]
lnL = self.lnlikes[inds]
_guess = 4.5
if kernel is None:
kernel = kernels.ExpSquaredKernel(metric=_guess, ndim=len(x[0]))
#Note: the mean is set slightly lower that the minimum lnlike
lnPmin = np.min(self.lnlikes)
gp = GP(kernel, mean=lnPmin - np.fabs(lnPmin * 3))
gp.compute(x)
def neg_ln_likelihood(p):
gp.set_parameter_vector(p)
return -gp.log_likelihood(lnL)
def grad_neg_ln_likelihood(p):
gp.set_parameter_vector(p)
return -gp.grad_log_likelihood(lnL)
result = minimize(neg_ln_likelihood,
gp.get_parameter_vector(),
jac=grad_neg_ln_likelihood)
print(result)
gp.set_parameter_vector(result.x)
self.gp = gp
self.lnL_training = lnL
return
def create_gp(self):
gp = GP(kernel=self.kk, mean=self.mean)
gp.compute(self.x_train, self.sigma_n)
return gp
def __init__(self, kernel):
self.kernel = kernel
self._gp = GP(kernel._k)
self._y = None ## Cached inputs
self._x = None ## Cached values
self._dirty = True ## Flag telling if the arrays are up to date
def get_simple_gp(pars):
amp, length = pars
kernel = amp * ExpSquaredKernel(length)
return GP(kernel)
def get_linear_gp(pars):
amp, sigma = pars
kernel = (amp * PolynomialKernel(sigma, order=2))
return GP(kernel)
def get_composite_gp(pars):
amp, sigma, amp2, length = pars
kernel = (amp * PolynomialKernel(sigma, order=1) +
amp2 * ExpSquaredKernel(length))
return GP(kernel)
def create_gp(self):
# This function uses the kernel defined above to compute and train the Gaussian Process model
gp = GP(kernel=self.kk, mean=self.mean)
gp.compute(self.x_train, self.sigma_n)
return gp
def get_fancy_gp(pars):
amp, a, b, c, d = pars
kernel = amp * MyDijetKernelSimp(a, b, c, d)
return GP(kernel)
