def test_constraints(self):
# constraints should work during fitting
self.p[0].value = 5.4
self.p[1].constraint = -0.203 * self.p[0]
assert_equal(self.p[1].value, self.p[0].value * -0.203)
res = self.mcfitter.fit()
assert_(res.success)
assert_equal(len(self.objective.varying_parameters()), 1)
# lnsigma is parameters[0]
assert_(self.p[0] is self.objective.parameters.flattened()[0])
assert_(self.p[1] is self.objective.parameters.flattened()[1])
assert_almost_equal(self.p[0].value, res.x[0])
assert_almost_equal(self.p[1].value, self.p[0].value * -0.203)
# check that constraints work during sampling
# the CurveFitter has to be set up again if you change how the
# parameters are being fitted.
mcfitter = CurveFitter(self.objective)
assert_(mcfitter.nvary == 1)
mcfitter.sample(5)
assert_equal(self.p[1].value, self.p[0].value * -0.203)
# the constrained parameters should have a chain
assert_(self.p[0].chain is not None)
assert_(self.p[1].chain is not None)
assert_allclose(self.p[1].chain, self.p[0].chain * -0.203)
def test_mcmc_pt(self):
# smoke test for parallel tempering
x = np.array(self.objective.parameters)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
assert_equal(mcfitter.sampler.ntemps, 10)
assert len(list(flatten(self.objective.parameters))) == 2
# check that the parallel sampling works
# and that chain shape is correct
res = mcfitter.sample(steps=5, nthin=2, verbose=False, pool=-1)
assert_equal(mcfitter.chain.shape, (5, 10, 50, 2))
assert_equal(res[0].chain.shape, (5, 50))
assert_equal(mcfitter.chain[:, 0, :, 0], res[0].chain)
assert_equal(mcfitter.chain[:, 0, :, 1], res[1].chain)
chain = np.copy(mcfitter.chain)
assert len(list(flatten(self.objective.parameters))) == 2
# the sampler should store the probability
assert_equal(mcfitter.logpost.shape, (5, 10, 50))
assert_allclose(mcfitter.logpost, mcfitter.sampler._ptchain.logP)
logprobs = mcfitter.logpost
highest_prob_loc = np.argmax(logprobs[:, 0])
idx = np.unravel_index(highest_prob_loc, logprobs[:, 0].shape)
idx = list(idx)
idx.insert(1, 0)
idx = tuple(idx)
assert_equal(idx, mcfitter.index_max_prob)
pvals = mcfitter.chain[idx]
assert_allclose(logprobs[idx], self.objective.logpost(pvals))
# try resetting the chain
mcfitter.reset()
# test for reproducible operation
self.objective.setp(x)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
mcfitter.initialise("jitter", random_state=1)
mcfitter.sample(steps=5, nthin=2, verbose=False, random_state=2)
chain = np.copy(mcfitter.chain)
self.objective.setp(x)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
mcfitter.initialise("jitter", random_state=1)
mcfitter.sample(steps=5, nthin=2, verbose=False, random_state=2)
chain2 = np.copy(mcfitter.chain)
assert_allclose(chain2, chain)
def test_mcmc_init(self):
# smoke test for sampler initialisation
# TODO check that the initialisation worked.
# reproducible initialisation with random_state dependents
self.mcfitter.initialise("prior", random_state=1)
starting_pos = np.copy(self.mcfitter._state.coords)
self.mcfitter.initialise("prior", random_state=1)
starting_pos2 = self.mcfitter._state.coords
assert_equal(starting_pos, starting_pos2)
self.mcfitter.initialise("jitter", random_state=1)
starting_pos = np.copy(self.mcfitter._state.coords)
self.mcfitter.initialise("jitter", random_state=1)
starting_pos2 = self.mcfitter._state.coords
assert_equal(starting_pos, starting_pos2)
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise("covar")
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise("prior")
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise("jitter")
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=chain)
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise(chain)
# initialise for Parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=20, nwalkers=100)
mcfitter.initialise("covar")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise("prior")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise("jitter")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=np.copy(chain))
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100, ntemps=20)
mcfitter.initialise(chain)
def test_mcmc(self):
self.mcfitter.sample(steps=50, nthin=1, verbose=False)
assert_equal(self.mcfitter.nvary, 2)
# smoke test for corner plot
self.mcfitter.objective.corner()
# we're not doing Parallel Tempering here.
assert_(self.mcfitter._ntemps == -1)
assert_(isinstance(self.mcfitter.sampler, emcee.EnsembleSampler))
# should be able to multithread
mcfitter = CurveFitter(self.objective, nwalkers=50)
res = mcfitter.sample(steps=33, nthin=2, verbose=False, pool=2)
# check that the autocorrelation function at least runs
acfs = mcfitter.acf(nburn=10)
assert_equal(acfs.shape[-1], mcfitter.nvary)
# check chain shape
assert_equal(mcfitter.chain.shape, (33, 50, 2))
# assert_equal(mcfitter._lastpos, mcfitter.chain[:, -1, :])
assert_equal(res[0].chain.shape, (33, 50))
# if the number of parameters changes there should be an Exception
# raised
from pytest import raises
with raises(RuntimeError):
self.p[0].vary = False
self.mcfitter.sample(1)
# can fix by making the sampler again
self.mcfitter.make_sampler()
self.mcfitter.sample(1)
class curvefitter(Benchmark):
repeat = 3
def setup(self):
# Reproducible results!
np.random.seed(123)
m_true = -0.9594
b_true = 4.294
f_true = 0.534
m_ls = -1.1040757010910947
b_ls = 5.4405552502319505
# Generate some synthetic data from the model.
N = 50
x = np.sort(10 * np.random.rand(N))
y_err = 0.1 + 0.5 * np.random.rand(N)
y = m_true * x + b_true
y += np.abs(f_true * y) * np.random.randn(N)
y += y_err * np.random.randn(N)
data = Data1D(data=(x, y, y_err))
p = Parameter(b_ls, 'b', vary=True, bounds=(-100, 100))
p |= Parameter(m_ls, 'm', vary=True, bounds=(-100, 100))
model = Model(p, fitfunc=line)
self.objective = Objective(model, data)
self.mcfitter = CurveFitter(self.objective)
self.mcfitter_t = CurveFitter(self.objective, ntemps=20)
self.mcfitter.initialise('prior')
self.mcfitter_t.initialise('prior')
def time_sampler(self):
# to get an idea of how fast the actual sampling is.
# i.e. the overhead of objective.lnprob, objective.lnprior, etc
self.mcfitter.sampler.run_mcmc(self.mcfitter._state, 100)
def time_sampler_pool(self):
# see how the multiprocessing in curvefitter performs
# automatically use all the cores available
self.mcfitter_t.sample(20, pool=-1)
def test_best_weighted(self):
assert_equal(len(self.objective.varying_parameters()), 4)
self.objective.setp(self.p0)
f = CurveFitter(self.objective, nwalkers=100)
res = f.fit('least_squares', jac='3-point')
output = res.x
assert_almost_equal(output, self.best_weighted, 3)
assert_almost_equal(self.objective.chisqr(),
self.best_weighted_chisqr, 5)
# compare the residuals
res = (self.data.y - self.model(self.data.x)) / self.data.y_err
assert_equal(self.objective.residuals(), res)
# compare objective.covar to the best_weighted_errors
uncertainties = [param.stderr for param in self.params]
assert_allclose(uncertainties, self.best_weighted_errors, rtol=0.005)
# we're also going to try the checkpointing here.
checkpoint = os.path.join(self.tmpdir, 'checkpoint.txt')
# compare samples to best_weighted_errors
np.random.seed(1)
f.sample(steps=101, random_state=1, verbose=False, f=checkpoint)
process_chain(self.objective, f.chain, nburn=50, nthin=10)
uncertainties = [param.stderr for param in self.params]
assert_allclose(uncertainties, self.best_weighted_errors, rtol=0.07)
# test that the checkpoint worked
check_array = np.loadtxt(checkpoint)
check_array = check_array.reshape(101, f._nwalkers, f.nvary)
assert_allclose(check_array, f.chain)
# test loading the checkpoint
chain = load_chain(checkpoint)
assert_allclose(chain, f.chain)
f.initialise('jitter')
f.sample(steps=2, nthin=4, f=checkpoint, verbose=False)
assert_equal(f.chain.shape[0], 2)
def test_best_weighted(self):
assert_equal(len(self.objective.varying_parameters()), 4)
self.objective.setp(self.p0)
f = CurveFitter(self.objective, nwalkers=100)
res = f.fit('least_squares', jac='3-point')
output = res.x
assert_almost_equal(output, self.best_weighted, 3)
assert_almost_equal(self.objective.chisqr(), self.best_weighted_chisqr,
5)
# compare the residuals
res = (self.data.y - self.model(self.data.x)) / self.data.y_err
assert_equal(self.objective.residuals(), res)
# compare objective.covar to the best_weighted_errors
uncertainties = [param.stderr for param in self.params]
assert_allclose(uncertainties, self.best_weighted_errors, rtol=0.005)
# we're also going to try the checkpointing here.
checkpoint = os.path.join(self.tmpdir, 'checkpoint.txt')
# compare samples to best_weighted_errors
np.random.seed(1)
f.sample(steps=101, random_state=1, verbose=False, f=checkpoint)
process_chain(self.objective, f.chain, nburn=50, nthin=10)
uncertainties = [param.stderr for param in self.params]
assert_allclose(uncertainties, self.best_weighted_errors, rtol=0.07)
# test that the checkpoint worked
check_array = np.loadtxt(checkpoint)
check_array = check_array.reshape(101, f._nwalkers, f.nvary)
assert_allclose(check_array, f.chain)
# test loading the checkpoint
chain = load_chain(checkpoint)
assert_allclose(chain, f.chain)
f.initialise('jitter')
f.sample(steps=2, nthin=4, f=checkpoint, verbose=False)
assert_equal(f.chain.shape[0], 2)
# we should be able to produce 2 * 100 steps from the generator
g = self.objective.pgen(ngen=20000000000)
s = [i for i, a in enumerate(g)]
assert_equal(np.max(s), 200 - 1)
g = self.objective.pgen(ngen=200)
pvec = next(g)
assert_equal(pvec.size, len(self.objective.parameters.flattened()))
# check that all the parameters are returned via pgen, not only those
# being varied.
self.params[0].vary = False
f = CurveFitter(self.objective, nwalkers=100)
f.initialise('jitter')
f.sample(steps=2, nthin=4, f=checkpoint, verbose=False)
g = self.objective.pgen(ngen=100)
pvec = next(g)
assert_equal(pvec.size, len(self.objective.parameters.flattened()))
def make_model(names, bs, thicks, roughs, fig_i, data, show=False, mcmc=False):
no_layers = len(bs)
layers = []
for i in range(no_layers):
names.append('layer' + str(i))
for i in range(no_layers):
sld = SLD(bs[i], name=names[i])
layers.append(sld(thicks[i], roughs[i]))
layers[0].thick.setp(vary=True, bounds=(thicks[i] - 1, thicks[i] + 1))
layers[0].sld.real.setp(vary=True, bounds=(bs[i] - 1, bs[i] + 1))
for layer in layers[1:]:
layer.thick.setp(vary=True, bounds=(thicks[i] - 1, thicks[i] + 1))
layer.sld.real.setp(vary=True, bounds=(bs[i] - 1, bs[i] + 1))
layer.rough.setp(vary=True, bounds=(0, 5))
structure = layers[0]
for layer in layers[1:]:
structure |= layer
print(structure)
model = ReflectModel(structure, bkg=3e-6, dq=5.0)
#model.scale.setp(bounds=(0.6, 1.2), vary=True)
#model.bkg.setp(bounds=(1e-9, 9e-6), vary=True)
objective = Objective(model, data, transform=Transform('logY'))
fitter = CurveFitter(objective)
if mcmc:
fitter.sample(1000)
process_chain(objective, fitter.chain, nburn=300, nthin=100)
else:
fitter.fit('differential_evolution')
print(objective.parameters)
if show:
plt.figure(fig_i)
plt.plot(*structure.sld_profile())
plt.ylabel('SLD /$10^{-6} \AA^{-2}$')
plt.xlabel('distance / $\AA$')
return structure, fitter, objective, fig_i + 1
def test_mcmc_pt(self):
if not _HAVE_PTSAMPLER:
return
# smoke test for parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
assert_equal(mcfitter.sampler.ntemps, 10)
res = mcfitter.sample(steps=30, nthin=2, verbose=False, pool=0)
assert_equal(mcfitter.chain.shape, (30, 10, 50, 2))
assert_equal(res[0].chain.shape, (30, 50))
assert_equal(mcfitter.chain[:, 0, :, 0], res[0].chain)
assert_equal(mcfitter.chain[:, 0, :, 1], res[1].chain)
def test_mcmc_init(self):
# smoke test for sampler initialisation
# TODO check that the initialisation worked.
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise('covar')
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise('prior')
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise('jitter')
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=chain)
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise(chain)
if not _HAVE_PTSAMPLER:
return
# initialise for Parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=20, nwalkers=100)
mcfitter.initialise('covar')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise('prior')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise('jitter')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=np.copy(chain))
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100, ntemps=20)
mcfitter.initialise(chain)
def test_reflectivity_emcee(self):
model = self.model361
model.dq = 5.
objective = Objective(model,
(self.qvals361, self.rvals361, self.evals361),
transform=Transform('logY'))
fitter = CurveFitter(objective, nwalkers=100)
assert_(len(objective.generative().shape) == 1)
assert_(len(objective.residuals().shape) == 1)
res = fitter.fit('least_squares')
res_mcmc = fitter.sample(steps=5, nthin=10, random_state=1,
verbose=False)
mcmc_val = [mcmc_result.median for mcmc_result in res_mcmc]
assert_allclose(mcmc_val, res.x, rtol=0.05)
def test_mcmc(self):
self.mcfitter.sample(steps=50, nthin=1, verbose=False)
# we're not doing Parallel Tempering here.
assert_(self.mcfitter._ntemps == -1)
assert_(isinstance(self.mcfitter.sampler, emcee.EnsembleSampler))
# should be able to multithread
mcfitter = CurveFitter(self.objective, nwalkers=50)
res = mcfitter.sample(steps=33, nthin=2, verbose=False, pool=2)
# check that the autocorrelation function at least runs
acfs = mcfitter.acf(nburn=10)
assert_equal(acfs.shape[-1], mcfitter.nvary)
# check chain shape
assert_equal(mcfitter.chain.shape, (33, 50, 2))
# assert_equal(mcfitter._lastpos, mcfitter.chain[:, -1, :])
assert_equal(res[0].chain.shape, (33, 50))
objective3 = Objective(model_lipid3, dataset3, transform=Transform('YX4'))
objective4 = Objective(model_lipid4, dataset4, transform=Transform('YX4'))
global_objective = GlobalObjective(
[objective1, objective2, objective3, objective4])
# ## Fitting
#
# The differential evolution algorithm is used to find optimal parameters, before the MCMC algorithm probes the parameter space for 1000 steps.
# In[ ]:
fitter = CurveFitter(global_objective)
res = fitter.fit('differential_evolution', seed=1)
fitter.sample(200, random_state=1)
fitter.sampler.reset()
res = fitter.sample(1000,
nthin=1,
random_state=1,
f='{}/{}/chain.txt'.format(analysis_dir, lipid))
flatchain = fitter.sampler.flatchain
# The `global_objective` is printed containing information about the models.
# In[ ]:
print(global_objective)
# ## Bibliography
#
structure[2].sld.real.setp(vary=True, bounds=(0.1, 3))
structure[2].rough.setp(vary=True, bounds=(1, 6))
model = ReflectModel(structure, bkg=9e-6, scale=1.)
model.bkg.setp(vary=True, bounds=(1e-8, 1e-5))
model.scale.setp(vary=True, bounds=(0.9, 1.1))
model.threads = 1
# fit on a logR scale, but use weighting
objective = Objective(model, data, transform=Transform('logY'),
use_weights=True)
return objective
if __name__ == "__main__":
with MPIPool() as pool:
if not pool.is_master():
pool.wait()
sys.exit(0)
# buffering so the program doesn't try to write to the file
# constantly
with open('steps.chain', 'w', buffering=500000) as f:
objective = setup()
# Create the fitter and fit
fitter = CurveFitter(objective, nwalkers=300, ntemps=15)
fitter.initialise('prior')
fitter.fit('differential_evolution')
# thin by 10 so we have a smaller filesize
fitter.sample(100, pool=pool, f=f, verbose=False, nthin=10);
f.flush()
class Reflect(Benchmark):
timeout = 120.
# repeat = 2
def setup(self):
pth = os.path.dirname(os.path.abspath(refnx.reflect.__file__))
e361 = RD(os.path.join(pth, 'test', 'e361r.txt'))
sio2 = SLD(3.47, name='SiO2')
si = SLD(2.07, name='Si')
d2o = SLD(6.36, name='D2O')
polymer = SLD(1, name='polymer')
# e361 is an older dataset, but well characterised
structure361 = si | sio2(10, 4) | polymer(200, 3) | d2o(0, 3)
model361 = ReflectModel(structure361, bkg=2e-5)
model361.scale.vary = True
model361.bkg.vary = True
model361.scale.range(0.1, 2)
model361.bkg.range(0, 5e-5)
model361.dq = 5.
# d2o
structure361[-1].sld.real.vary = True
structure361[-1].sld.real.range(6, 6.36)
self.p = structure361[1].thick
structure361[1].thick.vary = True
structure361[1].thick.range(5, 20)
structure361[2].thick.vary = True
structure361[2].thick.range(100, 220)
structure361[2].sld.real.vary = True
structure361[2].sld.real.range(0.2, 1.5)
self.structure361 = structure361
self.model361 = model361
# e361.x_err = None
self.objective = Objective(self.model361,
e361)
self.fitter = CurveFitter(self.objective, nwalkers=200)
self.fitter.initialise('jitter')
def time_reflect_emcee(self):
# test how fast the emcee sampler runs in serial mode
self.fitter.sampler.run_mcmc(self.fitter._state, 30)
def time_reflect_sampling_parallel(self):
# discrepancies in different runs may be because of different numbers
# of processors
self.model361.threads = 1
self.fitter.sample(30, pool=-1)
def time_pickle_objective(self):
# time taken to pickle an objective
s = pickle.dumps(self.objective)
pickle.loads(s)
def time_pickle_model(self):
# time taken to pickle a model
s = pickle.dumps(self.model361)
pickle.loads(s)
def time_pickle_model(self):
# time taken to pickle a parameter
s = pickle.dumps(self.p)
pickle.loads(s)
def time_structure_slabs(self):
self.structure361.slabs()
class TestCurveFitter(object):
def setup_method(self):
# Reproducible results!
np.random.seed(123)
self.m_true = -0.9594
self.b_true = 4.294
self.f_true = 0.534
self.m_ls = -1.1040757010910947
self.b_ls = 5.4405552502319505
# Generate some synthetic data from the model.
N = 50
x = np.sort(10 * np.random.rand(N))
y_err = 0.1 + 0.5 * np.random.rand(N)
y = self.m_true * x + self.b_true
y += np.abs(self.f_true * y) * np.random.randn(N)
y += y_err * np.random.randn(N)
self.data = Data1D(data=(x, y, y_err))
self.p = Parameter(self.b_ls, "b", vary=True, bounds=(-100, 100))
self.p |= Parameter(self.m_ls, "m", vary=True, bounds=(-100, 100))
self.model = Model(self.p, fitfunc=line)
self.objective = Objective(self.model, self.data)
assert_(len(self.objective.varying_parameters()) == 2)
mod = np.array([
4.78166609,
4.42364699,
4.16404064,
3.50343504,
3.4257084,
2.93594347,
2.92035638,
2.67533842,
2.28136038,
2.19772983,
1.99295496,
1.93748334,
1.87484436,
1.65161016,
1.44613461,
1.11128101,
1.04584535,
0.86055984,
0.76913963,
0.73906649,
0.73331407,
0.68350418,
0.65216599,
0.59838566,
0.13070299,
0.10749131,
-0.01010195,
-0.10010155,
-0.29495372,
-0.42817431,
-0.43122391,
-0.64637715,
-1.30560686,
-1.32626428,
-1.44835768,
-1.52589881,
-1.56371158,
-2.12048349,
-2.24899179,
-2.50292682,
-2.53576659,
-2.55797996,
-2.60870542,
-2.7074727,
-3.93781479,
-4.12415366,
-4.42313742,
-4.98368609,
-5.38782395,
-5.44077086,
])
self.mod = mod
self.mcfitter = CurveFitter(self.objective)
def test_bounds_list(self):
bnds = bounds_list(self.p)
assert_allclose(bnds, [(-100, 100), (-100, 100)])
# try making a Parameter bound a normal distribution, then get an
# approximation to box bounds
self.p[0].bounds = PDF(norm(0, 1))
assert_allclose(bounds_list(self.p),
[norm(0, 1).ppf([0.005, 0.995]), (-100, 100)])
def test_constraints(self):
# constraints should work during fitting
self.p[0].value = 5.4
self.p[1].constraint = -0.203 * self.p[0]
assert_equal(self.p[1].value, self.p[0].value * -0.203)
res = self.mcfitter.fit()
assert_(res.success)
assert_equal(len(self.objective.varying_parameters()), 1)
# lnsigma is parameters[0]
assert_(self.p[0] is self.objective.parameters.flattened()[0])
assert_(self.p[1] is self.objective.parameters.flattened()[1])
assert_almost_equal(self.p[0].value, res.x[0])
assert_almost_equal(self.p[1].value, self.p[0].value * -0.203)
# check that constraints work during sampling
# the CurveFitter has to be set up again if you change how the
# parameters are being fitted.
mcfitter = CurveFitter(self.objective)
assert_(mcfitter.nvary == 1)
mcfitter.sample(5)
assert_equal(self.p[1].value, self.p[0].value * -0.203)
# the constrained parameters should have a chain
assert_(self.p[0].chain is not None)
assert_(self.p[1].chain is not None)
assert_allclose(self.p[1].chain, self.p[0].chain * -0.203)
def test_mcmc(self):
self.mcfitter.sample(steps=50, nthin=1, verbose=False)
assert_equal(self.mcfitter.nvary, 2)
# smoke test for corner plot
self.mcfitter.objective.corner()
# we're not doing Parallel Tempering here.
assert_(self.mcfitter._ntemps == -1)
assert_(isinstance(self.mcfitter.sampler, emcee.EnsembleSampler))
# should be able to multithread
mcfitter = CurveFitter(self.objective, nwalkers=50)
res = mcfitter.sample(steps=33, nthin=2, verbose=False, pool=2)
# check that the autocorrelation function at least runs
acfs = mcfitter.acf(nburn=10)
assert_equal(acfs.shape[-1], mcfitter.nvary)
# check the standalone autocorrelation calculator
acfs2 = autocorrelation_chain(mcfitter.chain, nburn=10)
assert_equal(acfs, acfs2)
# check integrated_time
integrated_time(acfs2, tol=5)
# check chain shape
assert_equal(mcfitter.chain.shape, (33, 50, 2))
# assert_equal(mcfitter._lastpos, mcfitter.chain[:, -1, :])
assert_equal(res[0].chain.shape, (33, 50))
# if the number of parameters changes there should be an Exception
# raised
from pytest import raises
with raises(RuntimeError):
self.p[0].vary = False
self.mcfitter.sample(1)
# can fix by making the sampler again
self.mcfitter.make_sampler()
self.mcfitter.sample(1)
def test_random_seed(self):
# check that MCMC sampling is reproducible
self.mcfitter.sample(steps=2, random_state=1)
# get a starting pos
starting_pos = self.mcfitter._state.coords
# is sampling reproducible
self.mcfitter.reset()
self.mcfitter.initialise(pos=starting_pos)
self.mcfitter.sample(3, random_state=1, pool=1)
chain1 = np.copy(self.mcfitter.chain)
self.mcfitter.reset()
self.mcfitter.initialise(pos=starting_pos)
self.mcfitter.sample(3, random_state=1, pool=1)
chain2 = np.copy(self.mcfitter.chain)
assert_equal(chain1, chain2)
def test_mcmc_pt(self):
# smoke test for parallel tempering
x = np.array(self.objective.parameters)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
assert_equal(mcfitter.sampler.ntemps, 10)
# check that the parallel sampling works
# and that chain shape is correct
res = mcfitter.sample(steps=5, nthin=2, verbose=False, pool=-1)
assert_equal(mcfitter.chain.shape, (5, 10, 50, 2))
assert_equal(res[0].chain.shape, (5, 50))
assert_equal(mcfitter.chain[:, 0, :, 0], res[0].chain)
assert_equal(mcfitter.chain[:, 0, :, 1], res[1].chain)
chain = np.copy(mcfitter.chain)
# the sampler should store the probability
assert_equal(mcfitter.logpost.shape, (5, 10, 50))
assert_allclose(mcfitter.logpost, mcfitter.sampler._ptchain.logP)
logprobs = mcfitter.logpost
highest_prob_loc = np.argmax(logprobs[:, 0])
idx = np.unravel_index(highest_prob_loc, logprobs[:, 0].shape)
idx = list(idx)
idx.insert(1, 0)
idx = tuple(idx)
assert_equal(idx, mcfitter.index_max_prob)
pvals = mcfitter.chain[idx]
assert_allclose(logprobs[idx], self.objective.logpost(pvals))
# try resetting the chain
mcfitter.reset()
# test for reproducible operation
self.objective.setp(x)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
mcfitter.initialise("jitter", random_state=1)
mcfitter.sample(steps=5, nthin=2, verbose=False, random_state=2)
chain = np.copy(mcfitter.chain)
self.objective.setp(x)
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
mcfitter.initialise("jitter", random_state=1)
mcfitter.sample(steps=5, nthin=2, verbose=False, random_state=2)
chain2 = np.copy(mcfitter.chain)
assert_allclose(chain2, chain)
def test_mcmc_init(self):
# smoke test for sampler initialisation
# TODO check that the initialisation worked.
# reproducible initialisation with random_state dependents
self.mcfitter.initialise("prior", random_state=1)
starting_pos = np.copy(self.mcfitter._state.coords)
self.mcfitter.initialise("prior", random_state=1)
starting_pos2 = self.mcfitter._state.coords
assert_equal(starting_pos, starting_pos2)
self.mcfitter.initialise("jitter", random_state=1)
starting_pos = np.copy(self.mcfitter._state.coords)
self.mcfitter.initialise("jitter", random_state=1)
starting_pos2 = self.mcfitter._state.coords
assert_equal(starting_pos, starting_pos2)
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise("covar")
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise("prior")
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise("jitter")
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=chain)
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise(chain)
# initialise for Parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=20, nwalkers=100)
mcfitter.initialise("covar")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise("prior")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise("jitter")
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=np.copy(chain))
assert_equal(mcfitter._state.coords, chain[-1])
# initialise with chain if it's never been run before
mcfitter = CurveFitter(self.objective, nwalkers=100, ntemps=20)
mcfitter.initialise(chain)
def test_fit_smoke(self):
# smoke tests to check that fit runs
def callback(xk):
return
def callback2(xk, **kws):
return
# L-BFGS-B
res0 = self.mcfitter.fit(callback=callback)
assert_almost_equal(res0.x, [self.b_ls, self.m_ls], 6)
res0 = self.mcfitter.fit()
res0 = self.mcfitter.fit(verbose=False)
res0 = self.mcfitter.fit(verbose=False, callback=callback)
# least_squares
res1 = self.mcfitter.fit(method="least_squares")
assert_almost_equal(res1.x, [self.b_ls, self.m_ls], 6)
# least_squares doesn't accept a callback. As well as testing that
# least_squares works, it checks that providing a callback doesn't
# trip the fitter up.
res1 = self.mcfitter.fit(method="least_squares", callback=callback)
assert_almost_equal(res1.x, [self.b_ls, self.m_ls], 6)
# need full bounds for differential_evolution
self.p[0].range(3, 7)
self.p[1].range(-2, 0)
res2 = self.mcfitter.fit(
method="differential_evolution",
seed=1,
popsize=10,
maxiter=100,
callback=callback2,
)
assert_almost_equal(res2.x, [self.b_ls, self.m_ls], 6)
# check that the res object has covar and stderr
assert_("covar" in res0)
assert_("stderr" in res0)
def test_NIST(self):
# Run all the NIST standard tests with leastsq
for model in NIST_Models:
try:
NIST_runner(model)
except Exception:
print(model)
raise
objective_n2 = Objective(model_lipid_2, dataset_2, transform=Transform('YX4'))
global_objective = GlobalObjective([objective_n1, objective_n2])
# ## Fitting
#
# The differential evolution algorithm is used to find optimal parameters, before the MCMC algorithm probes the parameter space for 1000 steps.
# In[ ]:
# A differential evolution algorithm is used to obtain an best fit
fitter = CurveFitter(global_objective)
# A seed is used to ensure reproduciblity
res = fitter.fit('differential_evolution', seed=1)
# The first 200*200 samples are binned
fitter.sample(200, random_state=1)
fitter.sampler.reset()
# The collection is across 5000*200 samples
# The random_state seed is to allow for reproducibility
res = fitter.sample(1000,
nthin=1,
random_state=1,
f='{}{}/{}_chain_neutron.txt'.format(
analysis_dir, lipid, sp))
flatchain = fitter.sampler.flatchain
# The `global_objective` is printed containing information about the models.
# In[ ]:
#print total objective
class TestCurveFitter(object):
def setup_method(self):
# Reproducible results!
np.random.seed(123)
self.m_true = -0.9594
self.b_true = 4.294
self.f_true = 0.534
self.m_ls = -1.1040757010910947
self.b_ls = 5.4405552502319505
# Generate some synthetic data from the model.
N = 50
x = np.sort(10 * np.random.rand(N))
y_err = 0.1 + 0.5 * np.random.rand(N)
y = self.m_true * x + self.b_true
y += np.abs(self.f_true * y) * np.random.randn(N)
y += y_err * np.random.randn(N)
self.data = Data1D(data=(x, y, y_err))
self.p = Parameter(self.b_ls, 'b', vary=True, bounds=(-100, 100))
self.p |= Parameter(self.m_ls, 'm', vary=True, bounds=(-100, 100))
self.model = Model(self.p, fitfunc=line)
self.objective = Objective(self.model, self.data)
assert_(len(self.objective.varying_parameters()) == 2)
mod = np.array([4.78166609, 4.42364699, 4.16404064, 3.50343504,
3.4257084, 2.93594347, 2.92035638, 2.67533842,
2.28136038, 2.19772983, 1.99295496, 1.93748334,
1.87484436, 1.65161016, 1.44613461, 1.11128101,
1.04584535, 0.86055984, 0.76913963, 0.73906649,
0.73331407, 0.68350418, 0.65216599, 0.59838566,
0.13070299, 0.10749131, -0.01010195, -0.10010155,
-0.29495372, -0.42817431, -0.43122391, -0.64637715,
-1.30560686, -1.32626428, -1.44835768, -1.52589881,
-1.56371158, -2.12048349, -2.24899179, -2.50292682,
-2.53576659, -2.55797996, -2.60870542, -2.7074727,
-3.93781479, -4.12415366, -4.42313742, -4.98368609,
-5.38782395, -5.44077086])
self.mod = mod
self.mcfitter = CurveFitter(self.objective)
def test_constraints(self):
# constraints should work during fitting
self.p[0].value = 5.4
self.p[1].constraint = -0.203 * self.p[0]
assert_equal(self.p[1].value, self.p[0].value * -0.203)
res = self.mcfitter.fit()
assert_(res.success)
assert_equal(len(self.objective.varying_parameters()), 1)
# lnsigma is parameters[0]
assert_(self.p[0] is self.objective.parameters.flattened()[0])
assert_(self.p[1] is self.objective.parameters.flattened()[1])
assert_almost_equal(self.p[0].value, res.x[0])
assert_almost_equal(self.p[1].value, self.p[0].value * -0.203)
# check that constraints work during sampling
# the CurveFitter has to be set up again if you change how the
# parameters are being fitted.
mcfitter = CurveFitter(self.objective)
assert_(mcfitter.nvary == 1)
mcfitter.sample(5)
assert_equal(self.p[1].value, self.p[0].value * -0.203)
# the constrained parameters should have a chain
assert_(self.p[0].chain is not None)
assert_(self.p[1].chain is not None)
assert_allclose(self.p[1].chain, self.p[0].chain * -0.203)
def test_mcmc(self):
self.mcfitter.sample(steps=50, nthin=1, verbose=False)
assert_equal(self.mcfitter.nvary, 2)
# smoke test for corner plot
self.mcfitter.objective.corner()
# we're not doing Parallel Tempering here.
assert_(self.mcfitter._ntemps == -1)
assert_(isinstance(self.mcfitter.sampler, emcee.EnsembleSampler))
# should be able to multithread
mcfitter = CurveFitter(self.objective, nwalkers=50)
res = mcfitter.sample(steps=33, nthin=2, verbose=False, pool=2)
# check that the autocorrelation function at least runs
acfs = mcfitter.acf(nburn=10)
assert_equal(acfs.shape[-1], mcfitter.nvary)
# check chain shape
assert_equal(mcfitter.chain.shape, (33, 50, 2))
# assert_equal(mcfitter._lastpos, mcfitter.chain[:, -1, :])
assert_equal(res[0].chain.shape, (33, 50))
# if the number of parameters changes there should be an Exception
# raised
from pytest import raises
with raises(RuntimeError):
self.p[0].vary = False
self.mcfitter.sample(1)
# can fix by making the sampler again
self.mcfitter.make_sampler()
self.mcfitter.sample(1)
def test_mcmc_pt(self):
if not _HAVE_PTSAMPLER:
return
# smoke test for parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=10, nwalkers=50)
assert_equal(mcfitter.sampler.ntemps, 10)
res = mcfitter.sample(steps=30, nthin=2, verbose=False, pool=0)
assert_equal(mcfitter.chain.shape, (30, 10, 50, 2))
assert_equal(res[0].chain.shape, (30, 50))
assert_equal(mcfitter.chain[:, 0, :, 0], res[0].chain)
assert_equal(mcfitter.chain[:, 0, :, 1], res[1].chain)
def test_mcmc_init(self):
# smoke test for sampler initialisation
# TODO check that the initialisation worked.
mcfitter = CurveFitter(self.objective, nwalkers=100)
mcfitter.initialise('covar')
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise('prior')
assert_equal(mcfitter._state.coords.shape, (100, 2))
mcfitter.initialise('jitter')
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=chain)
assert_equal(mcfitter._state.coords, chain[-1])
if not _HAVE_PTSAMPLER:
return
# initialise for Parallel tempering
mcfitter = CurveFitter(self.objective, ntemps=20, nwalkers=100)
mcfitter.initialise('covar')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise('prior')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
mcfitter.initialise('jitter')
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with last position
mcfitter.sample(steps=1)
chain = mcfitter.chain
mcfitter.initialise(pos=chain[-1])
assert_equal(mcfitter._state.coords.shape, (20, 100, 2))
# initialise with chain
mcfitter.sample(steps=2)
chain = mcfitter.chain
mcfitter.initialise(pos=np.copy(chain))
assert_equal(mcfitter._state.coords, chain[-1])
def test_fit_smoke(self):
# smoke tests to check that fit runs
# L-BFGS-B
res0 = self.mcfitter.fit()
assert_almost_equal(res0.x, [self.b_ls, self.m_ls], 6)
# least_squares
res1 = self.mcfitter.fit(method='least_squares')
assert_almost_equal(res1.x, [self.b_ls, self.m_ls], 6)
# need full bounds for differential_evolution
self.p[0].range(3, 7)
self.p[1].range(-2, 0)
res2 = self.mcfitter.fit(method='differential_evolution', seed=1,
popsize=10, maxiter=100)
assert_almost_equal(res2.x, [self.b_ls, self.m_ls], 6)
# check that the res object has covar and stderr
assert_('covar' in res0)
assert_('stderr' in res0)
def test_NIST(self):
# Run all the NIST standard tests with leastsq
for model in NIST_Models:
try:
NIST_runner(model)
except Exception:
print(model)
raise
for i in range(t):
models.append(ReflectModel(structures[i]))
models[i].scale.setp(vary=True, bounds=(0.005, 10))
models[i].bkg.setp(datasets[i].y[-1], vary=False)
objectives = []
if neutron:
t = len(cont)
else:
t = sp.size
for i in range(t):
objectives.append(
Objective(models[i], datasets[i], transform=Transform("YX4")))
global_objective = GlobalObjective(objectives)
fitter = CurveFitter(global_objective)
np.random.seed(1)
res = fitter.fit("differential_evolution")
print(global_objective)
fitter.sample(200, random_state=1)
fitter.sampler.reset()
res = fitter.sample(
1000,
nthin=1,
random_state=1,
f="{}/{}_chain.txt".format(anal_dir, label),
)
def seperateNLayer(data, nLayers, limits = None, doMCMC=False): #used
air = SLD(0,name="air layer")
airSlab = air(10,0)
sio2 = SLD(10,name="bottem layer")
sio2Slab = sio2(10,0)
if limits is None:
limits = [350,50,4,6]
# maxThick = 350
# lowerThick = 50
# upperThick = maxThick - nLayers*lowerThick
# lowerB = 4
# upperB = 6
maxThick = float(limits[0])
lowerThick = limits[1]
upperThick = maxThick - nLayers*lowerThick
lowerB = limits[2]
upperB = limits[3]
if nLayers>=1:
sld1 = SLD(5,name="first layer")
sld1Slab = sld1(maxThick/nLayers,0)
if nLayers>=2:
sld2 = SLD(5,name="second layer")
sld2Slab = sld2(maxThick/nLayers,0)
if nLayers>=3:
sld3 = SLD(5,name="second layer")
sld3Slab = sld3(maxThick/nLayers,0)
if nLayers>=4:
sld4 = SLD(5,name="second layer")
sld4Slab = sld4(maxThick/nLayers,0)
if nLayers>=1:
sld1Slab.thick.setp(vary=True, bounds=(lowerThick,upperThick))
sld1Slab.sld.real.setp(vary=True, bounds=(lowerB,upperB))
if nLayers>=2:
sld2Slab.thick.setp(vary=True, bounds=(lowerThick,upperThick))
sld2Slab.sld.real.setp(vary=True, bounds=(lowerB,upperB))
if nLayers>=3:
sld3Slab.thick.setp(vary=True, bounds=(lowerThick,upperThick))
sld3Slab.sld.real.setp(vary=True, bounds=(lowerB,upperB))
if nLayers>=4:
sld4Slab.thick.setp(vary=True, bounds=(lowerThick,upperThick))
sld4Slab.sld.real.setp(vary=True, bounds=(lowerB,upperB))
if nLayers>=1:
structure = airSlab|sld1Slab|sio2Slab
if nLayers>=2:
structure = airSlab|sld1Slab|sld2Slab|sio2Slab
if nLayers>=3:
structure = airSlab|sld1Slab|sld2Slab|sld3Slab|sio2Slab
if nLayers>=4:
structure = airSlab|sld1Slab|sld2Slab|sld3Slab|sld4Slab|sio2Slab
model = ReflectModel(structure, bkg=3e-6, dq=5.0)
objective = Objective(model, data, transform=Transform('logY'))
fitter = CurveFitter(objective)
if not doMCMC:
fitter.fit("differential_evolution")
else:
fitter.sample(500)
fitter.sampler.reset()
fitter.sample(40, nthin=50)
pass
# print(objective.parameters)
lp = objective.logpost()
# print("log: ", lp)
return lp
