def __init__(self, x, y, yerr, subdivisions):
"""
Initialize global variables of Gaussian Process Regression Interpolator
Args:
x (array): Independent variable
y (array): Dependent variable
yerr (array): Uncertainty on y
subdivisions: The number of subdivisions between data points
"""
# Define kernels
kernel_expsq = 38**2 * kernels.ExpSquaredKernel(metric=10**2)
kernel_periodic = 150**2 * kernels.ExpSquaredKernel(
2**2) * kernels.ExpSine2Kernel(gamma=0.05, log_period=np.log(11))
kernel_poly = 5**2 * kernels.RationalQuadraticKernel(
log_alpha=np.log(.78), metric=1.2**2)
kernel_extra = 5**2 * kernels.ExpSquaredKernel(1.6**2)
kernel = kernel_expsq + kernel_periodic + kernel_poly + kernel_extra
# Create GP object
self.gp = george.GP(kernel, mean=np.mean(y), fit_mean=False)
self.gp.compute(x, yerr)
# Set global variables
self.ndim = len(self.gp)
self.x = x
self.y = y
self.yerr = yerr
self.subdivisions = subdivisions
self.priors = [prior.Prior(0, 1) for i in range(self.ndim)]
self.x_predict = np.linspace(min(self.x), max(self.x),
subdivisions * (len(self.x) - 1) + 1)
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 kernel_gp(self, kernelname = 'expsquared'):
""" Kernel defininition
Standard kernels provided with george, evtl replaced with manual customizable kernels
User can change function to add new kernels or comninations thereof as much as required
:param kernelname: name of kernel, either 'expsquared', 'matern32', or 'rationalq'
"""
# Kernel for spatial 2D Gaussian Process. Default Exponential Squared Kernel. Change accordingly below.
# Kernels are initialised with weight and length (1 by default)
if kernelname == 'expsquared':
k0 = 1. * kernels.ExpSquaredKernel(1., ndim = 2) # + kernels.WhiteKernel(1.,ndim=2)
# other possible kernels as well as combinations:
if kernelname == 'matern32':
k0 = 1. * kernels.Matern32Kernel(1., ndim = 2)
# k2 = 2.4 ** 2 * kernels.ExpSquaredKernel(90 ** 2) * kernels.ExpSine2Kernel(2.0 / 1.3 ** 2, 1.0)
if kernelname == 'rationalq':
k0 = 1. * kernels.RationalQuadraticKernel(0.78, 1.2, ndim=2)
# k4 = kernels.WhiteKernel(1., ndim=2)
return k0 # + k1 + k2 + ...
def get_kernel(architecture, kernel_name, domain_name_lst, n_dims):
if architecture == "trans":
mapping = trans_domain_kernel_mapping
else:
mapping = None
kernel = None
initial_ls = np.ones([n_dims])
if kernel_name == "constant":
kernel = kernels.ConstantKernel(1, ndim=n_dims)
elif kernel_name == "polynomial":
kernel = kernels.PolynomialKernel(log_sigma2=1, order=3, ndim=n_dims)
elif kernel_name == "linear":
kernel = kernels.LinearKernel(log_gamma2=1, order=3, ndim=n_dims)
elif kernel_name == "dotproduct":
kernel = kernels.DotProductKernel(ndim=n_dims)
elif kernel_name == "exp":
kernel = kernels.ExpKernel(initial_ls, ndim=n_dims)
elif kernel_name == "expsquared":
kernel = kernels.ExpSquaredKernel(initial_ls, ndim=n_dims)
elif kernel_name == "matern32":
kernel = kernels.Matern32Kernel(initial_ls, ndim=n_dims)
elif kernel_name == "matern52":
kernel = kernels.Matern52Kernel(initial_ls, ndim=n_dims)
elif kernel_name == "rationalquadratic":
kernel = kernels.RationalQuadraticKernel(log_alpha=1,
metric=initial_ls,
ndim=n_dims)
elif kernel_name == "expsine2":
kernel = kernels.ExpSine2Kernel(1, 2, ndim=n_dims)
elif kernel_name == "heuristic":
kernel = mapping[domain_name_lst[0]](ndim=n_dims, axes=0)
for i in range(len(domain_name_lst[1:])):
d = domain_name_lst[1:][i]
kernel += mapping[d](ndim=n_dims, axes=i)
elif kernel_name == "logsquared":
kernel = kernels.LogSquaredKernel(initial_ls, ndim=n_dims)
return kernel
def sample_curve_v2(x,y,err,xsample_range,num_of_curves,filename):
ls = get_ls(x,y,err)
k1 = np.var(y)* kernels.ExpSquaredKernel(ls**2)
k2 = 1 * kernels.RationalQuadraticKernel(log_alpha=1, metric=ls**2)
kernel = k1 + k2
gp = george.GP(kernel, fit_mean=True)
gp.compute(x,err)
# Define the objective function (negative log-likelihood in this case).
def nll(p):
gp.set_parameter_vector(p)
ll = gp.lnlikelihood(y, quiet=True)
return -ll if np.isfinite(ll) else 1e25
# And the gradient of the objective function.
def grad_nll(p):
gp.set_parameter_vector(p)
return -gp.grad_lnlikelihood(y, quiet=True)
p0 = gp.get_parameter_vector()
results = op.minimize(nll, p0, jac=grad_nll, method="L-BFGS-B")
gp.set_parameter_vector(results.x)
xnew = xsample_range
ynew = gp.sample_conditional(y,xnew,number_of_curves)
t = np.linspace(np.min(x), np.max(x), 100)
mu, cov = gp.predict(y, t)
pl.errorbar(x,y,err,fmt='kx')
pl.plot(t,mu)
pl.fill_between(t, mu - 2*np.sqrt(std**2), mu + 2*np.sqrt(std**2), color='blue', alpha=0.2)
pl.savefig(filename+'.pdf')
# mu, cov = gp.predict(y, t)
# std = np.sqrt(np.diag(cov))
return xnew,ynew
def get_kernel(self, kernel_name, i):
"""get individual kernels"""
metric = (1. / np.exp(self.coeffs[kernel_name]))**2
if self.gp_code_name == 'george':
if kernel_name == 'Matern32':
kernel = kernels.Matern32Kernel(metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'ExpSquared':
kernel = kernels.ExpSquaredKernel(metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'RationalQuadratic':
kernel = kernels.RationalQuadraticKernel(log_alpha=1,
metric=metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'Exp':
kernel = kernels.ExpKernel(metric, ndim=self.nkernels, axes=i)
if self.gp_code_name == 'tinygp':
if kernel_name == 'Matern32':
kernel = tinygp.kernels.Matern32(metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'ExpSquared':
kernel = tinygp.kernels.ExpSquared(metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'RationalQuadratic':
kernel = tinygp.kernels.RationalQuadratic(alpha=1,
scale=metric,
ndim=self.nkernels,
axes=i)
if kernel_name == 'Exp':
kernel = tinygp.kernels.Exp(metric, ndim=self.nkernels, axes=i)
return kernel
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.))
data = co2.load_pandas().data
t = 2000 + (np.array(data.index.to_julian_date()) - 2451545.0) / 365.25
y = np.array(data.co2)
m = np.isfinite(t) & np.isfinite(y) & (t < 1996)
t, y = t[m][::4], y[m][::4]
plt.plot(t, y, ".k")
plt.xlim(t.min(), t.max())
plt.xlabel("year")
plt.ylabel("CO$_2$ in ppm")
#Load kernels
k1 = 66**2 * kernels.ExpSquaredKernel(metric=67**2)
k2 = 2.4**2 * kernels.ExpSquaredKernel(90**2) * kernels.ExpSine2Kernel(
gamma=2 / 1.3**2, log_period=0.0)
k3 = 0.66**2 * kernels.RationalQuadraticKernel(log_alpha=np.log(0.78),
metric=1.2**2)
k4 = 0.18**2 * kernels.ExpSquaredKernel(1.6**2)
kernel = k1 + k2 + k3 + k4
gp = george.GP(kernel,
mean=np.mean(y),
fit_mean=True,
white_noise=np.log(0.19**2),
fit_white_noise=True)
gp.compute(t)
print(gp.log_likelihood(y))
print(gp.grad_log_likelihood(y))
import scipy.optimize as op
import logging import george from george import kernels fig, ax = plt.subplots() plt.subplots_adjust(left=0.25, bottom=0.40) x = np.linspace(0.0, 1.0, 100) k1, k2 = (1e-3, 3.35) k3 = 0 #kernel = k1 * kernels.ExpKernel(np.exp(k2)) #kernel = k1 * kernels.LinearKernel(log_gamma2=k2, order=3) #kernel = k1 * kernels.ExpSquaredKernel(metric=k2) kernel = k1 * kernels.RationalQuadraticKernel(log_alpha=k2, metric=1) gp = george.GP(kernel, fit_white_noise=False) # white_noise=k3, # fit_white_noise=True # ) gp.compute(x) l, = ax.plot(x, gp.sample(), c="tab:blue") l2, = ax.plot(x, gp.sample(), c="tab:blue", alpha=0.6) l3, = ax.plot(x, gp.sample(), c="tab:blue", alpha=0.3) axcolor = 'lightgoldenrodyellow' ax_k1 = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor) ax_k2 = plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor)
param_bounds = [
(0, None),
(-100, 100),
(-0.5, 0.5),
(0, None)
]
get_omega = get_omega_arctan
init_params = np.array([50, 90, -0.25, mean_omega_init])
else:
kernel = 10 * kernels.RationalQuadraticKernel(log_alpha=1, metric=1)
gp = george.GP(
kernel,
mean=mean_omega_init,
fit_mean=True
)
gp.freeze_parameter("kernel:k2:metric:log_M_0_0")
gp.compute(r)
def get_omega(params):
gp.set_parameter_vector(params)
return gp.sample()
init_params = gp.get_parameter_vector()
# Plot the data.
fig = pl.figure(figsize=(6, 3.5))
ax = fig.add_subplot(111)
ax.plot(t, y, ".k", ms=2)
ax.set_xlim(min(t), 1999)
ax.set_ylim(min(y), 369)
ax.set_xlabel("year")
ax.set_ylabel("CO$_2$ in ppm")
fig.subplots_adjust(left=0.15, bottom=0.2, right=0.99, top=0.95)
fig.savefig("../_static/hyper/data.png", dpi=150)
# Initialize the kernel.
k1 = 66.0**2 * kernels.ExpSquaredKernel(67.0**2)
k2 = 2.4**2 * kernels.ExpSquaredKernel(90**2) \
* kernels.ExpSine2Kernel(2.0 / 1.3**2, 1.0)
k3 = 0.66**2 * kernels.RationalQuadraticKernel(0.78, 1.2**2)
k4 = 0.18**2 * kernels.ExpSquaredKernel(1.6**2) + kernels.WhiteKernel(0.19)
kernel = k1 + k2 + k3 + k4
# Set up the Gaussian process and maximize the marginalized likelihood.
gp = george.GP(kernel, mean=np.mean(y))
# Define the objective function (negative log-likelihood in this case).
def nll(p):
# Update the kernel parameters and compute the likelihood.
gp.kernel[:] = p
ll = gp.lnlikelihood(y, quiet=True)
# The scipy optimizer doesn't play well with infinities.
return -ll if np.isfinite(ll) else 1e25
import george
from george import kernels
from celerite import terms
__all__ = ["george_kernels", "george_solvers",
"celerite_terms",
"setup_george_kernel", "setup_celerite_terms"]
george_kernels = {
"Exp2": kernels.ExpSquaredKernel(10**2),
"Exp2ESin2": (kernels.ExpSquaredKernel(10**2) *
kernels.ExpSine2Kernel(2 / 1.3**2, 1.0)),
"ESin2": kernels.ExpSine2Kernel(2 / 1.3**2, 1.0),
"27dESin2": kernels.ExpSine2Kernel(2 / 1.3**2, 27.0 / 365.25),
"RatQ": kernels.RationalQuadraticKernel(0.8, 0.1**2),
"Mat32": kernels.Matern32Kernel((0.5)**2),
"Exp": kernels.ExpKernel((0.5)**2),
# "W": kernels.WhiteKernel, # deprecated, delegated to `white_noise`
"B": kernels.ConstantKernel,
}
george_solvers = {
"basic": george.BasicSolver,
"HODLR": george.HODLRSolver,
}
celerite_terms = {
"N": terms.Term(),
"B": terms.RealTerm(log_a=-6., log_c=-np.inf,
bounds={"log_a": [-30, 30],
"log_c": [-np.inf, np.inf]}),
def predict_Q_data(input_dir_2, filename4="training.txt"):
nu, lam_squared, stokesQ, stokesU = read_data(input_dir_2, filename4)
nu_R = nu
stokesQ_R = stokesQ
lam_R = lam_squared
# Squared exponential kernel
k1 = 0.3**2 * kernels.ExpSquaredKernel(0.02**2)
# periodic covariance kernel with exponential component toallow decay away from periodicity
k2 = 0.6**2 * kernels.ExpSquaredKernel(0.5**2) * kernels.ExpSine2Kernel(
gamma=2 / 2.5**2, log_period=0.0)
###vary gamma value to widen the funnel
# rational quadratic kernel for medium term irregularities.
k3 = 0.3**2 * kernels.RationalQuadraticKernel(log_alpha=np.log(0.1),
metric=0.1**2)
# noise kernel: includes correlated noise & uncorrelated noise
k4 = 0.18**2 * kernels.ExpSquaredKernel(1.6**2)
kernel = k1 + k2 #+k3 + k4
gp = george.GP(kernel,
mean=np.mean(stokesQ),
fit_mean=True,
white_noise=np.log(0.02**2),
fit_white_noise=True)
#gp = george.GP(kernel)
gp.compute(lam_R)
# range of times for prediction:
x = np.linspace(np.min(lam_squared) - 0.01, np.max(lam_squared),
1024) #extend to smaller wavelengths
# calculate expectation and variance at each point:
mu_initial, cov = gp.predict(stokesQ_R, x)
#mu, cov = gp.predict(stokesQ_2Gz, x, return_var = True)
std_initial = np.sqrt(np.diag(cov))
print("Initial prediction of missing Q values: \n {}".format(mu_initial))
# Define the objective function (negative log-likelihood in this case).
def nll(p):
gp.set_parameter_vector(p)
ll = gp.log_likelihood(stokesQ_R, quiet=True)
return -ll if np.isfinite(ll) else 1e25
# And the gradient of the objective function.
def grad_nll(p):
gp.set_parameter_vector(p)
return -gp.grad_log_likelihood(stokesQ_R, quiet=True)
gp.compute(lam_R)
p0 = gp.get_parameter_vector()
results = op.minimize(nll, p0, jac=grad_nll, method="L-BFGS-B")
# run optimization:
#results = op.minimize(nll, p0, jac=grad_nll)
gp.set_parameter_vector(results.x)
x = np.linspace(np.min(lam_squared) - 0.01, np.max(lam_squared),
1024) #extend to smaller wavelengths
mu_optimized, cov = gp.predict(stokesQ_R, x)
std_optimized = np.sqrt(np.diag(cov))
print("Final prediction of missing Q values: \n {}".format(mu_optimized))
return nu_R, lam_R, stokesQ_R, mu_initial, std_initial, mu_optimized, std_optimized
plt.xlabel('time [day]')
plt.show()
#==============================================================================
# GP
#==============================================================================
from george import kernels
k1 = 10 * kernels.ExpSquaredKernel(metric=10**2)
# k2 = 1**2 * kernels.ExpSquaredKernel(90**2) * kernels.ExpSine2Kernel(gamma=1, log_period=1.9)
k2 = 20 * kernels.ExpSquaredKernel(200**2) * kernels.ExpSine2Kernel(
gamma=2,
log_period=np.log(17),
bounds=dict(gamma=(-3, 30), log_period=(np.log(17 - 5), np.log(17 + 5))))
k3 = 20 * kernels.RationalQuadraticKernel(log_alpha=np.log(100), metric=120**2)
k4 = 10 * kernels.ExpSquaredKernel(1000**2)
# kernel = k1 + k2 + k3 + k4
kernel = k3 + k2 + k4
import george
#gp = george.GP(kernel, mean=np.mean(y), fit_mean=True,
# white_noise=np.log(0.19**2), fit_white_noise=True)
gp = george.GP(kernel, mean=np.mean(y), fit_mean=True)
gp.compute(t, yerr)
#==============================================================================
# Optimization
#==============================================================================
if 0:
def main():
k1 = 66.0**2 * kernels.ExpSquaredKernel(67.0**2)
k2 = 2.4**2 * kernels.ExpSquaredKernel(90**2) * kernels.ExpSine2Kernel(
2.0 / 1.3**2, 1.0)
k3 = 0.66**2 * kernels.RationalQuadraticKernel(0.78, 1.2**2)
k4 = 0.18**2 * kernels.ExpSquaredKernel(1.6**2) + kernels.WhiteKernel(0.19)
kernel = k2 + k4 #k1 + k2 + k3 + k4
gp = george.GP(kernel)
indata = np.loadtxt(
'/Users/lapguest/newbol/bol_ni_ej/out_files/err_bivar_regress.txt',
usecols=(5, 6, 1, 2),
skiprows=1)
def nll(p):
# Update the kernel parameters and compute the likelihood.
gp.kernel[:] = p
ll = gp.lnlikelihood(indata[:, 2], quiet=True)
# The scipy optimizer doesn't play well with infinities.
return -ll if np.isfinite(ll) else 1e25
# And the gradient of the objective function.
def grad_nll(p):
# Update the kernel parameters and compute the likelihood.
gp.kernel[:] = p
return -gp.grad_lnlikelihood(indata[:, 2], quiet=True)
#ph=lc['MJD']-tbmax
#condition for second maximum
##TODO: GUI for selecting region
#cond=(ph>=10.0) & (ph<=40.0)
#define the data in the region of interest
print "Fitting with george"
#print max(mag)
# Pre-compute the factorization of the matrix.
gp.compute(indata[:, 0], indata[:, 2])
#print gp.lnlikelihood(mag), gp.grad_lnlikelihood(mag)
gp.compute(indata[:, 0], indata[:, 2])
if sys.argv[1] == 'mle':
p0 = gp.kernel.vector
results = op.minimize(nll, p0, jac=grad_nll)
gp.kernel[:] = results.x
print gp.kernel.value
t2 = indata[:, 0]
t = np.linspace(t2.min(), t2.max(), 100)
mu, cov = gp.predict(indata[:, 1], t)
print gp.predict(indata[:, 1], 31.99)[0]
std = np.sqrt(np.diag(cov))
plt.plot(t2, indata[:, 2], 'bo')
plt.plot(t, mu, 'r:', linewidth=3)
plt.fill_between(t, mu - std, mu + std, alpha=0.3)
plt.show()
