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_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 __init__(self, signal, err, init_period=None, period_ppf=None):
if not isinstance(signal, TSeries):
signal = TSeries(data=signal)
self.signal = signal
self.err = err
self.t = self.signal.time
self.y = self.signal.values
self.sigma = np.std(self.y)
self.jitter = np.min(self.err) ** 2
self.mean = np.mean(self.y)
if init_period is None:
init_period = np.sqrt(signal.size) * signal.median_dt
if period_ppf is None:
def period_ppf(u):
sigma_period = 0.5 * np.log(signal.size)
return np.exp(norm.ppf(u, np.log(init_period), sigma_period))
self.period_ppf = period_ppf
init_params = self.prior_transform(np.full(self.ndim, 50.0))
init_params["period"] = init_period
mean = init_params.pop("mean")
jitter = init_params.pop("jitter")
self.gp = celerite2.GaussianProcess(self.kernel(**init_params), mean=mean)
self.gp.compute(self.t, diag=self.err ** 2 + jitter)
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_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_consistency(oterm, mean, data):
x, diag, y, t = data
# Setup the original GP
original_gp = original_celerite.GP(oterm, mean=mean)
original_gp.compute(x, np.sqrt(diag))
# Setup the new GP
term = terms.OriginalCeleriteTerm(oterm)
gp = celerite2.GaussianProcess(term, mean=mean)
gp.compute(x, diag=diag)
# "log_likelihood" method
assert np.allclose(original_gp.log_likelihood(y), gp.log_likelihood(y))
# "predict" method
for args in [
dict(return_cov=False, return_var=False),
dict(return_cov=False, return_var=True),
dict(return_cov=True, return_var=False),
]:
assert all(
np.allclose(a, b) for a, b in zip(
original_gp.predict(y, **args),
gp.predict(y, **args),
))
assert all(
np.allclose(a, b) for a, b in zip(
original_gp.predict(y, t=t, **args),
gp.predict(y, t=t, **args),
))
# "sample" method
seed = 5938
np.random.seed(seed)
a = original_gp.sample()
np.random.seed(seed)
b = gp.sample()
assert np.allclose(a, b)
np.random.seed(seed)
a = original_gp.sample(size=10)
np.random.seed(seed)
b = gp.sample(size=10)
assert np.allclose(a, b)
# "sample_conditional" method, numerics make this one a little unstable;
# just check the shape
a = original_gp.sample_conditional(y, t=t)
b = gp.sample_conditional(y, t=t)
assert a.shape == b.shape
a = original_gp.sample_conditional(y, size=10)
b = gp.sample_conditional(y, size=10)
assert a.shape == b.shape
def test_consistency(oterm, mean, data):
x, diag, y, t = data
# Setup the original GP
original_gp = original_celerite.GP(oterm, mean=mean)
original_gp.compute(x, np.sqrt(diag))
# Setup the new GP
term = terms.OriginalCeleriteTerm(oterm)
gp = celerite2.GaussianProcess(term, mean=mean)
gp.compute(x, diag=diag)
# "log_likelihood" method
assert np.allclose(original_gp.log_likelihood(y), gp.log_likelihood(y))
# Apply inverse
assert np.allclose(
np.squeeze(original_gp.apply_inverse(y)), gp.apply_inverse(y)
)
conditional_t = gp.condition(y, t=t)
mu, cov = original_gp.predict(y, t=t, return_cov=True)
assert np.allclose(conditional_t.mean, mu)
assert np.allclose(conditional_t.variance, np.diag(cov))
assert np.allclose(conditional_t.covariance, cov)
conditional = gp.condition(y)
mu, cov = original_gp.predict(y, return_cov=True)
assert np.allclose(conditional.mean, mu)
assert np.allclose(conditional.variance, np.diag(cov))
assert np.allclose(conditional.covariance, cov)
# "sample" method
seed = 5938
np.random.seed(seed)
a = original_gp.sample()
np.random.seed(seed)
b = gp.sample()
assert np.allclose(a, b)
np.random.seed(seed)
a = original_gp.sample(size=10)
np.random.seed(seed)
b = gp.sample(size=10)
assert np.allclose(a, b)
# "sample_conditional" method, numerics make this one a little unstable;
# just check the shape
a = original_gp.sample_conditional(y, t=t)
b = conditional_t.sample()
assert a.shape == b.shape
a = original_gp.sample_conditional(y, size=10)
b = conditional.sample(size=10)
assert a.shape == b.shape
def test_consistency(name, args, mean, data):
x, diag, y, t = data
term = getattr(terms, name)(**args)
gp = GaussianProcess(term, mean=mean)
gp.compute(x, diag=diag)
pyterm = getattr(pyterms, name)(**args)
pygp = celerite2.GaussianProcess(pyterm, mean=mean)
pygp.compute(x, diag=diag)
check_gp_models(lambda x: x.eval(), gp, pygp, y, t)
def test_consistency(name, args, mean):
# 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 = getattr(terms, name)(**args)
gp = GaussianProcess(term, mean=mean)
gp.compute(x, diag=diag)
pyterm = getattr(pyterms, name)(**args)
pygp = celerite2.GaussianProcess(pyterm, mean=mean)
pygp.compute(x, diag=diag)
check_gp_models(lambda x: x.detach().numpy(), gp, pygp, y, t)
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 _compute(self, light_curve: pd.DataFrame, **kwargs) -> pd.Series:
time = light_curve["hmjd"]
mag = light_curve["mag"]
err = light_curve["magerr"]
time = time - time.min()
mag = mag - mag.mean()
sq_error = err**2
kernel = celerite2.terms.RealTerm(a=1.0, c=10.0)
gp = celerite2.GaussianProcess(kernel, mean=0.0)
initial_params = np.array([np.log(1.0), np.log(1.0)])
sol = minimize(neg_log_like,
initial_params,
method="L-BFGS-B",
args=(gp, time, mag, sq_error))
optimal_params = np.exp(sol.x)
out_data = [optimal_params[0], 1.0 / optimal_params[1]]
out = pd.Series(data=out_data,
index=self.get_features_keys_without_band())
return out
# 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:
# +
freq = np.linspace(1.0 / 8, 1.0 / 0.3, 500)
omega = 2 * np.pi * freq
def plot_psd(gp):
for n, term in enumerate(gp.kernel.terms):
plt.loglog(freq, term.get_psd(omega), label="term {0}".format(n + 1))
def sim_signal(time, amp=1e-3, w=10.):
kernel = celerite.terms.SHOTerm(S0=1, Q=1, w0=2 * np.pi / w)
gp = celerite.GaussianProcess(kernel)
gp.compute(time)
return 1 + utils.rescale(gp.sample()) * amp / 2
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]),
spec_path='..')
