Repository: Joshuaalbert/jaxns (language: python)

Issue:
Performance degradation as max_samples increases
**Describe the bug**
In 2.3 I've refactored the algorithm for improvements but there's a loop where I'm pushing samples between iterations. This must be where slow down is happening. I'll profile it, and determine for sure. I don't think the entire state is needed per iteration so it should be fairly trivial to resolve the slow down. Slow down happens around `max_samples>1e6`.

**JAXNS version**

2.3.x



Discussion / hints:
[perfetto_trace_1e8_constant_likelihood.json.gz](https://github.com/Joshuaalbert/jaxns/files/13741430/perfetto_trace_1e8_constant_likelihood.json.gz)
[perfetto_trace_1e6_constant_likelihood.json.gz](https://github.com/Joshuaalbert/jaxns/files/13741432/perfetto_trace_1e6_constant_likelihood.json.gz)
[perfetto_trace_1e3_constant_likelihood.json.gz](https://github.com/Joshuaalbert/jaxns/files/13741435/perfetto_trace_1e3_constant_likelihood.json.gz)


Fix patch:
diff --git a/README.md b/README.md
index 11fa19f7..d7fa12c7 100644
--- a/README.md
+++ b/README.md
@@ -20,17 +20,217 @@ JAXNS is:
 2) coded in JAX in a manner that allows lowering the entire inference algorithm to XLA primitives, which are
    JIT-compiled for high performance;
 3) continuously improving on its mission of making nested sampling faster, easier, and more powerful; and
-4) citable, and you can read an (old) pre-print here: (https://arxiv.org/abs/2012.15286).
+4) citable, use the (old) pre-print here: (https://arxiv.org/abs/2012.15286).
+
+## JAXNS Probabilistic Programming Framework
+
+JAXNS provides a powerful JAX-based probabilistic programming framework, which allows you to define probabilistic
+models easily, and use them for advanced purposes. Probabilistic models can have both Bayesian and parameterised
+variables.
+Bayesian variables are random variables, and are sampled from a prior distribution.
+Parameterised variables are point-wise representations of a prior distribution, and are thus not random.
+Associated with them is the log-probability of the prior distribution at that point.
+
+Let's break apart an example of a simple probabilistic model. Note, this example can also be followed
+in [docs/examples/intro_example.ipynb](docs/examples/intro_example.ipynb).
+
+### Defining a probabilistic model
+
+Prior models are functios that produce generators of `Prior` objects.
+The function must eventually return the inputs to the likelihood function.
+The returned values of a yielded `Prior` is a simple JAX array, i.e. you can do anything you want to it with JAX ops.
+The rules of static programming apply, i.e. you cannot dynamically allocate arrays.
+
+JAXNS makes use of the Tensorflow Probability library for defining prior distributions, thus you can use __almost__
+any of the TFP distributions. You can also use any of the TFP bijectors to define transformed distributions.
+
+Distributions does have some requirements to be valid for use in JAXNS.
+
+1. They must have a quantile function, i.e. `dist.quantile(dist.cdf(x)) == x`.
+2. They must have a `log_prob` method that returns the log-probability of the distribution at a given value.
+
+Most of the TFP distributions satisfy these requirements.
+
+JAXNS has some special priors defined that can't be defined from TFP, see `jaxns.framework.special_priors`. You can
+always request more if you need them.
+
+Prior variables __may__ be named but don't have to be. If they are named then they can be collected later via a
+transformation, otherwise they are deemed hidden variables.
+
+The output values of prior models are the inputs to the likelihood function. They can be PyTree's,
+e.g. `typing.NamedTuple`'s.
+
+Finally, priors can become point-wise estimates of the prior distribution, by calling `parametrised()`. This turns a
+Bayesian variable into a parameterised variable, e.g. one which can be used in optimisation.
+
+```python
+import jax
+import tensorflow_probability.substrates.jax as tfp
+
+tfpd = tfp.distributions
+
+from jaxns.framework.model import Model
+from jaxns.framework.prior import Prior
+
+
+def prior_model():
+    mu = yield Prior(tfpd.Normal(loc=0., scale=1.))
+    # Let's make sigma a parameterised variable
+    sigma = yield Prior(tfpd.Exponential(rate=1.), name='sigma').parametrised()
+    x = yield Prior(tfpd.Cauchy(loc=mu, scale=sigma), name='x')
+    uncert = yield Prior(tfpd.Exponential(rate=1.), name='uncert')
+    return x, uncert
+
+
+def log_likelihood(x, uncert):
+    return tfpd.Normal(loc=0., scale=uncert).log_prob(x)
+
+
+model = Model(prior_model=prior_model, log_likelihood=log_likelihood)
+
+# You can sanity check the model (always a good idea when exploring)
+model.sanity_check(key=jax.random.PRNGKey(0), S=100)
+
+# The size of the Bayesian part of the prior space is `model.U_ndims`.
+```
+
+### Sampling and transforming variables
+
+There are two spaces of samples:
+
+1. U-space: samples in base measure space, and is dimensionless, or rather has units of probability.
+2. X-space: samples in the space of the model, and has units of the prior variable.
+
+```python
+# Sample the prior in U-space (base measure)
+U = model.sample_U(key=jax.random.PRNGKey(0))
+# Transform to X-space
+X = model.transform(U=U)
+# Only named Bayesian prior variables are returned, the rest are treated as hidden variables.
+assert set(X.keys()) == {'x', 'uncert'}
+
+# Get the return value of the prior model, i.e. the input to the likelihood
+x_sample, uncert_sample = model.prepare_input(U=U)
+```
+
+### Computing log-probabilities
+
+All computations are based on the U-space variables.
+
+```python
+# Evaluate different parts of the model
+log_prob_prior = model.log_prob_prior(U)
+log_prob_likelihood = model.log_prob_likelihood(U, allow_nan=False)
+log_prob_joint = model.log_prob_joint(U, allow_nan=False)
+```
+
+### Computing gradients of the joint probability w.r.t. parameters
+
+```python
+init_params = model.params
+
+
+def log_prob_joint_fn(params, U):
+    # Calling model with params returns a new model with the params set
+    return model(params).log_prob_joint(U, allow_nan=False)
+
+
+value, grad = jax.value_and_grad(log_prob_joint_fn)(init_params, U)
+```
+
+## Nested Sampling Engine
+
+Given a probabilistic model, JAXNS can perform nested sampling on it. This allows computing the Bayesian evidence and
+posterior samples.
+
+```python
+from jaxns import DefaultNestedSampler
+
+ns = DefaultNestedSampler(model=model, max_samples=1e5)
+
+# Run the sampler
+termination_reason, state = ns(jax.random.PRNGKey(42))
+# Get the results
+results = ns.to_results(termination_reason=termination_reason, state=state)
+```
+
+#### To AOT or JIT-compile the sampler
+
+```python
+# Ahead of time compilation (sometimes useful)
+ns_aot = jax.jit(ns).lower(jax.random.PRNGKey(42)).compile()
+
+# Just-in-time compilation (usually useful)
+ns_jit = jax.jit(ns)
+```
+
+You can inspect the results, and plot them.
+
+```python
+from jaxns import summary, plot_diagnostics, plot_cornerplot
+
+summary(results)
+plot_diagnostics(results)
+plot_cornerplot(results)
+```
+
+Output:
+
+```
+--------
+Termination Conditions:
+Small remaining evidence
+--------
+likelihood evals: 149918
+samples: 3780
+phantom samples: 1710
+likelihood evals / sample: 39.7
+phantom fraction (%): 45.2%
+--------
+logZ=-1.65 +- 0.15
+H=-1.13
+ESS=132
+--------
+uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.
+uncert: 0.68 +- 0.58 | 0.13 / 0.48 / 1.37 | 0.0 | 0.0
+--------
+x: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.
+x: 0.07 +- 0.62 | -0.57 / 0.06 / 0.73 | 0.0 | 0.0
+--------
+```
+
+![](docs/examples/intro_diagnostics.png)
+![](docs/examples/intro_cornerplot.png)
+
+### Using the posterior samples
+
+Nested sampling produces weighted posterior samples. To use for most use cases, you can simply resample (with
+replacement).
+
+```python
+from jaxns import resample
+
+samples = resample(
+    key=jax.random.PRNGKey(0),
+    samples=results.samples,
+    log_weights=results.log_dp_mean,
+    S=1000,
+    replace=True
+)
+```
 
 # Documentation
 
-You can read the documentation [here](https://jaxns.readthedocs.io/en/latest/#).
+You can read the documentation [here](https://jaxns.readthedocs.io/en/latest/#). In addition, JAXNS is partially
+described in the
+original paper (https://arxiv.org/abs/2012.15286), as well as the paper on Phantom-Powered Nested
+Sampling (https://arxiv.org/abs/2312.11330).
 
 # Install
 
 **Notes:**
 
-1. JAXNS requires >= Python 3.8.
+1. JAXNS requires >= Python 3.9. It is always highly recommended to use the latest version of Python.
 2. It is always highly recommended to use a unique virtual environment for each project.
    To use `miniconda`, have it installed, and run
 
@@ -83,10 +283,10 @@ If you're unfamiliar, take a quick tour of JAX (https://jax.readthedocs.io/en/la
 JAXNS is really fast because it uses JAX.
 JAXNS is much faster than PolyChord, MultiNEST, and dynesty, typically achieving two to three orders of magnitude
 improvement in run time, for models with cheap likelihood evaluations.
-This is shown in (https://arxiv.org/abs/2012.15286). 
+This is shown in (https://arxiv.org/abs/2012.15286).
 
-Recently JAXNS has implemented Phantom-Powered Nested Sampling, which significantly reduces the number of required 
-likelihood evaluations. This is shown in (https://arxiv.org/abs/). 
+Recently JAXNS has implemented Phantom-Powered Nested Sampling, which significantly reduces the number of required
+likelihood evaluations. This is shown in (https://arxiv.org/abs/2312.11330).
 
 # Note on performance with parallelisation
 
@@ -103,17 +303,17 @@ This ensures consistency of depth across all copies.
 We then merge the copies and compute the final results.
 
 The algorithm is fairly memory bound, so running parallelisation over multiple CPUs on the same machine may not yield
-the expected speed up, and depends how expensive the likelihood evaluations are. Running over separate physical devices 
+the expected speed up, and depends how expensive the likelihood evaluations are. Running over separate physical devices
 is the best way to achieve speed up.
 
 # Change Log
 
-8 Jan, 2024 -- JAXNS 2.4.0 released. Migrate parametrised models to stable. All models are now default able to be 
-parametrised, so you can use hk.Parameter anywhere in the model.
+8 Jan, 2024 -- JAXNS 2.4.0 released. Python 3.9+ becomes supported. Migrate parametrised models to stable.
+All models are now default able to be parametrised, so you can use hk.Parameter anywhere in the model.
 
 21 Dec, 2023 -- JAXNS 2.3.4 released. Correction for ESS and logZ uncert. `parameter_estimation` mode.
 
-20 Dec, 2023 -- JAXNS 2.3.2/3 released. Improved default parameters. `difficult_model` mode. Improve plotting. 
+20 Dec, 2023 -- JAXNS 2.3.2/3 released. Improved default parameters. `difficult_model` mode. Improve plotting.
 
 18 Dec, 2023 -- JAXNS 2.3.1 released. Paper open science release. Default parameters from paper.
 
diff --git a/docs/examples/intro_cornerplot.png b/docs/examples/intro_cornerplot.png
new file mode 100644
index 00000000..fd049a3d
Binary files /dev/null and b/docs/examples/intro_cornerplot.png differ
diff --git a/docs/examples/intro_diagnostics.png b/docs/examples/intro_diagnostics.png
new file mode 100644
index 00000000..27122027
Binary files /dev/null and b/docs/examples/intro_diagnostics.png differ
diff --git a/docs/examples/intro_example.ipynb b/docs/examples/intro_example.ipynb
new file mode 100644
index 00000000..241888ef
--- /dev/null
+++ b/docs/examples/intro_example.ipynb
@@ -0,0 +1,266 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:01:47.530868923Z",
+     "start_time": "2024-01-08T16:01:44.319876519Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO[2024-01-08 17:01:45,714]: Unable to initialize backend 'cuda': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
+      "INFO[2024-01-08 17:01:45,714]: Unable to initialize backend 'rocm': module 'jaxlib.xla_extension' has no attribute 'GpuAllocatorConfig'\n",
+      "INFO[2024-01-08 17:01:45,715]: 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[2024-01-08 17:01:45,717]: An NVIDIA GPU may be present on this machine, but a CUDA-enabled jaxlib is not installed. Falling back to cpu.\n",
+      "INFO[2024-01-08 17:01:46,975]: Sanity check...\n",
+      "INFO[2024-01-08 17:01:47,527]: Sanity check passed\n"
+     ]
+    }
+   ],
+   "source": [
+    "import jax\n",
+    "import tensorflow_probability.substrates.jax as tfp\n",
+    "\n",
+    "tfpd = tfp.distributions\n",
+    "\n",
+    "from jaxns.framework.model import Model\n",
+    "from jaxns.framework.prior import Prior\n",
+    "\n",
+    "\n",
+    "def prior_model():\n",
+    "    mu = yield Prior(tfpd.Normal(loc=0., scale=1.))\n",
+    "    # Let's make sigma a parameterised variable. \n",
+    "    # It requires a name, but will not be collected as a Bayesian variable.\n",
+    "    sigma = yield Prior(tfpd.Exponential(rate=1.), name='sigma').parametrised()\n",
+    "    x = yield Prior(tfpd.Cauchy(loc=mu, scale=sigma), name='x')\n",
+    "    uncert = yield Prior(tfpd.Exponential(rate=1.), name='uncert')\n",
+    "    return x, uncert\n",
+    "\n",
+    "\n",
+    "def log_likelihood(x, uncert):\n",
+    "    return tfpd.Normal(loc=0., scale=uncert).log_prob(x)\n",
+    "\n",
+    "\n",
+    "model = Model(prior_model=prior_model, log_likelihood=log_likelihood)\n",
+    "\n",
+    "# You can sanity check the model (always a good idea when exploring)\n",
+    "model.sanity_check(key=jax.random.PRNGKey(0), S=100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "# Sample the prior in U-space (base measure)\n",
+    "U = model.sample_U(key=jax.random.PRNGKey(0))\n",
+    "# Transform to X-space\n",
+    "X = model.transform(U=U)\n",
+    "# Only named Bayesian prior variables are returned, the rest are treated as hidden variables.\n",
+    "assert set(X.keys()) == {'x', 'uncert'}\n",
+    "\n",
+    "# Get the return value of the prior model, i.e. the input to the likelihood\n",
+    "x_sample, uncert_sample = model.prepare_input(U=U)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:01:47.715958982Z",
+     "start_time": "2024-01-08T16:01:47.533566469Z"
+    }
+   },
+   "id": "57f60983e4060827",
+   "execution_count": 2
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "# Evaluate different parts of the model\n",
+    "log_prob_prior = model.log_prob_prior(U)\n",
+    "log_prob_likelihood = model.log_prob_likelihood(U, allow_nan=False)\n",
+    "log_prob_joint = model.log_prob_joint(U, allow_nan=False)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:01:47.780290636Z",
+     "start_time": "2024-01-08T16:01:47.718700670Z"
+    }
+   },
+   "id": "711a04c5a485eb67",
+   "execution_count": 3
+  },
+  {
+   "cell_type": "code",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-8.101052 {'~': {'sigma_param': Array(-11.244353, dtype=float32)}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "init_params = model.params\n",
+    "\n",
+    "\n",
+    "def log_prob_joint_fn(params, U):\n",
+    "    # Calling model with params returns a new model with the params set\n",
+    "    return model(params).log_prob_joint(U, allow_nan=False)\n",
+    "\n",
+    "\n",
+    "value, grad = jax.value_and_grad(log_prob_joint_fn)(init_params, U)\n",
+    "print(value, grad)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:01:48.255896149Z",
+     "start_time": "2024-01-08T16:01:47.780366090Z"
+    }
+   },
+   "id": "d3b4a1ddef258c8e",
+   "execution_count": 4
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "from jaxns import DefaultNestedSampler\n",
+    "\n",
+    "ns = DefaultNestedSampler(model=model, max_samples=1e5)\n",
+    "\n",
+    "# Run the sampler\n",
+    "termination_reason, state = ns(jax.random.PRNGKey(42))\n",
+    "# Get the results\n",
+    "results = ns.to_results(termination_reason=termination_reason, state=state)"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:01:57.235276909Z",
+     "start_time": "2024-01-08T16:01:48.261669223Z"
+    }
+   },
+   "id": "d7876cdf55aa6ade",
+   "execution_count": 5
+  },
+  {
+   "cell_type": "code",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--------\n",
+      "Termination Conditions:\n",
+      "Small remaining evidence\n",
+      "--------\n",
+      "likelihood evals: 149918\n",
+      "samples: 3780\n",
+      "phantom samples: 1710\n",
+      "likelihood evals / sample: 39.7\n",
+      "phantom fraction (%): 45.2%\n",
+      "--------\n",
+      "logZ=-1.65 +- 0.15\n",
+      "H=-1.13\n",
+      "ESS=132\n",
+      "--------\n",
+      "uncert: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
+      "uncert: 0.68 +- 0.58 | 0.13 / 0.48 / 1.37 | 0.0 | 0.0\n",
+      "--------\n",
+      "x: mean +- std.dev. | 10%ile / 50%ile / 90%ile | MAP est. | max(L) est.\n",
+      "x: 0.07 +- 0.62 | -0.57 / 0.06 / 0.73 | 0.0 | 0.0\n",
+      "--------\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 800x1200 with 5 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 400x400 with 3 Axes>",
+      "image/png": "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"
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from jaxns import summary, plot_diagnostics, plot_cornerplot\n",
+    "\n",
+    "summary(results)\n",
+    "plot_diagnostics(results, save_name='intro_diagnostics.png')\n",
+    "plot_cornerplot(results, save_name='intro_cornerplot.png')"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:02:00.740076209Z",
+     "start_time": "2024-01-08T16:01:57.243884852Z"
+    }
+   },
+   "id": "5f39eb79467304d3",
+   "execution_count": 6
+  },
+  {
+   "cell_type": "code",
+   "outputs": [],
+   "source": [
+    "from jaxns import resample\n",
+    "\n",
+    "samples = resample(\n",
+    "    key=jax.random.PRNGKey(0),\n",
+    "    samples=results.samples,\n",
+    "    log_weights=results.log_dp_mean,\n",
+    "    S=1000,\n",
+    "    replace=True\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-01-08T16:02:01.377816156Z",
+     "start_time": "2024-01-08T16:02:00.738584235Z"
+    }
+   },
+   "id": "f85410f95b4fd3e",
+   "execution_count": 7
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/jaxns/framework/prior.py b/jaxns/framework/prior.py
index 358d1b5a..43ebf252 100644
--- a/jaxns/framework/prior.py
+++ b/jaxns/framework/prior.py
@@ -1,3 +1,4 @@
+import logging
 from typing import Tuple, Optional, Union
 
 import haiku as hk
@@ -16,6 +17,8 @@
     "InvalidPriorName"
 ]
 
+logger = logging.getLogger('jaxns')
+
 
 class InvalidPriorName(Exception):
     """
@@ -32,7 +35,7 @@ class SingularPrior(BaseAbstractPrior):
         (at the singular value).
     """
 
-    def __init__(self, value: jnp.ndarray, dist: BaseAbstractDistribution, name: str):
+    def __init__(self, value: jnp.ndarray, dist: BaseAbstractDistribution, name: Optional[str] = None):
         super().__init__(name=name)
         self.value = value
         self.dist = dist
@@ -165,6 +168,8 @@ def prior_to_parametrised_singular(prior: Prior) -> SingularPrior:
     Returns:
         A parameter representing the prior.
     """
+    if prior.name is None:
+        raise ValueError("Prior must have a name to be parametrised.")
     name = f"{prior.name}_param"
     # Initialises at median of distribution.
     init_value = jnp.zeros(prior.base_shape, dtype=float_type)
@@ -179,4 +184,4 @@ def prior_to_parametrised_singular(prior: Prior) -> SingularPrior:
     # U_base_param = ndtr(norm_U_base_param)
     U_base_param = jax.nn.sigmoid(norm_U_base_param)
     param = prior.forward(U_base_param)
-    return SingularPrior(value=param, dist=prior.dist, name=prior.name)
+    return SingularPrior(value=param, dist=prior.dist, name=None)
diff --git a/jaxns/nested_sampler/standard_static.py b/jaxns/nested_sampler/standard_static.py
index 8e6b38ac..85e9f0e6 100644
--- a/jaxns/nested_sampler/standard_static.py
+++ b/jaxns/nested_sampler/standard_static.py
@@ -6,7 +6,6 @@
 
 from jaxns.framework.bases import BaseAbstractModel
 from jaxns.internals.log_semiring import LogSpace, normalise_log_space
-from jaxns.internals.maps import replace_index
 from jaxns.internals.shrinkage_statistics import compute_evidence_stats
 from jaxns.internals.stats import linear_to_log_stats, effective_sample_size
 from jaxns.internals.tree_structure import SampleTreeGraph, count_crossed_edges, unbatch_state
@@ -38,102 +37,161 @@ def _inter_sync_shrinkage_process(
     Args:
         init_state: the state of the nested sampler at the start
         sampler: sampler to use
-        num_samples: number of samples to take, i.e. work to do
+        num_samples: number of samples to take, i.e. work to do, must be >= front_size
 
     Returns:
         sampler state with samples added
     """
 
+    front_size = init_state.front_idx.size
+    if num_samples < front_size:
+        raise RuntimeError(f"num_samples ({num_samples}) must be >= front_size ({front_size})")
+
+    max_num_samples = init_state.sample_collection.log_L.size
+
     class CarryType(NamedTuple):
-        state: StaticStandardNestedSamplerState
+        front_sample_collection: StaticStandardSampleCollection
         sampler_state: SamplerState
+        key: PRNGKey
+        front_idx: IntArray
+        next_sample_idx: IntArray
+
+    class ResultType(NamedTuple):
+        replace_idx: IntArray
+        sample_collection: StaticStandardSampleCollection
 
     # TODO(Joshuaalbert): Could make much faster by passing just the front, rather than whole state. Would need to
     #  recombine later, and handle sender_idx correctly.
-    def body(carry: CarryType, unused_X: IntArray) -> Tuple[CarryType, Any]:
-        state = carry.state
-
-        front_loc = jnp.argmin(state.sample_collection.log_L[state.front_idx])
-        dead_idx = state.front_idx[front_loc]
+    def body(carry: CarryType, unused_X: IntArray) -> Tuple[CarryType, ResultType]:
+        front_loc = jnp.argmin(carry.front_sample_collection.log_L)
+        dead_idx = carry.front_idx[front_loc]
 
         # Node index is based on root of 0, so sample-nodes are 1-indexed
         dead_node_idx = dead_idx + 1
 
-        log_L_contour = state.sample_collection.log_L[dead_idx]
+        log_L_contour = carry.front_sample_collection.log_L[front_loc]
 
-        key, sample_key = random.split(state.key, 2)
+        key, sample_key = random.split(carry.key, 2)
 
         sample, phantom_samples = sampler.get_sample(
             key=sample_key,
             log_L_constraint=log_L_contour,
             sampler_state=carry.sampler_state
         )
+        # Replace in front_sample_collection
+        front_sample_collection = carry.front_sample_collection._replace(
+            sender_node_idx=carry.front_sample_collection.sender_node_idx.at[front_loc].set(dead_node_idx),
+            log_L=carry.front_sample_collection.log_L.at[front_loc].set(sample.log_L),
+            U_samples=carry.front_sample_collection.U_samples.at[front_loc].set(sample.U_sample),
+            num_likelihood_evaluations=carry.front_sample_collection.num_likelihood_evaluations.at[front_loc].set(
+                sample.num_likelihood_evaluations),
+            # Phantom samples are not on the front, so don't need to be updated from default of False
+        )
+        front_idx = carry.front_idx.at[front_loc].set(carry.next_sample_idx)
+
         # Set (non-phantom) sample as the next sample
 
-        sample_collection = state.sample_collection
-        sample_collection = sample_collection._replace(
-            sender_node_idx=sample_collection.sender_node_idx.at[state.next_sample_idx].set(dead_node_idx),
-            log_L=sample_collection.log_L.at[state.next_sample_idx].set(sample.log_L),
-            U_samples=sample_collection.U_samples.at[state.next_sample_idx].set(sample.U_sample),
-            num_likelihood_evaluations=sample_collection.num_likelihood_evaluations.at[state.next_sample_idx].set(
-                sample.num_likelihood_evaluations)
-            # phantom stays default of False
-        )
-        front_idx = state.front_idx.at[front_loc].set(state.next_sample_idx)
-        next_sample_idx = jnp.minimum(state.next_sample_idx + 1, state.sample_collection.log_L.size)
-        state = state._replace(
-            key=key,
-            next_sample_idx=next_sample_idx,
-            sample_collection=sample_collection,
-            front_idx=front_idx
-        )
+        new_replace_idx = [
+            carry.next_sample_idx[None]
+        ]
+        new_sender_node_idx = [
+            dead_node_idx[None]
+        ]
+        new_log_L = [
+            sample.log_L[None]
+        ]
+        new_U_samples = [
+            sample.U_sample[None]
+        ]
+        new_num_likelihood_evaluations = [
+            sample.num_likelihood_evaluations[None]
+        ]
+        new_phantom = [
+            jnp.zeros((1,), jnp.bool_)
+        ]
+
+        next_sample_idx = jnp.minimum(carry.next_sample_idx + 1, max_num_samples)
 
         # Set phantom samples, whose sender nodes are all the dead point. These do not get set on the front.
+
         num_phantom = phantom_samples.log_L.size
-        sample_collection = sample_collection._replace(
-            sender_node_idx=replace_index(
-                sample_collection.sender_node_idx,
-                jnp.full((num_phantom,), dead_node_idx),
-                next_sample_idx
-            ),
-            log_L=replace_index(
-                sample_collection.log_L,
-                phantom_samples.log_L,
-                next_sample_idx
-            ),
-            U_samples=replace_index(
-                sample_collection.U_samples,
-                phantom_samples.U_sample,
-                next_sample_idx
-            ),
-            num_likelihood_evaluations=replace_index(
-                sample_collection.num_likelihood_evaluations,
-                phantom_samples.num_likelihood_evaluations,
-                next_sample_idx
-            ),
-            phantom=replace_index(
-                sample_collection.phantom,
-                jnp.ones(num_phantom, dtype=jnp.bool_),
-                next_sample_idx
-            )
+        new_replace_idx.append(
+            (next_sample_idx + jnp.arange(num_phantom)).astype(next_sample_idx.dtype)
+        )
+        new_sender_node_idx.append(
+            jnp.full((num_phantom,), dead_node_idx)
+        )
+        new_log_L.append(
+            phantom_samples.log_L
+        )
+        new_U_samples.append(
+            phantom_samples.U_sample
+        )
+        new_num_likelihood_evaluations.append(
+            phantom_samples.num_likelihood_evaluations
+        )
+        new_phantom.append(
+            jnp.ones((num_phantom,), dtype=jnp.bool_)
         )
 
-        next_sample_idx = jnp.minimum(state.next_sample_idx + num_phantom, state.sample_collection.log_L.size)
-        state = state._replace(
-            next_sample_idx=next_sample_idx,
-            sample_collection=sample_collection
+        next_sample_idx = jnp.minimum(next_sample_idx + num_phantom, max_num_samples)
 
+        new_sample_collection = StaticStandardSampleCollection(
+            sender_node_idx=jnp.concatenate(new_sender_node_idx, axis=0),
+            log_L=jnp.concatenate(new_log_L, axis=0),
+            U_samples=jnp.concatenate(new_U_samples, axis=0),
+            num_likelihood_evaluations=jnp.concatenate(new_num_likelihood_evaluations, axis=0),
+            phantom=jnp.concatenate(new_phantom, axis=0)
         )
+        new_replace_idx = jnp.concatenate(new_replace_idx, axis=0)
 
         # Fast update of sampler state given this state
-        sampler_state = sampler.post_process(state, carry.sampler_state)
-        return CarryType(state=state, sampler_state=sampler_state), ()
+        sampler_state = sampler.post_process(sample_collection=new_sample_collection, sampler_state=carry.sampler_state)
+
+        new_carry = CarryType(
+            front_sample_collection=front_sample_collection,
+            sampler_state=sampler_state,
+            key=key,
+            front_idx=front_idx,
+            next_sample_idx=next_sample_idx
+        )
+
+        new_return = ResultType(
+            replace_idx=new_replace_idx,
+            sample_collection=new_sample_collection
+        )
+
+        return new_carry, new_return
 
     # Sampler state is created before all this work. Quickly updated during shrinkage.
     init_sampler_state = sampler.pre_process(state=init_state)
-    init_carry = CarryType(state=init_state, sampler_state=init_sampler_state)
-    out_carry, _ = lax.scan(body, init_carry, jnp.arange(num_samples))
-    return out_carry.state
+    init_front_sample_collection = tree_map(lambda x: x[init_state.front_idx], init_state.sample_collection)
+    key, carry_key = random.split(init_state.key)
+    init_carry = CarryType(
+        sampler_state=init_sampler_state,
+        key=carry_key,
+        front_idx=init_state.front_idx,
+        front_sample_collection=init_front_sample_collection,
+        next_sample_idx=init_state.next_sample_idx
+    )
+    out_carry, out_return = lax.scan(body, init_carry, jnp.arange(num_samples))
+
+    # Replace the samples in the sample collection with out_return counterparts.
+    sample_collection = tree_map(
+        lambda x, y: x.at[out_return.replace_idx].set(y),
+        init_state.sample_collection,
+        out_return.sample_collection
+    )
+    # Note, discard front_sample_collection since it's already in out_return, and we've replaced the whole front.
+
+    # Take front_idx and next_sample_idx from carry, which have been kept up-to-date at every iteration.
+    state = StaticStandardNestedSamplerState(
+        key=key,
+        next_sample_idx=out_carry.next_sample_idx,
+        sample_collection=sample_collection,
+        front_idx=out_carry.front_idx
+    )
+    return state
 
 
 def _single_thread_ns(init_state: StaticStandardNestedSamplerState,
diff --git a/jaxns/samplers/abc.py b/jaxns/samplers/abc.py
index 47c1b698..11257fc4 100644
--- a/jaxns/samplers/abc.py
+++ b/jaxns/samplers/abc.py
@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
 from typing import TypeVar, Tuple
 
-from jaxns.internals.types import PRNGKey, FloatArray, Sample, StaticStandardNestedSamplerState
+from jaxns.internals.types import PRNGKey, FloatArray, Sample, StaticStandardSampleCollection, \
+    StaticStandardNestedSamplerState
 
 SamplerState = TypeVar('SamplerState')
 
@@ -15,7 +16,7 @@ def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
         updated quickly.
 
         Args:
-            state: nested sampler state
+            state: the current state of the sampler
 
         Returns:
             any valid pytree
@@ -23,12 +24,13 @@ def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
         ...
 
     @abstractmethod
-    def post_process(self, state: StaticStandardNestedSamplerState, sampler_state: SamplerState) -> SamplerState:
+    def post_process(self, sample_collection: StaticStandardSampleCollection,
+                     sampler_state: SamplerState) -> SamplerState:
         """
         Post process the sampler state, after the sampler has been run. Should be quick.
 
         Args:
-            state: the state after successful sampling
+            sample_collection: a sample collection post sample step
             sampler_state: data pytree produced by the sampler
 
         Returns:
diff --git a/jaxns/samplers/multi_ellipsoidal_samplers.py b/jaxns/samplers/multi_ellipsoidal_samplers.py
index 80d330b3..29e27247 100644
--- a/jaxns/samplers/multi_ellipsoidal_samplers.py
+++ b/jaxns/samplers/multi_ellipsoidal_samplers.py
@@ -4,7 +4,7 @@
 
 from jaxns.internals.shrinkage_statistics import compute_evidence_stats
 from jaxns.internals.tree_structure import SampleTreeGraph, count_crossed_edges
-from jaxns.internals.types import IntArray, StaticStandardNestedSamplerState, UType
+from jaxns.internals.types import IntArray, StaticStandardNestedSamplerState, UType, StaticStandardSampleCollection
 from jaxns.internals.types import PRNGKey, FloatArray
 from jaxns.internals.types import Sample, int_type
 from jaxns.samplers.abc import SamplerState
@@ -59,7 +59,7 @@ def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
             method='em_gmm'
         )
 
-    def post_process(self, state: StaticStandardNestedSamplerState, sampler_state: SamplerState) -> SamplerState:
+    def post_process(self, sample_collection: StaticStandardSampleCollection, sampler_state: SamplerState) -> SamplerState:
         return sampler_state
 
     @property
diff --git a/jaxns/samplers/multi_slice_sampler.py b/jaxns/samplers/multi_slice_sampler.py
index 90d614b2..97df08fa 100644
--- a/jaxns/samplers/multi_slice_sampler.py
+++ b/jaxns/samplers/multi_slice_sampler.py
@@ -4,11 +4,12 @@
 from jax import numpy as jnp, random, tree_map, lax
 
 from jaxns.framework.bases import BaseAbstractModel
+from jaxns.internals.shrinkage_statistics import _cumulative_op_static
+from jaxns.internals.types import PRNGKey, FloatArray, BoolArray, Sample, int_type, StaticStandardNestedSamplerState, \
+    UType, \
+    IntArray, float_type, StaticStandardSampleCollection
 from jaxns.samplers.abc import SamplerState
 from jaxns.samplers.bases import SeedPoint, BaseAbstractMarkovSampler
-from jaxns.internals.shrinkage_statistics import _cumulative_op_static
-from jaxns.internals.types import PRNGKey, FloatArray, BoolArray, Sample, int_type, StaticStandardNestedSamplerState, UType, \
-    IntArray, float_type
 
 __all__ = [
     'MultiDimSliceSampler'
@@ -193,25 +194,26 @@ def num_phantom(self) -> int:
         return self.num_phantom_save
 
     def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
-        return (state,)
+        sample_collection = tree_map(lambda x: x[state.front_idx], state.sample_collection)
+        return (sample_collection,)
 
-    def post_process(self, state: StaticStandardNestedSamplerState, sampler_state: SamplerState) -> SamplerState:
-        return (state,)
+    def post_process(self, sample_collection: StaticStandardSampleCollection, sampler_state: SamplerState) -> SamplerState:
+        return sampler_state
 
     def get_seed_point(self, key: PRNGKey, sampler_state: SamplerState,
                        log_L_constraint: FloatArray) -> SeedPoint:
 
-        state: StaticStandardNestedSamplerState
-        (state,) = sampler_state
+        sample_collection: StaticStandardSampleCollection
+        (sample_collection,) = sampler_state
 
-        unnorm_select_prob = (state.sample_collection.log_L[state.front_idx] > log_L_constraint).astype(float_type)
+        unnorm_select_prob = (sample_collection.log_L > log_L_constraint).astype(float_type)
         # Choose randomly where mask is True
         g = random.gumbel(key, shape=unnorm_select_prob.shape)
-        sample_idx = state.front_idx[jnp.argmax(g + jnp.log(unnorm_select_prob))]
+        sample_idx = jnp.argmax(g + jnp.log(unnorm_select_prob))
 
         return SeedPoint(
-            U0=state.sample_collection.U_samples[sample_idx],
-            log_L0=state.sample_collection.log_L[sample_idx]
+            U0=sample_collection.U_samples[sample_idx],
+            log_L0=sample_collection.log_L[sample_idx]
         )
 
     def get_sample_from_seed(self, key: PRNGKey, seed_point: SeedPoint, log_L_constraint: FloatArray,
diff --git a/jaxns/samplers/uni_slice_sampler.py b/jaxns/samplers/uni_slice_sampler.py
index 134f5a6b..977fd60a 100644
--- a/jaxns/samplers/uni_slice_sampler.py
+++ b/jaxns/samplers/uni_slice_sampler.py
@@ -7,7 +7,7 @@
 from jaxns.internals.shrinkage_statistics import _cumulative_op_static
 from jaxns.internals.types import PRNGKey, FloatArray, BoolArray, Sample, float_type, int_type, \
     StaticStandardNestedSamplerState, \
-    IntArray, UType
+    IntArray, UType, StaticStandardSampleCollection
 from jaxns.samplers.abc import SamplerState
 from jaxns.samplers.bases import SeedPoint, BaseAbstractMarkovSampler
 
@@ -264,31 +264,32 @@ def num_phantom(self) -> int:
         return self.num_phantom_save
 
     def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
+        sample_collection = tree_map(lambda x: x[state.front_idx], state.sample_collection)
         if self.perfect:  # nothing needed
-            return (state,)
+            return (sample_collection,)
         else:  # TODO: step out with doubling, using ellipsoidal clustering
-            return (state,)  # multi_ellipsoidal_params()
+            return (sample_collection,)  # multi_ellipsoidal_params()
 
-    def post_process(self, state: StaticStandardNestedSamplerState, sampler_state: SamplerState) -> SamplerState:
+    def post_process(self, sample_collection: StaticStandardSampleCollection, sampler_state: SamplerState) -> SamplerState:
         if self.perfect:  # nothing needed
-            return (state,)
+            return sampler_state
         else:  # TODO: step out with doubling, using ellipsoidal clustering, could shrink ellipsoids
-            return (state,)
+            return sampler_state
 
     def get_seed_point(self, key: PRNGKey, sampler_state: SamplerState,
                        log_L_constraint: FloatArray) -> SeedPoint:
 
-        state: StaticStandardNestedSamplerState
-        (state,) = sampler_state
+        sample_collection: StaticStandardSampleCollection
+        (sample_collection,) = sampler_state
 
-        unnorm_select_prob = (state.sample_collection.log_L[state.front_idx] > log_L_constraint).astype(float_type)
+        unnorm_select_prob = (sample_collection.log_L > log_L_constraint).astype(float_type)
         # Choose randomly where mask is True
         g = random.gumbel(key, shape=unnorm_select_prob.shape)
-        sample_idx = state.front_idx[jnp.argmax(g + jnp.log(unnorm_select_prob))]
+        sample_idx = jnp.argmax(g + jnp.log(unnorm_select_prob))
 
         return SeedPoint(
-            U0=state.sample_collection.U_samples[sample_idx],
-            log_L0=state.sample_collection.log_L[sample_idx]
+            U0=sample_collection.U_samples[sample_idx],
+            log_L0=sample_collection.log_L[sample_idx]
         )
 
     def get_sample_from_seed(self, key: PRNGKey, seed_point: SeedPoint, log_L_constraint: FloatArray,
diff --git a/jaxns/samplers/uniform_samplers.py b/jaxns/samplers/uniform_samplers.py
index 465ad71f..93bc7165 100644
--- a/jaxns/samplers/uniform_samplers.py
+++ b/jaxns/samplers/uniform_samplers.py
@@ -3,11 +3,12 @@
 from jax import random, numpy as jnp, lax, tree_map
 
 from jaxns.framework.bases import BaseAbstractModel
-from jaxns.samplers.abc import SamplerState
-from jaxns.samplers.bases import BaseAbstractRejectionSampler
-from jaxns.internals.types import IntArray, StaticStandardNestedSamplerState, UType, MeasureType
+from jaxns.internals.types import IntArray, StaticStandardNestedSamplerState, UType, MeasureType, \
+    StaticStandardSampleCollection
 from jaxns.internals.types import PRNGKey, FloatArray
 from jaxns.internals.types import Sample, int_type
+from jaxns.samplers.abc import SamplerState
+from jaxns.samplers.bases import BaseAbstractRejectionSampler
 
 __all__ = [
     'UniformSampler'
@@ -39,7 +40,7 @@ def num_phantom(self) -> int:
     def pre_process(self, state: StaticStandardNestedSamplerState) -> SamplerState:
         return ()
 
-    def post_process(self, state: StaticStandardNestedSamplerState, sampler_state: SamplerState) -> SamplerState:
+    def post_process(self, sample_collection: StaticStandardSampleCollection, sampler_state: SamplerState) -> SamplerState:
         return sampler_state
 
     def get_sample(self, key: PRNGKey, log_L_constraint: FloatArray, sampler_state: SamplerState) -> Tuple[
diff --git a/setup.py b/setup.py
index 2eea7d12..7aee7f8b 100755
--- a/setup.py
+++ b/setup.py
@@ -39,5 +39,5 @@
           "License :: OSI Approved :: Apache Software License",
           "Operating System :: OS Independent",
       ],
-      python_requires='>=3.8',
+      python_requires='>=3.9',
       )


Test patch:
diff --git a/.github/workflows/unittests.yml b/.github/workflows/unittests.yml
index 6eef40ee..fcbbae11 100644
--- a/.github/workflows/unittests.yml
+++ b/.github/workflows/unittests.yml
@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [ "3.8", "3.9", "3.10", "3.11" ]
+        python-version: [ "3.9", "3.10", "3.11" ]
 
     steps:
       - uses: actions/checkout@v3
diff --git a/jaxns/framework/tests/test_model.py b/jaxns/framework/tests/test_model.py
index 5099a616..d9e344c7 100644
--- a/jaxns/framework/tests/test_model.py
+++ b/jaxns/framework/tests/test_model.py
@@ -22,7 +22,7 @@ def log_likelihood(x):
 
 def test_parametrised_singular():
     def prior_model():
-        x = yield Prior(dist_or_value=jnp.asarray(0.)).parametrised()
+        x = yield Prior(dist_or_value=jnp.asarray(0.), name='x').parametrised()
         return x
 
     def log_likelihood(x):
@@ -34,7 +34,7 @@ def log_likelihood(x):
 
 def test_parametrised():
     def prior_model():
-        x = yield Prior(tfpd.Uniform()).parametrised()
+        x = yield Prior(tfpd.Uniform(),name='x').parametrised()
         return x
 
     def log_likelihood(x):