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_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 __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 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