def set_params(params, gp):
gp.mean = params[0]
theta = np.exp(params[1:])
gp.kernel = terms.SHOTerm(sigma=theta[0], rho=theta[1],
tau=theta[2]) + terms.SHOTerm(
sigma=theta[3], rho=theta[4], Q=0.25)
gp.compute(t, diag=yerr**2 + theta[5], quiet=True)
return gp
def test_mean(data):
x, diag, y, t = data
term = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
gp = celerite2.GaussianProcess(term, t=x, diag=diag, mean=lambda x: 2 * x)
mu1 = gp.predict(y, include_mean=True)
mu2 = gp.predict(y, x, include_mean=True)
assert np.allclose(mu1, mu2)
mu1 = gp.predict(y, include_mean=False)
mu2 = gp.predict(y, x, include_mean=False)
assert np.allclose(mu1, mu2)
mu_mean = gp.predict(y, include_mean=True)
mu_no_mean = gp.predict(y, include_mean=False)
assert np.allclose(mu_mean, mu_no_mean + 2 * x)
mu_mean = gp.predict(y, t, include_mean=True)
mu_no_mean = gp.predict(y, t, include_mean=False)
assert np.allclose(mu_mean, mu_no_mean + 2 * t)
np.random.seed(42)
s1 = gp.sample(size=5, include_mean=True)
np.random.seed(42)
s2 = gp.sample(size=5, include_mean=False)
assert np.allclose(s1, s2 + 2 * x)
def test_mean(data):
x, diag, y, t = data
term = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
gp = celerite2.GaussianProcess(term, t=x, diag=diag, mean=lambda x: 2 * x)
cond1 = gp.condition(y, include_mean=True)
cond2 = gp.condition(y, x, include_mean=True)
assert np.allclose(cond1.mean, cond2.mean)
cond1 = gp.condition(y, include_mean=False)
cond2 = gp.condition(y, x, include_mean=False)
assert np.allclose(cond1.mean, cond2.mean)
cond_mean = gp.condition(y, include_mean=True)
cond_no_mean = gp.condition(y, include_mean=False)
assert np.allclose(cond_mean.mean, cond_no_mean.mean + 2 * x)
cond_mean = gp.condition(y, t, include_mean=True)
cond_no_mean = gp.condition(y, t, include_mean=False)
assert np.allclose(cond_mean.mean, cond_no_mean.mean + 2 * t)
np.random.seed(42)
s1 = gp.sample(size=5, include_mean=True)
np.random.seed(42)
s2 = gp.sample(size=5, include_mean=False)
assert np.allclose(s1, s2 + 2 * x)
def test_base_terms(name, args):
term = getattr(terms, name)(**args)
pyterm = getattr(pyterms, name)(**args)
compare_terms(term, pyterm)
compare_terms(terms.TermDiff(term), pyterms.TermDiff(pyterm))
compare_terms(terms.TermConvolution(term, 0.5),
pyterms.TermConvolution(pyterm, 0.5))
term0 = terms.SHOTerm(S0=1.0, w0=0.5, Q=1.5)
pyterm0 = pyterms.SHOTerm(S0=1.0, w0=0.5, Q=1.5)
compare_terms(term + term0, pyterm + pyterm0)
compare_terms(term * term0, pyterm * pyterm0)
term0 = terms.SHOTerm(S0=1.0, w0=0.5, Q=0.2)
pyterm0 = pyterms.SHOTerm(S0=1.0, w0=0.5, Q=0.2)
compare_terms(term + term0, pyterm + pyterm0)
compare_terms(term * term0, pyterm * pyterm0)
def test_errors():
# Generate fake data
np.random.seed(40582)
x = np.sort(np.random.uniform(0, 10, 50))
t = np.sort(np.random.uniform(-1, 12, 100))
diag = np.random.uniform(0.1, 0.3, len(x))
y = np.sin(x)
term = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
gp = celerite2.GaussianProcess(term)
# Need to call compute first
with pytest.raises(RuntimeError):
gp.recompute()
with pytest.raises(RuntimeError):
gp.log_likelihood(y)
with pytest.raises(RuntimeError):
gp.sample()
# Sorted
with pytest.raises(ValueError):
gp.compute(x[::-1], diag=diag)
# 1D
with pytest.raises(ValueError):
gp.compute(np.tile(x[:, None], (1, 5)), diag=diag)
# Only one of diag and yerr
with pytest.raises(ValueError):
gp.compute(x, diag=diag, yerr=np.sqrt(diag))
# Not positive definite
# with pytest.raises(celerite2.driver.LinAlgError):
with pytest.raises(Exception):
gp.compute(x, diag=-10 * diag)
# Not positive definite with `quiet`
gp.compute(x, diag=-10 * diag, quiet=True)
assert np.isinf(gp._log_det)
assert gp._log_det < 0
# Compute correctly
gp.compute(x, diag=diag)
gp.log_likelihood(y)
# Dimension mismatch
with pytest.raises(ValueError):
gp.log_likelihood(y[:-1])
with pytest.raises(ValueError):
gp.log_likelihood(np.tile(y[:, None], (1, 5)))
with pytest.raises(ValueError):
gp.predict(y, t=np.tile(t[:, None], (1, 5)))
def test_diag(data):
x, diag, y, t = data
term = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
gp1 = celerite2.GaussianProcess(term, t=x, diag=diag)
gp2 = celerite2.GaussianProcess(term, t=x, yerr=np.sqrt(diag))
assert np.allclose(gp1.log_likelihood(y), gp2.log_likelihood(y))
gp1 = celerite2.GaussianProcess(term, t=x, diag=np.zeros_like(x))
gp2 = celerite2.GaussianProcess(term, t=x)
assert np.allclose(gp1.log_likelihood(y), gp2.log_likelihood(y))
def test_predict_kernel(data):
x, diag, y, t = data
term1 = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
term2 = terms.SHOTerm(S0=0.3, w0=0.1, Q=0.1)
term = term1 + term2
gp = celerite2.GaussianProcess(term, t=x, diag=diag)
cond0 = gp.condition(y)
cond1 = gp.condition(y, kernel=term)
assert np.allclose(cond0.mean, cond1.mean)
cond0 = gp.condition(y, t)
cond1 = gp.condition(y, t, kernel=term)
assert np.allclose(cond0.mean, cond1.mean)
cond0 = gp.condition(y, t)
cond1 = gp.condition(y, t, kernel=term1)
cond2 = gp.condition(y, t, kernel=term2)
assert np.allclose(cond0.mean, cond1.mean + cond2.mean)
cond1 = gp.condition(y, kernel=term1)
mu2 = term1.dot(x, np.zeros_like(x), gp.apply_inverse(y))
assert np.allclose(cond1.mean, mu2)
def test_predict_kernel(data):
x, diag, y, t = data
term1 = terms.SHOTerm(S0=1.0, w0=0.5, Q=3.0)
term2 = terms.SHOTerm(S0=0.3, w0=0.1, Q=0.1)
term = term1 + term2
gp = celerite2.GaussianProcess(term, t=x, diag=diag)
mu0 = gp.predict(y)
mu1 = gp.predict(y, kernel=term)
assert np.allclose(mu0, mu1)
mu0 = gp.predict(y, t)
mu1 = gp.predict(y, t, kernel=term)
assert np.allclose(mu0, mu1)
mu0 = gp.predict(y, t)
mu1 = gp.predict(y, t, kernel=term1)
mu2 = gp.predict(y, t, kernel=term2)
assert np.allclose(mu0, mu1 + mu2)
mu1 = gp.predict(y, kernel=term1)
mu2 = term1.dot(x, np.zeros_like(x), gp.apply_inverse(y))
assert np.allclose(mu1, mu2)
def _convert_kernel(celerite_kernel):
if isinstance(celerite_kernel, cterms.TermSum):
result = _convert_kernel(celerite_kernel.terms[0])
for k in celerite_kernel.terms[1:]:
result += _convert_kernel(k)
return result
elif isinstance(celerite_kernel, cterms.TermProduct):
return _convert_kernel(celerite_kernel.k1) * _convert_kernel(
celerite_kernel.k2)
elif isinstance(celerite_kernel, cterms.RealTerm):
return terms.RealTerm(a=np.exp(celerite_kernel.log_a),
c=np.exp(celerite_kernel.log_c))
elif isinstance(celerite_kernel, cterms.ComplexTerm):
if not celerite_kernel.fit_b:
return terms.ComplexTerm(
a=np.exp(celerite_kernel.log_a),
b=0.0,
c=np.exp(celerite_kernel.log_c),
d=np.exp(celerite_kernel.log_d),
)
return terms.ComplexTerm(
a=np.exp(celerite_kernel.log_a),
b=np.exp(celerite_kernel.log_b),
c=np.exp(celerite_kernel.log_c),
d=np.exp(celerite_kernel.log_d),
)
elif isinstance(celerite_kernel, cterms.SHOTerm):
return terms.SHOTerm(
S0=np.exp(celerite_kernel.log_S0),
Q=np.exp(celerite_kernel.log_Q),
w0=np.exp(celerite_kernel.log_omega0),
)
elif isinstance(celerite_kernel, cterms.Matern32Term):
return terms.Matern32Term(
sigma=np.exp(celerite_kernel.log_sigma),
rho=np.exp(celerite_kernel.log_rho),
)
raise NotImplementedError()
plt.xlabel("x [day]")
plt.ylabel("y [ppm]")
plt.xlim(0, 10)
plt.ylim(-2.5, 2.5)
_ = plt.title("simulated data")
# -
# Now, let's fit this dataset using a mixture of [SHOTerm](../api/python.rst#celerite2.terms.SHOTerm) terms: one quasi-periodic component and one non-periodic component.
# First let's set up an initial model to see how it looks:
# +
import celerite2
from celerite2 import terms
# Quasi-periodic term
term1 = terms.SHOTerm(sigma=1.0, rho=1.0, tau=10.0)
# Non-periodic component
term2 = terms.SHOTerm(sigma=1.0, rho=5.0, Q=0.25)
kernel = term1 + term2
# Setup the GP
gp = celerite2.GaussianProcess(kernel, mean=0.0)
gp.compute(t, yerr=yerr)
print("Initial log likelihood: {0}".format(gp.log_likelihood(y)))
# -
# Let's look at the underlying power spectral density of this initial model:
# +
disp = parts[5]
name = parts[6]
filt_disp = '{0}/{1}'.format(filt, disp)
wl = result['noise_dic']['All noise']['wl']
means = result['noise_dic']['All noise']['signal_mean_stack']
stds = result['noise_dic']['All noise']['signal_std_stack']
t = np.arange(0, nhours * 60 * 60, cycle_time)
import celerite2
from celerite2 import terms
S0 = float(sys.argv[2])
w0 = 886
term = terms.SHOTerm(S0=S0, w0=w0, Q=1 / np.sqrt(2))
gp = celerite2.GaussianProcess(term, mean=0.0)
gp.compute(t / (60 * 60 * 24), yerr=0)
fk = (gp.dot_tril(np.random.randn(len(t))) + 1)
import sys
sys.path.append('./')
import generate_noise
factors, data, wl = generate_noise.variability_factors(
fk,
wl,
cold_temp=int(sys.argv[3]),
hot_temp=int(sys.argv[4]),
effective_temp=int(sys.argv[3]),