9f2dd4f6-0775-47e9-b700-af647027ebfa

Committed 22 Apr 2024 12:51PM UTC coverage: 74.53% (+0.3%) from 74.242%

Build # 9f2dd4f6-0775-47e9-b700-af647027ebfa

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #118 from njzifjoiez/fixed-size-vectorised-slice-sampler

vectorised slice sampler of fixed batch size

Run Details

1329 of 2026 branches covered (65.6%)

Branch coverage included in aggregate %.

79 of 80 new or added lines in 1 file covered. (98.75%)

1 existing line in 1 file now uncovered.

4026 of 5159 relevant lines covered (78.04%)

0.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.29

/ultranest/solvecompat.py

"""Drop-in replacement for pymultinest.solve.

Example::

    from ultranest.solvecompat import pymultinest_solve_compat as solve

    # is a drop-in replacement for

    from pymultinest.solve import solve

"""


import numpy as np
import string

from .integrator import ReactiveNestedSampler
from .stepsampler import SliceSampler, generate_mixture_random_direction


def pymultinest_solve_compat(
    LogLikelihood, Prior, n_dims, paramnames=None,
    outputfiles_basename=None, resume=False,
    n_live_points=400, evidence_tolerance=0.5,
    seed=-1, max_iter=0, wrapped_params=None, verbose=True,
    speed="safe",
    **kwargs
):
    """Run nested sampling analysis.

    Disadvantages compared to using ReactiveNestedSampler directly:
    cannot resume easily, cannot plot interactively.
    Limited results.

    It is recommended that you directly use::

        sampler = ReactiveNestedSampler(paramnames, LogLikelihood, transform=Prior)
        sampler.run()

    following the UltraNest documentation and manuals,
    as this gives you more control on resuming and sampler options.
    """
    if paramnames is None:
        paramnames = list(string.ascii_lowercase)[:n_dims]
    if seed >= 0:
        np.random.seed(seed)
    assert len(paramnames) == n_dims
    min_ess = kwargs.pop('min_ess', 0)
    frac_remain = kwargs.pop('frac_remain', 0.01)
    Lepsilon = kwargs.pop('Lepsilon', 0.001)
    outputkwargs = {}
    if not verbose:
        outputkwargs = dict(viz_callback=False, show_status=False)

    sampler = ReactiveNestedSampler(
        paramnames, LogLikelihood, transform=Prior,
        log_dir=outputfiles_basename, resume='resume' if resume else 'overwrite',
        wrapped_params=wrapped_params, draw_multiple=False, vectorized=False,
        **outputkwargs)

    if speed == "safe":
        pass
    elif speed == "auto":
        sampler.run(
            dlogz=evidence_tolerance,
            max_iters=max_iter if max_iter > 0 else None,
            min_num_live_points=n_live_points,
            min_ess=min_ess, frac_remain=frac_remain,
            Lepsilon=Lepsilon, max_ncalls=40000)

        sampler.stepsampler = SliceSampler(
            nsteps=1000,
            generate_direction=generate_mixture_random_direction,
            adaptive_nsteps='move-distance',
            region_filter=kwargs.get('region_filter', True)
        )
    else:
        sampler.stepsampler = SliceSampler(
            generate_direction=generate_mixture_random_direction,
            nsteps=speed,
            adaptive_nsteps=False,
            region_filter=False)

    sampler.run(dlogz=evidence_tolerance,
                max_iters=max_iter if max_iter > 0 else None,
                min_num_live_points=n_live_points,
                min_ess=min_ess, frac_remain=frac_remain,
                Lepsilon=Lepsilon)

    if verbose:
        sampler.print_results()
    results = sampler.results
    sampler.plot()

    return dict(logZ=results['logz'],
                logZerr=results['logzerr'],
                samples=results['samples'],
                weighted_samples=results['weighted_samples'])

1	"""Drop-in replacement for pymultinest.solve.
2
3	Example::
4
5	from ultranest.solvecompat import pymultinest_solve_compat as solve
6
7	# is a drop-in replacement for
8
9	from pymultinest.solve import solve
10
11	"""
12
13
14	import numpy as np	1✔
15	import string	1✔
16
17	from .integrator import ReactiveNestedSampler	1✔
18	from .stepsampler import SliceSampler, generate_mixture_random_direction	1✔
19
20
21	def pymultinest_solve_compat(	1✔
22	LogLikelihood, Prior, n_dims, paramnames=None,
23	outputfiles_basename=None, resume=False,
24	n_live_points=400, evidence_tolerance=0.5,
25	seed=-1, max_iter=0, wrapped_params=None, verbose=True,
26	speed="safe",
27	**kwargs
28	):
29	"""Run nested sampling analysis.
30
31	Disadvantages compared to using ReactiveNestedSampler directly:
32	cannot resume easily, cannot plot interactively.
33	Limited results.
34
35	It is recommended that you directly use::
36
37	sampler = ReactiveNestedSampler(paramnames, LogLikelihood, transform=Prior)
38	sampler.run()
39
40	following the UltraNest documentation and manuals,
41	as this gives you more control on resuming and sampler options.
42	"""
43	if paramnames is None:	1!
44	paramnames = list(string.ascii_lowercase)[:n_dims]	1✔
45	if seed >= 0:	1!
46	np.random.seed(seed)	×
47	assert len(paramnames) == n_dims	1✔
48	min_ess = kwargs.pop('min_ess', 0)	1✔
49	frac_remain = kwargs.pop('frac_remain', 0.01)	1✔
50	Lepsilon = kwargs.pop('Lepsilon', 0.001)	1✔
51	outputkwargs = {}	1✔
52	if not verbose:	1!
53	outputkwargs = dict(viz_callback=False, show_status=False)	×
54
55	sampler = ReactiveNestedSampler(	1✔
56	paramnames, LogLikelihood, transform=Prior,
57	log_dir=outputfiles_basename, resume='resume' if resume else 'overwrite',
58	wrapped_params=wrapped_params, draw_multiple=False, vectorized=False,
59	**outputkwargs)
60
61	if speed == "safe":	1!
62	pass	1✔
63	elif speed == "auto":	×
64	sampler.run(	×
65	dlogz=evidence_tolerance,
66	max_iters=max_iter if max_iter > 0 else None,
67	min_num_live_points=n_live_points,
68	min_ess=min_ess, frac_remain=frac_remain,
69	Lepsilon=Lepsilon, max_ncalls=40000)
70
71	sampler.stepsampler = SliceSampler(	×
72	nsteps=1000,
73	generate_direction=generate_mixture_random_direction,
74	adaptive_nsteps='move-distance',
75	region_filter=kwargs.get('region_filter', True)
76	)
77	else:
78	sampler.stepsampler = SliceSampler(	×
79	generate_direction=generate_mixture_random_direction,
80	nsteps=speed,
81	adaptive_nsteps=False,
82	region_filter=False)
83
84	sampler.run(dlogz=evidence_tolerance,	1✔
85	max_iters=max_iter if max_iter > 0 else None,
86	min_num_live_points=n_live_points,
87	min_ess=min_ess, frac_remain=frac_remain,
88	Lepsilon=Lepsilon)
89
90	if verbose:	1!
91	sampler.print_results()	1✔
92	results = sampler.results	1✔
93	sampler.plot()	1✔
94
95	return dict(logZ=results['logz'],	1✔
96	logZerr=results['logzerr'],
97	samples=results['samples'],
98	weighted_samples=results['weighted_samples'])

JohannesBuchner / UltraNest / 9f2dd4f6-0775-47e9-b700-af647027ebfa

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous