def __init__(self, model, nwalkers, checkpoint_interval=None,
logpost_function=None, nprocesses=1, use_mpi=False):
self.model = model
# create a wrapper for calling the model
if logpost_function is None:
logpost_function = 'logposterior'
model_call = models.CallModel(model, logpost_function)
# Set up the pool
if nprocesses > 1:
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.count = nprocesses
# set up emcee
self._nwalkers = nwalkers
ndim = len(model.variable_params)
self._sampler = emcee.EnsembleSampler(nwalkers, ndim, model_call,
pool=pool)
# emcee uses it's own internal random number generator; we'll set it
# to have the same state as the numpy generator
rstate = numpy.random.get_state()
self._sampler.random_state = rstate
self._checkpoint_interval = checkpoint_interval
def sampler_from_cli(opts, likelihood_evaluator, pool=None):
"""Parses the given command-line options to set up a sampler.
Parameters
----------
opts : object
ArgumentParser options.
likelihood_evaluator : LikelihoodEvaluator
The likelihood evaluator to use with the sampler.
Returns
-------
pycbc.inference.sampler
A sampler initialized based on the given arguments.
"""
# Used to help paralleize over multiple cores / MPI
if opts.nprocesses > 1:
likelihood._global_instance = likelihood_evaluator
likelihood_call = likelihood._call_global_likelihood
else:
likelihood_call = None
sclass = pycbc.inference.sampler.samplers[opts.sampler]
pool = choose_pool(mpi=opts.use_mpi, processes=opts.nprocesses)
if pool is not None:
pool.count = opts.nprocesses
return sclass.from_cli(opts, likelihood_evaluator,
pool=pool, likelihood_call=likelihood_call)
def __init__(self, model, nwalkers,
checkpoint_interval=None, checkpoint_signal=None,
logpost_function=None, nprocesses=1, use_mpi=False):
self.model = model
# create a wrapper for calling the model
if logpost_function is None:
logpost_function = 'logposterior'
model_call = models.CallModel(model, logpost_function)
# Set up the pool
if nprocesses > 1:
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.count = nprocesses
# set up emcee
self.nwalkers = nwalkers
ndim = len(model.variable_params)
self._sampler = emcee.EnsembleSampler(nwalkers, ndim, model_call,
pool=pool)
# emcee uses it's own internal random number generator; we'll set it
# to have the same state as the numpy generator
rstate = numpy.random.get_state()
self._sampler.random_state = rstate
self._checkpoint_interval = checkpoint_interval
self._checkpoint_signal = checkpoint_signal
def sampler_from_cli(opts, likelihood_evaluator, pool=None):
"""Parses the given command-line options to set up a sampler.
Parameters
----------
opts : object
ArgumentParser options.
likelihood_evaluator : LikelihoodEvaluator
The likelihood evaluator to use with the sampler.
Returns
-------
pycbc.inference.sampler
A sampler initialized based on the given arguments.
"""
# Used to help paralleize over multiple cores / MPI
if opts.nprocesses > 1:
likelihood._global_instance = likelihood_evaluator
likelihood_call = likelihood._call_global_likelihood
else:
likelihood_call = None
sclass = pycbc.inference.sampler.samplers[opts.sampler]
# check for consistency
if opts.skip_burn_in and opts.min_burn_in is not None:
raise ValueError("both skip-burn-in and min-burn-in specified")
pool = choose_pool(mpi=opts.use_mpi, processes=opts.nprocesses)
if pool is not None:
pool.count = opts.nprocesses
return sclass.from_cli(opts, likelihood_evaluator,
pool=pool, likelihood_call=likelihood_call)
def __init__(self,
model,
nlive,
dlogz,
nprocesses=1,
loglikelihood_function=None,
use_mpi=False,
**kwargs):
self.model = model
# Set up the pool
model_call = DynestyModel(model, loglikelihood_function)
if nprocesses > 1:
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
log_likelihood_call = _call_global_loglikelihood
prior_call = _call_global_logprior
else:
prior_call = model_call.prior_transform
log_likelihood_call = model_call.log_likelihood
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.size = nprocesses
self.nlive = nlive
self.dlogz = dlogz
self.names = model.sampling_params
self.ndim = len(model.sampling_params)
self.checkpoint_file = None
self._sampler = dynesty.NestedSampler(log_likelihood_call,
prior_call,
self.ndim,
nlive=self.nlive,
dlogz=self.dlogz,
pool=pool,
**kwargs)
def sampler_from_cli(opts, model, pool=None):
"""Parses the given command-line options to set up a sampler.
Parameters
----------
opts : object
ArgumentParser options.
model : model
The model to use with the sampler.
Returns
-------
gwin.sampler
A sampler initialized based on the given arguments.
"""
# create a wrapper for the model
model = models.CallModel(model, opts.logpost_function)
# Used to help paralleize over multiple cores / MPI
if opts.nprocesses > 1:
models._global_instance = model
model_call = models._call_global_model
else:
model_call = None
sclass = sampler.samplers[opts.sampler]
pool = choose_pool(mpi=opts.use_mpi, processes=opts.nprocesses)
if pool is not None:
pool.count = opts.nprocesses
return sclass.from_cli(opts, model, pool=pool, model_call=model_call)
def __init__(self, model, nlive, nprocesses=1,
loglikelihood_function=None, use_mpi=False, run_kwds=None,
**kwargs):
self.model = model
log_likelihood_call, prior_call = setup_calls(
model,
nprocesses=nprocesses,
loglikelihood_function=loglikelihood_function)
# Set up the pool
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.size = nprocesses
self.run_kwds = {} if run_kwds is None else run_kwds
self.nlive = nlive
self.names = model.sampling_params
self.ndim = len(model.sampling_params)
self.checkpoint_file = None
if self.nlive < 0:
# Interpret a negative input value for the number of live points
# (which is clearly an invalid input in all senses)
# as the desire to dynamically determine that number
self._sampler = dynesty.DynamicNestedSampler(log_likelihood_call,
prior_call, self.ndim,
pool=pool, **kwargs)
else:
self._sampler = dynesty.NestedSampler(log_likelihood_call,
prior_call, self.ndim,
nlive=self.nlive,
pool=pool, **kwargs)
def sampler_from_cli(opts, likelihood_evaluator, pool=None):
"""Parses the given command-line options to set up a sampler.
Parameters
----------
opts : object
ArgumentParser options.
likelihood_evaluator : LikelihoodEvaluator
The likelihood evaluator to use with the sampler.
Returns
-------
gwin.sampler
A sampler initialized based on the given arguments.
"""
# Used to help paralleize over multiple cores / MPI
if opts.nprocesses > 1:
likelihood._global_instance = likelihood_evaluator
likelihood_call = likelihood._call_global_likelihood
else:
likelihood_call = None
sclass = sampler.samplers[opts.sampler]
pool = choose_pool(mpi=opts.use_mpi, processes=opts.nprocesses)
if pool is not None:
pool.count = opts.nprocesses
return sclass.from_cli(opts,
likelihood_evaluator,
pool=pool,
likelihood_call=likelihood_call)
def __init__(self, model, ntemps, nwalkers, betas=None,
checkpoint_interval=None, checkpoint_signal=None,
loglikelihood_function=None,
nprocesses=1, use_mpi=False):
self.model = model
# create a wrapper for calling the model
if loglikelihood_function is None:
loglikelihood_function = 'loglikelihood'
# frustratingly, emcee_pt does not support blob data, so we have to
# turn it off
model_call = models.CallModel(model, loglikelihood_function,
return_all_stats=False)
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
prior_call = models._call_global_model_logprior
self.pool = choose_pool(mpi=use_mpi, processes=nprocesses)
# construct the sampler: PTSampler needs the likelihood and prior
# functions separately
ndim = len(model.variable_params)
self._sampler = emcee.PTSampler(ntemps, nwalkers, ndim,
model_call, prior_call, pool=self.pool,
betas=betas)
self.nwalkers = nwalkers
self._ntemps = ntemps
self._checkpoint_interval = checkpoint_interval
self._checkpoint_signal = checkpoint_signal
def __init__(self,
model,
nlive,
nprocesses=1,
loglikelihood_function=None,
use_mpi=False,
run_kwds=None,
**kwargs):
self.model = model
log_likelihood_call, prior_call = setup_calls(
model,
nprocesses=nprocesses,
loglikelihood_function=loglikelihood_function)
# Set up the pool
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.size = nprocesses
self.run_kwds = {} if run_kwds is None else run_kwds
self.nlive = nlive
self.names = model.sampling_params
self.ndim = len(model.sampling_params)
self.checkpoint_file = None
self._sampler = dynesty.NestedSampler(log_likelihood_call,
prior_call,
self.ndim,
nlive=self.nlive,
pool=pool,
**kwargs)
def __init__(self, model, nchains, ntemps=None, betas=None,
proposals=None, default_proposal=None,
default_proposal_args=None, seed=None,
swap_interval=1,
checkpoint_interval=None, checkpoint_signal=None,
loglikelihood_function=None,
nprocesses=1, use_mpi=False):
# create the betas if not provided
if betas is None:
betas = default_beta_ladder(len(model.variable_params),
ntemps=ntemps)
self.model = model
# create a wrapper for calling the model
model_call = _EpsieCallModel(model, loglikelihood_function)
# Set up the pool
if nprocesses > 1:
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.count = nprocesses
# initialize the sampler
self._sampler = ParallelTemperedSampler(
model.sampling_params, model_call, nchains, betas=betas,
swap_interval=swap_interval,
proposals=proposals, default_proposal=default_proposal,
default_proposal_args=default_proposal_args,
seed=seed, pool=pool)
# set other parameters
self._nwalkers = nchains
self._ntemps = ntemps
self._checkpoint_interval = checkpoint_interval
self._checkpoint_signal = checkpoint_signal
def __init__(self, model, ntemps, nwalkers, betas=None,
checkpoint_interval=None, checkpoint_signal=None,
loglikelihood_function=None,
nprocesses=1, use_mpi=False):
self.model = model
# create a wrapper for calling the model
if loglikelihood_function is None:
loglikelihood_function = 'loglikelihood'
# frustratingly, emcee_pt does not support blob data, so we have to
# turn it off
model_call = models.CallModel(model, loglikelihood_function,
return_all_stats=False)
# Set up the pool
if nprocesses > 1:
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
prior_call = models._call_global_model_logprior
else:
prior_call = models.CallModel(model, 'logprior',
return_all_stats=False)
pool = choose_pool(mpi=use_mpi, processes=nprocesses)
if pool is not None:
pool.count = nprocesses
# construct the sampler: PTSampler needs the likelihood and prior
# functions separately
ndim = len(model.variable_params)
self._sampler = emcee.PTSampler(ntemps, nwalkers, ndim,
model_call, prior_call, pool=pool,
betas=betas)
self._nwalkers = nwalkers
self._ntemps = ntemps
self._checkpoint_interval = checkpoint_interval
self._checkpoint_signal = checkpoint_signal
def __init__(self,
model,
nlive,
nprocesses=1,
checkpoint_time_interval=None,
maxcall=None,
loglikelihood_function=None,
use_mpi=False,
no_save_state=False,
run_kwds=None,
extra_kwds=None,
internal_kwds=None,
**kwargs):
self.model = model
self.no_save_state = no_save_state
log_likelihood_call, prior_call = setup_calls(
model,
loglikelihood_function=loglikelihood_function,
copy_prior=True)
# Set up the pool
self.pool = choose_pool(mpi=use_mpi, processes=nprocesses)
self.maxcall = maxcall
self.checkpoint_time_interval = checkpoint_time_interval
self.run_kwds = {} if run_kwds is None else run_kwds
self.extra_kwds = {} if extra_kwds is None else extra_kwds
self.internal_kwds = {} if internal_kwds is None else internal_kwds
self.nlive = nlive
self.names = model.sampling_params
self.ndim = len(model.sampling_params)
self.checkpoint_file = None
# Enable checkpointing if checkpoint_time_interval is set in config
# file in sampler section
if self.checkpoint_time_interval:
self.run_with_checkpoint = True
if self.maxcall is None:
self.maxcall = 5000 * self.pool.size
logging.info(
"Checkpointing enabled, will verify every %s calls"
" and try to checkpoint every %s seconds", self.maxcall,
self.checkpoint_time_interval)
else:
self.run_with_checkpoint = False
# Check for cyclic boundaries
periodic = []
cyclic = self.model.prior_distribution.cyclic
for i, param in enumerate(self.variable_params):
if param in cyclic:
logging.info('Param: %s will be cyclic', param)
periodic.append(i)
if len(periodic) == 0:
periodic = None
# Check for reflected boundaries. Dynesty only supports
# reflection on both min and max of boundary.
reflective = []
reflect = self.model.prior_distribution.well_reflected
for i, param in enumerate(self.variable_params):
if param in reflect:
logging.info("Param: %s will be well reflected", param)
reflective.append(i)
if len(reflective) == 0:
reflective = None
if 'sample' in extra_kwds:
if 'rwalk2' in extra_kwds['sample']:
dynesty.dynesty._SAMPLING["rwalk"] = sample_rwalk_mod
dynesty.nestedsamplers._SAMPLING["rwalk"] = sample_rwalk_mod
extra_kwds['sample'] = 'rwalk'
if self.nlive < 0:
# Interpret a negative input value for the number of live points
# (which is clearly an invalid input in all senses)
# as the desire to dynamically determine that number
self._sampler = dynesty.DynamicNestedSampler(log_likelihood_call,
prior_call,
self.ndim,
pool=self.pool,
reflective=reflective,
periodic=periodic,
**extra_kwds)
self.run_with_checkpoint = False
logging.info("Checkpointing not currently supported with"
"DYNAMIC nested sampler")
else:
self._sampler = dynesty.NestedSampler(log_likelihood_call,
prior_call,
self.ndim,
nlive=self.nlive,
reflective=reflective,
periodic=periodic,
pool=self.pool,
**extra_kwds)
self._sampler.kwargs.update(internal_kwds)
# properties of the internal sampler which should not be pickled
self.no_pickle = [
'loglikelihood', 'prior_transform', 'propose_point',
'update_proposal', '_UPDATE', '_PROPOSE', 'evolve_point',
'use_pool', 'queue_size', 'use_pool_ptform', 'use_pool_logl',
'use_pool_evolve', 'use_pool_update', 'pool', 'M'
]
def __init__(self,
model,
nwalkers,
ntemps=None,
Tmax=None,
betas=None,
adaptive=False,
adaptation_lag=None,
adaptation_time=None,
scale_factor=None,
loglikelihood_function=None,
checkpoint_interval=None,
checkpoint_signal=None,
nprocesses=1,
use_mpi=False):
self.model = model
ndim = len(model.variable_params)
# create temperature ladder if needed
if ntemps is None and Tmax is None and betas is None:
raise ValueError("must provide either ntemps/Tmax or betas")
if betas is None:
betas = ptemcee.make_ladder(ndim, ntemps=ntemps, Tmax=Tmax)
# construct the keyword arguments to pass; if a kwarg is None, we
# won't pass it, resulting in ptemcee's defaults being used
kwargs = {}
kwargs['adaptive'] = adaptive
kwargs['betas'] = betas
if adaptation_lag is not None:
kwargs['adaptation_lag'] = adaptation_lag
if adaptation_time is not None:
kwargs['adaptation_time'] = adaptation_time
if scale_factor is not None:
kwargs['scale_factor'] = scale_factor
# create a wrapper for calling the model
if loglikelihood_function is None:
loglikelihood_function = 'loglikelihood'
# frustratingly, ptemcee does not support blob data, so we have to
# turn it off
model_call = models.CallModel(model,
loglikelihood_function,
return_all_stats=False)
# these are used to help paralleize over multiple cores / MPI
models._global_instance = model_call
model_call = models._call_global_model
prior_call = models._call_global_model_logprior
self.pool = choose_pool(mpi=use_mpi, processes=nprocesses)
# construct the sampler
self._sampler = ptemcee.Sampler(nwalkers=nwalkers,
ndim=ndim,
logl=model_call,
logp=prior_call,
mapper=self.pool.map,
**kwargs)
self.nwalkers = nwalkers
self._ntemps = ntemps
self._checkpoint_interval = checkpoint_interval
self._checkpoint_signal = checkpoint_signal
# we'll initialize ensemble and chain to None
self._chain = None
self._ensemble = None
