def test_run_sampler_flags_if_marginalized_time_is_sampled(self):
like = bilby.gw.likelihood.GravitationalWaveTransient(
interferometers=self.interferometers,
waveform_generator=self.waveform_generator,
priors=self.prior,
time_marginalization=True,
)
new_prior = self.prior.copy()
new_prior["geocent_time"] = bilby.prior.Uniform(minimum=0, maximum=1)
for key, param in dict(
mass_1=31.0,
mass_2=29.0,
a_1=0.4,
a_2=0.3,
tilt_1=0.0,
tilt_2=0.0,
phi_12=1.7,
phi_jl=0.3,
theta_jn=0.4,
psi=2.659,
ra=1.375,
dec=-1.2108,
).items():
new_prior[key] = param
with self.assertRaises(
bilby.core.sampler.SamplingMarginalisedParameterError):
bilby.run_sampler(like, new_prior)
def test_run_ultranest(self):
# run using NestedSampler (with nlive specified)
_ = bilby.run_sampler(
likelihood=self.likelihood, priors=self.priors,
sampler="ultranest", nlive=100, save=False,
)
# run using ReactiveNestedSampler (with no nlive given)
_ = bilby.run_sampler(
likelihood=self.likelihood, priors=self.priors,
sampler='ultranest', save=False,
)
def test_run_cpnest(self):
_ = bilby.run_sampler(likelihood=self.likelihood,
priors=self.priors,
sampler='cpnest',
nlive=100,
save=False,
resume=False)
def run_sampler(self):
if self.scheduler.lower() == "condor":
signal.signal(signal.SIGALRM, handler=sighandler)
signal.alarm(self.periodic_restart_time)
likelihood, priors = self.get_likelihood_and_priors()
self.result = bilby.run_sampler(
likelihood=likelihood,
priors=priors,
sampler=self.sampler,
label=self.label,
outdir=self.result_directory,
conversion_function=self.parameter_generation,
injection_parameters=self.meta_data["injection_parameters"],
meta_data=self.meta_data,
result_class=self.result_class,
exit_code=CHECKPOINT_EXIT_CODE,
**self.sampler_kwargs,
)
if self.convert_to_flat_in_component_mass:
try:
result_reweighted = (
bilby.gw.prior.convert_to_flat_in_component_mass_prior(self.result)
)
result_reweighted.save_to_file()
except Exception as e:
logger.warning(
f"Unable to convert to the flat in component mass prior due to: {e}"
)
def test_run_kombine(self):
_ = bilby.run_sampler(likelihood=self.likelihood,
priors=self.priors,
sampler='kombine',
iterations=2500,
nwalkers=100,
save=False)
def test_run_emcee(self):
_ = bilby.run_sampler(likelihood=self.likelihood,
priors=self.priors,
sampler='emcee',
nsteps=1000,
nwalkers=10,
save=False)
def test_run_pymultinest(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="pymultinest",
nlive=100,
save=False,
)
def marginalize_over_redshift(self):
likelihood, priors = self.get_likelihood_and_priors()
self.marginalization_result = bilby.run_sampler(likelihood=likelihood,
priors=priors,
sampler="dynesty",
outdir=self.outdir,
**self.sampler_kwargs)
def test_run_nestle(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="nestle",
nlive=100,
save=False,
)
def test_run_pymc3(self):
_ = bilby.run_sampler(likelihood=self.likelihood,
priors=self.priors,
sampler='pymc3',
draws=50,
tune=50,
n_init=1000,
save=False)
def test_run_PTMCMCSampler(self):
_ = bilby.run_sampler(likelihood=self.likelihood,
priors=self.priors,
sampler='PTMCMCsampler',
Niter=101,
burn=2,
isave=100,
save=False)
def test_run_pypolychord(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="pypolychord",
nlive=100,
save=False,
)
def test_run_emcee(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="emcee",
iterations=1000,
nwalkers=10,
save=False,
)
def test_run_bilby_mcmc(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="bilby_mcmc",
nsamples=200,
save=False,
printdt=1,
)
def test_run_kombine(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="kombine",
iterations=1000,
nwalkers=100,
save=False,
autoburnin=True,
)
def test_run_nessai(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="nessai",
nlive=100,
poolsize=1000,
max_iteration=1000,
save=False,
)
def test_run_bilby_mcmc(self):
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="bilby_mcmc",
nsamples=200,
**self.kwargs,
printdt=1,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_dynesty(self):
pytest.importorskip("dynesty")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="dynesty",
nlive=100,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def fit(n):
likelihood = Polynomial(time, data, sigma, n)
priors = {}
for i in range(n):
k = 'c{}'.format(i)
priors[k] = bilby.core.prior.Uniform(0, 10, k)
result = bilby.run_sampler(
likelihood=likelihood, priors=priors, npoints=100, outdir=outdir,
label=label)
return (result.log_evidence, result.log_evidence_err,
np.log(result.occam_factor(priors)))
def test_run_ptemcee(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="ptemcee",
nsamples=100,
nwalkers=50,
burn_in_act=1,
ntemps=1,
frac_threshold=0.5,
save=False,
)
def test_run_emcee(self):
pytest.importorskip("emcee")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="emcee",
iterations=1000,
nwalkers=10,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_dnest4(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="dnest4",
max_num_levels=2,
num_steps=10,
new_level_interval=10,
num_per_step=10,
thread_steps=1,
num_particles=50,
save=False,
)
def test_run_dynamic_dynesty(self):
_ = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="dynamic_dynesty",
nlive_init=100,
nlive_batch=100,
dlogz_init=1.0,
maxbatch=0,
maxcall=100,
bound="single",
save=False,
)
def test_run_kombine(self):
pytest.importorskip("kombine")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="kombine",
iterations=2000,
nwalkers=20,
autoburnin=False,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_nessai(self):
pytest.importorskip("nessai")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="nessai",
nlive=100,
poolsize=1000,
max_iteration=1000,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_pymc3(self):
pytest.importorskip("pymc3")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="pymc3",
draws=50,
tune=50,
n_init=250,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_PTMCMCSampler(self):
pytest.importorskip("PTMCMCSampler")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="PTMCMCsampler",
Niter=101,
burn=2,
isave=100,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def test_run_ultranest(self):
pytest.importorskip("ultranest")
# run using NestedSampler (with nlive specified)
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="ultranest",
nlive=100,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
# run using ReactiveNestedSampler (with no nlive given)
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="ultranest",
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
def run_bilby(hierarchy: Hierarchy,
data: NeutrinoConstraint,
nlive: int = 1000):
hierarchy_str = 'nh' if hierarchy == Hierarchy.Normal else 'ih'
sum_str = str(data.sum_of_masses_one_sigma)[:5] # Max 5 sig fig
prefix = '' if data.sum_of_masses_offset == 0. else str(
data.sum_of_masses_offset) + '_'
sample = "rwalk"
label = sample + str(
nlive) + "_" + prefix + 'likeli_' + hierarchy_str + '_' + sum_str
# Going to get posteriors on the quantile, then need to do some post-processing
likelihood = HierarchyLikelihood(data)
priors = get_bilby_priors()
bilby.run_sampler(likelihood,
priors,
sampler="dynesty",
nlive=nlive,
label=label,
bound="multi",
sample=sample,
dlogz=0.01)
def test_run_ptemcee(self):
pytest.importorskip("ptemcee")
res = bilby.run_sampler(
likelihood=self.likelihood,
priors=self.priors,
sampler="ptemcee",
nsamples=100,
nwalkers=50,
burn_in_act=1,
ntemps=1,
frac_threshold=0.5,
**self.kwargs,
)
assert "derived" in res.posterior
assert res.log_likelihood_evaluations is not None
