def test_chained_lsqfit_p0(self): " MultiFitter.chained_lsqfit(...) " # sequential fit fitter = MultiFitter(models=self.make_models(ncg=1)) p0 = gv.BufferDict({'a': 0.9991638707908023, 'b': 0.4995927960301173}) p0list = [ p0, gv.BufferDict(a=0.9991638707908023), gv.BufferDict(a=0.9991638707908023) ] fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior, p0=p0) self.assertTrue(self.agree_ref(fit1.p)) self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2']) self.assertEqual(fit1.p0, p0list) fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior, p0=3 * [p0]) self.assertTrue(self.agree_ref(fit1.p)) self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2']) self.assertEqual(fit1.p0, p0list) fn = 'test_multifitter.p' fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior, p0=fn) fit2 = fitter.chained_lsqfit(data=self.data, prior=self.prior, p0=fn) self.assertTrue(self.agree_ref(fit1.p)) self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2']) self.assertEqual([f.pmean for f in fit1.chained_fits.values()], fit2.p0) os.unlink(fn)
def __call__(self, y0, interval): if len(interval) > 2: ans = [] xlast = interval[0] ylast = y0 nbad = 0 ngood = 0 for x in interval[1:]: y = self(ylast, interval=(xlast,x)) xlast = x ylast = y nbad += self.nbad ngood += self.ngood ans.append(y) self.nbad = nbad self.ngood = ngood return ans if not isinstance(y0, gvar.BufferDict): y0 = gvar.BufferDict(y0) deriv_orig = self.deriv def deriv(x, y): y = gvar.BufferDict(y0, buf=y) dydx = gvar.BufferDict(deriv_orig(x, y), keys=y0.keys()) return dydx.buf self.deriv = deriv ans = super(DictIntegrator, self).__call__(y0.buf, interval) self.deriv = deriv_orig return gvar.BufferDict(y0, buf=ans)
def test_nopdf(self): " integrator(f ... nopdf=True) and pdf(p) " xarray = gv.gvar([5., 3.], [[4., 1.9], [1.9, 1.]]) xdict = gv.BufferDict([(0, 1), (1, 1)]) xdict = gv.BufferDict(xdict, buf=xarray) pdf = PDFIntegrator(xarray).pdf def farray(x): if hasattr(x, 'keys'): x = x.buf prob = pdf(x) return [x[0] * prob, x[0]**2 * prob, prob] def fdict(x): if hasattr(x, 'keys'): x = x.buf prob = pdf(x) return gv.BufferDict([(0, x[0] * prob), (1, x[0]**2 * prob), (3, prob)]) for x in [xarray, xdict]: x[0] -= 0.1 * x[0].sdev x[1] += 0.1 * x[1].sdev for f in [farray, fdict]: integ = PDFIntegrator(x) integ(f, neval=1000, nitn=5) r = integ(f, neval=1000, nitn=5, nopdf=True, adapt=False) rmean = r[0] rsdev = np.sqrt(r[1] - rmean**2) self.assertTrue(abs(rmean.mean - 5.) < 5. * rmean.sdev) self.assertTrue(abs(rsdev.mean - 2.) < 5. * rsdev.sdev)
def main(): x, y = make_data() # collect fit data p0 = None # make larger fits go faster (opt.) for nexp in range(1, 7): print('************************************* nexp =', nexp) prior = make_prior(nexp) fit = lsqfit.nonlinear_fit(data=(x, y), fcn=fcn, prior=prior, p0=p0) print(fit) # print the fit results if nexp > 2: E = fit.p['E'] # best-fit parameters a = fit.p['a'] print('E1/E0 =', E[1] / E[0], ' E2/E0 =', E[2] / E[0]) print('a1/a0 =', a[1] / a[0], ' a2/a0 =', a[2] / a[0]) if fit.chi2 / fit.dof < 1.: p0 = fit.pmean # starting point for next fit (opt.) print() # error budget analysis # outputs = { # 'E1/E0':E[1]/E[0], 'E2/E0':E[2]/E[0], # 'a1/a0':a[1]/a[0], 'a2/a0':a[2]/a[0] # } # inputs = {'E':fit.prior['E'], 'a':fit.prior['a'], 'y':y} outputs = gv.BufferDict() outputs['E2/E0'] = E[2] / E[0] outputs['E1/E0'] = E[1] / E[0] outputs['a2/a0'] = a[2] / a[0] outputs['a1/a0'] = a[1] / a[0] inputs = gv.BufferDict() inputs['a'] = fit.prior['a'] inputs['y'] = y inputs['E'] = fit.prior['E'] print('================= Error Budget Analysis') print(gv.fmt_values(outputs)) print(gv.fmt_errorbudget(outputs, inputs))
def test_expval(self): " integrator(f ...) " xarray = gv.gvar([5., 3.], [[400., 0.9], [0.9, 1.]]) xdict = gv.BufferDict([(0, 1), (1, 1)]) xdict = gv.BufferDict(xdict, buf=xarray) xscalar = xarray[0] def fscalar(x): if hasattr(x, 'keys'): x = x.buf return x.flat[0] def farray(x): if hasattr(x, 'keys'): x = x.buf return gv.PDFStatistics.moments(x.flat[0]) def fdict(x): if hasattr(x, 'keys'): x = x.buf return gv.BufferDict([(0, x.flat[0]), (1, x.flat[0]**2), (2, x.flat[0]**3), (3, x.flat[0]**4)]) for x in [xscalar, xarray, xdict]: integ = PDFIntegrator(x) integ(neval=1000, nitn=5) for f in [fscalar, farray, fdict]: r = integ(f, neval=1000, nitn=5, adapt=False) if f is fscalar: self.assertTrue(abs(r.mean - 5) < 5. * r.sdev) else: if hasattr(r, 'keys'): r = r.buf s = gv.PDFStatistics(r) self.assertTrue(abs(s.mean.mean - 5.) < 10. * s.mean.sdev) self.assertTrue(abs(s.sdev.mean - 20.) < 10. * s.sdev.sdev) self.assertTrue(abs(s.skew.mean) < 10. * s.skew.sdev) self.assertTrue(abs(s.ex_kurt.mean) < 10. * s.ex_kurt.sdev) # covariance test # N.B. Integrand has two entries that are identical, # which leads to a singular covariance -- so SVD # is essential here. The off-diagonal elements # of np.outer(x, x) are what cause the singularity. def fcov(x): return dict(x=x, xx=np.outer(x, x)) integ = PDFIntegrator(xarray) r = integ(fcov, neval=1000, nitn=5) rmean = r['x'] rcov = r['xx'] - np.outer(r['x'], r['x']) xmean = gv.mean(xarray) xcov = gv.evalcov(xarray) for i in [0, 1]: self.assertTrue(abs(rmean[i].mean - xmean[i]) < 5. * rmean[i].sdev) for j in [0, 1]: self.assertTrue( abs(rcov[i, j].mean - xcov[i, j]) < 5. * rcov[i, j].sdev)
def test_expval(self): " integrator(f ...) " xarray = gv.gvar([5., 3.], [[4., 0.9], [0.9, 1.]]) xdict = gv.BufferDict([(0, 1), (1, 1)]) xdict = gv.BufferDict(xdict, buf=xarray) xscalar = xarray[0] def fscalar(x): if hasattr(x, 'keys'): x = x.buf return x.flat[0] def farray(x): if hasattr(x, 'keys'): x = x.buf return gv.PDFStatistics.moments(x.flat[0]) def fdict(x): if hasattr(x, 'keys'): x = x.buf return gv.BufferDict([(0, x.flat[0]), (1, x.flat[0]**2), (2, x.flat[0]**3), (3, x.flat[0]**4)]) for x in [xscalar, xarray, xdict]: integ = PDFIntegrator(x) integ(neval=1000, nitn=5) for f in [fscalar, farray, fdict]: r = integ(f, neval=1000, nitn=5, adapt=False) if f is fscalar: self.assertTrue(abs(r.mean - 5) < 5. * r.sdev) else: if hasattr(r, 'keys'): r = r.buf s = gv.PDFStatistics(r) self.assertTrue(abs(s.mean.mean - 5.) < 10. * s.mean.sdev) self.assertTrue(abs(s.sdev.mean - 2.) < 10. * s.sdev.sdev) self.assertTrue(abs(s.skew.mean) < 10. * s.skew.sdev) self.assertTrue(abs(s.ex_kurt.mean) < 10. * s.ex_kurt.sdev) # covariance test def fcov(x): return dict(x=x, xx=np.outer(x, x)) integ = PDFIntegrator(xarray) r = integ(fcov, neval=1000, nitn=5) rmean = r['x'] rcov = r['xx'] - np.outer(r['x'], r['x']) xmean = gv.mean(xarray) xcov = gv.evalcov(xarray) for i in [0, 1]: self.assertTrue(abs(rmean[i].mean - xmean[i]) < 5. * rmean[i].sdev) for j in [0, 1]: self.assertTrue( abs(rcov[i, j].mean - xcov[i, j]) < 5. * rcov[i, j].sdev)
def ff(theta, nopdf=nopdf): tan_theta = numpy.tan(theta) x = self.scale * tan_theta jac = self.scale * (tan_theta**2 + 1.) if nopdf: pdf = jac * self.pdf.pjac[None, :] else: pdf = jac * numpy.exp(-(x**2) / 2.) / numpy.sqrt(2 * numpy.pi) dp = self.pdf.x2dpflat(x) parg = None ans = None fparg_is_dict = False # iterate through the batch for i, (dpi, pdfi) in enumerate(zip(dp, pdf)): p = self.pdf.meanflat + dpi if parg is None: # first time only if self.pdf.shape is None: parg = _gvar.BufferDict(self.pdf.g, buf=p) else: parg = p.reshape(self.pdf.shape) else: if parg.shape is None: parg.buf = p else: parg.flat[:] = p fparg = 1. if f is None else f(parg) if ans is None: # first time only if hasattr(fparg, 'keys'): fparg_is_dict = True if not isinstance(fparg, _gvar.BufferDict): fparg = _gvar.BufferDict(fparg) ans = _gvar.BufferDict() for k in fparg: ans[k] = numpy.empty( (len(pdf), ) + fparg.slice_shape(k)[1], float) else: if numpy.shape(fparg) == (): ans = numpy.empty(len(pdf), float) else: ans = numpy.empty( (len(pdf), ) + numpy.shape(fparg), float) if fparg_is_dict: prod_pdfi = numpy.prod(pdfi) for k in ans: ans[k][i] = fparg[k] ans[k][i] *= prod_pdfi else: if not isinstance(fparg, numpy.ndarray): fparg = numpy.asarray(fparg) ans[i] = fparg * numpy.prod(pdfi) return ans
def main(): x, y = make_data() prior = make_prior(100) # 100 exponential terms in all p0 = None for nexp in range(1, 6): # marginalize the last 100 - nexp terms (in ymod_prior) fit_prior = gv.BufferDict() # part of prior used in fit ymod_prior = gv.BufferDict() # part of prior absorbed in ymod for k in prior: fit_prior[k] = prior[k][:nexp] ymod_prior[k] = prior[k][nexp:] ymod = y - fcn(x, ymod_prior) # remove temrs in ymod_prior # fit modified data with just nexp terms (in fit_prior) fit = lsqfit.nonlinear_fit( data=(x, ymod), prior=fit_prior, fcn=fcn, p0=p0, tol=1e-15, svdcut=1e-4, ) # print fit information print('************************************* nexp =', nexp) print(fit.format(True)) p0 = fit.pmean # print summary information and error budget E = fit.p['E'] # best-fit parameters a = fit.p['a'] # outputs = { # 'E1/E0':E[1] / E[0], 'E2/E0':E[2] / E[0], # 'a1/a0':a[1] / a[0], 'a2/a0':a[2] / a[0] # } # inputs = { # 'E prior':prior['E'], 'a prior':prior['a'], # 'svd cut':fit.svdcorrection, # } outputs = gv.BufferDict() outputs['E2/E0'] = E[2] / E[0] outputs['E1/E0'] = E[1] / E[0] outputs['a2/a0'] = a[2] / a[0] outputs['a1/a0'] = a[1] / a[0] inputs = gv.BufferDict() inputs['E prior'] = prior['E'] inputs['svd cut'] = fit.svdcorrection inputs['a prior'] = prior['a'] print(fit.fmt_values(outputs)) print(fit.fmt_errorbudget(outputs, inputs))
def test_buildprior(self): " MultiFitter.buildprior " prior = gv.BufferDict(self.prior) prior['dummy'] = gv.gvar('12(12)') fitter = MultiFitter(models=self.make_models(ncg=1)) prior = fitter.buildprior(prior=prior) self.assertEqual(str(prior), str(self.prior))
def _make_empbayes_fit(self, empbayes_grouping='order'): if (self._empbayes_fit is None) or (empbayes_grouping != self.empbayes_grouping): self.empbayes_grouping = empbayes_grouping self._counter = {'iters': 0, 'evals': 0} z0 = gv.BufferDict() for group in self._empbayes_groupings(): z0[group] = 1.0 # Might need to change minargs default values for empbayes_fit to converge: # tol=1e-8, svdcut=1e-12, debug=False, maxit=1000, add_svdnoise=False, add_priornoise=False # Note: maxit != maxfev. See https://github.com/scipy/scipy/issues/3334 # For Nelder-Mead algorithm, maxfev < maxit < 3 maxfev? # For debugging. Same as 'callback': # https://github.com/scipy/scipy/blob/c0dc7fccc53d8a8569cde5d55673fca284bca191/scipy/optimize/optimize.py#L651 def analyzer(arg): self._counter['evals'] += 1 print("\nEvals: ", self._counter['evals'], arg, "\n") print(type(arg[0])) return None fit, z = lsqfit.empbayes_fit(z0, fitargs=self._make_fitargs, maxit=200, analyzer=None) print(z) self._empbayes_fit = fit return self._empbayes_fit
def key_parameters(p): """ collect key fit parameters in dictionary """ ans = gv.BufferDict() for k in ['etas:a', 'etas:dE', 'Ds:a', 'Ds:dE']: ans[k] = p[k][0] ans['Vnn'] = p['Vnn'][0, 0] return ans
def test_chained_lsqfit(self): " MultiFitter.chained_lsqfit(models=[m1, m2, m3], ...) " # sequential fit fitter = MultiFitter(models=self.make_models(ncg=1)) fit1 = fitter.chained_lsqfit(data=self.data, prior=self.prior) self.assertEqual(str(fit1.p), "{'a': 0.99929(48),'b': 0.50004(81)}") self.assertEqual(list(fit1.chained_fits.keys()), ['l', 'c1', 'c2']) # with coarse grain, marginalization and extend, and with fast=False prior = gv.BufferDict([ ('log(a)', gv.log(self.prior['a'])), ('b', self.prior['b']), ]) prior['log(aa)'] = prior['log(a)'] + gv.gvar('0(1)') * 1e-6 fitter = MultiFitter(models=self.make_models(ncg=2), fast=False) fit2 = fitter.chained_lsqfit(data=self.data, prior=prior, mopt=True, extend=True) self.assertEqual( str(fit2.p), "{'log(a)': -0.00073(48),'b': 0.50015(82)," "'log(aa)': -0.00073(48),'a': 0.99927(48)," "'aa': 0.99927(48)}", )
def fdict(x): if hasattr(x, 'keys'): x = x.buf return gv.BufferDict([ (0, x.flat[0]), (1, x.flat[0] ** 2), (2, x.flat[0] ** 3), (3, x.flat[0] ** 4) ])
def test_buildprior_fast(self): " MultiFitter.buildprior with fast=False " prior = gv.BufferDict(self.prior) prior['dummy'] = gv.gvar('12(12)') fitter = MultiFitter(models=self.make_models(ncg=1), fast=False) newprior = fitter.buildprior(prior=prior) self.assertEqual(str(prior), str(newprior))
def build_prior(nexp): prior = gv.BufferDict() prior.add('log(a1:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(a1:vec:s)'][0] = log(gv.gvar(0.5, 1)) prior.add('log(ao:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(ao:vec:s)'][0] = log(gv.gvar(0.5, 1)) #prior.add('as1:etac',[gv.gvar(0.001,0.01) for i in range(nexp)]) prior.add('log(dE:vec:s)', [log(gv.gvar(2, 2)) for i in range(nexp)]) prior['log(dE:vec:s)'][0] = log(gv.gvar(1, 1)) prior.add('log(dEo:vec:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(dEo:vec:s)'][0] = log(gv.gvar(1, 1)) #prior['logdE:etac'][0] = log(gv.gvar(0.1,0.05)) prior.add('log(a1:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(a1:vec:qed:s)'][0] = log(gv.gvar(0.5, 1)) prior.add('log(ao:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(ao:vec:qed:s)'][0] = log(gv.gvar(0.5, 1)) #prior.add('as1:etac',[gv.gvar(0.001,0.01) for i in range(nexp)]) prior.add('log(dE:vec:qed:s)', [log(gv.gvar(2, 2)) for i in range(nexp)]) prior['log(dE:vec:qed:s)'][0] = log(gv.gvar(1, 1)) prior.add('log(dEo:vec:qed:s)', [log(gv.gvar(1, 1)) for i in range(nexp)]) prior['log(dEo:vec:qed:s)'][0] = log(gv.gvar(1, 1)) return prior
def gv_data(self): gv_data = {} for ens in sorted(self.bs_data): gv_data[ens] = gv.BufferDict() for param in ['mO', 'mpi', 'mk', 'Fpi']: gv_data[ens][param] = self.bs_data[ens][param][1:] gv_data[ens] = gv.dataset.avg_data(gv_data[ens], bstrap=True) for param in ['mO', 'mpi', 'mk', 'Fpi']: gv_data[ens][param] = gv_data[ens][param] - gv.mean(gv_data[ens][param]) + self.bs_data[ens][param][0] gv_data[ens]['a/w'] = self.bs_data[ens]['a/w'] gv_data[ens]['t/a^2'] = self.bs_data[ens]['t/a^2'] gv_data[ens]['a/w:orig'] = self.bs_data[ens]['a/w:orig'] gv_data[ens]['a/w:impr'] = self.bs_data[ens]['a/w:impr'] gv_data[ens]['t/a^2:orig'] = self.bs_data[ens]['t/a^2:orig'] gv_data[ens]['t/a^2:impr'] = self.bs_data[ens]['t/a^2:impr'] gv_data[ens]['L'] = gv.gvar(self.bs_data[ens]['L'], self.bs_data[ens]['L'] / 10**6) gv_data[ens]['alpha_s'] = gv.gvar(self.bs_data[ens]['alpha_s'], self.bs_data[ens]['alpha_s'] / 10**6) return gv_data
def test_flat(): hp = gvar.BufferDict({'log(sdev)': gvar.log(gvar.gvar(1, 1))}) x = np.linspace(0, 5, 10) def gpfactory1(hp): gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2) gp.addx(x, 'x') return gp def gpfactory2(hp): gp = lgp.GP(lgp.ExpQuad() * jnp.exp(hp[0])**2) gp.addx(x, 'x') return gp def gpfactory3(hp): gp = lgp.GP(lgp.ExpQuad() * jnp.exp(hp)**2) gp.addx(x, 'x') return gp truehp = gvar.sample(hp) truegp = gpfactory1(truehp) trueprior = truegp.prior() data = gvar.sample(trueprior) fit1 = lgp.empbayes_fit(hp, gpfactory1, data) fit2 = lgp.empbayes_fit(hp.buf, gpfactory2, data) fit3 = lgp.empbayes_fit(hp.buf[0], gpfactory3, data) util.assert_similar_gvars(fit1.p.buf[0], fit2.p[0], fit3.p)
def params(self): """ Read in fit results. """ p = gv.BufferDict() dir_str = "./results/" pmean = np.loadtxt(dir_str + "pmean.txt") p0mean = np.loadtxt(dir_str + "p0mean.txt") pcorr = np.loadtxt(dir_str + "corr.txt") pcov = np.loadtxt(dir_str + "cov.txt") # print pmean, p0mean pmean = np.append(pmean, p0mean) #print pmean #print pcov #print pcorr D = np.sqrt(np.diag(np.diag(pcov))) DInv = np.linalg.inv(D) correlationMat = np.matmul(DInv, np.matmul(pcov,DInv)) #print correlationMat - pcorr x = gv.gvar(pmean, pcov) p['b'] = x[:4] p['b0'] = x[4:] #print gv.evalcov(p) #print pcov return p
def flat(g): """convert dictionary or array to 1D array""" if hasattr(g, 'buf'): return g.buf elif hasattr(g, 'keys'): return gvar.BufferDict(g).buf else: return np.reshape(g, -1)
def test_cov(g): if hasattr(g, 'keys'): g = gvar.BufferDict(g) g = g.flat[:] cov = np.zeros((len(g), len(g)), dtype=float) for idx, bcov in ef.evalcov_blocks(g): cov[idx[:, None], idx] = bcov assert str(gvar.evalcov(g)) == str(cov)
def make_prior_all_twostate(): prior = gv.BufferDict() prior["log(Mg1)"] = gv.log(gv.gvar(0.24, 0.2)) prior["log(Mg2)"] = gv.log(gv.gvar(0.4, 0.2)) prior["Zg1"] = gv.gvar(1, 1) prior["Zg2"] = gv.gvar(1, 1) return prior
def test_buildprior_marginalized(self): " MultiFitter.buildprior with marginalization" prior = gv.BufferDict(self.prior) prior['dummy'] = gv.gvar('12(12)') fitter = MultiFitter(models=self.make_models(ncg=1), mopt=True) prior = fitter.buildprior(prior=prior, mopt=fitter.mopt) del self.prior['b'] self.assertEqual(str(prior), str(self.prior))
def make_prior(): prior = gv.BufferDict(c=gv.gvar(['0(5)', '0(5)'])) if LSQFIT_ONLY: return prior if MULTI_W: prior['erfinv(2w-1)'] = gv.gvar(19 * ['0(1)']) / 2**0.5 else: prior['erfinv(2w-1)'] = gv.gvar('0(1)') / 2**0.5 return prior
def test_extend(self): " MultiFitter.lsqfit(..., extend=True) " fitter = MultiFitter(models=self.make_models(ncg=1)) prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])), ('b', self.prior['b'])]) fit5 = fitter.lsqfit(data=self.data, prior=prior, extend=True) self.assertEqual(str(fit5.p['a']), str(self.ref_fit.p['a'])) self.assertEqual(gv.fmt_chi2(fit5), gv.fmt_chi2(self.ref_fit)) self.assertTrue('log(a)' in fit5.p)
def make_prior(): prior = gv.BufferDict(c=gv.gvar(['0(5)', '0(5)'])) if LSQFIT_ONLY: return prior if MULTI_W: prior['unif(w)'] = gv.BufferDict.uniform('unif', 0., 1., shape=19) else: prior['unif(w)'] = gv.BufferDict.uniform('unif', 0., 1.) return prior
def optimize_prior(self, empbayes_grouping='order'): prior = {} for observable in ['w0', 't0']: temp_prior = self.fitter[observable]._make_empbayes_fit( empbayes_grouping).prior prior[observable] = gv.BufferDict() for key in self.fit_keys[observable]: prior[observable][key] = temp_prior[key] return prior
def test_extend(self): " MultiFitter.lsqfit(...) " fitter = MultiFitter(models=self.make_models(ncg=1)) prior = gv.BufferDict([('log(a)', gv.log(self.prior['a'])), ('b', self.prior['b'])]) fit5 = fitter.lsqfit(data=self.data, prior=prior) self.assertTrue(self.agree_ref(fit5.p)) self.assertTrue( abs(fit5.chi2 - self.ref_fit.chi2) / 0.1 / self.ref_fit.chi2) self.assertTrue('log(a)' in fit5.p)
def test_copy(self): global b,bkeys,bvalues,bslices,bbuf b = gv.BufferDict(b, buf=b.buf * gv.gvar('2(1)')) c = copy.copy(b) self.assertTrue(gv.equivalent(b, c)) c['vector'] *= -1 self.assertEqual(c['vector'].tolist(), (-b['vector']).tolist()) c = copy.deepcopy(b) self.assertTrue(gv.equivalent(b, c)) c['vector'] *= -1 self.assertEqual(c['vector'].tolist(), (-b['vector']).tolist())
def test_data(): hp = gvar.BufferDict({'log(sdev)': gvar.log(gvar.gvar(1, 1))}) x = np.linspace(0, 5, 10) def gpfactory(hp): gp = lgp.GP(lgp.ExpQuad() * hp['sdev']**2) gp.addx(x, 'x') return gp truehp = gvar.sample(hp) truegp = gpfactory(truehp) trueprior = truegp.prior() def makeerr(bd, err): return gvar.BufferDict(bd, buf=np.full_like(bd.buf, err)) data_noerr = gvar.sample(trueprior) error = makeerr(data_noerr, 0.1) zeroerror = makeerr(data_noerr, 0) zerocov = gvar.evalcov(gvar.gvar(data_noerr, zeroerror)) data_err = gvar.make_fake_data(gvar.gvar(data_noerr, error)) datas = [ [ data_noerr, gvar.gvar(data_noerr), (data_noerr, ), (data_noerr, zerocov), lambda _: data_noerr, lambda _: gvar.gvar(data_noerr), lambda _: (data_noerr, ), lambda _: (data_noerr, zerocov), ], [ data_err, (data_err, ), (gvar.mean(data_err), gvar.evalcov(data_err)), lambda _: data_err, lambda _: (data_err, ), lambda _: (gvar.mean(data_err), gvar.evalcov(data_err)), ], ] for datasets in datas: fits = [] for data in datasets: fit = lgp.empbayes_fit(hp, gpfactory, data) fits.append(fit) p = fits[0].minresult.x for fit in fits[1:]: np.testing.assert_allclose(fit.minresult.x, p, atol=1e-6)
def buildprior(self, prior, mopt=None, extend=False): nprior = gv.BufferDict() if mopt is None: for k in [self.a, self.b]: k = gv.dictkey(prior, k) nprior[k] = prior[k] else: k = gv.dictkey(prior, self.a) nprior[k] = prior[k] self.mopt = mopt # use self.mopt to marginalize fitfcn return nprior