def do_mcmc(self,
nwalker=100,
nburn=50,
nchain=50,
threads=1,
set_prior=True):
# initial walkers for MCMC
ndim = 2
pinit = np.zeros((nwalker, ndim))
pinit[:, 0] = np.random.uniform(-10, -2, nwalker)
pinit[:, 1] = np.random.uniform(np.log10(self.lc.dt_min / 10),
np.log10(self.lc.dt_tot * 10), nwalker)
#start sampling
sampler = EnsembleSampler(nwalker,
ndim,
self.lnprob,
args=(self.lc, set_prior),
threads=threads)
# burn-in
pos, prob, state = sampler.run_mcmc(pinit, nburn)
sampler.reset()
# actual samples
sampler.run_mcmc(pos, nchain, rstate0=state)
self.sampler = sampler
self.flatchain = sampler.flatchain
self.lnprobability = sampler.lnprobability
def optimize():
from emcee import EnsembleSampler
import multiprocessing as mp
ndim = 4
nwalkers = 4 * ndim
p0 = np.array(
[
np.random.uniform(1000, 5000, nwalkers),
np.random.uniform(0.1, 1.0, nwalkers),
np.random.uniform(2, 12, nwalkers),
np.random.uniform(0.1, 1.5, nwalkers),
]
).T
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=mp.cpu_count())
pos, prob, state = sampler.run_mcmc(p0, 1000)
sampler.reset()
print("Burned in")
# actual run
pos, prob, state = sampler.run_mcmc(pos, 1000)
# Save the last position of the walkers
np.save("walkers_emcee.npy", pos)
np.save("eparams_emcee.npy", sampler.flatchain)
def run_sampler(
backend,
nwalkers=32,
ndim=3,
nsteps=25,
seed=1234,
thin=None,
thin_by=1,
progress=False,
store=True,
):
np.random.seed(seed)
coords = np.random.randn(nwalkers, ndim)
np.random.seed(None)
sampler = EnsembleSampler(nwalkers,
ndim,
normal_log_prob,
backend=backend,
seed=seed)
sampler.run_mcmc(
coords,
nsteps,
thin=thin,
thin_by=thin_by,
progress=progress,
store=store,
)
return sampler
def fitMcmc(self, u, v, *theta0, **kwargs):
"""!
@brief Markov chain monte carlo fit method
@param u <b>np_1darray</b> Rank data vector
@param v <b>np_1darray</b> Rank data vector
@param theta0 Initial guess for copula parameter list
@return <b>tuple</b> :
(<b>np_array</b> Array of MLE fit copula parameters,
<b>np_2darray</b> sample array of shape (nparams, nsamples))
"""
from emcee import EnsembleSampler
wgts = kwargs.pop("weights", np.ones(len(u)))
rotation = 0
ln_prob = lambda theta: self._ln_prior(*theta, **kwargs) + \
self._ln_like(u, v, wgts, rotation, *theta)
if None in theta0:
params0 = self.theta0
else:
params0 = theta0
ndim = len(params0)
ngen = kwargs.get("ngen", 200)
nburn = kwargs.get("nburn", 100)
nwalkers = kwargs.get("nwalkers", 50)
# initilize walkers in gaussian ball around theta0
pos_0 = [
np.array(params0) +
1e-6 * np.asarray(params0) * np.random.randn(ndim)
for i in range(nwalkers)
]
emcee_mcmc = EnsembleSampler(nwalkers, ndim, ln_prob)
emcee_mcmc.run_mcmc(pos_0, ngen)
samples = emcee_mcmc.chain[:, nburn:, :].reshape((-1, ndim))
res = np.mean(samples, axis=0)
self._fittedParams = res
return res, samples
def test_blob_shape(backend, blob_spec):
# HDF backends don't support the object type
hdf_able, ragged, blob_shape, func = blob_spec
if backend in (backends.TempHDFBackend,) and not hdf_able:
return
with backend() as be:
np.random.seed(42)
model = BlobLogProb(func)
coords = np.random.randn(32, 3)
nwalkers, ndim = coords.shape
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
nsteps = 10
if ragged:
with warnings.catch_warnings():
warnings.simplefilter("ignore", DeprecationWarning)
sampler.run_mcmc(coords, nsteps)
else:
sampler.run_mcmc(coords, nsteps)
shape = [nsteps, nwalkers]
if isinstance(blob_shape, tuple):
shape += blob_shape
elif blob_shape > 0:
shape += [blob_shape]
assert sampler.get_blobs().shape == tuple(shape)
if not hdf_able:
assert sampler.get_blobs().dtype == np.dtype("object")
def runsample(self, sed_obs, sed_obs_err, vpi_obs, vpi_obs_err,
Lvpi=1.0, Lprior=1.0, nsteps=(1000, 1000, 2000), p0try=None):
ndim = 4 # 4 stands for [Teff, logg, Av, DM]
nwalkers = len(p0try) # number of chains
for i in range(len(nsteps)):
if i == 0:
# initialize sampler
sampler = EnsembleSampler(nwalkers, ndim, costfun,
args=(self.r, self.p_bounds,
self.Alambda, sed_obs,
sed_obs_err, vpi_obs,
vpi_obs_err, Lvpi, Lprior))
# guess Av and DM for p0try
p0try = np.array([initial_guess(_, self.r, self.Alambda, sed_obs, sed_obs_err) for _ in p0try])
# run sampler
pos, _, __ = sampler.run_mcmc(p0try, nsteps[i])
else:
# generate new p
p_rand = random_p(sampler, nloopmax=1000, method="mle",
costfun=costfun, args=(self.r, self.p_bounds,
self.Alambda, sed_obs,
sed_obs_err, vpi_obs,
vpi_obs_err,
Lvpi, Lprior))
# reset sampler
sampler.reset()
# run at new p
pos1, lnprob1, rstate1 = sampler.run_mcmc(p_rand, nsteps[i])
return sampler
def test_errors(backend, nwalkers=32, ndim=3, nsteps=5, seed=1234):
# Set up the random number generator.
np.random.seed(seed)
with backend() as be:
# Initialize the ensemble, proposal, and sampler.
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob, backend=be)
# Test for not running.
with pytest.raises(AttributeError):
sampler.chain
with pytest.raises(AttributeError):
sampler.lnprobability
# What about not storing the chain.
sampler.run_mcmc(coords, nsteps, store=False)
with pytest.raises(AttributeError):
sampler.chain
# Now what about if we try to continue using the sampler with an
# ensemble of a different shape.
sampler.run_mcmc(coords, nsteps, store=False)
coords2 = np.random.randn(nwalkers, ndim + 1)
with pytest.raises(ValueError):
list(sampler.run_mcmc(coords2, nsteps))
def sample_emcee(model,
data,
nwalkers,
nsamples,
walker_initial_pos,
threads='auto',
cleanup_threads=True,
seed=None):
sampler = EnsembleSampler(nwalkers,
len(list(model.parameters)),
model.lnposterior,
threads=autothreads(threads),
args=[data])
if seed is not None:
np.random.seed(seed)
seed_state = np.random.mtrand.RandomState(seed).get_state()
sampler.random_state = seed_state
sampler.run_mcmc(walker_initial_pos, nsamples)
if sampler.pool is not None and cleanup_threads:
sampler.pool.terminate()
sampler.pool.join()
return sampler
def sample_orbit(sampler, nsteps=0, theta0=None, processes=None):
"""Run the MCMC sampler
Note: For improved parallel performance this function is not implemented as
a class method of MCMCSampler.
"""
with Pool(processes) as pool:
worker = EnsembleSampler(sampler.nwalkers,
sampler.ndim,
sampler.objective,
backend=sampler.backend,
pool=pool)
if worker.backend.iteration == 0:
logger.info("Starting new run")
if theta0 is None:
theta = np.array([[prior.draw() for prior in sampler.priors]
for n in range(sampler.nwalkers)])
else:
theta = theta0
else:
logger.info("Resuming last run")
theta = worker._previous_state
assert theta is not None
if nsteps is not None:
assert nsteps >= 0
worker.run_mcmc(theta, nsteps, progress=True)
logger.info("finished MCMC run")
return worker
def run_sampler(backend, nwalkers=32, ndim=3, nsteps=25, seed=1234, thin_by=1):
np.random.seed(seed)
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob,
backend=backend)
sampler.run_mcmc(coords, nsteps, thin_by=thin_by)
return sampler
def test_errors(backend, nwalkers=32, ndim=3, nsteps=5, seed=1234):
# Set up the random number generator.
np.random.seed(seed)
with backend() as be:
# Initialize the ensemble, proposal, and sampler.
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob,
backend=be)
# Test for not running.
with pytest.raises(AttributeError):
sampler.chain
with pytest.raises(AttributeError):
sampler.lnprobability
# What about not storing the chain.
sampler.run_mcmc(coords, nsteps, store=False)
with pytest.raises(AttributeError):
sampler.chain
# Now what about if we try to continue using the sampler with an
# ensemble of a different shape.
sampler.run_mcmc(coords, nsteps, store=False)
coords2 = np.random.randn(nwalkers, ndim+1)
with pytest.raises(ValueError):
list(sampler.run_mcmc(coords2, nsteps))
def test_shapes(backend, moves, nwalkers=32, ndim=3, nsteps=10, seed=1234):
# Set up the random number generator.
np.random.seed(seed)
with backend() as be:
# Initialize the ensemble, moves and sampler.
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob,
moves=moves, backend=be)
# Run the sampler.
sampler.run_mcmc(coords, nsteps)
chain = sampler.get_chain()
assert len(chain) == nsteps, "wrong number of steps"
tau = sampler.get_autocorr_time(quiet=True)
assert tau.shape == (ndim,)
# Check the shapes.
assert sampler.chain.shape == (nwalkers, nsteps, ndim), \
"incorrect coordinate dimensions"
assert sampler.get_chain().shape == (nsteps, nwalkers, ndim), \
"incorrect coordinate dimensions"
assert sampler.lnprobability.shape == (nsteps, nwalkers), \
"incorrect probability dimensions"
assert sampler.acceptance_fraction.shape == (nwalkers,), \
"incorrect acceptance fraction dimensions"
# Check the shape of the flattened coords.
assert sampler.get_chain(flat=True).shape == \
(nsteps * nwalkers, ndim), "incorrect coordinate dimensions"
assert sampler.get_log_prob(flat=True).shape == \
(nsteps*nwalkers,), "incorrect probability dimensions"
def test_hybrid_sampling(pipe):
n_walkers, p0, hybrid_lnpost = get_walkers(pipe, lnpost_fn=lnpost)
n_walkers *= 2
p0 = np.concatenate([p0, p0])
with pipe.worker_mode:
if pipe._is_controller:
sampler = EnsembleSampler(n_walkers, pipe._modellink._n_par,
hybrid_lnpost, args=[pipe])
sampler.run_mcmc(p0, 10)
def run_sampler(backend, nwalkers=32, ndim=3, nsteps=25, seed=1234,
thin=None, thin_by=1, progress=False, store=True):
np.random.seed(seed)
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob,
backend=backend)
sampler.run_mcmc(coords, nsteps, thin=thin, thin_by=thin_by,
progress=progress, store=store)
return sampler
def test_shapes(backend, moves, nwalkers=32, ndim=3, nsteps=10, seed=1234):
# Set up the random number generator.
np.random.seed(seed)
with backend() as be:
# Initialize the ensemble, moves and sampler.
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers,
ndim,
normal_log_prob,
moves=moves,
backend=be)
# Run the sampler.
sampler.run_mcmc(coords, nsteps)
chain = sampler.get_chain()
assert len(chain) == nsteps, "wrong number of steps"
tau = sampler.get_autocorr_time(quiet=True)
assert tau.shape == (ndim, )
# Check the shapes.
with pytest.warns(DeprecationWarning):
assert sampler.chain.shape == (
nwalkers,
nsteps,
ndim,
), "incorrect coordinate dimensions"
with pytest.warns(DeprecationWarning):
assert sampler.lnprobability.shape == (
nwalkers,
nsteps,
), "incorrect probability dimensions"
assert sampler.get_chain().shape == (
nsteps,
nwalkers,
ndim,
), "incorrect coordinate dimensions"
assert sampler.get_log_prob().shape == (
nsteps,
nwalkers,
), "incorrect probability dimensions"
assert sampler.acceptance_fraction.shape == (
nwalkers, ), "incorrect acceptance fraction dimensions"
# Check the shape of the flattened coords.
assert sampler.get_chain(flat=True).shape == (
nsteps * nwalkers,
ndim,
), "incorrect coordinate dimensions"
assert sampler.get_log_prob(flat=True).shape == (
nsteps * nwalkers, ), "incorrect probability dimensions"
def run_sampler(backend, nwalkers=32, ndim=3, nsteps=25, seed=1234, thin_by=1,
dtype=None, blobs=True, lp=None):
if lp is None:
lp = normal_log_prob_blobs if blobs else normal_log_prob
if seed is not None:
np.random.seed(seed)
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, lp,
backend=backend, blobs_dtype=dtype)
sampler.run_mcmc(coords, nsteps, thin_by=thin_by)
return sampler
def test_vectorize():
def lp_vec(p):
return -0.5 * np.sum(p**2, axis=1)
np.random.seed(42)
nwalkers, ndim = 32, 3
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, lp_vec, vectorize=True)
sampler.run_mcmc(coords, 10)
assert sampler.get_chain().shape == (10, nwalkers, ndim)
def test_vectorize():
def lp_vec(p):
return -0.5 * np.sum(p**2, axis=1)
np.random.seed(42)
nwalkers, ndim = 32, 3
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, lp_vec, vectorize=True)
sampler.run_mcmc(coords, 10)
assert sampler.get_chain().shape == (10, nwalkers, ndim)
def test_overwrite(seed=1234):
np.random.seed(seed)
def ll(x):
return -0.5 * np.sum(x**2)
nwalkers = 64
p0 = np.random.normal(size=(nwalkers, 1))
init = np.copy(p0)
sampler = EnsembleSampler(nwalkers, 1, ll)
sampler.run_mcmc(p0, 10)
assert np.allclose(init, p0)
def mcmc(self, n_walkers, n_iter, n_burnin, lnprob, args, pos0, chain_labels,
pool=None, progress=True, out_file=None):
"""
PARAMETERS
----------
`n_walkers` (int): the number of walkers to use
`n_iter` (int): the number of sample iterations to perform post burn-in
`n_burnin` (int): the number of burn-in steps to perform
`lnprob` (func): function returning the log-posterior probability
`args` (tuple): arguments to be passed to `lnprob`
`pos0` (list-like): list of initial walker positions
`chain_labels` (list of str): list of column labels for the sample chains
`out_file` (str, optional): the user has the option to save the sample
chains and blobs to a csv or pickle file. This is the path to the
output filename.
RETURNS
-------
`output`: a pandas DataFrame containing all the sample chains and blobs
"""
n_dim = len(chain_labels)
sampler = EnsembleSampler(n_walkers, n_dim, lnprob, args=args,
pool=pool,
blobs_dtype=[("star", pd.Series)])
# Burn-in phase
if n_burnin != 0:
print("Burn-in phase...", end="\r")
pos, prob, state, blobs = sampler.run_mcmc(pos0, n_burnin)
sampler.reset()
else:
pos = pos0
# Sampling phase
pos, prob, state, blobs = sampler.run_mcmc(pos, n_iter,
progress=progress)
samples = pd.DataFrame(sampler.flatchain, columns=chain_labels)
blobs = sampler.get_blobs(flat=True)
blobs = pd.concat(blobs["star"], axis=1).T
output = pd.concat([samples, blobs], axis=1)
if out_file is not None:
if "csv" in out_file:
output.to_csv(out_file, index=False)
else:
output.to_pickle(out_file)
return sampler, output
def test_blob_shape(backend):
with backend() as be:
np.random.seed(42)
nblobs = 5
model = BlobLogProb(lambda x: np.random.randn(nblobs))
coords = np.random.randn(32, 3)
nwalkers, ndim = coords.shape
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
nsteps = 10
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers, nblobs)
model = BlobLogProb(lambda x: np.random.randn())
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers)
# HDF backends don't support the object type
if backend in (backends.TempHDFBackend, ):
return
model = BlobLogProb(lambda x: "face")
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers)
model = BlobLogProb(lambda x: (np.random.randn(nblobs), "face"))
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers, 2)
def test_blob_shape(backend):
with backend() as be:
np.random.seed(42)
nblobs = 5
model = BlobLogProb(lambda x: np.random.randn(nblobs))
coords = np.random.randn(32, 3)
nwalkers, ndim = coords.shape
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
nsteps = 10
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers, nblobs)
model = BlobLogProb(lambda x: np.random.randn())
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers)
# HDF and FITS backends don't support the object type
if backend in (backends.TempHDFBackend, backends.TempFITSBackend):
return
model = BlobLogProb(lambda x: "face")
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers)
model = BlobLogProb(lambda x: (np.random.randn(nblobs), "face"))
be.reset(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
sampler.run_mcmc(coords, nsteps)
assert sampler.get_blobs().shape == (nsteps, nwalkers, 2)
def test_sampler_generator():
nwalkers = 32
ndim = 3
nsteps = 5
np.random.seed(456)
coords = np.random.randn(nwalkers, ndim)
seed1 = np.random.default_rng(1)
sampler1 = EnsembleSampler(nwalkers, ndim, normal_log_prob, seed=seed1)
sampler1.run_mcmc(coords, nsteps)
seed2 = np.random.default_rng(1)
sampler2 = EnsembleSampler(nwalkers, ndim, normal_log_prob, seed=seed2)
sampler2.run_mcmc(coords, nsteps)
np.testing.assert_allclose(sampler1.get_chain(), sampler2.get_chain())
np.testing.assert_allclose(sampler1.get_log_prob(),
sampler2.get_log_prob())
def __call__(self, nw=None, nt=None, nb=None, ns=None):
if nw is None:
nw = self.nWalkers
else:
self.nWalkers = nw
self._initial_parameters()
if nt is None:
nt = self.nThreads
if nb is None:
nb = self.nBurnin
if ns is None:
ns = self.nSteps
# setup emcee sampler
sampler = EnsembleSampler(nw, self.nDim, self.lnProb, threads=nt)
if nb:
# Run burn-in steps
pos, prob, state = sampler.run_mcmc(self.pos0, nb)
# Reset the chain to remove the burn-in samples
sampler.reset()
# from the final position in burn-in chain, sample for nsteps
sampler.run_mcmc(pos, ns, rstate0=state)
else:
# sample for nsteps
sampler.run_mcmc(self.pos0, ns)
samples = sampler.flatchain
lnprobs = sampler.flatlnprobability
indxs = np.where(lnprobs > -float_info.max)[0]
if self.scale == 'linear':
samples = samples[indxs]
elif self.scale == 'log':
samples = np.power(10, samples[indxs])
else:
raise Exception("prior scale must be set")
lnprobs = lnprobs[indxs]
Xmin = max(lnprobs)
indmin = np.where(lnprobs == Xmin)[0][0]
vals = samples[indmin]
return vals, samples, lnprobs
def lt_taum(pTeff, plogLstar, grid_name='MIST', ntrials=10000, burn=0,
nwalkers=10):
# set up parser
parser = argparse.ArgumentParser(description="Given a set of MCMC samples of T, log L, use scipy.kde to approximate the density field.")
parser.add_argument("--config", default="config.yaml", help="The config file specifying everything we need.")
args = parser.parse_args()
f = open(args.config)
config = yaml.load(f)
f.close()
# collate the Teff, logLstar samples (presumed independent here)
TlL_samples = np.column_stack((np.log10(pTeff), plogLstar))
# initialize MCMC walkers
ndim = 2
age_low, age_high = 0.2, 20. # in Myr
Mstar_low, Mstar_high = 0.1, 3. # in Msun
p0 = np.array([np.log10(1e6*np.random.uniform(age_low, age_high, nwalkers)),
np.log10(np.random.uniform(Mstar_low, Mstar_high, nwalkers))]).T
# KDE for Teff, logLstar
samples = TlL_samples.T
kernel = gaussian_kde(samples)
# define the likelihood function
def lnprob(p, grid):
age, mass = p
#if ((age < 0.0) or (mass < 0.0)):
# return -np.inf
# smooth interpolation in H-R diagram
temp = grid.interp_T(p)
lL = grid.interp_lL(p)
# land outside the grid, you get a NaN; convert to -np.inf to sample
if np.isnan(temp) or np.isnan(lL):
return -np.inf
# evaluate the KDE kernel
lnp = kernel.logpdf([temp, lL])
# return the log-likelihood
return lnp
# *** sample the {age, Mstar} posterior
# assign the model grid
grid = model_dict[grid_name](**config[grid_name])
# initialize and run the EMCEE sampler
sampler = EnsembleSampler(nwalkers, ndim, lnprob, args=[grid])
pos, prob, state = sampler.run_mcmc(p0, ntrials)
# flatten the resulting chain to give joint samples of {age, Mstar}
ptauMstar = (sampler.chain[:,burn:,:]).reshape(-1, ndim)
return ptauMstar
def sample_emcee(model, data, nwalkers, nsamples, walker_initial_pos,
threads='auto', cleanup_threads=True, seed=None):
sampler = EnsembleSampler(nwalkers, len(list(model.parameters)),
model.lnposterior,
threads=autothreads(threads), args=[data])
if seed is not None:
np.random.seed(seed)
seed_state = np.random.mtrand.RandomState(seed).get_state()
sampler.random_state=seed_state
sampler.run_mcmc(walker_initial_pos, nsamples)
if sampler.pool is not None and cleanup_threads:
sampler.pool.terminate()
sampler.pool.join()
return sampler
def centroid(img, x0, y0, fwhm_x=8., fwhm_y=8., verbose=False, **kwargs):
def prior_bounds(pv):
return -1e18 if not ((0 < pv[0] < img.shape[1]) | (0 < pv[1] < img.shape[0])) else 0
estimate_errors = kwargs.get('estimate_errors', True)
return_chains = kwargs.get('return_chains', False)
operation = kwargs.get('operation', 'mean')
maxiter = kwargs.get('maxiter', 5000)
maxfun = kwargs.get('maxfun', 5000)
mc_threads = kwargs.get('mc_threads', 1)
mc_nwalkers = kwargs.get('mc_nwalkers', 50)
mc_niter = kwargs.get('mc_niter', 300)
mc_thinning = kwargs.get('mc_thinning', 300)
mc_burn = kwargs.get('mc_burn', 100)
if operation == 'mean':
x, y = img.mean(axis=0), img.mean(axis=1)
elif operation == 'max':
x, y = img.max(axis=0), img.max(axis=1)
else:
raise TypeError
vmin, vmax = 0.5*(x.min()+y.min()), 0.5*(x.max()+y.max())
pv0 = np.array([x0, y0, fwhm_x, fwhm_y, vmax-vmin, 1e-2*(vmax-vmin), vmin])
lpfun = lambda pv: ( logl_g1d(pv[0], pv[4], pv[2], pv[5], pv[6], x)
+ logl_g1d(pv[1], pv[4], pv[3], pv[5], pv[6], y)
+ prior_bounds(pv))
pv = fmin(lambda pv:-lpfun(pv), pv0, disp=verbose, maxfun=maxfun, maxiter=maxiter)
if not (with_emcee and estimate_errors):
return pv, -np.ones(pv.size)
else:
sampler = EnsembleSampler(mc_nwalkers, pv.size, lpfun, threads=1)
sampler.run_mcmc(multivariate_normal(pv, 5e-3*np.eye(pv.size), size=mc_nwalkers), mc_niter);
fc = sampler.chain[:,mc_burn::mc_thinning,:].reshape([-1,pv.size])
pc = np.array(np.percentile(fc, [50,16,84], axis=0))
if return_chains:
pc[0,:], np.mean(np.abs(pc[1:,:]-pc[0,:]), axis=0), fc
else:
return pc[0,:], np.mean(np.abs(pc[1:,:]-pc[0,:]), axis=0)
def do_mcmc(self, nwalker=100, nburn=50, nchain=50, threads=1, set_prior=True):
# initial walkers for MCMC
ndim = 2
pinit = np.zeros((nwalker, ndim))
pinit[:,0] = np.random.uniform(-10, -2, nwalker)
pinit[:,1] = np.random.uniform(np.log10(self.lc.dt_min/10), np.log10(self.lc.dt_tot*10), nwalker)
#start sampling
sampler = EnsembleSampler(nwalker, ndim, self.lnprob, args=(self.lc,set_prior), threads=threads)
# burn-in
pos, prob, state = sampler.run_mcmc(pinit, nburn)
sampler.reset()
# actual samples
sampler.run_mcmc(pos, nchain, rstate0=state)
self.sampler = sampler
self.flatchain = sampler.flatchain
self.lnprobability = sampler.lnprobability
def test_blob_mismatch(backend):
with backend() as be:
np.random.seed(42)
model = VariableLogProb()
coords = np.random.randn(32, 3)
nwalkers, ndim = coords.shape
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
model.i += 1
# We don't save blobs from the initial points
# so blob shapes are taken from the first round of moves
sampler.run_mcmc(coords, 1)
model.i += 1
with pytest.raises(ValueError):
sampler.run_mcmc(coords, 1)
def sample(self, lnl):
# set up output file
if self.output_file and mpi.is_master():
_output_file = open(self.output_file,"wb")
protocol = pickle.HIGHEST_PROTOCOL
pickle.dump(
obj=list(chain(['lnl','weight'], self.sampled.keys(), self.output_extra_params.keys())),
file=_output_file,
protocol=protocol
)
dtypes = ','.join([dtype(float).name]*(2+len(self.sampled))+list(self.output_extra_params.values()))
samples = {i:empty(self.output_freq,dtypes) for i in range(self.nwalkers)}
# distribute walkers initially according to covariance estimate
pos = multivariate_normal(
[v.start for v in self.sampled.values()],
self.cov_est,
size=self.nwalkers
)
# diferent sign convention with emcee
def lnprob(x):
l, p = lnl(*x)
return -l, p
# step each walker once, yield them all one-by-one, repeat
weight = ones(self.nwalkers)
isample = zeros(self.nwalkers,dtype=int)
from emcee import EnsembleSampler
sampler = EnsembleSampler(self.nwalkers, len(self.sampled), lnprob, pool=self.pool)
nsteps = int(ceil(self.num_samples/self.nwalkers))
for i in range(nsteps):
posnext, prob, state, blobs = sampler.run_mcmc(pos,1)
for iwalker, (x, xnext, l, params) in enumerate(zip(pos,posnext,prob,blobs)):
if (x==xnext).all() and i!=nsteps-1:
weight[iwalker] += 1
else:
yield sample(-l,x,weight[iwalker])
# write to file once every `self.output_freq` accepted steps (per walker)
if self.output_file and mpi.is_master():
row = tuple(chain([-l,weight[iwalker]],x,[params[k] for k in self.output_extra_params]))
samples[iwalker][isample[iwalker]] = row
isample[iwalker] += 1
if isample[iwalker]>=self.output_freq or i==nsteps-1:
pickle.dump((iwalker,samples[iwalker][:isample[iwalker]]),_output_file,protocol)
_output_file.flush()
isample[iwalker] = 0
weight[iwalker] = 1
pos = posnext
def run_sampler(backend,
nwalkers=32,
ndim=3,
nsteps=25,
seed=1234,
thin_by=1,
dtype=None,
blobs=True,
lp=None):
if lp is None:
lp = normal_log_prob_blobs if blobs else normal_log_prob
if seed is not None:
np.random.seed(seed)
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers,
ndim,
lp,
backend=backend,
blobs_dtype=dtype)
sampler.run_mcmc(coords, nsteps, thin_by=thin_by)
return sampler
def test_blob_shape(backend, blob_spec):
# HDF backends don't support the object type
if backend in (backends.TempHDFBackend, ) and not blob_spec[0]:
return
with backend() as be:
np.random.seed(42)
model = BlobLogProb(blob_spec[2])
coords = np.random.randn(32, 3)
nwalkers, ndim = coords.shape
sampler = EnsembleSampler(nwalkers, ndim, model, backend=be)
nsteps = 10
sampler.run_mcmc(coords, nsteps)
shape = [nsteps, nwalkers]
if blob_spec[1] > 0:
shape += [blob_spec[1]]
assert sampler.get_blobs().shape == tuple(shape)
while len(pos) < nwalkers:
realization = [random_in_range(0, 1), random_in_range(0.01, 1)]
if np.isfinite(lnprior(realization)):
pos.append(realization)
# pool = MPIPool(loadbalance=True)
# if not pool.is_master():
# pool.wait()
# sys.exit(0)
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=8,
args=(target_slices, source1_slices,
source2_slices))
#pool=pool)
sampler.run_mcmc(pos, 1000)
samples = sampler.chain[:, 500:, :].reshape((-1, ndim))
samples[:, 0] *= R_lambda
lower, m, upper = np.percentile(samples[:, 0], [16, 50, 84])
band_results['f_S_lower'] = m - lower
band_results['f_S'] = m
band_results['f_S_upper'] = upper - m
band_results['yerr'] = np.median(samples[:, 1])
corner(samples, labels=['$f_S$', '$f$'])
plt.savefig('plots_ekdra/{0}_{1}_{2}.pdf'.format(star, int(band.core.value),
time.replace(':', '_')),
bbox_inches='tight')
:return:
Log of prior density for given parameter ``p``.
"""
return p[2]
if __name__ == '__main__':
# Data from Gelman (Table 11.2)
y_ij = list()
y_ij.append([62, 60, 63, 59])
y_ij.append([63, 67, 71, 64, 65, 66])
y_ij.append([68, 66, 71, 67, 68, 68])
y_ij.append([56, 62, 60, 61, 63, 64, 63, 59])
print y_ij
lnpost = LnPost(y_ij, lnpr=lnpr)
ndim = 7
nwalkers = 500
sampler = EnsembleSampler(nwalkers, ndim, lnpost)
p0 = sample_ball([60., 0., 0., 60., 60., 60., 60.],
[10., 1., 1., 10., 10., 10., 10.], size=500)
print "sample ball :"
print p0
print "Burning-in..."
pos, prob, state = sampler.run_mcmc(p0, 300)
print "Reseting burn-in..."
sampler.reset()
print "Now sampling from posterior"
sampler.run_mcmc(pos, 1000, rstate0=state)
#print("\nInitializing walkers")
nwalk = 100
params0 = np.tile(guess_list, nwalk).reshape(nwalk, len(guess_list))
#
# perturb walkers around guess
#
for i in xrange(len(guess_list)):
params0.T[i] += np.random.rand(nwalk) * perturb_list[i]
# hack!
params0.T[2] = np.absolute(params0.T[2]) # ...and force >= 0
#print("\nInitializing the sampler and burning in walkers")
s = EnsembleSampler(nwalk, params0.shape[-1], bre, threads=4)
pos, prob, state = s.run_mcmc(params0, burn_in)
s.reset()
#print("\nSampling the posterior density for the problem")
s.run_mcmc(pos, samples)
samplea = s.flatchain[:,0]
pylab.plot(samplea)
pylab.xlabel('Step number')
pylab.ylabel('alpha')
pylab.show()
pylab.savefig('alpha.png')
samples = s.flatchain[:,1]
pylab.plot(samples)
pylab.xlabel('Step number')
def mcmc(meta_prefit, C0, P, D, t_steps, pops, nwalkers=80, nsteps=500, nburn=100, storage="mcmc"):
"""
MCMC Version 2015 Jan 17 Madhura Killedar
Last update: 2015 Nov 20 Madhura Killedar
implementation of D. Forman-Mackay's emcee for Bayesian parameter fitting
emcee is a python implementation of affine invariant MCMC ensemble sampler
INPUT
meta_prefit: as a starting proposal for parameters, taken from model baseline (or mean).
the walkers begin in a ball around this point and the send a chain to explore the parameter space
nwalkers: number of walkers/chains
nsteps: total number of steps taken by each chain
nburn: assumed burn-in phase
storage: path to folder in which to place output files
OUTPUT
samples: non-burn-in steps of all chains combined, used to actually sample the posterior
ON-THE-FLY OUTPUT
fn_diagnostics (ASCII ~1KB) : a log file for useful diagnostics of the MCMC run
fn_chains (PNG ~200KB) : plot of some of the chains/walkers in MCMC run for some of the parameters
fn_corner (PNG ~1MB) : corner plot for MCMC sample of all parameters
"""
# -------------------------------------------------
# on-the-fly output filenames
fn_diagnostics = "MCMCdiagnostics.log"
fn_chains = "plot-mcmc-chain.png"
fn_corner = "plot-mcmc-corner.png"
logfile = storage+"/"+fn_diagnostics
logf = open(logfile, "w")
# SETUP NUMBER OF PARAMETERS, WALKERS, STEPS TO USE
nparam = len(meta_prefit) # actual number of parameters being calibrated (mortality for now)
if nwalkers < 2*nparam: # will increase number of walkers/chains if needed
nwalkers = 2*nparam
print("\n I'm increasing number of walkers")
logf.write("\n Number of walkers = "+str(nwalkers))
logf.write("\n Number of steps per walker = "+str(nsteps))
logf.write("\n ... of which the first "+str(nburn)+" are considered in the burn-in phase")
steps_used = (nsteps-nburn)*nwalkers
logf.write("\n Therefore, number of samples used = "+str(steps_used))
# PROPOSAL DISTRIBUTION
pars, proposal_center = [], []
for i in meta_prefit.keys(): # Converting dictionary to ordered list
pars.append(i)
proposal_center.append(meta_prefit[i])
prop_str = ""
for i in meta_prefit:
prop_str = prop_str+" ("+i+": "+str(meta_prefit[i])+")"
prop_str = "\n Initial proposal for each parameter = "+prop_str
print(prop_str)
logf.write(prop_str)
# starting point for all walkers in a ball around the suspected centre
proposal_dist = [proposal_center + 1.e-2*random.randn(nparam) for i in range(nwalkers)]
for i in range(nwalkers):
for j in range(nparam):
if proposal_dist[i][j] < 0:
proposal_dist[i][j] = 0.001 # some lower bound starting point
# RUN EMCEE
print("\n *** running emcee ***")
sampler = EnsembleSampler(nwalkers, nparam, lnprob, args=(C0, P, D, t_steps, pops))
sampler.run_mcmc(proposal_dist, nsteps)
# POST EMCEE DIAGNOSTICS
samples = sampler.chain[:, nburn:, :].reshape((-1, nparam))
steps_used = samples.shape[0]
logf.write("\n Number of samples used = "+str(steps_used))
# Autocorrelation time
auto_time = sampler.acor
auto_str = ""
for i in range(nparam):
auto_str = auto_str+" "+str(auto_time[i])
auto_str = "\n\n Autocorrelation time for each parameter = "+auto_str
print(auto_str)
logf.write(auto_str)
# Acceptance fraction
accept_frac = sampler.acceptance_fraction
accf_str = "\n Acceptance fractions = "
for i in range(nwalkers):
accf_str = accf_str+" "+str(accept_frac[i])
print(accf_str)
logf.write(accf_str)
# CHAIN PLOT OF MCMC
figwalkers = plt.figure()
npar_plt = min(4, nparam)
nwalk_plt = min(20, nwalkers)
axes_plt = empty(npar_plt, dtype=object)
step = arange(nsteps)
for i in arange(npar_plt):
axes_plt[i] = figwalkers.add_subplot(npar_plt, 1, i+1)
axes_plt[i] = plt.gca()
for i in arange(npar_plt):
k = i
for j in arange(nwalk_plt): # or all nwalkers
position_plt = sampler.chain[j, :, k]
axes_plt[i].plot(step,position_plt, '-')
label_plt = 'par '+str(i)
axes_plt[i].set_xlabel(label_plt)
axes_plt[i].set_ylim(amin(sampler.chain[:nwalk_plt-1, :, k]), amax(sampler.chain[:nwalk_plt-1, :, k]))
figwalkers.savefig(storage+"/"+fn_chains, format="png")
"""
# DEBUG: USE PRIOR DISTRIBUTION INSTEAD OF POSTERIOR/MCMC RESULT
samples = empty([steps_used,nparam])
for i in arange(nparam):
samples[:,i] = random.lognormal(1.,1.,steps_used)
"""
# CORNER PLOT OF POSTERIOR SAMPLE
labels_mcmc = empty(nparam, dtype=object)
for k in range(nparam):
labels_mcmc[k] = pars[k]
fig_mcmc_corner = corner(samples, labels=labels_mcmc, truths=proposal_center)
fig_mcmc_corner.savefig(storage+"/"+fn_corner, format="png")
logf.close()
return samples
def test_errors(backend, nwalkers=32, ndim=3, nsteps=5, seed=1234):
# Set up the random number generator.
np.random.seed(seed)
with backend() as be:
# Initialize the ensemble, proposal, and sampler.
coords = np.random.randn(nwalkers, ndim)
sampler = EnsembleSampler(nwalkers, ndim, normal_log_prob, backend=be)
# Test for not running.
with pytest.raises(AttributeError):
sampler.get_chain()
with pytest.raises(AttributeError):
sampler.get_log_prob()
# What about not storing the chain.
sampler.run_mcmc(coords, nsteps, store=False)
with pytest.raises(AttributeError):
sampler.get_chain()
# Now what about if we try to continue using the sampler with an
# ensemble of a different shape.
sampler.run_mcmc(coords, nsteps, store=False)
coords2 = np.random.randn(nwalkers, ndim + 1)
with pytest.raises(ValueError):
list(sampler.run_mcmc(coords2, nsteps))
# Ensure that a warning is logged if the inital coords don't allow
# the chain to explore all of parameter space, and that one is not
# if we explicitly disable it, or the initial coords can.
with pytest.raises(ValueError):
sampler.run_mcmc(np.ones((nwalkers, ndim)), nsteps)
sampler.run_mcmc(np.ones((nwalkers, ndim)),
nsteps,
skip_initial_state_check=True)
sampler.run_mcmc(np.random.randn(nwalkers, ndim), nsteps)
ndim, nwalkers = 2, 6
pos = []
counter = -1
while len(pos) < nwalkers:
realization = [random_in_range(0, 1), random_in_range(0.01, 1)]# ,
#random_in_range(-0.01, 0.01)]
if np.isfinite(lnprior(realization)):
pos.append(realization)
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=8,
args=(target_slices, source1_slices,
source2_slices))
p0 = sampler.run_mcmc(pos, 1000)[0]
sampler.reset()
sampler.run_mcmc(p0, 1000)
sampler.pool.close()
samples = sampler.chain[:, 500:, :].reshape((-1, ndim))
#samples[:, 0] *= R_lambda
lower, m, upper = np.percentile(samples[:, 0], [16, 50, 84])
band_results['f_S_lower'] = m - lower
band_results['f_S'] = m
band_results['f_S_upper'] = upper - m
band_results['yerr'] = np.median(samples[:, 1])
corner(samples, labels=['$f_S$', '$f$'])#, '$\Delta \lambda$'])
results = curve_fit(bkplw, k, plaw, p0=(np.log10(1e3), 0.1, 0.0, -2.),
maxfev=100000)
print results[0]
p.loglog(vcs.vel_freqs, vcs.ps1D, 'bD')
p.loglog(k, 10**bkplw(k, *results[0]), 'r')
p.show()
from emcee import EnsembleSampler
ndim = 4
nwalkers = 100
pos = [results[0] + 1e-4*np.random.randn(ndim) for i in range(nwalkers)]
sampler = EnsembleSampler(nwalkers, ndim, fit_func, args=(plaw, k))
sampler.run_mcmc(pos, 1e3)
samples = sampler.chain.reshape((-1, ndim))
# Remove the burn-in
samples = samples[200:, :]
import triangle
fig = triangle.corner(samples)
p.show()
print samples.mean(axis=0)
p.loglog(vcs.vel_freqs, vcs.ps1D, 'bD')
p.loglog(k, 10**bkplw(k, *results[0]), 'r')
p.loglog(k, 10**bkplw(k, *samples.mean(axis=0)), 'g')
p.grid(True)
def sample(self, lnl):
# set up output file
if self.output_file and mpi.is_master():
_output_file = open(self.output_file, "wb")
protocol = pickle.HIGHEST_PROTOCOL
pickle.dump(obj=list(
chain(['lnl', 'weight'], self.sampled.keys(),
self.output_extra_params.keys())),
file=_output_file,
protocol=protocol)
dtypes = ','.join([dtype(float).name] * (2 + len(self.sampled)) +
list(self.output_extra_params.values()))
samples = {
i: empty(self.output_freq, dtypes)
for i in range(self.nwalkers)
}
# distribute walkers initially according to covariance estimate
pos = multivariate_normal([v.start for v in self.sampled.values()],
self.cov_est,
size=self.nwalkers)
# diferent sign convention with emcee
def lnprob(x):
l, p = lnl(*x)
return -l, p
# step each walker once, yield them all one-by-one, repeat
weight = ones(self.nwalkers)
isample = zeros(self.nwalkers, dtype=int)
from emcee import EnsembleSampler
sampler = EnsembleSampler(self.nwalkers,
len(self.sampled),
lnprob,
pool=self.pool)
nsteps = int(ceil(self.num_samples / self.nwalkers))
for i in range(nsteps):
posnext, prob, state, blobs = sampler.run_mcmc(pos, 1)
for iwalker, (x, xnext, l,
params) in enumerate(zip(pos, posnext, prob, blobs)):
if (x == xnext).all() and i != nsteps - 1:
weight[iwalker] += 1
else:
yield sample(-l, x, weight[iwalker])
# write to file once every `self.output_freq` accepted steps (per walker)
if self.output_file and mpi.is_master():
row = tuple(
chain(
[-l, weight[iwalker]], x,
[params[k] for k in self.output_extra_params]))
samples[iwalker][isample[iwalker]] = row
isample[iwalker] += 1
if isample[
iwalker] >= self.output_freq or i == nsteps - 1:
pickle.dump(
(iwalker, samples[iwalker][:isample[iwalker]]),
_output_file, protocol)
_output_file.flush()
isample[iwalker] = 0
weight[iwalker] = 1
pos = posnext
print(lnprob(np.array([6302, 4.38, 0.1, -39.54, 5.6, -12.221])))
# # Use vanilla emcee to do the sampling
from emcee import EnsembleSampler
#
ndim = 6
nwalkers = 4 * ndim
#
# # Load values from config file.
# # Add scatter in
#
p0 = np.array([ np.random.uniform(6200, 6400, nwalkers),
np.random.uniform(4.0, 4.49, nwalkers),
np.random.uniform(-0.2, -0.1, nwalkers),
np.random.uniform(-5., -4., nwalkers),
np.random.uniform(4.0, 6.0, nwalkers),
np.random.uniform(-12.81, -12.80, nwalkers)]).T
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=mp.cpu_count()-1)
#
# # burn in
pos, prob, state = sampler.run_mcmc(p0, args.samples)
sampler.reset()
print("Burned in")
#
# actual run
pos, prob, state = sampler.run_mcmc(pos, args.samples)
# Save the last position of the walkers
np.save("walkers_emcee.npy", pos)
np.save("eparams_emcee.npy", sampler.flatchain)
import numpy as np
from emcee import EnsembleSampler
def lnprob(p):
x, y = p
lnp = -((1.0 - x)**2 + 100 * (y - x**2)**2)
return lnp
ndim, nwalkers = 2, 40
p0 = np.array([np.random.rand(ndim) for i in range(nwalkers)])
sampler = EnsembleSampler(nwalkers, ndim, lnprob)
p0, prob, state = sampler.run_mcmc(p0, 10000)
#
sampler.reset()
#
p0, prob, state = sampler.run_mcmc(p0, 10000)
#
np.save("chain.npy", sampler.chain)
h5chain = HDFBackend('chains/' + name + str(nwalkers) + 'x' + str(nsteps) +
'.h5')
try:
pos0 = h5chain.get_chain()[-1] #continue existing chains...
nsteps -= len(h5chain.get_chain()) #...for missing steps only
if nsteps <= 0:
raise ValueError("Chain is already complete.")
sampler = EnsembleSampler(nwalkers,
ndim,
Likelihood,
pool=pool,
backend=h5chain)
sampler.run_mcmc(pos0, nsteps)
pool.close()
except AttributeError:
pos0 = np.random.uniform(ranges_min, ranges_max,
(nwalkers, len(ranges_max)))
sampler = EnsembleSampler(nwalkers,
ndim,
Likelihood,
pool=pool,
backend=h5chain)
sampler.run_mcmc(pos0, nsteps)
pool.close()
except ValueError:
return -np.inf
# Use the KDE kernel to evaluate how well this point fits based upon our temp, lL posterior.
lnp = kernel.logpdf([temp, lL])
return lnp
from ScottiePippen.grids import model_dict
for grid_name in config["grids"]:
print(grid_name)
grid = model_dict[grid_name](**config[grid_name])
sampler = EnsembleSampler(nwalkers, ndim, lnprob, args=[grid])
pos, prob, state = sampler.run_mcmc(p0, config["samples"])
# Save the actual chain of samples
np.save(config["outfile"].format(grid_name), sampler.chain)
# grid = DartmouthPMS(age_range=[0.1, 100], mass_range=[0.1, 1.8])
# grid = PISA(age_range=[0.1, 100], mass_range=[0.1, 1.8])
# grid = Baraffe15(age_range=[0.1, 100], mass_range=[0.1, 1.4])
# grid = Seiss(age_range=[0.1, 100], mass_range=[0.1, 1.8])
# grid.load()
# grid.setup_interpolator()
# Profile code here
# randomly sampled points from parameter ranges
pos0 = np.empty([nwalkers, ndim])
for w in range(nwalkers):
for p, par in enumerate(LLargs):
pL, pR = priors[par]
p0 = np.random.uniform(low=pL, high=pR)
pos0[w, p] = p0
from emcee import EnsembleSampler
# multi-threads computation
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=1)
# Run initial burn-in steps
pos, prob, state = sampler.run_mcmc(pos0, 200)
# Reset the chain to remove the burn-in samples
sampler.reset()
# Starting from the final position in the burn-in chain, sample for nsteps.
sampler.run_mcmc(pos, nsteps, rstate0=state)
###############################################################################
# statistical inference from sampling the loglikelihood parameter space
###############################################################################
# instruction to save the result of sampling:
# - the coordinates of the sampled points in the chain
# - the corresponding logprobability
np.save('results/{0}/{1}/samples_{0}_{1}'.format(ker, dwarf), sampler.chain)
def fit_exp_data(theta_0, mcmc_algo="DE-MC"):
"""!
@brief Fit an exponential model to some data
"""
# get data
t_data, y_data = read_data()
sigma_0 = 1e-4
theta_0 = np.array(list(theta_0) + [sigma_0])
varepsilon = np.asarray([1e-2, 1e-2, 1e-3, 1e-8, 1e-9]) * 1e-2
# Run MCMC
n_chains = 6
my_mcmc = DreamMpi(lnprob,
theta_0,
n_chains=n_chains,
mpi_comm=comm,
n_cr_gen=200,
burnin_gen=4000,
varepsilon=varepsilon,
ln_kwargs={
'y_data': y_data,
't': t_data
})
my_mcmc.run_mcmc(1000 * 100, suffle=True, flip=0.5)
# Run Emcee MCMC
if comm.rank == 0:
ndim, nwalkers = 5, 100
pos = [theta_0 + 1e-6 * np.random.randn(ndim) for i in range(nwalkers)]
sampler = EnsembleSampler(nwalkers,
ndim,
lnprob,
args=(t_data, y_data))
sampler.run_mcmc(pos, 1000) # 100 * 1000 tot samples
samples = sampler.chain[:, 400:, :].reshape((-1, ndim))
fig = corner.corner(
samples,
labels=["$\tau$", "$c_\infty$", "$c_0$", "l", r"$\sigma$"])
fig.savefig("exp_emcee_out.png")
print("=== EMCEE ===")
print("Emcee mean acceptance fraction: {0:.3f}".format(
np.mean(sampler.acceptance_fraction)))
# view results
print("=== Opti values by Bipymc MCMC ===")
print("[tau, c_inf, c_0, leakage]:")
theta_est, sig_est, chain = my_mcmc.param_est(n_burn=400 * 100)
theta_est_, sig_est_, full_chain = my_mcmc.param_est(n_burn=0)
if comm.rank == 0:
print("MCMC Esimated params: %s" % str(theta_est))
print("MCMC Estimated params sigma: %s " % str(sig_est))
print("Acceptance fraction: %f" % my_mcmc.acceptance_fraction)
print("P_cr: %s" % str(my_mcmc.p_cr))
# vis the parameter estimates
mc_plot.plot_mcmc_params(
chain,
labels=[r"$\tau$", "$c_\infty$", "$c_0$", "leak", r"$\sigma$"],
savefig='exp_mcmc_out.png',
)
# vis the full chain
mc_plot.plot_mcmc_indep_chains(
full_chain,
n_chains,
labels=[r"$\tau$", "$c_\infty$", "$c_0$", "leak", r"$\sigma$"],
savefig='exp_chain_out.png',
)
# plot trajectories
xdata, ydata = read_data()
plt.close()
i = 0
reduced_model = lambda t, tau, c_inf, c_0, set_leak, sigma: exp_c1_model_full(
tau, c_inf, c_0, set_leak, t)
for sample in chain:
i += 1
plt.plot(xdata,
np.abs(reduced_model(xdata, *sample) - sample[1]) /
sample[1],
lw=0.2,
alpha=0.02,
c='b')
if i > 1000:
break
plt.title("MCMC Fit")
plt.plot(xdata,
np.abs(reduced_model(xdata, *theta_est) - theta_est[1]) /
theta_est[1],
lw=1.0,
alpha=0.8,
label="MCMC",
c='b')
plt.scatter(xdata,
np.abs(ydata - theta_est[1]) / theta_est[1],
s=2,
alpha=0.9,
c='r',
label="data")
plt.ylabel("$|C_t - c_\infty| /C_\infty$")
plt.xlabel("time")
plt.legend()
plt.savefig("mcmc_trajectories.png", dpi=160)
# plot the slopes at the end
pass
# compute and plot c_o/c_inf
c_inf_samples = chain[:, 1]
c_0_samples = chain[:, 2]
c_ratio = c_0_samples / c_inf_samples
c_ratio_avg, c_ratio_sd = np.mean(c_ratio), np.std(c_ratio)
print("c_0/c_inf estimate: %0.3e +/- %0.3e" %
(c_ratio_avg, c_ratio_sd))
#a=scipy.optimize.minimize(tominimize,p0,method='Nelder-Mead')
#a=scipy.optimize.minimize(tominimize,a['x'],method='Nelder-Mead')
#a=scipy.optimize.minimize(tominimize,p0,method='Powell')
#a=scipy.optimize.minimize(tominimize,p0,method='CG')
#a=scipy.optimize.minimize(tominimize,p0,method='BFGS',bounds=p_range)
#p0=a[x]
nwalkers = 280
ndim = 14
nthreads = 20
iterations = 2000
pos = np.array([(1. + 2.e-1 * np.random.random(ndim)) * p0
for i in range(nwalkers)])
import os
os.environ["OMP_NUM_THREADS"] = "1"
with Pool(processes=nthreads) as pool:
sampler = EnsembleSampler(nwalkers, ndim, lnpostfnbis, pool=pool)
pos, prob, state = sampler.run_mcmc(pos, iterations, progress=True)
samples = sampler.chain
np.save(
'results/optimization/optigal_{}_{}_{}'.format(ndim, nwalkers, iterations),
(samples, p_range[:, 0], p_range[:, 1], labels))
#np.save('firsttestopti.npy',sampler.chain)
r"$\Delta$Dec"
]
else:
labels = [
r"$f_0$", r"$\sigma$", r"$incl$", r"PA", r"$\Delta$RA", r"$\Delta$Dec"
]
### do mcmc fit
print("\nStarting fit...\n")
start = time.time()
prob, state = None, None
for j in range(nsteps, tsteps + 1, nsteps):
### get last 500 samples
pos, prob, state = sampler.run_mcmc(pos,
nsteps,
rstate0=state,
lnprob0=prob)
samples = sampler.chain[:, -500:, :].reshape((-1, ndim))
### plot corner plot ever nsteps
fig = corner.corner(samples,
labels=labels,
show_titles=True,
quantiles=[0.16, 0.50, 0.84],
label_kwargs={
'labelpad': 20,
'fontsize': 0
},
fontsize=8)
fig.savefig(os.path.join(outdir, "corner_{}.png".format(j)))
plt.close('all')
def run_mcmc(self,
obs,
obs_err=0,
obs_tag=None,
p0=None,
n_burnin=(100, 100),
n_step=1000,
lnlike=None,
lnprior=None,
lnlike_kwargs={},
lnprior_kwargs={},
pos_eps=.1,
full=True,
shrink="max"):
""" run MCMC for (obs, obs_err, obs_tag)
Parameters
----------
obs:
observable
obs_err:
error of observation
obs_tag:
array(size(obs), 1 for good, 0 for bad.
p0:
initial points
n_burnin:
int/sequence, do 1 or multiple times of burn in process
n_step:
running step
lnlike:
lnlike(x, *args) is the log likelihood function
lnprior:
lnpost(x) is the log prior
pos_eps:
random magnitude for starting position
full:
if True, return sampler, pos, prob, state
otherwise, return sampler
shrink:
default "max": shrink to the maximum likelihood position
Return
------
EnsembleSampler instance
"""
if obs_tag is None:
# default obs_tag
obs_tag = np.isfinite(obs)
else:
obs_tag = np.isfinite(obs) & obs_tag
# cope with bad obs
if np.sum(obs_tag) == 0:
return None
if p0 is None:
# do best match for starting position
p0 = self.best_match(obs, obs_err)
print("@Regli.best_match: ", p0)
if lnlike is None:
# default gaussian likelihood function
lnlike = default_lnlike
print("@Regli: using the default gaussian *lnlike* function...")
if lnprior is None:
# no prior is specified
lnpost = lnlike
print("@Regli: No prior is adopted ...")
else:
# use user-defined prior
print("@Regli: using user-defined *lnprior* function...")
def lnpost(*_args, **_kwargs):
lnpost_value = np.float(lnprior(_args[0], **_kwargs["lnprior_kwargs"])) + \
lnlike(*_args, **_kwargs["lnlike_kwargs"])
if np.isfinite(lnpost_value):
return lnpost_value
else:
return -np.inf
# set parameters for sampler
ndim = self.ndim
nwalkers = 2 * ndim
# initiate sampler
sampler = EnsembleSampler(nwalkers,
ndim,
lnpostfn=lnpost,
args=(self, obs, obs_err, obs_tag),
kwargs=dict(lnprior_kwargs=lnprior_kwargs,
lnlike_kwargs=lnlike_kwargs))
# generate random starting positions
pos0 = rand_pos(p0, nwalkers=nwalkers, eps=pos_eps)
if isinstance(n_burnin, collections.Iterable):
# [o] multiple burn-ins
for n_burnin_ in n_burnin:
# run mcmc
print("@Regli: running burn-in [{}]...".format(n_burnin_))
pos, prob, state = sampler.run_mcmc(pos0, n_burnin_)
# shrink to a new position
if shrink == "max":
p1 = sampler.flatchain[np.argmax(
sampler.flatlnprobability)]
else:
p1 = np.median(pos, axis=0)
pos_std = np.std(sampler.flatchain, axis=0) * 0.5
# reset sampler
sampler.reset()
# randomly generate new start position
pos0 = rand_pos(p1, nwalkers=nwalkers, eps=pos_std)
else:
# [o] single burn-in
# run mcmc
print("@Regli: running burn-in [{}]...".format(n_burnin))
pos, prob, state = sampler.run_mcmc(pos0, n_burnin)
# shrink to a new position
if shrink == "max":
p1 = sampler.flatchain[np.argmax(sampler.flatlnprobability)]
else:
p1 = np.median(pos, axis=0)
pos_std = np.std(sampler.flatchain, axis=0) * 0.5
# reset sampler
sampler.reset()
# randomly generate new start position
pos0 = rand_pos(p1, nwalkers=nwalkers, eps=pos_std)
# run mcmc
print("@Regli: running chains [{}]...".format(n_step))
pos, prob, state = sampler.run_mcmc(pos0, n_step)
if full:
# return full result
return sampler, pos, prob, state
else:
# return sampler only
return sampler
ndim, nwalkers = 2, 10
pos = []
counter = -1
while len(pos) < nwalkers:
realization = [random_in_range(0, 1), random_in_range(0.01, 1)]
if np.isfinite(lnprior(realization)):
pos.append(realization)
sampler = EnsembleSampler(nwalkers, ndim, lnprob, threads=8,
args=(target_slices, source1_slices,
source2_slices))
sampler.run_mcmc(pos, 2000)
samples = sampler.chain[:, 1000:, :].reshape((-1, ndim))
samples[:, 0] *= R_lambda
lower, m, upper = np.percentile(samples[:, 0], [16, 50, 84])
band_results['f_S_lower'] = m - lower
band_results['f_S'] = m
band_results['f_S_upper'] = upper - m
band_results['yerr'] = np.median(samples[:, 1])
corner(samples, labels=['$f_S$', '$f$'])
plt.savefig('plots/{0}_{1}_{2}.pdf'.format(star, int(band.core.value),
time.replace(':', '_')),
bbox_inches='tight')
