def test_stepsampler_regionmh(plot=False):
np.random.seed(2)
sampler = ReactiveNestedSampler(paramnames, loglike_vectorized, transform=transform, vectorized=True)
sampler.stepsampler = RegionMHSampler(nsteps=4 * len(paramnames))
r = sampler.run(log_interval=50, min_num_live_points=400)
sampler.print_results()
a = (np.abs(r['samples'] - 0.7) < 0.1).all(axis=1)
b = (np.abs(r['samples'] - 0.3) < 0.1).all(axis=1)
assert a.sum() > 1, a
assert b.sum() > 1, b
def test_stepsampler_regionslice(plot=False):
np.random.seed(4)
sampler = ReactiveNestedSampler(paramnames, loglike, transform=transform)
sampler.stepsampler = RegionSliceSampler(nsteps=len(paramnames))
r = sampler.run(log_interval=50, min_num_live_points=400)
sampler.print_results()
a = (np.abs(r['samples'] - 0.7) < 0.1).all(axis=1)
b = (np.abs(r['samples'] - 0.3) < 0.1).all(axis=1)
assert a.sum() > 1
assert b.sum() > 1
def test_stepsampler_variable_speed_SLOW(plot=False):
matrices = [
np.array([[True, True, True], [False, True, True], [False, False, True]]),
[Ellipsis, slice(1,None), slice(2,4)]
]
for i, matrix in enumerate(matrices):
np.random.seed(42 + i)
sampler = ReactiveNestedSampler(paramnames, loglike, transform=transform)
sampler.stepsampler = SpeedVariableRegionSliceSampler(matrix)
r = sampler.run(log_interval=50, min_num_live_points=400)
sampler.print_results()
a = (np.abs(r['samples'] - 0.7) < 0.1).all(axis=1)
b = (np.abs(r['samples'] - 0.3) < 0.1).all(axis=1)
assert a.sum() > 1
assert b.sum() > 1
def test_stepsampler_cubeslice(plot=False):
np.random.seed(3)
nsteps = np.random.randint(10, 50)
popsize = np.random.randint(1, 20)
sampler = ReactiveNestedSampler(paramnames,
loglike_vectorized,
transform=transform,
vectorized=True)
sampler.stepsampler = PopulationSliceSampler(
popsize=popsize,
nsteps=nsteps,
generate_direction=generate_cube_oriented_direction,
)
r = sampler.run(viz_callback=None, log_interval=50)
sampler.print_results()
a = (np.abs(r['samples'] - 0.7) < 0.1).all(axis=1)
b = (np.abs(r['samples'] - 0.3) < 0.1).all(axis=1)
assert a.sum() > 1
assert b.sum() > 1
def main(args):
ndim = args.x_dim
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
def flat_loglike(theta):
delta = np.max(np.abs(theta - 0.5))
volume_enclosed = ndim * np.log(delta + 1e-15)
if volume_enclosed > -100:
return -volume_enclosed
else:
return +100
def loglike(theta):
delta = np.max(np.abs(theta - 0.5), axis=1)
volume_enclosed = ndim * np.log(delta + 1e-15)
like = -volume_enclosed
like[~(like < +100)] = 100
return like
def flat_transform(x):
return x
def transform(x):
return x
paramnames = ['param%d' % (i+1) for i in range(ndim)]
if args.pymultinest:
from pymultinest.solve import solve
result = solve(LogLikelihood=flat_loglike, Prior=flat_transform,
n_dims=ndim, outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
verbose=True, resume=True, importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
elif args.reactive:
if args.slice:
log_dir = args.log_dir + 'RNS-%dd-slice%d' % (ndim, args.slice_steps)
elif args.harm:
log_dir = args.log_dir + 'RNS-%dd-harm%d' % (ndim, args.slice_steps)
elif args.dyhmc:
log_dir = args.log_dir + 'RNS-%dd-dyhmc%d' % (ndim, args.slice_steps)
elif args.dychmc:
log_dir = args.log_dir + 'RNS-%dd-dychmc%d' % (ndim, args.slice_steps)
else:
log_dir = args.log_dir + 'RNS-%dd' % (ndim)
if adaptive_nsteps:
log_dir = log_dir + '-adapt%s' % (adaptive_nsteps)
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames, loglike, transform=transform,
log_dir=log_dir, resume=True,
vectorized=True)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
"""
if args.dyhmc:
import ultranest.dyhmc
from ultranest.utils import verify_gradient
verify_gradient(ndim, transform, loglike, transform_loglike_gradient, combination=True)
sampler.stepsampler = ultranest.dyhmc.DynamicHMCSampler(ndim=ndim, nsteps=args.slice_steps,
transform_loglike_gradient=transform_loglike_gradient)
if args.dychmc:
import ultranest.dychmc
from ultranest.utils import verify_gradient
verify_gradient(ndim, transform, loglike, gradient, verbose=True)
sampler.stepsampler = ultranest.dychmc.DynamicCHMCSampler(ndim=ndim, nsteps=args.slice_steps,
transform=transform, loglike=loglike, gradient=gradient)
"""
sampler.run(frac_remain=0.5, min_num_live_points=args.num_live_points, max_num_improvement_loops=1)
sampler.print_results()
if sampler.stepsampler is not None:
sampler.stepsampler.plot(filename = log_dir + '/stepsampler_stats_region.pdf')
if ndim <= 20:
sampler.plot()
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames, loglike, transform=transform,
num_live_points=args.num_live_points, vectorized=True,
log_dir=args.log_dir + '-%dd' % ndim, resume=True)
sampler.run()
sampler.print_results()
sampler.plot()
def main(args):
ndim = args.x_dim
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
rv1a = scipy.stats.loggamma(1, loc=2. / 3, scale=1. / 30)
rv1b = scipy.stats.loggamma(1, loc=1. / 3, scale=1. / 30)
rv2a = scipy.stats.norm(2. / 3, 1. / 30)
rv2b = scipy.stats.norm(1. / 3, 1. / 30)
rv_rest = []
for i in range(2, ndim):
if i <= (ndim + 2) / 2:
rv = scipy.stats.loggamma(1, loc=2. / 3., scale=1. / 30)
else:
rv = scipy.stats.norm(2. / 3, 1. / 30)
rv_rest.append(rv)
del rv
def loglike(theta):
L1 = log(0.5 * rv1a.pdf(theta[:, 0]) + 0.5 * rv1b.pdf(theta[:, 0]) +
1e-300)
L2 = log(0.5 * rv2a.pdf(theta[:, 1]) + 0.5 * rv2b.pdf(theta[:, 1]) +
1e-300)
Lrest = np.sum(
[rv.logpdf(t) for rv, t in zip(rv_rest, theta[:, 2:].transpose())],
axis=0)
#assert L1.shape == (len(theta),)
#assert L2.shape == (len(theta),)
#assert Lrest.shape == (len(theta),), Lrest.shape
like = L1 + L2 + Lrest
like = np.where(like < -1e300,
-1e300 - ((np.asarray(theta) - 0.5)**2).sum(), like)
assert like.shape == (len(theta), ), (like.shape, theta.shape)
return like
def transform(x):
return x
paramnames = ['param%d' % (i + 1) for i in range(ndim)]
if args.pymultinest:
from pymultinest.solve import solve
def flat_loglike(theta):
return loglike(theta.reshape((1, -1)))
result = solve(LogLikelihood=flat_loglike,
Prior=transform,
n_dims=ndim,
outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
verbose=True,
resume=True,
importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
elif args.reactive:
if args.slice:
log_dir = args.log_dir + 'RNS-%dd-slice%d' % (ndim,
args.slice_steps)
elif args.harm:
log_dir = args.log_dir + 'RNS-%dd-harm%d' % (ndim,
args.slice_steps)
elif args.dyhmc:
log_dir = args.log_dir + 'RNS-%dd-dyhmc%d' % (ndim,
args.slice_steps)
elif args.dychmc:
log_dir = args.log_dir + 'RNS-%dd-dychmc%d' % (ndim,
args.slice_steps)
else:
log_dir = args.log_dir + 'RNS-%dd' % (ndim)
if adaptive_nsteps:
log_dir = log_dir + '-adapt%s' % (adaptive_nsteps)
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames,
loglike,
transform=transform,
log_dir=log_dir,
resume=True,
vectorized=True)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w')
if sampler.mpi_rank == 0 else False)
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w')
if sampler.mpi_rank == 0 else False)
#if args.dyhmc:
# import ultranest.dyhmc
# verify_gradient(ndim, transform, loglike, transform_loglike_gradient, combination=True)
# sampler.stepsampler = ultranest.dyhmc.DynamicHMCSampler(ndim=ndim, nsteps=args.slice_steps,
# transform_loglike_gradient=transform_loglike_gradient, adaptive_nsteps=adaptive_nsteps)
#if args.dychmc:
# import ultranest.dychmc
# verify_gradient(ndim, transform, loglike, gradient)
# sampler.stepsampler = ultranest.dychmc.DynamicCHMCSampler(ndim=ndim, nsteps=args.slice_steps,
# transform=transform, loglike=loglike, gradient=gradient, adaptive_nsteps=adaptive_nsteps)
sampler.run(frac_remain=0.5,
min_num_live_points=args.num_live_points,
max_num_improvement_loops=1)
sampler.print_results()
if sampler.stepsampler is not None:
sampler.stepsampler.plot(filename=log_dir +
'/stepsampler_stats_region.pdf')
if ndim <= 20:
sampler.plot()
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames,
loglike,
transform=transform,
num_live_points=args.num_live_points,
vectorized=True,
log_dir=args.log_dir + '-%dd' % ndim,
resume=True)
sampler.run()
sampler.print_results()
sampler.plot()
def main(args):
ndim = args.x_dim
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
def loglike(theta):
a = theta[:, :-1]
b = theta[:, 1:]
return -2 * (100 * (b - a**2)**2 + (1 - a)**2).sum(axis=1)
def transform(u):
return u * 20 - 10
def transform_loglike_gradient(u):
theta = u * 20 - 10
a = theta[:-1]
b = theta[1:]
grad = theta.copy()
L = -2 * (100 * (b - a**2)**2 + (1 - a)**2).sum()
for i in range(ndim):
a = theta[i]
if i < ndim - 1:
b = theta[i + 1]
grad[i] = -2 * (-400 * a * (b - a**2) - 2 * (1 - a))
if i > 0:
c = theta[i - 1]
grad[i] += -400 * (a - c**2)
prior_factor = 20
return theta, L, grad * prior_factor
def gradient(u):
theta = u * 20 - 10
grad = theta.copy()
for i in range(ndim):
a = theta[i]
if i < ndim - 1:
b = theta[i + 1]
grad[i] = -2 * (-400 * a * (b - a**2) - 2 * (1 - a))
if i > 0:
c = theta[i - 1]
grad[i] += -400 * (a - c**2)
prior_factor = 20
return grad * prior_factor
paramnames = ['param%d' % (i + 1) for i in range(ndim)]
if args.pymultinest:
from pymultinest.solve import solve
def flat_loglike(theta):
return loglike(theta.reshape((1, -1)))
result = solve(LogLikelihood=flat_loglike,
Prior=transform,
n_dims=ndim,
outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
verbose=True,
resume=True,
importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
elif args.reactive:
if args.slice:
log_dir = args.log_dir + 'RNS-%dd-slice%d' % (ndim,
args.slice_steps)
elif args.harm:
log_dir = args.log_dir + 'RNS-%dd-harm%d' % (ndim,
args.slice_steps)
elif args.dyhmc:
log_dir = args.log_dir + 'RNS-%dd-dyhmc%d' % (ndim,
args.slice_steps)
elif args.dychmc:
log_dir = args.log_dir + 'RNS-%dd-dychmc%d' % (ndim,
args.slice_steps)
else:
log_dir = args.log_dir + 'RNS-%dd' % (ndim)
if adaptive_nsteps:
log_dir = log_dir + '-adapt%s' % (adaptive_nsteps)
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames,
loglike,
transform=transform,
log_dir=log_dir,
resume=True,
vectorized=True)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.dyhmc:
import ultranest.dyhmc
from ultranest.utils import verify_gradient
verify_gradient(ndim,
transform,
loglike,
transform_loglike_gradient,
combination=True)
sampler.stepsampler = ultranest.dyhmc.DynamicHMCSampler(
ndim=ndim,
nsteps=args.slice_steps,
transform_loglike_gradient=transform_loglike_gradient,
adaptive_nsteps=adaptive_nsteps)
if args.dychmc:
import ultranest.dychmc
from ultranest.utils import verify_gradient
verify_gradient(ndim, transform, loglike, gradient)
sampler.stepsampler = ultranest.dychmc.DynamicCHMCSampler(
ndim=ndim,
nsteps=args.slice_steps,
transform=transform,
loglike=loglike,
gradient=gradient,
adaptive_nsteps=adaptive_nsteps)
sampler.run(frac_remain=0.5,
min_num_live_points=args.num_live_points,
max_num_improvement_loops=1)
sampler.print_results()
if sampler.stepsampler is not None:
sampler.stepsampler.plot(filename=log_dir +
'/stepsampler_stats_region.pdf')
if ndim <= 20:
sampler.plot()
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames,
loglike,
transform=transform,
num_live_points=args.num_live_points,
vectorized=True,
log_dir=args.log_dir + '-%dd' % ndim,
resume=True)
sampler.run()
sampler.print_results()
sampler.plot()
def main(args):
ndim = args.x_dim
sigma = args.sigma
sigma = np.logspace(-1, np.log10(args.sigma), ndim)
width = 1 - 5 * sigma
width[width < 1e-20] = 1e-20
centers = (np.sin(np.arange(ndim) / 2.) * width + 1.) / 2.
#centers = np.ones(ndim) * 0.5
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
def loglike(theta):
like = -0.5 * (((theta - centers) / sigma)**2).sum(
axis=1) - 0.5 * np.log(2 * np.pi * sigma**2).sum()
return like
def transform(x):
return x
def transform_loglike_gradient(u):
theta = u
like = -0.5 * (((theta - centers) / sigma)**2).sum(
axis=1) - 0.5 * np.log(2 * np.pi * sigma**2).sum()
grad = (theta - centers) / sigma
return u, like, grad
def gradient(theta):
return (theta - centers) / sigma
paramnames = ['param%d' % (i + 1) for i in range(ndim)]
if args.pymultinest:
from pymultinest.solve import solve
def flat_loglike(theta):
return loglike(theta.reshape((1, -1)))
result = solve(LogLikelihood=flat_loglike,
Prior=transform,
n_dims=ndim,
outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
verbose=True,
resume=True,
importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
elif args.reactive:
if args.slice:
log_dir = args.log_dir + 'RNS-%dd-slice%d' % (ndim,
args.slice_steps)
elif args.harm:
log_dir = args.log_dir + 'RNS-%dd-harm%d' % (ndim,
args.slice_steps)
elif args.dyhmc:
log_dir = args.log_dir + 'RNS-%dd-dyhmc%d' % (ndim,
args.slice_steps)
elif args.dychmc:
log_dir = args.log_dir + 'RNS-%dd-dychmc%d' % (ndim,
args.slice_steps)
else:
log_dir = args.log_dir + 'RNS-%dd' % (ndim)
if adaptive_nsteps:
log_dir = log_dir + '-adapt%s' % (adaptive_nsteps)
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames,
loglike,
transform=transform,
log_dir=log_dir,
resume=True,
vectorized=True)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(
nsteps=args.slice_steps,
adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.dyhmc:
import ultranest.dyhmc
from ultranest.utils import verify_gradient
verify_gradient(ndim,
transform,
loglike,
transform_loglike_gradient,
combination=True)
sampler.stepsampler = ultranest.dyhmc.DynamicHMCSampler(
ndim=ndim,
nsteps=args.slice_steps,
transform_loglike_gradient=transform_loglike_gradient,
adaptive_nsteps=adaptive_nsteps)
if args.dychmc:
import ultranest.dychmc
from ultranest.utils import verify_gradient
verify_gradient(ndim, transform, loglike, gradient)
sampler.stepsampler = ultranest.dychmc.DynamicCHMCSampler(
ndim=ndim,
nsteps=args.slice_steps,
transform=transform,
loglike=loglike,
gradient=gradient,
adaptive_nsteps=adaptive_nsteps)
sampler.run(frac_remain=0.5,
min_num_live_points=args.num_live_points,
max_num_improvement_loops=1)
sampler.print_results()
if sampler.stepsampler is not None:
sampler.stepsampler.plot(filename=log_dir +
'/stepsampler_stats_region.pdf')
if ndim <= 20:
sampler.plot()
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames,
loglike,
transform=transform,
num_live_points=args.num_live_points,
vectorized=True,
log_dir=args.log_dir + '-%dd' % ndim,
resume=True)
sampler.run()
sampler.print_results()
sampler.plot()
def main(args):
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
np.random.seed(2)
Ndata = args.ndata
jitter_true = 0.1
phase_true = 0.
period_true = 180
amplitude_true = args.contrast / Ndata * jitter_true
paramnames = ['amplitude', 'jitter', 'phase', 'period']
ndim = 4
derivednames = [] #'frequency']
wrapped_params = [False, False, True, False]
#wrapped_params = None
x = np.linspace(0, 360, 1000)
y = amplitude_true * sin(x / period_true * 2 * pi + phase_true)
if True:
plt.plot(x, y)
x = np.random.uniform(0, 360, Ndata)
y = np.random.normal(
amplitude_true * sin(x / period_true * 2 * pi + phase_true),
jitter_true)
plt.errorbar(x, y, yerr=jitter_true, marker='x', ls=' ')
plt.savefig('testsine.pdf', bbox_inches='tight')
plt.close()
def loglike(params):
amplitude, jitter, phase, period = params.transpose()[:4]
predicty = amplitude * sin(
x.reshape((-1, 1)) / period * 2 * pi + phase)
logl = (-0.5 * log(2 * pi * jitter**2) - 0.5 * ((predicty - y.reshape(
(-1, 1))) / jitter)**2).sum(axis=0)
assert logl.shape == jitter.shape
return logl
def transform(x):
z = np.empty((len(x), 4))
z[:, 0] = 10**(x[:, 0] * 4 - 2)
z[:, 1] = 10**(x[:, 1] * 1 - 1.5)
z[:, 2] = 2 * pi * x[:, 2]
z[:, 3] = 10**(x[:, 3] * 4 - 1)
#z[:,4] = 2 * pi / x[:,3]
return z
loglike(transform(np.ones((2, ndim)) * 0.5))
if args.pymultinest:
from pymultinest.solve import solve
global Lmax
Lmax = -np.inf
def flat_loglike(theta):
L = loglike(theta.reshape((1, -1)))[0]
global Lmax
if L > Lmax:
print("Like: %.2f" % L)
Lmax = L
return L
def flat_transform(cube):
return transform(cube.reshape((1, -1)))[0]
result = solve(LogLikelihood=flat_loglike,
Prior=flat_transform,
n_dims=ndim,
outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
n_live_points=args.num_live_points,
verbose=True,
resume=False,
importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
return
elif args.reactive:
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames,
loglike,
transform=transform,
log_dir=args.log_dir,
vectorized=True,
derived_param_names=derivednames,
wrapped_params=wrapped_params,
resume='overwrite')
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(
nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(
nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps)
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames,
loglike,
transform=transform,
log_dir=args.log_dir,
vectorized=True,
derived_param_names=derivednames,
wrapped_params=wrapped_params,
resume='overwrite')
sampler.run(min_num_live_points=args.num_live_points)
print()
sampler.print_results()
sampler.plot()
for i, p in enumerate(paramnames + derivednames):
v = sampler.results['samples'][:, i]
print('%20s: %5.3f +- %5.3f' % (p, v.mean(), v.std()))
def main(args):
ndim = args.x_dim
adaptive_nsteps = args.adapt_steps
if adaptive_nsteps is None:
adaptive_nsteps = False
#C = 0.01
r = 0.2
# the shell thickness is
#w = (r**(ndim+1) + C * scipy.special.gamma((ndim+3)/2)*ndim*pi**(-(ndim+1)/2) / (
# scipy.special.gamma((ndim+2)/2) * pi**(-ndim/2)))**(1 / (ndim+1)) - r
w = 0.001 / ndim
r1, r2 = r, r
w1, w2 = w, w
c1, c2 = np.zeros(ndim) + 0.5, np.zeros(ndim) + 0.5
c1[0] -= r1 / 2
c2[0] += r2 / 2
N1 = -0.5 * log(2 * pi * w1**2)
N2 = -0.5 * log(2 * pi * w2**2)
Z_analytic = log(shell_vol(ndim, r1, w1) + shell_vol(ndim, r2, w2))
def loglike(theta):
d1 = ((theta - c1)**2).sum(axis=1)**0.5
d2 = ((theta - c2)**2).sum(axis=1)**0.5
L1 = -0.5 * ((d1 - r1)**2) / w1**2 + N1
L2 = -0.5 * ((d2 - r2)**2) / w2**2 + N2
return np.logaddexp(L1, L2)
def transform(x):
return x
def gradient(theta):
delta1 = theta - c1
delta2 = theta - c1
d1 = (delta1**2).sum()**0.5
d2 = (delta2**2).sum()**0.5
g1 = -delta1 * (1 - r1 / d1) / w1**2
g2 = -delta2 * (1 - r2 / d2) / w2**2
return np.logaddexp(g1, g2)
"""
N = 10000
x = np.random.normal(size=(N, ndim))
x *= (np.random.uniform(size=N)**(1./ndim) / (x**2).sum(axis=1)**0.5).reshape((-1, 1))
x = x * r1 + c1
print(loglike(x) - N1)
print('%.3f%%' % ((loglike(x) - N1 > -ndim*2).mean() * 100))
import sys; sys.exit()
"""
paramnames = ['param%d' % (i+1) for i in range(ndim)]
if args.pymultinest:
from pymultinest.solve import solve
def flat_loglike(theta):
return loglike(theta.reshape((1, -1)))
result = solve(LogLikelihood=flat_loglike, Prior=transform,
n_dims=ndim, outputfiles_basename=args.log_dir + 'MN-%dd' % ndim,
verbose=True, resume=True, importance_nested_sampling=False)
print()
print('evidence: %(logZ).1f +- %(logZerr).1f' % result)
print()
print('parameter values:')
for name, col in zip(paramnames, result['samples'].transpose()):
print('%15s : %.3f +- %.3f' % (name, col.mean(), col.std()))
elif args.reactive:
if args.slice:
log_dir = args.log_dir + 'RNS-%dd-slice%d' % (ndim, args.slice_steps)
elif args.harm:
log_dir = args.log_dir + 'RNS-%dd-harm%d' % (ndim, args.slice_steps)
elif args.dyhmc:
log_dir = args.log_dir + 'RNS-%dd-dyhmc%d' % (ndim, args.slice_steps)
elif args.dychmc:
log_dir = args.log_dir + 'RNS-%dd-dychmc%d' % (ndim, args.slice_steps)
else:
log_dir = args.log_dir + 'RNS-%dd' % (ndim)
if adaptive_nsteps:
log_dir = log_dir + '-adapt%s' % (adaptive_nsteps)
from ultranest import ReactiveNestedSampler
sampler = ReactiveNestedSampler(paramnames, loglike, transform=transform,
log_dir=log_dir, resume=True,
vectorized=True)
if args.slice:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionSliceSampler(nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
if args.harm:
import ultranest.stepsampler
sampler.stepsampler = ultranest.stepsampler.RegionBallSliceSampler(nsteps=args.slice_steps, adaptive_nsteps=adaptive_nsteps,
log=open(log_dir + '/stepsampler.log', 'w'))
#if args.dyhmc:
# import ultranest.dyhmc
# from ultranest.utils import verify_gradient
# verify_gradient(ndim, transform, loglike, transform_loglike_gradient, combination=True)
# sampler.stepsampler = ultranest.dyhmc.DynamicHMCSampler(ndim=ndim, nsteps=args.slice_steps,
# transform_loglike_gradient=transform_loglike_gradient)
if args.dychmc:
import ultranest.dychmc
from ultranest.utils import verify_gradient
verify_gradient(ndim, transform, loglike, gradient, verbose=True)
sampler.stepsampler = ultranest.dychmc.DynamicCHMCSampler(ndim=ndim, nsteps=args.slice_steps,
transform=transform, loglike=loglike, gradient=gradient)
sampler.run(frac_remain=0.5, min_num_live_points=args.num_live_points, max_num_improvement_loops=1)
sampler.print_results()
if sampler.stepsampler is not None:
sampler.stepsampler.plot(filename = log_dir + '/stepsampler_stats_region.pdf')
if ndim <= 20:
sampler.plot()
else:
from ultranest import NestedSampler
sampler = NestedSampler(paramnames, loglike, transform=transform,
num_live_points=args.num_live_points, vectorized=True,
log_dir=args.log_dir + '-%dd' % ndim, resume=True)
sampler.run()
sampler.print_results()
sampler.plot()
print("expected Z=%.3f (analytic solution)" % Z_analytic)
