def test_back_compat(seed=1234):
np.random.seed(seed)
coords = np.random.randn(16, 3)
log_prob = np.random.randn(len(coords))
blobs = np.random.randn(len(coords))
rstate = np.random.get_state()
state = State(coords, log_prob, blobs, rstate)
c, l, r, b = state
assert np.allclose(coords, c)
assert np.allclose(log_prob, l)
assert np.allclose(blobs, b)
assert all(np.allclose(a, b) for a, b in zip(rstate[1:], r[1:]))
state = State(coords, log_prob, None, rstate)
c, l, r = state
assert np.allclose(coords, c)
assert np.allclose(log_prob, l)
assert all(np.allclose(a, b) for a, b in zip(rstate[1:], r[1:]))
def test_live_dangerously(nwalkers=32, nsteps=3000, seed=1234):
warnings.filterwarnings("error")
# Set up the random number generator.
np.random.seed(seed)
state = State(np.random.randn(nwalkers, 2 * nwalkers),
log_prob=np.random.randn(nwalkers))
model = Model(None, lambda x: (np.zeros(len(x)), None), map, np.random)
proposal = moves.StretchMove()
# Test to make sure that the error is thrown if there aren't enough
# walkers.
with pytest.raises(RuntimeError):
proposal.propose(model, state)
# Living dangerously...
proposal.live_dangerously = True
proposal.propose(model, state)
def sample_ln_pdf(
self,
ln_pdf,
size=None,
sample_around=1.0,
nwalkers=50,
burn_in=20,
oversampling_factor=10,
):
"""Sample from a distribution given by ln(pdf)
This algorithm uses the :any:`emcee.EnsembleSampler`
Parameters
----------
ln_pdf : :any:`callable`
The logarithm of the Probability density function
of the given distribution, that takes a single argument
size : :class:`int` or :any:`None`, optional
sample size. Default: None
sample_around : :class:`float`, optional
Starting point for initial guess Default: 1.
nwalkers : :class:`int`, optional
The number of walkers in the mcmc sampler. Used for the
emcee.EnsembleSampler class.
Default: 100
burn_in : :class:`int`, optional
Number of burn-in runs in the mcmc algorithm.
Default: 100
oversampling_factor : :class:`int`, optional
To guess the sample number needed for proper results, we use a
factor for oversampling. The intern used sample-size is
calculated by
``sample_size = max(burn_in, (size/nwalkers)*oversampling_factor)``
So at least, as much as the burn-in runs.
Default: 10
"""
if size is None:
sample_size = burn_in
else:
sample_size = max(burn_in, (size / nwalkers) * oversampling_factor)
# initial guess
init_guess = (self.random.rand(nwalkers).reshape(
(nwalkers, 1)) * sample_around)
# initialize the sampler
sampler = mc.EnsembleSampler(nwalkers, 1, ln_pdf)
# burn in phase with saving of last position
##################### mc 2 and 3 compatibility
if MC_VER < 3: # pragma: no cover
burn_in_state, __, __ = sampler.run_mcmc(
pos0=init_guess, N=burn_in, rstate0=self.random.get_state())
else: # pragma: no cover
from emcee.state import State
initial_state = State(init_guess, copy=True)
initial_state.random_state = self.random.get_state()
burn_in_state = sampler.run_mcmc(initial_state=initial_state,
nsteps=burn_in)
##################### mc 2 and 3 compatibility
# reset after burn_in
sampler.reset()
# actual sampling
##################### mc 2 and 3 compatibility
if MC_VER < 3: # pragma: no cover
sampler.run_mcmc(
pos0=burn_in_state,
N=sample_size,
rstate0=self.random.get_state(),
)
samples = sampler.flatchain[:, 0]
else: # pragma: no cover
from emcee.state import State
initial_state = State(burn_in_state, copy=True)
initial_state.random_state = self.random.get_state()
sampler.run_mcmc(initial_state=initial_state, nsteps=sample_size)
samples = sampler.get_chain(flat=True)[:, 0]
##################### mc 2 and 3 compatibility
# choose samples according to size
return self.random.choice(samples, size)