def test_grad_log_likelihood(kernel, seed=42, eps=1.34e-7): np.random.seed(seed) x = np.sort(np.random.rand(100)) yerr = np.random.uniform(0.1, 0.5, len(x)) y = np.sin(x) if not terms.HAS_AUTOGRAD: gp = GP(kernel) gp.compute(x, yerr) with pytest.raises(ImportError): _, grad = gp.grad_log_likelihood(y) return for fit_mean in [True, False]: gp = GP(kernel, fit_mean=fit_mean) gp.compute(x, yerr) _, grad = gp.grad_log_likelihood(y) grad0 = np.empty_like(grad) v = gp.get_parameter_vector() for i, pval in enumerate(v): v[i] = pval + eps gp.set_parameter_vector(v) ll = gp.log_likelihood(y) v[i] = pval - eps gp.set_parameter_vector(v) ll -= gp.log_likelihood(y) grad0[i] = 0.5 * ll / eps v[i] = pval assert np.allclose(grad, grad0)
class GPModel(object): def __init__( self, x, y, n_bg_coef, wave_err=0.05, # MAGIC NUMBER: wavelength error hack log_sigma0=0., log_rho0=np.log(10.), # initial params for GP x_shift=None): self.x = np.array(x) self.y = np.array(y) if n_bg_coef >= 2: a_kw = dict([('a{}'.format(i), 0.) for i in range(2, n_bg_coef)]) # estimate background a_kw['a1'] = (y[-1] - y[0]) / (x[-1] - x[0]) # slope a_kw['a0'] = y[-1] - a_kw['a1'] * x[-1] # estimate constant term else: a_kw = dict(a0=np.mean([y[0], y[-1]])) # initialize model self.mean_model = MeanModel(n_bg_coef=n_bg_coef, **a_kw) self.kernel = terms.Matern32Term(log_sigma=log_sigma0, log_rho=log_rho0) # set up the gp self.gp = GP(self.kernel, mean=self.mean_model, fit_mean=True) self.gp.compute(x, yerr=wave_err) logger.log( 0, "Initial log-likelihood: {0}".format(self.gp.log_likelihood(y))) if x_shift is None: self.x_shift = 0. else: self.x_shift = x_shift def neg_ln_like(self, params): # minimize -log(likelihood) self.gp.set_parameter_vector(params) ll = self.gp.log_likelihood(self.y) if np.isnan(ll): return np.inf return -ll def __call__(self, params): return self.neg_ln_like(params)
def test_nyquist_singularity(method, seed=4220): np.random.seed(seed) kernel = terms.ComplexTerm(1.0, np.log(1e-6), np.log(1.0)) gp = GP(kernel, method=method) # Samples are very close to Nyquist with f = 1.0 ts = np.array([0.0, 0.5, 1.0, 1.5]) ts[1] = ts[1] + 1e-9 * np.random.randn() ts[2] = ts[2] + 1e-8 * np.random.randn() ts[3] = ts[3] + 1e-7 * np.random.randn() yerr = np.random.uniform(low=0.1, high=0.2, size=len(ts)) y = np.random.randn(len(ts)) gp.compute(ts, yerr) llgp = gp.log_likelihood(y) K = gp.get_matrix(ts) K[np.diag_indices_from(K)] += yerr**2.0 ll = (-0.5 * np.dot(y, np.linalg.solve(K, y)) - 0.5 * np.linalg.slogdet(K)[1] - 0.5 * len(y) * np.log(2.0 * np.pi)) assert np.allclose(ll, llgp)
def test_grad_log_likelihood(kernel, with_general, seed=42, eps=1.34e-7): np.random.seed(seed) x = np.sort(np.random.rand(100)) yerr = np.random.uniform(0.1, 0.5, len(x)) y = np.sin(x) if with_general: U = np.vander(x - np.mean(x), 4).T V = U * np.random.rand(4)[:, None] A = np.sum(U * V, axis=0) + 1e-8 else: A = np.empty(0) U = np.empty((0, 0)) V = np.empty((0, 0)) if not terms.HAS_AUTOGRAD: gp = GP(kernel) gp.compute(x, yerr, A=A, U=U, V=V) with pytest.raises(ImportError): _, grad = gp.grad_log_likelihood(y) return for fit_mean in [True, False]: gp = GP(kernel, fit_mean=fit_mean) gp.compute(x, yerr, A=A, U=U, V=V) _, grad = gp.grad_log_likelihood(y) grad0 = np.empty_like(grad) v = gp.get_parameter_vector() for i, pval in enumerate(v): v[i] = pval + eps gp.set_parameter_vector(v) ll = gp.log_likelihood(y) v[i] = pval - eps gp.set_parameter_vector(v) ll -= gp.log_likelihood(y) grad0[i] = 0.5 * ll / eps v[i] = pval assert np.allclose(grad, grad0)
def test_pickle(with_general, seed=42): solver = celerite.CholeskySolver() np.random.seed(seed) t = np.sort(np.random.rand(500)) diag = np.random.uniform(0.1, 0.5, len(t)) y = np.sin(t) if with_general: U = np.vander(t - np.mean(t), 4).T V = U * np.random.rand(4)[:, None] A = np.sum(U * V, axis=0) + 1e-8 else: A = np.empty(0) U = np.empty((0, 0)) V = np.empty((0, 0)) alpha_real = np.array([1.3, 1.5]) beta_real = np.array([0.5, 0.2]) alpha_complex_real = np.array([1.0]) alpha_complex_imag = np.array([0.1]) beta_complex_real = np.array([1.0]) beta_complex_imag = np.array([1.0]) def compare(solver1, solver2): assert solver1.computed() == solver2.computed() if not solver1.computed(): return assert np.allclose(solver1.log_determinant(), solver2.log_determinant()) assert np.allclose(solver1.dot_solve(y), solver2.dot_solve(y)) s = pickle.dumps(solver, -1) solver2 = pickle.loads(s) compare(solver, solver2) solver.compute(0.0, alpha_real, beta_real, alpha_complex_real, alpha_complex_imag, beta_complex_real, beta_complex_imag, A, U, V, t, diag) solver2 = pickle.loads(pickle.dumps(solver, -1)) compare(solver, solver2) # Test that models can be pickled too. kernel = terms.RealTerm(0.5, 0.1) kernel += terms.ComplexTerm(0.6, 0.7, 1.0) gp1 = GP(kernel) gp1.compute(t, diag) s = pickle.dumps(gp1, -1) gp2 = pickle.loads(s) assert np.allclose(gp1.log_likelihood(y), gp2.log_likelihood(y))
def test_log_likelihood(method, seed=42): np.random.seed(seed) x = np.sort(np.random.rand(10)) yerr = np.random.uniform(0.1, 0.5, len(x)) y = np.sin(x) kernel = terms.RealTerm(0.1, 0.5) gp = GP(kernel, method=method) with pytest.raises(RuntimeError): gp.log_likelihood(y) for term in [(0.6, 0.7, 1.0)]: kernel += terms.ComplexTerm(*term) gp = GP(kernel, method=method) assert gp.computed is False with pytest.raises(ValueError): gp.compute(np.random.rand(len(x)), yerr) gp.compute(x, yerr) assert gp.computed is True assert gp.dirty is False ll = gp.log_likelihood(y) K = gp.get_matrix(include_diagonal=True) ll0 = -0.5 * np.dot(y, np.linalg.solve(K, y)) ll0 -= 0.5 * np.linalg.slogdet(K)[1] ll0 -= 0.5 * len(x) * np.log(2*np.pi) assert np.allclose(ll, ll0) # Check that changing the parameters "un-computes" the likelihood. gp.set_parameter_vector(gp.get_parameter_vector()) assert gp.dirty is True assert gp.computed is False # Check that changing the parameters changes the likelihood. gp.compute(x, yerr) ll1 = gp.log_likelihood(y) params = gp.get_parameter_vector() params[0] += 0.1 gp.set_parameter_vector(params) gp.compute(x, yerr) ll2 = gp.log_likelihood(y) assert not np.allclose(ll1, ll2) gp[1] += 0.1 assert gp.dirty is True gp.compute(x, yerr) ll3 = gp.log_likelihood(y) assert not np.allclose(ll2, ll3)
def test_pickle(method, seed=42): solver = get_solver(method) np.random.seed(seed) t = np.sort(np.random.rand(500)) diag = np.random.uniform(0.1, 0.5, len(t)) y = np.sin(t) alpha_real = np.array([1.3, 1.5]) beta_real = np.array([0.5, 0.2]) alpha_complex_real = np.array([1.0]) alpha_complex_imag = np.array([0.1]) beta_complex_real = np.array([1.0]) beta_complex_imag = np.array([1.0]) def compare(solver1, solver2): assert solver1.computed() == solver2.computed() if not solver1.computed(): return assert np.allclose(solver1.log_determinant(), solver2.log_determinant()) assert np.allclose(solver1.dot_solve(y), solver2.dot_solve(y)) s = pickle.dumps(solver, -1) solver2 = pickle.loads(s) compare(solver, solver2) if method != "sparse": solver.compute( alpha_real, beta_real, alpha_complex_real, alpha_complex_imag, beta_complex_real, beta_complex_imag, t, diag ) solver2 = pickle.loads(pickle.dumps(solver, -1)) compare(solver, solver2) # Test that models can be pickled too. kernel = terms.RealTerm(0.5, 0.1) kernel += terms.ComplexTerm(0.6, 0.7, 1.0) gp1 = GP(kernel, method=method) gp1.compute(t, diag) s = pickle.dumps(gp1, -1) gp2 = pickle.loads(s) assert np.allclose(gp1.log_likelihood(y), gp2.log_likelihood(y))
class LineFitter(object): def __init__(self, x, flux, ivar=None, absorp_emiss=None, n_bg_coef=2, target_x=None): """ Parameters ---------- x : array_like Dispersion parameter. Usually either pixel or wavelength. flux : array_like Flux array. ivar : array_like Inverse-variance array. absorp_emiss : numeric [-1, 1] (optional) If -1, absorption line. If +1, emission line. If not specified, will try to guess. n_bg_coef : int (optional) The order of the polynomial used to fit the background. 1 = constant, 2 = linear, 3 = quadratic, etc. target_x : numeric (optional) Where we think the line of interest is. """ self.x = np.array(x) self.flux = np.array(flux) if ivar is not None: self.ivar = np.array(ivar) self._err = 1 / np.sqrt(self.ivar) else: self.ivar = np.ones_like(flux) self._err = None if absorp_emiss is None: raise NotImplementedError( "You must supply an absorp_emiss for now") self.absorp_emiss = float(absorp_emiss) self.target_x = target_x self.n_bg_coef = int(n_bg_coef) # result of fitting self.gp = None self.success = None @classmethod def transform_pars(cls, p): new_p = OrderedDict() for k, v in p.items(): if k in cls._log_pars: k = 'ln_{0}'.format(k) v = np.log(v) new_p[k] = v return new_p def get_init_generic(self, amp=None, x0=None, bg=None, bg_buffer=None): """ Get initial guesses for the generic line parameters. Parameters ---------- amp : numeric Line amplitude. This should be strictly positive; the ``absorp_emiss`` parameter controls whether it is absorption or emission. x0 : numeric Line centroid. bg : iterable Background polynomial coefficients. bg_buffer : int The number of values to use on either end of the flux array to estimate the background parameters. """ target_x = self.target_x if x0 is None: # estimate the initial guess for the centroid relmins = argrelmin(-self.absorp_emiss * self.flux)[0] if len(relmins) > 1 and target_x is None: logger.log( 0, "no target_x specified - taking largest line " "in spec region") target_x = self.x[np.argmin(-self.absorp_emiss * self.flux)] if len(relmins) == 1: x0 = self.x[relmins[0]] else: x0_idx = relmins[np.abs(self.x[relmins] - target_x).argmin()] x0 = self.x[x0_idx] # shift x array so that line is approximately at 0 _x = np.array(self.x, copy=True) x = np.array(_x) - x0 # background polynomial parameters if bg_buffer is None: bg_buffer = len(x) // 4 bg_buffer = max(1, bg_buffer) if bg is None: if self.n_bg_coef < 2: bg = np.array([0.]) bg[0] = np.median(self.flux) else: # estimate linear background model bg = np.array([0.] * self.n_bg_coef) i1 = argmedian(self.flux[:bg_buffer]) i2 = argmedian(self.flux[-bg_buffer:]) f1 = self.flux[:bg_buffer][i1] f2 = self.flux[-bg_buffer:][i2] x1 = x[:bg_buffer][i1] x2 = x[-bg_buffer:][i2] bg[1] = (f2 - f1) / (x2 - x1) # slope bg[0] = f2 - bg[1] * x2 # estimate constant term else: if len(bg) != self.n_bg_coef: raise ValueError('Number of bg polynomial coefficients does ' 'not match n_bg_coef specified when fitter ' 'was created.') if amp is None: # then estimate the initial guess for amplitude _i = np.argmin(np.abs(x)) if len(bg) > 1: _bg = bg[0] + bg[1] * x[_i] else: _bg = bg[0] # amp = np.sqrt(2*np.pi) * (flux[_i] - bg) amp = self.flux[_i] - _bg p0 = OrderedDict() p0['amp'] = np.abs(amp) p0['x0'] = x0 p0['bg_coef'] = bg return p0 def get_init_gp(self, log_sigma=None, log_rho=None, x0=None): """ Set up the GP kernel parameters. """ if log_sigma is None: if x0 is not None: # better initial guess for GP parameters mask = np.abs(self.x - x0) > 2. y_MAD = np.median( np.abs(self.flux[mask] - np.median(self.flux[mask]))) else: y_MAD = np.median(np.abs(self.flux - np.median(self.flux))) log_sigma = np.log(3 * y_MAD) if log_rho is None: log_rho = np.log(5.) p0 = OrderedDict() p0['log_sigma'] = log_sigma p0['log_rho'] = log_rho return p0 def init_gp(self, log_sigma=None, log_rho=None, amp=None, x0=None, bg=None, bg_buffer=None, **kwargs): """ **kwargs: """ # Call the different get_init methods with the correct kwargs passed sig = inspect.signature(self.get_init) kw = OrderedDict() for k in list(sig.parameters.keys()): kw[k] = kwargs.pop(k, None) p0 = self.get_init(**kw) # Call the generic init method - all line models must have these params p0_generic = self.get_init_generic(amp=amp, x0=x0, bg=bg, bg_buffer=bg_buffer) for k, v in p0_generic.items(): p0[k] = v # expand bg parameters bgs = p0.pop('bg_coef') for i in range(self.n_bg_coef): p0['bg{}'.format(i)] = bgs[i] # transform p0 = self.transform_pars(p0) # initialize model mean_model = self.MeanModel(n_bg_coef=self.n_bg_coef, absorp_emiss=self.absorp_emiss, **p0) p0_gp = self.get_init_gp(log_sigma=log_sigma, log_rho=log_rho) kernel = terms.Matern32Term(log_sigma=p0_gp['log_sigma'], log_rho=p0_gp['log_rho']) # set up the gp model self.gp = GP(kernel, mean=mean_model, fit_mean=True) if self._err is not None: self.gp.compute(self.x, self._err) else: self.gp.compute(self.x) init_params = self.gp.get_parameter_vector() init_ll = self.gp.log_likelihood(self.flux) logger.log(0, "Initial log-likelihood: {0}".format(init_ll)) return init_params def get_gp_mean_pars(self): """ Return a parameter dictionary for the mean model parameters only. """ fit_pars = OrderedDict() for k, v in self.gp.get_parameter_dict().items(): if 'mean' not in k: continue k = k[5:] # remove 'mean:' if k.startswith('ln'): if 'amp' in k: fit_pars[k[3:]] = self.absorp_emiss * np.exp(v) else: fit_pars[k[3:]] = np.exp(v) elif k.startswith('bg'): if 'bg_coef' not in fit_pars: fit_pars['bg_coef'] = [] fit_pars['bg_coef'].append(v) else: fit_pars[k] = v return fit_pars def _neg_log_like(self, params): self.gp.set_parameter_vector(params) try: ll = self.gp.log_likelihood(self.flux) except (RuntimeError, LinAlgError): return np.inf if np.isnan(ll): return np.inf return -ll def fit(self, bounds=None, **kwargs): """ """ init_params = self.init_gp() if bounds is None: bounds = OrderedDict() # default bounds for mean model parameters i = self.gp.models['mean'].get_parameter_names().index('x0') mean_bounds = self.gp.models['mean'].get_parameter_bounds() if mean_bounds[i][0] is None and mean_bounds[i][1] is None: mean_bounds[i] = (min(self.x), max(self.x)) for i, k in enumerate(self.gp.models['mean'].parameter_names): mean_bounds[i] = bounds.get(k, mean_bounds[i]) self.gp.models['mean'].parameter_bounds = mean_bounds # HACK: default bounds for kernel parameters self.gp.models['kernel'].parameter_bounds = [(None, None), (np.log(0.5), None)] soln = minimize(self._neg_log_like, init_params, method="L-BFGS-B", bounds=self.gp.get_parameter_bounds()) self.success = soln.success self.gp.set_parameter_vector(soln.x) if self.success: logger.debug("Success: {0}, Final log-likelihood: {1}".format( soln.success, -soln.fun)) else: logger.warning("Fit failed! Final log-likelihood: {0}, " "Final parameters: {1}".format(-soln.fun, soln.x)) return self def plot_fit(self, axes=None, fit_alpha=0.5): unbinned_color = '#3182bd' binned_color = '#2ca25f' gp_color = '#ff7f0e' noise_color = '#de2d26' if self.gp is None: raise ValueError("You must run .fit() first!") # ---------------------------------------------------------------------- # Plot the maximum likelihood model if axes is None: fig, axes = plt.subplots(1, 3, figsize=(15, 5), sharex=True) # data for ax in axes[:2]: ax.plot(self.x, self.flux, drawstyle='steps-mid', marker='', color='#777777', zorder=2) if self._err is not None: ax.errorbar(self.x, self.flux, self._err, marker='', ls='none', ecolor='#666666', zorder=1) # mean model wave_grid = np.linspace(self.x.min(), self.x.max(), 256) mu, var = self.gp.predict(self.flux, self.x, return_var=True) std = np.sqrt(var) axes[0].plot(wave_grid, self.gp.mean.get_unbinned_value(wave_grid), marker='', alpha=fit_alpha, zorder=10, color=unbinned_color) axes[0].plot(self.x, self.gp.mean.get_value(self.x), marker='', alpha=fit_alpha, zorder=10, drawstyle='steps-mid', color=binned_color) # full GP model axes[1].plot(self.x, mu, color=gp_color, drawstyle='steps-mid', marker='', alpha=fit_alpha, zorder=10) axes[1].fill_between(self.x, mu + std, mu - std, color=gp_color, alpha=fit_alpha / 10., edgecolor="none", step='mid') # just GP noise component mean_model = self.gp.mean.get_value(self.x) axes[2].plot(self.x, mu - mean_model, marker='', alpha=fit_alpha, zorder=10, drawstyle='steps-mid', color=noise_color) axes[2].plot(self.x, self.flux - mean_model, drawstyle='steps-mid', marker='', color='#777777', zorder=2) if self._err is not None: axes[2].errorbar(self.x, self.flux - mean_model, self._err, marker='', ls='none', ecolor='#666666', zorder=1) axes[0].set_ylabel('flux') axes[0].set_xlim(self.x.min(), self.x.max()) axes[0].set_title('Line model') axes[1].set_title('Line + noise model') axes[2].set_title('Noise model') fig = axes[0].figure fig.tight_layout() return fig
class CeleriteLogLikelihood: def __init__(self, lpf, name: str = 'gp', noise_ids=None, fixed_hps=None): if not with_celerite: raise ImportError("CeleriteLogLikelihood requires celerite.") self.name = name self.lpf = lpf if fixed_hps is None: self.free = True else: self.hps = asarray(fixed_hps) self.free = False if lpf.lcids is None: raise ValueError( 'The LPF data needs to be initialised before initialising CeleriteLogLikelihood.' ) self.noise_ids = noise_ids if noise_ids is not None else unique( lpf.noise_ids) self.mask = m = zeros(lpf.lcids.size, bool) for lcid, nid in enumerate(lpf.noise_ids): if nid in self.noise_ids: m[lcid == lpf.lcids] = 1 if m.sum() == lpf.lcids.size: self.times = lpf.timea self.fluxes = lpf.ofluxa else: self.times = lpf.timea[m] self.fluxes = lpf.ofluxa[m] self.gp = GP(Matern32Term(0, 0)) if self.free: self.init_parameters() else: self.compute_gp(None, force=True, hps=self.hps) def init_parameters(self): name = self.name wns = log10(mad_std(diff(self.fluxes)) / sqrt(2)) pgp = [ LParameter(f'{name}_ln_out', f'{name} ln output scale', '', NP(-6, 1.5), bounds=(-inf, inf)), LParameter(f'{name}_ln_in', f'{name} ln input scale', '', UP(-8, 8), bounds=(-inf, inf)), LParameter(f'{name}_log10_wn', f'{name} log10 white noise sigma', '', NP(wns, 0.025), bounds=(-inf, inf)) ] self.lpf.ps.thaw() self.lpf.ps.add_global_block(self.name, pgp) self.lpf.ps.freeze() self.pv_slice = self.lpf.ps.blocks[-1].slice self.pv_start = self.lpf.ps.blocks[-1].start setattr(self.lpf, f"_sl_{name}", self.pv_slice) setattr(self.lpf, f"_start_{name}", self.pv_start) def compute_gp(self, pv, force: bool = False, hps=None): if self.free or force: parameters = pv[self.pv_slice] if hps is None else hps self.gp.set_parameter_vector(parameters[:-1]) self.gp.compute(self.times, yerr=10**parameters[-1]) def compute_gp_lnlikelihood(self, pv, model): self.compute_gp(pv) return self.gp.log_likelihood(self.fluxes - model[self.mask]) def predict_baseline(self, pv): self.compute_gp(pv) residuals = self.fluxes - squeeze( self.lpf.transit_model(pv))[self.mask] bl = zeros_like(self.lpf.timea) bl[self.mask] = self.gp.predict(residuals, self.times, return_cov=False) return 1. + bl def __call__(self, pvp, model): if pvp.ndim == 1: lnlike = self.compute_gp_lnlikelihood(pvp, model) else: lnlike = zeros(pvp.shape[0]) for ipv, pv in enumerate(pvp): if all(isfinite(model[ipv])): lnlike[ipv] = self.compute_gp_lnlikelihood(pv, model[ipv]) else: lnlike[ipv] = -inf return lnlike
def test_log_likelihood(seed=42): np.random.seed(seed) x = np.sort(np.random.rand(10)) yerr = np.random.uniform(0.1, 0.5, len(x)) y = np.sin(x) kernel = terms.RealTerm(0.1, 0.5) gp = GP(kernel) with pytest.raises(RuntimeError): gp.log_likelihood(y) termlist = [(0.1 + 10./j, 0.5 + 10./j) for j in range(1, 4)] termlist += [(1.0 + 10./j, 0.01 + 10./j, 0.5, 0.01) for j in range(1, 10)] termlist += [(0.6, 0.7, 1.0), (0.3, 0.05, 0.5, 0.6)] for term in termlist: if len(term) > 2: kernel += terms.ComplexTerm(*term) else: kernel += terms.RealTerm(*term) gp = GP(kernel) assert gp.computed is False with pytest.raises(ValueError): gp.compute(np.random.rand(len(x)), yerr) gp.compute(x, yerr) assert gp.computed is True assert gp.dirty is False ll = gp.log_likelihood(y) K = gp.get_matrix(include_diagonal=True) ll0 = -0.5 * np.dot(y, np.linalg.solve(K, y)) ll0 -= 0.5 * np.linalg.slogdet(K)[1] ll0 -= 0.5 * len(x) * np.log(2*np.pi) assert np.allclose(ll, ll0) # Check that changing the parameters "un-computes" the likelihood. gp.set_parameter_vector(gp.get_parameter_vector()) assert gp.dirty is True assert gp.computed is False # Check that changing the parameters changes the likelihood. gp.compute(x, yerr) ll1 = gp.log_likelihood(y) params = gp.get_parameter_vector() params[0] += 10.0 gp.set_parameter_vector(params) gp.compute(x, yerr) ll2 = gp.log_likelihood(y) assert not np.allclose(ll1, ll2) gp[1] += 10.0 assert gp.dirty is True gp.compute(x, yerr) ll3 = gp.log_likelihood(y) assert not np.allclose(ll2, ll3) # Test zero delta t ind = len(x) // 2 x = np.concatenate((x[:ind], [x[ind]], x[ind:])) y = np.concatenate((y[:ind], [y[ind]], y[ind:])) yerr = np.concatenate((yerr[:ind], [yerr[ind]], yerr[ind:])) gp.compute(x, yerr) ll = gp.log_likelihood(y) K = gp.get_matrix(include_diagonal=True) ll0 = -0.5 * np.dot(y, np.linalg.solve(K, y)) ll0 -= 0.5 * np.linalg.slogdet(K)[1] ll0 -= 0.5 * len(x) * np.log(2*np.pi) assert np.allclose(ll, ll0), "face"
def test_log_likelihood(with_general, seed=42): np.random.seed(seed) x = np.sort(np.random.rand(10)) yerr = np.random.uniform(0.1, 0.5, len(x)) y = np.sin(x) if with_general: U = np.vander(x - np.mean(x), 4).T V = U * np.random.rand(4)[:, None] A = np.sum(U * V, axis=0) + 1e-8 else: A = np.empty(0) U = np.empty((0, 0)) V = np.empty((0, 0)) # Check quiet argument with a non-positive definite kernel. class NPDTerm(terms.Term): parameter_names = ("par1", ) def get_real_coefficients(self, params): # NOQA return [params[0]], [0.1] gp = GP(NPDTerm(-1.0)) with pytest.raises(celerite.solver.LinAlgError): gp.compute(x, 0.0) with pytest.raises(celerite.solver.LinAlgError): gp.log_likelihood(y) assert np.isinf(gp.log_likelihood(y, quiet=True)) if terms.HAS_AUTOGRAD: assert np.isinf(gp.grad_log_likelihood(y, quiet=True)[0]) kernel = terms.RealTerm(0.1, 0.5) gp = GP(kernel) with pytest.raises(RuntimeError): gp.log_likelihood(y) termlist = [(0.1 + 10. / j, 0.5 + 10. / j) for j in range(1, 4)] termlist += [(1.0 + 10. / j, 0.01 + 10. / j, 0.5, 0.01) for j in range(1, 10)] termlist += [(0.6, 0.7, 1.0), (0.3, 0.05, 0.5, 0.6)] for term in termlist: if len(term) > 2: kernel += terms.ComplexTerm(*term) else: kernel += terms.RealTerm(*term) gp = GP(kernel) assert gp.computed is False with pytest.raises(ValueError): gp.compute(np.random.rand(len(x)), yerr) gp.compute(x, yerr, A=A, U=U, V=V) assert gp.computed is True assert gp.dirty is False ll = gp.log_likelihood(y) K = gp.get_matrix(include_diagonal=True) ll0 = -0.5 * np.dot(y, np.linalg.solve(K, y)) ll0 -= 0.5 * np.linalg.slogdet(K)[1] ll0 -= 0.5 * len(x) * np.log(2 * np.pi) assert np.allclose(ll, ll0) # Check that changing the parameters "un-computes" the likelihood. gp.set_parameter_vector(gp.get_parameter_vector()) assert gp.dirty is True assert gp.computed is False # Check that changing the parameters changes the likelihood. gp.compute(x, yerr, A=A, U=U, V=V) ll1 = gp.log_likelihood(y) params = gp.get_parameter_vector() params[0] += 10.0 gp.set_parameter_vector(params) gp.compute(x, yerr, A=A, U=U, V=V) ll2 = gp.log_likelihood(y) assert not np.allclose(ll1, ll2) gp[1] += 10.0 assert gp.dirty is True gp.compute(x, yerr, A=A, U=U, V=V) ll3 = gp.log_likelihood(y) assert not np.allclose(ll2, ll3) # Test zero delta t ind = len(x) // 2 x = np.concatenate((x[:ind], [x[ind]], x[ind:])) y = np.concatenate((y[:ind], [y[ind]], y[ind:])) yerr = np.concatenate((yerr[:ind], [yerr[ind]], yerr[ind:])) gp.compute(x, yerr) ll = gp.log_likelihood(y) K = gp.get_matrix(include_diagonal=True) ll0 = -0.5 * np.dot(y, np.linalg.solve(K, y)) ll0 -= 0.5 * np.linalg.slogdet(K)[1] ll0 -= 0.5 * len(x) * np.log(2 * np.pi) assert np.allclose(ll, ll0)