fastcmb 0.3.0__py3-none-any.whl

fastcmb/__init__.py

@@ -0,0 +1,23 @@
+"""
+fastcmb: an online emulator of Boltzmann codes for CMB analyses.
+
+:class:`CMBEmulator` wraps a Boltzmann code -- an *oracle*, such as
+:class:`CAMBOracle` -- and answers with a Gaussian-process prediction
+wherever its error, in units of the log-likelihood, is below a
+tolerance; elsewhere the code runs, and the point is learned. It needs
+only numpy and scipy, and fits in any analysis code:
+
+* CosmoFit: ``theory: {background: ..., fastcmb: ...}`` in place of
+  ``camb`` (built into CosmoFit, with ``fastcmb`` installed);
+* cobaya: the theory ``fastcmb.cobaya.FastCAMB`` in place of ``camb``;
+* anything else: call a :class:`CMBEmulator`.
+"""
+
+from .camb_oracle import CAMBOracle
+from .emulator import CMBEmulator, Result
+from .gp import GP
+from .online import OnlineEmulator
+
+__all__ = ["GP", "CAMBOracle", "CMBEmulator", "OnlineEmulator", "Result", "__version__"]
+
+__version__ = "0.3.0"

fastcmb/camb_oracle.py

@@ -0,0 +1,134 @@
+"""
+CAMB as an oracle for :class:`~fastcmb.emulator.CMBEmulator`, with
+parameters named as cobaya and most codes name them.
+
+Parameters (missing ones take the default in brackets):
+
+* ``H0`` -- or ``cosmomc_theta`` (``100 theta_MC``, as ``theta_MC_100``);
+* ``ombh2``, ``omch2``; ``omk`` [0];
+* ``mnu`` [0.06 eV, one massive species], ``nnu`` [3.044];
+* ``ln1e10As`` (or ``logA``) or ``As``; ``ns``; ``tau``;
+* ``w`` [-1], ``wa`` [0]: a CPL dark energy through CAMB's PPF module.
+
+CAMB is imported on first use.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+__all__ = ["CAMBOracle"]
+
+_DEFAULTS = {"omk": 0.0, "mnu": 0.06, "nnu": 3.044, "w": -1.0, "wa": 0.0}
+
+
+class CAMBOracle:
+    """
+    Parameters
+    ----------
+    lmax : int
+        Highest multipole of the spectra.
+    lens_potential_accuracy : int
+        CAMB's; 1 is enough for Planck's CMB spectra, 4 for its lensing.
+    halofit_version : str
+        CAMB's non-linear model for the lensing potential.
+    TCMB : float
+        CMB temperature [K].
+    accuracy : dict, optional
+        Passed to ``CAMBparams.set_accuracy`` (``AccuracyBoost``, ...).
+    """
+
+    def __init__(self, lmax: int = 2508, lens_potential_accuracy: int = 1,
+                 halofit_version: str = "mead2020", TCMB: float = 2.7255,
+                 accuracy: dict | None = None):
+
+        self.lmax = int(lmax)
+        self.lens_potential_accuracy = int(lens_potential_accuracy)
+        self.halofit_version = halofit_version
+        self.TCMB = float(TCMB)
+        self.accuracy = dict(accuracy or {})
+        self._camb = None
+
+    @property
+    def tag(self) -> str:
+        accuracy = ",".join(f"{k}={v}" for k, v in sorted(self.accuracy.items()))
+        return (f"camb|lmax={self.lmax}|lens={self.lens_potential_accuracy}"
+                f"|halofit={self.halofit_version}|T={self.TCMB}|{accuracy}")
+
+    def _import(self):
+        if self._camb is None:
+            import camb
+            self._camb = camb
+        return self._camb
+
+    def parameters(self, params: dict):
+        """The ``CAMBparams`` for ``params``."""
+
+        camb = self._import()
+        p = {**_DEFAULTS, **params}
+
+        pars = camb.CAMBparams()
+
+        theta = p.get("cosmomc_theta", p.get("theta_MC_100"))
+        cosmology = {
+            "ombh2": p["ombh2"], "omch2": p["omch2"], "omk": p["omk"], "mnu": p["mnu"], "nnu": p["nnu"],
+            "num_massive_neutrinos": 1 if p["mnu"] > 0 else 0, "TCMB": self.TCMB, "tau": p["tau"],
+        }
+
+        if theta is not None:
+            pars.set_cosmology(cosmomc_theta=float(theta) / 100.0, **cosmology)
+        else:
+            pars.set_cosmology(H0=p["H0"], **cosmology)
+
+        if "As" in p:
+            As = p["As"]
+        else:
+            As = math.exp(p.get("ln1e10As", p.get("logA"))) * 1.0e-10
+
+        pars.InitPower.set_params(As=As, ns=p["ns"])
+
+        if p["w"] != -1.0 or p["wa"] != 0.0:
+            pars.set_dark_energy(w=p["w"], wa=p["wa"], dark_energy_model="ppf")
+
+        pars.set_matter_power(redshifts=[0.0], kmax=2.0, silent=True)
+        pars.set_for_lmax(self.lmax + 500, lens_potential_accuracy=self.lens_potential_accuracy)
+        pars.NonLinearModel.set_params(halofit_version=self.halofit_version)
+
+        if self.accuracy:
+            pars.set_accuracy(**self.accuracy)
+
+        return pars
+
+    def __call__(self, params: dict) -> dict | None:
+
+        camb = self._import()
+
+        try:
+            results = camb.get_results(self.parameters(params))
+
+            total = results.get_cmb_power_spectra(
+                lmax=self.lmax, spectra=("total",), CMB_unit="muK", raw_cl=True,
+            )["total"]
+            pp = results.get_lens_potential_cls(lmax=self.lmax)[:, 0]
+
+            sigma8 = float(results.get_sigma8_0())
+            sigma8_cb = float(results.get_sigmaR(8.0, z_indices=[-1], var1="delta_nonu",
+                                                 var2="delta_nonu")[0])
+
+        except camb.CAMBError:
+            return None
+
+        Cl = {
+            "ell": np.arange(self.lmax + 1),
+            "tt": total[:, 0], "ee": total[:, 1], "bb": total[:, 2], "te": total[:, 3], "pp": pp,
+        }
+
+        # CAMB can return NaN without raising; not a point to learn.
+        if not all(np.all(np.isfinite(v)) for v in Cl.values()) or not (
+            math.isfinite(sigma8) and math.isfinite(sigma8_cb)
+        ):
+            return None
+
+        return {"Cl": Cl, "sigma8": sigma8, "sigma8_cb": sigma8_cb}

fastcmb/cobaya.py

@@ -0,0 +1,133 @@
+"""
+fastcmb as a cobaya theory.
+
+In a cobaya input, in place of ``camb``::
+
+    theory:
+      fastcmb.cobaya.FastCAMB:
+        tolerance: 0.05
+        training_file: chains/emu/lcdm
+
+It provides ``Cl`` -- what cobaya's CMB likelihoods ask for -- and the
+derived ``sigma8``, from the parameters :mod:`fastcmb.camb_oracle`
+names (``H0`` or ``cosmomc_theta``, ``ombh2``, ``omch2``, ``logA`` or
+``As``, ``ns``, ``tau``, and optionally ``mnu``, ``nnu``, ``omk``,
+``w``, ``wa``). Where the emulator is not sure, CAMB runs.
+
+cobaya is imported here only, so ``fastcmb`` itself does not need it.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from cobaya.theory import Theory
+
+from .camb_oracle import CAMBOracle
+from .emulator import CMBEmulator
+
+__all__ = ["FastCAMB"]
+
+_INPUTS = ("H0", "cosmomc_theta", "theta_MC_100", "ombh2", "omch2", "omk", "mnu", "nnu",
+           "logA", "ln1e10As", "As", "ns", "tau", "w", "wa")
+
+
+class FastCAMB(Theory):
+
+    tolerance: float = 0.05
+    sigma8_tolerance: float = 1e-3
+    min_train: int = 30
+    retrain_fraction: float = 0.1
+    max_train: int = 800
+    training_file: str | None = None
+    check_every: int = 200
+    lens_potential_accuracy: int = 1
+    halofit_version: str = "mead2020"
+    TCMB: float = 2.7255
+    lmax: int = 0
+
+    def initialize(self):
+        self._lmax = int(self.lmax)
+        self._lens = int(self.lens_potential_accuracy)
+        self.emulator = None
+
+    def get_can_support_params(self):
+        return list(_INPUTS)
+
+    def get_can_provide(self):
+        return ["Cl"]
+
+    def get_can_provide_params(self):
+        return ["sigma8"]
+
+    def must_provide(self, **requirements):
+
+        Cl = requirements.get("Cl")
+        if Cl:
+            self._lmax = max(self._lmax, *(int(v) for v in Cl.values()))
+
+        return {}
+
+    def initialize_with_provider(self, provider):
+
+        super().initialize_with_provider(provider)
+
+        if self._lmax == 0:
+            self._lmax = 2508
+
+        oracle = CAMBOracle(lmax=self._lmax, lens_potential_accuracy=self._lens,
+                            halofit_version=self.halofit_version, TCMB=self.TCMB)
+
+        self.emulator = CMBEmulator(
+            oracle, inputs=sorted(self.input_params), tolerance=self.tolerance,
+            sigma8_tolerance=self.sigma8_tolerance, min_train=self.min_train,
+            retrain_fraction=self.retrain_fraction, max_train=self.max_train,
+            training_file=self.training_file, check_every=self.check_every,
+        )
+
+    def calculate(self, state, want_derived=True, **params_values_dict):
+
+        result = self.emulator(params_values_dict)
+
+        if result is None:
+            return False
+
+        state["Cl"] = result.Cl
+        state["emulated"] = result.emulated
+
+        if want_derived:
+            state["derived"] = {"sigma8": result.sigma8}
+
+    def get_Cl(self, ell_factor=False, units="FIRASmuK2"):
+        """As cobaya's ``camb`` returns them: ``tt``, ``te``, ``ee``, ``bb``, ``pp``."""
+
+        Cl = self.current_state["Cl"]
+
+        # cobaya's convention: the dimensionless spectra times u^2, with
+        # u from its table; the spectra here are in muK^2 at TCMB.
+        units_factor = {
+            "1": 1.0, "muK2": self.TCMB * 1e6, "K2": self.TCMB,
+            "FIRASmuK2": 2.7255e6, "FIRASK2": 2.7255,
+        }
+        if units not in units_factor:
+            raise ValueError(f"Units {units!r} not recognized; use one of {list(units_factor)}.")
+
+        factor = (units_factor[units] / (self.TCMB * 1e6)) ** 2
+
+        ell = Cl["ell"].astype(float)
+        out = {"ell": Cl["ell"]}
+
+        scale = np.ones_like(ell)
+        if ell_factor:
+            scale = ell * (ell + 1.0) / (2.0 * np.pi)
+
+        for name in ("tt", "te", "ee", "bb"):
+            out[name] = Cl[name] * factor * scale
+        out["et"] = out["te"]
+
+        # pp is [L(L+1)]^2 C_L / 2 pi already; raw C_L without ell_factor.
+        pp = Cl["pp"].copy()
+        if not ell_factor:
+            pp[1:] /= (ell[1:] * (ell[1:] + 1.0)) ** 2 / (2.0 * np.pi)
+        out["pp"] = pp
+
+        return out

fastcmb/compress.py

@@ -0,0 +1,148 @@
+"""
+What is emulated, and how it is made smooth and small.
+
+Each spectrum is a *block*. From ``l = 2``:
+
+* ``tt``, ``ee``, ``bb``, ``pp``: ``ln C_l`` -- positive, and spanning
+  orders of magnitude;
+* ``te``: the correlation ``C_TE / sqrt(C_TT C_EE)``, which crosses zero
+  where ``C_TE`` does and stays within [-1, 1];
+* ``scalars``: ``ln sigma8`` (all matter) and ``ln sigma8`` of the cold
+  matter.
+
+A block of spectra is projected on its leading principal components:
+as many as it takes to reproduce every training spectrum to
+:data:`PCA_TOLERANCE` in each multipole and, where the block has
+likelihood weights (:mod:`fastcmb.metric`), to :data:`PCA_LOGL` in
+the log-likelihood.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+__all__ = ["BLOCKS", "PCA", "PCA_TOLERANCE", "from_blocks", "to_blocks"]
+
+BLOCKS = ("tt", "te", "ee", "bb", "pp", "scalars")
+
+#: Largest error, over the training set, a block's PCA may make: in
+#: ``ln C_l`` (so 1e-3 is 0.1 %) or in the TE correlation.
+PCA_TOLERANCE = 1e-3
+
+#: Largest log-likelihood error, ``sqrt(delta^T F delta)``, a block's
+#: PCA may make on a training spectrum.
+PCA_LOGL = 0.01
+
+#: Most components a block keeps.
+MAX_COMPONENTS = 60
+
+
+def to_blocks(Cl: dict, sigma8: float, sigma8_cb: float) -> dict:
+    """A CosmoFit ``Cl`` dict and the two ``sigma8`` as block vectors."""
+
+    tt, ee, te = Cl["tt"][2:], Cl["ee"][2:], Cl["te"][2:]
+
+    return {
+        "tt": np.log(tt),
+        "te": te / np.sqrt(tt * ee),
+        "ee": np.log(ee),
+        "bb": np.log(Cl["bb"][2:]),
+        "pp": np.log(Cl["pp"][2:]),
+        "scalars": np.log([sigma8, sigma8_cb]),
+    }
+
+
+def from_blocks(blocks: dict, lmax: int) -> tuple[dict, float, float]:
+    """The inverse of :func:`to_blocks`: ``(Cl, sigma8, sigma8_cb)``."""
+
+    zeros = np.zeros(2)
+
+    tt = np.exp(blocks["tt"])
+    ee = np.exp(blocks["ee"])
+
+    Cl = {
+        "ell": np.arange(lmax + 1),
+        "tt": np.concatenate([zeros, tt]),
+        "ee": np.concatenate([zeros, ee]),
+        "bb": np.concatenate([zeros, np.exp(blocks["bb"])]),
+        "te": np.concatenate([zeros, blocks["te"] * np.sqrt(tt * ee)]),
+        "pp": np.concatenate([zeros, np.exp(blocks["pp"])]),
+    }
+
+    sigma8, sigma8_cb = np.exp(blocks["scalars"])
+
+    return Cl, float(sigma8), float(sigma8_cb)
+
+
+def _svd(Z):
+    """
+    The thin SVD of ``Z`` ``(n, l)``, from the eigenvectors of the
+    smaller of its two Gram matrices -- for ``n`` a few hundred points of
+    ``l`` ~ 2500 multipoles, much faster than LAPACK's SVD of ``Z``. The
+    components it loses to rounding are ~1e-8 of the largest, far below
+    what any tolerance here keeps.
+    """
+
+    n, l = Z.shape
+
+    if n <= l:
+        w, U = np.linalg.eigh(Z @ Z.T)
+        order = np.argsort(w)[::-1]
+        s = np.sqrt(np.maximum(w[order], 0.0))
+        U = U[:, order]
+        keep = s > s[0] * 1e-12
+        Vt = (U[:, keep].T @ Z) / s[keep, None]
+        return U[:, keep], s[keep], Vt
+
+    w, V = np.linalg.eigh(Z.T @ Z)
+    order = np.argsort(w)[::-1]
+    s = np.sqrt(np.maximum(w[order], 0.0))
+    V = V[:, order]
+    keep = s > s[0] * 1e-12
+    U = (Z @ V[:, keep]) / s[keep]
+    return U, s[keep], V[:, keep].T
+
+
+class PCA:
+    """Principal components of a block's training vectors ``(n, l)``."""
+
+    def __init__(self, Y, weights=None, tolerance: float = PCA_TOLERANCE,
+                 logl: float = PCA_LOGL, max_components: int = MAX_COMPONENTS):
+
+        Y = np.asarray(Y, dtype=float)
+
+        self.mean = Y.mean(0)
+        Z = Y - self.mean
+
+        if Y.shape[1] <= 2:
+            # Nothing to compress: the scalars are their own components.
+            self.components = np.eye(Y.shape[1])
+            return
+
+        U, s, Vt = _svd(Z)
+
+        top = min(max_components, Vt.shape[0])
+
+        # The fewest components that reproduce every training vector; the
+        # residual loses one component at a time. A block that has not
+        # varied keeps none: its mean is the prediction.
+        residual = Z.copy()
+        k = 0
+        for k in range(1, top + 1):
+            residual -= np.outer(U[:, k - 1] * s[k - 1], Vt[k - 1])
+            if np.abs(residual).max() >= tolerance:
+                continue
+            if weights is None or np.sqrt((residual ** 2 @ weights).max()) < logl:
+                break
+
+        self.components = Vt[:k]
+
+    @property
+    def size(self) -> int:
+        return self.components.shape[0]
+
+    def project(self, Y):
+        return (np.asarray(Y, dtype=float) - self.mean) @ self.components.T
+
+    def reconstruct(self, coefficients):
+        return self.mean + coefficients @ self.components

fastcmb/emulator.py

@@ -0,0 +1,247 @@
+"""
+The emulator as a function: parameters in, spectra out.
+
+:class:`CMBEmulator` wraps any Boltzmann code -- an *oracle*, a function
+from a parameter dict to spectra. At each call it predicts, and answers
+with the prediction when its error, in units of ``ln L``, is below the
+tolerance; otherwise it runs the oracle and learns the point.
+
+This is all an analysis code needs: CosmoFit's ``fastcmb`` theory, the
+cobaya theory in :mod:`fastcmb.cobaya`, or a script of one's own::
+
+    from fastcmb import CAMBOracle, CMBEmulator
+
+    emulator = CMBEmulator(CAMBOracle(lmax=2508))
+    result = emulator({"H0": 67.4, "ombh2": 0.0224, "omch2": 0.12,
+                       "ln1e10As": 3.044, "ns": 0.965, "tau": 0.054})
+    result.Cl["tt"], result.sigma8, result.emulated
+
+An oracle returns a dict with ``Cl`` -- ``ell``, ``tt``, ``te``, ``ee``,
+``bb`` (``C_l`` in muK^2) and ``pp`` (``[L(L+1)]^2 C_L / 2 pi``), from
+``l = 0`` to ``lmax`` -- and ``sigma8`` and ``sigma8_cb``; or ``None``
+when it cannot compute the point.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from dataclasses import dataclass
+
+import numpy as np
+
+from .compress import from_blocks, to_blocks
+from .online import OnlineEmulator
+
+__all__ = ["CMBEmulator", "Result"]
+
+log = logging.getLogger("fastcmb")
+
+
+@dataclass
+class Result:
+    Cl: dict
+    sigma8: float
+    sigma8_cb: float
+    #: Whether the spectra are the emulator's (else the oracle's).
+    emulated: bool
+    #: The predicted ``ln L`` error, when there was a prediction.
+    error: float | None = None
+    #: Whether this is a prediction above the tolerance, given because
+    #: the call allowed it (``loose_tolerance``): good enough to tell
+    #: that a point is far worse than another, not to be kept.
+    approximate: bool = False
+
+
+class CMBEmulator:
+    """
+    Parameters
+    ----------
+    oracle : callable
+        ``oracle(params) -> dict | None``, as described in the module.
+        It may also be given per call, to :meth:`__call__`.
+    lmax : int, optional
+        Highest multipole; by default the oracle's ``lmax``.
+    inputs : list of str, optional
+        The parameters the spectra depend on, in a fixed order. By
+        default the keys of the first call's parameters, sorted. A
+        parameter not listed is ignored -- it must not change the
+        spectra.
+    tag : str, optional
+        What the spectra are computed for (model, accuracy); points
+        stored under another tag are not read. By default the oracle's
+        ``tag``.
+    tolerance : float
+        Largest predicted ``ln L`` error the emulator answers with.
+        The measure is that of an idealized Planck (see
+        :mod:`fastcmb.metric`).
+    sigma8_tolerance : float
+        Largest predicted relative error of ``sigma8``.
+    min_train, retrain_fraction, max_train, training_file
+        As :class:`~fastcmb.online.OnlineEmulator`'s ``min_train``,
+        ``retrain_fraction``, ``max_train`` and ``path``.
+    check_every : int
+        After this many predictions, the oracle runs as well and the
+        error is measured; a prediction off by more than three times
+        the tolerance is learned. 0 never. While the checks find the
+        error within the tolerance, the interval between them doubles,
+        up to ten times ``check_every``; a check that does not brings
+        it back.
+    """
+
+    def __init__(self, oracle: Callable | None = None, lmax: int | None = None,
+                 inputs: list[str] | None = None, tag: str | None = None,
+                 tolerance: float = 0.05, sigma8_tolerance: float = 1e-3,
+                 min_train: int = 30, retrain_fraction: float = 0.1, max_train: int = 800,
+                 training_file: str | None = None, check_every: int = 200):
+
+        self.oracle = oracle
+        self.lmax = lmax if lmax is not None else getattr(oracle, "lmax", None)
+        self.inputs = None if inputs is None else list(inputs)
+        self.tag = tag if tag is not None else str(getattr(oracle, "tag", ""))
+        self.tolerance = float(tolerance)
+        self.sigma8_tolerance = float(sigma8_tolerance)
+        self.check_every = int(check_every)
+        self._options = {"min_train": min_train, "retrain_fraction": retrain_fraction,
+                         "max_train": max_train, "path": training_file}
+
+        self.online: OnlineEmulator | None = None
+
+        self.n_oracle = 0
+        self.n_emulated = 0
+        #: Predictions given as approximate (see :meth:`__call__`).
+        self.n_approximate = 0
+        self.check_errors: list[float] = []
+        self._check_interval = self.check_every
+        self._next_check = self.check_every
+
+    # ---------------------------------------------------------
+
+    def _vector(self, params) -> np.ndarray:
+
+        if self.inputs is None:
+            self.inputs = sorted(params)
+
+        try:
+            return np.array([float(params[name]) for name in self.inputs])
+        except KeyError as error:
+            raise KeyError(f"fastcmb: the emulator's input {error} is missing from the parameters.") from None
+
+    def _online(self) -> OnlineEmulator:
+
+        if self.online is None:
+            if self.lmax is None:
+                raise ValueError("fastcmb: give lmax, or an oracle that has one.")
+            self.online = OnlineEmulator(self.inputs, self.lmax, tag=self.tag, **self._options)
+
+        return self.online
+
+    def __call__(self, params: dict, oracle: Callable | None = None,
+                 loose_tolerance: float | None = None) -> Result | None:
+        """
+        The spectra at ``params``; ``None`` if the oracle cannot compute them.
+
+        With ``loose_tolerance``, a prediction whose error is above the
+        tolerance but below this is returned, marked ``approximate``,
+        instead of running the oracle. A sampler uses it to reject,
+        without the oracle, a point the prediction already shows to be
+        far worse than the current one; one it might accept, it asks
+        for again without.
+        """
+
+        oracle = oracle or self.oracle
+        if oracle is None:
+            raise ValueError("fastcmb: no oracle to compute the spectra with.")
+
+        x = self._vector(params)
+        online = self._online()
+
+        prediction = online.predict(x, tolerance=self.tolerance, scalar_tolerance=self.sigma8_tolerance)
+
+        trusted = (
+            prediction is not None
+            and prediction.error <= self.tolerance
+            and prediction.scalar_error <= self.sigma8_tolerance
+        )
+
+        if not trusted and loose_tolerance is not None and prediction is not None:
+
+            # The error above was bounded, stopping early; the exact
+            # one may be lower.
+            prediction = online.predict(x)
+            trusted = (prediction.error <= self.tolerance
+                       and prediction.scalar_error <= self.sigma8_tolerance)
+
+            if not trusted and prediction.error <= loose_tolerance:
+                self.n_approximate += 1
+                Cl, sigma8, sigma8_cb = from_blocks(prediction.blocks, online.lmax)
+                return Result(Cl, sigma8, sigma8_cb, emulated=True, error=prediction.error,
+                              approximate=True)
+
+        if not trusted:
+            return self._run(oracle, params, x, learn=True)
+
+        self.n_emulated += 1
+
+        if not (self.check_every and self.n_emulated >= self._next_check):
+            Cl, sigma8, sigma8_cb = from_blocks(prediction.blocks, online.lmax)
+            return Result(Cl, sigma8, sigma8_cb, emulated=True, error=prediction.error)
+
+        # A check: the oracle too, and the error measured.
+        result = self._run(oracle, params, x, learn=False)
+        self._next_check = self.n_emulated + self._check_interval
+
+        if result is not None:
+
+            truth = to_blocks(result.Cl, result.sigma8, result.sigma8_cb)
+            error = online.error_between(prediction.blocks, truth)
+            self.check_errors.append(error)
+
+            # Checks grow rarer while they pass.
+            if error <= self.tolerance:
+                self._check_interval = min(2 * self._check_interval, 10 * self.check_every)
+            else:
+                self._check_interval = self.check_every
+                self._next_check = self.n_emulated + self._check_interval
+
+            if error > 3.0 * self.tolerance:
+                log.warning(
+                    "fastcmb: a prediction was off by %.3g in ln L (predicted %.3g); "
+                    "the point is learned.", error, prediction.error,
+                )
+                online.add(x, truth)
+
+        return result
+
+    def _run(self, oracle, params, x, learn: bool) -> Result | None:
+
+        self.n_oracle += 1
+
+        out = oracle(params)
+
+        if out is None:
+            return None
+
+        result = Result(out["Cl"], float(out["sigma8"]), float(out["sigma8_cb"]), emulated=False)
+
+        if learn:
+            self.online.add(x, to_blocks(result.Cl, result.sigma8, result.sigma8_cb))
+
+        return result
+
+    # ---------------------------------------------------------
+
+    def stats(self) -> dict:
+        """Calls to the oracle and the emulator, and what the checks found."""
+
+        errors = np.array(self.check_errors)
+
+        return {
+            "oracle": self.n_oracle,
+            "emulated": self.n_emulated,
+            "approximate": self.n_approximate,
+            "training_points": 0 if self.online is None else self.online.size,
+            "checks": errors.size,
+            "check_error_median": float(np.median(errors)) if errors.size else None,
+            "check_error_max": float(errors.max()) if errors.size else None,
+        }