binference 0.1.0__py3-none-any.whl

binference/samplers/__init__.py

@@ -0,0 +1,19 @@
+"""Inference engines.
+
+* :class:`NUTS` -- No-U-Turn Sampler on the exact posterior (any prior).
+* :class:`Gibbs` -- data-augmentation Gibbs sampler (conjugate priors; joint labels).
+* :class:`MAP` -- posterior mode / maximum likelihood (mix-SQP, SQUAREM-EM or L-BFGS).
+* :class:`Laplace` -- Gaussian approximation with PSIS importance correction.
+* :class:`MeanFieldVB` -- mean-field variational Bayes (approximate).
+* :class:`Bootstrap` -- bootstrap of the MAP estimator (approximate).
+"""
+
+from .base import Engine
+from .bootstrap import Bootstrap
+from .gibbs import Gibbs
+from .laplace import Laplace
+from .nuts import NUTS
+from .optimize import MAP
+from .vb import MeanFieldVB
+
+__all__ = ["MAP", "NUTS", "Bootstrap", "Engine", "Gibbs", "Laplace", "MeanFieldVB"]

binference/samplers/_curvature.py

@@ -0,0 +1,67 @@
+"""Finite-difference curvature of a log density, shared by NUTS and Laplace."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import numpy as np
+
+LogpGrad = Callable[[np.ndarray], tuple[float, np.ndarray]]
+
+
+def _step(x: np.ndarray, j: int, h: float) -> np.ndarray:
+    e = np.zeros(x.size)
+    e[j] = h * max(1.0, abs(x[j]))
+    return e
+
+
+def fd_hessian(fn: LogpGrad, x: np.ndarray, h: float = 1e-4, cols=None) -> np.ndarray:
+    """Symmetrised central-difference Hessian of a log density from its gradient.
+
+    ``cols`` restricts the computation to some columns (returns ``(dim, len(cols))``).
+    """
+    x = np.asarray(x, dtype=float)
+    idx = range(x.size) if cols is None else cols
+    H = np.empty((x.size, len(idx)))
+    for c, j in enumerate(idx):
+        e = _step(x, j, h)
+        H[:, c] = (fn(x + e)[1] - fn(x - e)[1]) / (2.0 * e[j])
+    if cols is None:
+        H = 0.5 * (H + H.T)
+    return H
+
+
+def fd_hessian_diag(
+    fn: LogpGrad, x: np.ndarray, idx: Sequence[int], h: float = 1e-4
+) -> np.ndarray:
+    """The diagonal entries ``idx`` of the Hessian, without storing its columns."""
+    x = np.asarray(x, dtype=float)
+    out = np.empty(len(idx))
+    for c, j in enumerate(idx):
+        e = _step(x, j, h)
+        out[c] = (fn(x + e)[1][j] - fn(x - e)[1][j]) / (2.0 * e[j])
+    return out
+
+
+def neg_hessian_eigen(H: np.ndarray) -> tuple[np.ndarray, np.ndarray] | None:
+    """Eigenvalues and vectors of ``-H`` (symmetrised); ``None`` if ``H`` is not finite."""
+    A = -0.5 * (H + H.T)
+    if not np.all(np.isfinite(A)):
+        return None
+    return np.linalg.eigh(A)
+
+
+def covariance_from_hessian(H: np.ndarray, floor: float = 1e-6) -> np.ndarray | None:
+    """A positive-definite covariance from a (possibly indefinite) Hessian of log p.
+
+    Eigenvalues of ``-H`` are clipped below at ``floor`` times the largest, so
+    directions with no or negative curvature get the largest variance seen.
+    Returns ``None`` if the Hessian is unusable.
+    """
+    eig = neg_hessian_eigen(H)
+    if eig is None or not eig[0].max() > 0:
+        return None
+    lam, U = eig
+    lam = np.maximum(lam, floor * lam.max())
+    cov = (U / lam) @ U.T
+    return 0.5 * (cov + cov.T)

binference/samplers/_nuts_core.py

@@ -0,0 +1,284 @@
+"""Core of the No-U-Turn Sampler (pure functions).
+
+Multinomial NUTS with the generalised U-turn criterion and Stan's additional
+checks across merged subtrees; diagonal or dense Euclidean metrics.
+References: Hoffman & Gelman (2014); Betancourt (2017, arXiv:1701.02434).
+
+The tree stores, at each end, the position, momentum, velocity
+(``inverse metric @ momentum``) and gradient, so that the U-turn checks need no
+extra metric products. Scalar arithmetic uses :mod:`math`, which is much
+faster than NumPy scalars in this hot loop.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+
+import numpy as np
+from scipy import linalg
+
+LogpGrad = Callable[[np.ndarray], tuple[float, np.ndarray]]
+
+_NEG_INF = -math.inf
+
+#: Iterations of the first fast phase of Stan-style warm-up.
+_INIT_BUFFER = 75
+#: Iterations of the first slow window of Stan-style warm-up; each next one is twice as long.
+_BASE_WINDOW = 25
+#: Iterations of the last fast phase of Stan-style warm-up.
+_TERM_BUFFER = 50
+
+
+class Metric:
+    """Euclidean metric: inverse mass matrix ``inv_m`` (diagonal vector or dense matrix)."""
+
+    def __init__(self, inv_m: np.ndarray) -> None:
+        self.inv_m = np.asarray(inv_m, dtype=float)
+        self.dense = self.inv_m.ndim == 2
+        if self.dense:
+            # p ~ N(0, inv_m^{-1}) with inv_m = C C^T is p = C^{-T} z; C^{-T} once (audit N-9)
+            chol = np.linalg.cholesky(self.inv_m)
+            self._draw = linalg.solve_triangular(chol, np.eye(chol.shape[0]), lower=True).T
+        else:
+            self._draw = 1.0 / np.sqrt(self.inv_m)
+
+    def mv(self, p: np.ndarray) -> np.ndarray:
+        return self.inv_m @ p if self.dense else self.inv_m * p
+
+    def kinetic(self, p: np.ndarray) -> float:
+        return 0.5 * float(p @ self.mv(p))
+
+    def draw_momentum(self, rng: np.random.Generator) -> np.ndarray:
+        z = rng.standard_normal(self.inv_m.shape[0])
+        return self._draw @ z if self.dense else self._draw * z
+
+
+def _logaddexp(a: float, b: float) -> float:
+    if a == _NEG_INF:
+        return b
+    if b == _NEG_INF:
+        return a
+    if a > b:
+        return a + math.log1p(math.exp(b - a))
+    return b + math.log1p(math.exp(a - b))
+
+
+class _Tree:
+    __slots__ = (
+        "diverging",
+        "g_m",
+        "g_p",
+        "g_prop",
+        "log_w",
+        "lp_prop",
+        "n_leaf",
+        "p_m",
+        "p_p",
+        "p_prop",
+        "rho",
+        "sum_acc",
+        "turning",
+        "v_m",
+        "v_p",
+        "x_m",
+        "x_p",
+        "x_prop",
+    )
+
+
+def leapfrog(x, p, g, eps, metric: Metric, fn: LogpGrad):
+    p_half = p + (0.5 * eps) * g
+    x_new = x + eps * metric.mv(p_half)
+    lp_new, g_new = fn(x_new)
+    p_new = p_half + (0.5 * eps) * g_new
+    return x_new, p_new, g_new, lp_new
+
+
+def _no_uturn(va, vb, rho) -> bool:
+    """Generalised criterion with velocities ``va``, ``vb`` at the two ends."""
+    return float(va @ rho) > 0.0 and float(vb @ rho) > 0.0
+
+
+def _accept(rng, log_ratio: float) -> bool:
+    # u < exp(log_ratio) with u in (0, 1]: log1p(-u) never takes log(0) (audit N-8)
+    return math.log1p(-rng.random()) < log_ratio
+
+
+def _merge(t1: _Tree, t2: _Tree, v: int, rng, biased: bool) -> bool:
+    """Append ``t2`` to ``t1`` in direction ``v``; returns whether the merged tree is valid.
+
+    ``t2``'s proposal replaces ``t1``'s with probability ``exp(t2.log_w - w)``: ``w`` is
+    the merged weight within subtrees (multinomial) and the old tree's weight at the top
+    level (``biased``, progressive sampling). Then Stan's U-turn checks across the
+    merged tree and the two extra sub-checks.
+    """
+    merged = _logaddexp(t1.log_w, t2.log_w)
+    if _accept(rng, t2.log_w - (t1.log_w if biased else merged)):
+        t1.x_prop, t1.p_prop, t1.lp_prop, t1.g_prop = t2.x_prop, t2.p_prop, t2.lp_prop, t2.g_prop
+    t1.log_w = merged
+    rho = t1.rho + t2.rho
+    if v > 0:
+        p_ie, p_fb = t1.p_p, t2.p_m
+        v_ib, v_ie, v_fb, v_fe = t1.v_m, t1.v_p, t2.v_m, t2.v_p
+    else:
+        p_ie, p_fb = t1.p_m, t2.p_p
+        v_ib, v_ie, v_fb, v_fe = t1.v_p, t1.v_m, t2.v_p, t2.v_m
+    ok = (
+        _no_uturn(v_ib, v_fe, rho)
+        and _no_uturn(v_ib, v_fb, t1.rho + p_fb)
+        and _no_uturn(v_ie, v_fe, t2.rho + p_ie)
+    )
+    t1.rho = rho
+    if v > 0:
+        t1.x_p, t1.p_p, t1.v_p, t1.g_p = t2.x_p, t2.p_p, t2.v_p, t2.g_p
+    else:
+        t1.x_m, t1.p_m, t1.v_m, t1.g_m = t2.x_m, t2.p_m, t2.v_m, t2.g_m
+    return ok
+
+
+def _leaf(x, p, g, v, eps, H0, metric, fn, max_dE):
+    x1, p1, g1, lp1 = leapfrog(x, p, g, v * eps, metric, fn)
+    with np.errstate(over="ignore", invalid="ignore"):  # a blown-up step diverges below
+        vel = metric.mv(p1)
+        H1 = float(lp1) - 0.5 * float(p1 @ vel)  # NaN in g1 propagates into p1 and H1
+    finite = math.isfinite(H1)
+    t = _Tree()
+    t.x_m = t.x_p = t.x_prop = x1
+    t.p_m = t.p_p = t.p_prop = p1
+    t.v_m = t.v_p = vel
+    t.g_m = t.g_p = t.g_prop = g1
+    t.lp_prop = lp1
+    t.rho = p1
+    t.turning = False
+    t.n_leaf = 1
+    if finite:
+        dH = H1 - H0
+        t.log_w = dH
+        t.diverging = -dH > max_dE
+        t.sum_acc = math.exp(dH) if dH < 0.0 else 1.0
+    else:
+        t.log_w = _NEG_INF
+        t.diverging = True
+        t.sum_acc = 0.0
+    return t
+
+
+def _build(x, p, g, v, depth, eps, H0, metric, fn, rng, max_dE):
+    if depth == 0:
+        return _leaf(x, p, g, v, eps, H0, metric, fn, max_dE)
+    t1 = _build(x, p, g, v, depth - 1, eps, H0, metric, fn, rng, max_dE)
+    if t1.turning or t1.diverging:
+        return t1
+    if v > 0:
+        t2 = _build(t1.x_p, t1.p_p, t1.g_p, v, depth - 1, eps, H0, metric, fn, rng, max_dE)
+    else:
+        t2 = _build(t1.x_m, t1.p_m, t1.g_m, v, depth - 1, eps, H0, metric, fn, rng, max_dE)
+    t1.sum_acc += t2.sum_acc
+    t1.n_leaf += t2.n_leaf
+    if t2.turning or t2.diverging:
+        t1.turning = t1.turning or t2.turning
+        t1.diverging = t1.diverging or t2.diverging
+        return t1
+    t1.turning = not _merge(t1, t2, v, rng, biased=False)
+    return t1
+
+
+def nuts_step(x, lp, g, eps, metric: Metric, fn: LogpGrad, rng, max_depth=10, max_dE=1000.0):
+    """One NUTS transition.
+
+    Returns ``(x, lp, g, accept_stat, depth, diverging, n_leapfrog, energy)``.
+    """
+    p0 = metric.draw_momentum(rng)
+    v0 = metric.mv(p0)
+    H0 = float(lp) - 0.5 * float(p0 @ v0)
+    tree = _Tree()
+    tree.x_m = tree.x_p = x
+    tree.p_m = tree.p_p = p0
+    tree.v_m = tree.v_p = v0
+    tree.g_m = tree.g_p = g
+    tree.log_w = 0.0
+    tree.rho = p0
+    tree.x_prop, tree.lp_prop, tree.g_prop, tree.p_prop = x, lp, g, p0
+    sum_acc, n_leaf = 0.0, 0
+    diverging = False
+    n_doublings = 0
+    for depth in range(max_depth):
+        v = 1 if rng.random() < 0.5 else -1
+        if v > 0:
+            t = _build(tree.x_p, tree.p_p, tree.g_p, v, depth, eps, H0, metric, fn, rng, max_dE)
+        else:
+            t = _build(tree.x_m, tree.p_m, tree.g_m, v, depth, eps, H0, metric, fn, rng, max_dE)
+        sum_acc += t.sum_acc
+        n_leaf += t.n_leaf
+        if t.diverging:
+            diverging = True
+            break
+        if t.turning:
+            break
+        ok = _merge(tree, t, v, rng, biased=True)
+        n_doublings = depth + 1
+        if not ok:
+            break
+    accept = sum_acc / max(n_leaf, 1)
+    energy = -float(tree.lp_prop) + metric.kinetic(tree.p_prop)
+    return tree.x_prop, tree.lp_prop, tree.g_prop, accept, n_doublings, diverging, n_leaf, energy
+
+
+def find_reasonable_eps(x, lp, g, metric: Metric, fn: LogpGrad, rng) -> float:
+    """Heuristic initial step size (Hoffman & Gelman 2014, Algorithm 4).
+
+    Starts from 1 with one momentum draw and an acceptance threshold of 0.5,
+    unlike Stan's ``init_stepsize`` (current step size, threshold 0.8).
+    """
+    eps = 1.0
+    p = metric.draw_momentum(rng)
+    H0 = lp - metric.kinetic(p)
+
+    def dH(e):
+        _, p1, _, lp1 = leapfrog(x, p, g, e, metric, fn)
+        if not np.isfinite(lp1):
+            return -np.inf
+        with np.errstate(over="ignore", invalid="ignore"):  # trial steps may blow up
+            h = lp1 - metric.kinetic(p1) - H0
+        return h if math.isfinite(h) else -np.inf
+
+    h = dH(eps)
+    a = 1.0 if h > np.log(0.5) else -1.0
+    for _ in range(100):
+        if not (a * h > -a * np.log(2.0)):
+            break
+        eps *= 2.0**a
+        h = dH(eps)
+    return float(eps)
+
+
+def adaptation_windows(
+    n_warmup: int,
+    init_buffer: int = _INIT_BUFFER,
+    term_buffer: int = _TERM_BUFFER,
+    base_window: int = _BASE_WINDOW,
+) -> list[tuple[int, int]]:
+    """Stan-style slow adaptation windows ``[(start, end), ...]``.
+
+    As Stan's, except that the first window also extends to the end of the slow
+    phase when the next would not fit, where Stan adds a short last window (49
+    warm-up lengths, all from 151 to 199 iterations, differ). None below 20.
+    """
+    if n_warmup < 20:
+        return []
+    if init_buffer + base_window + term_buffer > n_warmup:
+        init_buffer = int(0.15 * n_warmup)
+        term_buffer = int(0.1 * n_warmup)
+        base_window = n_warmup - init_buffer - term_buffer
+    wins = []
+    start, size = init_buffer, base_window
+    end_slow = n_warmup - term_buffer
+    while start < end_slow:
+        end = start + size
+        if end + 2 * size > end_slow:
+            end = end_slow
+        wins.append((start, end))
+        start = end
+        size *= 2
+    return wins

binference/samplers/base.py

@@ -0,0 +1,118 @@
+"""Base class and shared helpers for inference engines."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from .. import _kernels as kern
+from .._utils import RNGLike, as_generator
+from ..model import PopulationModel
+
+__all__ = ["Engine"]
+
+#: Most regularised EM steps of the start of Gibbs and of MAP's EM and L-BFGS paths when
+#: ``init`` is ``None``.
+INTERIOR_START_ITER = 50
+
+
+class Engine:
+    """Base class of all inference engines.
+
+    Engines are configured at construction and executed with :meth:`run`,
+    which returns a :class:`~binference.PopulationResult` (or a
+    :class:`~binference.PointEstimate` for :class:`~binference.samplers.MAP`).
+
+    Parameters
+    ----------
+    model : PopulationModel
+        The model to infer.
+    rng : int, numpy.random.Generator, or None
+        Random number generator.
+    progress : bool
+        Show a progress bar.
+    """
+
+    name: str = "engine"
+    approximate: bool = False
+    #: whether the engine infers a selection from injections or a tallied response jointly
+    #: (DECISIONS #30, #80, #81)
+    joint: bool = False
+    #: whether its draws are Markov chains, described by R-hat and ESS
+    markov: bool = False
+
+    def __init__(self, model: PopulationModel, *, rng: RNGLike = None, progress: bool = False):
+        if not isinstance(model, PopulationModel):
+            raise TypeError("Engines operate on a binference.PopulationModel.")
+        reason = self.unsupported(model)
+        if reason is not None:
+            raise ValueError(reason)
+        self.model = model
+        self.rng = as_generator(rng)
+        self.progress = bool(progress)
+
+    @classmethod
+    def unsupported(cls, model: PopulationModel) -> str | None:
+        """Why the engine cannot run on ``model``, or ``None`` when it can.
+
+        Parameters
+        ----------
+        model : PopulationModel
+            The model to run on.
+        """
+        if model.joint and not cls.joint:
+            from ..inference import METHODS  # the registry imports the engines
+
+            *names, last = (repr(k) for k, e in METHODS.items() if e.joint)
+            fixed = "selection.at_mean()" if model.selection_uncertain else "response.fixed()"
+            return (
+                f"{cls.__name__} cannot infer a selection from injections or a tallied "
+                f"response; use method={', '.join(names)} or {last}, or pass {fixed} for a "
+                "fixed one that ignores its uncertainty."
+            )
+        return None
+
+    def run(self, *args: Any, **kwargs: Any):  # pragma: no cover - abstract
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.model!r})"
+
+
+def em_update(
+    model: PopulationModel, value: np.ndarray, s: np.ndarray | None = None
+) -> np.ndarray | None:
+    """One EM step for conjugate priors (fractions or rates, with selection), given the
+    evidences ``s = L @ value`` when they are already computed.
+
+    Returns ``None`` where an object has zero likelihood, rather than taking zero
+    counts that would reset the step to the prior's mode (audit M-1).
+    """
+    s = kern.matvec(model._L, value) if s is None else s
+    if not kern.possible(s):
+        return None
+    nhat = value * kern.rmatvec(model._L, model._w / s)
+    counts = model._complete_counts(value, nhat)
+    return model.prior.map_from_counts(counts, exposure=model._exposure)
+
+
+def interior_start(model: PopulationModel, n_iter: int = INTERIOR_START_ITER) -> np.ndarray:
+    """A robust interior starting value: up to ``n_iter`` regularised EM steps from uniform.
+
+    Returns fractions (or rates for rate models) bounded away from zero.
+    """
+    K = model.K
+    rho = np.full(K, 1.0 / K)
+    for _ in range(n_iter):
+        nhat = model._complete_counts(rho, model.expected_counts(rho))
+        new = (nhat + 0.5) / (nhat.sum() + 0.5 * K)
+        converged = np.max(np.abs(new - rho)) < 1e-6
+        rho = new
+        if converged:
+            break
+    if model.kind == "rates":
+        # rho is the composition of the observed objects, n_k proportional to S_k lambda_k
+        # (rates impute nothing), so the MLE-like start is W rho_k / S_k (audit M-7)
+        return np.maximum(model.W * rho / np.maximum(model._S, 1e-12), 1e-12)
+    return rho

binference/samplers/bootstrap.py

@@ -0,0 +1,136 @@
+"""Bootstrap distribution of the MAP / maximum-likelihood estimator."""
+
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+
+from .._utils import RNGLike, is_integer_array, progress, warn
+from ..model import PopulationModel
+from ..results import PopulationResult
+from ..warnings import ApproximationWarning, ConvergenceWarning
+from .base import Engine
+from .optimize import MAP
+
+__all__ = ["Bootstrap"]
+
+
+class Bootstrap(Engine):
+    """Bootstrap over objects of the MAP / maximum-likelihood estimator.
+
+    ``scheme="nonparametric"`` resamples objects with replacement;
+    ``scheme="bayesian"`` reweights them with Dirichlet weights (Rubin 1981).
+    Integer weights are multiplicities, so a row of weight ``w`` stands for
+    ``w`` objects that are resampled individually. For rate models the number
+    of objects is itself random: objects get Poisson(1) counts (or Gamma(1)
+    weights), so the total rate varies between replicates. Every replicate is
+    fitted from an interior starting point; ``info["n_not_converged"]`` counts
+    the replicates whose fit did not converge (a warning names it).
+
+    The result is the sampling distribution of an estimator, not a posterior:
+    it is flagged ``approximate=True``. Useful for frequentist intervals and
+    comparisons with unfolding / empirical-Bayes practice.
+
+    Parameters
+    ----------
+    model : PopulationModel
+    scheme : {"nonparametric", "bayesian"}, optional
+        Resample objects (``"nonparametric"``) or reweight them with Dirichlet weights
+        (``"bayesian"``).
+    tol : float, optional
+        KKT tolerance of each replicate's MAP fit.
+    max_iter : int, optional
+        Most iterations of each replicate's MAP fit.
+    rng : int, Generator or None
+        Random number generator.
+    progress : bool, optional
+        Show a progress bar.
+    """
+
+    name = "bootstrap"
+    approximate = True
+
+    def __init__(
+        self,
+        model: PopulationModel,
+        *,
+        scheme: str = "nonparametric",
+        tol: float = 1e-8,
+        max_iter: int = 5000,
+        rng: RNGLike = None,
+        progress: bool = False,
+    ) -> None:
+        super().__init__(model, rng=rng, progress=progress)
+        if scheme not in ("nonparametric", "bayesian"):
+            raise ValueError("scheme must be 'nonparametric' or 'bayesian'.")
+        self.scheme = scheme
+        self.tol = float(tol)
+        self.max_iter = int(max_iter)
+
+    def _replicate_weights(self, w: np.ndarray, integer: bool, rates: bool) -> np.ndarray:
+        rng = self.rng
+        N = w.size
+        if self.scheme == "nonparametric":
+            if integer:  # resample the underlying objects, not the rows
+                if rates:
+                    return rng.poisson(w).astype(float)
+                W = round(float(w.sum()))
+                return rng.multinomial(W, w / w.sum()).astype(float)
+            counts = rng.poisson(1.0, size=N) if rates else rng.multinomial(N, np.full(N, 1 / N))
+            return w * counts
+        # Bayesian bootstrap: a row of multiplicity w gets a Gamma(w, 1) weight (a sum of
+        # w Exp(1) weights); fractions renormalise to the original total
+        g = rng.gamma(w, 1.0) if integer else w * rng.gamma(1.0, 1.0, size=N)
+        return g if rates else g * (w.sum() / g.sum())
+
+    def run(self, n_samples: int = 200) -> PopulationResult:
+        """Return ``n_samples`` bootstrap replicates of the estimate.
+
+        Parameters
+        ----------
+        n_samples : int, optional
+            Number of bootstrap replicates.
+        """
+        m = self.model
+        w = m.likelihoods.weights
+        integer = is_integer_array(w)
+        rates = m.kind == "rates"
+        base = MAP(m, tol=self.tol, max_iter=self.max_iter).run()  # warns if it fails
+        # EM cannot revive components that are exactly (or nearly) zero, and maximum
+        # likelihood estimates on grids are often sparse: start replicates inside
+        start = 0.5 * base.value + 0.5 * base.value.mean()
+        out = np.empty((int(n_samples), m.K))
+        n_not_converged = 0
+        for b in progress(range(int(n_samples)), n_samples, "Bootstrap", self.progress):
+            wb = self._replicate_weights(w, integer, rates)
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", ConvergenceWarning)
+                mw = m._with_weights(wb)  # zero-weight objects dropped (audit M-1)
+                engine = MAP(mw, tol=self.tol, max_iter=self.max_iter, init=start)
+                engine._diagnostics = False  # only the value is used
+                est = engine.run()
+            out[b] = est.value
+            n_not_converged += not est.converged
+        if n_not_converged:  # their warnings were silenced one by one (audit G-8)
+            warn(
+                f"{n_not_converged} of {int(n_samples)} bootstrap fits did not converge; raise "
+                "max_iter.",
+                ConvergenceWarning,
+            )
+        warn(
+            "Bootstrap replicates describe the sampling distribution of the MAP estimator, not "
+            "the posterior.",
+            ApproximationWarning,
+        )
+        return PopulationResult(
+            m,
+            out[None],
+            method="bootstrap",
+            approximate=True,
+            info={
+                "scheme": self.scheme,
+                "estimate": base.value,
+                "n_not_converged": n_not_converged,
+            },
+        )