Пример #1
0
    def test_lnpost(self):
        data = (self.xvals, self.yvals, self.evals)
        f = _parallel_likelihood_calculator(gauss,
                                            data_tuple=data)
        lnprob = f(self.params)

        def lnpost(pars, generative, y, e):
            resid = y - generative
            resid /= e
            resid *= resid
            resid += np.log(2 * np.pi * e**2)
            return -0.5 * np.sum(resid)

        g = _parallel_likelihood_calculator(gauss,
                                            data_tuple=data,
                                            lnpost=lnpost)
        lnprob2 = g(self.params)

        assert_equal(lnprob2, lnprob)

        pars_copy = deepcopy(self.params)

        f = CurveFitter(gauss,
                        data,
                        self.params)
        res = f.emcee(steps=10, burn=0, thin=1, seed=1)

        g = CurveFitter(gauss,
                        data,
                        pars_copy,
                        lnpost=lnpost)
        res2 = g.emcee(steps=10, burn=0, thin=1, seed=1)
        assert_almost_equal(values(res.params), values(res2.params))
Пример #2
0
    def test_emcee_vs_lm(self):
        # test mcmc output vs lm
        if not HAS_EMCEE:
            return True

        f = CurveFitter(gauss, self.xvals, self.yvals, self.params,
                        edata=self.evals)
        np.random.seed(123456)

        # start = time.time()
        out = f.emcee(nwalkers=100, steps=300, burn=100, thin=10)
        # finish = time.time()
        # print(finish - start)

        within_sigma(self.best_weighted, out.params)

        # test mcmc output vs lm, some parameters not bounded
        self.params['p1'].max = None
        f = CurveFitter(gauss, self.xvals, self.yvals, self.params,
                        edata=self.evals)
        np.random.seed(123456)
        f.emcee(nwalkers=100, steps=300, burn=100, thin=5)
        within_sigma(self.best_weighted, out.params)

        # test mcmc output vs lm, some parameters not bounded
        self.params['p1'].min = None
        f = CurveFitter(gauss, self.xvals, self.yvals, self.params,
                        edata=self.evals)
        f.emcee(nwalkers=100, steps=300, burn=100, thin=5)
        within_sigma(self.best_weighted, out.params)
Пример #3
0
    def test_reflectivity_emcee(self):
        transform = reflect.Transform('logY')
        yt, et = transform.transform(self.qvals361,
                                     self.rvals361,
                                     self.evals361)

        kws = {'transform': transform.transform}
        fitfunc = RFF(transform=transform.transform, dq=5.)

        fitter = CurveFitter(fitfunc,
                             (self.qvals361, yt, et),
                             self.params361,
                             fcn_kws=kws)
        res = fitter.fit()
        res_em = fitter.emcee(steps=10)
Пример #4
0
    def test_emcee_vs_lm(self):
        # test mcmc output vs lm
        f = CurveFitter(gauss,
                        (self.xvals, self.yvals, self.evals),
                        self.params)
        np.random.seed(123456)

        out = f.emcee(nwalkers=100, steps=500, burn=250, thin=20)
        within_sigma(self.best_weighted, out.params)
        # test if the sigmas are similar as well (within 20 %)
        errs = np.array([out.params[par].stderr for par in out.params])
        assert_allclose(errs, self.best_weighted_errors, rtol=0.2)

        # now try with resampling MC
        out = f._resample_mc(500, params=self.params, method='leastsq')
        within_sigma(self.best_weighted, out.params)
        # test if the sigmas are similar as well (within 20 %)
        errs = np.array([out.params[par].stderr for par in out.params])
        assert_allclose(errs, self.best_weighted_errors, rtol=0.2)

        # test mcmc output vs lm, some parameters not bounded
        self.params['p1'].max = np.inf
        f = CurveFitter(gauss,
                        (self.xvals, self.yvals, self.evals),
                        self.params)
        np.random.seed(123456)
        f.emcee(nwalkers=100, steps=300, burn=100, thin=5)
        within_sigma(self.best_weighted, out.params)

        # test mcmc output vs lm, some parameters not bounded
        self.params['p1'].min = -np.inf
        f = CurveFitter(gauss,
                        (self.xvals, self.yvals, self.evals),
                        self.params)
        f.emcee(nwalkers=100, steps=300, burn=100, thin=5)
        within_sigma(self.best_weighted, out.params)
Пример #5
0
    def test_reflectivity_emcee(self):
        transform = reflect.Transform('logY')
        yt, et = transform.transform(self.qvals361,
                                     self.rvals361,
                                     self.evals361)

        kws = {'transform': transform.transform}
        fitfunc = RFF(transform=transform.transform, dq=5.)

        fitter = CurveFitter(fitfunc,
                             (self.qvals361, yt, et),
                             self.params361,
                             fcn_kws=kws)
        res = fitter.fit()
        res_em = fitter.emcee(steps=10, seed=1)
        assert_allclose(values(res.params), values(res_em.params), rtol=1e-2)