diff --git a/README.md b/README.md index 28d0263..f68b1b6 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ JAXNS is: What can you do with JAXNS? -1) Compute the Bayesian evidence of a model or hypothesis (the ultimate scientific method); +1) Compute the Bayesian evidence of a model or hypothesis (the ultimate scientific method); 2) Produce high-quality samples from the posterior distribution; 3) Easily handle degenerate difficult multi-modal posteriors; 4) Model both discrete and continuous priors and likelihoods; @@ -359,6 +359,9 @@ before importing JAXNS. # Change Log +9 Nov, 2024 -- JAXNS 2.6.5 released. Added gradient guided nested sampling. Removed `num_parallel_workers` in favour +`devices`. + 4 Nov, 2024 -- JAXNS 2.6.4 released. Resolved bias when using phantom points. 1 Oct, 2024 -- JAXNS 2.6.3 released. Enable pytrees in context. diff --git a/benchmarks/gh136/main.py b/benchmarks/gh136/main.py new file mode 100644 index 0000000..c39c198 --- /dev/null +++ b/benchmarks/gh136/main.py @@ -0,0 +1,171 @@ +import time + +import jax +import jax.numpy as jnp +import matplotlib.pyplot as plt +import numpy as np +import pkg_resources +import tensorflow_probability.substrates.jax as tfp +from jax._src.scipy.linalg import solve_triangular + +from jaxns import Model, Prior + +try: + from jaxns import NestedSampler +except ImportError: + from jaxns import DefaultNestedSampler as NestedSampler + +tfpd = tfp.distributions + + +def build_run_model(num_slices, gradient_guided, ndims): + def run_model(key, prior_mu, prior_cov, data_mu, data_cov): + def log_normal(x, mean, cov): + L = jnp.linalg.cholesky(cov) + dx = x - mean + dx = solve_triangular(L, dx, lower=True) + return -0.5 * x.size * jnp.log(2. * jnp.pi) - jnp.sum(jnp.log(jnp.diag(L))) \ + - 0.5 * dx @ dx + + true_logZ = log_normal(data_mu, prior_mu, prior_cov + data_cov) + + J = jnp.linalg.solve(data_cov + prior_cov, prior_cov) + post_mu = prior_mu + J.T @ (data_mu - prior_mu) + post_cov = prior_cov - J.T @ (prior_cov + data_cov) @ J + + # print("True logZ={}".format(true_logZ)) + # print("True post_mu={}".format(post_mu)) + # print("True post_cov={}".format(post_cov)) + + # KL posterior || prior + dist_posterior = tfpd.MultivariateNormalFullCovariance(loc=post_mu, covariance_matrix=post_cov) + dist_prior = tfpd.MultivariateNormalFullCovariance(loc=prior_mu, covariance_matrix=prior_cov) + H_true = -tfp.distributions.kl_divergence(dist_posterior, dist_prior) + + # print("True H={}".format(H_true)) + + def prior_model(): + x = yield Prior( + tfpd.MultivariateNormalTriL(loc=prior_mu, scale_tril=jnp.linalg.cholesky(prior_cov)), + name='x') + return x + + def log_likelihood(x): + return tfpd.MultivariateNormalTriL(loc=data_mu, scale_tril=jnp.linalg.cholesky(data_cov)).log_prob(x) + + model = Model(prior_model=prior_model, log_likelihood=log_likelihood) + + ns = NestedSampler(model=model, verbose=False, k=0, num_slices=num_slices, gradient_guided=gradient_guided) + + termination_reason, state = ns(key) + results = ns.to_results(termination_reason=termination_reason, state=state, trim=False) + + error = results.H_mean - H_true + log_Z_error = results.log_Z_mean - true_logZ + return results.H_mean, H_true, error, log_Z_error + + return run_model + + +def get_data(ndims): + prior_mu = 15 * jnp.ones(ndims) + prior_cov = jnp.diag(jnp.ones(ndims)) ** 2 + + data_mu = jnp.zeros(ndims) + data_cov = jnp.diag(jnp.ones(ndims)) ** 2 + data_cov = jnp.where(data_cov == 0., 0.99, data_cov) + return prior_mu, prior_cov, data_mu, data_cov + + +def main(): + jaxns_version = pkg_resources.get_distribution("jaxns").version + m = 3 + d = 32 + + data = get_data(d) + + # Row 1: Plot logZ error for gradient guided vs baseline for different s, with errorbars + # Row 2: Plot H error for gradient guided vs baseline for different s, with errorbars + # Row 3: Plot time taken for gradient guided vs baseline for different s, with errorbars + + s_array = [10, 20, 30, 40, 80, 120] + + run_model_baseline_aot_array = [ + jax.jit(build_run_model(num_slices=s, gradient_guided=False, ndims=d)).lower(jax.random.PRNGKey(0), *data).compile() for + s in + s_array] + run_model_gg_aot_array = [ + jax.jit(build_run_model(num_slices=s, gradient_guided=True, ndims=d)).lower(jax.random.PRNGKey(0), *data).compile() for s + in + s_array] + + H_errors = np.zeros((len(s_array), m, 2)) + log_z_errors = np.zeros((len(s_array), m, 2)) + dt = np.zeros((len(s_array), m, 2)) + + for s_idx in range(len(s_array)): + s = s_array[s_idx] + for i in range(m): + key = jax.random.PRNGKey(i * 42) + baseline_model = run_model_baseline_aot_array[s_idx] + gg_model = run_model_gg_aot_array[s_idx] + t0 = time.time() + H, H_true, H_error, log_Z_error = jax.block_until_ready(baseline_model(key, *data)) + t1 = time.time() + dt[s_idx, i, 0] = t1 - t0 + H_errors[s_idx, i, 0] = H_error + log_z_errors[s_idx, i, 0] = log_Z_error + print(f"Baseline: i={i} k=0 s={s} H={H} H_true={H_true} H_error={H_error} log_Z_error={log_Z_error}") + t0 = time.time() + H, H_true, H_error, log_Z_error = jax.block_until_ready(gg_model(key, *data)) + t1 = time.time() + dt[s_idx, i, 1] = t1 - t0 + H_errors[s_idx, i, 1] = H_error + log_z_errors[s_idx, i, 1] = log_Z_error + print(f"GG: i={i} k=0 s={s} H={H} H_true={H_true} H_error={H_error} log_Z_error={log_Z_error}") + + fig, axs = plt.subplots(3, 1, figsize=(10, 15), sharex=True) + # Row 1 + H_error_mean = np.mean(H_errors, axis=1) # [s, 2] + H_error_std = np.std(H_errors, axis=1) # [s, 2] + axs[0].plot(s_array, H_error_mean[:, 0], label="Baseline", c='b') + axs[0].plot(s_array, H_error_mean[:, 1], label="Gradient Guided", c='r') + axs[0].fill_between(s_array, H_error_mean[:, 0] - H_error_std[:, 0], H_error_mean[:, 0] + H_error_std[:, 0], + color='b', alpha=0.2) + axs[0].fill_between(s_array, H_error_mean[:, 1] - H_error_std[:, 1], H_error_mean[:, 1] + H_error_std[:, 1], + color='r', alpha=0.2) + axs[0].set_ylabel("H error") + axs[0].legend() + + # Row 2 + logZ_error_mean = np.mean(log_z_errors, axis=1) # [s, 2] + logZ_error_std = np.std(log_z_errors, axis=1) # [s, 2] + axs[1].plot(s_array, logZ_error_mean[:, 0], label="Baseline", c='b') + axs[1].plot(s_array, logZ_error_mean[:, 1], label="Gradient Guided", c='r') + axs[1].fill_between(s_array, logZ_error_mean[:, 0] - logZ_error_std[:, 0], + logZ_error_mean[:, 0] + logZ_error_std[:, 0], color='b', alpha=0.2) + axs[1].fill_between(s_array, logZ_error_mean[:, 1] - logZ_error_std[:, 1], + logZ_error_mean[:, 1] + logZ_error_std[:, 1], color='r', alpha=0.2) + axs[1].set_ylabel("logZ error") + axs[1].legend() + + # Row 3 + dt_mean = np.mean(dt, axis=1) # [s, 2] + dt_std = np.std(dt, axis=1) # [s, 2] + axs[2].plot(s_array, dt_mean[:, 0], label="Baseline", c='b') + axs[2].plot(s_array, dt_mean[:, 1], label="Gradient Guided", c='r') + axs[2].fill_between(s_array, dt_mean[:, 0] - dt_std[:, 0], dt_mean[:, 0] + dt_std[:, 0], color='b', alpha=0.2) + axs[2].fill_between(s_array, dt_mean[:, 1] - dt_std[:, 1], dt_mean[:, 1] + dt_std[:, 1], color='r', alpha=0.2) + axs[2].set_ylabel("Time taken") + axs[2].legend() + axs[2].set_xlabel(r"number of slices") + + axs[0].set_title(f"Gradient guided vs baseline, D={d}, v{jaxns_version}") + + plt.savefig(f"Gradient_guided_vs_baseline_D{d}_v{jaxns_version}.png") + + plt.show() + + +if __name__ == '__main__': + main() diff --git a/docs/examples/efficient_parameter_estimation.ipynb b/docs/examples/efficient_parameter_estimation.ipynb new file mode 100644 index 0000000..c06844f --- /dev/null +++ b/docs/examples/efficient_parameter_estimation.ipynb @@ -0,0 +1,428 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Efficient parameter estimation\n", + "\n", + "This uses a problem from radio interferometry of inferring ionospheric parameters from phase data. We'll explore how to use JAXNS when the focus is on efficient parameter estimation rather than evidence calculation. \n" + ] + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:53.533478Z", + "iopub.status.busy": "2024-09-23T22:36:53.532777Z", + "iopub.status.idle": "2024-09-23T22:36:54.814731Z", + "shell.execute_reply": "2024-09-23T22:36:54.814167Z" + }, + "pycharm": { + "is_executing": true + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:18:31.054184Z", + "start_time": "2024-11-09T15:18:29.706292Z" + } + }, + "source": [ + "\n", + "\n", + "import pylab as plt\n", + "import tensorflow_probability.substrates.jax as tfp\n", + "from jax import random, numpy as jnp\n", + "\n", + "from jaxns import NestedSampler\n", + "from jaxns import bruteforce_evidence\n", + "\n", + "tfpd = tfp.distributions\n" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/albert/git/jaxns/src/jaxns/internals/mixed_precision.py:14: UserWarning: JAX x64 is not enabled. Setting it now. Check for errors.\n", + " warnings.warn(\"JAX x64 is not enabled. Setting it now. Check for errors.\")\n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'cuda': \n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n", + "WARNING:jax._src.xla_bridge:An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:54.817250Z", + "iopub.status.busy": "2024-09-23T22:36:54.816667Z", + "iopub.status.idle": "2024-09-23T22:36:54.822180Z", + "shell.execute_reply": "2024-09-23T22:36:54.821123Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:18:31.063111Z", + "start_time": "2024-11-09T15:18:31.058104Z" + } + }, + "source": [ + "\n", + "TEC_CONV = -8.4479745 #rad*MHz/mTECU\n", + "CLOCK_CONV = (2e-3 * jnp.pi) #rad/MHz/ns\n", + "\n", + "\n", + "def wrap(phi):\n", + " return (phi + jnp.pi) % (2 * jnp.pi) - jnp.pi\n", + "\n", + "\n", + "def generate_data(key, uncert):\n", + " \"\"\"\n", + " Generate gain data where the phase have a clock const and tec component. This is a model of the impact of the ionosphere on the propagation of radio waves, part of radio interferometry:\n", + "\n", + " phase[:] = tec * (tec_conv / freqs[:]) + clock * (clock_conv * freqs[:]) + const\n", + "\n", + " then the gains are:\n", + "\n", + " gains[:] ~ Normal[{cos(phase[:]), sin(phase[:])}, uncert^2 * I]\n", + "\n", + " phase_obs[:] = ArcTan[gains.imag, gains.real]\n", + "\n", + " Args:\n", + " key:\n", + " uncert: uncertainty of the gains\n", + "\n", + " Returns:\n", + " phase_obs, freqs\n", + " \"\"\"\n", + " freqs = jnp.linspace(121, 166, 24) #MHz\n", + " tec = 90. #mTECU\n", + " const = 2. #rad\n", + " clock = 0.5 #ns\n", + " phase = wrap(tec * (TEC_CONV / freqs) + clock * (CLOCK_CONV * freqs) + const)\n", + " Y = jnp.concatenate([jnp.cos(phase), jnp.sin(phase)], axis=-1)\n", + " Y_obs = Y + uncert * random.normal(key, shape=Y.shape)\n", + " phase_obs = jnp.arctan2(Y_obs[..., freqs.size:], Y_obs[..., :freqs.size])\n", + " return phase, phase_obs, freqs\n" + ], + "outputs": [], + "execution_count": 2 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:54.824732Z", + "iopub.status.busy": "2024-09-23T22:36:54.824265Z", + "iopub.status.idle": "2024-09-23T22:36:55.536048Z", + "shell.execute_reply": "2024-09-23T22:36:55.535452Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:18:31.834582Z", + "start_time": "2024-11-09T15:18:31.206132Z" + } + }, + "source": [ + "# Generate data\n", + "key = random.PRNGKey(43)\n", + "key, data_key = random.split(key)\n", + "phase_underlying, phase_obs, freqs = generate_data(data_key, 0.25)\n", + "plt.scatter(freqs, phase_obs, label='data')\n", + "plt.plot(freqs, phase_underlying, label='Underlying phase')\n", + "plt.legend()\n", + "plt.show()\n", + "# Note: the phase wrapping makes this a difficult problem to solve. As we'll see, the posterior is rather complicated." + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:55.537954Z", + "iopub.status.busy": "2024-09-23T22:36:55.537763Z", + "iopub.status.idle": "2024-09-23T22:37:04.591007Z", + "shell.execute_reply": "2024-09-23T22:37:04.590573Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:18:41.885376Z", + "start_time": "2024-11-09T15:18:31.848701Z" + } + }, + "source": [ + "\n", + "from jaxns import Prior, Model\n", + "\n", + "\n", + "def log_normal(x, mean, scale):\n", + " return tfpd.Normal(loc=mean, scale=scale).log_prob(x)\n", + "\n", + "\n", + "def log_likelihood(dtec, const, clock, uncert):\n", + " phase = dtec * (TEC_CONV / freqs) + const + clock * (CLOCK_CONV * freqs)\n", + " logL = log_normal(wrap(wrap(phase) - wrap(phase_obs)), 0., uncert)\n", + " return jnp.sum(logL)\n", + "\n", + "\n", + "def prior_model():\n", + " tec = yield Prior(tfpd.Uniform(-300, 300.), name='dtec')\n", + " const = yield Prior(tfpd.Uniform(-jnp.pi, jnp.pi), name='const')\n", + " clock = yield Prior(tfpd.Uniform(-2., 2.), name='clock')\n", + " uncert = yield Prior(tfpd.HalfNormal(0.25), name='uncert')\n", + "\n", + " return tec, const, clock, uncert\n", + "\n", + "\n", + "model = Model(prior_model=prior_model, log_likelihood=log_likelihood)\n", + "\n", + "model.sanity_check(random.PRNGKey(0), S=100)\n", + "\n", + "log_Z_true = bruteforce_evidence(model=model, S=80)\n", + "print(f\"Approx. log(Z)={log_Z_true}\") # Unsure if this grid is sufficient to get a good estimate of the evidence." + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:jaxns:Sanity check...\n", + "INFO:jaxns:Sanity check passed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Approx. log(Z)=-8.74251800745667\n" + ] + } + ], + "execution_count": 4 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "# First the normal nested sampler (parameter_estimation=False)" + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:37:04.593194Z", + "iopub.status.busy": "2024-09-23T22:37:04.593049Z", + "iopub.status.idle": "2024-09-23T22:37:10.791240Z", + "shell.execute_reply": "2024-09-23T22:37:10.790720Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:18:50.427297Z", + "start_time": "2024-11-09T15:18:41.959152Z" + } + }, + "source": [ + "import jax\n", + "\n", + "# Create the nested sampler class. In this case without any tuning.\n", + "ns = NestedSampler(model=model, parameter_estimation=False)\n", + "termination_reason, state = jax.jit(ns)(random.PRNGKey(432345987))\n", + "results = ns.to_results(termination_reason=termination_reason, state=state)\n", + "ns.summary(results)\n", + "ns.plot_diagnostics(results)\n", + "ns.plot_cornerplot(results)" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------\n", + "Termination Conditions:\n", + "Small remaining evidence\n", + "--------\n", + "likelihood evals: 233772\n", + "samples: 1800\n", + "phantom samples: 0\n", + "likelihood evals / sample: 129.9\n", + "phantom fraction (%): 0.0%\n", + "--------\n", + "logZ=-8.81 +- 0.3\n", + "max(logL)=0.32\n", + "H=-7.48\n", + "ESS=188\n", + "--------\n", + "clock: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "clock: -0.41 +- 0.88 | -1.5 / -0.4 / 0.63 | -1.6 | -1.65\n", + "--------\n", + "const: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "const: -0.2 +- 1.9 | -2.7 / -0.4 / 2.2 | -1.4 | -1.4\n", + "--------\n", + "dtec: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "dtec: 90.0 +- 17.0 | 71.0 / 90.0 / 110.0 | 107.0 | 106.0\n", + "--------\n", + "uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "uncert: 0.266 +- 0.036 | 0.228 / 0.261 / 0.315 | 0.234 | 0.238\n", + "--------\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": [ + "# Now with parameter estimation enabled\n", + "\n", + "Notice fewer likelihood evaluations are needed. " + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-09T15:18:58.639149Z", + "start_time": "2024-11-09T15:18:50.440834Z" + } + }, + "cell_type": "code", + "source": [ + "# Create the nested sampler class. In this case without any tuning.\n", + "ns = NestedSampler(model=model, parameter_estimation=True)\n", + "termination_reason, state = jax.jit(ns)(random.PRNGKey(432345987))\n", + "results = ns.to_results(termination_reason=termination_reason, state=state)\n", + "ns.summary(results)\n", + "ns.plot_diagnostics(results)\n", + "ns.plot_cornerplot(results)" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------\n", + "Termination Conditions:\n", + "XL < max(XL) * peak_XL_frac\n", + "--------\n", + "likelihood evals: 146580\n", + "samples: 6420\n", + "phantom samples: 5040\n", + "likelihood evals / sample: 22.8\n", + "phantom fraction (%): 78.5%\n", + "--------\n", + "logZ=-8.85 +- 0.34\n", + "max(logL)=0.31\n", + "H=-7.43\n", + "ESS=208\n", + "--------\n", + "clock: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "clock: -0.32 +- 0.91 | -1.48 / -0.25 / 0.68 | -1.6 | -1.56\n", + "--------\n", + "const: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "const: -0.3 +- 1.9 | -2.7 / -0.6 / 2.1 | -1.4 | -1.5\n", + "--------\n", + "dtec: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "dtec: 88.0 +- 17.0 | 70.0 / 87.0 / 112.0 | 107.0 | 105.0\n", + "--------\n", + "uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "uncert: 0.264 +- 0.037 | 0.222 / 0.259 / 0.315 | 0.234 | 0.237\n", + "--------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/albert/git/jaxns/src/jaxns/plotting.py:45: UserWarning: Found samples with zero likelihood evaluations.\n", + " warnings.warn(\"Found samples with zero likelihood evaluations.\")\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 6 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-09T15:18:58.653354Z", + "start_time": "2024-11-09T15:18:58.651218Z" + } + }, + "cell_type": "code", + "source": "", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/examples/gradient_guided.ipynb b/docs/examples/gradient_guided.ipynb new file mode 100644 index 0000000..1372248 --- /dev/null +++ b/docs/examples/gradient_guided.ipynb @@ -0,0 +1,334 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Gradient Guided\n", + "\n", + "This uses a problem from radio interferometry of inferring ionospheric parameters from phase data. We'll show the impact of turning on gradient guided sampling.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:53.533478Z", + "iopub.status.busy": "2024-09-23T22:36:53.532777Z", + "iopub.status.idle": "2024-09-23T22:36:54.814731Z", + "shell.execute_reply": "2024-09-23T22:36:54.814167Z" + }, + "pycharm": { + "is_executing": true + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:28:49.285070Z", + "start_time": "2024-11-09T15:28:47.693471Z" + } + }, + "source": [ + "\n", + "\n", + "import jax\n", + "import pylab as plt\n", + "import tensorflow_probability.substrates.jax as tfp\n", + "from jax import random, numpy as jnp\n", + "\n", + "from jaxns import NestedSampler\n", + "from jaxns import bruteforce_evidence\n", + "\n", + "tfpd = tfp.distributions\n" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/albert/git/jaxns/src/jaxns/internals/mixed_precision.py:14: UserWarning: JAX x64 is not enabled. Setting it now. Check for errors.\n", + " warnings.warn(\"JAX x64 is not enabled. Setting it now. Check for errors.\")\n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'cuda': \n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n", + "WARNING:jax._src.xla_bridge:An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:54.817250Z", + "iopub.status.busy": "2024-09-23T22:36:54.816667Z", + "iopub.status.idle": "2024-09-23T22:36:54.822180Z", + "shell.execute_reply": "2024-09-23T22:36:54.821123Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:28:49.292778Z", + "start_time": "2024-11-09T15:28:49.288551Z" + } + }, + "source": [ + "\n", + "TEC_CONV = -8.4479745 #rad*MHz/mTECU\n", + "CLOCK_CONV = (2e-3 * jnp.pi) #rad/MHz/ns\n", + "\n", + "\n", + "def wrap(phi):\n", + " return (phi + jnp.pi) % (2 * jnp.pi) - jnp.pi\n", + "\n", + "\n", + "def generate_data(key, uncert):\n", + " \"\"\"\n", + " Generate gain data where the phase have a clock const and tec component. This is a model of the impact of the ionosphere on the propagation of radio waves, part of radio interferometry:\n", + "\n", + " phase[:] = tec * (tec_conv / freqs[:]) + clock * (clock_conv * freqs[:]) + const\n", + "\n", + " then the gains are:\n", + "\n", + " gains[:] ~ Normal[{cos(phase[:]), sin(phase[:])}, uncert^2 * I]\n", + "\n", + " phase_obs[:] = ArcTan[gains.imag, gains.real]\n", + "\n", + " Args:\n", + " key:\n", + " uncert: uncertainty of the gains\n", + "\n", + " Returns:\n", + " phase_obs, freqs\n", + " \"\"\"\n", + " freqs = jnp.linspace(121, 166, 24) #MHz\n", + " tec = 90. #mTECU\n", + " const = 2. #rad\n", + " clock = 0.5 #ns\n", + " phase = wrap(tec * (TEC_CONV / freqs) + clock * (CLOCK_CONV * freqs) + const)\n", + " Y = jnp.concatenate([jnp.cos(phase), jnp.sin(phase)], axis=-1)\n", + " Y_obs = Y + uncert * random.normal(key, shape=Y.shape)\n", + " phase_obs = jnp.arctan2(Y_obs[..., freqs.size:], Y_obs[..., :freqs.size])\n", + " return phase, phase_obs, freqs\n" + ], + "outputs": [], + "execution_count": 2 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:54.824732Z", + "iopub.status.busy": "2024-09-23T22:36:54.824265Z", + "iopub.status.idle": "2024-09-23T22:36:55.536048Z", + "shell.execute_reply": "2024-09-23T22:36:55.535452Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:28:50.146837Z", + "start_time": "2024-11-09T15:28:49.440871Z" + } + }, + "source": [ + "# Generate data\n", + "key = random.PRNGKey(43)\n", + "key, data_key = random.split(key)\n", + "phase_underlying, phase_obs, freqs = generate_data(data_key, 0.25)\n", + "plt.scatter(freqs, phase_obs, label='data')\n", + "plt.plot(freqs, phase_underlying, label='Underlying phase')\n", + "plt.legend()\n", + "plt.show()\n", + "# Note: the phase wrapping makes this a difficult problem to solve. As we'll see, the posterior is rather complicated." + ], + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 3 + }, + { + "cell_type": "code", + "metadata": { + "execution": { + "iopub.execute_input": "2024-09-23T22:36:55.537954Z", + "iopub.status.busy": "2024-09-23T22:36:55.537763Z", + "iopub.status.idle": "2024-09-23T22:37:04.591007Z", + "shell.execute_reply": "2024-09-23T22:37:04.590573Z" + }, + "ExecuteTime": { + "end_time": "2024-11-09T15:29:00.021931Z", + "start_time": "2024-11-09T15:28:50.156268Z" + } + }, + "source": [ + "\n", + "from jaxns import Prior, Model\n", + "\n", + "\n", + "def log_normal(x, mean, scale):\n", + " return tfpd.Normal(loc=mean, scale=scale).log_prob(x)\n", + "\n", + "\n", + "def log_likelihood(dtec, const, clock, uncert):\n", + " phase = dtec * (TEC_CONV / freqs) + const + clock * (CLOCK_CONV * freqs)\n", + " logL = log_normal(wrap(wrap(phase) - wrap(phase_obs)), 0., uncert)\n", + " return jnp.sum(logL)\n", + "\n", + "\n", + "def prior_model():\n", + " tec = yield Prior(tfpd.Uniform(-300, 300.), name='dtec')\n", + " const = yield Prior(tfpd.Uniform(-jnp.pi, jnp.pi), name='const')\n", + " clock = yield Prior(tfpd.Uniform(-2., 2.), name='clock')\n", + " uncert = yield Prior(tfpd.HalfNormal(0.25), name='uncert')\n", + "\n", + " return tec, const, clock, uncert\n", + "\n", + "\n", + "model = Model(prior_model=prior_model, log_likelihood=log_likelihood)\n", + "\n", + "model.sanity_check(random.PRNGKey(0), S=100)\n", + "\n", + "log_Z_true = bruteforce_evidence(model=model, S=80)\n", + "print(f\"Approx. log(Z)={log_Z_true}\") # Unsure if this grid is sufficient to get a good estimate of the evidence." + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:jaxns:Sanity check...\n", + "INFO:jaxns:Sanity check passed\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Approx. log(Z)=-8.74251800745667\n" + ] + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-09T15:29:08.717111Z", + "start_time": "2024-11-09T15:29:00.116617Z" + } + }, + "cell_type": "code", + "source": [ + "\n", + "# Create the nested sampler class. In this case without any tuning.\n", + "ns = NestedSampler(model=model, gradient_guided=True)\n", + "termination_reason, state = jax.jit(ns)(random.PRNGKey(432345987))\n", + "results = ns.to_results(termination_reason=termination_reason, state=state)\n", + "ns.summary(results)\n", + "ns.plot_diagnostics(results)\n", + "ns.plot_cornerplot(results)" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/albert/git/jaxns/src/jaxns/samplers/uni_slice_sampler.py:331: UserWarning: Gradient guided slice sampler is experimental and will likely change.\n", + " warnings.warn(\"Gradient guided slice sampler is experimental and will likely change.\")\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------\n", + "Termination Conditions:\n", + "Small remaining evidence\n", + "--------\n", + "likelihood evals: 273883\n", + "samples: 1860\n", + "phantom samples: 0\n", + "likelihood evals / sample: 147.2\n", + "phantom fraction (%): 0.0%\n", + "--------\n", + "logZ=-9.2 +- 0.3\n", + "max(logL)=0.33\n", + "H=-7.85\n", + "ESS=184\n", + "--------\n", + "clock: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "clock: -0.2 +- 1.1 | -1.6 / -0.3 / 1.6 | -1.8 | -1.8\n", + "--------\n", + "const: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "const: -0.2 +- 1.8 | -2.3 / -1.0 / 2.5 | -1.0 | -1.0\n", + "--------\n", + "dtec: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "dtec: 85.0 +- 20.0 | 56.0 / 88.0 / 108.0 | 109.0 | 109.0\n", + "--------\n", + "uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n", + "uncert: 0.266 +- 0.039 | 0.22 / 0.261 / 0.322 | 0.234 | 0.234\n", + "--------\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2024-11-09T15:29:08.731502Z", + "start_time": "2024-11-09T15:29:08.729479Z" + } + }, + "cell_type": "code", + "source": "", + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/src/jaxns/internals/pytree_utils.py b/src/jaxns/internals/pytree_utils.py new file mode 100644 index 0000000..152b7f9 --- /dev/null +++ b/src/jaxns/internals/pytree_utils.py @@ -0,0 +1,26 @@ +import jax +import jax.numpy as jnp + + +def tree_dot(x, y): + dots = jax.tree.leaves(jax.tree.map(jnp.vdot, x, y)) + return sum(dots[1:], start=dots[0]) + + +def tree_norm(x): + norm2 = tree_dot(x, x) + if jnp.issubdtype(norm2.dtype, jnp.complexfloating): + return jnp.sqrt(norm2.real) + return jnp.sqrt(norm2) + + +def tree_mul(x, y): + return jax.tree.map(jax.lax.mul, x, y) + + +def tree_sub(x, y): + return jax.tree.map(jax.lax.sub, x, y) + + +def tree_div(x, y): + return jax.tree.map(jax.lax.div, x, y) diff --git a/src/jaxns/internals/random.py b/src/jaxns/internals/random.py index 8c45d17..1fad429 100644 --- a/src/jaxns/internals/random.py +++ b/src/jaxns/internals/random.py @@ -1,5 +1,6 @@ from typing import Optional +import jax from jax import random, numpy as jnp from jax.scipy import special @@ -72,3 +73,12 @@ def resample_indicies(key: PRNGKey, log_weights: Optional[FloatArray] = None, S: g = -random.gumbel(key, shape=(num_total,)) idx = jnp.argsort(g)[:S] return idx + + +def sample_uniformly_masked(key, v, select_mask, num_samples: int, squeeze: bool = False): + # If no satisfied samples, then chooses randomly from them. Should never happen, but good to know. + log_weights = jnp.where(select_mask, 0., -jnp.inf) + sample_idxs = resample_indicies(key, log_weights=log_weights, S=num_samples, replace=True) + if squeeze: + sample_idxs = jnp.squeeze(sample_idxs) + return jax.tree.map(lambda x: x[sample_idxs], v) diff --git a/src/jaxns/nested_samplers/common/initialisation.py b/src/jaxns/nested_samplers/common/initialisation.py index 38b9c82..c08a1ea 100644 --- a/src/jaxns/nested_samplers/common/initialisation.py +++ b/src/jaxns/nested_samplers/common/initialisation.py @@ -103,5 +103,6 @@ def create_init_termination_register() -> TerminationRegister: plateau=jnp.asarray(False, jnp.bool_), no_seed_points=jnp.asarray(False, jnp.bool_), relative_spread=jnp.asarray(jnp.inf, mp_policy.measure_dtype), - absolute_spread=jnp.asarray(jnp.inf, mp_policy.measure_dtype) + absolute_spread=jnp.asarray(jnp.inf, mp_policy.measure_dtype), + peak_log_XL=jnp.asarray(-jnp.inf, mp_policy.measure_dtype) ) diff --git a/src/jaxns/nested_samplers/common/termination.py b/src/jaxns/nested_samplers/common/termination.py index b14a5a2..6324637 100644 --- a/src/jaxns/nested_samplers/common/termination.py +++ b/src/jaxns/nested_samplers/common/termination.py @@ -26,6 +26,7 @@ def determine_termination( 8-bit -> 256: relative spread of live points < rtol 9-bit -> 512: absolute spread of live points < atol 10-bit -> 1024: no seed points left + 11-bit -> 2048: XL < max(XL) * peak_XL_frac Multiple flags are summed together @@ -136,4 +137,11 @@ def _set_done_bit(bit_done, bit_reason, done, termination_reason): done, termination_reason = _set_done_bit(termination_register.no_seed_points, 10, done=done, termination_reason=termination_reason) + if term_cond.peak_XL_frac is not None: + log_XL = termination_register.evidence_calc.log_X_mean + termination_register.evidence_calc.log_L + peak_log_XL = termination_register.peak_log_XL + XL_reduction_reached = log_XL < peak_log_XL + jnp.log(term_cond.peak_XL_frac) + done, termination_reason = _set_done_bit(XL_reduction_reached, 11, + done=done, termination_reason=termination_reason) + return done, termination_reason diff --git a/src/jaxns/nested_samplers/common/types.py b/src/jaxns/nested_samplers/common/types.py index 16e0414..7f5f352 100644 --- a/src/jaxns/nested_samplers/common/types.py +++ b/src/jaxns/nested_samplers/common/types.py @@ -51,6 +51,7 @@ class TerminationCondition(NamedTuple): efficiency_threshold: Optional[FloatArray] = None rtol: Optional[FloatArray] = None atol: Optional[FloatArray] = None + peak_XL_frac: Optional[FloatArray] = None def __and__(self, other): return TerminationConditionConjunction(conds=[self, other]) @@ -134,6 +135,7 @@ class TerminationRegister(NamedTuple): no_seed_points: BoolArray relative_spread: FloatArray absolute_spread: FloatArray + peak_log_XL: FloatArray class NestedSamplerState(NamedTuple): diff --git a/src/jaxns/nested_samplers/sharded/sharded_static.py b/src/jaxns/nested_samplers/sharded/sharded_static.py index 34a980d..e81cdf1 100644 --- a/src/jaxns/nested_samplers/sharded/sharded_static.py +++ b/src/jaxns/nested_samplers/sharded/sharded_static.py @@ -1,4 +1,5 @@ import dataclasses +import warnings from functools import partial from typing import List, Optional, Tuple, NamedTuple, Any @@ -16,6 +17,7 @@ from jaxns.internals.log_semiring import LogSpace, normalise_log_space from jaxns.internals.maps import create_mesh, tree_device_put, replace_index from jaxns.internals.mixed_precision import mp_policy +from jaxns.internals.random import sample_uniformly_masked, resample_indicies from jaxns.internals.shrinkage_statistics import EvidenceUpdateVariables, _update_evidence_calc_op, \ compute_evidence_stats from jaxns.internals.stats import linear_to_log_stats, effective_sample_size_kish @@ -83,31 +85,20 @@ def _add_samples_to_state(sample_collection: LivePointCollection, return state -def _collect_shell( - mesh: Mesh, - live_point_collection: LivePointCollection, - state: NestedSamplerState, - termination_register: TerminationRegister, - sampler: AbstractSampler, - sampler_state: Any, - shell_size: int -) -> Tuple[LivePointCollection, NestedSamplerState, TerminationRegister]: +def get_samples(key, mesh: Mesh, sampler: AbstractSampler, sampler_state: Any, log_L_contour, num_samples: int): """ - Run nested sampling until `num_samples` samples are collected. + Get samples from the sampler. Args: - mesh: the device mesh to use - live_point_collection: the live point collection - state: the state of the nested sampler at the start - termination_register: the termination register at the start - sampler: sampler to use - sampler_state: the sampler state to use for - shell_size: the size of the shell to collect + key: the PRNG key + mesh: the mesh to use + sampler: the sampler to use + sampler_state: the sampler state + log_L_contour: the log likelihood contour + num_samples: the number of samples to get Returns: - live_point_collection: the live point collection - state: the state of the nested sampler at the end - termination_register: the termination register at the end + samples, phantom_samples """ @partial( @@ -134,6 +125,115 @@ def body(carry, sample_key): ) return sample, phantom_samples + sharded_sample_keys = tree_device_put(jax.random.split(key, num_samples), mesh, ('shard',)) + return get_samples(sharded_sample_keys, log_L_contour, sampler_state) + + +def dynamic_new_live_point_collection( + key, + mesh: Mesh, + state: NestedSamplerState, + sender_sample_idx: IntArray, + sampler: AbstractSampler, + sampler_state: Any, + num_live_points: int +): + """ + Get live points from the sampler for a dynamic slice. + + Args: + mesh: the mesh to use + state: the state + sampler: the sampler + sampler_state: the sampler state + num_live_points: the number of live points to get + + Returns: + live_point_collection, state + """ + log_L_contour = state.sample_collection.log_L[sender_sample_idx] + + new_samples, phantom_samples = get_samples( + key=key, + mesh=mesh, + sampler=sampler, + sampler_state=sampler_state, + log_L_contour=log_L_contour, + num_samples=num_live_points + ) + # Node is sample_idx - 1 + sender_node_idx = sender_sample_idx - jnp.asarray(1, mp_policy.index_dtype) + live_point_collection = LivePointCollection( + sender_node_idx=jnp.full((num_live_points,), sender_node_idx, mp_policy.index_dtype), + U_sample=new_samples.U_sample, + log_L=new_samples.log_L, + log_L_constraint=new_samples.log_L_constraint, + num_likelihood_evaluations=new_samples.num_likelihood_evaluations + ) + + sort_indices = jnp.argsort(live_point_collection.log_L) + live_point_collection = jax.tree_map(lambda x: x[sort_indices], live_point_collection) + + state = add_phantom_samples_to_state(phantom_samples, sender_node_idx, state) + return live_point_collection, state + + +def add_phantom_samples_to_state(phantom_samples, sender_node_idx, state): + """ + Add phantom samples to the state + + Args: + phantom_samples: the phantom samples + sender_node_idx: the sender node index + state: the state + + Returns: + live_point_collection, state + """ + # Add phantom samples (this is an option of user, controlled by `k`) + num_phantom = np.shape(phantom_samples.log_L)[0] + phantom_collection = LivePointCollection( + sender_node_idx=jnp.full((num_phantom,), sender_node_idx, mp_policy.index_dtype), + U_sample=phantom_samples.U_sample, + log_L=phantom_samples.log_L, + log_L_constraint=phantom_samples.log_L_constraint, + num_likelihood_evaluations=phantom_samples.num_likelihood_evaluations + ) + state = _add_samples_to_state( + sample_collection=phantom_collection, + state=state, + is_phantom=True + ) + return state + + +def _collect_shell( + mesh: Mesh, + live_point_collection: LivePointCollection, + state: NestedSamplerState, + termination_register: TerminationRegister, + sampler: AbstractSampler, + sampler_state: Any, + shell_size: int +) -> Tuple[LivePointCollection, NestedSamplerState, TerminationRegister]: + """ + Run nested sampling until `num_samples` samples are collected. + + Args: + mesh: the device mesh to use + live_point_collection: the live point collection + state: the state of the nested sampler at the start + termination_register: the termination register at the start + sampler: sampler to use + sampler_state: the sampler state to use for + shell_size: the size of the shell to collect + + Returns: + live_point_collection: the live point collection + state: the state of the nested sampler at the end + termination_register: the termination register at the end + """ + # Find and discard shell front_size = np.shape(live_point_collection.log_L)[0] # always leave live points sorted so that we don't need to do it here. @@ -149,8 +249,14 @@ def body(carry, sample_key): state = state._replace(key=key) supremum_index = shell_size - 1 # Biggest of discarded log_L_contour = live_point_collection.log_L[supremum_index] - sharded_sample_keys = tree_device_put(jax.random.split(sample_key, shell_size), mesh, ('shard',)) - new_samples, phantom_samples = get_samples(sharded_sample_keys, log_L_contour, sampler_state) + new_samples, phantom_samples = get_samples( + key=sample_key, + mesh=mesh, + sampler=sampler, + sampler_state=sampler_state, + log_L_contour=log_L_contour, + num_samples=shell_size + ) # Sender is the maximum log_L sample from discarded, i.e. that last added discarded sender_node_idx = state.next_sample_idx - jnp.asarray(1, mp_policy.index_dtype) new_sample_collection = LivePointCollection( @@ -167,26 +273,14 @@ def body(carry, sample_key): ) sort_indices = jnp.argsort(live_point_collection.log_L) live_point_collection = jax.tree_map(lambda x: x[sort_indices], live_point_collection) - # compute insert index KS-statistic + # TODO: compute insert index KS-statistic _, insert_indices = jax.lax.top_k(-sort_indices, k=shell_size) - # Add phantom samples (this is an option of user, controlled by `k`) - num_phantom = np.shape(phantom_samples.log_L)[0] - phantom_collection = LivePointCollection( - sender_node_idx=jnp.full((num_phantom,), sender_node_idx, mp_policy.index_dtype), - U_sample=phantom_samples.U_sample, - log_L=phantom_samples.log_L, - log_L_constraint=phantom_samples.log_L_constraint, - num_likelihood_evaluations=phantom_samples.num_likelihood_evaluations - ) - state = _add_samples_to_state( - sample_collection=phantom_collection, - state=state, - is_phantom=True - ) + state = add_phantom_samples_to_state(phantom_samples, sender_node_idx, state) # Update termination register - # TODO: technically we must compute the num live points in case there is a plateau + # Technically we must compute the num live points in case there is a plateau. + # but it gets done properly in to_results. evidence_calc, _ = cumulative_op_static( op=_update_evidence_calc_op, init=termination_register.evidence_calc, @@ -213,6 +307,7 @@ def body(carry, sample_key): absolute_spread = jnp.abs(live_point_collection.log_L[-1] - live_point_collection.log_L[0]) relative_spread = 2. * absolute_spread / jnp.abs(live_point_collection.log_L[0] + live_point_collection.log_L[-1]) no_seed_points = live_point_collection.log_L[supremum_index] >= live_point_collection.log_L[-1] + peak_log_XL = jnp.maximum(termination_register.peak_log_XL, evidence_calc.log_X_mean + evidence_calc.log_L) termination_register = TerminationRegister( num_samples_used=state.num_samples, evidence_calc=evidence_calc, @@ -223,11 +318,112 @@ def body(carry, sample_key): plateau=plateau, no_seed_points=no_seed_points, relative_spread=relative_spread, - absolute_spread=absolute_spread + absolute_spread=absolute_spread, + peak_log_XL=peak_log_XL ) return live_point_collection, state, termination_register +def _dynamic_posterior_refinement_iteration( + mesh: Mesh, + state: NestedSamplerState, + sampler: AbstractSampler, + termination_register: TerminationRegister, + refine_threshold: float, + num_live_points: int +) -> NestedSamplerState: + """ + Perform a dynamic posterior refinement iteration. + + Args: + mesh: the mesh to use + state: the state of the nested sampler + sampler: the sampler to use + termination_register: the termination register + refine_threshold: the threshold for refinement, will attach new points from somewhere within a masked region, + where XL > max(XL) * refine_threshold + num_live_points: the number of live points to get + + Returns: + the updated state + """ + key, sample_key, ephemeral_key, reseed_key, select_attach_key = jax.random.split(state.key, 5) + state = state._replace(key=key) + sample_collection = state.sample_collection + + # Get the part of prior region that contains most of the posterior mass. + # This is where XL is largest. + sample_tree = SampleTreeGraph( + sender_node_idx=sample_collection.sender_node_idx, + log_L=sample_collection.log_L + ) + num_samples = jnp.minimum( + state.num_samples, + jnp.asarray(state.sample_collection.log_L.size, mp_policy.count_dtype) + ) + live_point_counts = count_crossed_edges(sample_tree=sample_tree, num_samples=num_samples) + num_live_points_per_sample = live_point_counts.num_live_points + log_L = sample_tree.log_L[live_point_counts.samples_indices] + final_evidence_stats, per_sample_evidence_stats = compute_evidence_stats( + log_L=log_L, + num_live_points=num_live_points_per_sample, + num_samples=num_samples + ) + log_XL = per_sample_evidence_stats.log_X_mean + per_sample_evidence_stats.log_L + peak_log_XL = jnp.max(log_XL) + + # Randomly choose attach point + # TODO: ensure attachment certain to be within sample set. + select_mask = jnp.logical_and( + log_XL > peak_log_XL + np.log(refine_threshold), + jnp.logical_not(sample_collection.phantom) + ) + log_weights = jnp.where(select_mask, 0., -jnp.inf) + sample_root_idx = resample_indicies(select_attach_key, log_weights, 1)[0] + + # Create a fake live point collection to create sampler state. We don't care about the samples being i.i.d. + log_L_constraint = sample_collection.log_L[sample_root_idx] + select_mask = sample_collection.log_L > log_L_constraint + ephemeral_sample_collection: SampleCollection = sample_uniformly_masked( + key=reseed_key, + v=sample_collection, + select_mask=select_mask, + num_samples=num_live_points + ) + ephemeral_live_point_collection = LivePointCollection( + sender_node_idx=ephemeral_sample_collection.sender_node_idx, + U_sample=ephemeral_sample_collection.U_samples, + log_L=ephemeral_sample_collection.log_L, + log_L_constraint=sample_collection.log_L[ephemeral_sample_collection.sender_node_idx + 1], + num_likelihood_evaluations=ephemeral_sample_collection.num_likelihood_evaluations + ) + ephemeral_state = EphemeralState( + key=ephemeral_key, + live_points_collection=ephemeral_live_point_collection, + termination_register=termination_register + ) + sampler_state = sampler.pre_process(ephemeral_state) + + # Get a proper i.i.d. set of live points + live_point_collection, state = dynamic_new_live_point_collection( + key=sample_key, + mesh=mesh, + state=state, + sender_sample_idx=sample_root_idx, + sampler=sampler, + sampler_state=sampler_state, + num_live_points=num_live_points + ) + + # Add all live points to the state + state = _add_samples_to_state( + sample_collection=live_point_collection, + state=state, + is_phantom=False + ) + return state + + def _main_ns_thread( mesh: Mesh, live_point_collection: LivePointCollection, @@ -421,6 +617,8 @@ class ShardedStaticNestedSampler(AbstractNestedSampler): sampler: AbstractSampler num_live_points: int shell_fraction: Optional[float] = None + num_dynamic_refinement_iterations: int = 0 + refine_threshold: float = 0.01 devices: Optional[List[xla_client.Device]] = None verbose: bool = False @@ -448,6 +646,9 @@ def __post_init__(self): num_phantom_points=self.sampler.num_phantom() ) + if self.num_dynamic_refinement_iterations > 0: + warnings.warn("Dynamic refinement is experimental and may not work as expected.") + def _to_results(self, termination_reason: IntArray, state: NestedSamplerState, trim: bool) -> NestedSamplerResults: @@ -636,4 +837,15 @@ def _run(self, key: PRNGKey, term_cond: TerminationCondition) -> Tuple[ is_phantom=False ) + def body(i, state: NestedSamplerState) -> NestedSamplerState: + state = _dynamic_posterior_refinement_iteration( + mesh=mesh, state=state, sampler=self.sampler, termination_register=termination_register, + refine_threshold=self.refine_threshold, + num_live_points=self.num_live_points + ) + return state + + if self.num_dynamic_refinement_iterations > 0: + state = jax.lax.fori_loop(0, self.num_dynamic_refinement_iterations, body, state) + return termination_reason, termination_register, state diff --git a/src/jaxns/plotting.py b/src/jaxns/plotting.py index 6785030..84f9c62 100644 --- a/src/jaxns/plotting.py +++ b/src/jaxns/plotting.py @@ -30,7 +30,7 @@ def plot_diagnostics(results: NestedSamplerResults, save_name=None): """ num_samples = int(results.total_num_samples) - fig, axs = plt.subplots(5, 1, sharex=True, figsize=(8, 12)) + fig, axs = plt.subplots(6, 1, sharex=True, figsize=(8, 15)) log_X = np.asarray(results.log_X_mean[:num_samples]) num_live_points_per_sample = np.asarray(results.num_live_points_per_sample[:num_samples]) log_L = np.asarray(results.log_L_samples[:num_samples]) @@ -80,7 +80,13 @@ def plot_diagnostics(results: NestedSamplerResults, save_name=None): axs[4].set_ylabel("sampler efficiency") axs[4].set_ylim(0., 1.05) axs[4].legend() - axs[4].set_xlabel(r'$- \log X$') + + # Plot X*L vs -log(X) + XL = (LogSpace(log_X) * LogSpace(log_L)).value + axs[5].plot(-log_X, XL, c='black') + axs[5].set_ylabel(r'$X L$') + + axs[5].set_xlabel(r'$- \log X$') if save_name is not None: fig.savefig(save_name, bbox_inches='tight', dpi=300, pad_inches=0.0) plt.show() diff --git a/src/jaxns/public.py b/src/jaxns/public.py index 01b1fcf..215ba10 100644 --- a/src/jaxns/public.py +++ b/src/jaxns/public.py @@ -1,5 +1,4 @@ import dataclasses -import warnings from typing import Optional, Tuple, Union, List import jax @@ -43,42 +42,53 @@ class NestedSampler: s: number of slices to use per dimension. Defaults to 4. k: number of phantom samples to use. Defaults to 0. c: number of parallel Markov-chains to use. Defaults to 20 * D. - num_parallel_workers: number of parallel workers to use. Defaults to 1. Experimental feature. devices: devices to use. Defaults to all available devices. difficult_model: if True, uses more robust default settings. Defaults to False. parameter_estimation: if True, uses more robust default settings for parameter estimation. Defaults to False. + shell_fraction: fraction of the shell to use for the slice sampler. Defaults to 0.5. + gradient_guided: if True, uses gradient guided sampling. Defaults to False. init_efficiency_threshold: if > 0 then use uniform sampling first down to this acceptance efficiency. 0 turns it off. - verbose: whether to use JAX + verbose: whether to log progress. """ model: BaseAbstractModel max_samples: Optional[Union[int, float]] = None num_live_points: Optional[int] = None + num_slices: Optional[int] = None s: Optional[int] = None k: Optional[int] = None c: Optional[int] = None - num_parallel_workers: Optional[int] = None devices: Optional[List[xla_client.Device]] = None difficult_model: bool = False parameter_estimation: bool = False shell_fraction: float = 0.5 + gradient_guided: bool = False init_efficiency_threshold: float = 0.1 verbose: bool = False def __post_init__(self): - if self.difficult_model: - self.s = 10 if self.s is None else int(self.s) - else: - self.s = 5 if self.s is None else int(self.s) - if self.s <= 0: - raise ValueError(f"Expected s > 0, got s={self.s}") + # Determine number of slices per acceptance + if self.num_slices is None: + if self.difficult_model: + self.s = 10 if self.s is None else int(self.s) + else: + self.s = 5 if self.s is None else int(self.s) + if self.s <= 0: + raise ValueError(f"Expected s > 0, got s={self.s}") + self.num_slices = self.model.U_ndims * self.s + self.num_slices = int(self.num_slices) + + # Determine number of phantom samples if self.parameter_estimation: max_k = self.s * self.model.U_ndims - 1 self.k = min(self.model.U_ndims, max_k) if self.k is None else int(self.k) else: self.k = 0 if self.k is None else int(self.k) - if not (0 <= self.k < self.s * self.model.U_ndims): - raise ValueError(f"Expected 0 <= k < s * U_ndims, got k={self.k}, s={self.s}, U_ndims={self.model.U_ndims}") + if not (0 <= self.k < self.num_slices): + raise ValueError( + f"Expected 0 <= k < num_slices, got k={self.k}, num_slices={self.num_slices}, U_ndims={self.model.U_ndims}") + + # Determine number of parallel Markov-chains if self.num_live_points is not None: self.c = max(1, int(self.num_live_points / (self.k + 1))) logger.info(f"Number of Markov-chains set to: {self.c}") @@ -87,30 +97,32 @@ def __post_init__(self): self.c = 100 * self.model.U_ndims if self.c is None else int(self.c) else: self.c = 30 * self.model.U_ndims if self.c is None else int(self.c) - if self.c <= 0: - raise ValueError(f"Expected c > 0, got c={self.c}") + if self.c <= 0: + raise ValueError(f"Expected c > 0, got c={self.c}") + # Sanity check for max_samples (should be able to at least do one shrinkage) if self.max_samples is None: - # Default to 100 shrinkages + # Default to 100 shrinkages. self.max_samples = self.c * (self.k + 1) * 100 self.max_samples = int(self.max_samples) - if self.num_parallel_workers is not None: - warnings.warn("`num_parallel_workers` is depreciated. Use `devices` instead.") + self._nested_sampler = ShardedStaticNestedSampler( model=self.model, num_live_points=self.c, max_samples=self.max_samples, sampler=UniDimSliceSampler( model=self.model, - num_slices=self.model.U_ndims * self.s, + num_slices=self.num_slices, num_phantom_save=self.k, midpoint_shrink=not self.difficult_model, + gradient_guided=self.gradient_guided, perfect=True ), init_efficiency_threshold=self.init_efficiency_threshold, shell_fraction=self.shell_fraction, devices=self.devices, - verbose=self.verbose + verbose=self.verbose, + ) # Back propagate any updates here self.num_live_points = self._nested_sampler.num_live_points @@ -139,10 +151,16 @@ def __call__(self, key: PRNGKey, term_cond: Optional[TerminationCondition] = Non termination reason, state """ if term_cond is None: - term_cond = TerminationCondition( - dlogZ=jnp.asarray(np.log(1. + 1e-3), mp_policy.measure_dtype), - max_samples=jnp.asarray(jnp.iinfo(mp_policy.count_dtype).max, mp_policy.count_dtype) - ) + if self.parameter_estimation: + term_cond = TerminationCondition( + peak_XL_frac=jnp.asarray(0.1, mp_policy.measure_dtype), + max_samples=jnp.asarray(jnp.iinfo(mp_policy.count_dtype).max, mp_policy.count_dtype) + ) + else: + term_cond = TerminationCondition( + dlogZ=jnp.asarray(np.log(1. + 1e-3), mp_policy.measure_dtype), + max_samples=jnp.asarray(jnp.iinfo(mp_policy.count_dtype).max, mp_policy.count_dtype) + ) term_cond = term_cond._replace( max_samples=( jnp.minimum(term_cond.max_samples, jnp.asarray(self._nested_sampler.max_samples, mp_policy.count_dtype)) diff --git a/src/jaxns/samplers/uni_slice_sampler.py b/src/jaxns/samplers/uni_slice_sampler.py index ca55a44..7233de1 100644 --- a/src/jaxns/samplers/uni_slice_sampler.py +++ b/src/jaxns/samplers/uni_slice_sampler.py @@ -1,12 +1,15 @@ import dataclasses -from typing import NamedTuple, Tuple, Any +import warnings +from typing import NamedTuple, Tuple, Any, Callable import jax -from jax import numpy as jnp, random, lax +from jax import numpy as jnp, random from jaxns.framework.bases import BaseAbstractModel from jaxns.internals.cumulative_ops import cumulative_op_static from jaxns.internals.mixed_precision import mp_policy +from jaxns.internals.pytree_utils import tree_dot +from jaxns.internals.random import sample_uniformly_masked from jaxns.internals.types import PRNGKey, FloatArray, BoolArray, IntArray, UType from jaxns.nested_samplers.common.types import Sample, SampleCollection, LivePointCollection from jaxns.samplers.abc import EphemeralState @@ -108,29 +111,38 @@ def _shrink_interval(key: PRNGKey, t: FloatArray, left: FloatArray, right: Float return left, right -def _new_proposal(key: PRNGKey, - seed_point: SeedPoint, - midpoint_shrink: bool, - alpha: jax.Array, - perfect: bool, - gradient_slice: bool, - log_L_constraint: FloatArray, - model: BaseAbstractModel) -> Tuple[FloatArray, FloatArray, IntArray]: +def _new_proposal( + key: PRNGKey, + seed_point: SeedPoint, + direction: UType, + midpoint_shrink: bool, + alpha: jax.Array, + perfect: bool, + gradient_slice: bool, + gradient_guided: bool, + log_L_constraint: FloatArray, + log_likelihood_fn: Callable, + grad_fn: Callable +) -> Tuple[FloatArray, FloatArray, FloatArray, IntArray]: """ Sample from a slice about a seed point. Args: key: PRNG key seed_point: the seed point to sample from + direction: the direction to sample along midpoint_shrink: if true then contract to the midpoint of interval on rejection. Otherwise, normal contract alpha: exponential shrinkage factor perfect: if true then perform exponential shrinkage from maximal bounds, requiring no step-out procedure. gradient_slice: if true the slice along gradient direction + gradient_guided: if true then do householder reflections log_L_constraint: the constraint to sample within - model: the model to sample from + log_likelihood_fn: the log-likelihood function + grad_fn: the gradient function Returns: point_U: the new sample + momentum: the new momentum log_L: the log-likelihood of the new sample num_likelihood_evaluations: the number of likelihood evaluations performed """ @@ -170,7 +182,7 @@ def body(carry: Carry) -> Carry: left=left, right=right ) - log_L = model.forward(point_U) + log_L = log_likelihood_fn(point_U) num_likelihood_evaluations = carry.num_likelihood_evaluations + jnp.ones_like(carry.num_likelihood_evaluations) return Carry( key=key, @@ -183,25 +195,25 @@ def body(carry: Carry) -> Carry: direction=carry.direction ) - key, n_key, t_key = random.split(key, 3) + # Chose the direction to go + num_likelihood_evaluations = jnp.full((), 0, mp_policy.count_dtype) + + run_key, n_key, t_key, after_key = random.split(key, 4) if gradient_slice: - direction = jax.grad(model.forward)(seed_point.U0) - norm = jnp.linalg.norm(direction) - direction /= norm - direction = jnp.where( - jnp.bitwise_or(jnp.equal(norm, jnp.zeros_like(norm)), ~jnp.isfinite(norm)), - _sample_direction(n_key, seed_point.U0.size), - direction - ) - num_likelihood_evaluations = jnp.full((), 1, mp_policy.count_dtype) + # climb the gradient + grad = grad_fn(seed_point.U0) + num_likelihood_evaluations += jnp.ones_like(num_likelihood_evaluations) + grad_norm = jnp.linalg.norm(grad) + grad_mask = jnp.bitwise_or(jnp.equal(grad_norm, jnp.zeros_like(grad_norm)), ~jnp.isfinite(grad_norm)) + grad_dir = grad / grad_norm + direction = jnp.where(grad_mask, direction, grad_dir) (left, right) = _slice_bounds( point_U0=seed_point.U0, direction=direction ) - left = jnp.zeros_like(left) + left = jnp.where(grad_mask, left, jnp.zeros_like(left)) else: - direction = _sample_direction(n_key, seed_point.U0.size) - num_likelihood_evaluations = jnp.full((), 0, mp_policy.count_dtype) + if perfect: (left, right) = _slice_bounds( point_U0=seed_point.U0, @@ -209,7 +221,8 @@ def body(carry: Carry) -> Carry: ) else: # TODO: implement doubling step out - raise NotImplementedError("TODO: implement doubling step out") + raise NotImplementedError("Step out not implemented.") + point_U, t = _pick_point_in_interval( key=t_key, point_U0=seed_point.U0, @@ -217,9 +230,10 @@ def body(carry: Carry) -> Carry: left=left, right=right ) - log_L = model.forward(point_U) + log_L = log_likelihood_fn(point_U) + num_likelihood_evaluations += jnp.ones_like(num_likelihood_evaluations) init_carry = Carry( - key=key, + key=run_key, direction=direction, left=left, right=right, @@ -229,12 +243,40 @@ def body(carry: Carry) -> Carry: num_likelihood_evaluations=num_likelihood_evaluations ) - carry = lax.while_loop( + carry = jax.lax.while_loop( cond_fun=cond, body_fun=body, init_val=init_carry ) - return carry.point_U, carry.log_L, carry.num_likelihood_evaluations + + # Update direction + direction = carry.direction + num_likelihood_evaluations = carry.num_likelihood_evaluations + if gradient_guided: + # Perform a Householder reflection at the accepted point + after_key1, after_key2 = jax.random.split(after_key, 2) + grad = grad_fn(carry.point_U) + num_likelihood_evaluations += jnp.ones_like(num_likelihood_evaluations) + grad_norm = jnp.linalg.norm(grad) + grad_mask = jnp.bitwise_or(jnp.equal(grad_norm, jnp.zeros_like(grad_norm)), ~jnp.isfinite(grad_norm)) + grad = grad / grad_norm + + reflect_direction = direction - 2 * tree_dot(direction, grad) * grad + reflect_direction /= jnp.linalg.norm(reflect_direction) + + random_direction = _sample_direction(after_key1, direction.size) + + choose_dir = jax.random.randint(after_key2, shape=(), minval=0, maxval=2) + direction = jnp.where( + choose_dir == 0, + reflect_direction, + random_direction + ) + direction = jnp.where(grad_mask, random_direction, direction) + else: + # Randomly choose a new direction + direction = _sample_direction(after_key, direction.size) + return carry.point_U, direction, carry.log_L, num_likelihood_evaluations @dataclasses.dataclass(eq=False) @@ -254,6 +296,7 @@ class UniDimSliceSampler(BaseAbstractMarkovSampler[SampleCollection]): Note: Perfect is a misnomer, as perfection also depends on the number of slices between acceptance. gradient_slice: if true then always slice along increasing gradient direction. adaptive_shrink: if true then shrink interval to random point in interval, rather than midpoint. + gradient_guided: if true then do householder reflections at between proposals with a 50% probability. """ model: BaseAbstractModel @@ -263,6 +306,7 @@ class UniDimSliceSampler(BaseAbstractMarkovSampler[SampleCollection]): perfect: bool gradient_slice: bool = False adaptive_shrink: bool = False + gradient_guided: bool = False def __post_init__(self): if self.num_slices < 1: @@ -278,10 +322,13 @@ def __post_init__(self): self.perfect = bool(self.perfect) self.gradient_slice = bool(self.gradient_slice) self.adaptive_shrink = bool(self.adaptive_shrink) + self.gradient_guided = bool(self.gradient_guided) if self.adaptive_shrink: raise NotImplementedError("Adaptive shrinkage not implemented.") if not self.perfect: raise ValueError("Only perfect slice sampler is implemented.") + if self.gradient_guided: + warnings.warn("Gradient guided slice sampler is experimental and will likely change.") def num_phantom(self) -> int: return self.num_phantom_save @@ -289,14 +336,14 @@ def num_phantom(self) -> int: def _pre_process(self, ephemeral_state: EphemeralState) -> Any: if self.perfect: # nothing needed return ephemeral_state.live_points_collection - else: # TODO: step out with doubling, using ellipsoidal clustering + else: # TODO: step out with doubling return ephemeral_state.live_points_collection def _post_process(self, ephemeral_state: EphemeralState, sampler_state: Any) -> Any: if self.perfect: # nothing needed return ephemeral_state.live_points_collection - else: # TODO: step out with doubling, using ellipsoidal clustering, could shrink ellipsoids + else: # TODO: step out with doubling return ephemeral_state.live_points_collection def get_seed_point(self, key: PRNGKey, sampler_state: LivePointCollection, @@ -305,24 +352,17 @@ def get_seed_point(self, key: PRNGKey, sampler_state: LivePointCollection, sample_collection = sampler_state select_mask = sample_collection.log_L > log_L_constraint - # If non satisfied samples, then choose randomly from them. - any_satisfied = jnp.any(select_mask) - yes_ = jnp.asarray(0., jnp.float32) - no_ = jnp.asarray(-jnp.inf, jnp.float32) - unnorm_select_log_prob = jnp.where( - any_satisfied, - jnp.where(select_mask, yes_, no_), - yes_ - ) - # Choose randomly where mask is True - g = random.gumbel(key, shape=unnorm_select_log_prob.shape) - sample_idx = jnp.argmax(g + unnorm_select_log_prob) - return SeedPoint( - U0=sample_collection.U_sample[sample_idx], - log_L0=sample_collection.log_L[sample_idx] + seed_point = sample_uniformly_masked( + key=key, + v=SeedPoint(U0=sample_collection.U_sample, log_L0=sample_collection.log_L), + select_mask=select_mask, + num_samples=1, + squeeze=True ) + return seed_point + def get_sample_from_seed(self, key: PRNGKey, seed_point: SeedPoint, log_L_constraint: FloatArray, sampler_state: SampleCollection) -> Tuple[Sample, Sample]: @@ -330,26 +370,41 @@ class XType(NamedTuple): key: jax.Array alpha: jax.Array - def propose_op(sample: Sample, x: XType) -> Sample: - U_sample, log_L, num_likelihood_evaluations = _new_proposal( + log_likelihood_fn = self.model.forward + grad_fn = jax.grad(log_likelihood_fn) + + class Carry(NamedTuple): + sample: Sample + direction: UType + + def propose_op(carry: Carry, x: XType) -> Carry: + U_sample, direction, log_L, num_likelihood_evaluations = _new_proposal( key=x.key, seed_point=SeedPoint( - U0=sample.U_sample, - log_L0=sample.log_L + U0=carry.sample.U_sample, + log_L0=carry.sample.log_L ), + direction=carry.direction, midpoint_shrink=self.midpoint_shrink, alpha=x.alpha, perfect=self.perfect, gradient_slice=self.gradient_slice, - log_L_constraint=sample.log_L_constraint, - model=self.model + gradient_guided=self.gradient_guided, + log_L_constraint=carry.sample.log_L_constraint, + log_likelihood_fn=log_likelihood_fn, + grad_fn=grad_fn ) - return Sample( - U_sample=U_sample, - log_L_constraint=sample.log_L_constraint, - log_L=log_L, - num_likelihood_evaluations=num_likelihood_evaluations + sample.num_likelihood_evaluations + + carry = Carry( + sample=Sample( + U_sample=U_sample, + log_L_constraint=carry.sample.log_L_constraint, + log_L=log_L, + num_likelihood_evaluations=num_likelihood_evaluations + carry.sample.num_likelihood_evaluations + ), + direction=direction ) + return carry init_sample = Sample( U_sample=seed_point.U0, @@ -357,19 +412,30 @@ def propose_op(sample: Sample, x: XType) -> Sample: log_L=seed_point.log_L0, num_likelihood_evaluations=jnp.asarray(0, mp_policy.count_dtype) ) + + direction_key, sample_key = jax.random.split(key, 2) + + n = init_sample.U_sample.size + direction = _sample_direction(direction_key, n) + + init_carry = Carry( + sample=init_sample, + direction=direction + ) + xs = XType( - key=random.split(key, self.num_slices), + key=random.split(sample_key, self.num_slices), alpha=jnp.linspace(0.5, 1., self.num_slices) ) - final_sample, cumulative_samples = cumulative_op_static( + final_carry, cumulative_samples = cumulative_op_static( op=propose_op, - init=init_sample, + init=init_carry, xs=xs ) # Last sample is the final sample, the rest are potential phantom samples # Take only the last num_phantom_save phantom samples - phantom_samples: Sample = jax.tree.map(lambda x: x[-(self.num_phantom_save + 1):-1], cumulative_samples) + phantom_samples: Sample = jax.tree.map(lambda x: x[-(self.num_phantom_save + 1):-1], cumulative_samples.sample) phantom_samples = phantom_samples._replace( num_likelihood_evaluations=jnp.full( @@ -378,4 +444,4 @@ def propose_op(sample: Sample, x: XType) -> Sample: mp_policy.count_dtype ) ) - return final_sample, phantom_samples + return final_carry.sample, phantom_samples diff --git a/src/jaxns/utils.py b/src/jaxns/utils.py index b8c02d3..855418c 100644 --- a/src/jaxns/utils.py +++ b/src/jaxns/utils.py @@ -291,6 +291,33 @@ def summary(results: NestedSamplerResults, with_parametrised: bool = False, f_ob f_obj: file-like object to write summary to. If None, prints to stdout. """ + samples = results.samples + if with_parametrised: + samples.update(results.parametrised_samples) + log_L_samples = results.log_L_samples + log_dp_mean = results.log_dp_mean + num_samples = int(results.total_num_samples) + if np.isnan(results.ESS): + ESS = 100 + else: + ESS = int(results.ESS) + # Trim + samples = jax.tree.map(lambda x: x[:num_samples], samples) + log_L_samples = log_L_samples[:num_samples] + log_dp_mean = log_dp_mean[:num_samples] + + max_like_idx = np.argmax(log_L_samples) + max_like_points = jax.tree.map(lambda x: x[max_like_idx], samples) + + uniform_samples = resample(random.PRNGKey(23426), + samples, + log_dp_mean, + S=max(100, ESS), + replace=True) + + max_map_idx = np.argmax(results.log_posterior_density) + map_points = jax.tree.map(lambda x: x[max_map_idx], samples) + main_s = [] def _print(s): @@ -307,7 +334,7 @@ def _round(v, uncert_v): return float(v) def _print_termination_reason(_termination_reason: int): - termination_bit_mask = _bit_mask(int(_termination_reason), width=11) + termination_bit_mask = _bit_mask(int(_termination_reason), width=12) for bit, condition in zip(termination_bit_mask, [ 'Reached max samples', @@ -320,7 +347,8 @@ def _print_termination_reason(_termination_reason: int): 'All live-points are on a single plateau (sign of possible precision error)', 'relative spread of live points < rtol', 'absolute spread of live points < atol', - 'no seed points left (consider decreasing shell_fraction)' + 'no seed points left (consider decreasing shell_fraction)', + 'XL < max(XL) * peak_XL_frac' ]): if bit == 1: _print(condition) @@ -349,7 +377,7 @@ def _print_termination_reason(_termination_reason: int): f"logZ={_round(results.log_Z_mean, results.log_Z_uncert)} +- {_round(results.log_Z_uncert, results.log_Z_uncert)}" ) _print( - f"max(logL)={_round(np.max(results.log_L_samples), results.log_Z_uncert)}" + f"max(logL)={_round(log_L_samples[max_like_idx], results.log_Z_uncert)}" ) # _print("H={} +- {}".format( # _round(results.H_mean, results.H_uncert), _round(results.H_uncert, results.H_uncert))) @@ -360,33 +388,6 @@ def _print_termination_reason(_termination_reason: int): f"ESS={np.asarray(results.ESS, np.int64)}" ) - samples = results.samples - if with_parametrised: - samples.update(results.parametrised_samples) - log_L_samples = results.log_L_samples - log_dp_mean = results.log_dp_mean - num_samples = int(results.total_num_samples) - if np.isnan(results.ESS): - ESS = 100 - else: - ESS = int(results.ESS) - # Trim - samples = jax.tree.map(lambda x: x[:num_samples], samples) - log_L_samples = log_L_samples[:num_samples] - log_dp_mean = log_dp_mean[:num_samples] - - max_like_idx = np.argmax(log_L_samples) - max_like_points = jax.tree.map(lambda x: x[max_like_idx], samples) - - uniform_samples = resample(random.PRNGKey(23426), - samples, - log_dp_mean, - S=max(100, ESS), - replace=True) - - max_map_idx = np.argmax(results.log_posterior_density) - map_points = jax.tree.map(lambda x: x[max_map_idx], samples) - for name in uniform_samples.keys(): _samples = uniform_samples[name].reshape((uniform_samples[name].shape[0], -1)) _max_like_points = max_like_points[name].reshape((-1,))