From 2fc3950d8230ae5f631ada8aab125d175686697f Mon Sep 17 00:00:00 2001 From: beykyle Date: Mon, 10 Aug 2026 23:21:12 -0400 Subject: [PATCH 01/24] Refactor covariance modeling into Term-based stacked covariance Replace the LikelihoodModel zoo with additive covariance Terms over each constraint's stacked observation vector: cross-block terms couple observations (case A) and Parameter-identity sharing wires one sampled value into several terms (case B). Likelihoods become thin functionals (Gaussian, Student-t, chi-squared) of the precomputed Mahalanobis statistics, with the full-tuple parameter convention validated everywhere. Also: constraint-scoped parameter validation (cross-constraint sharing and duplicate names are hard errors), fail-fast singular-covariance checks naming the offending dataset, frozen block classification with cached dense and per-block Cholesky factors, measurement systematics retained as inert Observation metadata with an opt-in systematic_terms factory (norm-divided units), latent-scale models (ScaledModel, PerObservationScaledModel), predictive utilities including GP discrepancy propagation, and comprehensive unit + regression coverage (178 tests), including real-solver smoke tests and a fix for the never-working dXS/dA-from-dXS/dRuth unit conversion. Co-Authored-By: Claude Fable 5 --- pyproject.toml | 9 +- src/rxmc/__init__.py | 8 +- src/rxmc/config.py | 63 +- src/rxmc/constraint.py | 342 +++--- ...correlated_discrepancy_likelihood_model.py | 128 --- src/rxmc/covariance.py | 576 +++++++++++ src/rxmc/elastic_diffxs_observation.py | 107 +- src/rxmc/evidence.py | 200 ++-- src/rxmc/ias_pn_observation.py | 82 +- src/rxmc/likelihood_model.py | 979 ++---------------- src/rxmc/observation.py | 347 +++---- src/rxmc/observation_from_measurement.py | 191 +--- src/rxmc/physical_model.py | 125 +++ src/rxmc/predictive.py | 267 +++++ src/rxmc/walker.py | 10 +- test/conftest.py | 6 + test/helpers.py | 22 + test/test_config.py | 136 ++- test/test_constraint.py | 443 +++++++- test/test_covariance.py | 497 +++++++++ test/test_evidence.py | 142 ++- test/test_likelihood_model.py | 573 +++------- test/test_observation.py | 307 ++---- test/test_predictive.py | 200 ++++ test/test_reaction_models.py | 120 +++ test/test_reaction_observation.py | 174 +++- test/test_regression.py | 141 +++ test/test_sampler.py | 141 ++- 28 files changed, 3813 insertions(+), 2523 deletions(-) delete mode 100644 src/rxmc/correlated_discrepancy_likelihood_model.py create mode 100644 src/rxmc/covariance.py create mode 100644 src/rxmc/predictive.py create mode 100644 test/conftest.py create mode 100644 test/helpers.py create mode 100644 test/test_covariance.py create mode 100644 test/test_predictive.py create mode 100644 test/test_reaction_models.py create mode 100644 test/test_regression.py diff --git a/pyproject.toml b/pyproject.toml index 5502d87..731bee7 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -88,8 +88,11 @@ target-version = "py310" select = ["F", "I"] [tool.ruff.lint.isort] -known-first-party = ["rxmc"] +# match isort's src_paths = ["src", "test"]: the shared test helpers module is +# first-party too, so the two sorters agree +known-first-party = ["rxmc", "helpers"] [tool.pytest.ini_options] -addopts = "--nbmake --nbmake-timeout=1200" -testpaths = ["test", "examples"] +# bare `pytest` runs the unit suite only; the notebooks are executed in CI via +# `pytest -n 4 --nbmake --nbmake-timeout=1200 examples` +testpaths = ["test"] diff --git a/src/rxmc/__init__.py b/src/rxmc/__init__.py index a68737d..9a76a0e 100644 --- a/src/rxmc/__init__.py +++ b/src/rxmc/__init__.py @@ -1,9 +1,7 @@ from . import adaptive_metropolis as adaptive_metropolis from . import config as config from . import constraint as constraint -from . import ( - correlated_discrepancy_likelihood_model as correlated_discrepancy_likelihood_model, -) +from . import covariance as covariance from . import elastic_diffxs_model as elastic_diffxs_model from . import elastic_diffxs_observation as elastic_diffxs_observation from . import evidence as evidence @@ -15,6 +13,7 @@ from . import param_sampling as param_sampling from . import params as params from . import physical_model as physical_model +from . import predictive as predictive from . import priors as priors from . import walker as walker from .__version__ import __version__ as __version__ @@ -24,7 +23,7 @@ "adaptive_metropolis", "config", "constraint", - "correlated_discrepancy_likelihood_model", + "covariance", "elastic_diffxs_model", "elastic_diffxs_observation", "evidence", @@ -36,6 +35,7 @@ "param_sampling", "params", "physical_model", + "predictive", "priors", "walker", ] diff --git a/src/rxmc/config.py b/src/rxmc/config.py index 0957e8b..55e99de 100644 --- a/src/rxmc/config.py +++ b/src/rxmc/config.py @@ -252,16 +252,12 @@ def __init__( 1.0 if likelihood_scaling is None else likelihood_scaling ) - if ( - len(self.evidence.constraints) == 0 - and len(self.evidence.parametric_constraints) == 0 - ): + if len(self.evidence.constraints) == 0: raise ValueError("Evidence must have at least one constraint") if np.any( [ c.physical_model.params != self.model_config.params for c in self.evidence.constraints - + self.evidence.parametric_constraints ] ): raise ValueError( @@ -273,7 +269,7 @@ def __init__( "in the evidence constraints" ) for lc, c in zip(self.likelihood_configs, self.evidence.parametric_constraints): - if lc.params != c.likelihood.params: + if list(lc.params) != list(c.params): raise ValueError( "Likelihood parameters do not match those in the evidence constraints" ) @@ -523,20 +519,45 @@ def predict(self, xmodel) -> list: Returns ------- - list of ndarray - Predicted observable for each constraint, in the order - ``evidence.constraints + evidence.parametric_constraints``. + list + One entry per constraint, in ``evidence.constraints`` order; each entry + is itself a list of per-observation prediction arrays. For the + conditioning data of a likelihood sector use :meth:`predict_parametric`, + whose order matches :meth:`conditional_posterior`'s ``lm_index``. + """ + return [c.predict(*xmodel) for c in self.evidence.constraints] + + def predict_parametric(self, xmodel) -> list: + """Predictions for the *parametric* constraints only. + + Indexed in ``evidence.parametric_constraints`` order, so + ``predict_parametric(xmodel)[lm_index]`` is the correct ``ym`` to feed + :meth:`conditional_posterior` at ``lm_index`` (unlike :meth:`predict`, + which is indexed over *all* constraints and therefore misaligns whenever a + non-parametric constraint precedes a parametric one). + + Parameters + ---------- + xmodel : ndarray, shape (model_config.ndim,) + Physical model parameter vector. + + Returns + ------- + list + One prediction per parametric constraint. """ - constraints = self.evidence.constraints + self.evidence.parametric_constraints - return [c.predict(*xmodel) for c in constraints] + return [c.predict(*xmodel) for c in self.evidence.parametric_constraints] def conditional_posterior(self, x_lm, lm_index: int, ym) -> float: """Log posterior for one likelihood sector, conditioned on observed data. - Evaluates ``marginal_log_likelihood(ym, *x_lm) + prior_logpdf(x_lm)`` - for the likelihood sector at ``lm_index``. Useful for Gibbs-style - updates where the likelihood parameters are sampled separately from - the physical model parameters. + Evaluates + ``prior_logpdf(x_lm) + likelihood_scaling * w * marginal_log_likelihood(ym, *x_lm)`` + for the likelihood sector at ``lm_index``, where ``w`` is the + constraint's :attr:`Evidence.weights` entry. The likelihood is tempered + exactly as in :meth:`log_posterior` (prior untouched), so Gibbs-style + updates that alternate this conditional with the model block target the + same joint distribution. Parameters ---------- @@ -546,13 +567,17 @@ def conditional_posterior(self, x_lm, lm_index: int, ym) -> float: Index into ``likelihood_configs`` (and ``evidence.parametric_constraints``). ym : ndarray - Predicted observable used as the conditioning data. + Predicted observable used as the conditioning data — use + ``predict_parametric(xmodel)[lm_index]`` to obtain it with matching + index order. Returns ------- float Log posterior for this likelihood sector. """ - return self.evidence.parametric_constraints[lm_index].marginal_log_likelihood( - ym, *x_lm - ) + self.likelihood_configs[lm_index].prior_logpdf(x_lm) + lp = self.likelihood_configs[lm_index].prior_logpdf(x_lm) + if not np.isfinite(lp): + return -np.inf + ll = self.evidence.weighted_marginal_log_likelihood(lm_index, ym, *x_lm) + return lp + self.likelihood_scaling * ll diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index ff197c7..dde8a3d 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -1,163 +1,288 @@ """ -Constraint: the composition of observations, a physical model, and a likelihood. +Constraint: the maximal block of mutually-correlated data. A :class:`Constraint` pairs one or more :class:`~rxmc.observation.Observation` -objects with a :class:`~rxmc.physical_model.PhysicalModel` and a -:class:`~rxmc.likelihood_model.LikelihoodModel`. Given model parameters it -computes the log likelihood, chi-squared statistic, and coverage statistics. +objects with a :class:`~rxmc.physical_model.PhysicalModel` and a likelihood +functional (:class:`~rxmc.likelihood_model.GaussianLikelihood` by default). It +owns **one** multivariate distribution over the *stacked* vector of all its +observations, whose covariance is a +:class:`~rxmc.covariance.ConstraintCovariance` assembled from +:class:`~rxmc.covariance.Term` s. + +Each observation *i* occupies a contiguous slice of the stacked vector. The +default covariance is the concatenation of every observation's statistical +diagonal (strictly block-diagonal — reproducing the old summed independent +likelihoods). Correlated modes — a dataset's own normalisation/offset +systematic, an unknown-noise term, or a cross-dataset coupling — are supplied as +``extra_terms``. """ import numpy as np -from .likelihood_model import LikelihoodModel +from .covariance import ConstraintCovariance, StackContext, stacked_supports +from .likelihood_model import GaussianLikelihood from .observation import Observation from .physical_model import PhysicalModel class Constraint: - """Pair observations with a physical model and a likelihood model. - - A ``Constraint`` is the composition of one or more :class:`~rxmc.observation.Observation` - objects with a :class:`~rxmc.physical_model.PhysicalModel` and a - :class:`~rxmc.likelihood_model.LikelihoodModel`. It acts as a box that - accepts model parameters and returns the log likelihood or other statistics, - acting as a constraint on those parameters. + """Pair observations with a physical model and a stacked covariance. Parameters ---------- observations : list of Observation - The observed data that the model will attempt to reproduce. + The observed data that the model will attempt to reproduce. Together + they form one stacked vector ``y = [y1; y2; ...]``. physical_model : PhysicalModel Model that predicts the observed data. - likelihood_model : LikelihoodModel - Model that defines the likelihood of the observations given the - physical-model predictions. + likelihood : object, optional + Likelihood functional of ``(d2, logdet, n, *like_params)``. Defaults to + :class:`~rxmc.likelihood_model.GaussianLikelihood`. + extra_terms : sequence of Term, optional + Additional covariance contributions beyond the statistical diagonals — + local systematics or cross-block couplings. + include_statistical_term : bool, optional + When ``True`` (default) each observation's statistical diagonal + (``obs.statistical_term``) is added automatically. Set ``False`` to omit + it and compose the *entire* covariance from ``extra_terms`` — e.g. to let + an unknown-noise term (:func:`~rxmc.covariance.noise_term`) *replace* the + reported statistics rather than add to them. + + Attributes + ---------- + covariance : ConstraintCovariance + The stacked covariance. + params : tuple of Parameter + Free parameters of this constraint: covariance params followed by + likelihood params (e.g. Student-t ``nu``). + n_params : int + ``len(params)``. """ def __init__( self, observations: list[Observation], physical_model: PhysicalModel, - likelihood_model: LikelihoodModel, + likelihood=None, + extra_terms=(), + include_statistical_term: bool = True, ): self.observations = observations self.physical_model = physical_model - self.likelihood = likelihood_model - self.n_data_pts = sum(obs.n_data_pts for obs in self.observations) + self.likelihood = likelihood if likelihood is not None else GaussianLikelihood() - def model(self, model_params): - """Compute the physical model output for each observation. + supports = stacked_supports(observations) + self._supports = supports + self.n_data_pts = sum(o.n_data_pts for o in observations) - Parameters - ---------- - model_params : tuple - Parameters of the physical model. + # x and y are invariant per constraint; stack them once. Frozen + # because they are shared across every likelihood evaluation. + self._x_stacked = np.concatenate([o.x for o in observations]) + self._y_stacked = np.concatenate([o.y for o in observations]) + self._x_stacked.setflags(write=False) + self._y_stacked.setflags(write=False) - Returns - ------- - list of np.ndarray - Model predictions, one array per observation. - """ - return [self.physical_model(obs, *model_params) for obs in self.observations] + if include_statistical_term: + terms = [obs.statistical_term(s) for obs, s in zip(observations, supports)] + else: + terms = [] + terms += list(extra_terms) + self.covariance = ConstraintCovariance(terms, self.n_data_pts, blocks=supports) - def log_likelihood(self, model_params, likelihood_params=()): - """Total log likelihood over all observations. + self.params = tuple(self.covariance.params) + tuple(self.likelihood.params) + self.n_params = len(self.params) + self._n_cov_params = self.covariance.n_params - Parameters - ---------- - model_params : tuple - Parameters of the physical model. - likelihood_params : tuple, optional - Additional parameters for the likelihood model. + self._validate_parameter_names() + if self.covariance.is_constant: + self._validate_constant_covariance() - Returns - ------- - float - Sum of log likelihoods across all observations. + def _validate_parameter_names(self): + """Reject ambiguous parameter names within this constraint. + + Sharing one sampled value between terms works by referencing the *same* + ``Parameter`` object (identity); two distinct objects with one name would + silently become two sampler columns with identical labels. """ - return sum( - self.likelihood.log_likelihood( - obs, self.physical_model(obs, *model_params), *likelihood_params + model_names = {p.name for p in self.physical_model.params} + seen = set() + for p in self.params: + if p.name in seen: + raise ValueError( + f"Constraint has multiple distinct parameters named " + f"'{p.name}'. To share one sampled value between terms, " + "pass the SAME Parameter object to each term; otherwise " + "give each parameter a unique name." + ) + seen.add(p.name) + if p.name in model_names: + raise ValueError( + f"Constraint parameter '{p.name}' collides with a " + "physical-model parameter of the same name; rename the " + "covariance/likelihood parameter." + ) + + def _validate_constant_covariance(self): + """Fail fast on a singular constant covariance (also warms the cache). + + A routine trigger is an EXFOR measurement reporting no statistical + error: ``from_measurement`` then yields an all-zero ``y_stat_err``, and + without an extra covariance term the stacked covariance is singular. + Catching it here names the offending dataset instead of surfacing an + opaque ``LinAlgError`` deep inside a sampler. + """ + try: + self.covariance.cholesky(None) + except np.linalg.LinAlgError as err: + labels = [ + o.label or f"observation {i}" for i, o in enumerate(self.observations) + ] + Sigma = self.covariance.matrix(None) + zero_rows = np.flatnonzero(np.diag(Sigma) == 0.0) + offenders = [ + label + for label, s in zip(labels, self._supports) + if np.isin(s, zero_rows).any() + ] + msg = ( + f"Constraint covariance over [{', '.join(labels)}] is singular " + "(Cholesky factorization failed)." ) - for obs in self.observations - ) + if offenders: + msg += ( + f" The covariance diagonal is zero on rows belonging to " + f"{offenders}: these datasets report zero statistical error " + "and no other covariance term covers their points." + ) + msg += ( + " Remedies: pass the dataset's reported systematics as terms " + "(extra_terms=[*obs.systematic_terms(support)], with supports " + "from rxmc.covariance.stacked_supports(observations)), add a " + "noise_term or DenseTerm covering those points, or compose the " + "full covariance explicitly with include_statistical_term=False." + ) + raise ValueError(msg) from err - def marginal_log_likelihood(self, ym: list, *likelihood_params): - """Log likelihood given pre-computed model predictions. + # ------------------------------------------------------------------ + # Stacking + # ------------------------------------------------------------------ - Parameters - ---------- - ym : list of np.ndarray - Pre-computed model predictions for each observation. - *likelihood_params : float - Additional parameters for the likelihood model. + def _stack(self, model_params): + ym = [self.physical_model(o, *model_params) for o in self.observations] + return self._stack_from_predictions(ym) - Returns - ------- - float - Sum of log likelihoods across all observations. - """ - return sum( - self.likelihood.log_likelihood(obs, y, *likelihood_params) - for obs, y in zip(self.observations, ym) + def _stack_from_predictions(self, ym: list): + if len(ym) != len(self.observations): + raise ValueError( + f"expected {len(self.observations)} prediction arrays, got {len(ym)}" + ) + ym_arrays = [] + for o, y in zip(self.observations, ym): + y = np.asarray(y) + if y.shape != o.y.shape: + raise ValueError( + f"prediction shape {y.shape} does not match observation shape " + f"{o.y.shape}" + ) + ym_arrays.append(y) + return StackContext( + x=self._x_stacked, + y=self._y_stacked, + ym=np.concatenate(ym_arrays), + supports=self._supports, ) - def chi2(self, model_params, likelihood_params=()): - """Generalised chi-squared (Mahalanobis distance) summed over observations. + def _split(self, params): + params = tuple(params) + if len(params) != self.n_params: + names = ", ".join(p.name for p in self.params) or "none" + raise ValueError( + f"Constraint expects {self.n_params} parameter(s) [{names}], " + f"got {len(params)}" + ) + return params[: self._n_cov_params], params[self._n_cov_params :] + + # ------------------------------------------------------------------ + # Likelihood + # ------------------------------------------------------------------ + + def _evaluate(self, ctx, cov_params, statistic): + cov_part, like_part = self._split(cov_params) + d2, logdet = self.covariance.stacked_distance(ctx, cov_part) + return statistic(d2, logdet, self.n_data_pts, *like_part) + + def log_likelihood(self, model_params, cov_params=()): + """Log likelihood of the stacked observations given the model. Parameters ---------- model_params : tuple - Parameters of the physical model. - likelihood_params : tuple, optional - Additional parameters for the likelihood model. - - Returns - ------- - float - Total chi-squared statistic. + Physical-model parameters. + cov_params : tuple, optional + Constraint parameters: covariance params followed by likelihood + params, in :attr:`params` order. """ - return sum( - self.likelihood.chi2( - obs, self.physical_model(obs, *model_params), *likelihood_params - ) - for obs in self.observations - ) + ctx = self._stack(model_params) + return self._evaluate(ctx, cov_params, self.likelihood.log_likelihood) - def predict(self, *model_params): - """Generate predictions for each observation. + def marginal_log_likelihood(self, ym: list, *cov_params): + """Log likelihood from pre-computed predictions (Gibbs hook). Parameters ---------- - *model_params : float - Parameters of the physical model. + ym : list of np.ndarray + One prediction array per observation (no physical-model re-eval). + *cov_params : float + Constraint parameters, in :attr:`params` order. + """ + ctx = self._stack_from_predictions(ym) + return self._evaluate(ctx, cov_params, self.likelihood.log_likelihood) - Returns - ------- - list of np.ndarray - Predicted values for each observation. + def chi2(self, model_params, cov_params=()): + """Generalised chi-squared (Mahalanobis distance) over the stack. + + ``cov_params`` is the full constraint tuple in :attr:`params` order, + including likelihood params (e.g. Student-t ``nu``) even though the + chi-squared statistic ignores them. """ + ctx = self._stack(model_params) + return self._evaluate(ctx, cov_params, self.likelihood.chi2) + + def predict(self, *model_params): + """Generate predictions for each observation.""" return [self.physical_model(obs, *model_params) for obs in self.observations] - def num_pts_within_interval( - self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None - ): - """Count data points that fall within a predictive interval. + def covariance_matrix(self, model_params, cov_params=()): + """Assemble the stacked covariance matrix Σ at a parameter point. + + Convenience accessor (e.g. for visualising the off-diagonal block + structure of correlated observations). Parameters ---------- - ylow : list of np.ndarray - Lower bounds of the interval for each observation. - yhigh : list of np.ndarray - Upper bounds of the interval for each observation. - xlim : tuple, optional - ``(x_min, x_max)`` range to restrict the count. + model_params : tuple + Physical-model parameters (needed for prediction-scaled terms). + cov_params : tuple, optional + Constraint parameters: covariance params followed by likelihood + params, in :attr:`params` order (matching :meth:`log_likelihood`). Returns ------- - int - Total number of points within the interval across all observations. + np.ndarray, shape (n_data_pts, n_data_pts) + A fresh copy (safe to mutate; never aliases the internal cache). """ + ctx = self._stack(model_params) + cov_part, _ = self._split(cov_params) + return np.array(self.covariance.matrix(ctx, *cov_part)) + + # ------------------------------------------------------------------ + # Coverage diagnostics + # ------------------------------------------------------------------ + + def num_pts_within_interval( + self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None + ): + """Count data points that fall within a predictive interval.""" return sum( obs.num_pts_within_interval(ylow[i], yhigh[i], xlim) for i, obs in enumerate(self.observations) @@ -166,20 +291,5 @@ def num_pts_within_interval( def empirical_coverage( self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None ): - """Fraction of data points within a predictive interval. - - Parameters - ---------- - ylow : list of np.ndarray - Lower bounds of the interval for each observation. - yhigh : list of np.ndarray - Upper bounds of the interval for each observation. - xlim : tuple, optional - ``(x_min, x_max)`` range to restrict the count. - - Returns - ------- - float - Empirical coverage fraction in ``[0, 1]``. - """ + """Fraction of data points within a predictive interval.""" return self.num_pts_within_interval(ylow, yhigh, xlim) / self.n_data_pts diff --git a/src/rxmc/correlated_discrepancy_likelihood_model.py b/src/rxmc/correlated_discrepancy_likelihood_model.py deleted file mode 100644 index 4d29dbc..0000000 --- a/src/rxmc/correlated_discrepancy_likelihood_model.py +++ /dev/null @@ -1,128 +0,0 @@ -""" -Gaussian-process discrepancy likelihood model using sklearn kernels. - -:class:`SklearnKernelGPDiscrepancyModel` adds a GP discrepancy term to the -observation covariance, with the kernel hyperparameters sampled alongside the -physical-model parameters via the :class:`~rxmc.likelihood_model.ParametricLikelihoodModel` -interface. -""" - -import numpy as np -from sklearn.gaussian_process.kernels import Kernel - -from .likelihood_model import ParametricLikelihoodModel -from .observation import Observation -from .params import Parameter - - -class SklearnKernelGPDiscrepancyModel(ParametricLikelihoodModel): - """Parametric likelihood with a GP discrepancy covariance term. - - Adds a kernel-based GP discrepancy covariance to the observation covariance: - - .. math:: - - \\Sigma = \\Sigma_{\\mathrm{obs}}(y_m) + K_{\\mathrm{disc}}(x, x;\\,\\theta) + \\epsilon I - - The free hyperparameters of the sklearn kernel (those not marked ``fixed``) - become likelihood parameters that are sampled alongside the physical-model - parameters. sklearn stores hyperparameters in log space via ``kernel.theta``, - so the sampled values are also in log space. - - Parameters - ---------- - kernel : sklearn.gaussian_process.kernels.Kernel - Frozen sklearn kernel. Free hyperparameters (``hp.fixed == False``) - are registered as likelihood parameters. - jitter : float, optional - Small diagonal regularisation added to the GP covariance matrix for - numerical stability. Defaults to ``1e-10``. - param_prefix : str, optional - Prefix applied to each hyperparameter name when building the - :class:`~rxmc.params.Parameter` list. Defaults to ``"discrepancy_"``. - """ - - def __init__( - self, - kernel: Kernel, - jitter: float = 1e-10, - param_prefix: str = "discrepancy_", - ): - self.kernel = kernel - self.jitter = float(jitter) - self.param_prefix = param_prefix - - likelihood_params = [] - for hp in kernel.hyperparameters: - if hp.fixed: - continue - likelihood_params.append( - Parameter( - f"{param_prefix}_{hp.name}", - float, - latex_name=hp.name, - ) - ) - - super().__init__(likelihood_params) - - def _kernel_matrix( - self, observation: Observation, theta_vec: np.ndarray - ) -> np.ndarray: - """Evaluate the GP kernel matrix for the observation input grid. - - Parameters - ---------- - observation : Observation - Observation whose ``x`` attribute provides the input locations. - theta_vec : np.ndarray - Kernel hyperparameters in sklearn's log space. - - Returns - ------- - np.ndarray, shape (n, n) - Kernel matrix evaluated at ``observation.x``. - """ - X = np.asarray(observation.x) - if X.ndim == 1: - X = X[:, None] - k = self.kernel.clone_with_theta(np.asarray(theta_vec, dtype=float)) - return k(X) - - def covariance(self, observation: Observation, ym: np.ndarray, *kernel_theta): - """Total covariance: observation covariance plus GP discrepancy. - - Parameters - ---------- - observation : Observation - Observation object. - ym : np.ndarray - Model prediction for the observation. - *kernel_theta : float - Kernel hyperparameter values in sklearn's log space, one per free - hyperparameter of the kernel. - - Returns - ------- - np.ndarray, shape (n, n) - Combined covariance matrix. - - Raises - ------ - ValueError - If the number of *kernel_theta* values does not match - ``self.n_params``. - """ - if len(kernel_theta) != self.n_params: - raise ValueError( - f"Expected {self.n_params} kernel hyperparameters, got {len(kernel_theta)}" - ) - - sigma_obs = observation.covariance(ym) - K_disc = self._kernel_matrix(observation, np.array(kernel_theta, dtype=float)) - - cov = sigma_obs + K_disc - if self.jitter > 0: - cov = cov + self.jitter * np.eye(observation.n_data_pts) - - return cov diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py new file mode 100644 index 0000000..08ca08b --- /dev/null +++ b/src/rxmc/covariance.py @@ -0,0 +1,576 @@ +""" +Stacked-covariance model for a :class:`~rxmc.constraint.Constraint`. + +A constraint owns one multivariate-normal distribution over the *stacked* vector +of all its observations, ``y = [y1; y2; ...]``. The covariance of that MVN is +built additively from :class:`Term` objects, each of which writes its +contribution into a sub-block of the stacked covariance matrix selected by an +index array ``support``. + +Two mechanisms are expressed here (see ``covariance_refactor.md``): + +* **Correlating observations (A)** — a term whose ``support`` spans more than one + observation block writes off-diagonal blocks, coupling the data. A + block-diagonal covariance (every term local to one block) reproduces the old + per-observation summed likelihood as a special case. +* **Sharing a parameter (B)** — terms declare the :class:`~rxmc.params.Parameter` + objects they consume *by identity*. :class:`ConstraintCovariance` deduplicates + them (gather, not slice): two terms referencing the *same* ``Parameter`` object + share one entry in the sampled vector. + +Term primitives +--------------- +:class:`DenseTerm` + A fixed sub-block (statistical diagonal, fixed offset, fixed full covariance). +:class:`DiagonalTerm` + ``diag((c * basis)**2)`` — an uncorrelated (rank-zero) contribution. +:class:`RankOneTerm` + ``outer(v, v)`` with ``v = c * basis`` — one correlated mode. +:class:`KernelTerm` + A Gaussian-process kernel ``K(x, x; theta)`` over ``support``. + +Factory helpers (:func:`statistical_term`, :func:`normalization_term`, +:func:`offset_term`, :func:`noise_term`, :func:`noise_fraction_term`, +:func:`model_error_term`, :func:`discrepancy_term`) map each capability of the old +``LikelihoodModel`` zoo to a single ``Term``. +""" + +from dataclasses import dataclass + +import numpy as np +import scipy as sc + +from .params import Parameter + +__all__ = [ + "StackContext", + "Term", + "DenseTerm", + "DiagonalTerm", + "RankOneTerm", + "KernelTerm", + "ConstraintCovariance", + "stacked_supports", + "chol_logdet", + "ym_basis", + "ones_basis", + "averaging_basis", + "statistical_term", + "offset_term", + "normalization_term", + "noise_term", + "noise_fraction_term", + "model_error_term", + "discrepancy_term", +] + + +@dataclass(frozen=True) +class StackContext: + """Bundle of stacked arrays passed to every :meth:`Term.add_to`. + + Attributes + ---------- + x : np.ndarray + Stacked independent variable, ``np.concatenate`` over observations. + y : np.ndarray + Stacked observed data. + ym : np.ndarray + Stacked model prediction. + supports : tuple of np.ndarray + One contiguous index array per observation block, in stacking order. + """ + + x: np.ndarray + y: np.ndarray + ym: np.ndarray + supports: tuple + + +def stacked_supports(observations) -> tuple: + """One contiguous index array per observation, in stacking order. + + The block layout of the stacked vector ``y = [y1; y2; ...]``: + ``Constraint`` uses this internally, and callers building ``extra_terms`` + use it to place a term on the right rows. + """ + supports, b = [], 0 + for obs in observations: + supports.append(np.arange(b, b + obs.n_data_pts)) + b += obs.n_data_pts + return tuple(supports) + + +# ---------------------------------------------------------------------------- +# Standard basis callables (shared modes / diagonal scalings) +# ---------------------------------------------------------------------------- + + +def ym_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: + """Model prediction on ``support`` — the prediction-scaled basis.""" + return ctx.ym[support] + + +def ones_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: + """Constant unit basis on ``support``.""" + return np.ones(len(support)) + + +def averaging_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: + """``0.5 * (y + ym)`` on ``support`` — the averaging model-error basis.""" + return 0.5 * (ctx.y[support] + ctx.ym[support]) + + +def chol_logdet(Sigma): + """Lower Cholesky factor and log-determinant of a positive-definite matrix.""" + L = sc.linalg.cholesky(Sigma, lower=True) + return L, 2.0 * float(np.sum(np.log(np.diag(L)))) + + +def as_2d(X) -> np.ndarray: + """Promote a 1-D input grid to a single-column 2-D array (sklearn kernels).""" + X = np.asarray(X, dtype=float) + return X[:, None] if X.ndim == 1 else X + + +# ---------------------------------------------------------------------------- +# Term primitives +# ---------------------------------------------------------------------------- + + +class Term: + """One additive contribution to the stacked covariance. + + Subclasses set ``support`` (indices into the stacked vector) and ``params`` + (the :class:`~rxmc.params.Parameter` objects they consume, by identity) and + implement :meth:`add_to`. + + ``couples_offdiagonal`` declares whether the term can write off-diagonal + entries of its sub-block: terms that write only the diagonal (e.g. + :class:`DiagonalTerm`) can never couple observation blocks, whatever their + support. + + ``is_constant`` declares that the contribution depends on neither ``theta`` + nor ``ctx`` — a covariance whose every term is constant is factored once and + cached by :class:`ConstraintCovariance`. + """ + + params: tuple = () + support: np.ndarray + couples_offdiagonal: bool = True + is_constant: bool = False + + def add_to(self, Sigma: np.ndarray, ctx: StackContext, theta: np.ndarray) -> None: + raise NotImplementedError + + +class DenseTerm(Term): + """A fixed sub-block written into ``Sigma[support, support]``. + + A 1-D ``matrix`` is treated as a diagonal (variance vector); a 2-D ``matrix`` + is used as-is. + """ + + is_constant = True + + def __init__(self, support, matrix): + self.support = np.asarray(support, dtype=int) + m = np.asarray(matrix, dtype=float) + n = len(self.support) + if m.shape not in ((n,), (n, n)): + raise ValueError( + f"DenseTerm matrix shape {m.shape} does not match support " + f"length {n}: expected ({n},) or ({n}, {n})" + ) + if m.ndim == 2 and not np.allclose(m, m.T): + raise ValueError("DenseTerm 2-D matrix must be symmetric") + self.couples_offdiagonal = m.ndim != 1 + self._m = m + + def add_to(self, Sigma, ctx, theta): + ix = self.support + if self._m.ndim == 1: + Sigma[ix, ix] += self._m + else: + Sigma[np.ix_(ix, ix)] += self._m + + +class _ScaledBasisTerm(Term): + """Shared ``v = c * basis`` machinery for scaled-basis terms. + + ``c = exp(theta)`` when ``log`` else ``theta`` (``c = 1`` when there is no + parameter). ``basis`` is an array, a callable ``basis(ctx, support)``, or + ``None`` (ones). + """ + + def __init__(self, support, basis=None, parameter=None, log=True): + self.support = np.asarray(support, dtype=int) + self.basis = basis + self.log = log + self.params = (parameter,) if parameter is not None else () + # a callable basis reads ctx (e.g. ym); a parameter reads theta + self.is_constant = not self.params and not callable(basis) + + def _vec(self, ctx, theta): + if self.params: + c = np.exp(theta[0]) if self.log else theta[0] + else: + c = 1.0 + if callable(self.basis): + b = self.basis(ctx, self.support) + elif self.basis is not None: + b = np.asarray(self.basis, dtype=float) + else: + b = np.ones(len(self.support)) + return c * b + + +class DiagonalTerm(_ScaledBasisTerm): + """``diag((c * basis)**2)`` on ``support`` — an uncorrelated contribution. + + See :class:`_ScaledBasisTerm` for the ``basis``/``parameter``/``log`` + semantics. + """ + + couples_offdiagonal = False + + def add_to(self, Sigma, ctx, theta): + v = self._vec(ctx, theta) + ix = self.support + Sigma[ix, ix] += v**2 + + +class RankOneTerm(_ScaledBasisTerm): + """``outer(v, v)`` with ``v = c * basis`` — one correlated mode. + + A local systematic when ``support`` lies in a single observation block; a + cross-block *coupling* (case A) when ``support`` spans blocks. See + :class:`_ScaledBasisTerm` for the ``basis``/``parameter``/``log`` semantics. + """ + + def add_to(self, Sigma, ctx, theta): + v = self._vec(ctx, theta) + ix = self.support + Sigma[np.ix_(ix, ix)] += np.outer(v, v) + + +class KernelTerm(Term): + """A Gaussian-process kernel ``K(x, x; theta)`` over ``support``. + + Subsumes the old ``SklearnKernelGPDiscrepancyModel``. Auto-derives one + :class:`~rxmc.params.Parameter` per *free* kernel hyperparameter **element** + (sampled in sklearn's log-theta space): an anisotropic hyperparameter (one + with ``n_elements > 1``, e.g. a vector ``length_scale``) contributes that many + parameters, so ``len(self.params) == len(kernel.theta)``. Local on one block, + or a correlated discrepancy across blocks when ``support`` spans them. + """ + + def __init__(self, support, kernel, jitter=1e-10, prefix="discrepancy"): + self.support = np.asarray(support, dtype=int) + self.kernel = kernel + self.jitter = float(jitter) + params = [] + for hp in kernel.hyperparameters: + if hp.fixed: + continue + if hp.n_elements == 1: + params.append( + Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name) + ) + else: + params.extend( + Parameter( + f"{prefix}_{hp.name}_{i}", + float, + latex_name=f"{hp.name}[{i}]", + ) + for i in range(hp.n_elements) + ) + self.params = tuple(params) + + def add_to(self, Sigma, ctx, theta): + ix = self.support + X = as_2d(np.asarray(ctx.x)[ix]) + K = self.kernel.clone_with_theta(np.asarray(theta, dtype=float))(X) + K[np.diag_indices_from(K)] += self.jitter + Sigma[np.ix_(ix, ix)] += K + + +# ---------------------------------------------------------------------------- +# Constraint-local covariance: gather-by-identity over the stacked space +# ---------------------------------------------------------------------------- + + +class ConstraintCovariance: + """The stacked covariance of a constraint, assembled from :class:`Term` s. + + Parameters are routed *by identity*: the unique ``Parameter`` objects across + all terms (first-seen order) form the flat parameter vector; each term gathers + its own parameters from that vector. Referencing the *same* ``Parameter`` + object in two terms makes them share one sampled value (case B). + + Parameters + ---------- + terms : sequence of Term + Additive covariance contributions. + N : int + Dimension of the stacked vector. + blocks : sequence of np.ndarray, optional + One index array per observation block. When given, :attr:`block_diagonal` + is decided against the true block boundaries. When omitted, only a + covariance whose every term is strictly diagonal + (``couples_offdiagonal == False``) is classified block-diagonal; any + coupling-capable term conservatively forces the dense path — there is no + guessing of block structure from support shape. + + ``terms`` and ``blocks`` are treated as immutable after construction: + :attr:`block_diagonal` and :attr:`is_constant` are decided once, here. + """ + + def __init__(self, terms, N, blocks=None): + self.terms = list(terms) + self.N = int(N) + self._blocks = ( + None if blocks is None else [np.asarray(b, dtype=int) for b in blocks] + ) + + params, index_of = [], {} + for t in self.terms: + for p in t.params: + if id(p) not in index_of: # dedup by identity -> sharing + index_of[id(p)] = len(params) + params.append(p) + self.params = tuple(params) + self._gather = [ + np.array([index_of[id(p)] for p in t.params], dtype=int) for t in self.terms + ] + self._const_cache = None + self._chol_cache = None + self._block_chol_cache = None + + self.block_diagonal = all( + not t.couples_offdiagonal or self._within_one_block(t.support) + for t in self.terms + ) + self.is_constant = self.n_params == 0 and all(t.is_constant for t in self.terms) + + def _within_one_block(self, support) -> bool: + """True if ``support`` lies inside a single known observation block.""" + if self._blocks is None: + return False + support = np.asarray(support, dtype=int) + return any(bool(np.isin(support, b).all()) for b in self._blocks) + + @property + def n_params(self) -> int: + return len(self.params) + + @property + def blocks(self): + """Observation block index arrays, or ``None`` if unknown.""" + return self._blocks + + def matrix(self, ctx, *theta) -> np.ndarray: + """Assemble the stacked covariance matrix. + + Parameters + ---------- + ctx : StackContext + Stacked arrays; may be ``None`` only when :attr:`is_constant`. + *theta : float + One value per unique parameter, in :attr:`params` order. + """ + if len(theta) != self.n_params: + raise ValueError(f"expected {self.n_params} params, got {len(theta)}") + if self.is_constant and self._const_cache is not None: + return self._const_cache + theta = np.asarray(theta, dtype=float) + Sigma = np.zeros((self.N, self.N)) + for t, g in zip(self.terms, self._gather): + t.add_to(Sigma, ctx, theta[g]) + if self.is_constant: + # cached arrays are shared across calls; freeze so aliasing + # bugs fail loudly instead of corrupting later evaluations + Sigma.setflags(write=False) + self._const_cache = Sigma + return Sigma + + def cholesky(self, ctx, *theta): + """Lower Cholesky factor and log-determinant of the full stacked covariance. + + Cached when :attr:`is_constant` (the old ``FixedCovarianceLikelihood`` fast + path). + + Returns + ------- + (np.ndarray, float) + ``(L, logdet)`` with ``L`` lower-triangular and + ``logdet = log det Sigma``. + """ + if self.is_constant and self._chol_cache is not None: + return self._chol_cache + L, logdet = chol_logdet(self.matrix(ctx, *theta)) + result = (L, logdet) + if self.is_constant: + L.setflags(write=False) + self._chol_cache = result + return result + + def block_cholesky(self, ctx, *theta): + """Per-block ``(L_i, logdet_i)`` factors, aligned with :attr:`blocks`. + + Only meaningful when :attr:`block_diagonal`; cached when + :attr:`is_constant` so a constant block-diagonal covariance is factored + once instead of on every likelihood evaluation. + + Returns + ------- + tuple of (np.ndarray, float) + One ``(L_i, logdet_i)`` pair per block, ``L_i`` lower-triangular. + """ + if self._blocks is None: + raise ValueError("block_cholesky requires blocks to be set") + if self.is_constant and self._block_chol_cache is not None: + return self._block_chol_cache + Sigma = self.matrix(ctx, *theta) + factors = [] + for ix in self._blocks: + L, logdet = chol_logdet(Sigma[np.ix_(ix, ix)]) + L.setflags(write=False) + factors.append((L, logdet)) + factors = tuple(factors) + if self.is_constant: + self._block_chol_cache = factors + return factors + + def stacked_distance(self, ctx, params=()): + r"""Squared Mahalanobis distance and log-determinant over the stacked residual. + + Owns the dispatch between the block-diagonal fast path (factor each + block separately, :math:`O(\sum n_i^3)`, cached per block via + :meth:`block_cholesky` when constant) and a single dense Cholesky over + the full stack (cached via :meth:`cholesky` when constant). + + Returns + ------- + (float, float) + ``(d2, logdet)``. + """ + params = tuple(params) + if self.block_diagonal and self._blocks is not None and len(self._blocks) > 1: + factors = self.block_cholesky(ctx, *params) + d2 = 0.0 + logdet = 0.0 + for ix, (L, ld) in zip(self._blocks, factors): + z = sc.linalg.solve_triangular(L, ctx.y[ix] - ctx.ym[ix], lower=True) + d2 += float(np.dot(z, z)) + logdet += ld + return d2, logdet + + L, logdet = self.cholesky(ctx, *params) + z = sc.linalg.solve_triangular(L, ctx.y - ctx.ym, lower=True) + return float(np.dot(z, z)), logdet + + +# ---------------------------------------------------------------------------- +# Term factory helpers (the assembly-time builders) +# ---------------------------------------------------------------------------- + + +def _masked(magnitude, support, mask=None) -> np.ndarray: + """Broadcast a scalar/array magnitude over ``support`` with an optional mask. + + Scalar-like values include 0-d ndarrays (e.g. ``np.array(0.05)`` as stored by + ``exfor_tools`` distributions), not just Python scalars. + """ + n = len(support) + if np.ndim(magnitude) == 0: + v = np.full(n, float(magnitude), dtype=float) + else: + v = np.asarray(magnitude, dtype=float) + if v.shape != (n,): + raise ValueError( + f"magnitude shape {v.shape} does not match support length {n}" + ) + if mask is not None: + v = v * np.asarray(mask, dtype=float) + return v + + +def statistical_term(support, stat_err) -> DenseTerm: + """Always-on, genuinely uncorrelated statistical diagonal ``diag(stat_err**2)``.""" + return DenseTerm(support, np.asarray(stat_err, dtype=float) ** 2) + + +def offset_term( + support, magnitude=None, parameter=None, mask=None, log=True +) -> RankOneTerm: + """A correlated absolute-offset systematic ``outer(omega, omega)`` on ``support``. + + With ``magnitude`` it is a fixed (data-given) rank-one mode; with ``parameter`` + it is a free nuisance magnitude (``c = exp(theta)`` when ``log``). + """ + if magnitude is None and parameter is None: + raise ValueError("offset_term requires a magnitude and/or a parameter") + basis = _masked(1.0 if magnitude is None else magnitude, support, mask) + return RankOneTerm(support, basis=basis, parameter=parameter, log=log) + + +def normalization_term( + support, magnitude=None, parameter=None, mask=None, log=True +) -> RankOneTerm: + """A correlated normalisation systematic ``outer(eta * ym, eta * ym)``. + + With ``magnitude`` it is a fixed fractional normalisation uncertainty; with + ``parameter`` the magnitude eta is a free nuisance (``UnknownNormalizationError``, + ``c = exp(theta)`` when ``log``). In both cases the mode scales with the model + prediction ``ym`` on ``support``. + """ + if magnitude is None and parameter is None: + raise ValueError("normalization_term requires a magnitude and/or a parameter") + if magnitude is None and mask is None: + basis = ym_basis + else: + scale = _masked(1.0 if magnitude is None else magnitude, support, mask) + + def basis(ctx, support): + return scale * ctx.ym[support] + + return RankOneTerm(support, basis=basis, parameter=parameter, log=log) + + +def noise_term(support, parameter, log=True) -> DiagonalTerm: + """Unknown constant statistical noise ``diag(epsilon**2)`` (``UnknownNoise``). + + This term is **additive**: a :class:`~rxmc.constraint.Constraint` already adds + each observation's reported statistical diagonal, so the assembled covariance + is ``diag(y_stat_err**2 + epsilon**2)``. To make the inferred noise *replace* + the reported statistics (the old ``UnknownNoise`` semantics), build the + ``Observation`` with zero ``y_stat_err`` or pass ``include_statistical_term=False`` + to the ``Constraint``. + """ + return DiagonalTerm(support, basis=ones_basis, parameter=parameter, log=log) + + +def noise_fraction_term(support, parameter, log=True) -> DiagonalTerm: + """Unknown fractional noise ``diag((epsilon * ym)**2)`` (``UnknownNoiseFraction``). + + **Additive** on top of the reported statistical diagonal (see + :func:`noise_term` for how to get replace-semantics instead). + """ + return DiagonalTerm(support, basis=ym_basis, parameter=parameter, log=log) + + +def model_error_term(support, parameter, averaging=True, log=True) -> DiagonalTerm: + """Unknown uncorrelated model error ``diag((gamma * z)**2)`` (``UnknownModelError``). + + ``z = 0.5 * (y + ym)`` when ``averaging`` (stabilises when ``ym`` is near zero), + else ``z = ym``. + """ + basis = averaging_basis if averaging else ym_basis + return DiagonalTerm(support, basis=basis, parameter=parameter, log=log) + + +def discrepancy_term(support, kernel, jitter=1e-10, prefix="discrepancy") -> KernelTerm: + """A Gaussian-process discrepancy ``K(x, x; theta)`` over ``support``.""" + return KernelTerm(support, kernel, jitter=jitter, prefix=prefix) diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index fb61525..1d51f86 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -1,24 +1,20 @@ """ Observation class for elastic differential cross sections. -:class:`ElasticDifferentialXSObservation` wraps a ``jitr`` -:class:`jitr.xs.elastic.DifferentialWorkspace` to pre-compute boundary -conditions and Rutherford cross sections, then delegates covariance and -residual computation to a chosen :class:`~rxmc.observation.Observation` subclass. +:class:`ElasticDifferentialXSObservation` is an :class:`~rxmc.observation.Observation` +that sets up a ``jitr`` :class:`jitr.xs.elastic.DifferentialWorkspace` to pre-compute +boundary conditions and Rutherford cross sections. It carries statistical error +only; correlated systematics are composed as :class:`~rxmc.covariance.Term` s in the +:class:`~rxmc.constraint.Constraint`. """ -from typing import Type - import jitr import numpy as np from exfor_tools.distribution import Distribution from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import ( - check_angle_grid, - set_up_observation, -) +from .observation_from_measurement import check_angle_grid, normalized_error_kwargs # Create a unit registry ureg = UnitRegistry() @@ -27,16 +23,15 @@ DEFAULT_LMAX = 20 -class ElasticDifferentialXSObservation: +class ElasticDifferentialXSObservation(Observation): """ Observation for elastic differential cross sections. - This class dynamically inherits from `Observation` or any other - derived class of `Observation` based on the `ObservationClass` - parameter in the initializer. The default behavior is to inherit - from `Observation`, but users can specify a different subclass, such as - `FixedCovarianceObservation`, to precompute the covariance matrix inverse - in cases where the covariance is fixed. + This is an :class:`~rxmc.observation.Observation` (statistical error only): it + inherits ``statistical_term`` and ``num_pts_within_interval``. Any correlated + systematic — the dataset's reported normalisation/offset, or a fixed covariance + (:class:`~rxmc.covariance.DenseTerm`) — is composed explicitly as an + ``extra_terms`` entry in the :class:`~rxmc.constraint.Constraint`. It is designed to handle elastic differential cross section measurements, specifically absolute differential cross sections, @@ -66,8 +61,6 @@ def __init__( wavelengths_beyond_range=2.0, zeros_per_node=5, angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - ObservationClass: Type[Observation] = Observation, - error_kwargs: dict = None, compound_correction: np.ndarray = None, ): """ @@ -89,10 +82,15 @@ def __init__( Units of the supplied *y* values (e.g. ``"mb/sr"``). y_stat_err : np.ndarray, optional Statistical errors associated with *y*. - y_sys_err_normalization : float or array-like, optional - Systematic normalization error(s) associated with *y*. - y_sys_err_offset : float or array-like, optional - Systematic offset error(s) associated with *y*. + y_sys_err_normalization : float or np.ndarray, optional + Reported *fractional* (dimensionless) normalisation uncertainty. + Retained as inert metadata (see + :meth:`rxmc.observation.Observation.systematic_terms`); not divided + by the unit normalisation. + y_sys_err_offset : float or np.ndarray, optional + Reported *absolute* offset uncertainty in the same units as *y*. + Retained as inert metadata, converted to internal units (divided by + the unit normalisation, per-angle where applicable). dataset_label : str, optional Human-readable dataset identifier used in error messages. lmax : int, optional @@ -106,20 +104,10 @@ def __init__( angles_vis : np.ndarray, optional Angle grid in degrees for visualisation. Defaults to ``np.linspace(0.01, 180, 100)``. - ObservationClass : type, optional - :class:`~rxmc.observation.Observation` subclass to use for - covariance and residual computations. Supply - :class:`~rxmc.observation.FixedCovarianceObservation` to - pre-compute the inverse covariance. Defaults to - :class:`~rxmc.observation.Observation`. - error_kwargs : dict, optional - Extra keyword arguments forwarded to *ObservationClass*. compound_correction : np.ndarray, optional Compound-nuclear contribution to dXS/dΩ in mb/sr, added to the calculated cross section before comparing to data. """ - if not issubclass(ObservationClass, Observation): - raise ValueError("ObservationClass must be a subclass of Observation") self.reaction = reaction self.quantity = quantity self.lmax = lmax @@ -157,37 +145,19 @@ def __init__( measurement_quantity, y_units ) self.y_units = normalized_y_units + # retained for provenance / manual term recomposition; a scalar, or a + # per-angle array in the Rutherford-conversion cases + self.norm = norm - # initialize the observation instance - args, kwargs, y_stat_err = set_up_observation( - ObservationClass, - x=angles_rad_constraint, - y=y, - y_stat_err=y_stat_err, - y_sys_err_normalization=y_sys_err_normalization, - y_sys_err_offset=y_sys_err_offset, - dataset_label=dataset_label, - normalization=norm, - **error_kwargs if error_kwargs is not None else {}, + super().__init__( + angles_rad_constraint, + np.asarray(y) / norm, + label=dataset_label, + **normalized_error_kwargs( + norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset + ), ) - # Create an instance of the chosen ObservationClass - self._obs = ObservationClass(*args, **kwargs) - - self.x = self._obs.x - self.y = self._obs.y - self.y_stat_err = y_stat_err - self.n_data_pts = self._obs.n_data_pts - - def covariance(self, y): - return self._obs.covariance(y) - - def residual(self, ym): - return self._obs.residual(ym) - - def num_pts_within_interval(self, interval): - return self._obs.num_pts_within_interval(interval) - @classmethod def from_measurement( cls, @@ -198,8 +168,6 @@ def from_measurement( wavelengths_beyond_range=2.0, zeros_per_node=5, angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - ObservationClass: Type[Observation] = Observation, - error_kwargs: dict = None, compound_correction: np.ndarray = None, ): return cls( @@ -218,8 +186,6 @@ def from_measurement( wavelengths_beyond_range=wavelengths_beyond_range, zeros_per_node=zeros_per_node, angles_vis=angles_vis, - ObservationClass=ObservationClass, - error_kwargs=error_kwargs, compound_correction=compound_correction, ) @@ -249,7 +215,8 @@ def calculate_normalization( return self.constraint_workspace.rutherford * conversion_factor, y_unit elif self.quantity == "dXS/dA" and measurement_quantity == "dXS/dRuth": - conversion_factor = 1.0 / rutherford_unit.to(y_unit).magnitude + # rutherford is stored in mb/sr; convert one unit of it to b/sr + conversion_factor = 1.0 / (1 * rutherford_unit).to(y_unit).magnitude return conversion_factor / self.constraint_workspace.rutherford, y_unit elif self.quantity == "dXS/dA" and measurement_quantity == "dXS/dA": @@ -273,10 +240,10 @@ def calculate_normalization( return 1.0, y_unit else: - if self.quantity != measurement_quantity: - raise ValueError( - f"Quantity mismatch: {self.quantity} != {measurement_quantity}" - ) + raise ValueError( + f"Cannot convert measurement quantity '{measurement_quantity}' " + f"(units '{measurement_y_units}') to '{self.quantity}'" + ) def set_up_solver( diff --git a/src/rxmc/evidence.py b/src/rxmc/evidence.py index be0ae22..d315ae9 100644 --- a/src/rxmc/evidence.py +++ b/src/rxmc/evidence.py @@ -4,8 +4,10 @@ An :class:`Evidence` object collects multiple :class:`~rxmc.constraint.Constraint` objects that share the same physical-model parameters. It computes a joint log likelihood by summing the individual constraint log likelihoods (optionally -weighted), supporting both fixed and parametric likelihood models via a -Gibbs-style decomposition. +weighted). Each constraint owns its own (possibly correlated) covariance over the +stack of its observations; constraints are assumed independent of one another, so +``Evidence`` is a plain sum. Parametric constraints (those with free covariance / +likelihood parameters) are auto-detected via ``constraint.n_params > 0``. """ import numpy as np @@ -16,94 +18,59 @@ class Evidence: """A collection of independent constraints sharing a common physical model. - Each :class:`~rxmc.constraint.Constraint` represents a set of observations - paired with a likelihood model. All constraints must share the same - physical-model parameters, but may have different likelihood-model parameters. - - Optional per-constraint weights scale the contribution of each constraint to - the total log likelihood. - Parameters ---------- - constraints : list of Constraint, optional - Constraints whose likelihood models have no free parameters. - parametric_constraints : list of Constraint, optional - Constraints whose likelihood models have free parameters. + constraints : list of Constraint + All constraints. Those with ``n_params > 0`` are exposed (in order) as + :attr:`parametric_constraints`. weights : np.ndarray, optional - 1-D array of weights for *constraints*. Defaults to all ones. - weights_parametric : np.ndarray, optional - 1-D array of weights for *parametric_constraints*. Defaults to all ones. + 1-D array of per-constraint weights. Defaults to all ones. Raises ------ ValueError - If both *constraints* and *parametric_constraints* are empty. - ValueError - If any constraint uses different physical-model parameters than the first. - ValueError - If a non-parametric constraint appears in *parametric_constraints*, or - vice versa. - ValueError - If the number of data points is less than the number of free parameters - (under-constrained model). - ValueError - If *weights* or *weights_parametric* do not match the corresponding list - length. + If *constraints* is empty, if any constraint uses different + physical-model parameters than the first, if the model is + under-constrained, or if *weights* does not match the constraint count. + + Attributes + ---------- + constraints : list of Constraint + All constraints. + parametric_constraints : list of Constraint + The subset with ``n_params > 0``, in the order they appear. + parametric_indices : list of int + Global index into :attr:`constraints` for each entry of + :attr:`parametric_constraints` (e.g. to look up its :attr:`weights` + entry). """ def __init__( self, constraints: list[Constraint] | None = None, - parametric_constraints: list[Constraint] | None = None, weights: np.ndarray = None, - weights_parametric: np.ndarray = None, ): - constraints = constraints or [] - parametric_constraints = parametric_constraints or [] - - if len(constraints) > 0: - self.model_params = constraints[0].physical_model.params - elif len(parametric_constraints) > 0: - self.model_params = parametric_constraints[0].physical_model.params - else: - raise ValueError( - "Either 'constraints' or 'parametric_constraints' must not be empty" - ) + constraints = list(constraints or []) + if len(constraints) == 0: + raise ValueError("'constraints' must not be empty") self.constraints = constraints - self.parametric_constraints = parametric_constraints - self.n_likelihood_params = 0 - + self.model_params = constraints[0].physical_model.params for constraint in self.constraints: if constraint.physical_model.params != self.model_params: raise ValueError( "All constraints must use the same physical model parameters" ) - if constraint.likelihood.n_params > 0: - raise ValueError( - "Constraint with parametric likelihood model " - "found in the `constraints` list; should be " - "in the `parametric_constraints` list" - ) - for constraint in self.parametric_constraints: - if constraint.physical_model.params != self.model_params: - raise ValueError( - "All constraints must use the same physical model parameters" - ) - if constraint.likelihood.n_params == 0: - raise ValueError( - "Constraint without parametric likelihood " - "model found in the `parametric_constraints` " - "list; should be in the `constraints` list" - ) - self.n_likelihood_params += constraint.likelihood.n_params + self._validate_constraint_params() + + parametric = [(i, c) for i, c in enumerate(self.constraints) if c.n_params > 0] + self.parametric_indices = [i for i, _ in parametric] + self.parametric_constraints = [c for _, c in parametric] + self.n_likelihood_params = sum(c.n_params for c in self.parametric_constraints) self.n_params = len(self.model_params) + self.n_likelihood_params - self.n_data_pts = sum( - sum(obs.n_data_pts for obs in c.observations) - for c in constraints + parametric_constraints - ) + self.n_data_pts = sum(c.n_data_pts for c in self.constraints) self.n_dof = self.n_data_pts - self.n_params if self.n_dof < 0: raise ValueError( @@ -119,51 +86,88 @@ def __init__( ) self.weights = weights - if weights_parametric is None: - weights_parametric = np.ones( - (len(self.parametric_constraints),), dtype=float - ) - elif weights_parametric.shape != (len(self.parametric_constraints),): - raise ValueError( - "weights_parametric must be a 1D array with the same shape as parametric_constraints" - ) - self.weights_parametric = weights_parametric + def _validate_constraint_params(self): + """Reject cross-constraint parameter sharing and duplicate names. - def log_likelihood( - self, model_params, likelihood_params: list[tuple] | None = None - ): + Covariance/likelihood parameters are constraint-scoped (see + ``covariance_refactor.md`` §8): the same ``Parameter`` object in two + constraints would silently be sampled as two independent values. + Names must also be unique across the whole Evidence — they label + sampler columns, priors, and corner-plot axes. + """ + seen_id = {} # id(p) -> constraint index + seen_name = {} # p.name -> constraint index + for ci, c in enumerate(self.constraints): + for p in c.params: + if id(p) in seen_id: + raise ValueError( + f"Parameter '{p.name}' is the same object in constraints " + f"{seen_id[id(p)]} and {ci}. Covariance/likelihood " + "parameters are constraint-scoped and cannot be shared " + "across constraints. To model a systematic shared " + "between datasets, place those datasets in ONE " + "Constraint with a cross-block coupling term." + ) + seen_id[id(p)] = ci + if p.name in seen_name: + raise ValueError( + f"Duplicate parameter name '{p.name}' in constraints " + f"{seen_name[p.name]} and {ci}. Parameter names label " + "sampler columns and must be unique across the " + "Evidence; rename one (e.g. suffix it with the dataset " + "label)." + ) + seen_name[p.name] = ci + + def log_likelihood(self, model_params, cov_params: list | None = None): """Weighted sum of log likelihoods over all constraints. Parameters ---------- model_params : tuple - Parameters of the physical model. - likelihood_params : list of tuple, optional - One tuple of likelihood parameters per entry in - *parametric_constraints*. Defaults to an empty list. + Physical-model parameters. + cov_params : list of tuple, optional + One tuple of constraint parameters per entry in + :attr:`parametric_constraints` (in that order). Defaults to ``[]``. Returns ------- float Total weighted log likelihood. """ - likelihood_params = likelihood_params or [] - if len(likelihood_params) != len(self.parametric_constraints): + cov_params = cov_params or [] + if len(cov_params) != len(self.parametric_constraints): raise ValueError( - f"Expected {len(self.parametric_constraints)} likelihood parameter " - f"tuples, got {len(likelihood_params)}" + f"Expected {len(self.parametric_constraints)} constraint parameter " + f"tuples, got {len(cov_params)}" ) - ll = sum( - c.log_likelihood(model_params) * w - for w, c in zip(self.weights, self.constraints) - ) - ll += sum( - c.log_likelihood(model_params, lp) * w - for w, c, lp in zip( - self.weights_parametric, - self.parametric_constraints, - likelihood_params, - ) - ) + ll = 0.0 + pidx = 0 + for w, c in zip(self.weights, self.constraints): + cp = () + if c.n_params > 0: + cp = cov_params[pidx] + pidx += 1 + ll += c.log_likelihood(model_params, cp) * w return ll + + def weighted_marginal_log_likelihood(self, lm_index, ym, *cov_params): + """Weighted marginal log likelihood of one parametric constraint. + + Applies the same :attr:`weights` entry that :meth:`log_likelihood` + uses for this constraint, so Gibbs-style conditional updates target + the same joint distribution as the model block. + + Parameters + ---------- + lm_index : int + Index into :attr:`parametric_constraints`. + ym : list of np.ndarray + One prediction array per observation of that constraint. + *cov_params : float + The constraint's parameters, in its ``params`` order. + """ + w = self.weights[self.parametric_indices[lm_index]] + c = self.parametric_constraints[lm_index] + return w * c.marginal_log_likelihood(ym, *cov_params) diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py index c87f245..b37e8df 100644 --- a/src/rxmc/ias_pn_observation.py +++ b/src/rxmc/ias_pn_observation.py @@ -1,12 +1,10 @@ -from typing import Type - import jitr import numpy as np from exfor_tools.distribution import Distribution from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import check_angle_grid, set_up_observation +from .observation_from_measurement import check_angle_grid, normalized_error_kwargs # Create a unit registry ureg = UnitRegistry() @@ -14,16 +12,14 @@ DEFAULT_LMAX = 20 -class IsobaricAnalogPNObservation: +class IsobaricAnalogPNObservation(Observation): """ Observation for (p,n) isobaric analog state (IAS) reactions. - This class dynamically inherits from `Observation` or any other - derived class of `Observation` based on the `ObservationClass` - parameter in the initializer. The default behavior is to inherit - from `Observation`, but users can specify a different subclass, such as - `FixedCovarianceObservation`, to precompute the covariance matrix inverse - in cases where the covariance is fixed. + This is an :class:`~rxmc.observation.Observation` (statistical error only): it + inherits ``statistical_term`` and ``num_pts_within_interval``. Any correlated + systematic is composed explicitly as an ``extra_terms`` entry in the + :class:`~rxmc.constraint.Constraint`. It is designed to handle (p,n) IAS reaction measurements in differential cross section form. @@ -47,8 +43,6 @@ def __init__( dataset_label: str | None = None, lmax: int = DEFAULT_LMAX, angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - ObservationClass: Type[Observation] = Observation, - error_kwargs: dict = None, wavelengths_beyond_range: float = 2.0, zeros_per_node: int = 5, ): @@ -71,31 +65,26 @@ def __init__( Units of the supplied `y` values. y_stat_err : np.ndarray, optional Statistical errors associated with `y`. - y_sys_err_normalization : float or array-like, optional - Systematic normalization error(s) associated with `y`. - y_sys_err_offset : float or array-like, optional - Systematic offset error(s) associated with `y`. + y_sys_err_normalization : float or np.ndarray, optional + Reported *fractional* (dimensionless) normalisation uncertainty. + Retained as inert metadata (see + :meth:`rxmc.observation.Observation.systematic_terms`); not divided + by the unit normalisation. + y_sys_err_offset : float or np.ndarray, optional + Reported *absolute* offset uncertainty in the same units as `y`. + Retained as inert metadata, converted to internal units (divided by + the unit normalisation). dataset_label : str, optional Human-readable dataset identifier used in error messages. lmax: int Maximum angular momentum angles_vis: np.ndarray Array of angles in degrees for visualization. - ObservationClass: Type[Observation] - The base class Type that this instance will inherit from; - must be a subclass of `Observation`. Defaults to the base - class `Observation`, but the user can supply any other subclass. - For example, if one wants the covariance to be precomputed one - can supply `FixedCovarianceObservation` instead here. - error_kwargs: dict - Additional keyword arguments for error handling. wavelengths_beyond_range: float Number of wavelengths beyond the interaction range to set the channel radius. zeros_per_node: int Number of zeros of the basis functions per node in the R-matrix solver. """ - if not issubclass(ObservationClass, Observation): - raise ValueError("ObservationClass must be a subclass of Observation") self.reaction = reaction self.lmax = lmax self.subentry = dataset_label @@ -135,37 +124,18 @@ class `Observation`, but the user can supply any other subclass. ) norm = 1.0 / measurement_unit.to(self.y_units).magnitude + # retained for provenance / manual term recomposition + self.norm = norm - # initialize the observation instance - args, kwargs, y_stat_err = set_up_observation( - ObservationClass, - x=angles_rad_constraint, - y=y, - y_stat_err=y_stat_err, - y_sys_err_normalization=y_sys_err_normalization, - y_sys_err_offset=y_sys_err_offset, - dataset_label=dataset_label, - normalization=norm, - **error_kwargs if error_kwargs is not None else {}, + super().__init__( + angles_rad_constraint, + np.asarray(y) / norm, + label=dataset_label, + **normalized_error_kwargs( + norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset + ), ) - # Create an instance of the chosen ObservationClass - self._obs = ObservationClass(*args, **kwargs) - - self.x = self._obs.x - self.y = self._obs.y - self.y_stat_err = y_stat_err - self.n_data_pts = self._obs.n_data_pts - - def covariance(self, y): - return self._obs.covariance(y) - - def residual(self, ym): - return self._obs.residual(ym) - - def num_pts_within_interval(self, interval): - return self._obs.num_pts_within_interval(interval) - @classmethod def from_measurement( cls, @@ -174,8 +144,6 @@ def from_measurement( ExIAS: float, lmax: int = DEFAULT_LMAX, angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - ObservationClass: Type[Observation] = Observation, - error_kwargs: dict = None, wavelengths_beyond_range: float = 2.0, zeros_per_node: int = 5, ): @@ -192,8 +160,6 @@ def from_measurement( dataset_label=getattr(measurement, "subentry", None), lmax=lmax, angles_vis=angles_vis, - ObservationClass=ObservationClass, - error_kwargs=error_kwargs, wavelengths_beyond_range=wavelengths_beyond_range, zeros_per_node=zeros_per_node, ) diff --git a/src/rxmc/likelihood_model.py b/src/rxmc/likelihood_model.py index 6344e13..a819cf5 100644 --- a/src/rxmc/likelihood_model.py +++ b/src/rxmc/likelihood_model.py @@ -1,894 +1,114 @@ """ -Likelihood models for comparing physical-model predictions to observations. +Likelihoods over the stacked residual of a :class:`~rxmc.constraint.Constraint`. -All classes derive from :class:`LikelihoodModel`. The base class uses a -covariance matrix built from the observation's statistical and systematic errors. -Subclasses extend this with unknown noise, normalization, model-error, and -Student-t variants. Parametric likelihood models expose free parameters that -can be sampled alongside the physical-model parameters. +A constraint owns one multivariate distribution over the stacked vector of all its +observations; its covariance is a :class:`~rxmc.covariance.ConstraintCovariance` +assembled from :class:`~rxmc.covariance.Term` s. A *likelihood* here is a thin +functional of the pre-computed Mahalanobis statistics ``(d2, logdet, n)`` plus its +own optional parameters: + +* :class:`GaussianLikelihood` — the multivariate normal (parameter-free). +* :class:`StudentT` — a heavy-tailed variant carrying a degrees-of-freedom + parameter ``nu``. +* :class:`Chi2` — drops the log-determinant normalisation (pure chi-squared). + +All covariance parameters live on the :class:`~rxmc.covariance.ConstraintCovariance`; +the only likelihood-side parameter is ``StudentT``'s ``nu``. The ``(d2, logdet)`` +statistics themselves are computed by +:meth:`~rxmc.covariance.ConstraintCovariance.stacked_distance`. Helper functions ---------------- :func:`mahalanobis_distance_sqr_cholesky` Squared Mahalanobis distance and log-determinant via Cholesky decomposition. :func:`log_likelihood` - Multivariate-normal log likelihood from pre-computed distance and - log-determinant. -:func:`statistical_covariance` - Diagonal covariance matrix from a vector of statistical errors. -:func:`uncorrelated_model_covariance` - Diagonal model-error covariance scaled by a fractional error. + Multivariate-normal log likelihood from pre-computed distance and log-det. """ import numpy as np import scipy as sc +from scipy.special import gammaln -from .observation import FixedCovarianceObservation, Observation +from .covariance import chol_logdet from .params import Parameter - -class LikelihoodModel: - r""" - A class to represent a likelihood model for comparing an Observation - to a PhysicalModel. - - The default behavior uses the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where $sigma^2_{i}^{stat}$ is the statistical variance of the i-th - observation, (`observation.statistical_covariance`) and $\gamma$ is the - fractional uncorrelated error (`self.frac_err`). - - Here, $Sigma_{ij}^{sys}$ is the systematic covariance matrix: - - .. math:: - - \Sigma_{ij}^{sys} = \eta**2 y_m(x_i, \alpha) y_m(x_j, \alpha) + \omega, - - where $\eta$ is the uncertainty in the overall normalization of the - observation (`observation.y_sys_err_normalization`) and $\omega$ is the - uncertainty in the additive normalization to the observation - (`observation.y_sys_err_offset`). - - Here, also, $y_m(x_i, \alpha)$ is the model prediction for the i-th - observation. Thus the covariance matrix is dependent on the values - of the PhysicalModel and its parameters, as is the case when systematic - errors are present in the observation, following D'Agostini, G. (1993) 'On - the use of the covariance matrix to fit correlated data' - - Note that if there is no systematic uncertainty encoded in the `observation` - and `self.frac_err` takes the default value of 0, the - covariance matrix becomes diaginal, and the `chi2` function reduces to the - simple and familiar $\chi^2$ form. - - Note also that this is equivalent to the alternative method to handle systematic - errors described by Barlow, R (2021) 'Combining experiments with systematic - errors', in which nuisance parameters are introduced corresponding to the - normalization and additive offset bias of the observation. - - The advantage of this approach is that it does not require introducing - nuisance parameters, but instead encodes the correlation between the data - points in the observation in the covariance matrix directly. - """ - - def __init__(self): - r""" - Initializes the LikelihoodModel, optionally with a fractional - uncorrelated error. - - """ - self.params = None - self.n_params = 0 - - def covariance(self, observation: Observation, ym: np.ndarray): - r""" - Default covariance model. Derived classes of `LikelihoodModel` will - override this. - - Returns the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where $sigma^2_{i}^{stat}$ is the statistical variance of the i-th - observation, (`observation.statistical_covariance`) and $\gamma$ is the - fractional uncorrelated error (`self.frac_err`). - - Here, $Sigma_{ij}^{sys}$ is the systematic covariance matrix: - - .. math:: - - \Sigma_{ij}^{sys} = \eta**2 y_m(x_i, \alpha) y_m(x_j, \alpha) + \omega, - - where $\eta$ is the uncertainty in the overall normalization of the - observation (`observation.y_sys_err_normalization`) and $\omega$ is the - uncertainty in the additive normalization to the observation - (`observation.y_sys_err_offset`). - - Here, also, $y_m(x_i, \alpha)$ is the model prediction for the i-th - observation. - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - return observation.covariance(ym) - - def residual(self, observation: Observation, ym: np.ndarray): - r"""Return the residual ``observation.y - ym``. - - Parameters - ---------- - observation : Observation - Observation containing the measured data. - ym : np.ndarray - Model prediction for the observation. - - Returns - ------- - np.ndarray - Residual vector. - """ - return observation.residual(ym) - - def chi2(self, observation: Observation, ym: np.ndarray): - r""" - Calculate the generalised chi-squared statistic. This is the - square of the Mahalanobis distance between y and ym - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - - Returns - ------- - float - Chi-squared statistic. - """ - cov = self.covariance(observation, ym) - mahalanobis_sqr, _ = mahalanobis_distance_sqr_cholesky(observation.y, ym, cov) - return mahalanobis_sqr - - def log_likelihood(self, observation: Observation, ym: np.ndarray): - r""" - Returns the log_likelihood that ym reproduces y, given the covariance - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - - Returns - ------- - float - """ - cov = self.covariance(observation, ym) - mahalanobis_sqr, log_det = mahalanobis_distance_sqr_cholesky( - observation.y, ym, cov - ) - return log_likelihood(mahalanobis_sqr, log_det, observation.n_data_pts) - - -class FixedCovarianceLikelihood(LikelihoodModel): - r""" - A special LikelihoodModel to handle FixedCovarianceObservation objects, - where the covariance matrix is fixed and does not depend on the - parameters of the PhysicalModel. - - This allows for the use of precomputed inverse covariance matrices which - can speed up the calculation of the chi-squared statistic and log_likelihood. - """ - - def __init__(self): - super().__init__() - - def covariance(self, observation: FixedCovarianceObservation, ym: np.ndarray): - r""" - Returns the fixed covariance matrix in `observation` - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : FixedCovarianceObservation - The observation object containing the observed data, which has - attribute `covariance`. - - Returns - ------- - np.ndarray - Fixed covariance matrix. - """ - return observation.cov - - def chi2(self, observation: FixedCovarianceObservation, ym: np.ndarray): - r""" - Calculate the generalised chi-squared statistic. This is the - Mahalanobis distance between y and ym - - Parameters - ---------- - params : OrderedDict - parameters of model - observation : FixedCovarianceObservation - The observation object containing the observed data, which has - attribute `cov_inv`. - - Returns - ------- - float - Chi-squared statistic. - """ - # we overload this method to use precomputed inverse - # covariance matrix - delta = observation.residual(ym) - return delta.T @ observation.cov_inv @ delta - - def log_likelihood(self, observation: FixedCovarianceObservation, ym: np.ndarray): - r""" - Returns the log_likelihood that ym reproduces y, given the fixed - covariance matrix - - Parameters - ---------- - params : OrderedDict - parameters of model - observation : FixedCovarianceObservation - The observation object containing the observed data, which has - attributes `cov_inv`, `n_data_pts` and `log_det`. - - Returns - ------- - float - """ - # we overload this method to use precomputed inverse - # covariance matrix - mahalanobis_sqr = self.chi2(observation, ym) - return log_likelihood( - mahalanobis_sqr, observation.log_det, observation.n_data_pts - ) +__all__ = [ + "Likelihood", + "GaussianLikelihood", + "StudentT", + "Chi2", + "mahalanobis_distance_sqr_cholesky", + "log_likelihood", +] -class Chi2LikelihoodModel(LikelihoodModel): - r""" - A `LikelihoodModel` that returns the negative half of the chi-squared - statistic for the log likelihood, ignoring the log determinant term. - This is useful for doing chi2 minimization without computing the full - log likelihood. - """ +class Likelihood: + """A functional of the pre-computed Mahalanobis statistics ``(d2, logdet, n)``. - def __init__(self): - super().__init__() - - def log_likelihood(self, observation: Observation, ym: np.ndarray): - r""" - Returns -1/2 Chi2 only, ignoring the log determinant term. - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - - Returns - ------- - float - """ - chi2 = self.chi2(observation, ym) - return -0.5 * chi2 - - -class ParametricLikelihoodModel(LikelihoodModel): - r""" - A class to represent a likelihood model for comparing an `Observation` - to a `PhysicalModel`, in which the `LikelihoodModel` has it's own parameters - to calculate the covariance, aside from the parameters of the - `PhysicalModel`. This is useful when the covariance is unknown, and one - would like to calibrate the likelihood parameters to an `Observation`, - along with the parameters of a `PhysicalModel`. + Subclasses implement :meth:`log_likelihood` and declare any parameters via + ``params``/``n_params``. The chi-squared statistic is + likelihood-independent (always the Mahalanobis distance). """ - def __init__(self, likelihood_params: list[Parameter]): - super().__init__() - self.params = likelihood_params - self.n_params = len(likelihood_params) - - def chi2(self, observation: Observation, ym: np.ndarray, *likelihood_params): - r""" - Calculate the generalised chi-squared statistic. This is the - Mahalanobis distance between `Observation.y` and `ym`. - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - likelihood_params : tuple - Additional parameters for the covariance - - Returns - ------- - float - Chi-squared statistic. - """ - if len(likelihood_params) != self.n_params: - raise ValueError( - f"Expected {self.n_params} likelihood parameters, got {len(likelihood_params)}" - ) - cov = self.covariance(observation, ym, *likelihood_params) - mahalanobis_sqr, _ = mahalanobis_distance_sqr_cholesky(observation.y, ym, cov) - return mahalanobis_sqr - - def log_likelihood( - self, observation: Observation, ym: np.ndarray, *likelihood_params - ): - r""" - Returns the log likelihood that `ym` reproduces `observation.y` - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - likelihood_params: tuple - Additional parameters for the covariance - - Returns - ------- - float - """ - if len(likelihood_params) != self.n_params: - raise ValueError( - f"Expected {self.n_params} likelihood parameters, got {len(likelihood_params)}" - ) - cov = self.covariance(observation, ym, *likelihood_params) - mahalanobis_sqr, log_det = mahalanobis_distance_sqr_cholesky( - observation.y, ym, cov - ) - return log_likelihood(mahalanobis_sqr, log_det, observation.n_data_pts) - - def covariance(self, observation: Observation, ym: np.ndarray, *likelihood_params): - r""" - Returns the covariance matrix determined by the likelihood model, - which is dependent on `likelihood_params` - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - likelihood_params : tuple - Additional parameters for the covariance. - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - raise NotImplementedError( - "This method should be implemented in subclasses to return the " - "covariance matrix." - ) - + params: tuple = () + n_params: int = 0 -class UnknownNoiseErrorModel(ParametricLikelihoodModel): - r""" - A ParametricLikelihoodModel in which each data point in the observation - has the same, unknown, statistical error, which is a parameter, $epsilon$. + def log_likelihood(self, d2, logdet, n, *like_params): + raise NotImplementedError - No matter the Observation, the statistical contribution to the covariance - thus always takes the form: + def chi2(self, d2, logdet, n, *like_params): + return d2 - .. math:: - \Sigma_{ij}^{stat} = \epsilon^2 \delta_{ij} +class GaussianLikelihood(Likelihood): + """Multivariate-normal likelihood over the stacked residual. - where $\epsilon$ is the statistical `noise` parameter. + Parameter-free — all uncertainty lives on the covariance terms. """ - def __init__(self): - r""" - Initializes the UnknownNoiseErrorModel, optionally with - a fractional uncorrelated error. - """ - likelihood_params = [ - Parameter("log noise", float, latex_name=r"\log{\epsilon}"), - ] - super().__init__(likelihood_params) - - def covariance(self, observation: Observation, ym: np.ndarray, log_epsilon: float): - r""" - Returns the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where sigma^2_{i}^{stat} is the statistical variance of the i-th - observation, which is dependent on the parameter $\epsilon$, which - is the statistical `noise`: - - .. math:: - - \sigma^2_{i}^{stat} = \epsilon^2 \delta_{ij} - - (note this class ignores `observation.statistical_covariance`, - replacing it with $\epsilon$). - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - log_epsilon : float - natural log of the statistical noise, $\epsilon$ - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - sigma_sys = ( - observation.systematic_offset_covariance - + observation.systematic_normalization_covariance * np.outer(ym, ym) - ) - sigma_stat = statistical_covariance(np.ones_like(ym) * np.exp(log_epsilon)) - cov = sigma_sys + sigma_stat - return cov - + def log_likelihood(self, d2, logdet, n, *like_params): + return log_likelihood(d2, logdet, n) -class UnknownNoiseFractionErrorModel(ParametricLikelihoodModel): - r""" - A `ParametricLikelihoodModel` in which each data point in the observation - has the a statistical error corresponding to a fixed fraction of it's value, - the fraction being a parameter, $epsilon$. - This implies the statistical contribution to the covariance takes the form: +class StudentT(Likelihood): + r"""Multivariate Student-t likelihood with a degrees-of-freedom parameter. .. math:: - \Sigma_{ij}^{stat} = \epsilon^2 y(x_i)^2 \delta_{ij} - - - """ - - def __init__(self): - likelihood_params = [ - Parameter( - "log noise fraction", - float, - latex_name=r"\log{\epsilon}", - unit="dimensionless", - ) - ] - super().__init__(likelihood_params) - - def covariance(self, observation: Observation, ym: np.ndarray, log_epsilon: float): - r""" - Returns the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where sigma^2_{i}^{stat} is the statistical variance of the i-th - observation, which is dependent on the parameter $\epsilon$, which - is the statistical `noise_fraction`: - - .. math:: - - \Sigma_{ij}^{stat} = \epsilon^2 y(x_i)^2 \delta_{ij} - - (note this class ignores `observation.statistical_covariance`, substituting it with - the variable `noise_fraction` multiplied by `ym`) and $\gamma$ is the - fractional uncorrelated error (`self.frac_err`). - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - log_epsilon : float - natural log of statistical noise as a fraction of `observation.y` - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - sigma_sys = ( - observation.systematic_offset_covariance - + observation.systematic_normalization_covariance * np.outer(ym, ym) - ) - sigma_stat = statistical_covariance(ym * np.exp(log_epsilon)) - cov = sigma_sys + sigma_stat - return cov - - -class UnknownNormalizationModel(ParametricLikelihoodModel): - r""" - A `ParametricLikelihoodModel` in which the (log of the) - multiplicative factor of the model output is a free parameter. In - this case, the covariance does not include systematic errors due to - the normalization, as the data are explicitly re-normalized. - - This corresponds to a statistical model: - - .. math:: - - y_i + \epsilon_i = \rho y_m(x_i, \alpha) + \epsilon_i + \dots - - where $\rho$ is a free parameter corresponding to the multiplicative - normalization factor. This corresponds to the Kennedy & O'Hagan - (2001) treatment of normalization of model output in in 'Bayesian - calibration of computer models'. Here the normalization is not - associated with the data, but is a latent parameter which scales the - model output to best fit the data. - - This should not be confused with `UnknownDataNormalizationModel`, in - which the normalization of the data is a free parameter. - - In fact, the confusion between them is related to Peelle's Pertinent - Puzzle, or D'Agostin bias. + \log p = \ln\Gamma\!\Big(\tfrac{n+\nu}{2}\Big) - \ln\Gamma\!\Big(\tfrac{\nu}{2}\Big) + - \tfrac{n}{2}\ln(\pi\nu) - \tfrac12 \ln\det\Sigma + - \tfrac{\nu+n}{2}\,\ln\!\Big(1 + \tfrac{d^2}{\nu}\Big) """ - def __init__(self): - likelihood_params = [ - Parameter( - "log normalization", - float, - latex_name=r"\log{\rho}", - unit="dimensionless", - ), - ] - super().__init__(likelihood_params) - - def covariance(self, observation: Observation, ym: np.ndarray, log_rho: float): - r""" - Returns the statistical covariance matrix: - - .. math:: - - \Sigma_{ij}^{stat} = \sigma^2_{i}^{stat} \delta_{ij} - - where $\sigma^2_{i}^{stat}$ is the statistical variance of the i-th - observation, (`observation.statistical_covariance`). - - When the normalization is a free parameter, the systematic - normalization contribution to the covariance is not included, - as the data are explicitly re-normalized. - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation - log_rho : float - natural log of the multiplicative normalization factor. - """ - return observation.statistical_covariance - - def residual(self, observation: Observation, ym: np.ndarray, log_rho: float): - r""" - Returns the residual between the renormalized model prediction ym and - observation.y - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - log_rho : float - natural log of the multiplicative normalization factor. - - Returns - ------- - np.ndarray - Residual vector. - """ - return observation.y - ym * np.exp(log_rho) - - def chi2(self, observation: Observation, ym: np.ndarray, log_rho: float): - r""" - Calculate the generalised chi-squared statistic. This is the - square of the Mahalanobis distance between y and ym - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - log_rho : float - natural log of the multiplicative normalization factor. - - Returns - ------- - float - Chi-squared statistic. - """ - y_renorm = ym * np.exp(log_rho) - cov = self.covariance(observation, ym, log_rho) - mahalanobis_sqr, _ = mahalanobis_distance_sqr_cholesky( - observation.y, y_renorm, cov - ) - return mahalanobis_sqr - - def log_likelihood(self, observation: Observation, ym: np.ndarray, log_rho: float): - r""" - Returns the log_likelihood that ym reproduces y, given the covariance - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - log_rho : float - natural log of the multiplicative normalization factor. - - Returns - ------- - float - """ - y_renorm = ym * np.exp(log_rho) - cov = self.covariance(observation, ym, log_rho) - mahalanobis_sqr, log_det = mahalanobis_distance_sqr_cholesky( - observation.y, y_renorm, cov + def __init__(self, nu_parameter: Parameter = None): + self.nu_parameter = ( + nu_parameter + if nu_parameter is not None + else Parameter("degrees_of_freedom", float, latex_name=r"\nu") ) - return log_likelihood(mahalanobis_sqr, log_det, observation.n_data_pts) - - -class UnknownNormalizationErrorModel(ParametricLikelihoodModel): - r""" - A ParametricLikelihoodModel in which the systematic uncertainty - of the normalization of the observation is a parameter, $\eta$. - - This implies the systematic normalization contribution to the - covariance takes the form: - - .. math:: - - \Sigma_{ij}^{sys norm} = \eta**2 y_m(x_i, \alpha) y_m(x_j, \alpha) - - where $\eta$ is a free parameter. - """ - - def __init__(self): - likelihood_params = [ - Parameter( - "log normalization error", - float, - latex_name=r"\log{\eta}", - unit="dimensionless", - ) - ] - super().__init__(likelihood_params) - - def covariance(self, observation: Observation, ym: np.ndarray, log_eta: float): - r""" - Returns the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where $sigma^2_{i}^{stat}$ is the statistical variance of the i-th - observation, (`observation.statistical_covariance`) and $\gamma$ is the - fractional uncorrelated error (`self.frac_err`). - - Here, $Sigma_{ij}^{sys}$ is the systematic covariance matrix: - - .. math:: - - \Sigma_{ij}^{sys} = \eta**2 y_m(x_i, \alpha) y_m(x_j, \alpha) + \omega, - - where $\eta$ is the uncertainty in the overall normalization of the - observation (`y_sys_err_normalization` - in this case, this value is a parameter, - and corresponding value in `observation` is ignored) and $\omega$ is - the uncertainty in the additive normalization to the observation - (`observation.y_sys_err_offset`). - - Here, also, $y_m(x_i, \alpha)$ is the model prediction for the i-th - observation. - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - log_eta: float - natual log of the uncertainty in the overall normalization - of the observation. - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - sigma_sys = observation.systematic_offset_covariance + np.exp( - log_eta - ) ** 2 * np.outer(ym, ym) - sigma_stat = observation.statistical_covariance - cov = sigma_sys + sigma_stat - return cov - - -class UnknownModelError(ParametricLikelihoodModel): - r""" - A `ParametricLikelihoodModel` in which the `frac_err` - is a free parameter $\gamma$, such that the covariance due to the - uncorrelated model error takes the form: + self.params = (self.nu_parameter,) + self.n_params = 1 - .. math:: - - \Sigma_{ij}^{uncorrelated} = \gamma^2 y_m(x_i, \alpha)^2 \delta_{ij} - - where $\gamma$ is a free parameter. - - This is commonly used as a model-error term or unquantified uncertainty. - """ - - def __init__(self, averaging=True): - """ - Initializes the UnknownModelError instance. - - Parameters - ---------- - averaging : bool, optional - If ``True``, the model error term uses ``0.5 * (observation.y + ym)`` - instead of ``ym`` alone, which improves stability when ``ym`` is - near zero. Defaults to ``True``. - """ - likelihood_params = [ - Parameter( - "log fractional err", float, latex_name=r"\gamma", unit="dimensionless" - ) - ] - super().__init__(likelihood_params) - self.averaging = averaging - - def covariance( - self, - observation: Observation, - ym: np.ndarray, - log_frac_err: float, - ): - r""" - Default covariance model. Derived classes of `LikelihoodModel` will - override this. - - Returns the following covariance matrix: - - .. math:: - - \Sigma_{ij} = \sigma^2_{i}^{stat} \delta_{ij} - + \Sigma_{ij}^{sys} - + \gamma^2 y_m^2(x_i, \alpha) - - where $\gamma$ is the fractional uncorrelated error - (`frac_err`), treated here as a free parameter, and - all other definitions are the same as `LikelihoodModel.covariance` - - - Parameters - ---------- - ym : np.ndarray - Model prediction for the observation. - observation : Observation - The observation object containing the observed data. - log_frac_err: float - log of fraction of the model prediction at point x_i that - is treated as the standard deviation of the model prediction - at that point, such that the model prediction is independent - at every point (log of $\gamma$). - - Returns - ------- - np.ndarray - Covariance matrix of the observation. - """ - sigma = observation.covariance(ym) - sigma_model = uncorrelated_model_covariance( - np.exp(log_frac_err), - ym if not self.averaging else 0.5 * (observation.y + ym), + def log_likelihood(self, d2, logdet, n, nu): + return ( + gammaln((n + nu) / 2.0) + - gammaln(nu / 2.0) + - 0.5 * n * np.log(np.pi * nu) + - 0.5 * logdet + - 0.5 * (nu + n) * np.log1p(d2 / nu) ) - cov = sigma + sigma_model - return cov -class StudentTLikelihoodModel(ParametricLikelihoodModel): - r""" - A `LikelihoodModel` that uses a Student's t-distribution for the likelihood. - This is useful when the data has heavy tails or outliers, as it is more robust - to deviations from normality compared to the Gaussian likelihood. - """ +class Chi2(Likelihood): + """Generalised chi-squared functional — drops the log-det normalisation.""" - def __init__(self): - r""" - Initializes the StudentTLikelihoodModel with a specified degrees of freedom. - """ - likelihood_params = [ - Parameter("degrees_of_freedom", float, latex_name=r"\nu"), - ] - super().__init__(likelihood_params) - - def log_likelihood(self, observation: Observation, ym: np.ndarray, nu: float): - r""" - Calculate the log likelihood using the Student's t-distribution. - - Parameters - ---------- - observation : Observation - The observation object containing the observed data. - ym : np.ndarray - Model prediction for the observation. - nu : float - Degrees of freedom for the Student's t-distribution. - - Returns - ------- - float - Log likelihood value. - """ - cov = self.covariance(observation, ym) - mahalanobis_sqr, log_det = mahalanobis_distance_sqr_cholesky( - observation.y, ym, cov - ) - - # Log likelihood for Student's t-distribution - n = observation.n_data_pts - return ( - sc.special.gammaln((n + nu) / 2) - - sc.special.gammaln(nu / 2) - - 0.5 * n * np.log(np.pi * nu) - - 0.5 * log_det - - (nu + n) / 2 * np.log(1 + mahalanobis_sqr / nu) - ) + def log_likelihood(self, d2, logdet, n, *like_params): + return -0.5 * d2 -def scale_covariance( - cov: np.ndarray, observation: Observation, scale: float, divide_by_N: bool -) -> np.ndarray: - if divide_by_N: - scale /= observation.n_data_pts - return scale * cov +# ---------------------------------------------------------------------------- +# Math helpers +# ---------------------------------------------------------------------------- def mahalanobis_distance_sqr_cholesky(y, ym, cov): @@ -910,12 +130,9 @@ def mahalanobis_distance_sqr_cholesky(y, ym, cov): log_det : float $\log \det \Sigma$. """ - L = sc.linalg.cholesky(cov, lower=True) - z = sc.linalg.solve_triangular(L, y - ym, lower=True) - mahalanobis_sqr = np.dot(z, z) - log_det = 2 * np.sum(np.log(np.diag(L))) - - return mahalanobis_sqr, log_det + L, log_det = chol_logdet(np.asarray(cov, dtype=float)) + z = sc.linalg.solve_triangular(L, np.asarray(y) - np.asarray(ym), lower=True) + return np.dot(z, z), log_det def log_likelihood(mahalanobis_sqr: float, log_det: float, n: int): @@ -936,55 +153,3 @@ def log_likelihood(mahalanobis_sqr: float, log_det: float, n: int): Log likelihood value. """ return -0.5 * (mahalanobis_sqr + log_det + n * np.log(2 * np.pi)) - - -def statistical_covariance(y_stat_err: np.ndarray): - r""" - Returns the statistical covariance matrix: - \[ - \Sigma_{ij}^{stat} = \sigma^2_{i}^{stat} \delta_{ij} - \] - where $\sigma^2_{i}^{stat}$ is the statistical variance of the i-th - observation (`observation.statistical_covariance`). - - Parameters - ---------- - y_stat_err : np.ndarray - Statistical errors for the observation. - - Returns - ------- - np.ndarray - Statistical covariance matrix. - """ - return np.diag(y_stat_err**2) - - -def uncorrelated_model_covariance(frac_err: float, ym: np.ndarray): - r""" - Returns the uncorrelated model covariance matrix: - \[ - \Sigma_{ij}^{uncorrelated} = \gamma^2 y_m(x_i, \alpha)^2 \delta_{ij} - \] - where $\gamma$ is the fractional uncorrelated error. - - This is commonly used as a model-error term or unquantified uncertainty - term. E.g. if one expects the model to be correct to 1% in any given data - point, then this should be set to 0.01. - - It should be noted that this assumption ignores correlations between data - points in the model. - - Parameters - ---------- - frac_err : float - Fractional uncorrelated error in the model prediction. - ym : np.ndarray - Model prediction for the observation. - - Returns - ------- - np.ndarray - Uncorrelated model error covariance matrix. - """ - return frac_err**2 * np.diag(ym**2) diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index eb49756..8d98be4 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -1,31 +1,78 @@ -from collections.abc import Iterable +""" +Observation: a leaf of experimental data. + +An :class:`Observation` is *pure data* — an independent variable ``x``, a +dependent variable ``y``, and the statistical error ``y_stat_err`` on ``y``. It +emits **only** its statistical diagonal, via :meth:`Observation.statistical_term`. + +Every *correlated* mode — a dataset's own normalisation/offset systematic, an +unknown-noise term, a cross-dataset coupling — is an **explicit** +:class:`~rxmc.covariance.Term` added at constraint-assembly time (see +:mod:`rxmc.covariance`). Nothing correlated is hidden in a default. This is a +deliberate change from the old behaviour, which folded normalisation/offset into +``Observation.covariance`` silently; there is no compatibility path that +re-folds them. + +An observation may still *carry* its reported systematic magnitudes +(``y_sys_err_normalization``, ``y_sys_err_offset``) as **inert metadata** — +provenance from the measurement. :meth:`Observation.systematic_terms` turns them +into fixed-magnitude rank-one terms, but only when the caller asks: pass its +result via ``Constraint(extra_terms=...)``. +""" import numpy as np +from .covariance import DenseTerm, normalization_term, offset_term, statistical_term + + +def _store_error_spec(value, n, name): + """Validate/normalize a systematic-error spec: None, scalar, or shape (n,).""" + if value is None: + return None + if np.ndim(value) == 0: + return float(value) + v = np.asarray(value, dtype=float) + if v.shape != (n,): + raise ValueError( + f"{name} must be a scalar or have shape ({n},), got shape {v.shape}" + ) + return v + class Observation: - """ - A class to represent an observation with statistical errors, - as well as systematic errors associated with a common normalization - and offset of all or some of the data points of the the dependent - variable y. + """Experimental data: ``x``, ``y``, and the statistical error on ``y``. - Attributes + Parameters ---------- x : np.ndarray - The independent variable data. + Independent-variable data. y : np.ndarray - The dependent variable data. - statistical_covariance : np.ndarray - The covariance matrix representing the statistical errors of y. - systematic_offset_covariance : np.ndarray - The covariance matrix representing systematic errors associated with - the offset of y. - systematic_normalization_covariance : np.ndarray - The fractional covariance matrix representing systematic errors - associated with the normalization of y. + Dependent-variable data, same shape as ``x``. + y_stat_err : np.ndarray, optional + Statistical (uncorrelated) error on ``y``. Defaults to zeros. + y_sys_err_normalization : float or np.ndarray, optional + Reported *fractional* (dimensionless) normalisation uncertainty — + inert metadata; see :meth:`systematic_terms`. + y_sys_err_offset : float or np.ndarray, optional + Reported *absolute* offset uncertainty, in the same units as ``y`` — + inert metadata; see :meth:`systematic_terms`. + label : str, optional + Human-readable dataset identifier used in error messages. + + Attributes + ---------- + x, y : np.ndarray + The data. + y_stat_err : np.ndarray + Statistical error on ``y`` (raw, not squared). + y_sys_err_normalization : float or np.ndarray or None + Fractional normalisation uncertainty (dimensionless). + y_sys_err_offset : float or np.ndarray or None + Absolute offset uncertainty (units of ``y``). + label : str or None + Human-readable dataset identifier. n_data_pts : int - The number of data points in the observation. + Number of data points. """ def __init__( @@ -34,140 +81,82 @@ def __init__( y: np.ndarray, y_stat_err=None, y_sys_err_normalization=None, - y_sys_err_normalization_mask=None, y_sys_err_offset=None, - y_sys_err_offset_mask=None, + label=None, ): - r""" - x : np.ndarray - The independent variable data. - y : np.ndarray - The dependent variable data. - y_stat_err : np.ndarray, optional - The statistical error associated with y. Defaults to an array of - zeros with the same shape as y. - y_sys_err_normalization : float or array-like, optional - The fractional systematic error associated with normalization of y. - Defaults to 0.0. If array-like object is passed in, that implies - that there are multiple systematic errors associated with - normalization, each corresponding to an entry in - `y_sys_err_normalization_mask`. - y_sys_err_normalization_mask : list of np.ndarray, optional - Masks for the systematic errors associated with normalization of y. - Each mask should have the same shape as y, and the systematic error - associated with normalization will only apply to the points where - the mask is True. Defaults to None, meaning no systematic errors - associated with normalization, or equivalently, a single - systematic error for all points. - y_sys_err_offset : float or array-like, optional - The systematic error associated with the offset of y. Defaults to - 0.0. If array-like object is passed in, that implies that there - a multiple systematic errors associated with normalization, each - corresponding to an entry in `y_sys_err_normalization_mask`. - y_sys_err_offset_mask : list of np.ndarray, optional - Masks for the systematic errors associated with the offset of y. - Each mask should have the same shape as y, and the systematic error - associated with the offset will only apply to the points where - the mask is True. Defaults to None, meaning no systematic errors - associated with the offset, or equivalently, a single systematic - error for all points. - """ - self.n_data_pts = x.shape[0] - self.x = x - self.y = y + self.label = label + self.x = np.asarray(x) + self.y = np.asarray(y) if self.x.shape != self.y.shape: raise ValueError( - "x and y mustr have the same shape, they have shapes " - f" {x.shape} and {y.shape}" + "x and y must have the same shape, they have shapes " + f"{self.x.shape} and {self.y.shape}" ) - y_stat_err = y_stat_err if y_stat_err is not None else np.zeros_like(y) + self.n_data_pts = self.x.shape[0] + + y_stat_err = y_stat_err if y_stat_err is not None else np.zeros_like(self.y) + y_stat_err = np.asarray(y_stat_err, dtype=float) if y_stat_err.shape != self.y.shape: raise ValueError( "y_stat_err must have the same shape as y, " f"it has shape {y_stat_err.shape} and y has shape {self.y.shape}" ) - self.statistical_covariance = np.diag(y_stat_err**2) + self.y_stat_err = y_stat_err - # systematic errors in normalization - self.systematic_normalization_covariance = np.zeros_like( - self.statistical_covariance + self.y_sys_err_normalization = _store_error_spec( + y_sys_err_normalization, self.n_data_pts, "y_sys_err_normalization" + ) + self.y_sys_err_offset = _store_error_spec( + y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" ) - if y_sys_err_normalization is not None: - if is_array_like(y_sys_err_normalization): - if y_sys_err_normalization_mask is None: - raise ValueError( - "If y_sys_err_normalization is array-like, " - "y_sys_err_normalization_mask must also be provided." - ) - if len(y_sys_err_normalization) != len(y_sys_err_normalization_mask): - raise ValueError( - "If y_sys_err_normalization is array-like, " - "y_sys_err_normalization_mask must have the same length." - ) - for sys_err, mask in zip( - y_sys_err_normalization, y_sys_err_normalization_mask - ): - if mask.shape != self.y.shape: - raise ValueError( - "each mask in y_sys_err_normalization_mask must have the same shape as y" - ) - sys_err = sys_err * mask.astype(float) - self.systematic_normalization_covariance += np.outer( - sys_err, sys_err - ) - elif is_scalar_like(y_sys_err_normalization): - sys_err = y_sys_err_normalization * np.ones_like(y) - self.systematic_normalization_covariance += np.outer(sys_err, sys_err) - # systematic errors in offset - self.systematic_offset_covariance = np.zeros_like(self.statistical_covariance) - if y_sys_err_offset is not None: - if is_array_like(y_sys_err_offset): - if y_sys_err_offset_mask is None: - raise ValueError( - "If y_sys_err_offset is array-like, " - "y_sys_err_offset_mask must also be provided." - ) - if len(y_sys_err_offset) != len(y_sys_err_offset_mask): - raise ValueError( - "If y_sys_err_offset is array-like, " - "y_sys_err_offset_mask must have the same length." - ) - for sys_err, mask in zip(y_sys_err_offset, y_sys_err_offset_mask): - if mask.shape != self.y.shape: - raise ValueError( - "each mask in y_sys_err_offset_mask must have the same shape as y" - ) - sys_err = sys_err * mask.astype(float) - self.systematic_offset_covariance += np.outer(sys_err, sys_err) - elif is_scalar_like(y_sys_err_offset): - sys_err = y_sys_err_offset * np.ones_like(y) - self.systematic_offset_covariance += np.outer(sys_err, sys_err) + def statistical_term(self, support) -> DenseTerm: + """The always-on, genuinely uncorrelated statistical diagonal. + + Parameters + ---------- + support : np.ndarray + Indices of this observation's block in the stacked vector. - def covariance(self, y): + Returns + ------- + DenseTerm + ``diag(y_stat_err**2)`` on ``support``. """ - Returns the default covariance matrix for the observation, - which is the sum of the statistical and systematic offset covariance - matrices, and the fractional normalization covariance matrix - multiplied by the outer product of y with itself. + return statistical_term(support, self.y_stat_err) + + def systematic_terms(self, support) -> list: + """This dataset's reported correlated systematics as fixed rank-one terms. + + Opt-in — **not** added to any covariance automatically. Pass the result + via ``Constraint(extra_terms=[*obs.systematic_terms(support), ...])``. + Zero magnitudes are skipped, so an observation without reported + systematics yields an empty list. Parameters ---------- - y : np.ndarray - The dependent variable data for which to compute the covariance. - """ - return ( - self.statistical_covariance - + self.systematic_offset_covariance - + self.systematic_normalization_covariance * np.outer(y, y) - ) + support : np.ndarray + Indices of this observation's block in the stacked vector. - def residual(self, ym: np.ndarray): - if ym.shape != self.y.shape: - raise ValueError( - f"Shape mismatch: ym has shape {ym.shape}, expected {self.y.shape}" + Returns + ------- + list of Term + The absolute offset mode (``outer(omega, omega)``) first, then the + fractional, prediction-scaled normalisation mode + (``eta**2 * outer(ym, ym)``). + """ + terms = [] + if self.y_sys_err_offset is not None and np.any( + np.asarray(self.y_sys_err_offset) != 0.0 + ): + terms.append(offset_term(support, magnitude=self.y_sys_err_offset)) + if self.y_sys_err_normalization is not None and np.any( + np.asarray(self.y_sys_err_normalization) != 0.0 + ): + terms.append( + normalization_term(support, magnitude=self.y_sys_err_normalization) ) - return self.y - ym + return terms def num_pts_within_interval( self, @@ -175,24 +164,16 @@ def num_pts_within_interval( yhigh: np.ndarray, xlim=None, ): - """ - Returns the number of points in y that fall between ylow and yhigh, - useful for calculating emperical coverages + """Number of points of ``y`` that fall within ``[ylow, yhigh)``. + + Useful for empirical-coverage diagnostics. Parameters ---------- - ylow : np.ndarray, same shape as self.y - yhigh : np.ndarray, same shape as self.y + ylow, yhigh : np.ndarray + Interval bounds, same shape as ``y``. xlim : tuple, optional - If provided, only consider points where self.x is within - this range. Defaults to None, meaning all points are - considered. - - Returns - ------- - int - The number of points in self.y (within xlim) that fall - within the specified interval defined by ylow and yhigh. + ``(x_min, x_max)`` range to restrict the count. """ mask = np.ones_like(self.y, dtype=bool) if xlim is not None: @@ -206,77 +187,3 @@ def num_pts_within_interval( ) ) ) - - -class FixedCovarianceObservation(Observation): - """ - A class to represent an observation with fixed covariance. That is, the - covariance matrix for the Multivariate Gaussian likelihood for a model - prediction ym is known a priori and does not change with the model - prediction. - - The simplest such case is when the covariance is a diagonal matrix - containing the reported statistical variances for each data point in y. - - In the case that the covariance is a vector, it is interpreted as the - diagonal of the covariance matrix, and the likelihood reduces to the - standard form using the chi-squared statistic. In the case that the - covariance is a full matrix, this corresponds to the generalised - chi-squared statistic. - """ - - def __init__( - self, - x: np.ndarray, - y: np.ndarray, - covariance: np.ndarray, - ): - """ - Initializes the FixedCovarianceObservation with data and a fixed - covariance matrix. - - Parameters - ---------- - x : np.ndarray - The independent variable data. - y : np.ndarray - The dependent variable data. - covariance : np.ndarray - The fixed covariance matrix associated with the observation. - """ - super().__init__(x, y) - if covariance.shape == (self.y.shape[0],): - self.cov = np.diag(covariance) - elif covariance.shape == (self.y.shape[0], self.y.shape[0]): - self.cov = covariance - else: - raise ValueError( - f"Incompatible covariance matrix shape " - f"{covariance.shape} for Constraint with " - f"{self.y.shape[0]} data points" - ) - - self.cov_inv = np.linalg.inv(self.cov) - sign, self.log_det = np.linalg.slogdet(self.cov) - if sign != +1: - raise ValueError("Invalid covariance matrix! Must be positive definite.") - - def covariance(self, y): - """ - Returns the fixed covariance matrix for the observation, - which is constant and does not depend on y. - - Parameters - ---------- - y : np.ndarray - The dependent variable data for which to compute the covariance. - """ - return self.cov - - -def is_array_like(obj): - return isinstance(obj, Iterable) and not isinstance(obj, (str, bytes)) - - -def is_scalar_like(obj): - return np.isscalar(obj) or isinstance(obj, (int, float, complex)) diff --git a/src/rxmc/observation_from_measurement.py b/src/rxmc/observation_from_measurement.py index 0ccb94e..cb97a11 100644 --- a/src/rxmc/observation_from_measurement.py +++ b/src/rxmc/observation_from_measurement.py @@ -1,171 +1,38 @@ -from typing import Any, Type +""" +Helpers shared by the reaction-observation classes. -import numpy as np -from exfor_tools.distribution import Distribution - -from .observation import FixedCovarianceObservation, Observation - - -def set_up_observation( - ObservationClass: Type[Observation], - y: np.ndarray, - normalization: np.ndarray, - x: np.ndarray, - y_stat_err=None, - y_sys_err_normalization=None, - y_sys_err_offset=None, - dataset_label: str | None = None, - include_sys_norm_err: bool = True, - include_sys_offset_err: bool = True, - include_statistical_err: bool = True, -): - r""" - Set up an `Observation` from explicit measurement data. - - This function normalizes raw measurement arrays and handles systematic and - statistical errors before constructing the requested `Observation` type. - - Parameters - ---------- - ObservationClass : Type[Observation] - The class type of the `Observation` to be created. It must be a - subclass of `Observation`, such as `FixedCovarianceObservation`. - y : np.ndarray - Measured dependent-variable data. - normalization : np.ndarray - Normalization factor which the y-values and all dimensionfull - errors (e.g. all others than normalization errors) will be divided by. - x : np.ndarray - Independent-variable grid for the observation. - y_stat_err : np.ndarray, optional - Statistical errors associated with `y`. - y_sys_err_normalization : float or array-like, optional - Systematic normalization error(s) associated with `y`. - y_sys_err_offset : float or array-like, optional - Systematic offset error(s) associated with `y`. - dataset_label : str, optional - Human-readable dataset identifier used in validation errors. - include_sys_norm_err : bool, optional - Whether to include systematic normalization errors, by default True. - include_sys_offset_err : bool, optional - Whether to include systematic offset errors, by default True. - include_statistical_err : bool, optional - Whether to include statistical errors, by default True. +The reaction observations (:class:`~rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation` +and :class:`~rxmc.ias_pn_observation.IsobaricAnalogPNObservation`) are now plain +:class:`~rxmc.observation.Observation` subclasses carrying **statistical error +only**; any correlated systematic is composed explicitly as a +:class:`~rxmc.covariance.Term` in the :class:`~rxmc.constraint.Constraint`. This +module just holds the angle-grid validation they share. +""" - Returns - ------- - args: tuple - args for the ObservationClass initializer - kwargs: dict - kwargs for the ObservationClass initializer - y_stat_err: np.ndarray - Statistical errors normalized by the normalization factor. - """ - - label = dataset_label or "dataset" - y = np.asarray(y) / normalization - y_stat_err = ( - np.asarray(y_stat_err) / normalization - if include_statistical_err and y_stat_err is not None - else np.zeros_like(y) - ) - - y_sys_err_offset_value = None - y_sys_err_offset_mask = None - if include_sys_offset_err and y_sys_err_offset is not None: - y_sys_err_offset_value = np.asarray(y_sys_err_offset) / normalization - offset_is_scalar = ( - np.isscalar(y_sys_err_offset) or np.ndim(y_sys_err_offset_value) == 0 - ) - # check if systematic errors are common to all angles - if not ( - offset_is_scalar - or np.allclose(y_sys_err_offset_value, y_sys_err_offset_value[0]) - ): - raise ValueError( - f"Error while parsing measurement from {label}:\n" - "Systematic offset errors must be scalar or constant." - ) - else: - y_sys_err_offset_value = ( - np.asarray(y_sys_err_offset_value).item() - if offset_is_scalar - else y_sys_err_offset_value[0] - ) - y_sys_err_offset_mask = None - - y_sys_err_normalization_value = None - y_sys_err_normalization_mask = None - if include_sys_norm_err and y_sys_err_normalization is not None: - y_sys_err_normalization_value = y_sys_err_normalization - # check if systematic errors are common to all angles - ratio = y_sys_err_normalization_value - ratio_is_scalar = np.isscalar(ratio) or np.ndim(ratio) == 0 - if not (ratio_is_scalar or np.allclose(ratio, ratio[0])): - raise ValueError( - f"Error while parsing measurement from {label}:\n" - "Systematic normalization errors must be scalar or constant." - ) - else: - y_sys_err_normalization_mask = None - y_sys_err_normalization_value = ( - np.asarray(ratio).item() if ratio_is_scalar else ratio[0] - ) +import numpy as np - if ObservationClass is Observation: - # If the base class is Observation, we can directly return it - args = (x, y) - kwargs = { - "y_stat_err": y_stat_err, - "y_sys_err_offset": y_sys_err_offset_value, - "y_sys_err_offset_mask": y_sys_err_offset_mask, - "y_sys_err_normalization": y_sys_err_normalization_value, - "y_sys_err_normalization_mask": y_sys_err_normalization_mask, - } - return args, kwargs, y_stat_err - elif ObservationClass is FixedCovarianceObservation: - if include_sys_norm_err: - raise ValueError( - "FixedCovarianceObservation does not support systematic normalization errors." - ) - covariance = np.diag(y_stat_err**2) - if y_sys_err_offset_value is not None and include_sys_offset_err: - covariance += np.outer(y_sys_err_offset_value, y_sys_err_offset_value) - args = (x, y, covariance) - return args, {}, y_stat_err - else: - # if a new ObservationClass is written, a case for it must be added here - raise NotImplementedError( - f"ObservationClass {ObservationClass} is not implemented." - ) +def normalized_error_kwargs( + norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset +) -> dict: + """Error keywords for ``Observation.__init__`` in internal (norm-divided) units. -def set_up_observation_from_measurement( - ObservationClass: Type[Observation], - measurement: Distribution | Any, - normalization: np.ndarray, - x=None, - include_sys_norm_err=True, - include_sys_offset_err=True, - include_statistical_err=True, -): - r""" - Convenience wrapper for EXFOR-style `Distribution` inputs. + Encodes the unit contract shared by the reaction observations: dimensionful + errors (statistical, absolute offset) are divided by ``norm`` (a scalar, or + a per-point array); the fractional normalisation error is dimensionless and + passed through untouched. """ - x = x if x is not None else measurement.x - return set_up_observation( - ObservationClass, - x=x, - y=measurement.y, - y_stat_err=measurement.statistical_err, - y_sys_err_normalization=measurement.systematic_norm_err, - y_sys_err_offset=measurement.systematic_offset_err, - dataset_label=getattr(measurement, "subentry", None), - normalization=normalization, - include_sys_norm_err=include_sys_norm_err, - include_sys_offset_err=include_sys_offset_err, - include_statistical_err=include_statistical_err, - ) + return { + "y_stat_err": ( + None if y_stat_err is None else np.asarray(y_stat_err, dtype=float) / norm + ), + "y_sys_err_normalization": y_sys_err_normalization, + "y_sys_err_offset": ( + None + if y_sys_err_offset is None + else np.asarray(y_sys_err_offset, dtype=float) / norm + ), + } def check_angle_grid(angles_rad: np.ndarray, name: str): diff --git a/src/rxmc/physical_model.py b/src/rxmc/physical_model.py index 3312095..5ef3a0d 100644 --- a/src/rxmc/physical_model.py +++ b/src/rxmc/physical_model.py @@ -113,3 +113,128 @@ def evaluate(self, observation: Observation, *params) -> np.ndarray: x_powers = np.vander(observation.x, self.order + 1, increasing=True) y = np.dot(x_powers, np.asarray(params)) return y + + +class ScaledModel(PhysicalModel): + r"""A physical model with a latent multiplicative normalisation. + + Wraps a base :class:`PhysicalModel` and prepends a scale parameter + :math:`\rho`, returning + + .. math:: + + y_{\mathrm{model}}(x;\, \rho, \alpha) = \rho \, y_{\mathrm{base}}(x;\, \alpha) + + This is the Kennedy & O'Hagan latent forward-model scale that the old + ``UnknownNormalizationModel`` expressed on the likelihood side. It changes the + *mean*, not the covariance, so it lives on the model and flows through the + ordinary model-parameter machinery (priors, ``split_parameters``). + + Parameters + ---------- + base_model : PhysicalModel + The model whose prediction is rescaled. + scale_parameter : Parameter, optional + The scale parameter. Defaults to a log-scale ``log rho``; set + ``log=False`` for a linear scale. + log : bool, optional + If ``True`` (default), the sampled value is ``log(rho)`` and the model + scales by ``exp(value)``; otherwise it scales by ``value`` directly. + """ + + def __init__( + self, base_model: PhysicalModel, scale_parameter: Parameter = None, log=True + ): + self.base_model = base_model + self.log = log + if scale_parameter is None: + scale_parameter = Parameter( + "log normalization", + float, + unit="dimensionless", + latex_name=r"\log{\rho}" if log else r"\rho", + ) + self.scale_parameter = scale_parameter + super().__init__([scale_parameter] + list(base_model.params)) + + def evaluate(self, observation: Observation, *params) -> np.ndarray: + if len(params) != self.n_params: + raise ValueError(f"Expected {self.n_params} parameters, got {len(params)}") + scale = np.exp(params[0]) if self.log else params[0] + return scale * self.base_model.evaluate(observation, *params[1:]) + + +class PerObservationScaledModel(PhysicalModel): + r"""A physical model with an independent latent normalisation per dataset. + + Wraps a base :class:`PhysicalModel` and assigns one scale parameter + :math:`\rho_i` to each :class:`~rxmc.observation.Observation` in + ``observations``, routing **by identity**: when evaluated on observation + :math:`i` it returns :math:`\rho_i\, y_{\mathrm{base}}`. The base parameters + come first, followed by the per-observation scales in ``observations`` order. + + Because every constraint shares one such model instance, the per-dataset + scales are ordinary *model* parameters (sampled in the model block jointly + with the physics) rather than per-constraint covariance nuisances — this is + how the old per-dataset ``UnknownNormalizationModel`` is expressed in v2. The + routing reuses the same gather-by-identity idea as + :class:`~rxmc.covariance.ConstraintCovariance`. + + Parameters + ---------- + base_model : PhysicalModel + The model whose prediction is rescaled. + observations : sequence of Observation + The datasets, each assigned its own scale parameter (matched by identity + when :meth:`evaluate` is called). + scale_parameters : sequence of Parameter, optional + One scale parameter per observation. Defaults to ``log_rho_{i}``. + log : bool, optional + If ``True`` (default), the sampled value is ``log(rho_i)`` and the model + scales by ``exp(value)``; otherwise it scales by ``value`` directly. + prefix : str, optional + Name prefix for the default scale parameters. + """ + + def __init__( + self, + base_model: PhysicalModel, + observations, + scale_parameters=None, + log=True, + prefix="log_rho", + ): + self.base_model = base_model + self.log = log + self._n_base = len(base_model.params) + # hold references so id()-keyed routing can never see a recycled id + self.observations = list(observations) + self._index = {id(o): i for i, o in enumerate(self.observations)} + if len(self._index) != len(self.observations): + raise ValueError( + "observations must be distinct objects (routing by identity)" + ) + if scale_parameters is None: + scale_parameters = [ + Parameter( + f"{prefix}_{i}", + float, + unit="dimensionless", + latex_name=(rf"\log{{\rho_{{{i}}}}}" if log else rf"\rho_{{{i}}}"), + ) + for i in range(len(self._index)) + ] + self.scale_parameters = list(scale_parameters) + super().__init__(list(base_model.params) + self.scale_parameters) + + def evaluate(self, observation: Observation, *params) -> np.ndarray: + if len(params) != self.n_params: + raise ValueError(f"Expected {self.n_params} parameters, got {len(params)}") + if id(observation) not in self._index: + raise KeyError( + "observation was not registered with this PerObservationScaledModel" + ) + base_params = params[: self._n_base] + value = params[self._n_base + self._index[id(observation)]] + scale = np.exp(value) if self.log else value + return scale * self.base_model.evaluate(observation, *base_params) diff --git a/src/rxmc/predictive.py b/src/rxmc/predictive.py new file mode 100644 index 0000000..45087cf --- /dev/null +++ b/src/rxmc/predictive.py @@ -0,0 +1,267 @@ +""" +Predictive-uncertainty helpers. + +A :class:`~rxmc.covariance.KernelTerm` (like the GP discrepancy model it replaced) +only inflates the covariance *at the data points* with ``K(X, X)`` — it does not +propagate the discrepancy to new ``x``. :func:`gp_posterior_predictive` performs +the standard Gaussian-process conditioning needed to predict the discrepancy (mean +and covariance) at new points, and :func:`total_predictive_band` turns a posterior +sample of ``[model params | kernel log-theta]`` into a data-space predictive band +that propagates model-parameter, discrepancy, and observation-noise uncertainty. + +The kernel is duck-typed exactly as in :class:`~rxmc.covariance.KernelTerm`: a +scikit-learn-style object exposing ``clone_with_theta`` and ``__call__``, with +``theta`` in sklearn **log-theta** space. +""" + +import numpy as np +import scipy as sc + +from .covariance import as_2d + +__all__ = [ + "gp_posterior_predictive", + "total_predictive_band", + "predictive_band", +] + + +def _train_noise_matrix(train_noise_var, n) -> np.ndarray: + if train_noise_var is None: + return np.zeros((n, n)) + v = np.asarray(train_noise_var, dtype=float) + if v.ndim == 0: + return float(v) * np.eye(n) + if v.ndim == 1: + return np.diag(v) + return v + + +def gp_posterior_predictive( + kernel, + theta, + X_train, + residuals, + X_pred, + *, + train_noise_var=None, + jitter=1e-10, +): + r"""Posterior mean and covariance of a GP discrepancy at ``X_pred``. + + Conditions a zero-mean GP with covariance ``kernel`` (rebuilt at ``theta``) on + the observed ``residuals`` at ``X_train`` and returns its posterior at + ``X_pred``: + + .. math:: + + \bar f_* = K_{*t} (K_{tt} + N)^{-1} r, \qquad + \mathrm{cov}_* = K_{**} - K_{*t} (K_{tt} + N)^{-1} K_{t*} + + where ``N`` is the training-noise covariance. + + Parameters + ---------- + kernel : sklearn-style kernel + Object with ``clone_with_theta`` and ``__call__`` (as for + :class:`~rxmc.covariance.KernelTerm`). + theta : array-like + Kernel hyperparameters in sklearn **log-theta** space. + X_train, X_pred : array-like + Training and prediction inputs (1-D promoted to a column). + residuals : array-like, shape (n_train,) + Observed minus model-mean at ``X_train``. + train_noise_var : float, array-like, or matrix, optional + Training-noise variance: scalar (``var*I``), per-point vector + (``diag``), or full covariance. Defaults to none. + jitter : float, optional + Diagonal nugget added to the training covariance for stability. + + Returns + ------- + mean : np.ndarray, shape (n_pred,) + cov : np.ndarray, shape (n_pred, n_pred) + """ + k = kernel.clone_with_theta(np.asarray(theta, dtype=float)) + Xp = as_2d(X_pred) + mean, v = _gp_condition( + k, X_train, residuals, Xp, train_noise_var=train_noise_var, jitter=jitter + ) + Kss = np.asarray(k(Xp), dtype=float) + cov = Kss - v.T @ v + return mean, cov + + +def _gp_condition(k, X_train, residuals, Xp, *, train_noise_var, jitter): + """Shared GP conditioning: returns (mean, v). + + ``k`` is an already-instantiated kernel (``clone_with_theta`` applied); + ``Xp`` is the 2-D prediction grid. ``mean = Kst @ alpha`` and + ``v = L^{-1} Kst.T`` so callers form the full posterior covariance + (``Kss - v.T @ v``) or only its diagonal (``diag(Kss) - sum(v**2, 0)``). + """ + Xtr = as_2d(X_train) + r = np.asarray(residuals, dtype=float) + n = Xtr.shape[0] + + Ktt = np.asarray(k(Xtr), dtype=float) + Kst = np.asarray(k(Xp, Xtr), dtype=float) + + Ktrain = Ktt + _train_noise_matrix(train_noise_var, n) + jitter * np.eye(n) + L = sc.linalg.cholesky(Ktrain, lower=True) + alpha = sc.linalg.cho_solve((L, True), r) + mean = Kst @ alpha + v = sc.linalg.solve_triangular(L, Kst.T, lower=True) + return mean, v + + +def _gp_posterior_mean_var( + kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10 +): + """Posterior mean and **diagonal variance** of a GP discrepancy at ``X_pred``. + + Equivalent to ``mean, diag(cov)`` from :func:`gp_posterior_predictive` but + avoids building the full ``n_pred x n_pred`` covariance — O(n_pred * n_train) + instead of O(n_pred^2 * n_train). Uses ``kernel.diag(X_pred)`` for the prior + variances. + """ + k = kernel.clone_with_theta(np.asarray(theta, dtype=float)) + Xp = as_2d(X_pred) + mean, v = _gp_condition( + k, X_train, residuals, Xp, train_noise_var=train_noise_var, jitter=jitter + ) + prior_var = np.asarray(k.diag(Xp), dtype=float) + var = prior_var - np.einsum("ij,ij->j", v, v) + return mean, var + + +def predictive_band(draws, levels=(16, 50, 84)) -> np.ndarray: + """Percentile band over a matrix of predictive draws. + + Parameters + ---------- + draws : array-like, shape (n_draws, n_points) + Predictive samples (each row a function evaluated on a grid). + levels : sequence of float, optional + Percentile levels. + + Returns + ------- + np.ndarray, shape (len(levels), n_points) + """ + return np.percentile(np.asarray(draws, dtype=float), levels, axis=0) + + +def total_predictive_band( + mean_fn, + kernel, + x_train, + y_train, + x_pred, + draws, + n_model_params, + *, + theta_cols=None, + noise_std=0.0, + train_noise_var=None, + levels=(16, 84), + n_draws=400, + rng=None, +): + r"""Data-space predictive band that propagates *total* uncertainty. + + For each posterior draw ``q`` it splits out the model parameters and the kernel + log-theta, forms the residual ``y_train - mean_fn(x_train, *model_params)``, + conditions the GP discrepancy at ``x_pred``, and samples + + .. math:: + + y_*^{(s)} = \mathrm{mean\_fn}(x_*) + \bar f_*^{(s)} + + \mathcal N\!\big(0,\ \mathrm{var}_*^{(s)} + \sigma^2\big), + + returning the requested percentile band over the samples. Only the GP's + posterior *variance* is propagated per point (the off-diagonal posterior + covariance is not used for the marginal band). + + Parameters + ---------- + mean_fn : callable + ``mean_fn(x, *model_params) -> y`` on a raw ``x`` array (e.g. a model's + ``.y`` plotting helper). + kernel : sklearn-style kernel + The discrepancy kernel (as passed to :class:`~rxmc.covariance.KernelTerm`). + x_train, y_train, x_pred : array-like + Training inputs/outputs and the prediction grid. + draws : array-like, shape (n_samples, n_draw_cols) + Posterior chain rows. + n_model_params : int + Number of leading model parameters in each draw (consumed by ``mean_fn``). + theta_cols : array-like of int, optional + Column indices selecting the kernel log-theta within each draw row, in + ``kernel.theta`` order. When ``None`` (default) the kernel theta is taken + as the trailing columns ``q[n_model_params:]`` and the row width is + validated against ``len(kernel.theta)``. Pass explicit columns when the + draw also carries other covariance/likelihood nuisances. + noise_std : float, optional + Observation noise std-dev, used both to condition the GP and as the + prediction-point noise (overridden for conditioning by + ``train_noise_var`` if given). + train_noise_var : float or array-like, optional + Training-noise covariance for conditioning (defaults to ``noise_std**2``). + levels : sequence of float, optional + Percentile levels for the returned band. + n_draws : int, optional + Number of posterior rows to subsample (if the chain is longer). + rng : np.random.Generator, optional + + Returns + ------- + np.ndarray, shape (len(levels), len(x_pred)) + + Raises + ------ + ValueError + If the kernel-theta selection does not have ``len(kernel.theta)`` columns. + """ + rng = np.random.default_rng() if rng is None else rng + draws = np.asarray(draws, dtype=float) + if draws.shape[0] > n_draws: + draws = draws[rng.choice(draws.shape[0], n_draws, replace=False)] + + n_theta = len(kernel.theta) + if theta_cols is None: + n_trailing = draws.shape[1] - n_model_params + if n_trailing != n_theta: + raise ValueError( + f"draws have {n_trailing} columns after the {n_model_params} model " + f"parameters, but the kernel has {n_theta} hyperparameters. Pass " + "theta_cols to select the kernel log-theta columns explicitly." + ) + theta_cols = np.arange(n_model_params, n_model_params + n_theta) + else: + theta_cols = np.asarray(theta_cols, dtype=int) + if theta_cols.shape[0] != n_theta: + raise ValueError( + f"theta_cols selects {theta_cols.shape[0]} columns but the kernel " + f"has {n_theta} hyperparameters." + ) + + x_train = np.asarray(x_train, dtype=float) + y_train = np.asarray(y_train, dtype=float) + x_pred = np.asarray(x_pred, dtype=float) + pred_noise_var = float(noise_std) ** 2 + cond_noise = pred_noise_var if train_noise_var is None else train_noise_var + + samples = np.empty((draws.shape[0], x_pred.shape[0])) + for i, q in enumerate(draws): + model_params = q[:n_model_params] + theta = q[theta_cols] + residual = y_train - mean_fn(x_train, *model_params) + disc_mean, disc_var = _gp_posterior_mean_var( + kernel, theta, x_train, residual, x_pred, train_noise_var=cond_noise + ) + disc_var = np.clip(disc_var, 0.0, np.inf) + mu = mean_fn(x_pred, *model_params) + disc_mean + samples[i] = mu + rng.normal(0.0, np.sqrt(disc_var + pred_noise_var)) + + return predictive_band(samples, levels) diff --git a/src/rxmc/walker.py b/src/rxmc/walker.py index e7aafee..643bcba 100644 --- a/src/rxmc/walker.py +++ b/src/rxmc/walker.py @@ -75,7 +75,7 @@ def __init__( ) for i, conf in enumerate(self.likelihood_samplers): constraint = self.evidence.parametric_constraints[i] - if constraint.likelihood.params != conf.params: + if list(constraint.params) != list(conf.params): raise ValueError( "Inconsistent likelihood model parameters " f"between 'likelihood_samplers[{i}]' and " @@ -122,15 +122,13 @@ def run_likelihood_batches( burn : bool, optional If ``True``, treat as burn-in (samples are not recorded). """ + wmll = self.evidence.weighted_marginal_log_likelihood for i, sampler in enumerate(self.likelihood_samplers): constraint = self.evidence.parametric_constraints[i] - ym = constraint.predict(*model_params) - def log_posterior_lm(x): - lp = sampler.prior.logpdf(x) + constraint.marginal_log_likelihood( - ym, *np.atleast_1d(x) - ) + def log_posterior_lm(x, sampler=sampler, i=i, ym=ym): + lp = sampler.prior.logpdf(x) + wmll(i, ym, *np.atleast_1d(x)) return float(np.squeeze(lp)) x0 = starting_locations[i] diff --git a/test/conftest.py b/test/conftest.py new file mode 100644 index 0000000..1056006 --- /dev/null +++ b/test/conftest.py @@ -0,0 +1,6 @@ +"""Make the shared test helpers importable under any pytest import mode.""" + +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).parent)) diff --git a/test/helpers.py b/test/helpers.py new file mode 100644 index 0000000..90eb5dc --- /dev/null +++ b/test/helpers.py @@ -0,0 +1,22 @@ +"""Shared helpers for the test suite.""" + +import numpy as np + +from rxmc.covariance import StackContext +from rxmc.likelihood_model import log_likelihood, mahalanobis_distance_sqr_cholesky + + +def make_ctx(x, y, ym, supports) -> StackContext: + """Build a StackContext from stacked arrays and block supports.""" + return StackContext( + x=np.asarray(x), + y=np.asarray(y), + ym=np.asarray(ym), + supports=tuple(np.asarray(s, dtype=int) for s in supports), + ) + + +def manual_mvn_loglike(y, ym, cov): + """Reference dense multivariate-normal log likelihood.""" + d2, logdet = mahalanobis_distance_sqr_cholesky(y, ym, cov) + return log_likelihood(d2, logdet, len(y)) diff --git a/test/test_config.py b/test/test_config.py index 2903238..d8758cb 100644 --- a/test/test_config.py +++ b/test/test_config.py @@ -5,14 +5,31 @@ from rxmc.config import CalibrationConfig, ParameterConfig from rxmc.constraint import Constraint +from rxmc.covariance import model_error_term from rxmc.evidence import Evidence -from rxmc.likelihood_model import LikelihoodModel, UnknownModelError from rxmc.observation import Observation from rxmc.params import Parameter from rxmc.physical_model import Polynomial from rxmc.priors import TruncatedNormalPrior +def gamma_parameter(): + """The UnknownModelError gamma, as a covariance parameter.""" + return Parameter( + "log fractional err", float, latex_name=r"\gamma", unit="dimensionless" + ) + + +def model_error_constraint(observation, model, gamma): + """A constraint with an UnknownModelError (averaging) covariance term.""" + support = np.arange(observation.n_data_pts) + return Constraint( + observations=[observation], + physical_model=model, + extra_terms=[model_error_term(support, gamma, averaging=True)], + ) + + class TestParameterConfig(unittest.TestCase): def setUp(self): self.param1 = Parameter(name="param1") @@ -118,6 +135,7 @@ class TestCalibrationConfig(unittest.TestCase): def setUp(self): # Evidence with one regular and one parametric constraint self.model = Polynomial(1) + self.gamma = gamma_parameter() self.evidence = Evidence( constraints=[ Constraint( @@ -129,20 +147,15 @@ def setUp(self): ) ], physical_model=self.model, - likelihood_model=LikelihoodModel(), - ) - ], - parametric_constraints=[ - Constraint( - observations=[ - Observation( - x=np.array([6.0, 7.0, 8.0]), - y=np.array([6.3, 8.1, 9.6]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - ], - physical_model=self.model, - likelihood_model=UnknownModelError(), + ), + model_error_constraint( + Observation( + x=np.array([6.0, 7.0, 8.0]), + y=np.array([6.3, 8.1, 9.6]), + y_stat_err=np.array([0.1, 0.1, 0.1]), + ), + self.model, + self.gamma, ), ], ) @@ -161,7 +174,7 @@ def setUp(self): # Likelihood Config likelihood_prior = scipy.stats.multivariate_normal(mean=[0], cov=[[1]]) self.likelihood_config = ParameterConfig( - params=self.evidence.parametric_constraints[0].likelihood.params, + params=list(self.evidence.parametric_constraints[0].params), prior=likelihood_prior, initial_proposal_distribution=likelihood_prior, ) @@ -251,23 +264,65 @@ def test_conditional_posterior_uses_parametric_constraint(self): ) + self.likelihood_config.prior_logpdf(x_lm) self.assertAlmostEqual(config.conditional_posterior(x_lm, 0, ym), expected) + def test_parametric_indices_map(self): + # the parametric constraint is second in evidence.constraints + self.assertEqual(self.evidence.parametric_indices, [1]) + + def test_conditional_posterior_tempering(self): + # the Gibbs conditional must apply likelihood_scaling and the + # constraint's Evidence weight, matching log_posterior's tempering + scaling = 0.5 + weights = np.array([1.0, 3.0]) # parametric constraint has weight 3 + evidence = Evidence(constraints=self.evidence.constraints, weights=weights) + config = CalibrationConfig( + evidence=evidence, + model_config=self.model_config, + likelihood_configs=[self.likelihood_config], + likelihood_scaling=scaling, + ) + + xmodel = np.array([1.0, 1.0]) + ym = evidence.parametric_constraints[0].predict(*xmodel) + x_lm = np.array([0.0]) + + lp = self.likelihood_config.prior_logpdf(x_lm) + ll = evidence.parametric_constraints[0].marginal_log_likelihood(ym, *x_lm) + self.assertAlmostEqual( + config.conditional_posterior(x_lm, 0, ym), lp + scaling * 3.0 * ll + ) + + def test_predict_parametric_aligns_with_conditional_posterior(self): + # mixed evidence: constraints[0] is non-parametric, constraints[1] is the + # parametric one. predict() is in constraints order (len 2) while + # predict_parametric() is in parametric order (len 1) -> aligned with lm_index. + config = CalibrationConfig( + evidence=self.evidence, + model_config=self.model_config, + likelihood_configs=[self.likelihood_config], + ) + xmodel = np.array([1.0, 1.0]) + + all_preds = config.predict(xmodel) + param_preds = config.predict_parametric(xmodel) + self.assertEqual(len(all_preds), 2) + self.assertEqual(len(param_preds), 1) + # predict_parametric()[0] is the parametric constraint's prediction (== all_preds[1]) + np.testing.assert_allclose(param_preds[0][0], all_preds[1][0]) + np.testing.assert_allclose( + param_preds[0][0], + self.evidence.parametric_constraints[0].predict(*xmodel)[0], + ) + def test_starting_location_with_single_parameter_sectors(self): model = Polynomial(0) - likelihood = UnknownModelError() + gamma = gamma_parameter() observation = Observation( x=np.array([1.0, 2.0]), y=np.array([1.0, 1.1]), y_stat_err=np.array([0.1, 0.1]), ) - evidence = Evidence( - parametric_constraints=[ - Constraint( - observations=[observation], - physical_model=model, - likelihood_model=likelihood, - ) - ] - ) + constraint = model_error_constraint(observation, model, gamma) + evidence = Evidence(constraints=[constraint]) model_config = ParameterConfig( params=model.params, prior=scipy.stats.multivariate_normal(mean=[0], cov=[[1]]), @@ -276,7 +331,7 @@ def test_starting_location_with_single_parameter_sectors(self): ), ) likelihood_config = ParameterConfig( - params=likelihood.params, + params=list(constraint.params), prior=scipy.stats.multivariate_normal(mean=[0], cov=[[1]]), initial_proposal_distribution=scipy.stats.multivariate_normal( mean=[0], cov=[[1]] @@ -294,22 +349,17 @@ def test_starting_location_with_single_parameter_sectors(self): def test_prior_transform_via_generic_prior(self): """prior_transform works end-to-end with TruncatedNormalPrior sectors.""" model = Polynomial(1) - likelihood = UnknownModelError() - evidence = Evidence( - parametric_constraints=[ - Constraint( - observations=[ - Observation( - x=np.array([1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.0, 3.0, 4.0]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1]), - ) - ], - physical_model=model, - likelihood_model=likelihood, - ) - ] + gamma = gamma_parameter() + constraint = model_error_constraint( + Observation( + x=np.array([1.0, 2.0, 3.0, 4.0]), + y=np.array([1.0, 2.0, 3.0, 4.0]), + y_stat_err=np.array([0.1, 0.1, 0.1, 0.1]), + ), + model, + gamma, ) + evidence = Evidence(constraints=[constraint]) model_prior = TruncatedNormalPrior( mu=[0.0, 1.0], sigma=[1.0, 1.0], lower=[-5.0, -5.0], upper=[5.0, 5.0] ) @@ -325,7 +375,7 @@ def test_prior_transform_via_generic_prior(self): ), likelihood_configs=[ ParameterConfig( - params=likelihood.params, + params=list(constraint.params), prior=lm_prior, initial_proposal_distribution=lm_prior, ) diff --git a/test/test_constraint.py b/test/test_constraint.py index f94b7af..0c6091a 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -1,11 +1,446 @@ +"""Tests for the stacked Constraint: multi-observation stacking and case A/B.""" + import unittest +import numpy as np + +from helpers import manual_mvn_loglike +from rxmc.constraint import Constraint +from rxmc.covariance import RankOneTerm, normalization_term +from rxmc.evidence import Evidence +from rxmc.observation import Observation +from rxmc.params import Parameter +from rxmc.physical_model import PerObservationScaledModel, Polynomial + + +class TestStackedConstraint(unittest.TestCase): + def setUp(self): + self.pm = Polynomial(order=1) + self.model_params = (0.5, 1.2) + self.obs1 = Observation( + np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) + ) + self.obs2 = Observation( + np.array([3.0, 4.0, 5.0]), + np.array([5.0, 6.0, 8.0]), + y_stat_err=np.array([0.3, 0.2, 0.4]), + ) + + def _stacked(self): + y = np.concatenate([self.obs1.y, self.obs2.y]) + ym = np.concatenate( + [ + self.pm.evaluate(self.obs1, *self.model_params), + self.pm.evaluate(self.obs2, *self.model_params), + ] + ) + return y, ym + + def test_block_diagonal_equals_sum_of_blocks(self): + c = Constraint([self.obs1, self.obs2], self.pm) + self.assertEqual(c.n_data_pts, 5) + self.assertTrue(c.covariance.block_diagonal) + + y, ym = self._stacked() + stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) + cov = np.diag(stat**2) + expected = manual_mvn_loglike(y, ym, cov) + self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) + + def test_block_diagonal_fast_path_matches_dense(self): + # build a constraint and compare blockwise path against an explicit dense MVN + c = Constraint([self.obs1, self.obs2], self.pm) + y, ym = self._stacked() + stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) + dense = manual_mvn_loglike(y, ym, np.diag(stat**2)) + self.assertAlmostEqual(c.log_likelihood(self.model_params), dense) + + def test_constant_block_diag_cached_factors_match_dense(self): + # constant multi-block covariance: cold call and cache-warm call both + # equal the manual dense MVN + c = Constraint([self.obs1, self.obs2], self.pm) + y, ym = self._stacked() + stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) + expected = manual_mvn_loglike(y, ym, np.diag(stat**2)) + cold = c.log_likelihood(self.model_params) + warm = c.log_likelihood(self.model_params) + self.assertAlmostEqual(cold, expected) + self.assertEqual(cold, warm) + + def test_case_A_cross_block_coupling(self): + # one rank-one mode spanning both blocks couples the data (off-diagonal blocks) + eta = 0.1 + p = Parameter("log eta") + support = np.arange(5) + coupling = RankOneTerm(support, basis=lambda ctx, s: ctx.ym[s], parameter=p) + c = Constraint([self.obs1, self.obs2], self.pm, extra_terms=[coupling]) + + self.assertFalse(c.covariance.block_diagonal) + self.assertEqual(c.n_params, 1) + + y, ym = self._stacked() + stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) + cov = np.diag(stat**2) + eta**2 * np.outer(ym, ym) + expected = manual_mvn_loglike(y, ym, cov) + self.assertAlmostEqual( + c.log_likelihood(self.model_params, (np.log(eta),)), expected + ) + + def test_case_A_differs_from_independent(self): + eta = 0.1 + p = Parameter("log eta") + coupled = Constraint( + [self.obs1, self.obs2], + self.pm, + extra_terms=[ + RankOneTerm(np.arange(5), basis=lambda c, s: c.ym[s], parameter=p) + ], + ) + # independent: two per-block normalization modes (no cross coupling) + p1, p2 = Parameter("log eta 1"), Parameter("log eta 2") + independent = Constraint( + [self.obs1, self.obs2], + self.pm, + extra_terms=[ + normalization_term(np.arange(2), parameter=p1), + normalization_term(np.arange(2, 5), parameter=p2), + ], + ) + ll_coupled = coupled.log_likelihood(self.model_params, (np.log(eta),)) + ll_indep = independent.log_likelihood( + self.model_params, (np.log(eta), np.log(eta)) + ) + self.assertNotAlmostEqual(ll_coupled, ll_indep) + + +class TestPerDatasetScaledModel(unittest.TestCase): + """Per-dataset latent rho expressed as identity-routed model parameters.""" + + def setUp(self): + self.base = Polynomial(order=1) + self.obs1 = Observation( + np.array([1.0, 2.0, 3.0]), + np.array([2.0, 4.0, 6.0]), + y_stat_err=np.array([0.1, 0.1, 0.1]), + ) + self.obs2 = Observation( + np.array([1.0, 2.0, 3.0]), + np.array([4.0, 8.0, 12.0]), + y_stat_err=np.array([0.1, 0.1, 0.1]), + ) + + def test_routes_rho_by_identity(self): + model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + # params = [a0, a1, log_rho_0, log_rho_1] + self.assertEqual(model.n_params, 4) + mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) + np.testing.assert_allclose(model.evaluate(self.obs1, *mp), [2.0, 4.0, 6.0]) + np.testing.assert_allclose(model.evaluate(self.obs2, *mp), [4.0, 8.0, 12.0]) + + def test_shared_across_constraints_in_evidence(self): + model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + c1 = Constraint([self.obs1], model) + c2 = Constraint([self.obs2], model) + ev = Evidence([c1, c2]) # all constraints share one model instance + self.assertEqual( + [p.name for p in ev.model_params], ["a0", "a1", "log_rho_0", "log_rho_1"] + ) + ll = ev.log_likelihood((0.0, 2.0, np.log(1.0), np.log(2.0))) + self.assertTrue(np.isfinite(ll)) + + def test_holds_observation_references(self): + # id()-keyed routing must keep the registered objects alive so a + # garbage-collected observation's id can never be recycled + import gc + + model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + gc.collect() + self.assertIs(model.observations[0], self.obs1) + self.assertIs(model.observations[1], self.obs2) + mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) + np.testing.assert_allclose( + model.evaluate(model.observations[0], *mp), [2.0, 4.0, 6.0] + ) + + def test_unregistered_observation_raises(self): + model = PerObservationScaledModel(self.base, [self.obs1]) + with self.assertRaises(KeyError): + model.evaluate(self.obs2, 0.0, 1.0, 0.0) + + +class TestSharedParameterCaseB(unittest.TestCase): + def test_shared_eta_one_param(self): + pm = Polynomial(order=0) + obs1 = Observation(np.array([1.0, 2.0]), np.array([3.0, 3.0])) + obs2 = Observation(np.array([3.0, 4.0]), np.array([3.0, 3.0])) + eta = Parameter("log eta") + c = Constraint( + [obs1, obs2], + pm, + extra_terms=[ + normalization_term(np.arange(2), parameter=eta), + normalization_term(np.arange(2, 4), parameter=eta), + ], + ) + # one shared parameter, covariance stays block-diagonal + self.assertEqual(c.n_params, 1) + self.assertTrue(c.covariance.block_diagonal) + + +class TestParamCountValidation(unittest.TestCase): + """The full constraint tuple is validated; surplus params no longer vanish.""" + + def setUp(self): + self.pm = Polynomial(order=1) + self.mp = (0.5, 1.2) + self.obs = Observation( + np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) + ) + + def test_surplus_params_raise(self): + # reviewer repro: these used to be silently swallowed, returning the + # same value as the no-param call + c = Constraint([self.obs], self.pm) + with self.assertRaises(ValueError) as cm: + c.log_likelihood(self.mp, (0.3, 99.0, -5.0)) + self.assertIn("expects 0 parameter", str(cm.exception)) + + def test_missing_params_raise(self): + eta = Parameter("log eta") + c = Constraint( + [self.obs], + self.pm, + extra_terms=[normalization_term(np.arange(2), parameter=eta)], + ) + with self.assertRaises(ValueError) as cm: + c.log_likelihood(self.mp) + self.assertIn("log eta", str(cm.exception)) + + def test_correct_count_unchanged(self): + eta = Parameter("log eta") + c = Constraint( + [self.obs], + self.pm, + extra_terms=[normalization_term(np.arange(2), parameter=eta)], + ) + self.assertTrue(np.isfinite(c.log_likelihood(self.mp, (np.log(0.1),)))) + + def test_studentt_chi2_full_tuple(self): + from rxmc.covariance import noise_term + from rxmc.likelihood_model import GaussianLikelihood, StudentT + + eps = Parameter("log eps") + student = Constraint( + [self.obs], + self.pm, + likelihood=StudentT(), + extra_terms=[noise_term(np.arange(2), eps)], + ) + # covariance-only tuple is a deficit now + with self.assertRaises(ValueError): + student.chi2(self.mp, (np.log(0.1),)) + # full tuple works; nu is ignored by the statistic + gauss = Constraint( + [self.obs], + self.pm, + likelihood=GaussianLikelihood(), + extra_terms=[noise_term(np.arange(2), Parameter("log eps g"))], + ) + self.assertAlmostEqual( + student.chi2(self.mp, (np.log(0.1), 4.0)), + gauss.chi2(self.mp, (np.log(0.1),)), + ) + + def test_covariance_matrix_full_tuple_convention(self): + from rxmc.likelihood_model import StudentT + + eta = Parameter("log eta") + c = Constraint( + [self.obs], + self.pm, + likelihood=StudentT(), + extra_terms=[normalization_term(np.arange(2), parameter=eta)], + ) + # reviewer repro: forwarding the full sampled tuple used to crash + S = c.covariance_matrix(self.mp, (np.log(0.1), 4.0)) + gauss = Constraint( + [self.obs], + self.pm, + extra_terms=[ + normalization_term(np.arange(2), parameter=Parameter("log eta")) + ], + ) + np.testing.assert_allclose(S, gauss.covariance_matrix(self.mp, (np.log(0.1),))) + # a partial (covariance-only) tuple is now rejected uniformly + with self.assertRaises(ValueError): + c.covariance_matrix(self.mp, (np.log(0.1),)) + + +class TestParameterNameValidation(unittest.TestCase): + def setUp(self): + self.pm = Polynomial(order=1) + self.obs = Observation( + np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) + ) + + def test_two_distinct_same_name_params_raise(self): + # two equal-but-distinct objects are almost certainly intended sharing + # gone wrong (sharing works by identity) + with self.assertRaises(ValueError) as cm: + Constraint( + [self.obs], + self.pm, + extra_terms=[ + normalization_term(np.arange(2), parameter=Parameter("log eta")), + normalization_term(np.arange(2), parameter=Parameter("log eta")), + ], + ) + self.assertIn("SAME Parameter object", str(cm.exception)) + + def test_collision_with_model_param_name_raises(self): + # Polynomial(order=1) has model params named a0, a1 + with self.assertRaises(ValueError) as cm: + Constraint( + [self.obs], + self.pm, + extra_terms=[ + normalization_term(np.arange(2), parameter=Parameter("a0")) + ], + ) + self.assertIn("physical-model parameter", str(cm.exception)) + + def test_likelihood_param_collision_raises(self): + from rxmc.likelihood_model import StudentT + + nu_clone = Parameter("nu") + with self.assertRaises(ValueError): + Constraint( + [self.obs], + self.pm, + likelihood=StudentT(nu_parameter=Parameter("nu")), + extra_terms=[normalization_term(np.arange(2), parameter=nu_clone)], + ) + + +class TestSingularCovarianceGuard(unittest.TestCase): + """A constant singular covariance fails at construction with a clear error.""" + + def setUp(self): + self.pm = Polynomial(order=1) + self.x = np.array([1.0, 2.0]) + self.y = np.array([2.0, 3.0]) + + def test_zero_stat_err_raises_clear_error(self): + obs = Observation(self.x, self.y) # y_stat_err defaults to zeros + with self.assertRaises(ValueError) as cm: + Constraint([obs], self.pm) + self.assertIn("singular", str(cm.exception)) + self.assertIn("observation 0", str(cm.exception)) + + def test_offending_dataset_named_by_label(self): + good = Observation(self.x, self.y, y_stat_err=np.array([0.1, 0.1])) + bad = Observation(np.array([3.0, 4.0]), np.array([4.0, 5.0]), label="C1010-2-0") + with self.assertRaises(ValueError) as cm: + Constraint([good, bad], self.pm) + msg = str(cm.exception) + self.assertIn("C1010-2-0", msg) + self.assertNotIn("observation 0'", msg) + + def test_zero_stat_err_with_covering_term_ok(self): + from rxmc.covariance import DenseTerm + + obs = Observation(self.x, self.y) + c = Constraint( + [obs], + self.pm, + extra_terms=[DenseTerm(np.arange(2), np.array([0.04, 0.04]))], + ) + self.assertTrue(np.isfinite(c.log_likelihood((0.5, 1.2)))) + + def test_zero_stat_err_with_systematic_terms_ok(self): + obs = Observation( + self.x, self.y, y_sys_err_normalization=0.05, y_sys_err_offset=0.1 + ) + c = Constraint([obs], self.pm, extra_terms=obs.systematic_terms(np.arange(2))) + self.assertTrue(np.isfinite(c.log_likelihood((0.5, 1.2)))) + + def test_parametric_covariance_not_checked_eagerly(self): + # replace-semantics: zero stat err + a free noise term must construct + from rxmc.covariance import noise_term + + obs = Observation(self.x, self.y) + p = Parameter("log eps") + c = Constraint([obs], self.pm, extra_terms=[noise_term(np.arange(2), p)]) + self.assertEqual(c.n_params, 1) + + +class TestConstraintFixes(unittest.TestCase): + def setUp(self): + self.pm = Polynomial(order=1) + self.params = (0.5, 1.2) + self.obs = Observation( + np.array([1.0, 2.0, 3.0]), + np.array([2.0, 3.0, 5.0]), + y_stat_err=np.array([0.1, 0.2, 0.3]), + ) + + def test_covariance_matrix_returns_copy(self): + c = Constraint([self.obs], self.pm) + before = c.log_likelihood(self.params) + M = c.covariance_matrix(self.params) + M += 1e6 # in-place mutation must not corrupt the constraint + after = c.log_likelihood(self.params) + self.assertAlmostEqual(before, after) + + def test_stack_shape_guard(self): + c = Constraint([self.obs], self.pm) + with self.assertRaises(ValueError): + c.marginal_log_likelihood([np.array([1.0, 2.0])]) # wrong length + + def test_include_statistical_term_false_omits_diagonal(self): + from rxmc.covariance import DenseTerm + + sup = np.arange(self.obs.n_data_pts) + cov = np.diag([0.04, 0.04, 0.04]) + c = Constraint( + [self.obs], + self.pm, + extra_terms=[DenseTerm(sup, cov)], + include_statistical_term=False, + ) + # only the supplied DenseTerm survives (no statistical diagonal added) + S = c.covariance_matrix(self.params) + np.testing.assert_allclose(S, cov) + + +class TestScaledModel(unittest.TestCase): + def test_scale_applied_and_params_prepended(self): + from rxmc.physical_model import ScaledModel + + base = Polynomial(order=1) + obs = Observation( + np.array([1.0, 2.0, 3.0]), + np.array([2.0, 4.0, 6.0]), + y_stat_err=np.array([0.1, 0.1, 0.1]), + ) + model = ScaledModel(base) + self.assertEqual(model.n_params, 3) + self.assertEqual(model.params[0].name, "log normalization") + np.testing.assert_allclose( + model.evaluate(obs, np.log(2.0), 0.0, 2.0), + 2.0 * base.evaluate(obs, 0.0, 2.0), + ) -class TestFixedCovConstraint(unittest.TestCase): + def test_linear_scale(self): + from rxmc.params import Parameter + from rxmc.physical_model import ScaledModel - # TODO - def test_diagonal_cov(self): - self.assertTrue(True) + base = Polynomial(order=0) + obs = Observation(np.array([1.0, 2.0]), np.array([3.0, 3.0])) + model = ScaledModel(base, scale_parameter=Parameter("rho"), log=False) + np.testing.assert_allclose( + model.evaluate(obs, 1.5, 4.0), 1.5 * base.evaluate(obs, 4.0) + ) if __name__ == "__main__": diff --git a/test/test_covariance.py b/test/test_covariance.py new file mode 100644 index 0000000..4a0571d --- /dev/null +++ b/test/test_covariance.py @@ -0,0 +1,497 @@ +"""Unit tests for the stacked-covariance core (:mod:`rxmc.covariance`).""" + +import numpy as np +import pytest + +from helpers import make_ctx +from rxmc.covariance import ( + ConstraintCovariance, + DenseTerm, + DiagonalTerm, + RankOneTerm, + model_error_term, + noise_fraction_term, + noise_term, + normalization_term, + offset_term, + statistical_term, + ym_basis, +) +from rxmc.params import Parameter + + +def single_block_ctx(x, y, ym): + n = len(x) + return make_ctx(x, y, ym, [np.arange(n)]) + + +class TestDenseTerm: + def test_vector_is_diagonal(self): + t = DenseTerm([0, 1, 2], np.array([1.0, 2.0, 3.0])) + S = np.zeros((3, 3)) + t.add_to(S, None, np.array([])) + assert np.allclose(S, np.diag([1.0, 2.0, 3.0])) + + def test_full_matrix_passthrough(self): + m = np.array([[2.0, 0.5], [0.5, 3.0]]) + t = DenseTerm([0, 1], m) + S = np.zeros((2, 2)) + t.add_to(S, None, np.array([])) + assert np.allclose(S, m) + + def test_writes_into_subblock(self): + t = DenseTerm([2, 3], np.array([1.0, 1.0])) + S = np.zeros((4, 4)) + t.add_to(S, None, np.array([])) + expected = np.zeros((4, 4)) + expected[2, 2] = expected[3, 3] = 1.0 + assert np.allclose(S, expected) + + def test_scalar_broadcast_raises(self): + # a (1, 1) matrix on a length-3 support used to broadcast silently + # into the whole block + with pytest.raises(ValueError, match="does not match support"): + DenseTerm(np.arange(3), [[0.04]]) + + def test_wrong_length_vector_raises(self): + with pytest.raises(ValueError, match="does not match support"): + DenseTerm(np.arange(3), np.ones(2)) + + def test_asymmetric_matrix_raises(self): + with pytest.raises(ValueError, match="symmetric"): + DenseTerm(np.arange(2), [[1.0, 0.5], [0.0, 1.0]]) + + def test_couples_offdiagonal(self): + # only terms that can write off-diagonal entries can couple blocks + assert not DenseTerm([0, 1, 2], np.ones(3)).couples_offdiagonal + assert DenseTerm([0, 1], np.array([[2.0, 0.5], [0.5, 3.0]])).couples_offdiagonal + assert not DiagonalTerm([0, 1]).couples_offdiagonal + assert RankOneTerm([0, 1], basis=np.ones(2)).couples_offdiagonal + + +class TestDiagonalTerm: + def test_ones_basis_with_param(self): + p = Parameter("log eps") + t = DiagonalTerm([0, 1], basis=None, parameter=p, log=True) + ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) + S = np.zeros((2, 2)) + t.add_to(S, ctx, np.array([np.log(0.5)])) + assert np.allclose(S, np.diag([0.25, 0.25])) + + def test_basis_array_no_param(self): + t = DiagonalTerm([0, 1], basis=np.array([2.0, 3.0])) + S = np.zeros((2, 2)) + t.add_to(S, None, np.array([])) + assert np.allclose(S, np.diag([4.0, 9.0])) + + def test_ym_basis_callable(self): + p = Parameter("log eps") + t = DiagonalTerm([0, 1], basis=ym_basis, parameter=p) + ym = np.array([2.0, 4.0]) + ctx = single_block_ctx(np.zeros(2), np.zeros(2), ym) + S = np.zeros((2, 2)) + t.add_to(S, ctx, np.array([np.log(0.1)])) + assert np.allclose(S, np.diag((0.1 * ym) ** 2)) + + +class TestRankOneTerm: + def test_outer_product(self): + v = np.array([1.0, 2.0, 3.0]) + t = RankOneTerm([0, 1, 2], basis=v) + S = np.zeros((3, 3)) + t.add_to(S, None, np.array([])) + assert np.allclose(S, np.outer(v, v)) + + def test_normalization_mode_scales_with_ym(self): + p = Parameter("log eta") + t = RankOneTerm([0, 1], basis=ym_basis, parameter=p) + ym = np.array([3.0, 5.0]) + ctx = single_block_ctx(np.zeros(2), np.zeros(2), ym) + S = np.zeros((2, 2)) + eta = 0.07 + t.add_to(S, ctx, np.array([np.log(eta)])) + assert np.allclose(S, np.outer(eta * ym, eta * ym)) + + def test_cross_block_coupling_writes_offdiagonal(self): + # support spans two blocks [0,1] and [2,3] + v = np.array([1.0, 1.0, 1.0, 1.0]) + t = RankOneTerm([0, 1, 2, 3], basis=v) + S = np.zeros((4, 4)) + t.add_to(S, None, np.array([])) + # off-diagonal blocks coupling block 0 and block 1 are non-zero + assert S[0, 2] != 0.0 and S[1, 3] != 0.0 + + +class TestGatherByIdentity: + def test_shared_parameter_dedup(self): + # Case B: two block-local terms share ONE Parameter object + eta = Parameter("log eta") + t1 = normalization_term([0, 1], parameter=eta) + t2 = normalization_term([2, 3], parameter=eta) + cov = ConstraintCovariance([t1, t2], N=4) + assert cov.n_params == 1 + assert cov.params == (eta,) + + def test_distinct_parameters_not_shared(self): + e1 = Parameter("log eta 1") + e2 = Parameter("log eta 2") + t1 = normalization_term([0, 1], parameter=e1) + t2 = normalization_term([2, 3], parameter=e2) + cov = ConstraintCovariance([t1, t2], N=4) + assert cov.n_params == 2 + assert cov.params == (e1, e2) + + def test_shared_value_fed_to_both(self): + eta = Parameter("log eta") + t1 = normalization_term([0, 1], parameter=eta) + t2 = normalization_term([2, 3], parameter=eta) + cov = ConstraintCovariance([t1, t2], N=4) + ym = np.array([1.0, 1.0, 2.0, 2.0]) + ctx = make_ctx(np.zeros(4), np.zeros(4), ym, [np.arange(2), np.arange(2, 4)]) + e = 0.1 + S = cov.matrix(ctx, np.log(e)) + # both blocks scaled by the same eta + assert np.allclose(S[:2, :2], np.outer(e * ym[:2], e * ym[:2])) + assert np.allclose(S[2:, 2:], np.outer(e * ym[2:], e * ym[2:])) + # block-local -> no cross coupling + assert np.allclose(S[:2, 2:], 0.0) + + def test_first_seen_order_deterministic(self): + a = Parameter("a") + b = Parameter("b") + t1 = DiagonalTerm([0], parameter=b) + t2 = DiagonalTerm([1], parameter=a) + cov = ConstraintCovariance([t1, t2], N=2) + assert cov.params == (b, a) + + def test_wrong_param_count_raises(self): + p = Parameter("p") + cov = ConstraintCovariance([DiagonalTerm([0], parameter=p)], N=1) + with pytest.raises(ValueError): + cov.matrix(single_block_ctx(np.zeros(1), np.zeros(1), np.zeros(1))) + + +class TestProperties: + def test_block_diagonal_true_for_local_terms(self): + cov = ConstraintCovariance( + [ + statistical_term([0, 1], np.ones(2)), + statistical_term([2, 3], np.ones(2)), + ], + N=4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + assert cov.block_diagonal + + def test_block_diagonal_false_for_coupling(self): + cov = ConstraintCovariance( + [RankOneTerm([0, 1, 2, 3], basis=np.ones(4))], + N=4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + assert not cov.block_diagonal + + def test_contiguous_cross_block_term_without_blocks_not_block_diagonal(self): + # the old contiguity heuristic classified a coupling term with a + # contiguous support as block-local; without explicit blocks the + # classification must now be conservative (dense path) + cov = ConstraintCovariance( + [ + statistical_term([0, 1], np.ones(2)), + statistical_term([2, 3], np.ones(2)), + RankOneTerm(np.arange(4), basis=np.ones(4)), + ], + N=4, + ) + assert not cov.block_diagonal + + def test_diagonal_only_terms_block_diagonal_without_blocks(self): + # strictly-diagonal terms are block-diagonal under ANY partition + cov = ConstraintCovariance( + [statistical_term([0, 1], np.ones(2)), DiagonalTerm([2, 3])], N=4 + ) + assert cov.block_diagonal + + def test_diagonal_term_spanning_blocks_stays_block_diagonal(self): + cov = ConstraintCovariance( + [DiagonalTerm(np.arange(4))], + N=4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + assert cov.block_diagonal + + def test_is_constant(self): + cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) + assert cov.is_constant + p = Parameter("p") + cov2 = ConstraintCovariance([DiagonalTerm([0, 1], parameter=p)], N=2) + assert not cov2.is_constant + + def test_constant_matrix_cached(self): + cov = ConstraintCovariance( + [statistical_term([0, 1], np.array([2.0, 3.0]))], N=2 + ) + m1 = cov.matrix(None) + m2 = cov.matrix(None) + assert m1 is m2 + assert np.allclose(m1, np.diag([4.0, 9.0])) + + def test_cached_matrix_readonly(self): + # the cached matrix is shared state: mutation must fail loudly + cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) + m = cov.matrix(None) + with pytest.raises(ValueError): + m[0, 0] = 99.0 + + def test_cached_cholesky_readonly(self): + cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) + L, _ = cov.cholesky(None) + with pytest.raises(ValueError): + L[0, 0] = 99.0 + + def test_block_cholesky_cached_and_readonly(self): + cov = ConstraintCovariance( + [ + statistical_term([0, 1], np.ones(2)), + statistical_term([2, 3], np.ones(2)), + ], + N=4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + f1 = cov.block_cholesky(None) + f2 = cov.block_cholesky(None) + assert f1 is f2 + with pytest.raises(ValueError): + f1[0][0][0, 0] = 99.0 + + def test_block_cholesky_requires_blocks(self): + cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) + with pytest.raises(ValueError, match="blocks"): + cov.block_cholesky(None) + + def test_block_cholesky_nonconstant_not_cached(self): + p = Parameter("log eps") + cov = ConstraintCovariance( + [ + statistical_term([0, 1], np.ones(2)), + DiagonalTerm([2, 3], parameter=p), + ], + N=4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + ctx = make_ctx( + np.zeros(4), np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)] + ) + f1 = cov.block_cholesky(ctx, 0.0) + f2 = cov.block_cholesky(ctx, 0.0) + assert f1 is not f2 + for (L1, d1), (L2, d2) in zip(f1, f2): + assert np.allclose(L1, L2) + assert d1 == d2 + + def test_nonconstant_matrix_writable(self): + p = Parameter("p") + cov = ConstraintCovariance([DiagonalTerm([0, 1], parameter=p)], N=2) + ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) + S = cov.matrix(ctx, 0.0) + S[0, 0] = 99.0 # fresh array, caller-owned + + +class TestNoSilentFastPathWithoutBlocks: + """A cross-block coupling built without explicit blocks must take the dense path. + + This pins the fix for the contiguity-heuristic bug: a RankOneTerm whose + support is one contiguous run over two observation blocks used to be + misclassified as block-local, and the fast path silently dropped the + off-diagonal coupling. + """ + + def test_stacked_distance_matches_dense(self): + from rxmc.likelihood_model import mahalanobis_distance_sqr_cholesky + + rng = np.random.default_rng(7) + y = rng.normal(size=4) + ym = y + 0.1 * rng.normal(size=4) + cov = ConstraintCovariance( + [ + statistical_term(np.arange(4), np.full(4, 0.5)), + RankOneTerm(np.arange(4), basis=np.ones(4)), + ], + N=4, + ) + ctx = make_ctx(np.arange(4.0), y, ym, [np.arange(2), np.arange(2, 4)]) + + d2, logdet = cov.stacked_distance(ctx) + Sigma = np.diag(np.full(4, 0.25)) + np.ones((4, 4)) + d2_dense, logdet_dense = mahalanobis_distance_sqr_cholesky(y, ym, Sigma) + assert np.isclose(d2, d2_dense) + assert np.isclose(logdet, logdet_dense) + + +class TestScalarLikeMagnitudes: + """0-d ndarrays (as stored by exfor_tools distributions) count as scalars.""" + + def test_zero_dim_offset_magnitude(self): + support = np.arange(3) + a = offset_term(support, magnitude=np.array(0.2)) + b = offset_term(support, magnitude=0.2) + S1, S2 = np.zeros((3, 3)), np.zeros((3, 3)) + a.add_to(S1, None, np.array([])) + b.add_to(S2, None, np.array([])) + assert np.allclose(S1, S2) + + def test_zero_dim_normalization_magnitude(self): + support = np.arange(3) + ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.array([1.0, 2.0, 3.0])) + a = normalization_term(support, magnitude=np.array(0.05)) + b = normalization_term(support, magnitude=0.05) + S1, S2 = np.zeros((3, 3)), np.zeros((3, 3)) + a.add_to(S1, ctx, np.array([])) + b.add_to(S2, ctx, np.array([])) + assert np.allclose(S1, S2) + + +class TestFactoryHelpersReproduceOldCovariance: + """Each helper reproduces the matrix the old LikelihoodModel zoo built.""" + + def setup_method(self): + self.y = np.array([1.0, 2.0, 3.0]) + self.ym = np.array([1.1, 1.9, 3.2]) + self.stat = np.array([0.1, 0.2, 0.3]) + self.support = np.arange(3) + self.ctx = single_block_ctx(np.arange(3.0), self.y, self.ym) + + def test_statistical_only(self): + S = ConstraintCovariance( + [statistical_term(self.support, self.stat)], N=3 + ).matrix(self.ctx) + assert np.allclose(S, np.diag(self.stat**2)) + + def test_unknown_noise(self): + eps = 0.05 + p = Parameter("log eps") + cov = ConstraintCovariance( + [statistical_term(self.support, np.zeros(3)), noise_term(self.support, p)], + N=3, + ) + S = cov.matrix(self.ctx, np.log(eps)) + assert np.allclose(S, np.diag(np.full(3, eps**2))) + + def test_unknown_noise_fraction(self): + eps = 0.05 + p = Parameter("log eps") + cov = ConstraintCovariance([noise_fraction_term(self.support, p)], N=3) + S = cov.matrix(self.ctx, np.log(eps)) + assert np.allclose(S, np.diag((eps * self.ym) ** 2)) + + def test_unknown_normalization_error(self): + eta = 0.07 + p = Parameter("log eta") + cov = ConstraintCovariance([normalization_term(self.support, parameter=p)], N=3) + S = cov.matrix(self.ctx, np.log(eta)) + assert np.allclose(S, eta**2 * np.outer(self.ym, self.ym)) + + def test_unknown_model_error_averaging(self): + gamma = 0.1 + p = Parameter("log gamma") + cov = ConstraintCovariance( + [model_error_term(self.support, p, averaging=True)], N=3 + ) + S = cov.matrix(self.ctx, np.log(gamma)) + z = 0.5 * (self.y + self.ym) + assert np.allclose(S, np.diag((gamma * z) ** 2)) + + def test_fixed_normalization_systematic(self): + # data-given fractional normalisation (no free parameter) + frac = 0.03 + cov = ConstraintCovariance( + [normalization_term(self.support, magnitude=frac)], N=3 + ) + S = cov.matrix(self.ctx) + expected = (frac**2) * np.outer(self.ym, self.ym) + assert np.allclose(S, expected) + + def test_fixed_offset_systematic(self): + off = 0.2 + cov = ConstraintCovariance([offset_term(self.support, magnitude=off)], N=3) + S = cov.matrix(self.ctx) + omega = off * np.ones(3) + assert np.allclose(S, np.outer(omega, omega)) + + +class TestOldObservationCovarianceEquivalence: + """A stat+offset+normalization stack matches the old Observation.covariance(ym).""" + + def test_full_covariance(self): + y = np.array([1.0, 2.0, 4.0]) + ym = np.array([1.2, 2.1, 3.5]) + stat = np.array([0.1, 0.2, 0.3]) + norm = 0.05 + offset = 0.2 + support = np.arange(3) + ctx = make_ctx(np.arange(3.0), y, ym, [support]) + + terms = [ + statistical_term(support, stat), + offset_term(support, magnitude=offset), + normalization_term(support, magnitude=norm), + ] + S = ConstraintCovariance(terms, N=3).matrix(ctx) + + # old Observation.covariance(ym): + old = ( + np.diag(stat**2) + + np.outer(offset * np.ones(3), offset * np.ones(3)) + + np.outer(norm * np.ones(3), norm * np.ones(3)) * np.outer(ym, ym) + ) + assert np.allclose(S, old) + + +def test_kernel_term_params_match_theta_length_isotropic(): + from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel + + from rxmc.covariance import KernelTerm + + kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) + term = KernelTerm(np.arange(4), kernel) + # one free Parameter per non-fixed hyperparameter element + assert len(term.params) == len(kernel.theta) + + +def test_kernel_term_params_anisotropic(): + from sklearn.gaussian_process.kernels import RBF, ConstantKernel + + from rxmc.covariance import KernelTerm + + # anisotropic: a vector length_scale is ONE hyperparameter with n_elements == 2 + kernel = ConstantKernel(1.0) * RBF(length_scale=[1.0, 1.0]) + term = KernelTerm(np.arange(3), kernel) + assert len(term.params) == len(kernel.theta) # would be 1 vs 2 before the fix + + # the gathered theta has the right length for clone_with_theta in add_to + x2d = np.array([[0.0, 0.0], [1.0, 0.5], [2.0, 1.0]]) + ctx = make_ctx(x2d, np.zeros(3), np.zeros(3), [np.arange(3)]) + Sigma = np.zeros((3, 3)) + term.add_to(Sigma, ctx, kernel.theta) # must not raise + assert np.all(np.isfinite(Sigma)) + + +def test_kernel_term_cross_block_values(): + # a kernel spanning two observation blocks writes the correct + # off-diagonal coupling block (case A with a GP) + from sklearn.gaussian_process.kernels import RBF + + from rxmc.covariance import KernelTerm + + kernel = RBF(length_scale=1.0) + term = KernelTerm(np.arange(4), kernel, jitter=0.0) + x = np.array([0.0, 1.0, 2.0, 3.0]) + ctx = make_ctx(x, np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)]) + + S = np.zeros((4, 4)) + term.add_to(S, ctx, kernel.theta) + np.testing.assert_allclose(S, kernel(x[:, None])) + assert np.any(S[:2, 2:] != 0.0) + + cov = ConstraintCovariance([term], N=4, blocks=[np.arange(2), np.arange(2, 4)]) + assert not cov.block_diagonal diff --git a/test/test_evidence.py b/test/test_evidence.py index e19dd19..f5204df 100644 --- a/test/test_evidence.py +++ b/test/test_evidence.py @@ -3,67 +3,133 @@ import numpy as np from rxmc.constraint import Constraint +from rxmc.covariance import model_error_term from rxmc.evidence import Evidence -from rxmc.likelihood_model import LikelihoodModel from rxmc.observation import Observation +from rxmc.params import Parameter from rxmc.physical_model import Polynomial class TestEvidence(unittest.TestCase): def setUp(self): - y = np.array([1, 2, 3]) - x = np.array([1, 2, 3]) + y = np.array([1.0, 2.0, 3.0]) + x = np.array([1.0, 2.0, 3.0]) y_stat_err = np.array([0.1, 0.2, 0.3]) - self.observations = [ - Observation( - x=x, - y=y, - y_stat_err=y_stat_err, - ), - ] + self.y = y + self.y_stat_err = y_stat_err + self.observations = [Observation(x=x, y=y, y_stat_err=y_stat_err)] self.pm = Polynomial(order=1) self.constraints = [ - Constraint( - observations=self.observations, - physical_model=self.pm, - likelihood_model=LikelihoodModel(), - ), - Constraint( - observations=self.observations, - physical_model=self.pm, - likelihood_model=LikelihoodModel(), - ), - Constraint( - observations=self.observations, - physical_model=self.pm, - likelihood_model=LikelihoodModel(), - ), - Constraint( - observations=self.observations, - physical_model=self.pm, - likelihood_model=LikelihoodModel(), - ), + Constraint(observations=self.observations, physical_model=self.pm) + for _ in range(4) ] self.weights = np.array([1.0, 1.0, 1.0, 1.0]) + self.evidence = Evidence(constraints=self.constraints, weights=self.weights) - self.evidence = Evidence( - constraints=self.constraints, - weights=self.weights, - ) - self.model_params = (3, 5) + self.model_params = (3.0, 5.0) modely = self.pm.evaluate(self.observations[0], *self.model_params) delta = y - modely chi2 = np.sum((delta / y_stat_err) ** 2) N = self.observations[0].n_data_pts - log_det = np.log(np.linalg.det(self.observations[0].statistical_covariance)) - logl_single_constraint = -0.5 * (N * np.log(2 * np.pi) + log_det + chi2) - self.expected_loglikelihood = 4 * logl_single_constraint + log_det = np.sum(np.log(y_stat_err**2)) + logl_single = -0.5 * (N * np.log(2 * np.pi) + log_det + chi2) + self.expected_loglikelihood = 4 * logl_single def test_serial_execution(self): log_likelihood = self.evidence.log_likelihood(model_params=self.model_params) self.assertAlmostEqual(log_likelihood, self.expected_loglikelihood) + def test_no_parametric_constraints_detected(self): + self.assertEqual(len(self.evidence.parametric_constraints), 0) + self.assertEqual(self.evidence.n_params, self.pm.n_params) + + def test_parametric_constraint_auto_detected(self): + gamma = Parameter("log gamma") + parametric = Constraint( + observations=self.observations, + physical_model=self.pm, + extra_terms=[model_error_term(np.arange(3), gamma)], + ) + evidence = Evidence(constraints=[self.constraints[0], parametric]) + self.assertEqual(len(evidence.parametric_constraints), 1) + self.assertIs(evidence.parametric_constraints[0], parametric) + self.assertEqual(evidence.n_params, self.pm.n_params + 1) + + def test_parametric_constraint_receives_its_params(self): + gamma = Parameter("log gamma") + parametric = Constraint( + observations=self.observations, + physical_model=self.pm, + extra_terms=[model_error_term(np.arange(3), gamma)], + ) + evidence = Evidence(constraints=[parametric]) + # one tuple per parametric constraint + ll = evidence.log_likelihood(self.model_params, [(np.log(0.1),)]) + # directly via the constraint + ll_direct = parametric.log_likelihood(self.model_params, (np.log(0.1),)) + self.assertAlmostEqual(ll, ll_direct) + + def test_wrong_cov_params_length_raises(self): + gamma = Parameter("log gamma") + parametric = Constraint( + observations=self.observations, + physical_model=self.pm, + extra_terms=[model_error_term(np.arange(3), gamma)], + ) + evidence = Evidence(constraints=[parametric]) + with self.assertRaises(ValueError): + evidence.log_likelihood(self.model_params, []) + + +class TestCrossConstraintParameterValidation(unittest.TestCase): + """Covariance/likelihood parameters are constraint-scoped (spec §8).""" + + def setUp(self): + self.pm = Polynomial(order=1) + self.obs = [ + Observation( + x=np.array([1.0, 2.0, 3.0]), + y=np.array([1.0, 2.0, 3.0]), + y_stat_err=np.array([0.1, 0.2, 0.3]), + ) + ] + + def _constraint(self, param): + return Constraint( + observations=self.obs, + physical_model=self.pm, + extra_terms=[model_error_term(np.arange(3), param)], + ) + + def test_same_parameter_object_in_two_constraints_raises(self): + gamma = Parameter("log gamma") + c1, c2 = self._constraint(gamma), self._constraint(gamma) + with self.assertRaises(ValueError) as cm: + Evidence(constraints=[c1, c2]) + self.assertIn("same object", str(cm.exception)) + + def test_duplicate_name_across_constraints_raises(self): + c1 = self._constraint(Parameter("log gamma")) + c2 = self._constraint(Parameter("log gamma")) + with self.assertRaises(ValueError) as cm: + Evidence(constraints=[c1, c2]) + self.assertIn("Duplicate parameter name", str(cm.exception)) + + def test_unique_names_accepted(self): + c1 = self._constraint(Parameter("log gamma 1")) + c2 = self._constraint(Parameter("log gamma 2")) + ev = Evidence(constraints=[c1, c2]) + self.assertEqual(ev.n_likelihood_params, 2) + + def test_two_default_student_t_constraints_raise(self): + from rxmc.likelihood_model import StudentT + + c1 = Constraint(self.obs, self.pm, likelihood=StudentT()) + c2 = Constraint(self.obs, self.pm, likelihood=StudentT()) + with self.assertRaises(ValueError): + Evidence(constraints=[c1, c2]) + if __name__ == "__main__": unittest.main() diff --git a/test/test_likelihood_model.py b/test/test_likelihood_model.py index 39fd633..db5af74 100644 --- a/test/test_likelihood_model.py +++ b/test/test_likelihood_model.py @@ -1,437 +1,166 @@ +"""Tests for the stacked likelihood functionals and their Term-based covariances.""" + import unittest import numpy as np - +from scipy.special import gammaln + +from helpers import manual_mvn_loglike +from rxmc.constraint import Constraint +from rxmc.covariance import ( + DenseTerm, + model_error_term, + noise_fraction_term, + noise_term, + normalization_term, +) from rxmc.likelihood_model import ( - FixedCovarianceLikelihood, - LikelihoodModel, - StudentTLikelihoodModel, - UnknownModelError, - UnknownNoiseErrorModel, - UnknownNoiseFractionErrorModel, - UnknownNormalizationErrorModel, - UnknownNormalizationModel, + Chi2, + StudentT, mahalanobis_distance_sqr_cholesky, ) -from rxmc.observation import FixedCovarianceObservation, Observation +from rxmc.observation import Observation +from rxmc.params import Parameter +from rxmc.physical_model import Polynomial -class TestFixedCovarianceLikelihoodDiagCovariance(unittest.TestCase): +class LikelihoodTestBase(unittest.TestCase): def setUp(self): - self.observation = FixedCovarianceObservation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - covariance=np.array( - [1.0, 1.0, 1.0], - ), - ) - self.delta = np.array([1.0, -1.0, 0.0]) - self.ym = self.observation.y + self.delta - self.ym_same = self.observation.y - self.likelihood = FixedCovarianceLikelihood() - - def test_covariance(self): - cov = self.likelihood.covariance(self.observation, self.ym) - np.testing.assert_array_equal(cov, self.observation.cov) - - def test_chi2(self): - chi2_value = self.likelihood.chi2(self.observation, self.ym) - expected_chi2 = np.dot(self.delta, self.delta) - self.assertAlmostEqual(chi2_value, expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood(self.observation, self.ym) - expected_log_likelihood = -0.5 * ( - np.dot(self.delta, self.delta) + np.log(1) + 3 * np.log(2 * np.pi) - ) - self.assertAlmostEqual(log_likelihood_value, expected_log_likelihood) - - def test_chi2_same_(self): - chi2_value = self.likelihood.chi2(self.observation, self.ym_same) - expected_chi2 = 0.0 - self.assertAlmostEqual(chi2_value, expected_chi2) - - def test_log_likelihood_same_(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym_same - ) - expected_log_likelihood = -0.5 * (np.log(1) + 3 * np.log(2 * np.pi)) - self.assertAlmostEqual(log_likelihood_value, expected_log_likelihood) - - -class TestFixedCovarianceLikelihood(unittest.TestCase): - def setUp(self): - # positive definite covariance matrix - self.cov = np.array( - [ - [1.0, 0.5, 0.3], - [0.5, 1.0, 0.2], - [0.3, 0.2, 1.0], - ] - ) - self.observation = FixedCovarianceObservation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - covariance=self.cov, - ) - self.delta = np.array([1.0, -1.0, 0.0]) - self.ym = self.observation.y - self.delta - self.likelihood = FixedCovarianceLikelihood() - self.expected_chi2 = self.delta @ np.linalg.inv(self.cov) @ self.delta - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 + np.log(np.linalg.det(self.cov)) + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance(self.observation, self.ym) - np.testing.assert_array_equal(cov, self.observation.cov) - - def test_chi2(self): - chi2_value = self.likelihood.chi2(self.observation, self.ym) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood(self.observation, self.ym) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestLikelihoodModel(unittest.TestCase): - def setUp(self): - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - y_sys_err_normalization=0.04, - y_sys_err_offset=0.2, - ) - self.ym = self.observation.y + np.array([1.0, -1.0, 0.0]) - self.delta = self.observation.y - self.ym - self.likelihood = LikelihoodModel() - self.expected_covariance = ( - self.observation.statistical_covariance - + self.observation.systematic_offset_covariance - + self.observation.systematic_normalization_covariance - * np.outer(self.ym, self.ym) - ) - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance(self.observation, self.ym) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_allclose(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2(self.observation, self.ym) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood(self.observation, self.ym) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestUnknownNoiseFrac(unittest.TestCase): - def setUp(self): - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - y_sys_err_normalization=0.00, - y_sys_err_offset=0.0, - ) - self.ym = self.observation.y + np.array([1.0, -1.0, 0.0]) - self.delta = self.observation.y - self.ym - self.likelihood = UnknownNoiseFractionErrorModel() - self.noise_fraction = 0.312 - self.expected_covariance = ( - np.diag((self.noise_fraction * self.ym) ** 2) - + self.observation.systematic_offset_covariance - + self.observation.systematic_normalization_covariance - * np.outer(self.ym, self.ym) - ) - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance( - self.observation, self.ym, np.log(self.noise_fraction) - ) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_array_almost_equal(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2( - self.observation, self.ym, np.log(self.noise_fraction) - ) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym, np.log(self.noise_fraction) - ) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestUnknownNoise(unittest.TestCase): - def setUp(self): - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - y_sys_err_normalization=0.04, - y_sys_err_offset=0.2, - ) - self.delta = np.array([1.0, -1.0, 0.0]) - self.ym = self.observation.y + self.delta - self.likelihood = UnknownNoiseErrorModel() - self.noise = 0.312 - self.expected_covariance = ( - np.diag(np.ones_like(self.ym) * self.noise**2) - + self.observation.systematic_offset_covariance - + self.observation.systematic_normalization_covariance - * np.outer(self.ym, self.ym) - ) - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance(self.observation, self.ym, np.log(self.noise)) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_array_almost_equal(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2(self.observation, self.ym, np.log(self.noise)) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym, np.log(self.noise) - ) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestUnknownNormalizationError(unittest.TestCase): - def setUp(self): - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - y_sys_err_normalization=0.04, - y_sys_err_offset=0.2, - ) - self.ym = self.observation.y + np.array([1.0, -1.0, 0.0]) - self.delta = self.observation.y - self.ym - self.likelihood = UnknownNormalizationErrorModel() - self.normalization_err = 0.312 - self.expected_covariance = ( - self.observation.statistical_covariance - + self.observation.systematic_offset_covariance - + self.normalization_err**2 * np.outer(self.ym, self.ym) - ) - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance( - self.observation, self.ym, np.log(self.normalization_err) - ) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_array_almost_equal(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2( - self.observation, self.ym, np.log(self.normalization_err) - ) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym, np.log(self.normalization_err) - ) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestUnknownNormalization(unittest.TestCase): - def setUp(self): - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - self.normalization = 0.9 - self.likelihood = UnknownNormalizationModel() - - self.ym = self.observation.y + np.array([1.0, -1.0, 0.0]) - self.delta = self.observation.y - self.ym * self.normalization - self.expected_covariance = self.observation.statistical_covariance - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance( - self.observation, self.ym, np.log(self.normalization) - ) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_array_almost_equal(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2( - self.observation, self.ym, np.log(self.normalization) - ) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym, np.log(self.normalization) - ) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) + self.x = np.array([1.0, 2.0, 3.0]) + self.y = np.array([2.0, 4.0, 7.0]) + self.stat = np.array([0.1, 0.2, 0.3]) + self.obs = Observation(self.x, self.y, y_stat_err=self.stat) + self.pm = Polynomial(order=1) + self.model_params = (1.0, 1.5) + self.ym = self.pm.evaluate(self.obs, *self.model_params) + + +class TestGaussianStatisticalOnly(LikelihoodTestBase): + def test_matches_manual_mvn(self): + c = Constraint([self.obs], self.pm) + cov = np.diag(self.stat**2) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) + + def test_constraint_is_non_parametric(self): + c = Constraint([self.obs], self.pm) + self.assertEqual(c.n_params, 0) + self.assertTrue(c.covariance.block_diagonal) + + +class TestUnknownNoise(LikelihoodTestBase): + def test_constant_noise(self): + eps = 0.05 + p = Parameter("log eps") + c = Constraint([self.obs], self.pm, extra_terms=[noise_term(np.arange(3), p)]) + cov = np.diag(self.stat**2) + np.diag(np.full(3, eps**2)) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertEqual(c.n_params, 1) + self.assertAlmostEqual( + c.log_likelihood(self.model_params, (np.log(eps),)), expected + ) + + def test_noise_fraction(self): + eps = 0.05 + p = Parameter("log eps") + c = Constraint( + [self.obs], self.pm, extra_terms=[noise_fraction_term(np.arange(3), p)] + ) + cov = np.diag(self.stat**2) + np.diag((eps * self.ym) ** 2) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertAlmostEqual( + c.log_likelihood(self.model_params, (np.log(eps),)), expected + ) + + +class TestUnknownNormalizationError(LikelihoodTestBase): + def test_eta(self): + eta = 0.07 + p = Parameter("log eta") + c = Constraint( + [self.obs], + self.pm, + extra_terms=[normalization_term(np.arange(3), parameter=p)], + ) + cov = np.diag(self.stat**2) + eta**2 * np.outer(self.ym, self.ym) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertAlmostEqual( + c.log_likelihood(self.model_params, (np.log(eta),)), expected + ) + + +class TestUnknownModelError(LikelihoodTestBase): + def test_averaging(self): + gamma = 0.1 + p = Parameter("log gamma") + c = Constraint( + [self.obs], + self.pm, + extra_terms=[model_error_term(np.arange(3), p, averaging=True)], + ) + z = 0.5 * (self.y + self.ym) + cov = np.diag(self.stat**2) + np.diag((gamma * z) ** 2) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertAlmostEqual( + c.log_likelihood(self.model_params, (np.log(gamma),)), expected + ) + + +class TestFixedCovariance(LikelihoodTestBase): + def test_dense_term_fixed_full_covariance(self): + cov = np.array([[0.04, 0.01, 0.0], [0.01, 0.09, 0.02], [0.0, 0.02, 0.16]]) + obs = Observation(self.x, self.y) # no stat err -> zeros + c = Constraint([obs], self.pm, extra_terms=[DenseTerm(np.arange(3), cov)]) + self.assertTrue(c.covariance.is_constant) + expected = manual_mvn_loglike(self.y, self.ym, cov) + self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) + + def test_cholesky_cached(self): + cov = np.diag([0.04, 0.09, 0.16]) + obs = Observation(self.x, self.y) + c = Constraint([obs], self.pm, extra_terms=[DenseTerm(np.arange(3), cov)]) + L1, _ = c.covariance.cholesky(None) + L2, _ = c.covariance.cholesky(None) + self.assertIs(L1, L2) + + +class TestStudentT(LikelihoodTestBase): + def test_student_t_value(self): + nu = 5.0 + c = Constraint([self.obs], self.pm, likelihood=StudentT()) + self.assertEqual(c.n_params, 1) + self.assertEqual(c.params[0].name, "degrees_of_freedom") + ll = c.log_likelihood(self.model_params, (nu,)) + + cov = np.diag(self.stat**2) + d2, logdet = mahalanobis_distance_sqr_cholesky(self.y, self.ym, cov) + n = 3 + expected = ( + gammaln((n + nu) / 2) + - gammaln(nu / 2) + - 0.5 * n * np.log(np.pi * nu) + - 0.5 * logdet + - 0.5 * (nu + n) * np.log1p(d2 / nu) + ) + self.assertAlmostEqual(ll, expected) + + +class TestChi2(LikelihoodTestBase): + def test_chi2_drops_logdet(self): + c = Constraint([self.obs], self.pm, likelihood=Chi2()) + cov = np.diag(self.stat**2) + d2, _ = mahalanobis_distance_sqr_cholesky(self.y, self.ym, cov) + self.assertAlmostEqual(c.log_likelihood(self.model_params), -0.5 * d2) class TestMahalanobisDistanceCholesky(unittest.TestCase): - def test_mahalanobis_distance_sqr(self): - # Test case: Simple 2D example - y = np.array([2.0, 3.0]) - ym = np.array([0.0, 0.0]) - cov = np.array([[1.0, 0.5], [0.5, 1.0]]) - - residual = y - ym - - expected_mahalanobis_distance_sqr = residual.T @ np.linalg.inv(cov) @ residual - expected_log_det = np.log(0.75) - - mahalanobis, log_det = mahalanobis_distance_sqr_cholesky(y, ym, cov) - - self.assertAlmostEqual(mahalanobis, expected_mahalanobis_distance_sqr, places=5) - self.assertAlmostEqual(log_det, expected_log_det, places=5) - - def test_mahalanobis_distance_sqr_0(self): - # Test case: Simple 2D example - y = np.array([2.0, 3.0]) - ym = y - cov = np.array([[1.0, 0.5], [0.5, 1.0]]) - - expected_mahalanobis_distance_sqr = 0 - expected_log_det = np.log(0.75) - - mahalanobis, log_det = mahalanobis_distance_sqr_cholesky(y, ym, cov) - - self.assertAlmostEqual(mahalanobis, expected_mahalanobis_distance_sqr, places=5) - self.assertAlmostEqual(log_det, expected_log_det, places=5) - - def test_mahalanobis_distance_sqr_near_singular(self): - # Test case: Simple 2D example - y = np.array([1, 2, 3]) - ym = np.array([1.1, 1.9, 3.1]) - - # Ill-conditioned covariance matrix - cov = np.array([[1.0, 0.999, 0.999], [0.999, 1.0, 0.999], [0.999, 0.999, 1.0]]) - residual = y - ym - - expected_mahalanobis_distance_sqr = residual.T @ np.linalg.inv(cov) @ residual - expected_log_det = np.log(np.linalg.det(cov)) - mahalanobis, log_det = mahalanobis_distance_sqr_cholesky(y, ym, cov) - - self.assertAlmostEqual(mahalanobis, expected_mahalanobis_distance_sqr, places=5) - self.assertAlmostEqual(log_det, expected_log_det, places=5) - - -class TestUnknownModelError(unittest.TestCase): - def setUp(self): - # Setup Observation instance with mock data - self.observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([10.0, 15.0, 20.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - y_sys_err_normalization=0.04, - y_sys_err_offset=0.2, - ) - - # Model prediction deviations from observations - self.ym = self.observation.y + np.array([1.0, -1.0, 0.0]) - self.delta = self.observation.y - self.ym - - # Initialize KnownModelError class - self.likelihood = UnknownModelError() - - # Free parameter: fractional uncorrelated error - self.frac_err = 0.312 - - # Expected covariance calculations - self.expected_covariance = ( - self.observation.statistical_covariance - + self.observation.systematic_offset_covariance - + self.observation.systematic_normalization_covariance - * np.outer(self.ym, self.ym) - + self.frac_err**2 * np.diag(0.5**2 * (self.ym + self.observation.y) ** 2) - ) - - # Expected chi-squared value - self.expected_chi2 = ( - self.delta.T @ np.linalg.inv(self.expected_covariance) @ self.delta - ) - - # Expected log-likelihood value - self.expected_log_likelihood = -0.5 * ( - self.expected_chi2 - + np.log(np.linalg.det(self.expected_covariance)) - + 3 * np.log(2 * np.pi) - ) - - def test_covariance(self): - cov = self.likelihood.covariance( - self.observation, self.ym, np.log(self.frac_err) - ) - self.assertEqual(cov.shape, (3, 3)) - np.testing.assert_array_almost_equal(cov, self.expected_covariance) - - def test_chi2(self): - chi2_value = self.likelihood.chi2( - self.observation, self.ym, np.log(self.frac_err) - ) - self.assertAlmostEqual(chi2_value, self.expected_chi2) - - def test_log_likelihood(self): - log_likelihood_value = self.likelihood.log_likelihood( - self.observation, self.ym, np.log(self.frac_err) - ) - self.assertAlmostEqual(log_likelihood_value, self.expected_log_likelihood) - - -class TestStudentTLikelihoodModel(unittest.TestCase): - def test_exposes_parametric_interface(self): - likelihood = StudentTLikelihoodModel() - self.assertEqual(likelihood.n_params, 1) - self.assertEqual(likelihood.params[0].name, "degrees_of_freedom") + def test_diagonal(self): + y = np.array([1.0, 2.0, 3.0]) + ym = np.array([1.1, 1.8, 3.2]) + cov = np.diag([0.1, 0.2, 0.3]) + d2, logdet = mahalanobis_distance_sqr_cholesky(y, ym, cov) + self.assertAlmostEqual(d2, np.sum((y - ym) ** 2 / np.diag(cov))) + self.assertAlmostEqual(logdet, np.log(np.prod(np.diag(cov)))) if __name__ == "__main__": diff --git a/test/test_observation.py b/test/test_observation.py index 8861774..8e92515 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -2,8 +2,9 @@ import numpy as np -from rxmc.observation import FixedCovarianceObservation, Observation -from rxmc.observation_from_measurement import set_up_observation +from helpers import make_ctx +from rxmc.covariance import ConstraintCovariance, RankOneTerm +from rxmc.observation import Observation class TestObservation(unittest.TestCase): @@ -15,6 +16,7 @@ def test_initialization(self): self.assertEqual(observation.n_data_pts, 3) np.testing.assert_array_equal(observation.x, x) np.testing.assert_array_equal(observation.y, y) + np.testing.assert_array_equal(observation.y_stat_err, np.zeros_like(y)) def test_invalid_initialization(self): x = np.array([1, 2, 3]) @@ -22,144 +24,123 @@ def test_invalid_initialization(self): with self.assertRaises(ValueError): Observation(x, y) - def test_statistical_covariance(self): - x = np.array([1, 2]) - y = np.array([2, 4]) - y_stat_err = np.array([0.1, 0.2]) - observation = Observation(x, y, y_stat_err=y_stat_err) - expected_covariance = np.diag(y_stat_err**2) - np.testing.assert_array_almost_equal( - observation.statistical_covariance, expected_covariance - ) - - def test_systematic_covariance(self): - x = np.array([1, 2]) - y = np.array([2, 4]) - y_stat_err = np.array([0.1, 0.2]) - y_sys_err_norm = 0.3 - y_sys_err_offset = 0.001 - observation = Observation( - x, - y, - y_stat_err=y_stat_err, - y_sys_err_normalization=y_sys_err_norm, - y_sys_err_offset=y_sys_err_offset, - ) - np.testing.assert_array_almost_equal( - observation.systematic_offset_covariance, - np.outer(np.ones_like(y), np.ones_like(y)) * y_sys_err_offset**2, - ) - np.testing.assert_array_almost_equal( - observation.systematic_normalization_covariance, - np.outer(np.ones_like(y), np.ones_like(y)) * y_sys_err_norm**2, - ) + def test_stat_err_shape_validation(self): + x = np.array([1, 2, 3]) + y = np.array([4, 5, 6]) + with self.assertRaises(ValueError): + Observation(x, y, y_stat_err=np.array([0.1, 0.2])) - def test_full_covariance(self): - x = np.array([1, 2]) - y = np.array([2, 4]) + def test_statistical_term_is_diagonal_variance(self): + x = np.array([1.0, 2.0]) + y = np.array([2.0, 4.0]) y_stat_err = np.array([0.1, 0.2]) - y_sys_err_norm = 0.3 - y_sys_err_offset = 0.001 - observation = Observation( - x, - y, - y_stat_err=y_stat_err, - y_sys_err_normalization=y_sys_err_norm, - y_sys_err_offset=y_sys_err_offset, - ) - expected_covariance = ( - np.diag(y_stat_err**2) - + np.outer(y, y) * y_sys_err_norm**2 - + np.outer(np.ones_like(y), np.ones_like(y)) * y_sys_err_offset**2 - ) - np.testing.assert_array_almost_equal( - observation.covariance(y), expected_covariance - ) - - def test_full_covariance_with_masks_offset_only(self): - x = np.array([1, 2, 3, 4]) - y = x**2 - y_stat_err = 0.119 * y - # first and last points have a shared err in offset of 1, - # no systematic error in offset for the other points - y_sys_err_offset = [0.331] - y_sys_err_offset_mask = [ - np.array([True, False, False, True]), - ] - # create the observation with the masks + observation = Observation(x, y, y_stat_err=y_stat_err) + support = np.arange(2) + term = observation.statistical_term(support) + Sigma = np.zeros((2, 2)) + term.add_to(Sigma, None, np.array([])) + np.testing.assert_array_almost_equal(Sigma, np.diag(y_stat_err**2)) + + def test_statistical_term_writes_into_support_block(self): + # an observation occupying the second block of a length-4 stack + x = np.array([1.0, 2.0]) + y = np.array([2.0, 4.0]) + y_stat_err = np.array([0.3, 0.4]) + observation = Observation(x, y, y_stat_err=y_stat_err) + support = np.array([2, 3]) + cov = ConstraintCovariance([observation.statistical_term(support)], N=4) + Sigma = cov.matrix(None) + expected = np.zeros((4, 4)) + expected[2, 2] = 0.3**2 + expected[3, 3] = 0.4**2 + np.testing.assert_array_almost_equal(Sigma, expected) + + def test_default_statistical_term_is_constant(self): observation = Observation( - x, - y, - y_stat_err=y_stat_err, - y_sys_err_offset=y_sys_err_offset, - y_sys_err_offset_mask=y_sys_err_offset_mask, - ) - expected_covariance = ( - # statistical error - np.diag(y_stat_err**2) - # systematic error in offset for first and last points - + np.outer(np.array([1, 0, 0, 1]), np.array([1, 0, 0, 1])) * 0.331**2 - ) - - np.testing.assert_array_almost_equal( - observation.covariance(y), expected_covariance - ) + np.array([1.0, 2.0]), np.array([2.0, 4.0]), y_stat_err=np.array([0.1, 0.2]) + ) + cov = ConstraintCovariance([observation.statistical_term(np.arange(2))], N=2) + self.assertTrue(cov.is_constant) + self.assertTrue(cov.block_diagonal) + self.assertEqual(cov.n_params, 0) + + def test_systematics_default_none_and_no_terms(self): + obs = Observation(np.array([1.0, 2.0]), np.array([2.0, 4.0])) + self.assertIsNone(obs.y_sys_err_normalization) + self.assertIsNone(obs.y_sys_err_offset) + self.assertEqual(obs.systematic_terms(np.arange(2)), []) + + def test_systematics_storage(self): + obs = Observation( + np.array([1.0, 2.0]), + np.array([2.0, 4.0]), + y_sys_err_normalization=0.03, + y_sys_err_offset=np.array([0.1, 0.2]), + ) + self.assertEqual(obs.y_sys_err_normalization, 0.03) + np.testing.assert_allclose(obs.y_sys_err_offset, [0.1, 0.2]) + # 0-d ndarrays count as scalars + obs2 = Observation( + np.array([1.0, 2.0]), + np.array([2.0, 4.0]), + y_sys_err_normalization=np.array(0.03), + ) + self.assertEqual(obs2.y_sys_err_normalization, 0.03) + + def test_systematics_bad_shape_raises(self): + with self.assertRaises(ValueError): + Observation( + np.array([1.0, 2.0, 3.0]), + np.array([2.0, 4.0, 6.0]), + y_sys_err_offset=np.array([0.1, 0.2]), + ) - def test_full_covariance_with_masks(self): - x = np.array([1, 2, 3, 4]) - y = x**2 - y_stat_err = 0.119 * y - # first two points have a shared 5% systematic error in normalization - # all points have a shared 10% systematic error in normalization - y_sys_err_norm = [0.05, 0.1] - y_sys_err_normalization_mask = [ - np.array([True, True, False, False]), - np.ones_like(y), - ] - # first and last points have a shared err in offset of 1, - # no systematic error in offset for the other points - y_sys_err_offset = [0.331] - y_sys_err_offset_mask = [ - np.array([True, False, False, True]), - ] - # create the observation with the masks - observation = Observation( - x, + def test_systematics_zero_magnitudes_skipped(self): + obs = Observation( + np.array([1.0, 2.0]), + np.array([2.0, 4.0]), + y_sys_err_normalization=0.0, + y_sys_err_offset=0, + ) + self.assertEqual(obs.systematic_terms(np.arange(2)), []) + + def test_systematic_terms_offset_then_normalization(self): + obs = Observation( + np.array([1.0, 2.0]), + np.array([2.0, 4.0]), + y_sys_err_normalization=0.05, + y_sys_err_offset=0.2, + ) + terms = obs.systematic_terms(np.arange(2)) + self.assertEqual(len(terms), 2) + self.assertTrue(all(isinstance(t, RankOneTerm) for t in terms)) + + def test_systematic_terms_recover_old_covariance(self): + # statistical_term + systematic_terms matches the old auto-folded + # Observation.covariance(ym) + y = np.array([1.0, 2.0, 4.0]) + ym = np.array([1.2, 2.1, 3.5]) + stat = np.array([0.1, 0.2, 0.3]) + norm_frac = 0.05 + offset = 0.2 + obs = Observation( + np.arange(3.0), y, - y_stat_err=y_stat_err, - y_sys_err_normalization=y_sys_err_norm, - y_sys_err_normalization_mask=y_sys_err_normalization_mask, - y_sys_err_offset=y_sys_err_offset, - y_sys_err_offset_mask=y_sys_err_offset_mask, - ) - expected_covariance = ( - # statistical error - np.diag(y_stat_err**2) - # systematic error in normalization - + np.outer(y, y) - * ( - # for all points - 0.1**2 - # plus for first two points - + np.outer(np.array([1, 1, 0, 0]), np.array([1, 1, 0, 0])) * 0.05**2 - ) - # systematic error in offset for first and last points - + np.outer(np.array([1, 0, 0, 1]), np.array([1, 0, 0, 1])) * 0.331**2 + y_stat_err=stat, + y_sys_err_normalization=norm_frac, + y_sys_err_offset=offset, ) - - np.testing.assert_array_almost_equal( - observation.covariance(y), expected_covariance + support = np.arange(3) + cov = ConstraintCovariance( + [obs.statistical_term(support), *obs.systematic_terms(support)], N=3 ) - - def test_residual(self): - x = np.array([1, 2]) - y = np.array([2, 4]) - ym = np.array([1.5, 3.5]) - observation = Observation(x, y) - expected_residual = y - ym - np.testing.assert_array_almost_equal( - observation.residual(ym), expected_residual + S = cov.matrix(make_ctx(np.arange(3.0), y, ym, [support])) + old = ( + np.diag(stat**2) + + np.outer(offset * np.ones(3), offset * np.ones(3)) + + norm_frac**2 * np.outer(ym, ym) ) + np.testing.assert_allclose(S, old) def test_num_pts_within_interval(self): x = np.array([1, 2, 3, 4]) @@ -180,67 +161,5 @@ def test_num_pts_within_interval_out(self): self.assertEqual(num_pts, 2) -class TestFixedCovarianceObservation(unittest.TestCase): - - def test_fixed_covariance_initialization(self): - x = np.array([1, 2, 3]) - y = np.array([4, 5, 6]) - covariance = np.array([0.1, 0.2, 0.3]) - obs = FixedCovarianceObservation(x, y, covariance) - expected_covariance = np.diag(covariance) - np.testing.assert_array_almost_equal(obs.cov, expected_covariance) - - def test_fixed_covariance_initialization_general(self): - x = np.array([1, 2, 3]) - y = np.array([4, 5, 6]) - covariance = np.diag([1, 1, 1]) - obs = FixedCovarianceObservation(x, y, covariance) - np.testing.assert_array_almost_equal(obs.cov, covariance) - - def test_invalid_fixed_covariance(self): - x = np.array([1, 2]) - y = np.array([3, 4]) - covariance = np.array([0.1, 0.2, 0.3]) - with self.assertRaises(ValueError): - FixedCovarianceObservation(x, y, covariance) - - def test_covariance_method(self): - x = np.array([1, 2]) - y = np.array([3, 4]) - covariance = np.array([0.1, 0.2]) - obs = FixedCovarianceObservation(x, y, covariance) - np.testing.assert_array_almost_equal(obs.covariance(y), np.diag(covariance)) - - -class TestSetUpObservation(unittest.TestCase): - - def test_scalar_like_offset_error_supported(self): - x = np.array([1.0, 2.0]) - y = np.array([3.0, 4.0]) - normalization = np.ones_like(y) - args, kwargs, _ = set_up_observation( - Observation, - y=y, - normalization=normalization, - x=x, - y_sys_err_offset=np.array(0.1), - ) - np.testing.assert_array_equal(args[0], x) - self.assertEqual(kwargs["y_sys_err_offset"], 0.1) - - def test_scalar_like_normalization_error_supported(self): - x = np.array([1.0, 2.0]) - y = np.array([3.0, 4.0]) - normalization = np.ones_like(y) - _, kwargs, _ = set_up_observation( - Observation, - y=y, - normalization=normalization, - x=x, - y_sys_err_normalization=np.array(0.05), - ) - self.assertEqual(kwargs["y_sys_err_normalization"], 0.05) - - if __name__ == "__main__": unittest.main() diff --git a/test/test_predictive.py b/test/test_predictive.py new file mode 100644 index 0000000..6f8a6e1 --- /dev/null +++ b/test/test_predictive.py @@ -0,0 +1,200 @@ +"""Tests for the predictive-uncertainty helpers (:mod:`rxmc.predictive`).""" + +import unittest + +import numpy as np +from sklearn.gaussian_process import GaussianProcessRegressor +from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel + +from rxmc.predictive import ( + _gp_posterior_mean_var, + gp_posterior_predictive, + predictive_band, + total_predictive_band, +) + + +def make_kernel(): + return ConstantKernel(1.0) * RBF(length_scale=0.7) + WhiteKernel(1e-6) + + +class TestGPPosteriorPredictive(unittest.TestCase): + def setUp(self): + rng = np.random.default_rng(0) + self.X_train = np.sort(rng.uniform(-2, 2, 12)) + self.residuals = np.sin(self.X_train) + 0.05 * rng.standard_normal(12) + self.X_pred = np.linspace(-2.5, 2.5, 25) + self.kernel = make_kernel() + self.theta = self.kernel.theta # log-space + + def test_matches_sklearn_gpr(self): + noise_var = 0.01 + # sklearn GPR with the SAME fixed kernel (no hyperparameter optimisation) + gpr = GaussianProcessRegressor( + kernel=self.kernel.clone_with_theta(self.theta), + optimizer=None, + alpha=noise_var, + normalize_y=False, + ) + gpr.fit(self.X_train[:, None], self.residuals) + mean_sk, cov_sk = gpr.predict(self.X_pred[:, None], return_cov=True) + + mean, cov = gp_posterior_predictive( + self.kernel, + self.theta, + self.X_train, + self.residuals, + self.X_pred, + train_noise_var=noise_var, + ) + np.testing.assert_allclose(mean, mean_sk, atol=1e-6) + np.testing.assert_allclose(cov, cov_sk, atol=1e-6) + + def test_noiseless_interpolation(self): + # a noiseless kernel (no WhiteKernel) interpolates the residuals exactly + kernel = ConstantKernel(1.0) * RBF(length_scale=0.7) + mean, cov = gp_posterior_predictive( + kernel, + kernel.theta, + self.X_train, + self.residuals, + self.X_train, + train_noise_var=0.0, + jitter=1e-10, + ) + # exact interpolation up to numerical conditioning of the Gram matrix + np.testing.assert_allclose(mean, self.residuals, atol=5e-3) + self.assertLess(np.max(np.abs(np.diag(cov))), 1e-3) + + def test_2d_inputs(self): + rng = np.random.default_rng(1) + Xtr = rng.uniform(-1, 1, (8, 2)) + r = rng.standard_normal(8) + Xp = rng.uniform(-1, 1, (5, 2)) + kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) + mean, cov = gp_posterior_predictive(kernel, kernel.theta, Xtr, r, Xp) + self.assertEqual(mean.shape, (5,)) + self.assertEqual(cov.shape, (5, 5)) + + +class TestPredictiveBand(unittest.TestCase): + def test_percentiles(self): + draws = np.arange(101)[:, None] * np.ones((1, 3)) # 0..100 on each column + band = predictive_band(draws, levels=(16, 50, 84)) + self.assertEqual(band.shape, (3, 3)) + np.testing.assert_allclose(band[1], [50, 50, 50]) + np.testing.assert_allclose(band[0], [16, 16, 16]) + np.testing.assert_allclose(band[2], [84, 84, 84]) + + +class TestTotalPredictiveBand(unittest.TestCase): + def test_shape_and_finite(self): + rng = np.random.default_rng(2) + kernel = make_kernel() + + def mean_fn(x, m, b): + return m * x + b + + x_train = np.linspace(0, 1, 10) + y_train = 0.5 * x_train + 0.2 + np.sin(3 * x_train) + x_pred = np.linspace(-0.2, 1.2, 30) + + n_kparams = len(kernel.theta) + n_model = 2 + # fake posterior chain: [m, b, *log_theta] + chain = np.column_stack( + [ + 0.5 + 0.05 * rng.standard_normal(50), + 0.2 + 0.05 * rng.standard_normal(50), + np.tile(kernel.theta, (50, 1)), + ] + ) + self.assertEqual(chain.shape[1], n_model + n_kparams) + + band = total_predictive_band( + mean_fn, + kernel, + x_train, + y_train, + x_pred, + chain, + n_model, + noise_std=0.05, + levels=(16, 84), + n_draws=40, + rng=rng, + ) + self.assertEqual(band.shape, (2, len(x_pred))) + self.assertTrue(np.all(np.isfinite(band))) + self.assertTrue(np.all(band[1] >= band[0])) + + def _mean_fn(self, x, m, b): + return m * x + b + + def test_raises_on_kernel_theta_width_mismatch(self): + kernel = make_kernel() + n_theta = len(kernel.theta) + x_train = np.linspace(0, 1, 8) + y_train = 0.5 * x_train + 0.2 + # an EXTRA nuisance column beyond the kernel theta -> ambiguous trailing slice + chain = np.zeros((10, 2 + n_theta + 1)) + chain[:, 2 : 2 + n_theta] = kernel.theta + with self.assertRaises(ValueError): + total_predictive_band( + self._mean_fn, + kernel, + x_train, + y_train, + np.linspace(0, 1, 5), + chain, + 2, + noise_std=0.05, + n_draws=5, + rng=np.random.default_rng(0), + ) + + def test_explicit_theta_cols(self): + kernel = make_kernel() + n_theta = len(kernel.theta) + x_train = np.linspace(0, 1, 8) + y_train = 0.5 * x_train + 0.2 + # layout: [m, b, log_eps, *kernel_theta]; kernel theta is NOT the only tail + chain = np.zeros((10, 2 + 1 + n_theta)) + chain[:, 3:] = kernel.theta + theta_cols = np.arange(3, 3 + n_theta) + band = total_predictive_band( + self._mean_fn, + kernel, + x_train, + y_train, + np.linspace(0, 1, 5), + chain, + 2, + theta_cols=theta_cols, + noise_std=0.05, + n_draws=5, + rng=np.random.default_rng(0), + ) + self.assertEqual(band.shape, (2, 5)) + self.assertTrue(np.all(np.isfinite(band))) + + +class TestDiagonalMeanVar(unittest.TestCase): + def test_matches_full_covariance_diagonal(self): + rng = np.random.default_rng(4) + kernel = make_kernel() + X_train = np.sort(rng.uniform(-2, 2, 10)) + residuals = np.sin(X_train) + X_pred = np.linspace(-2.5, 2.5, 20) + mean_full, cov_full = gp_posterior_predictive( + kernel, kernel.theta, X_train, residuals, X_pred, train_noise_var=0.01 + ) + mean, var = _gp_posterior_mean_var( + kernel, kernel.theta, X_train, residuals, X_pred, train_noise_var=0.01 + ) + np.testing.assert_allclose(mean, mean_full, atol=1e-9) + np.testing.assert_allclose(var, np.diag(cov_full), atol=1e-9) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_reaction_models.py b/test/test_reaction_models.py new file mode 100644 index 0000000..aae6ae3 --- /dev/null +++ b/test/test_reaction_models.py @@ -0,0 +1,120 @@ +"""Real-solver smoke tests for the jitr-backed reaction models. + +These are the only tests that exercise the actual solver pipeline +(everything else mocks ``set_up_solver``); they pin output shape, +finiteness, and positivity with deliberately small solver settings. +""" + +import unittest + +import jitr +import numpy as np +from jitr.optical_potentials.potential_forms import ( + coulomb_charged_sphere, + thomas_safe, + woods_saxon_safe, +) + +from rxmc.elastic_diffxs_model import ElasticDifferentialXSModel +from rxmc.elastic_diffxs_observation import ElasticDifferentialXSObservation +from rxmc.ias_pn_model import IsobaricAnalogPNXSModel +from rxmc.ias_pn_observation import IsobaricAnalogPNObservation +from rxmc.params import Parameter + +MSO = 1.0 / jitr.utils.constants.WAVENUMBER_PION + + +def central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + +def spin_orbit(r, Vso, Rso, aso): + return Vso * MSO**2 * thomas_safe(r, Rso, aso) + + +class TestElasticDifferentialXSModel(unittest.TestCase): + def test_evaluate_and_visualization_smoke(self): + R = 1.2 * 40 ** (1 / 3) + rxn = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) + model = ElasticDifferentialXSModel( + "dXS/dA", + interaction_central=central, + interaction_spin_orbit=spin_orbit, + calculate_interaction_from_params=lambda ws, *x: ( + tuple(x), + (6.0, R, 0.45), + ), + params=[Parameter(n) for n in ("Vv", "Wv", "Rv", "av")], + ) + obs = ElasticDifferentialXSObservation( + x=np.linspace(10.0, 150.0, 6), + y=np.ones(6), + Elab=14.1, + reaction=rxn, + quantity="dXS/dA", + measurement_quantity="dXS/dA", + y_units="barn / steradian", + lmax=10, + ) + + y = model.evaluate(obs, 48.0, 3.5, R, 0.7) + self.assertEqual(y.shape, (obs.n_data_pts,)) + self.assertTrue(np.all(np.isfinite(y))) + self.assertTrue(np.all(y > 0)) + + y_vis = model.visualizable_model_prediction(obs, 48.0, 3.5, R, 0.7) + self.assertEqual(y_vis.shape, obs.visualization_workspace.angles.shape) + self.assertTrue(np.all(np.isfinite(y_vis))) + + +class TestIsobaricAnalogPNXSModel(unittest.TestCase): + def test_evaluate_and_visualization_smoke(self): + A, Z = 48, 20 + R = 1.2 * A ** (1 / 3) + rxn = jitr.reactions.Reaction( + target=(A, Z), + projectile=(1, 1), + product=(1, 0), + residual=(A, Z + 1), + ) + model = IsobaricAnalogPNXSModel( + U_p_coulomb=coulomb_charged_sphere, + U_p_central=central, + U_p_spin_orbit=spin_orbit, + U_n_central=central, + U_n_spin_orbit=spin_orbit, + # the (p,n) IAS transition is driven by the *difference* between + # the proton and neutron potentials (the Lane term) — make them + # distinct or the cross section vanishes + calculate_params=lambda ws, Vv, Wv, Rv, av: ( + (Z, R), # p Coulomb: zz product, charge radius + (Vv + 4.0, Wv, Rv, av), # p central + (6.0, R, 0.45), # p spin-orbit + (Vv - 4.0, Wv, Rv, av), # n central + (6.0, R, 0.45), # n spin-orbit + ), + params=[Parameter(n) for n in ("Vv", "Wv", "Rv", "av")], + ) + obs = IsobaricAnalogPNObservation( + x=np.linspace(10.0, 150.0, 5), + y=np.ones(5), + Elab=25.0, + reaction=rxn, + ExIAS=6.7, + y_units="barn / steradian", + lmax=10, + ) + + y = model.evaluate(obs, 48.0, 3.5, R, 0.7) + self.assertEqual(y.shape, (obs.n_data_pts,)) + self.assertTrue(np.all(np.isfinite(y))) + self.assertTrue(np.all(y >= 0)) + self.assertGreater(y.max(), 0) + + y_vis = model.visualizable_model_prediction(obs, 48.0, 3.5, R, 0.7) + self.assertEqual(y_vis.shape, obs.visualization_workspace.angles.shape) + self.assertTrue(np.all(np.isfinite(y_vis))) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_reaction_observation.py b/test/test_reaction_observation.py index 73ec4ad..5c90e6e 100644 --- a/test/test_reaction_observation.py +++ b/test/test_reaction_observation.py @@ -6,6 +6,7 @@ from rxmc.elastic_diffxs_observation import ElasticDifferentialXSObservation from rxmc.ias_pn_observation import IsobaricAnalogPNObservation +from rxmc.observation import Observation class DummyElasticWorkspace: @@ -35,15 +36,17 @@ def test_direct_construction_from_explicit_data(self, mock_set_up_solver): measurement_quantity="dXS/dA", y_units="barn / steradian", y_stat_err=y_stat_err, - y_sys_err_normalization=0.05, - y_sys_err_offset=0.01, dataset_label="mock-elastic", ) + # it IS an Observation (statistical error only); systematics are composed + # as Constraint extra_terms by the caller + self.assertIsInstance(obs, Observation) np.testing.assert_allclose(obs.x, np.deg2rad(angles_deg)) np.testing.assert_allclose(obs.y, y) np.testing.assert_allclose(obs.y_stat_err, y_stat_err) self.assertEqual(obs.subentry, "mock-elastic") + self.assertIsNotNone(obs.statistical_term(np.arange(obs.n_data_pts))) @patch("rxmc.elastic_diffxs_observation.set_up_solver") def test_from_measurement_construction(self, mock_set_up_solver): @@ -75,6 +78,143 @@ def test_from_measurement_construction(self, mock_set_up_solver): np.testing.assert_allclose(obs.y, measurement.y) np.testing.assert_allclose(obs.y_stat_err, measurement.statistical_err) self.assertEqual(obs.subentry, "elastic-subentry") + # systematics are retained as inert metadata (norm == 1 here: b/sr) + self.assertEqual(obs.norm, 1.0) + self.assertEqual(obs.y_sys_err_normalization, 0.03) + self.assertEqual(obs.y_sys_err_offset, 0.02) + self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) + + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_from_measurement_rutherford_array_norm(self, mock_set_up_solver): + # dXS/dRuth requested from a dXS/dA measurement: norm is the per-angle + # Rutherford cross section, so the absolute offset error becomes a + # per-angle array in internal units, while the fractional normalization + # error is untouched + rutherford = np.array([2000.0, 500.0]) # mb/sr + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(rutherford=rutherford), + DummyElasticWorkspace(rutherford=rutherford), + object(), + ) + + measurement = SimpleNamespace( + x=np.array([20.0, 40.0]), + y=np.array([1800.0, 300.0]), + Einc=8.0, + quantity="dXS/dA", + y_units="mb/sr", + statistical_err=np.array([20.0, 10.0]), + systematic_norm_err=np.array(0.03), # 0-d, as exfor_tools stores it + systematic_offset_err=5.0, # mb/sr + subentry="ruth-subentry", + ) + + obs = ElasticDifferentialXSObservation.from_measurement( + measurement=measurement, + reaction=object(), + quantity="dXS/dRuth", + ) + + np.testing.assert_allclose(obs.norm, rutherford) + np.testing.assert_allclose(obs.y, measurement.y / rutherford) + np.testing.assert_allclose( + obs.y_stat_err, measurement.statistical_err / rutherford + ) + np.testing.assert_allclose(obs.y_sys_err_offset, 5.0 / rutherford) + self.assertEqual(obs.y_sys_err_normalization, 0.03) + + # reaction-level regression: statistical + systematic terms recover the + # old auto-folded covariance, in internal (normalized) units + support = np.arange(2) + from helpers import make_ctx + from rxmc.covariance import ConstraintCovariance + + ym = np.array([0.9, 0.6]) + cov = ConstraintCovariance( + [obs.statistical_term(support), *obs.systematic_terms(support)], N=2 + ) + S = cov.matrix(make_ctx(obs.x, obs.y, ym, [support])) + omega = 5.0 / rutherford + old = ( + np.diag((measurement.statistical_err / rutherford) ** 2) + + np.outer(omega, omega) + + 0.03**2 * np.outer(ym, ym) + ) + np.testing.assert_allclose(S, old) + + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_dxsda_from_dxsdruth_conversion(self, mock_set_up_solver): + # the inverse branch: absolute dXS/dA requested from a Rutherford-ratio + # measurement; norm = (1/mb->b) / rutherford, so obs.y is b/sr + rutherford = np.array([2000.0, 500.0]) # mb/sr + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(rutherford=rutherford), + DummyElasticWorkspace(rutherford=rutherford), + object(), + ) + + y_ratio = np.array([0.9, 0.6]) # dimensionless dXS/dRuth + obs = ElasticDifferentialXSObservation( + x=np.array([20.0, 40.0]), + y=y_ratio, + Elab=8.0, + reaction=object(), + quantity="dXS/dA", + measurement_quantity="dXS/dRuth", + y_units="no-dim", + ) + + np.testing.assert_allclose(obs.norm, 1000.0 / rutherford) + # y_ratio * rutherford[mb/sr] / 1000 = absolute xs in b/sr + np.testing.assert_allclose(obs.y, y_ratio * rutherford / 1000.0) + + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_incompatible_units_raise(self, mock_set_up_solver): + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(), + DummyElasticWorkspace(), + object(), + ) + # dXS/dA measurement with non-cross-section units + with self.assertRaises(ValueError): + ElasticDifferentialXSObservation( + x=np.array([15.0, 30.0]), + y=np.array([1.0, 0.5]), + Elab=12.0, + reaction=object(), + quantity="dXS/dA", + measurement_quantity="dXS/dA", + y_units="MeV", + ) + # dimensionless quantity with dimensionful units + with self.assertRaises(ValueError): + ElasticDifferentialXSObservation( + x=np.array([15.0, 30.0]), + y=np.array([1.0, 0.5]), + Elab=12.0, + reaction=object(), + quantity="Ay", + measurement_quantity="Ay", + y_units="mb/sr", + ) + + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_quantity_mismatch_raises(self, mock_set_up_solver): + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(), + DummyElasticWorkspace(), + object(), + ) + with self.assertRaises(ValueError): + ElasticDifferentialXSObservation( + x=np.array([15.0, 30.0]), + y=np.array([1.0, 0.5]), + Elab=12.0, + reaction=object(), + quantity="Ay", + measurement_quantity="dXS/dA", + y_units="barn / steradian", + ) class TestIsobaricAnalogPNObservation(unittest.TestCase): @@ -94,11 +234,10 @@ def test_direct_construction_from_explicit_data(self, mock_set_up_solver): ExIAS=5.0, y_units="barn / steradian", y_stat_err=y_stat_err, - y_sys_err_normalization=0.04, - y_sys_err_offset=0.01, dataset_label="mock-ias", ) + self.assertIsInstance(obs, Observation) np.testing.assert_allclose(obs.x, np.deg2rad(angles_deg)) np.testing.assert_allclose(obs.y, y) np.testing.assert_allclose(obs.y_stat_err, y_stat_err) @@ -129,6 +268,33 @@ def test_from_measurement_construction(self, mock_set_up_solver): np.testing.assert_allclose(obs.y, measurement.y) np.testing.assert_allclose(obs.y_stat_err, measurement.statistical_err) self.assertEqual(obs.subentry, "ias-subentry") + # systematics retained; norm == 1 (measurement already in b/sr) + self.assertEqual(obs.norm, 1.0) + self.assertEqual(obs.y_sys_err_normalization, 0.02) + self.assertEqual(obs.y_sys_err_offset, 0.01) + self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) + + @patch("rxmc.ias_pn_observation.set_up_solver") + def test_unit_conversion_divides_offset_not_normalization(self, mock_set_up_solver): + mock_set_up_solver.return_value = (object(), object(), object(), object()) + + obs = IsobaricAnalogPNObservation( + x=np.array([5.0, 15.0]), + y=np.array([900.0, 700.0]), + Elab=18.0, + reaction=object(), + ExIAS=4.5, + y_units="millibarn / steradian", + y_stat_err=np.array([80.0, 70.0]), + y_sys_err_normalization=0.02, + y_sys_err_offset=10.0, + ) + # mb -> b: norm = 1000 + self.assertEqual(obs.norm, 1000.0) + np.testing.assert_allclose(obs.y, [0.9, 0.7]) + np.testing.assert_allclose(obs.y_stat_err, [0.08, 0.07]) + self.assertAlmostEqual(obs.y_sys_err_offset, 0.01) + self.assertEqual(obs.y_sys_err_normalization, 0.02) if __name__ == "__main__": diff --git a/test/test_regression.py b/test/test_regression.py new file mode 100644 index 0000000..b7b5548 --- /dev/null +++ b/test/test_regression.py @@ -0,0 +1,141 @@ +""" +Regression pins for the deliberate behaviour change of the covariance refactor. + +The old default covariance silently folded a dataset's normalisation/offset +systematics into ``Observation.covariance``. The new default is **statistical +only**; those systematics must be stated explicitly as covariance +:class:`~rxmc.covariance.Term` s. These tests pin: + +1. the before/after log-posterior gap (the default changed), and +2. that re-adding the explicit terms exactly recovers the old number. + +They also pin the block-diagonal fast path against a dense Cholesky and a genuine +case-A cross-dataset coupling, so the new capabilities are recorded. +""" + +import unittest + +import numpy as np + +from helpers import manual_mvn_loglike as manual_mvn +from rxmc.constraint import Constraint +from rxmc.covariance import normalization_term, offset_term +from rxmc.observation import Observation +from rxmc.physical_model import Polynomial + + +class TestSystematicDefaultBehaviourChange(unittest.TestCase): + """systematic_err_demo / normalization_inference behaviour change.""" + + def setUp(self): + self.x = np.array([1.0, 2.0, 3.0, 4.0]) + self.y = np.array([2.1, 3.9, 6.2, 7.8]) + self.stat = np.array([0.1, 0.15, 0.2, 0.25]) + self.norm = 0.05 # fractional normalisation systematic + self.offset = 0.02 # absolute offset systematic + self.obs = Observation(self.x, self.y, y_stat_err=self.stat) + self.pm = Polynomial(order=1) + self.model_params = (0.2, 1.9) + self.ym = self.pm.evaluate(self.obs, *self.model_params) + + # the matrix the OLD Observation.covariance(ym) produced + ones = np.ones(4) + self.old_cov = ( + np.diag(self.stat**2) + + np.outer(self.offset * ones, self.offset * ones) + + np.outer(self.norm * ones, self.norm * ones) * np.outer(self.ym, self.ym) + ) + + def test_old_value(self): + # pinned old log-likelihood (auto-included systematics) + old = manual_mvn(self.y, self.ym, self.old_cov) + self.assertAlmostEqual(old, 1.195784087817536, places=9) + + def test_new_default_is_statistical_only_and_differs(self): + c = Constraint([self.obs], self.pm) + new_default = c.log_likelihood(self.model_params) + stat_only = manual_mvn(self.y, self.ym, np.diag(self.stat**2)) + self.assertAlmostEqual(new_default, stat_only) + # the default genuinely changed + old = manual_mvn(self.y, self.ym, self.old_cov) + self.assertNotAlmostEqual(new_default, old) + + def test_explicit_terms_recover_old_value(self): + support = np.arange(4) + c = Constraint( + [self.obs], + self.pm, + extra_terms=[ + offset_term(support, magnitude=self.offset), + normalization_term(support, magnitude=self.norm), + ], + ) + recovered = c.log_likelihood(self.model_params) + old = manual_mvn(self.y, self.ym, self.old_cov) + self.assertAlmostEqual(recovered, old) + + +class TestBlockDiagonalFastPathEquivalence(unittest.TestCase): + """The block-diagonal fast path equals a dense Cholesky over the full stack.""" + + def test_multi_block_matches_dense(self): + pm = Polynomial(order=1) + mp = (0.3, 1.1) + obs = [ + Observation( + np.array([1.0, 2.0]), + np.array([1.5, 2.4]), + y_stat_err=np.array([0.1, 0.2]), + ), + Observation( + np.array([3.0, 4.0, 5.0]), + np.array([3.2, 4.5, 5.9]), + y_stat_err=np.array([0.2, 0.1, 0.3]), + ), + Observation(np.array([6.0]), np.array([7.1]), y_stat_err=np.array([0.15])), + ] + c = Constraint(obs, pm) + self.assertTrue(c.covariance.block_diagonal) + fast = c.log_likelihood(mp) + + y = np.concatenate([o.y for o in obs]) + ym = np.concatenate([pm.evaluate(o, *mp) for o in obs]) + stat = np.concatenate([o.y_stat_err for o in obs]) + dense = manual_mvn(y, ym, np.diag(stat**2)) + self.assertAlmostEqual(fast, dense, places=10) + + +class TestCaseACrossDatasetCorrelation(unittest.TestCase): + """A correlated systematic shared across two datasets (case A).""" + + def test_off_diagonal_blocks_present_and_changes_likelihood(self): + pm = Polynomial(order=1) + mp = (0.5, 1.0) + obs1 = Observation( + np.array([1.0, 2.0]), np.array([1.6, 2.9]), y_stat_err=np.array([0.1, 0.1]) + ) + obs2 = Observation( + np.array([3.0, 4.0]), np.array([3.4, 4.6]), y_stat_err=np.array([0.1, 0.1]) + ) + + from rxmc.params import Parameter + + eta = Parameter("log eta") + coupling = normalization_term(np.arange(4), parameter=eta) + c = Constraint([obs1, obs2], pm, extra_terms=[coupling]) + + # the assembled Sigma has non-zero cross-block (off-diagonal) entries + ym = np.concatenate([pm.evaluate(obs1, *mp), pm.evaluate(obs2, *mp)]) + ctx = c._stack(mp) + Sigma = c.covariance.matrix(ctx, np.log(0.1)) + self.assertFalse(c.covariance.block_diagonal) + self.assertGreater(abs(Sigma[0, 2]), 0.0) + + # and it equals the explicit dense form + cov = np.diag(np.full(4, 0.1**2)) + 0.1**2 * np.outer(ym, ym) + expected = manual_mvn(np.concatenate([obs1.y, obs2.y]), ym, cov) + self.assertAlmostEqual(c.log_likelihood(mp, (np.log(0.1),)), expected) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_sampler.py b/test/test_sampler.py index 9aa030e..c42add4 100644 --- a/test/test_sampler.py +++ b/test/test_sampler.py @@ -5,8 +5,8 @@ from rxmc.adaptive_metropolis import adaptive_metropolis from rxmc.constraint import Constraint +from rxmc.covariance import Term from rxmc.evidence import Evidence -from rxmc.likelihood_model import ParametricLikelihoodModel from rxmc.observation import Observation from rxmc.param_sampling import AdaptiveMetropolisSampler, MetropolisHastingsSampler from rxmc.params import Parameter @@ -15,24 +15,20 @@ from rxmc.walker import Walker -class TwoParameterLikelihood(ParametricLikelihoodModel): - def __init__(self): - super().__init__( - [ - Parameter("log noise floor", float), - Parameter("log noise slope", float), - ] +class FloorSlopeNoiseTerm(Term): + """diag((exp(floor) + exp(slope)*|ym|)**2) — a two-parameter noise term.""" + + def __init__(self, support): + self.support = np.asarray(support, dtype=int) + self.params = ( + Parameter("log noise floor", float), + Parameter("log noise slope", float), ) - def covariance( - self, - observation: Observation, - ym: np.ndarray, - log_noise_floor: float, - log_noise_slope: float, - ) -> np.ndarray: - sigma = np.exp(log_noise_floor) + np.exp(log_noise_slope) * np.abs(ym) - return np.diag(sigma**2) + def add_to(self, Sigma, ctx, theta): + ym = ctx.ym[self.support] + sigma = np.exp(theta[0]) + np.exp(theta[1]) * np.abs(ym) + Sigma[self.support, self.support] += sigma**2 class TestAdaptiveMetropolisSampler(unittest.TestCase): @@ -97,16 +93,13 @@ def test_walk_runs_end_to_end_with_multi_parameter_likelihood(self): y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), ) - likelihood = TwoParameterLikelihood() - evidence = Evidence( - parametric_constraints=[ - Constraint( - observations=[observation], - physical_model=model, - likelihood_model=likelihood, - ) - ] + noise_term = FloorSlopeNoiseTerm(np.arange(observation.n_data_pts)) + constraint = Constraint( + observations=[observation], + physical_model=model, + extra_terms=[noise_term], ) + evidence = Evidence(constraints=[constraint]) model_sampler = MetropolisHastingsSampler( params=model.params, @@ -115,7 +108,7 @@ def test_walk_runs_end_to_end_with_multi_parameter_likelihood(self): proposal=NormalProposalDistribution(0.01 * np.eye(2)), ) likelihood_sampler = MetropolisHastingsSampler( - params=likelihood.params, + params=list(constraint.params), prior=scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)), starting_location=np.array([-2.0, -2.0]), proposal=NormalProposalDistribution(0.01 * np.eye(2)), @@ -134,6 +127,100 @@ def test_walk_runs_end_to_end_with_multi_parameter_likelihood(self): self.assertEqual(walker.model_sampler.state.shape, (2,)) self.assertEqual(walker.likelihood_samplers[0].state.shape, (2,)) + def test_gibbs_conditional_applies_evidence_weight(self): + from types import SimpleNamespace + + model = Polynomial(1) + observation = Observation( + x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), + y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), + y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), + ) + constraint = Constraint( + observations=[observation], + physical_model=model, + extra_terms=[FloorSlopeNoiseTerm(np.arange(observation.n_data_pts))], + ) + weight = 2.5 + evidence = Evidence(constraints=[constraint], weights=np.array([weight])) + + prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) + + class CapturingSampler: + def __init__(self, params, prior): + self.params = params + self.prior = prior + self.captured = None + + def sample(self, n_steps, x0, rng, log_posterior, burn=False): + self.captured = log_posterior + + lm_sampler = CapturingSampler(list(constraint.params), prior) + walker = Walker( + model_sampler=SimpleNamespace(params=evidence.model_params, prior=prior), + evidence=evidence, + likelihood_samplers=[lm_sampler], + ) + + model_params = (0.9, 1.0) + walker.run_likelihood_batches(1, [np.array([-2.0, -2.0])], model_params) + + x = np.array([-2.0, -2.0]) + ym = constraint.predict(*model_params) + expected = float( + prior.logpdf(x) + weight * constraint.marginal_log_likelihood(ym, *x) + ) + self.assertAlmostEqual(lm_sampler.captured(x), expected) + + +class TestWalkerValidation(unittest.TestCase): + def setUp(self): + from types import SimpleNamespace + + self.SimpleNamespace = SimpleNamespace + self.model = Polynomial(1) + obs = Observation( + x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), + y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), + y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), + ) + self.parametric = Constraint( + observations=[obs], + physical_model=self.model, + extra_terms=[FloorSlopeNoiseTerm(np.arange(obs.n_data_pts))], + ) + self.evidence = Evidence(constraints=[self.parametric]) + self.prior = scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)) + + def _sampler(self, params): + return self.SimpleNamespace(params=list(params), prior=self.prior) + + def test_mismatched_model_params_raise(self): + with self.assertRaises(ValueError): + Walker( + model_sampler=self._sampler(self.model.params[:1]), + evidence=self.evidence, + likelihood_samplers=[self._sampler(self.parametric.params)], + ) + + def test_sampler_count_mismatch_raises(self): + with self.assertRaises(ValueError): + Walker( + model_sampler=self._sampler(self.evidence.model_params), + evidence=self.evidence, + likelihood_samplers=[], + ) + + def test_mismatched_likelihood_params_raise(self): + from rxmc.params import Parameter + + with self.assertRaises(ValueError): + Walker( + model_sampler=self._sampler(self.evidence.model_params), + evidence=self.evidence, + likelihood_samplers=[self._sampler([Parameter("wrong name")])], + ) + if __name__ == "__main__": unittest.main() From 73a6c09a51feb30a78566f1dbf9301f79d50afe1 Mon Sep 17 00:00:00 2001 From: beykyle Date: Mon, 10 Aug 2026 23:21:13 -0400 Subject: [PATCH 02/24] Port and extend example notebooks for the Term API Port all notebooks to the Term-based covariance API and extend coverage: new measurement_to_calibration (EXFOR-shaped measurement to calibrated potential, unit contract, guardrails) and robust_likelihoods (Student-t vs Gaussian) notebooks; error-model catalog completed with noise_term and offset_term options; likelihood_scaling/weights equivalence; shared systematics across real cross-section datasets (case A); GP model discrepancy on a differential cross section. Notebooks use the stacked_supports helper and no longer write PDF artifacts on execution. Co-Authored-By: Claude Fable 5 --- .../30s_optical_potential_calibration.ipynb | 4 +- .../calibration_config_emcee_dynesty.ipynb | 12 +- examples/correlated_observations.ipynb | 783 +++ examples/gp_discrepancy.ipynb | 974 ++++ examples/linear_calibration_demo.ipynb | 1270 +++-- examples/measurement_to_calibration.ipynb | 619 ++ examples/normalization_inference.ipynb | 1555 ++++- examples/overconfidence.ipynb | 837 ++- examples/robust_likelihoods.ipynb | 481 ++ examples/sampling_algos.ipynb | 25 +- examples/systematic_err_demo.ipynb | 5001 ++++++++++++++--- 11 files changed, 9708 insertions(+), 1853 deletions(-) create mode 100644 examples/correlated_observations.ipynb create mode 100644 examples/gp_discrepancy.ipynb create mode 100644 examples/measurement_to_calibration.ipynb create mode 100644 examples/robust_likelihoods.ipynb diff --git a/examples/30s_optical_potential_calibration.ipynb b/examples/30s_optical_potential_calibration.ipynb index ca9ba50..ddd5060 100644 --- a/examples/30s_optical_potential_calibration.ipynb +++ b/examples/30s_optical_potential_calibration.ipynb @@ -212,7 +212,7 @@ "constraint = rxmc.constraint.Constraint(\n", " observations=[obs],\n", " physical_model=omp,\n", - " likelihood_model=rxmc.likelihood_model.LikelihoodModel(),\n", + " likelihood=rxmc.likelihood_model.GaussianLikelihood(),\n", ")\n", "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", "\n", @@ -494,4 +494,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/calibration_config_emcee_dynesty.ipynb b/examples/calibration_config_emcee_dynesty.ipynb index 1583612..c0e6d15 100644 --- a/examples/calibration_config_emcee_dynesty.ipynb +++ b/examples/calibration_config_emcee_dynesty.ipynb @@ -249,7 +249,7 @@ "constraint = rxmc.constraint.Constraint(\n", " observations=[obs],\n", " physical_model=omp,\n", - " likelihood_model=rxmc.likelihood_model.LikelihoodModel(),\n", + " likelihood=rxmc.likelihood_model.GaussianLikelihood(),\n", ")\n", "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", "\n", @@ -282,7 +282,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 5000/5000 [05:03<00:00, 16.47it/s]\n" + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [05:03<00:00, 16.47it/s]\n" ] } ], @@ -419,7 +419,7 @@ "output_type": "stream", "text": [ "Posterior samples: 3013\n", - "log Z = 119.43 ± 0.38\n", + "log Z = 119.43 \u00b1 0.38\n", "Efficiency: 4.70 %\n" ] } @@ -429,7 +429,7 @@ "flat_dynesty = results_dyn.samples_equal()\n", "\n", "print(f\"Posterior samples: {len(flat_dynesty)}\")\n", - "print(f\"log Z = {results_dyn.logz[-1]:.2f} ± {results_dyn.logzerr[-1]:.2f}\")\n", + "print(f\"log Z = {results_dyn.logz[-1]:.2f} \u00b1 {results_dyn.logzerr[-1]:.2f}\")\n", "print(f\"Efficiency: {results_dyn.eff:.2f} %\")" ] }, @@ -556,7 +556,7 @@ "## Comparing predictive posteriors\n", "\n", "We propagate 200 posterior samples from each method through the model and show\n", - "the 5th–95th percentile predictive band." + "the 5th\u201395th percentile predictive band." ] }, { @@ -658,4 +658,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file diff --git a/examples/correlated_observations.ipynb b/examples/correlated_observations.ipynb new file mode 100644 index 0000000..5aecd33 --- /dev/null +++ b/examples/correlated_observations.ipynb @@ -0,0 +1,783 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c00", + "metadata": {}, + "source": [ + "# Correlated observations\n", + "\n", + "Two datasets that are *individually* independent can still be **coupled** by a\n", + "shared systematic — e.g. a common detector calibration, flux normalisation, or\n", + "energy scale applied to both. The classic D'Agostini / Barlow point is that\n", + "treating such datasets independently is **overconfident**: the shared systematic\n", + "cannot average down the way independent errors do.\n", + "\n", + "The covariance API expresses this directly. A `Constraint` owns one multivariate\n", + "distribution over the *stacked* vector $y = [y_1; y_2]$, and a covariance `Term`\n", + "whose `support` spans **both** blocks writes off-diagonal blocks that couple the\n", + "data. This is \"case A\" of the refactor:\n", + "\n", + "- **case A — coupling the data**: a cross-block `Term` (off-diagonal $\\Sigma$).\n", + "- **case B — coupling the parameters**: the *same* `Parameter` object shared by two\n", + " block-local terms (one sampled value feeds both; $\\Sigma$ stays block-diagonal).\n", + "\n", + "We demonstrate both." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:30.768095Z", + "iopub.status.busy": "2026-08-11T03:18:30.767914Z", + "iopub.status.idle": "2026-08-11T03:18:32.802335Z", + "shell.execute_reply": "2026-08-11T03:18:32.801332Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], + "source": [ + "import corner\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from scipy import stats\n", + "\n", + "import rxmc\n", + "\n", + "rng = np.random.default_rng(3)" + ] + }, + { + "cell_type": "markdown", + "id": "c02", + "metadata": {}, + "source": [ + "## Two datasets with a shared calibration\n", + "\n", + "A straight-line signal is measured by two instruments over different $x$ ranges.\n", + "Both share **one** unknown multiplicative calibration factor $c \\sim\n", + "\\mathcal N(1, \\sigma_c)$ drawn once — so both datasets are biased by the *same*\n", + "amount. The reported statistical errors are small and independent." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:32.803854Z", + "iopub.status.busy": "2026-08-11T03:18:32.803610Z", + "iopub.status.idle": "2026-08-11T03:18:32.992778Z", + "shell.execute_reply": "2026-08-11T03:18:32.991831Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class LinearModel(rxmc.physical_model.PhysicalModel):\n", + " def __init__(self):\n", + " super().__init__(\n", + " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", + " )\n", + "\n", + " def evaluate(self, observation, m, b):\n", + " return self.y(observation.x, m, b)\n", + "\n", + " def y(self, x, m, b):\n", + " return m * x + b\n", + "\n", + "\n", + "model = LinearModel()\n", + "m_true, b_true = 1.0, 0.5\n", + "sigma_c = 0.10 # shared calibration uncertainty\n", + "noise = 0.02 # independent statistical error\n", + "\n", + "c = rng.normal(1.0, sigma_c) # ONE common factor, applied to both datasets\n", + "x1 = np.linspace(0.0, 2.0, 8)\n", + "x2 = np.linspace(3.0, 5.0, 8)\n", + "y1 = c * model.y(x1, m_true, b_true) + rng.normal(0.0, noise, x1.size)\n", + "y2 = c * model.y(x2, m_true, b_true) + rng.normal(0.0, noise, x2.size)\n", + "\n", + "obs1 = rxmc.observation.Observation(x=x1, y=y1, y_stat_err=noise * np.ones_like(y1))\n", + "obs2 = rxmc.observation.Observation(x=x2, y=y2, y_stat_err=noise * np.ones_like(y2))\n", + "\n", + "xg = np.linspace(0, 5, 100)\n", + "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", + "plt.errorbar(x1, y1, noise, ls=\"none\", marker=\".\", label=\"dataset 1\")\n", + "plt.errorbar(x2, y2, noise, ls=\"none\", marker=\".\", label=\"dataset 2\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend()\n", + "plt.title(f\"both datasets share one calibration c = {c:.3f}\");" + ] + }, + { + "cell_type": "markdown", + "id": "c04", + "metadata": {}, + "source": [ + "## The covariance structure\n", + "\n", + "We build the **same** shared-systematic two ways and compare the assembled\n", + "$\\Sigma$ (via `Constraint.covariance_matrix`):\n", + "\n", + "- **correlated (case A)**: one `normalization_term` over the *full* stacked\n", + " support — its rank-one mode spans both blocks.\n", + "- **independent**: a `normalization_term` per dataset (block-local) — no coupling." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c05", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:32.994269Z", + "iopub.status.busy": "2026-08-11T03:18:32.994136Z", + "iopub.status.idle": "2026-08-11T03:18:33.810366Z", + "shell.execute_reply": "2026-08-11T03:18:33.809598Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "correlated block_diagonal = False\n", + "independent block_diagonal = True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s1, s2 = rxmc.covariance.stacked_supports([obs1, obs2])\n", + "full = np.concatenate([s1, s2])\n", + "N1 = len(s1)\n", + "\n", + "constraint_corr = rxmc.constraint.Constraint(\n", + " [obs1, obs2],\n", + " model,\n", + " extra_terms=[rxmc.covariance.normalization_term(full, magnitude=sigma_c)],\n", + ")\n", + "constraint_indep = rxmc.constraint.Constraint(\n", + " [obs1, obs2],\n", + " model,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(s1, magnitude=sigma_c),\n", + " rxmc.covariance.normalization_term(s2, magnitude=sigma_c),\n", + " ],\n", + ")\n", + "\n", + "mp = (m_true, b_true)\n", + "S_corr = constraint_corr.covariance_matrix(mp)\n", + "S_indep = constraint_indep.covariance_matrix(mp)\n", + "\n", + "print(\"correlated block_diagonal =\", constraint_corr.covariance.block_diagonal)\n", + "print(\"independent block_diagonal =\", constraint_indep.covariance.block_diagonal)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", + "for ax, S, t in [\n", + " (axes[0], S_corr, \"correlated (case A)\"),\n", + " (axes[1], S_indep, \"independent\"),\n", + "]:\n", + " im = ax.imshow(S, cmap=\"viridis\")\n", + " ax.axhline(N1 - 0.5, color=\"w\", lw=0.8)\n", + " ax.axvline(N1 - 0.5, color=\"w\", lw=0.8)\n", + " ax.set_title(t)\n", + " fig.colorbar(im, ax=ax, fraction=0.046)\n", + "fig.suptitle(r\"stacked covariance $\\Sigma$ — off-diagonal blocks couple the data\");" + ] + }, + { + "cell_type": "markdown", + "id": "c06", + "metadata": {}, + "source": [ + "The correlated $\\Sigma$ has **non-zero off-diagonal blocks** (top-right /\n", + "bottom-left): every point in dataset 1 is correlated with every point in dataset 2\n", + "through the shared calibration. The independent $\\Sigma$ is block-diagonal." + ] + }, + { + "cell_type": "markdown", + "id": "c07", + "metadata": {}, + "source": [ + "## Effect on inference\n", + "\n", + "Fitting the line under each treatment: the correlated model is appropriately\n", + "**less certain** (the shared systematic is a common mode that cannot average\n", + "down), while the independent model is **overconfident**." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:33.812158Z", + "iopub.status.busy": "2026-08-11T03:18:33.811974Z", + "iopub.status.idle": "2026-08-11T03:18:39.649142Z", + "shell.execute_reply": "2026-08-11T03:18:39.648248Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "correlated m = 1.201 ± 0.105 b = 0.582 ± 0.051\n", + "independent m = 1.196 ± 0.079 b = 0.590 ± 0.041\n" + ] + } + ], + "source": [ + "def fit(constraint, seed):\n", + " evidence = rxmc.evidence.Evidence([constraint])\n", + " prior = stats.multivariate_normal(mean=[1.0, 0.5], cov=np.diag([0.3, 0.3]) ** 2)\n", + " sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=model.params,\n", + " starting_location=prior.mean,\n", + " prior=prior,\n", + " initial_proposal_cov=prior.cov / 100,\n", + " )\n", + " walker = rxmc.walker.Walker(sampler, evidence, rng=np.random.default_rng(seed))\n", + " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", + " return walker.model_sampler.chain\n", + "\n", + "\n", + "chain_corr = fit(constraint_corr, 5)\n", + "chain_indep = fit(constraint_indep, 5)\n", + "\n", + "for name, ch in [(\"correlated\", chain_corr), (\"independent\", chain_indep)]:\n", + " print(\n", + " f\"{name:12s} m = {ch[:,0].mean():.3f} ± {ch[:,0].std():.3f} \"\n", + " f\"b = {ch[:,1].mean():.3f} ± {ch[:,1].std():.3f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c09", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:39.650554Z", + "iopub.status.busy": "2026-08-11T03:18:39.650423Z", + "iopub.status.idle": "2026-08-11T03:18:39.814309Z", + "shell.execute_reply": "2026-08-11T03:18:39.813633Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " chain_corr,\n", + " labels=[\"m\", \"b\"],\n", + " color=\"tab:blue\",\n", + " truths=[m_true, b_true],\n", + " truth_color=\"k\",\n", + ")\n", + "corner.corner(chain_indep, fig=fig, color=\"tab:red\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"correlated (case A)\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"independent (overconfident)\")\n", + "fig.legend(loc=\"upper right\");" + ] + }, + { + "cell_type": "markdown", + "id": "c10", + "metadata": {}, + "source": [ + "## Case A vs case B with a *free* shared nuisance\n", + "\n", + "If the calibration magnitude is itself unknown, it becomes a sampled `Parameter`.\n", + "The same `Parameter` object can be wired two ways:\n", + "\n", + "- **case A** — one cross-block term: $\\Sigma$ couples the data (off-diagonal).\n", + "- **case B** — two block-local terms sharing the *same* `Parameter`: one sampled\n", + " value feeds both, but $\\Sigma$ stays **block-diagonal** (the datasets remain\n", + " independent; they only share the uncertainty *magnitude*).\n", + "\n", + "Both have exactly **one** free parameter (gather-by-identity)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c11", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:39.815796Z", + "iopub.status.busy": "2026-08-11T03:18:39.815612Z", + "iopub.status.idle": "2026-08-11T03:18:39.820536Z", + "shell.execute_reply": "2026-08-11T03:18:39.819858Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "case A (cross-block) n_params=1 block_diagonal=False\n", + "case B (shared param) n_params=1 block_diagonal=True\n", + "case A cross-block max |Sigma[s1,s2]| = 0.1375\n", + "case B cross-block max |Sigma[s1,s2]| = 0.0\n" + ] + } + ], + "source": [ + "eta = rxmc.params.Parameter(\"log eta\", float, latex_name=r\"\\log{\\eta}\")\n", + "\n", + "case_A = rxmc.constraint.Constraint(\n", + " [obs1, obs2],\n", + " model,\n", + " extra_terms=[rxmc.covariance.normalization_term(full, parameter=eta)],\n", + ")\n", + "case_B = rxmc.constraint.Constraint(\n", + " [obs1, obs2],\n", + " model,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(s1, parameter=eta),\n", + " rxmc.covariance.normalization_term(s2, parameter=eta),\n", + " ],\n", + ")\n", + "\n", + "for name, c in [(\"case A (cross-block)\", case_A), (\"case B (shared param)\", case_B)]:\n", + " print(\n", + " f\"{name:24s} n_params={c.n_params} \"\n", + " f\"block_diagonal={c.covariance.block_diagonal}\"\n", + " )\n", + "\n", + "# same single sampled value, different Sigma structure\n", + "val = (np.log(sigma_c),)\n", + "SA = case_A.covariance_matrix(mp, val)\n", + "SB = case_B.covariance_matrix(mp, val)\n", + "print(\"case A cross-block max |Sigma[s1,s2]| =\", np.abs(SA[:N1, N1:]).max().round(4))\n", + "print(\"case B cross-block max |Sigma[s1,s2]| =\", np.abs(SB[:N1, N1:]).max().round(4))" + ] + }, + { + "cell_type": "markdown", + "id": "c12", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- **Correlated observations are just a covariance `Term` whose `support` spans\n", + " blocks.** No special machinery — a cross-block `normalization_term` (or any\n", + " `RankOneTerm`/`KernelTerm`) writes the off-diagonal $\\Sigma$ blocks.\n", + "- Treating shared-systematic datasets **independently is overconfident**: the\n", + " common mode cannot average down.\n", + "- **A couples the data** (cross-block, off-diagonal $\\Sigma$); **B couples the\n", + " parameters** (same `Parameter` shared by block-local terms, $\\Sigma$\n", + " block-diagonal). Both are expressed by *where* you put the support and *which*\n", + " `Parameter` object you reuse." + ] + }, + { + "cell_type": "markdown", + "id": "2e389f4a", + "metadata": {}, + "source": [ + "# Shared systematics between cross-section datasets\n", + "\n", + "The toy example above carries over to real reaction data unchanged. Here two\n", + "mock *experiments* measure the same $n + {}^{40}$Ca elastic differential cross\n", + "section — one at forward angles, one at backward angles — and both were\n", + "normalized against the **same uncertain flux measurement**. That is case A:\n", + "the shared normalization couples the two datasets, so they belong in **one**\n", + "`Constraint` with a normalization mode spanning both blocks.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7cd8e173", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:39.821956Z", + "iopub.status.busy": "2026-08-11T03:18:39.821803Z", + "iopub.status.idle": "2026-08-11T03:18:39.920680Z", + "shell.execute_reply": "2026-08-11T03:18:39.920050Z" + } + }, + "outputs": [], + "source": [ + "import jitr\n", + "from jitr.optical_potentials.potential_forms import (\n", + " thomas_safe,\n", + " woods_saxon_prime_safe,\n", + " woods_saxon_safe,\n", + ")\n", + "\n", + "from rxmc.params import Parameter\n", + "\n", + "Ca40 = (40, 20)\n", + "neutron = (1, 0)\n", + "E_lab = 14.1\n", + "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", + "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", + "\n", + "\n", + "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", + " 4j * ad * Wd\n", + " ) * woods_saxon_prime_safe(r, Rd, ad)\n", + "\n", + "\n", + "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", + " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", + "\n", + "\n", + "R40 = 1.2 * 40 ** (1 / 3)\n", + "fixed_spin_orbit = (6.0, -3, R40, 0.45)\n", + "\n", + "\n", + "def extract_params(ws, *x):\n", + " return tuple(x), fixed_spin_orbit\n", + "\n", + "\n", + "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + " \"dXS/dA\",\n", + " interaction_central=central_potential,\n", + " interaction_spin_orbit=spin_orbit_potential,\n", + " calculate_interaction_from_params=extract_params,\n", + " params=[\n", + " Parameter(\"Vv\", unit=\"MeV\"),\n", + " Parameter(\"Wv\", unit=\"MeV\"),\n", + " Parameter(\"Rv\", unit=\"fm\"),\n", + " Parameter(\"av\", unit=\"fm\"),\n", + " Parameter(\"Wd\", unit=\"MeV\"),\n", + " Parameter(\"Rd\", unit=\"fm\"),\n", + " Parameter(\"ad\", unit=\"fm\"),\n", + " ],\n", + " model_name=\"shared_flux_demo\",\n", + ")\n", + "omp_true_params = np.array(\n", + " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d5480648", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:39.922385Z", + "iopub.status.busy": "2026-08-11T03:18:39.922240Z", + "iopub.status.idle": "2026-08-11T03:18:51.337995Z", + "shell.execute_reply": "2026-08-11T03:18:51.337238Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def make_xs_observation(angles_deg, label):\n", + " return rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", + " x=angles_deg,\n", + " y=np.ones_like(angles_deg, dtype=float),\n", + " Elab=E_lab,\n", + " reaction=rxn,\n", + " quantity=\"dXS/dA\",\n", + " measurement_quantity=\"dXS/dA\",\n", + " y_units=\"barn / steradian\",\n", + " dataset_label=label,\n", + " )\n", + "\n", + "\n", + "sigma_flux = 0.05 # one flux calibration, shared by both experiments\n", + "flux = rng.normal(1.0, sigma_flux)\n", + "\n", + "angles_fwd = np.linspace(5.0, 90.0, 12)\n", + "angles_bwd = np.linspace(60.0, 160.0, 12)\n", + "\n", + "obs_fwd = make_xs_observation(angles_fwd, \"forward experiment\")\n", + "obs_bwd = make_xs_observation(angles_bwd, \"backward experiment\")\n", + "\n", + "for o in (obs_fwd, obs_bwd):\n", + " y_true = omp.evaluate(o, *omp_true_params)\n", + " stat = 0.05 * np.maximum(y_true, 1e-4)\n", + " o.y = np.clip(flux * y_true + rng.normal(scale=stat), 1e-6, None)\n", + " o.y_stat_err = stat\n", + "\n", + "for o in (obs_fwd, obs_bwd):\n", + " plt.errorbar(\n", + " np.rad2deg(o.x), o.y, o.y_stat_err, ls=\"none\", marker=\".\", label=o.subentry\n", + " )\n", + "plt.xlabel(r\"$\\theta$ [deg]\")\n", + "plt.ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", + "plt.yscale(\"log\")\n", + "plt.legend()\n", + "plt.title(f\"both experiments share one flux calibration = {flux:.3f}\");" + ] + }, + { + "cell_type": "markdown", + "id": "f248a5cc", + "metadata": {}, + "source": [ + "## One constraint, one cross-block normalization mode\n", + "\n", + "Exactly as in the toy: the coupled covariance gets a single\n", + "`normalization_term` whose support spans **both** blocks; the independent\n", + "alternative gives each experiment its own block-local mode.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "cd5da3bc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:51.339630Z", + "iopub.status.busy": "2026-08-11T03:18:51.339493Z", + "iopub.status.idle": "2026-08-11T03:18:51.622477Z", + "shell.execute_reply": "2026-08-11T03:18:51.621873Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coupled block-diagonal? False\n", + "independent block-diagonal? True\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "s_fwd, s_bwd = rxmc.covariance.stacked_supports([obs_fwd, obs_bwd])\n", + "s_all = np.concatenate([s_fwd, s_bwd])\n", + "\n", + "xs_coupled = rxmc.constraint.Constraint(\n", + " [obs_fwd, obs_bwd],\n", + " omp,\n", + " extra_terms=[rxmc.covariance.normalization_term(s_all, magnitude=sigma_flux)],\n", + ")\n", + "xs_indep = rxmc.constraint.Constraint(\n", + " [obs_fwd, obs_bwd],\n", + " omp,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(s_fwd, magnitude=sigma_flux),\n", + " rxmc.covariance.normalization_term(s_bwd, magnitude=sigma_flux),\n", + " ],\n", + ")\n", + "print(\"coupled block-diagonal?\", xs_coupled.covariance.block_diagonal)\n", + "print(\"independent block-diagonal?\", xs_indep.covariance.block_diagonal)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", + "for a, (c, title) in zip(\n", + " axes,\n", + " [(xs_coupled, \"coupled (case A)\"), (xs_indep, \"independent\")],\n", + "):\n", + " im = a.imshow(c.covariance_matrix(omp_true_params), cmap=\"viridis\")\n", + " a.set_title(title)\n", + " fig.colorbar(im, ax=a, fraction=0.046)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a5cda1bf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:18:51.624199Z", + "iopub.status.busy": "2026-08-11T03:18:51.624047Z", + "iopub.status.idle": "2026-08-11T03:19:37.355527Z", + "shell.execute_reply": "2026-08-11T03:19:37.354746Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 45.8 s, sys: 2.09 ms, total: 45.8 s\n", + "Wall time: 45.7 s\n" + ] + } + ], + "source": [ + "%%time\n", + "xs_prior = stats.multivariate_normal(\n", + " mean=np.array([50.0, 3, 1.2 * 40 ** (1 / 3), 0.65, 18, 1.2 * 40 ** (1 / 3), 0.65]),\n", + " cov=np.diag([7, 7, 0.2, 0.2, 10, 0.2, 0.2]) ** 2,\n", + ")\n", + "\n", + "\n", + "def fit_xs(constraint, seed):\n", + " walker = rxmc.walker.Walker(\n", + " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=omp.params,\n", + " starting_location=xs_prior.mean,\n", + " prior=xs_prior,\n", + " initial_proposal_cov=xs_prior.cov / 100,\n", + " ),\n", + " rxmc.evidence.Evidence([constraint]),\n", + " rng=np.random.default_rng(seed),\n", + " )\n", + " walker.walk(n_steps=6000, burnin=1500, batch_size=1000, verbose=False)\n", + " return walker.model_sampler.chain\n", + "\n", + "\n", + "xs_chain_coupled = fit_xs(xs_coupled, 8)\n", + "xs_chain_indep = fit_xs(xs_indep, 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8d155f69", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:19:37.357572Z", + "iopub.status.busy": "2026-08-11T03:19:37.357306Z", + "iopub.status.idle": "2026-08-11T03:19:39.348068Z", + "shell.execute_reply": "2026-08-11T03:19:39.347258Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coupled Vv=45.63±2.31 Wv=4.19±0.82 Rv=3.90±0.14 av=0.67±0.02 Wd=20.38±1.44 Rd=4.09±0.03 ad=0.50±0.02\n", + "independent Vv=46.78±1.82 Wv=4.16±0.87 Rv=3.84±0.11 av=0.68±0.02 Wd=20.40±1.40 Rd=4.11±0.03 ad=0.50±0.02\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for name, ch in [(\"coupled\", xs_chain_coupled), (\"independent\", xs_chain_indep)]:\n", + " print(\n", + " f\"{name:12s} \"\n", + " + \" \".join(\n", + " f\"{p.name}={ch[:, i].mean():.2f}±{ch[:, i].std():.2f}\"\n", + " for i, p in enumerate(omp.params)\n", + " )\n", + " )\n", + "\n", + "fig = corner.corner(\n", + " xs_chain_coupled,\n", + " labels=[p.name for p in omp.params],\n", + " truths=omp_true_params,\n", + " truth_color=\"k\",\n", + " color=\"tab:blue\",\n", + ")\n", + "corner.corner(xs_chain_indep, fig=fig, color=\"tab:red\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"coupled (case A)\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"independent\")\n", + "fig.legend(loc=\"upper right\");" + ] + }, + { + "cell_type": "markdown", + "id": "d8d2706f", + "metadata": {}, + "source": [ + "## Takeaways, continued\n", + "\n", + "- **Real reaction data changes nothing structurally**: the shared-flux coupling\n", + " is the same three lines as the toy — put both experiments in one `Constraint`\n", + " and give the `normalization_term` a support spanning both blocks.\n", + "- The independent spelling silently claims the two flux calibrations could\n", + " fluctuate separately — a stronger (and here wrong) assumption, visible as the\n", + " covariance heatmap's missing off-diagonal blocks.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/gp_discrepancy.ipynb b/examples/gp_discrepancy.ipynb new file mode 100644 index 0000000..2846daa --- /dev/null +++ b/examples/gp_discrepancy.ipynb @@ -0,0 +1,974 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c00", + "metadata": {}, + "source": [ + "# Model discrepancy with a Gaussian-process term\n", + "\n", + "A linear model is fit to data drawn from a *mildly non-linear* truth. The model\n", + "is structurally wrong, so a plain fit leaves **correlated** residuals. We absorb\n", + "that structure with a Gaussian-process (GP) **discrepancy** term added to the\n", + "constraint covariance — a `rxmc.covariance.KernelTerm` built from a scikit-learn\n", + "kernel — and then **propagate the total uncertainty** (model parameters + GP\n", + "discrepancy + observation noise) to a fine prediction grid using\n", + "`rxmc.predictive.total_predictive_band`.\n", + "\n", + "This is the Kennedy & O'Hagan picture: the discrepancy is a latent correlated\n", + "function, marginalised over its GP prior. The `KernelTerm` only inflates the\n", + "covariance **at the data points**; predicting the discrepancy at *new* points is\n", + "the GP posterior-predictive provided by `rxmc.predictive.gp_posterior_predictive`." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:51.145746Z", + "iopub.status.busy": "2026-08-11T03:07:51.145608Z", + "iopub.status.idle": "2026-08-11T03:07:53.817459Z", + "shell.execute_reply": "2026-08-11T03:07:53.816779Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], + "source": [ + "import corner\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from scipy import stats\n", + "from sklearn.gaussian_process.kernels import ConstantKernel, Matern, WhiteKernel\n", + "\n", + "import rxmc\n", + "\n", + "rng = np.random.default_rng(7)" + ] + }, + { + "cell_type": "markdown", + "id": "c02", + "metadata": {}, + "source": [ + "## A linear model and a non-linear truth\n", + "\n", + "The model is a straight line $y_m(x; m, b) = m x + b$. We give it the usual\n", + "`.y(x, *params)` helper so the same model can be evaluated on a raw grid for\n", + "plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:53.819066Z", + "iopub.status.busy": "2026-08-11T03:07:53.818832Z", + "iopub.status.idle": "2026-08-11T03:07:53.822492Z", + "shell.execute_reply": "2026-08-11T03:07:53.821615Z" + } + }, + "outputs": [], + "source": [ + "class LinearModel(rxmc.physical_model.PhysicalModel):\n", + " def __init__(self):\n", + " super().__init__(\n", + " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", + " )\n", + "\n", + " def evaluate(self, observation, m, b):\n", + " return self.y(observation.x, m, b)\n", + "\n", + " def y(self, x, m, b):\n", + " return m * x + b\n", + "\n", + "\n", + "model = LinearModel()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c04", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:53.823735Z", + "iopub.status.busy": "2026-08-11T03:07:53.823595Z", + "iopub.status.idle": "2026-08-11T03:07:54.037874Z", + "shell.execute_reply": "2026-08-11T03:07:54.037056Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# truth: a saturating (non-linear) curve the straight line cannot capture\n", + "K = 2.0\n", + "\n", + "\n", + "def truth(x):\n", + " return (0.8 * x + 1.0) / (1.0 + x / K)\n", + "\n", + "\n", + "x = np.linspace(0.2, 5.0, 30)\n", + "noise = 0.02\n", + "y = truth(x) + rng.normal(0.0, noise, size=x.size)\n", + "observation = rxmc.observation.Observation(x=x, y=y, y_stat_err=noise * np.ones_like(y))\n", + "\n", + "xg = np.linspace(0.0, 5.5, 120) # fine grid for predictions\n", + "\n", + "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", label=\"data\")\n", + "plt.plot(xg, truth(xg), \"k:\", label=\"truth\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend()\n", + "plt.title(\"data from a non-linear truth\");" + ] + }, + { + "cell_type": "markdown", + "id": "c05", + "metadata": {}, + "source": [ + "## Building the constraint with a GP discrepancy term\n", + "\n", + "`rxmc.covariance.discrepancy_term(support, kernel)` wraps a scikit-learn kernel as\n", + "a `KernelTerm`. It **auto-derives one `Parameter` per free kernel hyperparameter**\n", + "(sampled in sklearn's log-theta space). The constraint then carries those\n", + "hyperparameters as its covariance parameters (`constraint.params`), so it is\n", + "auto-detected as a parametric constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c06", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:54.039335Z", + "iopub.status.busy": "2026-08-11T03:07:54.039172Z", + "iopub.status.idle": "2026-08-11T03:07:54.043021Z", + "shell.execute_reply": "2026-08-11T03:07:54.042513Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GP hyperparameters (sampled in log-theta space):\n", + " discrepancy_k1__k1__constant_value\n", + " discrepancy_k1__k2__length_scale\n", + " discrepancy_k2__noise_level\n" + ] + } + ], + "source": [ + "kernel = ConstantKernel(1.0) * Matern(length_scale=2.0, nu=2.5) + WhiteKernel(1e-6)\n", + "(support,) = rxmc.covariance.stacked_supports([observation])\n", + "\n", + "constraint_gp = rxmc.constraint.Constraint(\n", + " [observation],\n", + " model,\n", + " extra_terms=[rxmc.covariance.discrepancy_term(support, kernel)],\n", + ")\n", + "evidence_gp = rxmc.evidence.Evidence([constraint_gp])\n", + "\n", + "print(\"GP hyperparameters (sampled in log-theta space):\")\n", + "for p in constraint_gp.params:\n", + " print(\" \", p.name)" + ] + }, + { + "cell_type": "markdown", + "id": "c07", + "metadata": {}, + "source": [ + "For comparison we also build two reference constraints over the *same* data:\n", + "a plain line (statistical errors only) and a line with an uncorrelated\n", + "**model-error** term (`model_error_term`, the diagonal $\\gamma^2$ inflation).\n", + "Neither can represent the *correlated* curvature the GP captures." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:54.044477Z", + "iopub.status.busy": "2026-08-11T03:07:54.044335Z", + "iopub.status.idle": "2026-08-11T03:07:54.048000Z", + "shell.execute_reply": "2026-08-11T03:07:54.047249Z" + } + }, + "outputs": [], + "source": [ + "constraint_plain = rxmc.constraint.Constraint([observation], model)\n", + "evidence_plain = rxmc.evidence.Evidence([constraint_plain])\n", + "\n", + "gamma = rxmc.params.Parameter(\n", + " \"log fractional err\", float, latex_name=r\"\\gamma\", unit=\"dimensionless\"\n", + ")\n", + "constraint_me = rxmc.constraint.Constraint(\n", + " [observation],\n", + " model,\n", + " extra_terms=[rxmc.covariance.model_error_term(support, gamma, averaging=True)],\n", + ")\n", + "evidence_me = rxmc.evidence.Evidence([constraint_me])" + ] + }, + { + "cell_type": "markdown", + "id": "c09", + "metadata": {}, + "source": [ + "## Sampling\n", + "\n", + "The physical parameters $(m, b)$ are sampled in the model block; each parametric\n", + "constraint's covariance parameters (GP log-theta, or $\\gamma$) are sampled in a\n", + "Gibbs block by a `likelihood_sampler`. GP hyperparameters get a broad\n", + "$\\mathcal N(0, 2)$ prior **per log-hyperparameter**." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c10", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:54.049326Z", + "iopub.status.busy": "2026-08-11T03:07:54.049168Z", + "iopub.status.idle": "2026-08-11T03:08:09.762020Z", + "shell.execute_reply": "2026-08-11T03:08:09.761234Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "line only: model acceptance 0.45\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "line + model error: model acceptance 0.35\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "line + GP discrepancy: model acceptance 0.38\n" + ] + } + ], + "source": [ + "model_prior = stats.multivariate_normal(mean=[0.8, 1.0], cov=np.diag([0.5, 0.5]) ** 2)\n", + "\n", + "\n", + "def make_model_sampler():\n", + " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=model.params,\n", + " starting_location=model_prior.mean,\n", + " prior=model_prior,\n", + " initial_proposal_cov=model_prior.cov / 100,\n", + " )\n", + "\n", + "\n", + "def make_nuisance_sampler(params, prior, cov):\n", + " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=list(params),\n", + " starting_location=prior.mean,\n", + " prior=prior,\n", + " initial_proposal_cov=cov,\n", + " )\n", + "\n", + "\n", + "theta_prior = stats.multivariate_normal(\n", + " mean=np.zeros(constraint_gp.n_params), cov=4.0 * np.eye(constraint_gp.n_params)\n", + ")\n", + "gamma_prior = stats.multivariate_normal(mean=[np.log(0.05)], cov=[[1.0]])\n", + "\n", + "walkers = {}\n", + "walkers[\"line only\"] = rxmc.walker.Walker(make_model_sampler(), evidence_plain, rng=rng)\n", + "walkers[\"line + model error\"] = rxmc.walker.Walker(\n", + " make_model_sampler(),\n", + " evidence_me,\n", + " likelihood_samplers=[\n", + " make_nuisance_sampler(constraint_me.params, gamma_prior, np.array([[0.04]]))\n", + " ],\n", + " rng=rng,\n", + ")\n", + "walkers[\"line + GP discrepancy\"] = rxmc.walker.Walker(\n", + " make_model_sampler(),\n", + " evidence_gp,\n", + " likelihood_samplers=[\n", + " make_nuisance_sampler(\n", + " constraint_gp.params, theta_prior, 0.04 * np.eye(constraint_gp.n_params)\n", + " )\n", + " ],\n", + " rng=rng,\n", + ")\n", + "\n", + "for key, walker in walkers.items():\n", + " walker.walk(n_steps=4000, burnin=1500, batch_size=500, verbose=False)\n", + " print(\n", + " f\"{key}: model acceptance \"\n", + " f\"{walker.model_sampler.overall_acceptance_fraction():.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "c11", + "metadata": {}, + "source": [ + "## Posterior of the GP hyperparameters" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c12", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:09.763535Z", + "iopub.status.busy": "2026-08-11T03:08:09.763375Z", + "iopub.status.idle": "2026-08-11T03:08:11.031094Z", + "shell.execute_reply": "2026-08-11T03:08:11.030356Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gp_walker = walkers[\"line + GP discrepancy\"]\n", + "theta_chain = gp_walker.likelihood_samplers[0].chain\n", + "fig = corner.corner(\n", + " theta_chain,\n", + " labels=[p.latex_name for p in constraint_gp.params],\n", + " show_titles=True,\n", + ")\n", + "fig.suptitle(\"GP hyperparameters (log-theta)\");" + ] + }, + { + "cell_type": "markdown", + "id": "c13", + "metadata": {}, + "source": [ + "## Propagating the total uncertainty\n", + "\n", + "`rxmc.predictive.total_predictive_band` takes the posterior draws\n", + "$[m, b \\mid \\log\\theta]$ and, for each draw, conditions the GP discrepancy on the\n", + "residuals and samples\n", + "$y_* = y_m(x_*) + \\bar f_*(x_*) + \\mathcal N(0,\\ \\mathrm{var}_* + \\sigma^2)$ on the\n", + "fine grid. The line-only and model-error bands are credible intervals on the mean\n", + "line (they cannot bend); the GP band tracks the non-linear truth." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c14", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:11.032555Z", + "iopub.status.busy": "2026-08-11T03:08:11.032395Z", + "iopub.status.idle": "2026-08-11T03:08:12.461318Z", + "shell.execute_reply": "2026-08-11T03:08:12.460505Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draws_gp = np.column_stack([gp_walker.model_sampler.chain, theta_chain])\n", + "\n", + "band_gp = rxmc.predictive.total_predictive_band(\n", + " model.y,\n", + " kernel,\n", + " x,\n", + " y,\n", + " xg,\n", + " draws_gp,\n", + " n_model_params=model.n_params,\n", + " noise_std=noise,\n", + " levels=(16, 84),\n", + " n_draws=300,\n", + " rng=rng,\n", + ")\n", + "\n", + "\n", + "def mean_line_band(walker, levels=(16, 84)):\n", + " chain = walker.model_sampler.chain[:, : model.n_params]\n", + " return rxmc.predictive.predictive_band(\n", + " np.array([model.y(xg, *p) for p in chain]), levels=levels\n", + " )\n", + "\n", + "\n", + "band_plain = mean_line_band(walkers[\"line only\"])\n", + "band_me = mean_line_band(walkers[\"line + model error\"])\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "ax.plot(xg, truth(xg), \"k:\", lw=2, label=\"truth\")\n", + "ax.errorbar(x, y, noise, ls=\"none\", marker=\".\", color=\"k\", alpha=0.6, label=\"data\")\n", + "for (lo, hi), c, lab in [\n", + " (band_plain, \"tab:blue\", \"line only (68% mean band)\"),\n", + " (band_me, \"tab:orange\", \"line + model error (68% mean band)\"),\n", + " (band_gp, \"tab:green\", \"line + GP discrepancy (68% total predictive)\"),\n", + "]:\n", + " ax.fill_between(xg, lo, hi, color=c, alpha=0.3, label=lab)\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.legend()\n", + "ax.set_title(\"Only the GP discrepancy band follows the non-linear structure\");" + ] + }, + { + "cell_type": "markdown", + "id": "c15", + "metadata": {}, + "source": [ + "## What the GP actually captured: the correlated residuals\n", + "\n", + "The smoking gun for model discrepancy is **structure in the residuals** $y -\n", + "y_m(x)$ — a good (well-specified) model leaves white noise. Conditioning the GP on\n", + "those residuals (`rxmc.predictive.gp_posterior_predictive`) recovers a smooth\n", + "discrepancy that matches the true mismatch `truth(x) - line(x)`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c16", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:12.463263Z", + "iopub.status.busy": "2026-08-11T03:08:12.463090Z", + "iopub.status.idle": "2026-08-11T03:08:12.747816Z", + "shell.execute_reply": "2026-08-11T03:08:12.747122Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mp_mean = gp_walker.model_sampler.chain.mean(axis=0)\n", + "theta_mean = theta_chain.mean(axis=0)\n", + "residuals = y - model.y(x, *mp_mean)\n", + "\n", + "disc_mean, disc_cov = rxmc.predictive.gp_posterior_predictive(\n", + " kernel, theta_mean, x, residuals, xg, train_noise_var=noise**2\n", + ")\n", + "disc_sd = np.sqrt(np.clip(np.diag(disc_cov), 0.0, np.inf))\n", + "\n", + "plt.figure(figsize=(8, 4))\n", + "plt.axhline(0.0, color=\"0.7\", lw=1)\n", + "plt.plot(x, residuals, \"k.\", label=\"residuals $y - y_m(x)$\")\n", + "plt.plot(xg, truth(xg) - model.y(xg, *mp_mean), \"k:\", label=\"true discrepancy\")\n", + "plt.fill_between(\n", + " xg,\n", + " disc_mean - disc_sd,\n", + " disc_mean + disc_sd,\n", + " color=\"tab:green\",\n", + " alpha=0.3,\n", + " label=\"GP discrepancy (68%)\",\n", + ")\n", + "plt.plot(xg, disc_mean, color=\"tab:green\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"discrepancy\")\n", + "plt.legend()\n", + "plt.title(\"the GP recovers the correlated residual structure\");" + ] + }, + { + "cell_type": "markdown", + "id": "c17", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- A GP discrepancy is **just another covariance `Term`** — `discrepancy_term`\n", + " (a `KernelTerm`) added to the constraint. Its hyperparameters become\n", + " constraint parameters and are sampled like any other nuisance.\n", + "- The `KernelTerm` only inflates the covariance at the data points. To predict the\n", + " discrepancy at new $x$, use `rxmc.predictive.gp_posterior_predictive`; to get a\n", + " full data-space band that propagates model, discrepancy, and noise uncertainty,\n", + " use `rxmc.predictive.total_predictive_band`.\n", + "- Uncorrelated model error (`model_error_term`) inflates the variance but cannot\n", + " represent correlated mis-modelling; the GP can." + ] + }, + { + "cell_type": "markdown", + "id": "6e491de1", + "metadata": {}, + "source": [ + "# GP discrepancy on a differential cross section\n", + "\n", + "The same machinery on real reaction physics: we generate mock\n", + "$n + {}^{40}$Ca elastic scattering data from a **full** optical potential\n", + "(volume + surface absorption), then fit it with a **deficient** potential that\n", + "has no surface term. The missing physics leaves a smooth, *angle-correlated*\n", + "residual — exactly what a `discrepancy_term` over the angle grid absorbs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a2cefc08", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:12.749919Z", + "iopub.status.busy": "2026-08-11T03:08:12.749754Z", + "iopub.status.idle": "2026-08-11T03:08:24.846032Z", + "shell.execute_reply": "2026-08-11T03:08:24.845346Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import jitr\n", + "from jitr.optical_potentials.potential_forms import (\n", + " thomas_safe,\n", + " woods_saxon_prime_safe,\n", + " woods_saxon_safe,\n", + ")\n", + "\n", + "from rxmc.params import Parameter\n", + "\n", + "Ca40 = (40, 20)\n", + "E_lab = 14.1\n", + "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=(1, 0))\n", + "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", + "R40 = 1.2 * 40 ** (1 / 3)\n", + "fixed_spin_orbit = (6.0, -3, R40, 0.45)\n", + "\n", + "\n", + "def full_central(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", + " 4j * ad * Wd\n", + " ) * woods_saxon_prime_safe(r, Rd, ad)\n", + "\n", + "\n", + "def volume_central(r, Vv, Wv, Rv, av):\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av)\n", + "\n", + "\n", + "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", + " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", + "\n", + "\n", + "omp_full = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + " \"dXS/dA\",\n", + " interaction_central=full_central,\n", + " interaction_spin_orbit=spin_orbit_potential,\n", + " calculate_interaction_from_params=lambda ws, *x: (tuple(x), fixed_spin_orbit),\n", + " params=[\n", + " Parameter(n, unit=u)\n", + " for n, u in [\n", + " (\"Vv\", \"MeV\"),\n", + " (\"Wv\", \"MeV\"),\n", + " (\"Rv\", \"fm\"),\n", + " (\"av\", \"fm\"),\n", + " (\"Wd\", \"MeV\"),\n", + " (\"Rd\", \"fm\"),\n", + " (\"ad\", \"fm\"),\n", + " ]\n", + " ],\n", + " model_name=\"full_potential\",\n", + ")\n", + "omp_vol = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + " \"dXS/dA\",\n", + " interaction_central=volume_central,\n", + " interaction_spin_orbit=spin_orbit_potential,\n", + " calculate_interaction_from_params=lambda ws, *x: (tuple(x), fixed_spin_orbit),\n", + " params=[\n", + " Parameter(n, unit=u)\n", + " for n, u in [(\"Vv\", \"MeV\"), (\"Wv\", \"MeV\"), (\"Rv\", \"fm\"), (\"av\", \"fm\")]\n", + " ],\n", + " model_name=\"volume_only_potential\",\n", + ")\n", + "\n", + "full_truth = np.array([48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, R40, 0.5])\n", + "volume_truth = full_truth[:4] # the deficient model's share of the truth\n", + "\n", + "obs_xs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", + " x=np.linspace(5.0, 160.0, 25),\n", + " y=np.ones(25),\n", + " Elab=E_lab,\n", + " reaction=rxn,\n", + " quantity=\"dXS/dA\",\n", + " measurement_quantity=\"dXS/dA\",\n", + " y_units=\"barn / steradian\",\n", + " dataset_label=\"mock elastic dataset\",\n", + ")\n", + "y_true_xs = omp_full.evaluate(obs_xs, *full_truth)\n", + "stat_xs = 0.04 * np.maximum(y_true_xs, 1e-4)\n", + "obs_xs.y = np.clip(y_true_xs + rng.normal(scale=stat_xs), 1e-6, None)\n", + "obs_xs.y_stat_err = stat_xs\n", + "\n", + "plt.errorbar(\n", + " np.rad2deg(obs_xs.x), obs_xs.y, stat_xs, ls=\"none\", marker=\".\", label=\"data\"\n", + ")\n", + "plt.plot(\n", + " np.rad2deg(obs_xs.x),\n", + " omp_vol.evaluate(obs_xs, *volume_truth),\n", + " \"tab:red\",\n", + " label=\"deficient model at the true volume params\",\n", + ")\n", + "plt.xlabel(r\"$\\theta$ [deg]\")\n", + "plt.ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", + "plt.yscale(\"log\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "f1652855", + "metadata": {}, + "source": [ + "## The discrepancy term acts on the angle grid\n", + "\n", + "The kernel's input coordinate is `obs.x` — the scattering angle **in radians**\n", + "— so the `length_scale` is an angular correlation length. Everything else is\n", + "identical to the toy section.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1f0df948", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:24.847679Z", + "iopub.status.busy": "2026-08-11T03:08:24.847514Z", + "iopub.status.idle": "2026-08-11T03:08:24.851771Z", + "shell.execute_reply": "2026-08-11T03:08:24.851045Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GP hyperparameters: ['discrepancy_k1__k1__constant_value', 'discrepancy_k1__k2__length_scale', 'discrepancy_k2__noise_level']\n" + ] + } + ], + "source": [ + "kernel_xs = ConstantKernel(1.0) * Matern(length_scale=0.5, nu=2.5) + WhiteKernel(1e-6)\n", + "(support_xs,) = rxmc.covariance.stacked_supports([obs_xs])\n", + "\n", + "c_vol_plain = rxmc.constraint.Constraint([obs_xs], omp_vol)\n", + "c_vol_gp = rxmc.constraint.Constraint(\n", + " [obs_xs],\n", + " omp_vol,\n", + " extra_terms=[rxmc.covariance.discrepancy_term(support_xs, kernel_xs)],\n", + ")\n", + "print(\"GP hyperparameters:\", [p.name for p in c_vol_gp.params])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1059d23b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:24.853287Z", + "iopub.status.busy": "2026-08-11T03:08:24.853128Z", + "iopub.status.idle": "2026-08-11T03:08:58.711360Z", + "shell.execute_reply": "2026-08-11T03:08:58.710543Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 33.9 s, sys: 2.23 ms, total: 33.9 s\n", + "Wall time: 33.9 s\n" + ] + } + ], + "source": [ + "%%time\n", + "vol_prior = stats.multivariate_normal(\n", + " mean=np.array([50.0, 3.0, 1.2 * 40 ** (1 / 3), 0.65]),\n", + " cov=np.diag([7.0, 7.0, 0.2, 0.2]) ** 2,\n", + ")\n", + "\n", + "\n", + "def make_vol_sampler():\n", + " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=omp_vol.params,\n", + " starting_location=vol_prior.mean,\n", + " prior=vol_prior,\n", + " initial_proposal_cov=vol_prior.cov / 100,\n", + " )\n", + "\n", + "\n", + "theta_prior_xs = stats.multivariate_normal(\n", + " mean=np.zeros(c_vol_gp.n_params), cov=4.0 * np.eye(c_vol_gp.n_params)\n", + ")\n", + "\n", + "walker_vol_plain = rxmc.walker.Walker(\n", + " make_vol_sampler(), rxmc.evidence.Evidence([c_vol_plain]), rng=rng\n", + ")\n", + "walker_vol_gp = rxmc.walker.Walker(\n", + " make_vol_sampler(),\n", + " rxmc.evidence.Evidence([c_vol_gp]),\n", + " likelihood_samplers=[\n", + " make_nuisance_sampler(\n", + " c_vol_gp.params, theta_prior_xs, 0.04 * np.eye(c_vol_gp.n_params)\n", + " )\n", + " ],\n", + " rng=rng,\n", + ")\n", + "for w in (walker_vol_plain, walker_vol_gp):\n", + " w.walk(n_steps=5000, burnin=1500, batch_size=500, verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "0fcd16d6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:58.713058Z", + "iopub.status.busy": "2026-08-11T03:08:58.712866Z", + "iopub.status.idle": "2026-08-11T03:08:59.631340Z", + "shell.execute_reply": "2026-08-11T03:08:59.630582Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "no discrepancy Vv=32.20±1.17 Wv=22.95±0.67 Rv=4.28±0.05 av=0.66±0.01\n", + "GP discrepancy Vv=44.56±2.89 Wv=17.74±1.27 Rv=4.17±0.14 av=0.60±0.05\n", + "truth Vv=48.00 Wv=3.50 Rv=3.76 av=0.70\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for name, w in [\n", + " (\"no discrepancy\", walker_vol_plain),\n", + " (\"GP discrepancy\", walker_vol_gp),\n", + "]:\n", + " ch = w.model_sampler.chain\n", + " print(\n", + " f\"{name:16s} \"\n", + " + \" \".join(\n", + " f\"{p.name}={ch[:, i].mean():.2f}±{ch[:, i].std():.2f}\"\n", + " for i, p in enumerate(omp_vol.params)\n", + " )\n", + " )\n", + "print(\n", + " \"truth \"\n", + " + \" \".join(f\"{p.name}={v:.2f}\" for p, v in zip(omp_vol.params, volume_truth))\n", + ")\n", + "\n", + "fig = corner.corner(\n", + " walker_vol_gp.model_sampler.chain,\n", + " labels=[p.name for p in omp_vol.params],\n", + " truths=volume_truth,\n", + " truth_color=\"k\",\n", + " color=\"tab:blue\",\n", + ")\n", + "corner.corner(walker_vol_plain.model_sampler.chain, fig=fig, color=\"tab:red\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"with GP discrepancy\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"no discrepancy\")\n", + "fig.legend(loc=\"upper right\");" + ] + }, + { + "cell_type": "markdown", + "id": "65f86f5a", + "metadata": {}, + "source": [ + "## The learned discrepancy vs the missing physics\n", + "\n", + "Conditioning the GP on the posterior-mean residuals\n", + "(`rxmc.predictive.gp_posterior_predictive`) recovers the smooth angular\n", + "structure the deficient model cannot produce — compare it with the *true*\n", + "defect, the difference between the full and volume-only potentials.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d4fb9bb3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:59.633011Z", + "iopub.status.busy": "2026-08-11T03:08:59.632823Z", + "iopub.status.idle": "2026-08-11T03:08:59.846393Z", + "shell.execute_reply": "2026-08-11T03:08:59.845548Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mp_vol = walker_vol_gp.model_sampler.chain.mean(axis=0)\n", + "theta_xs = walker_vol_gp.likelihood_samplers[0].chain.mean(axis=0)\n", + "residuals_xs = obs_xs.y - omp_vol.evaluate(obs_xs, *mp_vol)\n", + "\n", + "angles_vis_rad = obs_xs.visualization_workspace.angles\n", + "disc_mean, disc_cov = rxmc.predictive.gp_posterior_predictive(\n", + " kernel_xs,\n", + " theta_xs,\n", + " obs_xs.x,\n", + " residuals_xs,\n", + " angles_vis_rad,\n", + " train_noise_var=obs_xs.y_stat_err**2,\n", + ")\n", + "\n", + "true_defect = omp_full.visualizable_model_prediction(\n", + " obs_xs, *full_truth\n", + ") - omp_vol.visualizable_model_prediction(obs_xs, *volume_truth)\n", + "\n", + "angles_vis_deg = np.rad2deg(angles_vis_rad)\n", + "disc_std = np.sqrt(np.diag(disc_cov))\n", + "plt.plot(angles_vis_deg, true_defect, \"k:\", label=\"true defect (full - volume)\")\n", + "plt.plot(angles_vis_deg, disc_mean, color=\"tab:blue\", label=\"GP posterior mean\")\n", + "plt.fill_between(\n", + " angles_vis_deg,\n", + " disc_mean - disc_std,\n", + " disc_mean + disc_std,\n", + " alpha=0.3,\n", + " color=\"tab:blue\",\n", + ")\n", + "plt.plot(np.rad2deg(obs_xs.x), residuals_xs, \".\", color=\"gray\", label=\"residuals\")\n", + "plt.xlabel(r\"$\\theta$ [deg]\")\n", + "plt.ylabel(r\"$\\delta(d\\sigma/d\\Omega)$ [b/sr]\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "35d64f79", + "metadata": {}, + "source": [ + "## Takeaways, continued\n", + "\n", + "- **Same API, real physics**: `discrepancy_term(support, kernel)` on a\n", + " differential cross section works exactly as in the toy — the kernel just\n", + " acts on the angle grid (radians), so its length scale is angular.\n", + "- Without the discrepancy term the deficient potential's parameters must\n", + " contort to mimic the missing surface absorption (note $V_v$ lands many\n", + " $\\sigma$ from the truth, and $W_v$ inflates to play the role of $W_d$);\n", + " with it, the GP absorbs the angle-correlated defect and the geometry\n", + " parameters relax to the truth. $W_v$ remains partially biased — volume and\n", + " surface absorption are genuinely degenerate at one energy, and no\n", + " discrepancy model can restore information the data do not contain.\n", + "- `rxmc.predictive.gp_posterior_predictive` reconstructs the learned\n", + " discrepancy on any angle grid — useful for comparing against candidate\n", + " missing-physics terms.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/linear_calibration_demo.ipynb b/examples/linear_calibration_demo.ipynb index a27e023..93b6152 100644 --- a/examples/linear_calibration_demo.ipynb +++ b/examples/linear_calibration_demo.ipynb @@ -12,10 +12,25 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "69d96b52-427c-4345-8622-d2726544a77c", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:02.712511Z", + "iopub.status.busy": "2026-08-11T03:09:02.712346Z", + "iopub.status.idle": "2026-08-11T03:09:05.354221Z", + "shell.execute_reply": "2026-08-11T03:09:05.353431Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], "source": [ "from collections import OrderedDict\n", "\n", @@ -29,9 +44,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "315006bb-c255-4555-b458-e00bfef26ef9", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.355925Z", + "iopub.status.busy": "2026-08-11T03:09:05.355653Z", + "iopub.status.idle": "2026-08-11T03:09:05.358653Z", + "shell.execute_reply": "2026-08-11T03:09:05.357898Z" + } + }, "outputs": [], "source": [ "rng = np.random.default_rng(49)" @@ -47,9 +69,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "ab500ce6-552f-4c9e-9b0f-648d456e4a53", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.360296Z", + "iopub.status.busy": "2026-08-11T03:09:05.360000Z", + "iopub.status.idle": "2026-08-11T03:09:05.363673Z", + "shell.execute_reply": "2026-08-11T03:09:05.362944Z" + } + }, "outputs": [ { "name": "stdout", @@ -58,33 +87,32 @@ "Help on class Parameter in module rxmc.params:\n", "\n", "class Parameter(builtins.object)\n", - " | Parameter(\n", - " | name,\n", - " | dtype=,\n", - " | unit='',\n", - " | latex_name=None,\n", - " | bounds=(-inf, inf)\n", - " | )\n", + " | Parameter(name, dtype=, unit='', latex_name=None, bounds=(-inf, inf))\n", + " |\n", + " | A single scalar model parameter.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | name : str\n", + " | Human-readable name of the parameter.\n", + " | dtype : type, optional\n", + " | Data type of the parameter value. Defaults to ``float``.\n", + " | unit : str, optional\n", + " | Physical unit string (e.g. ``\"MeV\"``). Defaults to ``\"\"``.\n", + " | latex_name : str, optional\n", + " | LaTeX representation used in plots and documentation. Defaults to\n", + " | ``name`` when not supplied.\n", + " | bounds : tuple of float, optional\n", + " | ``(lower, upper)`` bounds for the parameter. Defaults to\n", + " | ``(-np.inf, np.inf)``.\n", " |\n", " | Methods defined here:\n", " |\n", " | __eq__(self, other)\n", " | Return self==value.\n", " |\n", - " | __init__(\n", - " | self,\n", - " | name,\n", - " | dtype=,\n", - " | unit='',\n", - " | latex_name=None,\n", - " | bounds=(-inf, inf)\n", - " | )\n", - " | Parameters:\n", - " | name (str): Name of the parameter\n", - " | dtype (np.dtype): Data type of the parameter\n", - " | unit (str): Unit of the parameter\n", - " | latex_name (str): LaTeX representation of the parameter\n", - " | bounds (tuple, optional): Bounds for the parameter as a tuple (min, max)\n", + " | __init__(self, name, dtype=, unit='', latex_name=None, bounds=(-inf, inf))\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", @@ -117,9 +145,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "0669a9b0-3941-429b-887f-edcfeb909453", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.365347Z", + "iopub.status.busy": "2026-08-11T03:09:05.365169Z", + "iopub.status.idle": "2026-08-11T03:09:05.368679Z", + "shell.execute_reply": "2026-08-11T03:09:05.368006Z" + } + }, "outputs": [ { "name": "stdout", @@ -130,9 +165,18 @@ "class PhysicalModel(builtins.object)\n", " | PhysicalModel(params: list[rxmc.params.Parameter])\n", " |\n", - " | Represents an arbitrary parameteric model $y_{model}(x;params)$, for\n", - " | comparison to some experimental measurement $\\{x_i, y(x_i)\\}$ contained\n", - " | in an Observation object\n", + " | Abstract base class for parametric physical models.\n", + " |\n", + " | Represents an arbitrary parametric model\n", + " | $y_{\\mathrm{model}}(x;\\,\\alpha)$ for comparison to an experimental\n", + " | measurement $\\{x_i,\\, y(x_i)\\}$ encapsulated in an\n", + " | :class:`~rxmc.observation.Observation`.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | params : list of Parameter\n", + " | Parameters that define the model. Each entry should carry a name\n", + " | and a data type.\n", " |\n", " | Methods defined here:\n", " |\n", @@ -140,21 +184,29 @@ " | Call self as a function.\n", " |\n", " | __init__(self, params: list[rxmc.params.Parameter])\n", - " | Initialize the PhysicalModel with a list of parameters.\n", - " | Parameters:\n", - " | ----------\n", - " | params: list[Parameter]\n", - " | A list of Parameter objects that define the model's parameters.\n", - " | Each Parameter should have a name and a dtype.\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", " | evaluate(self, observation: rxmc.observation.Observation, *params) -> numpy.ndarray\n", " | Evaluate the model at the given parameter values.\n", - " | Should be overridden by subclasses.\n", " |\n", - " | Parameters:\n", + " | Must be overridden by subclasses.\n", + " |\n", + " | Parameters\n", " | ----------\n", - " | observation: Observation object containing x and y data.\n", - " | params: Parameters for the model, should match the model's parameters.\n", + " | observation : Observation\n", + " | Observation containing the independent-variable grid.\n", + " | *params : float\n", + " | Model parameter values.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | np.ndarray\n", + " | Predicted observable values on the observation grid.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | NotImplementedError\n", + " | Always — subclasses must implement this method.\n", " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", @@ -184,9 +236,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "3c64a7e3-c4a4-41e4-a7de-34eb7ab4728a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.370349Z", + "iopub.status.busy": "2026-08-11T03:09:05.370147Z", + "iopub.status.idle": "2026-08-11T03:09:05.373852Z", + "shell.execute_reply": "2026-08-11T03:09:05.373217Z" + } + }, "outputs": [ { "name": "stdout", @@ -195,119 +254,91 @@ "Help on class Observation in module rxmc.observation:\n", "\n", "class Observation(builtins.object)\n", - " | Observation(\n", - " | x: numpy.ndarray,\n", - " | y: numpy.ndarray,\n", - " | y_stat_err=None,\n", - " | y_sys_err_normalization=None,\n", - " | y_sys_err_normalization_mask=None,\n", - " | y_sys_err_offset=None,\n", - " | y_sys_err_offset_mask=None\n", - " | )\n", - " |\n", - " | A class to represent an observation with statistical errors,\n", - " | as well as systematic errors associated with a common normalization\n", - " | and offset of all or some of the data points of the the dependent\n", - " | variable y.\n", - " |\n", - " | Attributes:\n", + " | Observation(x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None)\n", + " |\n", + " | Experimental data: ``x``, ``y``, and the statistical error on ``y``.\n", + " |\n", + " | Parameters\n", " | ----------\n", " | x : np.ndarray\n", - " | The independent variable data.\n", + " | Independent-variable data.\n", " | y : np.ndarray\n", - " | The dependent variable data.\n", - " | statistical_covariance : np.ndarray\n", - " | The covariance matrix representing the statistical errors of y.\n", - " | systematic_offset_covariance : np.ndarray\n", - " | The covariance matrix representing systematic errors associated with\n", - " | the offset of y.\n", - " | systematic_normalization_covariance : np.ndarray\n", - " | The fractional covariance matrix representing systematic errors\n", - " | associated with the normalization of y.\n", + " | Dependent-variable data, same shape as ``x``.\n", + " | y_stat_err : np.ndarray, optional\n", + " | Statistical (uncorrelated) error on ``y``. Defaults to zeros.\n", + " | y_sys_err_normalization : float or np.ndarray, optional\n", + " | Reported *fractional* (dimensionless) normalisation uncertainty —\n", + " | inert metadata; see :meth:`systematic_terms`.\n", + " | y_sys_err_offset : float or np.ndarray, optional\n", + " | Reported *absolute* offset uncertainty, in the same units as ``y`` —\n", + " | inert metadata; see :meth:`systematic_terms`.\n", + " | label : str, optional\n", + " | Human-readable dataset identifier used in error messages.\n", + " |\n", + " | Attributes\n", + " | ----------\n", + " | x, y : np.ndarray\n", + " | The data.\n", + " | y_stat_err : np.ndarray\n", + " | Statistical error on ``y`` (raw, not squared).\n", + " | y_sys_err_normalization : float or np.ndarray or None\n", + " | Fractional normalisation uncertainty (dimensionless).\n", + " | y_sys_err_offset : float or np.ndarray or None\n", + " | Absolute offset uncertainty (units of ``y``).\n", + " | label : str or None\n", + " | Human-readable dataset identifier.\n", " | n_data_pts : int\n", - " | The number of data points in the observation.\n", + " | Number of data points.\n", " |\n", " | Methods defined here:\n", " |\n", - " | __init__(\n", - " | self,\n", - " | x: numpy.ndarray,\n", - " | y: numpy.ndarray,\n", - " | y_stat_err=None,\n", - " | y_sys_err_normalization=None,\n", - " | y_sys_err_normalization_mask=None,\n", - " | y_sys_err_offset=None,\n", - " | y_sys_err_offset_mask=None\n", - " | )\n", - " | x : np.ndarray\n", - " | The independent variable data.\n", - " | y : np.ndarray\n", - " | The dependent variable data.\n", - " | y_stat_err : np.ndarray, optional\n", - " | The statistical error associated with y. Defaults to an array of\n", - " | zeros with the same shape as y.\n", - " | y_sys_err_normalization : float or array-like, optional\n", - " | The fractional systematic error associated with normalization of y.\n", - " | Defaults to 0.0. If array-like object is passed in, that implies\n", - " | that there are multiple systematic errors associated with\n", - " | normalization, each corresponding to an entry in\n", - " | `y_sys_err_normalization_mask`.\n", - " | y_sys_err_normalization_mask : list of np.ndarray, optional\n", - " | Masks for the systematic errors associated with normalization of y.\n", - " | Each mask should have the same shape as y, and the systematic error\n", - " | associated with normalization will only apply to the points where\n", - " | the mask is True. Defaults to None, meaning no systematic errors\n", - " | associated with normalization, or equivalently, a single\n", - " | systematic error for all points.\n", - " | y_sys_err_offset : float or array-like, optional\n", - " | The systematic error associated with the offset of y. Defaults to\n", - " | 0.0. If array-like object is passed in, that implies that there\n", - " | a multiple systematic errors associated with normalization, each\n", - " | corresponding to an entry in `y_sys_err_normalization_mask`.\n", - " | y_sys_err_offset_mask : list of np.ndarray, optional\n", - " | Masks for the systematic errors associated with the offset of y.\n", - " | Each mask should have the same shape as y, and the systematic error\n", - " | associated with the offset will only apply to the points where\n", - " | the mask is True. Defaults to None, meaning no systematic errors\n", - " | associated with the offset, or equivalently, a single systematic\n", - " | error for all points.\n", - " |\n", - " | covariance(self, y)\n", - " | Returns the default covariance matrix for the observation,\n", - " | which is the sum of the statistical and systematic offset covariance\n", - " | matrices, and the fractional normalization covariance matrix\n", - " | multiplied by the outer product of y with itself.\n", + " | __init__(self, x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", + " |\n", + " | num_pts_within_interval(self, ylow: numpy.ndarray, yhigh: numpy.ndarray, xlim=None)\n", + " | Number of points of ``y`` that fall within ``[ylow, yhigh)``.\n", + " |\n", + " | Useful for empirical-coverage diagnostics.\n", " |\n", " | Parameters\n", " | ----------\n", - " | y : np.ndarray\n", - " | The dependent variable data for which to compute the covariance.\n", - " |\n", - " | num_pts_within_interval(\n", - " | self,\n", - " | ylow: numpy.ndarray,\n", - " | yhigh: numpy.ndarray,\n", - " | xlim=None\n", - " | )\n", - " | Returns the number of points in y that fall between ylow and yhigh,\n", - " | useful for calculating emperical coverages\n", + " | ylow, yhigh : np.ndarray\n", + " | Interval bounds, same shape as ``y``.\n", + " | xlim : tuple, optional\n", + " | ``(x_min, x_max)`` range to restrict the count.\n", + " |\n", + " | statistical_term(self, support) -> rxmc.covariance.DenseTerm\n", + " | The always-on, genuinely uncorrelated statistical diagonal.\n", " |\n", " | Parameters\n", " | ----------\n", - " | ylow : np.ndarray, same shape as self.y\n", - " | yhigh : np.ndarray, same shape as self.y\n", - " | xlim : tuple, optional\n", - " | If provided, only consider points where self.x is within\n", - " | this range. Defaults to None, meaning all points are\n", - " | considered.\n", + " | support : np.ndarray\n", + " | Indices of this observation's block in the stacked vector.\n", " |\n", " | Returns\n", " | -------\n", - " | int\n", - " | The number of points in self.y (within xlim) that fall\n", - " | within the specified interval defined by ylow and yhigh.\n", + " | DenseTerm\n", + " | ``diag(y_stat_err**2)`` on ``support``.\n", + " |\n", + " | systematic_terms(self, support) -> list\n", + " | This dataset's reported correlated systematics as fixed rank-one terms.\n", + " |\n", + " | Opt-in — **not** added to any covariance automatically. Pass the result\n", + " | via ``Constraint(extra_terms=[*obs.systematic_terms(support), ...])``.\n", + " | Zero magnitudes are skipped, so an observation without reported\n", + " | systematics yields an empty list.\n", " |\n", - " | residual(self, ym: numpy.ndarray)\n", + " | Parameters\n", + " | ----------\n", + " | support : np.ndarray\n", + " | Indices of this observation's block in the stacked vector.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | list of Term\n", + " | The absolute offset mode (``outer(omega, omega)``) first, then the\n", + " | fractional, prediction-scaled normalisation mode\n", + " | (``eta**2 * outer(ym, ym)``).\n", " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", @@ -335,9 +366,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "9f859e53-c6f9-4d88-b7bf-bbc5bc9ab686", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.375707Z", + "iopub.status.busy": "2026-08-11T03:09:05.375530Z", + "iopub.status.idle": "2026-08-11T03:09:05.379066Z", + "shell.execute_reply": "2026-08-11T03:09:05.378458Z" + } + }, "outputs": [], "source": [ "class LinearModel(rxmc.physical_model.PhysicalModel):\n", @@ -367,9 +405,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "b83c6308-935b-4c8a-b1ef-0d65677ec809", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.380724Z", + "iopub.status.busy": "2026-08-11T03:09:05.380525Z", + "iopub.status.idle": "2026-08-11T03:09:05.383075Z", + "shell.execute_reply": "2026-08-11T03:09:05.382377Z" + } + }, "outputs": [], "source": [ "my_model = LinearModel()" @@ -385,9 +430,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "27f09315-06dc-44ee-8190-f5d393974b68", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.384860Z", + "iopub.status.busy": "2026-08-11T03:09:05.384688Z", + "iopub.status.idle": "2026-08-11T03:09:05.390726Z", + "shell.execute_reply": "2026-08-11T03:09:05.390004Z" + } + }, "outputs": [ { "data": { @@ -395,7 +447,7 @@ "array([1, 2, 3])" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -408,9 +460,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "f5de0b99-d85b-4acf-bfb4-eabdc4580688", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.392309Z", + "iopub.status.busy": "2026-08-11T03:09:05.392096Z", + "iopub.status.idle": "2026-08-11T03:09:05.395544Z", + "shell.execute_reply": "2026-08-11T03:09:05.395004Z" + } + }, "outputs": [ { "data": { @@ -418,7 +477,7 @@ "array([3, 5, 7])" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -429,9 +488,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "bf846a07-d5d2-4f34-838c-06b1deca0739", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.397370Z", + "iopub.status.busy": "2026-08-11T03:09:05.397069Z", + "iopub.status.idle": "2026-08-11T03:09:05.400664Z", + "shell.execute_reply": "2026-08-11T03:09:05.399966Z" + } + }, "outputs": [ { "data": { @@ -439,7 +505,7 @@ "array([3, 5, 7])" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -451,9 +517,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "fb8188e6-7e47-479f-8b72-a8825ae5dacd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.402252Z", + "iopub.status.busy": "2026-08-11T03:09:05.402076Z", + "iopub.status.idle": "2026-08-11T03:09:05.405624Z", + "shell.execute_reply": "2026-08-11T03:09:05.405027Z" + } + }, "outputs": [ { "name": "stdout", @@ -487,9 +560,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "d251f717-09be-4280-b59d-de137fd7cfc2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.407376Z", + "iopub.status.busy": "2026-08-11T03:09:05.407202Z", + "iopub.status.idle": "2026-08-11T03:09:05.409979Z", + "shell.execute_reply": "2026-08-11T03:09:05.409330Z" + } + }, "outputs": [], "source": [ "prior_mean = OrderedDict(\n", @@ -508,9 +588,16 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "016fc2de-c206-44c1-916a-a3b663a8fd25", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.411250Z", + "iopub.status.busy": "2026-08-11T03:09:05.411020Z", + "iopub.status.idle": "2026-08-11T03:09:05.413480Z", + "shell.execute_reply": "2026-08-11T03:09:05.412844Z" + } + }, "outputs": [], "source": [ "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", @@ -519,9 +606,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "d28fcb22-9ca7-4846-9cba-24b7b4808e2c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.414714Z", + "iopub.status.busy": "2026-08-11T03:09:05.414573Z", + "iopub.status.idle": "2026-08-11T03:09:05.417834Z", + "shell.execute_reply": "2026-08-11T03:09:05.417232Z" + } + }, "outputs": [], "source": [ "n_prior_samples = 1000\n", @@ -539,9 +633,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "70a97727-68ec-4eea-880f-203a3f0817cc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.419363Z", + "iopub.status.busy": "2026-08-11T03:09:05.419191Z", + "iopub.status.idle": "2026-08-11T03:09:05.426888Z", + "shell.execute_reply": "2026-08-11T03:09:05.426199Z" + } + }, "outputs": [], "source": [ "x = np.linspace(0, 1, 10)\n", @@ -560,9 +661,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "e8476136-5ab0-42c7-a3fe-88539ee7a019", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.428500Z", + "iopub.status.busy": "2026-08-11T03:09:05.428328Z", + "iopub.status.idle": "2026-08-11T03:09:07.420058Z", + "shell.execute_reply": "2026-08-11T03:09:07.419311Z" + } + }, "outputs": [ { "data": { @@ -570,13 +678,13 @@ "Text(0.5, 1.0, 'prior')" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -601,9 +709,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "30ed8fc8-d5e9-4e58-85e8-aba6b8683d00", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.421881Z", + "iopub.status.busy": "2026-08-11T03:09:07.421708Z", + "iopub.status.idle": "2026-08-11T03:09:07.579757Z", + "shell.execute_reply": "2026-08-11T03:09:07.579177Z" + } + }, "outputs": [ { "data": { @@ -611,13 +726,13 @@ "Text(0.5, 0.98, 'prior')" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfoAAAIVCAYAAAA57z2DAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZw5JREFUeJztvQe0Y1X9v71HhipVBmEoQy9DZ0CqMIAgCIgwgKIMvQhKlyJKR0B6kypI9QcqgiIdlaoCShUYpDP03odO3vXs9e77P5NJObk3uUlOnmets+69SW5ycpJzPvvbh5RKpVIQERGRQvKldu+AiIiItA6FXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkTCPPPME7bZZhuPhEgBGdruHRCR9nPllVeG6aefvt27ISItYIi97kV6lw8//DBMPfXUTX3Ozz//PHz22WdhyimnbOrzikj/0HUv0uUceuihYciQIeG+++4LY8aMiZb5DDPMEMaOHRtee+21idzzG2ywQbjiiivCMsssE6aaaqpw2GGHVXXdjx8/Pj7HV7/61SjaI0eODCeccEL44osv+h7zzDPPxNc+9thjwy9+8Ysw77zzxsfefPPNg3gERKQWuu5FCsLGG28cvvvd74add945PPzww+Gggw4KjzzySLjrrrvC5JNPHh9z7733hnHjxoUDDzwwivKXv/zlis/FAmHllVcOn3zySTjiiCPiQuDqq68O++yzT3jyySfDGWecMdHjTz311LDQQguF448/Pi40FlxwwUF5zyJSH4VepCBgzWNZwze/+c0w66yzhi222CL8/ve/jz/h1VdfjeKPKNfixBNPDC+88EJcJCy//PLxtnXWWSe65c8666yw5557TvQceAduuOGGvgWFiHQOuu5FCkIS8wTW/dChQydyoy+55JJ1RR7+/ve/h0UXXbRP5BO490ulUrw/y4YbbqjIi3QoCr1IQZhtttkm+huRn3nmmcMbb7zRd9vw4cNzPRf/U+mxs88+e9/9WfI+r4gMPgq9SEF4+eWXJ/qbzHcEGbFPkDiXB/7npZdemuT2F198Mf4cNmzYRLfnfV4RGXwUepGC8Nvf/naiv4nNI/arr756w8/1jW98I8bySd7LctFFF0VRX2ONNQa8vyIyOJiMJ1IQKJvDXb/22mv3Zd0vtdRSMVbfKHvttVcU9fXXXz8cfvjhYe655w7XXHNNzLbfZZddcsX5RaQzUOhFCiT01NSfeeaZ0er+9re/HU4++eQwxRRTNPxcs8wyS/jnP/8ZDjjggLi9++67Yb755otZ/XvvvXdL9l9EWoOd8US6HMSdxjfUvpfHzkVEjNGLiIgUGIVeRESkwOi6FxERKTBa9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKzNB270CR+OKLL8KLL74YpptuujBkyJB2745IR1EqlcJ7770XZp999vClL2ljiAwWCn0TQeTnmmuuZj6lSOF47rnnwpxzztnu3RDpGRT6JoIlny5k008/fTOfWqTreffdd+NCOJ0nIjI4KPRNJLnrEXmFXqT2eSIig4OBMhERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMAq9iIhIgVHoRURECoxCLyIiUmAUehERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMAq9iIhIgXFMrXQU48ePD6+//nrdxw0bNiyMGDFiUPZJRKSbUeilo0R+5MiRYcKECXUfO80004Rx48Yp9iIidVDopWPAkkfkL7nkkij41UDgx44dGx+vVS8iUhuFXjoORH7UqFHt3g0RkUJgMp6IiEiBUehFREQKjEIvIiJSYIzRS9dCUl49LMMTkV5HoZeuA/GmvI7M+3pYhicivY5CL10HJXVY8/Ua61iGJyKi0EsXi7019CIi9TEZT0REpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKzNB274D0BuPHjw+vv/56zceMGzdu0PZHRKRXUOhlUER+5MiRYcKECXUfO80004Rhw4b5qYiINAmFXloOljwif8kll0TBrwUiP2LECD8VEZEmodDLoIHIjxo1yiMuIjKImIwnIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwlteJ5OzcB9b5i0i3odBLz9No5z5a9drUR0S6BYVeep68nfsQ+LFjx8bHK/Qi0i0o9CL/P3buE5EiYjKeiIhIgVHoRURECoxCLyIiUmAUehERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMAq9iIhIgbEznkiD0Aq3Hg6/EZFOQaEXyQnizVAb+t3Xw+E3ItIpKPQiOWGQDdZ8vXG2Dr8RkU5CoRdpUOydXCci3YTJeCIiIgVGoRcRESkwCr2IiEiBUehFREQKjMl4Enq97j1PXbyISLei0EthabTunceLiBQNhV5Cr9e9g53sRKSoKPRSaKx7F5Fex2Q8ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYIa2ewekuxk/fnx4/fXXaz5m3Lhxg7Y/IiIyMQq9DEjkR44cGSZMmFD3sdNMM00YNmyYR1tEZJBR6KXfYMkj8pdcckkU/Fog8iNGjPBoi4gMMgq9DBhEftSoUR5JEZEOxGQ8ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjHX0Ii0iT+tfGwmJSKtR6EWaDOJNy9+xY8fWfSyPY0Fg10ARaRUKvUiTQbQR7zzDflgM8DiFXkRahUIv0gIQbsVbRDoBk/FEREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYIa2ewekMxk/fnx4/fXXaz5m3Lhxg7Y/IiLSPxR6qSjyI0eODBMmTKh7dKaZZpowbNgwj6KISIei0MskYMkj8pdcckkU/Fog8iNGjPAoioh0KAq9VAWRHzVqlEdIRKSLMRlPRESkwGjRi7SZPEmNhkhEpL8o9CJtAvEmmXHs2LF1H8vjWBCYDyEijaLQi7QJRBvxzlPGyGKAxyn0ItIoCr1IG0G4FW8RaSUm44mIiBQYhV5ERKTAKPQiIiIFRqEXEREpMAq9iIhIgVHoRURECoxCLyIiUmAUehERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMAq9iIhIgVHoRURECoxCLyIiUmAUehERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMEPbvQMyuIwfPz68/vrrNR8zbty4QdsfERFpLQp9j4n8yJEjw4QJE+o+dppppgnDhg0blP0SEZHWodD3EFjyiPwll1wSBb8WiPyIESMGbd9ERKQ1KPQ9CCI/atSodu+GiIgMAibjiYiIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjOV1Il1Cno6F9j8QkXIUepEOB/GmU+HYsWPrPpbHsSCw2ZGIJBR6kQ4H0Ua888woYDHA4xR6EUko9CJdAMKteItIf1DoC4JT6UREpBIKfQFwKp2IiFRDoS8ATqUTEZFqKPQFwql0IiJSjg1zRERECoxCLyIiUmB03YsUDDvoiUgWhV6kINhBT0QqodCLFAQ76IlIJRR6kQJhBz0RKcdkPBERkQKj0IuIiBQYhV5ERKTAKPQiIiIFRqEXEREpMGbddziOnxURkYGg0Hcwjp+VVmIHPZHeQKHvYBw/K63ADnoivYVC3wU4flaaiR30RHoLhb4F3H///WHaaaeta1VxwRUpQge9PLkk77//ftNeT0Tyo9C3gNGjR9d9zDTTTBNjpIq9dHss/7XXXgtjxowJEyZMGLR9EpH8KPQt4JxzzgnLLrtszQvn2LFjowWk0EtRYvnXX399mGWWWao+5p577gk77bRTk/dSROqh0LeAhRdeOIwaNaoVTy3ScbH8vKEoXfci7UGhbyKlUin+/OCDD8K7775b94KHhVPr4ve///2v7/G1nk+kVcw444xxy0O97yjnRfY8EZHBYUjJs65pPP/882GuueZq3hOKFJDnnnsuzDnnnO3eDZGeQaFvIl988UV48cUXw3TTTReGDBnSzKeO1hKLCC6S008/feh0um1/wX1uLdgU7733Xph99tnDl75k922RwULXfRPh4tVqSwXR7Bbh7Mb9Bfe5dcwwwwwtfHYRqYTLahERkQKj0IuIiBQYhb5LmHLKKcMhhxwSf3YD3ba/4D6LSBExGU9ERKTAaNGLiIgUGIVeRESkwFhe1yV19CLdTt46es8jkeb2o1Domwgib2c8kYF1xvM8Emluh0mFvolgyacPoNuaxHQbeTo3MzaVjclqX/7ylwdlv6R+58F0nlTD80hk4OdRFoW+iSR3fTd2Viui0PMZGELpPOp9Jp5HIvVp5NpmMp6IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFJieFfpXXnklfPrpp+3eDRERkZbSk0J/3333heHDh4c77rij3bsiIiLSUnqujv6BBx4Io0ePDnvttVdYY401KtZn561P/Pjjj+OWbWQgg4P18SIi+egpi/6hhx4KK6+8cthjjz3CCSecEEX90UcfDX/729/CU0891Scg9NrOw9FHHx1mmGGGvs32tyIi0mn0zDx6LO9NN900XHvtteHzzz+Pt62//voxVn/vvfeGJZdcMiy33HLh3HPPzW3ZV7LoEft33nnHzngiZXB+sCCud37kfZxIL/JuP86PnrHoJ5988vCzn/0sLLjggmGVVVYJ3/zmN+PkHyx7LP2tt9463HnnnWG//fbL7Rqecsop+9rd2vZWREQ6kZ6J0SPqK620Uvjtb38bttpqq2iJX3XVVXHUH8w333zhiSeeCP/85z/D+++/H6addtp277KIiMiA6RmhT4waNSqKPS77r371q/E2YvJTTTVVmHvuucPtt9+ee8aviIhIp1N4oS+PtfM78XhIgp5+Pv7442GppZaKbn4REZEiUEihf+mll8Jbb70VFl100Yqx9nKL/c033wzHH398+POf/xxuueUWhV5Euprx48eH119/ve7jhg0bFkaMGDEo+yTto3BC/8ILL0SrfLXVVovJd2TS1+L6668Pl156aSyxu+GGG+LiQESkm0V+5MiRYcKECXUfO80004Rx48Yp9gWncEL/2GOPxbIDttNOOy3WzBOXT7F4SuuyrvnFF188rLrqquGQQw6JCXkiIt0Mljwif8kll0TBrwYCP3bs2JiXVOtxoOXf3RRO6LHm11tvvVgjf/bZZ4cTTzwxHHDAAWGxxRaL9yeRP//888Oaa64ZE/C22247E/BEpFAg3snIqSbeWPSIfT20/LubQgk91job3e7OOOOMMMsss8Tudaecckp4+OGHY3/7yy+/PK5guR13/QUXXBAmm2yydu+6iMigQmweq75eLD9Z/jzOeH53UiihJ8kOcf/a174Wm+BsvPHGsakNzXCom99xxx3j43DV77PPPmHttdcOQ4cW6hCIiOQG4Va8i0+hCsZThj0WOtnzcMUVV0Qrn9a0WPI0xIGddtopzDvvvG3dXxERkVYztIg188TeGVLzox/9KPa2v+eee8L9998f9t133zDFFFPEuBWWvhPQRESk6BRK6JNwY6lvu+22YdZZZw1XX311/JuN+0nWowueiIhIL1AooU/Q054pdNTQ0wUvWfobbbRRu3dNRERkUCmk0FNCt8022/SVzOmiFxGRXqVQyXhZHEwjIiJSYKEXERGRgrrupfiQd5GHvGGbZj+fiEinoEUvIiJSYLTopatheMcHH3wQvvzlL8d+3CK9Pn6WlrUiWRR66WoQ+c8++yz+VOilyDQ6fpahNSKg0EtXgyWfLHqRIpN3/Cw4VlayKPTS1WC5aMlLL1Fv/KxIOSbjiYiIFBiFXkREpMAo9FIIqIPPWwvfH4iNvvbaazEfQESkm1DopetAbBHdlH1MNvIyyywTN35vdXa/iEg3YTKeVOSLL75oaqe4ZnaoQ2wR+Y8//jgK+/rrrx+efvrpeN8aa6wRrrnmmjDXXHPFv/Nm49fbv0az+/Mevw8//DBXHwA78olIf9Gil64DUZxsssnCG2+80Sfy8847b9z4ndueeOKJ8NZbb+WqOc77ml/96lebXsanp0BEWo1CL10Hlu/7778fxowZ0yfy1157bdyS2H/nO9+J1n6nu9pZOAwdOtQ+ACLSMhR66Tqy7vok8nPOOWfcktjzmM033zw8//zzodPAy5Can7BomWWWWewFICItQ6GXroIY/nrrrTeJyCeyYo/I/+AHP2hpNn5/QOBJ7GtWWEFEpBYKveSyPGs9JpsBPxjgtocdd9xxIpFPcBv3wXvvvRcT3joJrHjc9Xb0E5HBQKGXhi3P7AJgsJPJyD7fd9994++nn356zLwvh9t+9atfxd9//OMfd1ycPg0cUehFZDBQ6KVhyzO7AGh1Mlklj8H2228fZp999vDCCy+Eiy++eJL/ueiii8KLL74Yhg8fHrbccksT3USkp1HopWHLM7sAaHUyWSWPwVRTTRV+8pOfxN+PP/74iax6fuc2wPLHjd8OyzlP2ENEZDBQ6KWjXM/lFnw1j8FWW21V0apP1jz38ZhOTrhrR36DiPQeCn2X9HCvtzX7+b70pS/l2j7//POJNpLfXnnllfgzezud4vJsWQue/Zh66qnjooKf2f2bccYZw/777x/f0wknnBBj92z8Dj/96U/DDDPMkPv98pr1tnfffTe8+uqruWL+2QVKtWOXFgPpvTZjExEpp+eF3otjc0G8EPb+WqmNZKRvt912YY455ohldOeff374zW9+Ey18buO+ZpMV5mZ00kuLAZPyRKSV9Gyvey7YXGSzPcQRfXuKDwxEKzWC6e//5/1fYvX77bdf2GOPPcIxxxzTt2jD0p9yyin79fr19u2jjz5qWnIfz4OnQkSklfSk0D/yyCPhxBNPDE899VQYNWpUWHXVVWPLVEV+4DQi1M0Ay/3YY4/t64DXLGueMEIKByR4X9NPP/2An1tEZDDpOdf9o48+GlZZZZV4IZ9vvvnCk08+Gb7//e+HI488smF3PhnexG2zWy+DtbviiivGrVJ9eysy15NVn2iGNU/7XBaAiyyySPjTn/5keEdEupqes+jPPffcMHr06BjPBYTk97//fdhzzz1jB7Vf/OIX0YrL48Y/+uijw2GHHRa6idTkpt5Y1P7AMb3nnnv6ft9ll136XpNFQKPWPv/33//+N06qW2211ao+DguebPv0e6XnSeGEeq+PyK+99trR2wObbbZZ+OY3vxlOPvnksOCCC+bedxGRTqGnLHrEmwv4FFNM0XcbGd0777xzOOuss6Jwn3HGGfH2PG78Aw44ILzzzjt923PPPRc6nVZ1skPIcaEnfvnLX/ZZ9ZVKzfJY6zfeeGNYZ511wje+8Y0otFlPS/b/servvPPOuCVrPnt/3lK3+++/P74W3xG8PdTq811hP5Zeeulw0EEHdVyXPRGRevSU0CPeWIZc0MeNG9d3O6VODD858MADw5lnnhkHpuQBUSFmm906nVZ1sstmvLNRy568JpUy6bPiW0n0L7/88rDNNtv0leYhujvttFP45JNPcmX3Z++v1eGP12W7++6749jbZ555Jor8X//617hY4buCRc/r8veiiy4arrzyyra58629F5FG6Smhh+WWWy7WV1OOlR1hilW47rrrRrF66aWXQreQLvx5Lc1WdLLLWvPEyFPMnEx4rPpKDXay4ltucSPyLLwQalrY0umOxRgLByx8hJn/w6Vf6X3wPIRhEOfkrq/U4Ce97oMPPhhd/nhkksjPNddc8TG466+++urwhz/8IYwYMSK69lkQfOtb3wqPP/54GGwGe7aAiHQ/PSf0X//616OIEJc/55xz+mKxsPDCC8eWqc1IJOulC395/Xqqb+e2ZNWXkxXfrOiXi/x5550X9tprr3DVVVeF6aabLtx2221hpZVWipZ3te58CDgud0rXai1ouO/ll18OO+ywQ0WRz3qCNtpoo5gv8POf/zw+9w033BAWX3zx+Pebb74Zj3+9rZIXoFoIo9rtrZ4tICIFpNRDfP75532/H3nkkaWFF164tPnmm5duuOGG0uOPP17ad999S3PMMUfphRde6Nfzv/POO1zJ48/B4v333y+98sor8Wcevvjii4pb9nn4m2OVZ3v77bfjMeN9n3LKKaWPPvoobieffHK8jfs4Hnme63e/+11psskmi/+3ySablJ5++unS+PHj+7abbrqpNNdcc8X7p5tuutJVV11V+vTTTyfaeK2nnnoqbvxefn92e/LJJ0vzzTdffL555503fgfS/lfb3nvvvdJ9991XWmutteL/NbLNM888pd/+9reld999Nz4PG8ec7xs/s8ei/PYikPf8aMd51A3cc8898bjwsxdeV5p3fhTSosfCoowO12qK6QLuX+K98LOf/Swm0+HixWW/8cYbR/fsX/7yl9gnvVvI04GtlZ6BCy64oM+aJ6ae4Pdk1fOYemQt+U022SS663HNZ8HjwuezwgorxBa7WNkk6bHP2cS7PNZ8NrseS56Eu3JLvhoLLLBAuOKKK8Jvf/vbMM8884S84IXYYostouv/iSeeiLdVyx9wZr2INI1Swfjvf/9bWmaZZUpLLLFEacoppywdccQRpc8++2yix2DNJbBg+Z+HH344Wk8DoRsskWZa9B988EFp+PDhk1jzlaz6CRMmNGzJ8/MnP/lJac899yw98cQTfZY9v2+33XZ9lvIPfvCDaMG/9NJL8dinn3kseX7yv/Us+axFn92wzl9++eW627PPPhs9RlNMMUV8XX7us88+8f/zHOsioEU/MLTopb86UyihR6xnnnnmeAHl9+OPP740ZMiQKA4JRKxVdLPQl295xOe0006byD1fLopZt/6vfvWruiK/5ZZbTiTyY8aM6RPzFVZYoXT//ff3if0nn3wSP98vfelL8f4VV1wxCnYtV301kef2/gp9o1u523/EiBGlyy+/PC5GFfruOY/agUIvpV533eO6pUHL2LFjw3HHHRfLoPbee++YpU12PWVS/Ez18WSEH3HEEe3e7a6D5DVc8ZtvvnmcEAdk2VfqRkclAzPhgaQ1kuoefvjhvvuvu+66SRLvcNezACW0gnucvwlL3HXXXWH99dcPf/vb3+L/8jnS4/7Pf/5zTNKjhh5XfK1eBjwv7v7krq+UeNdqsm5/XpsQwqabbhpDFSIiLaFUEF5//fXSUUcdVXrsscf6bjv88MOjRb/00kuX5pxzztI666xTuv3226N7+nvf+15ppZVWKr3xxhtN24eiWvRYm1jko0aNmiTBbLnllqtozWeteo5/9n+waE8//fSYUMffW2yxRbTQeS2s9YMOOijejrV+5plnxiS8ueeeu+//119//egKT1b6Aw88EBPdyq308o19Sc/x6KOPTnTfYFn02Q3vwtRTTx3358ADD9Si76LzqB1o0Qv0vOueeGfi0ksvjSJ/2WWXRTG/9dZbS8svv3zpkEMOifcjBi+++GKpmRRV6I877riJhHrZZZct/fznPy/dcccdMU6fRxx///vfl9Zee+1JFgqjR48uffjhh32vdcEFF/S54w8++OA+Vz3C/MMf/rDPzT/99NOXTj311Pj8tVzy2Uz8hx56qO91Ef12C/0OO+wQ94VKgnqVCUXAGP3AUOilvzpTqF73uHAT1Fr/5z//icNJgI54s846a+zFjgt33nnnbeOedg9UIiT3O+70XXfdNR7HxKefflr3OSaffPKYSc+G2xwX/YUXXhhmnnnm2M8gtSTGrc/zUxlBaGD77befKAsd9z/VEVRL3HfffWH33XcPl1xySWxbvNRSS4WbbrqpL5N+rbXW6nPNk4n//vvv12yBO9jceuutce4CnHTSSWHaaadt9y6J1CTbTbQa9LagsZR0FoUS+ixzzz133ABhp8yOiylNThxHm4877rgjbL311vF3BPjwww8f8LEjNs6kQLbs4CByLBgVjCAz/S4NFyqH3Ati3JTZ0bKY1rWU2xGvP/jggyuKPQsKPnvKKzsBSgN/9KMfxd+32mqrOCZZpFNJjanIf6oHj+P8pPtmved0QTB4DMGsDz0AIoAVyYW/VVPIGFNLe10G3LSj733qwEbyWrW6+rwfN30I6CJIT4INN9ww1rmX17WXW/Qk1SGuWOQcZyz5RPb3cliEkTRJ1ztOfkR8pplmqrl/w4cPj/306YHPvgGf6/XXXx9/z9bIJ8ueYzPjjDPG+99+++2JjhH7noc8Hox6MCkRrwbv9ZZbbsnVkrhTFimDcX60+zzqVO69996w7LLLRq9k8lQOFiSNshivBa246RGRx3PG9x0PgWLfOP05Pwpr0ScQAS6ml112WbT2um3UaF5hRqiwFNPPbBZ8dkxrNrxRjVdeeSUOckHkl1xyyWhdP/vssxUfi5Am/v3vf4d//etffRn1uOoT1S4SvD+qIxB59o2WufVEPl30gLACYRqqKGiQRIgGVz7ucKzmZNmzeKAKoBqvvvpqyAPNifJQaVEEf//736PIA677vA13sgOAao3brfa65ejVkkZAkPOIMuJdb0HAY/AO8DiFfnDofjOhDiNHjowrTYRkmWWWCUWm2qCXepPesmD1YsFTiogVzDwAxJh4+G677RYXEdVA3BO//vWvc+3z2WefHf7v//4vWqz8vtBCC4VGwfOAaKZOfMktjuCzEEHs11tvvYbGCNMpj62ZcOyYwAc//OEPwxprrNHQ/zfyOYq0A4Qbb0OtjWuyDC6FF/rFFlssJmwR2y0a5SNLq01pqzXpLQsiQotWLHNc3Fie/MTiRsRxizOwpprYJ7c54D2pN+4Xl/phhx0Wfz/00EPjLPj+QoIgI4bLxZ79QOzxSHz/+9/P9VwM0GHQDdtpp50WmgV9B9gPrHhG3jZK3s9RRKSnhL5efLibqdWfPjv9rNoCIAtWOwltiBxu/7POOisKEm57mtSQGU9ciMZDlcSeRjrJnU4cEVJWebUcAKxa4vksLpKlOxDqiX2e8cOPPPJIX5UB0HypGWKPyx7vCPCzP1n2eT5H6U6IgXP+1NryZL2L9KzQF5VaI0sbdfNedNFF0dVN7Pbiiy+OYs0cdrwh3EbnNpIZk9hnxTBZ54BbjoUA8PhK/O9//4viTob9yiuvHK3bZsWMy8Webnr8nsS+Fiw6WBww6IhY/z777NMn9sT4BwKLKOC4Lr300g17a6TYIs95w3ej1kZcOy32RBqh8Ml4RSablFWeNc7tyZrPw6mnnhp/HnTQQbEl65NPPhmzO2H++ecP3/rWt+Lv3/3ud2P8vdyiTxcfrI4f//jH8XfK2rIldGlBgCWPyCO8WP2pjr5ZJLGnFh/PAQsTLpSIPS1wSfqrdFzYz/S+eJ9UAhC+eOutt6L49xeOQcqOJWMaoceNz4Ko2ueT9dY024Lne1GvOkMGj+R5Y1FdL35tWZr0By36gtKIm/eBBx6IDWgIcVAvn0DcuY2RqggmZXB/+tOf4n2IaBZG/dJQJzF69Ojo8k8ij9gRDqCnfbLk8RiwGGgFiH1KviQRMyUKIbRUYVTyIHDbZptt1tco6He/+10U+dlmmy3W+PcXnhfXPYspvAuUBZLcuMgii0Qvyscff9yQt2ag9HcksbQWRL5eIptZ6tIfFHrpc7F/+9vfnsgt+JWvfCWsvvrq8fcrr7wyJtvhTqbEDGu3HBLrSMBjAA2PTc/FAoGEvkMOOaQvJo+I1hN5FgS49XGdf/TRRw1/UqnWmC50WdGtFSZICXssDijRAxY/lYb2NAL/z9AlwhZJ8Kls4LkZdFMu+CzQ8tTX94dWLiJEpPNQ6HsY3IVYl0xSg9QFL0uqhWdKXFoQIIaV3O2UyGFxLLfccn3345ZkUZBK6Oiud8IJJ9R119OVj1p+BJBkOMIJCGMjpKTA22+/PXdDHLop0qkOD8Qbb7wRrfnvfe97oVlUEnxyCaoJfj2ySZd5YfHAYk2hF+kNFPoeBtctcetkpeN+L4ekNCx7RO/BBx+Mrvxyt3016F1PO9vUDIcYJPH5WhY1VjwhAMbXIuxzzjlnLPHjtamFT274PNAcidg4uQbE6fOCxyHRDGu+luATFvnVr341keBTCsqchjykPv4cKxP3RKQSJuO1ANzTbM1oadrsDma40bPPnax5rPQ0EwCyLnyEHUsTaHFJbDmBOFWCmDSihQhh5dO5juS7Z555puq+Ub/P4BpaOwKeAWrrSYSjwyHeBzKPCSeccsopuY4hCw0a37CgWXjhhas+LtsxkPdIwiHHg1r6rNCnpjvcx/OeeOKJccFEkh8JfCmGmrc1JdY1nhSOMZUPhCkIf6yyyirhqKOO6lsYVXPhU6ZHB0P2kfBGns6H2WS8eqEBO+iJdD9a9INMcrW2KxGKJCyS5Cgjw3JMZXG1BlZkG83Uq3dHABFJMsrTgBpq82uVtnEsWAiwMEDkKeEjaQ8LHgHDot9mm236Yu4k09GlLy0I6nXNS6GAvOC14LhwnCpZ8wgxk/XYX7ru0TKYrn4sSthP8hMa7YnP6+y4445xSA+5Evw/JYx8LvTlr8XUU08dFz154/km44n0Flr0bRD6lPHcihhppX7ovB4JaWSSE2vP9qLGcidRbokllqj6nEz8o3EOIl5tmAav8c9//jPG4q+99tp4G1Yq/0c8vlqzGqx4Jtml+5MVXy6wJI9tsMEG0ZXP8+PC5/lJmMt6GKoJPftGnD5vL/hK8JlhwVMSiBCzIMDiJ1uacbssJv7xj3/EjVwE9g+hztvPHljU4GWhQgHvBoskwhYkL3JsyuGz5lhxfPIKPd+7Vn3/RKTzUOgHmVTf3qqLbGqUQ1yaATPVxJ1yMRLtiMEjEvVItfHl4o7gXnPNNeGGG26ILmTAumSELFZvNdcvQkNsmpGWaRod/4N1XAtq0CmdQ+yJSyOk/B+u80qwgMGdTX38f//731zNasphgUMpILkDKSGQ40bPgSTilCLS+ITjTZiBvAeSCNkoNWQcLUmJebo0csyI3y+//PLRQ0C4gwULTYv4HLLHtNF+Cel/7K4n0jso9INMusi2auxouvAzmAZrOSvuiCHx57ziXk/8yIqn/j5B0h4JfViy9QR15513Do899lj8nQUHAsbih0VDPVgUYOEecMABMaMeweU9k8BXDu+T6XbE0+nX36jQY6UfffTR0SMAs88+e1xYMBGvfBFDfJ6xudTIs8iiwyBhBrwpbHhGCAnkjXtTNcD7I8xCZz666xEqwKuQULRFpB7G6AvaKCc73hbXLqKIm3vNNdccsMgnst3isDbJFKfuPY+Y0ogGSDbbb7/9GvZwEMfHI4DXAJI7vRIbb7xx/Mn7zy5MKoE3hK6AeEEIFRAvR+QJPyDixN+ZdV9LrLHa+V8WI/QUSN6Qhx56qOHM+OTKTzX9JCGS6NifsjoR6U0U+oKCJZnqtKnLRqSIZRP77U/zmXIQOuLSKcuc18o70x0QUCD5rL/gFUFEWdjgKiezvhLUwacEt2233TYm8SHoWMeEAKjrJxEOTwc5AMTCcZkTa0fgicMzVARLnsS3RsC1z7Ef6LHGS8CiCNgfjnWaUS8iUguFvqBZ96lOGwuWjnU0fqEUbs8994yje5sh+Myrx2pF7IlPU15GCVwesLJJjGP/qCXvL1jPvC5Qp5/1ZGSFklg5zXAYE7vCCitEQcc1Ts08CYPE1Ynhc0ymmmqqsOSSS8bwAgJPyRsLpnZDZUJ6D4QTGknAE5HeRaFvY9b9YIDliqiSTIY4pMYsWcHHwmV/6m2VRJTn64/Y06AHCxpSQl5/oT89ljdCTdZ/NVf/+eefHx9Hwl9W0Nln4vy4yOmFT8IdMfV0vDoFkgrT6F9+ko0/UKF3Sp5I8VHoBxkuzIPZZ5zXo6kKiXIkdTFvnThvVvDJYqfvfHbD4i3faA2bGsbUEnuS9NJs+zQBrxK0tQWS5Ki57y+pRDDlCtCRrxIMuSEZjsUAlnoSdGrg+X/q9qn3H0gJXqshxyK58OlVUOnzaARr6kWKz5BSJTNN+gWihuVIg5N6ndGa3XEs78eYHkfc/je/+U1MnmukhzxCePPNN/fF5rPNXBAdxDtl0wOLGibVUVpGRn62cQ77QkY8fd9xS9OMhzBDHsh6L39fKTuehQuLGRY4tbrhZcl7DFjw5CH7+SOm6X2TF9CfRR7fqwSlgjQiImmQHAByJeiTz6IuT/kepKqP5K2pNrK2mZcHzg+SC/Eg1To/0nlU73FFgUUnYSS8SdX6VBSJXnu/zaY/54cWfY+SYvh0eeOLU75hYWc34uiIFUK1xhprRMu9UsyeBDZK5EgeQ2RTrT3NXzi5iY8ffPDBfQ1ssEqBRcdARCUlrCHyuOZJDizqGhYXPl6QeeedN9bYs7gqz3PIm5WPuDvgRqTYKPQ9DpYdF3uEknI5fibrLrvNP//8MZO/ntgnCx7L/M4774yrd3q2p9p9rH0S49Zff/3oKqeGnufHqm+kTW0lsOB/+tOfxtdhIUFeQn8go502vmyNVBIMJnhUaFKE2KfciKwbP+WCDDQr3xi+SPej0EtuYcBiLxf7ejFihAjPAXXpWJ1Y7ogSbmYa+mDtp6z5lGg2EJhYl2rrzzvvvJiglxdE/eSTT47d9ojjs/E7t3Wi4GfFHsue3Ij0eaRckIEm6+WN4bsgEOlcFHppSBiS2CMyiD1CmNdFTlyJCgCS3yhdAya2UdsOuPybURdOsxq8CggUz33EEUdEwS/fT+6nvI/GO7j9Gd7DgoR6e5r+sPE7tzFkh0TGgdLscEJW7AnDIPa8RmqcNFChx9uSJ3nUpD6RzsUWuNJQK1VE5Morr+wbQpPNUEc4sdhx15PsRwlb+c+0pSQ+GtCQnZ9+b0aSYorXU1VAzTmLCTbCD/T4JyGMXALa1JZXBSy11FKxWU7q7sccexYmjz76aHTlI6SNwvuaZZZZYlMfsvwJWzRb7C+44ILYUx83Pp9Rs5I9834vHJQj0rn0rNBjnZG1SNa35ANxJnkOoQfi63SVQ1QQVbLmU0/4vALFc9CVDnCR0ya2GRCvJ/MelzsWOWV1ZKln+8QDWatY//QUoCMejYWyIPjkG+C5QPRpaUtCYaN5EPT/JzeBBUezhR5SaIEEyFbNUaiFPfdFCiz0yRXZ7HKxVvLAAw/EmmpKywYi9FipbIlaNePtBHd4KqHi8yofY1sLMuNpgENzFuavEwumhAvBpP0siyXayHIf/esRWG6nbp+GNGT3p59Yttm/eX3K5NgnXOyIfrOEHnA5k0fARkkafeoJD+CO53NnIhzT7fBK1CqvIyudxEEWDIh1o0IPLBT4X8IeeBnocNdMUliBwTkiIk0RehKdGLTx+OOP9yVB0XyFPtydLvJc5BmkwjYQqNuuVPeNkHZS/W95/DQl3SG0X3zxRRQ5BJwNEcr+JLmLxyeIBVO3jfWLC37//fcP55xzTp/1y/ciWytfDZ6TaXqUgCFOZOa3uiSNDnps/YHJeCxosOj7Y9VT745rHdc9HfgYedsKoV900UUnuY/PupHFnYgUi34JPe1CEfnddtutzyIm3rnXXntFcaB3eCfCogRLHnHmPWCtIlp0UkPAcN/SiCQvTIRLHdmSRU+yWqcNGsnGT7MWPfFcEteqdZLLWsa42bGM6TxHjJtyONzRuLMBi55jSovZavDaxPYpsaPtLXFyPADEl7HyO5lmWPXMpEfoL7300rDvvvvmbm6TB3IIagl9dnEnIr1Fv4T+zDPPjIlJZCknmH9O33DEvxOFHpFJddp4HwC3MS7dVD/OxfDQQw+NApYH3M9s5XAxbVYoA4u7P5RbcWnqGm5rst8RWya6YbknIcednLaZZpopdoFj4YLIpaQ7FjMk3KUZ8HguWOB97Wtfi+VywHF8+eWXozeADY8BGfrcVj5IB0uZxUJaMGS/U7UgwzwP2YVYLVZfffW6j8HNn6x65sTznhuBRTGZ8MTT//SnP8VugRzfgcKClYUX4B0p/+5lF3rpvrzZ/3m/x+n5smEiFxUhLqbxWtVi3LhxuY6xyKAKPRcWXLfl0Pks6+btJLhg4bZ98803o7jss88+8cKL2xnhJzZMNzUsVm4fSAx1sPrY16KWFcfFJ4k8nowbb7xxEsGpVDdOhzw63KVkPJLY6LtOb3xAyE8//fRYylbte0CiGBnow4cPj+0vl19++dAtsPgZM2ZM7OvPYrdRoceCJw+BLH6eA6FvBix60pAeQgTlDKbLPhsm6nWh5zwbOXJkLg9fKocU6RihJ7GIC115BjOiydjPTiUliiH6uGCJkybrHkuIVqJkReNebnay1GDDhaOayCMwtUS+Wm4D3hpCM1j3zFinEU5y+9P/nu9Euqjh6UgeAX4SI0fcEflmuqwbrRogfMNCdfbZZ4/70+i+kINC2AHvBVujYk9zIIQe7xLejmZY9MkiXGSRRdo+kMcyu/9HakHM+GQEvxaIfJofIdI2oc+6QBFKupghEimmTbtTLlzEITsZrB4u1rjtuTAm9ziWJicbw0GIQXc75VYcFxzc9ViUiHVekSf2S9kbLus0qY4YdfLoYLkh8GSTpxgx8XrEPVvmhbXfLnjvvA9KABPUtON5oJyOfUX884gkjx+IVc/FfJVVVon5CX/4wx+iV6RZiXj1xGQwMOFvUvhcHN4iXSH0dBArd9MDtcmApcZWL7GrEyCuTD5BIgnSZZdd1jfko2iQi0D8uxGRp/Y8DZ0ButqRyJgWQsRlceXT2pZjyPNjsbbbqix/37TZTbkOfLa44Pne4mKmdJCNUAUei8Gw6skBQehZLLCAHohVzwIFb0qnCL2IdLHQp4tJN5DXOktg7eFOJfubrGhqwIsGE92w6PFo5HXXUxcPiDjd67KLo+TZIbkPFlpooY4T+UoJZVjy5GmU5xA0kjw5UKv+G9/4xkQta/N+HpW+5zQbwpvCce9P1z4RKT6F63WPmOFqTi1aK5HNOCYJj8cj8Fwwy8WsKKQsdcIVeUWFhD1EDWs4ZcWXQ1Ij8XgWS+Q3dBrkBiCs5GBQbcBnj8hTacBIW0INq666avjRj37U0PNi1RPfT1Z9I/B/LCr5HJLY1xsOVE3kGbyDyBMHpo+Bw2VEpNBCjwuZjHlqlIkjVyprKe8DjgDQupUYNH3OO5Hy2eJ5Z41XiuOmvIQ8YP2TvAgMfsl2AUxgme6xxx7x9z/+8Y+x7Kwd1CoXYyHCfjIqlzI6fq677rox45/+94QiGm0bm6x6oNKg0WE1JAMizlnLvhGxZ2GSFXnCKs0aLuNiQaRYFEboubDRqY56fkSe9rbHHnvsJGKfRP64447r62pHokx5j/NOHiHbn1njKXeiUkOVWnzve9+Lx4ZkOlzVlUA4k+jhHclb4z4QPvnkk7h4IVbO504uAbPoUyihloWPZd+MPgfJqr/nnnui6DYKYl8+eS6P2NOO+MILL5xE5BuZNlcLJ9GJFIvCCD0WGQmCWGpYoSTWURNfSeyJ0XJxvu6668Ibb7wRum2EbH9mjacSrEaFvtyqp5a+EltvvXXsOojVf+SRRza9OyA99fEWsA8ILL3xDz/88NjZkNI/mh6RaFgvl4S8A74PzRgXywKIMkPgu9afRNRKY2briT3iDixqsyIPfCdIih1IDXszFgsi0jkMKTV7QHYbSR25EligZIJzMcbao7ELsU0ysYk7I0rUUjcLusZhLSJKg93rvlYHPd4z+0NTFWLtuKvrkU1W4/9o+UoNPpYzE+sS2UUUder0r6eMjaZE2TkA5EDkIfvcvCeen8VFpbBBHrKd+MjBYHIcx4NF4YEHHhgXhlj3tHDOQ7lLnNMHjwJT+4j5MzGPfg1MkWsEMv/pT4HI0/SGPg9ZsU6fGR4LygFJKiRBkhbG5Z6OPD3wa7UqztLMYVV5z492nkfNhHHNfM8wKiyv87g0i/6cH4Wx6CGJPBdyLsC4nXGpIh7HHHNMvJiSPIY1yGObKfKdDO1na3VOqwf/RzgEaH9LuVoliHUjesBxzyuelUDc2W88LknkESdeoz+fGw2CEFK+G8DFF2uYCXZ4dvq73kUId9999yjyVDbQXbE/z4Ubn2E3eAnwTKTjXQ77isjzevU66xHWoCKADVd/p81gEJHBoZDz6IldcrHFIqRmmYvxlltuGS0g6qfvvvvuij3qi0q2oUp/y9+Iw7NAOv/882O9eRpIUw7JkFjzCD2dB6+++uqGXMB4EhDMNPKXGDiu6OROTtSqqigHtz6LPrwDrITphohVTFlbEnwscMIPNIBq1IrlODDFj2mIWPa850aSHhMsYPCC0FaY44xrvrw2HsEGOlDW6uqHyPOdTwubVFXAexTpBPL0+LdjYHMolEWfhYs1W7LsKaHCEsKdRiy5l2hW5zREiJIwXPiHHHJI1cdR9UAHPYbZkCORBz4nFg9Y8Unk6WfAyFvEOSvyjcDzInKELFjc4e76z3/+E4fK0AWRUAMucobCsDChrS+eiEatcvoIpOZCjOql615/WHPNNWM4AYFOExYTfH//8pe/1BXsrMiz6GLjd44Dk/NE2gnizTmHh43QRq2NaxbXGxkYhRV6QOix6uk+RpIWGxPIigZx41rldmnlnPr69xcy1kmGSy58Fk3VLNysC59eBfUgJo0ViyAhyIQYcE83WvZWDkmZiBvPQwgAjwYiyYWG7HUEf5tttomLQUIUSfCruc7r9R3Ao4FXgpLD/uYVkDuAB4MkQ1z1CVrm8txcAKt9j1nUZUWeKZNsSexJZEwLP5F2QAIq1yS8abU2kk5TKbEMjEILfYI584hSUZvhpHKoakKfBvTQpIVExIGQatDTfINmkUQRQeZCkMbqDhQs+BQDB74DdEFMljEg/jvvvHNclDDhELg//W8jC0sEHk8ESXWXX355v/aZBU5qMY0Vn0i9+tN8iWphCpFOh3OcBMVamy2dm0fhhZ6LOC5VuoYVlRS/rlZSRewYsSch7eCDDx7w6yXPQLUyMBLpDjjggPg7liRNifJYw7j08MAQo28W3/nOd+LigTACQszMBubJb7/99vF+EtVSdQA98HFv8/5YOP39739v+PXwZtAKGGiP2x+rHss7eUuy7XXxqECtZjh4QvC68L1n4UL3vGwHvYsvvrjhEksR6W4KL/TNLhHqVKFPca9KcIGnzhuYOpi31K0aqYVuNaEnLo/1ScIbi4w8sO+4lYEYfaPWdK0EN7rhAbXqMHr06L7hPnTzKz9uKZu9v9n41MKnLPz+WPW4NVkssWjIWjUp+bFaLwPAE0ISH59zEvusyKfGRrWwM55IsegJoe91uHAzDjUlcGG1DsSFX0voyTpPCV9HHXVUQxn3JMexYAE68ZXXhPeXZGFna+pxr1OFUWlSISOMyWhndv2VV17Z8OtRBkgooL9WPR6HZM1nqySSRV/rs2PRQr8I+kcg7Px/IyIPdsYTKRYKfQ+QOumRIEdsjCzWgbjwqwk9zVwYW5tc9iSmNQpCj1WKC5++B83o50RmPeLL8+GyJ/6NpV0tOZEs/6xQk6DXKMT6+2vVp9wHmhRlSUJfy6LPgrCnoTt5RR7sjCdSLApZRy+TCn1yT5OBjWsa1y6W7hprrFHxcNXKdie5MbWTpWwtJc7Rn4BYOEJJbXpWICvV3FeCfeJ5zznnnJhYhljiai+HfINyiKvjpmZxgNDynslcBxYdhCxYjJxxxhnxtnQfEGbIQq8A9p9a+1/84hexKoAuVHlFH6uY7HdCJgy9YYJepW505Q2MeA9kHKdSu9T5iveUjiEWfbUFUPlrVMtNqRXOQugbbX+bZ0FWoCacIl2FFn2PgXgwrQ9I0qrnwkd4qDtnWA2NYADxoUMdvPrqq32PTX3mEeaBZM2TFLfeeuvF3+nCl3eqG3F9xITyvPLXT3H3m266KZfgIIR4QFgAsHghubBRoSJWTrOf1K42D5Qi8plgvZcnMeZx3XcyduYTaQ8KfQ/CZL+UhZ+y47MZ3wg7bYPJhEeocCEzLwArPTWvSCV7SeixYJPLmcXEQKFOnA1xpRb+b3/7W7T0a5HuZ6FQbrGussoq0cKno17eZjYsaGhpS7wey544dyOw4Eh5EZQ25sk5IMchldCVdzHMWvTdiEIv0h4U+gJTbW49liGucaCmnOY3J510Uoxlk5yGm5ts+WuvvTZmwCN4CD5x8zSOtVzo6WqHW5z4fZ6hOXn41re+FfcHFz7PTxMbmmiQlV5piE8S+uRtyEIznBQCYFpcXlhsMBApLZBI0GulVc/7TAuTchqN0XcaA5moJyL9R6EvcGe8WnPrsy58eqsj7Ndcc02fsDPl7bjjjotxd56bDHpgLGxW6ElwgzvuuCP+JObfrHJGxJnwAvF2WuECLXLpEMdkQmLuTzzxRFwIZOvvseirlb1Bo/XxxNpZJLCQYUHUKKlRUxovWw3CFMmip0qiGlQPsC/dhkIv0h5MxitYZ7zsxZTfy2/LgoVKX3dc+MwCQMzofEcCF+5q/petUnkYVj8W9l//+tc4OCgNCWp2X2rc19SSs2Gx00iGBEDeM7XwbEDyGLeRRFhtul1alDQ60AjPBgseoHqBcEK9xQzHDAueITSpu121BQgW+uGHH943sAYvQnl8ns83LcxoeNPf3v8i0nt4tSgASeTKBT2bbV8JXMEIJ8KFVZwWBSk2nPUIJGs01aRvuummcaFAv3isfHrFs2hg5jux/Ga577MglGSv4zUgM52mPGyMsk3d4liwJBd3FuLjxMmBYRp5IF+BrHkqFICRtj/+8Y9rijyvQzyfRjxJ4HHd008fN34lK55ZDCnhkMcxzKY8Pk/ZIosqPh/G2dZbaPCZcUz4bmhJi/Q2Cn0B4GI+kCx3RANhQNgQTX4n8St5BOgQh5ucx1EfDwgRQk92PH3hN9hgg+gR4HGUr1GeVl461iyw2ondszGJkEUKSXa4+lNP+3KwrhFeRLeS4Jbz9ttvhz333LMvZk4IgYREQgW1BJ6wAsewXODLy94QYVrVMmkOyG0gLMBCpRwG76TOhkzGyzOzIdv0RqEX6W0UeokkUQcEn99pXkPyWZplzvhZGu5kY95LLbVUrEcnI32rrbaKVj215rvuumustyfW35/GOY3AIifF8CuRteYR3kr17FkeffTROK6WsjqemzI73kdegaczHfMVKgk8UNVAbT6Lk6wVX6nXwMMPPxwXHOn4J49KIoVXyr03ycvTaD28iBQPhV4iSSiywoFwbbLJJvHvtddeO4pTFiz8bbfdNgpRctnT5x7RQ/ARKTZc7rjbaS1L69nBphFrnoRESg7xElBDT2e8RRZZpOJjSVwkiZEFQRJ4hJgFUCXPQrkVTy4BeQ6VrHh488034yKAfeH4474nMTIr6tnwSnl+hpa8iIBCXxDyzm2vF9slvs2GyBN3f/rpp6MLnjK8SlPT6Kl+++23x5g0rV4ReW7DWsXKZ6MED3GjuxzZ/iTv0ce90r7kLR2r1tGvHJLWUpIbyWyVSu+ANrH06E/ja3GP77777vE9p051kMbHIq4M4UHk8XzgwSBvISX6zTbbbBM9PyENPCMpWZH/JQGPxUcleP4tttgiPp7hO+wbCX5J1JOlnix3YBHQrph8nkqLog+XEulULK+TihxyyCGx0x2igVhXyxgH6sxxUSP4WPbJWsXaJdmPmn0EkpAAnenoN0/Nfuq010pYYLDQIJ5frd87HfVwzyeRx+rnPdVq20tDIeL3uPbPP//8KMqVsvlpboPHgxwGRJvQB++beHylpMHEgQce2Jd8xwIKT0ilHvTcnxYLKSYvIpJFoZdJoEY99YPH1VxvnjziRUwajjjiiCjoCcr0mAlPjByrHy8B4kg9PC7y66+/vmWfAPFzevunZLpK8XLyCdgnuuUh1HvssUdMOKzlIcG9nzLxSUis5trHiqfDHQl0yYqne2Cl3v1ZqGJgIQG8Tkq+S6JeyWJ3EI2IVEOhl4kgsQ6LG3BdE3fPAwJJox1i8gh6JRZaaKFoqdKwBnEFpuj1Zzpc3vr3WtY8iwya4VCix2NwpddLHKQrX2obzOIh9eQvDz/0x4pPx5/nhX322ScmAVZqhlROrUVApVnzWv4ivYNC32OkC30l4aC7HPFz7iOW3sgoW1zLiH2ycnEjVwOXOGKJqJJoRmc++tk3a/48jXGw5JPVXcmaJyxBFjuvTxc6Ov+lbn/VwA1PnJ3/oaaecrtKkKPQqBUP9DOgxj+b/JjKHpslzM6aF+k9FPoeo9aFnmSp1FqV7njlTVvqgSeAzHMs5NTKtRo8Ny12STQj8e/II4+M1jEC3J/2rrwnXOWIN/FyevLzHumoV8maz06iGzVqVN0xuogtA25IviMbH+u80vHheVMWPuNp81jxCUSd0r4UMuH5UwOjZpXJ6eIX6T0U+h6j1oUeoUd8k9A8+eSTDT03sXcG0UCeAS7MrSfRjLIxXOf0qqfr289+9rOago/ngWoAhtNQnkZzHibtHXroobFGHZZbbrn4N89XKTaPx4L/S+/1yiuvrLmveByI4/MeKbmrlr3PMeS1U5Jff0nvHaEnq79ZmfTJxW99vUjvYHldj1GvvppseGa3I6L7779/LJdrpCyKjHXa5RIfx4Vfryc7Iky4AKubDHmSAOlpj0DzHFj5xPaJddPXnr78tIut1H+fygAWGsS1Ux07yYDVSL3jWSyQgAiVchLwTqSM/FrJdwnG+lJ9QBVCWkyIiLQLhV4mAlHHRc1gFWbAI7bVusJVgvGquO9xxyOQDMnJQxJ83OJMwuN1k+BXgna3Cy64YFh44YXjQoCN/2003FBP7FlY0EMA8BpUSr6rJPTA+8fl3+g+QTsaC0l+WHiSJFkvcVOkE1DoM+7gvE1nig4CSgOYE088MdaT05wmr+sYCx6rGqse931eoU9ggfN6JLsh+PTZJ9ZO5jrJcmkjga4/AlpN7MnOR+izYk/yHWVueA8ocSPJLg/kBVCBgOsedz/5Do1iV7vOFnk+43qVENnQi0g76UmhJ76LtUoZFCM/aVmKyOcZP9qp1MpyT3BhYpY58dl6MVoy7omfc1Ejhk3pWSV4vnJoA5vc93gHEP88F0VIZXfZKXOVPpe8z5cXyv7IE0iWPXFsOuKxAMBTQEiBnIJK77cS1M/TA58EwXp9CNpBNhmxGXTredMfUrkj33EEvxaIfHY+hEg76Dmhf+ihh2KpE1PPcK2RVDXrrLPGGCzi14jYY+llY8X0Pm8HWLxYn/Xi71yc8FzkGXbC/Vizm222WfxJvTmWfh7o3Z7c91jlq6++eugGsm58FjdA8t3JJ58cRb4ROAYIPXF6RttK8UDkqdgQ6XR6yleN0O28887RaqS9KM1dEDHqyomrkvWNyCOGeaBtKgKQNkaNtgOEO02cqwWLgGoZ95Wgox3eDurbaQCT1wrkNYhnQxrg0ii8Fr3xcXvTTpe6clrq0vOdErRs971mi302gQ5PBnkAjULoIRunbxQ+yzyNctrZd0FEuoOesuixvrG6EQ3AmifDfP7554+JYOuuu2647777crvxafqy99579/3Nc7dD7BHuZNHXgvuJHeeF9481i9hinSK8ZOXngSx62t4SpyfW3wiMxkXUWYwlaDrDln0vuMSJnTMql595jz1Weq18DMR+gQUWiI/przeCZEbq5/lc+hOnpykPLXnLp9INNs61F+l+ekroETmsdWq0U2Y1YoZLmsEkuKlJQsNtm8d9z4W40iCTdgh9K/YDkaFkDQsXzwfHhmNIDXqj7nvi33lAFEnGY1FGJj7d9lg0cPv9998fF2IPPvhgFKC77747bo1CqGbrrbeO4Yhq+5XnPdaCREG8RCxWGNmbR+hpf5tdjPAdbHdSnnPtRbqfnnHdY6Fz8UXMaapColi5BUZWNSJSVDcl74vksrztVFP7Vdq+Eo8ktIEHhJgzlmo99z1ufyBOnReG3SDyCPBdd90VkwKx3PlsjjnmmOhZoPMez8mCjPa2CGojgsj7OPbYY+NEPd4Li4dmwyz51LynXtY1303yAtZaa6349/LLLx//p5mNcvpL3h76ItK59IzQJwsdK44LK+1J00jVdD8Z+PRJL+rAD4S7kVGmqf0qgsNIVnrSA2NnSWbEM1Iv8xwasbppiQt4XnCfV4J9om6eRRv94AkP0MWPRUK97Yknnoid7RB5cg+oLCBkQ9tcFn/9ab9bCVr6vv3222GxxRarOh4XeAxVCoSAeG0ey3S8/mSxG08XkdDrrnsEfr755otCxShSrDq6rW2zzTbRikSQ6KiG27SIINypvC6PaKT4cLLmsKA32WSTaEXTSAaLnf72jKat1M8dyxSwbPM2jkmDZUhEw2uQt0888fS8SYaIKRuWPMNn/vSnP0VPDhstgBFeFhH9rX9mGh/5CYAXotr7vvfee+PQG8o96R/Aa+M96W+pmvF0KSJ5Gg9ZxlibIaVmF9R2AFitvK1s+9PUECf9fOSRR2LtNLFfEp+wHrnQM0K1Pw1OUjIe2fc0Smkk6W2w6uihXkvaxMsvv9wnzuWChwCTiJg6xiHOeEjKJ7Tx/9Sg06+AmuM85Xl4VXg+XN9krBNSqUQzwyuEM7DymQOfup3x3aGdLxPq8i42gO/ddtttFxc35IH85je/qfgYFpsHHXRQtOLxYjCEJ/XIr0SeRRLHJJVODsTV3p/nybM4yXt+tPM8ygMLNDxC9FmwvK5zGhOxIOiFngXv9uP8KJzrHgHHDUsy1bbbbhvLsQBxR3iS2CMoXGy5H5c0yVlY9P0V+aKR3PaVLvQIH9Y98XJOLKx7Zq/vtddeUdQT/D8XRGBB1aj7Hkt3MCAfYJdddonvBwucDH4E+I9//GO07EkCzAszAhB5vEKHHXbYJPdzcm611Vax4yCvwWKA710tke9vPL2/rnxH2UonwLUF8WZBVWvDiEjlqNIDrvvHHnsstkalhpsSOrrf4Q7lAk5WPcJDXDZNM0sJT824yLabvJZ6tR4B5a56xLyeJUvyGF4QROuss86K89/JMudYp9a39L6nOxyNimrFqrOeCU5wTmBi6tU8FXl7wWcXHrVIg2rwIBAvv+2222JYIoV2mLCHFwPhrAaeIcbSAuWBxOez/Pvf/45JhclVTyUDyYB5rOG87vysg66WK7/W82Uz7Xup4510HlwLesFKbzWFsei5wF100UVR4C+++OKYrU2fdC7WiEZqrZpEHjFiCppMnKjXqPXHYgC3/U033RRd7ggj1j0DabIJef2x6HmudsFCBcscYcYTROMcvES1vjO4/0nmnGOOOcI+++wzyX2UHCLyvD9KDvOK/GDPnufxeDkcZStSDAoj9FwwKbsitpzAiiFeSi02TViwyIDY71FHHRXnnreqw1q3kbrm8bM/Ll9EkHpx4vBYgzTXyQo98ba889nnmWeetgs9EAdj8XjhhRfGWBjvjwz9SrPrn3/++SjmQO5H1oLGs0QPAlz1TALEWzAYXiRL40SkMEKf3JUkxiDctEhNECslzoqlTzkYlibufVyrWGnNmoDW7aQpW0noy8vw8og/x5K2ucAce6BpDqVwgPu+EaEn9t8JUKGBdb/SSivFREQWjmzZ2QaU+VG5wWOyo2x5PFUKaUgPCYzJqzTYWH4n0psUQuiT+5MLLJY7ZXPZhi5YY/RqJ0ZKVj1w8U0uYqnfEz9Pghb/l4SeWP1LL700kVWfbWGbJ66O0OedO9Bq+K7w3SHhkIROrHqy8qmDp3kPNfjcfuihh07kjie2z/tg8UK+SKoEaUcfe5PsRHqTQgh9gp71lEhRqoSbPpuFiRVFkxcsTGnc5Zsn3svj8ZZg1bIowOqF1B8fK7+W2PM/v/zlL/vG01Ly2EnJYLx/hJ4mOwzaIVmQuvf9998/3k82fXZsKS1tkzsfS564dypV7E8+RLti9iLS3RQq6x7ok46g4K4nMYqflEuRoEcclcWANE69EbhZKL2jWQ7lacTqsfLZ+J3aceLeCGUWPisSKFPSHk1rsIA7SegTxNdpiMMChqQ6YKBOEvwUTmJRgEdi00037WtvCyk8kvd4ZuvaByLSjXyGvQq5JPXKtPI0cBHpJAon9EB5HQl3lElR+oUVg8uULPx2jZLtJehFQKMZQigMxGHxxd90jCN/IjXbSYN4+Fx4LIJGFj9lZyzQOhksdxYiJNkB+58VYax+ygqnmmqqeN9ABDfrctca75wGLf3tnCgy2BRS6FNiHj3Q6bBGzHe22WbzxBxEsM6x6OlBT3UDtei45XFvYxExupZFACJIkxlInpduqZslRs8iEq8D/QKy9fT77rtv/B0rP7X17S9OkBscUt4EDViyIZhK2HJVuonCCn1KwuvEFpq9ANUONNGh2oE4NfkRzI2nLz6JkfSXx+KlCoJsfcogWQx0i8gnshn2Cd4v9fa8l/J6+v60oGXTkh88EHlb20qRKLTQ9xLNHlmQ9/nINK8GcWkEnH7vuONp9YrYM6Oe0kZEnmx04t0pMz87n6AWeafM5e0YmLeDXrX59Qky7FngAO952mmnbfg4V+pol/fz6MScBhFpLwq9tBTi2FdffXWMz+OmJxmPvAnc27QjpvysmteFSXupHp+YPfHuTof8A/Z79dVXj5P++oOuehFpJoUqr5POg570p512WvwdoWfoEF4AXPgMkKkk8gjlGWecERvt4M5n43du475O5ZZbbglXXHFFfH+nnHJKv61rO9qJSDNR6HucNPWpVqZxnsfUAmuc1q+426k7r9YEJyvwJOrR0pi+8Wz8zm2dKvi42lM8fqeddoqJhSIinYBC3+PkGWbT34E3CSzbk08+OcaraZhz3nnnVSxtoj49K/DU49PpkI3fs4JPrJ+Wxp0CsxNo8YsHg4qDZmLrWhEZCAp9j5MdZjOQx9SD/gWHHHJI/J0yO/rCZ0V+nXXWCU888URspJMEfuutt46tjJlfwLz4rOCT9Patb30r7L777rkT6VoFIQiEHo488sjcI3TzYutaERkICn2Pk238Uc09nx14MxCYL5CscjLtsyLP+FYy8K+55poo8DTTKfckcBuC//DDD0f3OJxzzjlh2WWXHXTrnsXHvffeG+vl0wKGQUlpHHIzsXWtiAwEhV4i5aI60Lh8JciaT41kSMyjmU4SeYbG0BqX8jqm5NXyJFB3j7hSi0+terLuKeVjJCzvoxXCfv/998cQxJgxY6Lngb7+KdGQLoxbbLFFbNDUbEzOE5GBYHldwSlvvlKN8v7rWeFvZn90MugpucOq/9rXvhafH5G/8cYbYyyfsrvsPlV6bf4H4eX/77nnnliih2XPMCM2vA/01keQEeO8tfRZeH767tPLno2WytmJiEDFwNe//vXYl5+ftSb7iYi0C4W+4FRqvlKJclFtdPBKo1Y93fGyIk8Mn0Y6xO7rdYFjn3hPdN/j91NPPTVssMEG4bLLLgvXX3999ESQ8MfGtEJa1W688cZh1VVXnUT0EfRnnnkmhgNozZv68ZMPUJ7Zj7DzHKuttlrcyKzHuwC8F/aHTUSkk1DoO5yBdkTLNl9ppK47K/yIWBL9/gp/tuMdsfoLL7wwijpz3NOgIUR4hhlmiOV3lUrwsvtRPv1uzTXXDCussEL0FvzjH/+Ig3L+8pe/RNE///zz44alj+DTe556fjZEvVqpXrLYv/GNb8QGOGT6J2Evh/yBmWaaqeHjYic7EWk1Cn3BGeho01a48bHq//Of/8RFDK56xDgtIsigr/YayWWfptxlSf9PfJ8BM6NHj44T8kjSY5LclVdeGV/n17/+dcX9WXjhhcMSSywRFl100bDYYovFjeTAasIuItItKPQFi7W34nmTGx+yojxQsGaziwgs7kptbpMlDwhvrdfOejDwENBvn42yPDrXIfjE2hF0NjwDs88+e7TI6/WxF5HOhdBbPYYNG9Z1g7OagUJfsFh7K543CTsi3+wEvTy5AMmSR+TrzQCvtgjJin75c7M5HU6kO0mlv2PHjq372GmmmSYuCHpN7BX6LqFVg04aed5WJOjl8Q60KjEw+/q1pvCJSOeCaCPeGCK1GDduXFwM8DiFXjqSZrnLB/K8rdqHTn1dEekOEO5eE+9G0IwREREpMLrupevAjU9JXLMTE0VEiogWvXQdKVO/WZ3oeL5XX33VznYiUkgUeuk6Ug/8ZiUmNnvhICLSSei6l4o0Ows91czXq9nP06CGZjl0rcv7uo1UHuTtRFiL7Pvs1LK9gXZcFJHuQYteBo1OnauOGM8yyyxNi/d36vustiihm2AzpxSKSGehRd/DtKrb3kBq9gd7n7qp50E3NWIS6VTG9WAHvZ4WetyXuCbTz15jsC/yeerh2y08zVho8H/dIPLdtigZCOPHj8/VUEWKy7Ae7qDXs0L/4IMPxvGmZ5555kST1XqJTrzIt3uf2r3QGGx6oRkRIj9y5Mhc4QmORb02y9KdjOjhDno9KfQPPPBAWHHFFeNc9CTyKTmpEcueMatsiXfffTd0E514kW/3PrV7oSHNhws2In/JJZdEwe8ll61MTK920Bvai5Y8Y0x33XXXcPjhh/fd3h/X/dFHHx0OO+yw0C66Ibu722j3QkNaByI/atQoD7H0HD2VdY8Lb8011wwbbLBBOO644+JEtIMPPjh8//vfD6uttlr43e9+F1566aXcz3fAAQeEd955p2977rnnwmDSTdndIiLSHnpK6Im9zDXXXLFG/O677w7rrrtuuOOOO+Is8tlmmy3sscce4bTTTgtvvfVWrufj/6jnzm6DSZq5rjUvIiLV6CnX/TrrrBM+/PDDcPrpp0eRX2GFFcKll14aZp555ui6P+mkk8JBBx0UxowZE5ZbbrnQ6ehmFhGRevSM0H/xxRfRkt9oo43i73/5y1/CzjvvHJNv+Buh32uvvcIxxxwTbrzxxo4R+maX/TX7+ZrRSS5Lu8oce628sijv17I5kfr0jNAj8qleHot90UUXDfPOO+9E9z3//PNhjjnmCEsuuWS7d1dE6mDZnEg+ekboIdscZ5FFFpnkvnPOOSeWyy299NJt20cRyYdlcyI9LvRk1FcakFLJZXnFFVeEm2++OVx88cXhlltuCXPOOecg7aWIDBTL5kR6LOv+lVdeiT8RecQ+T1z5mWeeCffcc0/MwNeaFxGRIlEooX/00Udj+dyGG25YU+yTVf/mm2/Gn3vvvXe49tprw+KLLz7IeyzgBDURkdZRGNc9jW623377sOyyy4aHH344bLLJJuGPf/xjn9iXu/F/8pOfhGeffTY2ziEpb8YZZ2zbvvc62cY/9gSQxP333x+mnXbaqgfEITTSSsYVaMpdYYSe2DpNb3bfffeYpLPPPvtMJPYICc1lEiuvvHK44IILYtMbaS/2l5dKjB49uu6BcQiNNJthBZxyVxih/853vhMFg4sDok5t/H777dcn9og8ln0qpeN2GujUshhkcLDxj1SCKhg8dEWwqKR7GNHGKXd5+kK8//77vSn0iDpikWLziPq3v/3tGItnQl3Wsv/1r38d+9ovvPDCTXcTpyS/bptiN9D3TIydrRmCXZRGLjIp6byo12Qp3U/1ywILLFD3UPbS+SaDw4wzzlg3nJsEl0Tu/ohvOQg8Cwe6tza7WdmQUrNbm3UQHDCS7HDjYxlw4WAG/ZNPPtnXLKeZ0HCHZEARqQ7Dn2qVsHoeiQz8PCqk0JfH4BMfffRR+POf/xwn1M0000zhpptuatmoSjwLL774YphuuumabplitbCI4MMd7OE5vbC/4D63Fi417733Xph99tljCK3Z51G3fX7ur8e2P9+FvOdR4Vz3xN4Reerhr7vuurDDDjuEySefPN431VRThb/+9a/RpXz77bfH1retgoPe6mY77ZiS10v7C+5z65hhhhlafh512+fn/npsG/0u5DmPClVHjyVP7B2RJ+5+1113TWTZ47q/9dZb49ZKkRcREelEhhbBXY/I444nkeHss8+eyN23xhprhNtuuy2W3omIiPQaQ4si8mTcI/JZa55Y39RTTx23bod6/0MOOaRr6v67bX/Bfe5uuu3zc389toP1XejKZLzU6S4r8ueee27FZDwREZFepitj9Ig87WsXW2yxsNFGG4XzzjtPkRcRESmSRb/bbruFTz75JJx11lmKvIiISJGEHt5+++1YhpC3jlBERKQX6VqhFxERkfpoDouIiBQYhb7LSQ6ZbnHMUPIoraFbvgODjeeIlLrk3HjllVfCp59+2vTnVei7mAcffDDsuOOO8YvRiVPfnn766Vj2ePLJJ4cbb7wx3pbGBHcyjzzySPjXv/4VuqmnBGS/A51+jAcLz5Hm4rnROu67774wfPjwcMcddzT9uRX6LuWBBx4IK6ywQhxskPr6c3HvlAv8Qw89FJZbbrlw2WWXheOOOy7stddeYc011wwffPBBFKRO2c9Kx3XxxRePcxG6AS68O++8czy2TGlkgBN04sJvsPEcaf7x9Nxo3bEdPXp0vE7SzbWcAV8vScaT7uKBBx4offnLXy7ts88+pU7kgw8+KK2yyiqlXXbZJf791ltvla677rrS4osvXlpsscVKL7/8crz9888/L3US999/f2nqqacu7b///qVuYNy4caUZZ5yxtO2225a233770kYbbRT3/xe/+EXfY7744otSL+I50lw8N1rHf//739I000xTOvDAA/vOWc7tv/71r6Unn3yy73EDuV4q9F3Gs88+W5p55plL3/ve9+Lfn332Wemggw4qbb755qVVV121dNlll5VefPHFtu7jm2++WVpiiSVKV1xxRd9tfHkfe+yx0qhRo0pLL730RLd3AuzbkCFDSocffnjfcf2///u/0s9//vPSueeeW/rXv/5V6jR+8pOflL7zne/0/f3aa6+VTj/99NLkk08e97vTjvFg4TnSXDw3WsdHH31U2mCDDUpf+tKX+m5bb731Sssuu2y8Hi211FJxET/Qc1nXfZcxbty4OLeYWPfdd98d1l133RjToUcyg3v22GOPcNppp4W33nqrbftIfwOS7m6++ea+23AlL7jgguH8888PEyZMCLvuumvf7e2GBW+Ki7GPsNZaa4UTTjghXHnlleGkk04K22yzTQxDdArs81NPPRWmmGKKvtuGDRsW3fg0kTr66KPDGWec0THHeDDxHGkenhuthbDrz372s3jdWWWVVcI3v/nNeG3n2kP4c+uttw533nln2G+//QZ2LjdlWSKDypVXXllaa621SjPNNFNp3XXXjZZcWumdeOKJ0a3/73//uy2fStqPQw89tLTSSiuVrrnmmknuP+SQQ6L3ARd/p/Dee++Vjj/++LiKnmOOOUqbbrpptGSSa23HHXeMq+xnnnmm1CmcdNJJpQUXXLD0yCOPTHT7hx9+WDr44INjqOSpp54q9SKeI83Dc6P1/Oc//yktuuii8RrzwgsvTHQu/+hHP4qhUD6H/qLQdxHZGM0f//jH0jbbbFO68847J7lv1llnLR155JGldkJsacUVV4xuqJtvvnmi+373u9+V5p9//tKrr75a6iQ4qU444YTSaqutVrr33nsnuu+GG24oTTnllB3lwr/99ttLyy23XGnfffctPffccxPd989//jMuBP/xj3+UegnPkdbgudFaMIDuu+++0vXXX1/69NNPJ/ouH3PMMTEUOhDDyHFvXUQqTcN9M2bMmLDooouGeeedd6L7nn/++TDHHHOEJZdcsm37yX7MN9984Zxzzgk/+MEPwrHHHhsnDeL+/vjjj2PIgWqBThsfPNVUU4Uddtghuu0XWWSReBshCI4tbvEFFlggzDjjjKFT+PrXvx6P7ymnnBL3nePLcYeFF144zDnnnPF49xKeI63Bc6O5pOt4gt/TNTu1dU8/H3/88bDUUkv1VVf19wWly6iVkEHmJpnt5RZeK2Dl+cknn0x0W1qFpp8PP/xwaeONNy4tsMAC0SU+evToaGmyeu0msJqXX3750htvvFHqNMsV783CCy8cEzLxPDz++ONxfzneWTdgL+E5Mnh4buSDJGmuh3nhWnPAAQeUZplllob+rxIKfQdD5ndecOXvuuuupRlmmGFQRJQv3ne/+93S17/+9RhCIEO9fL+TGJFDQM4AGe2/+c1vohB1wzEFylz23HPPWMZGydZgw8nOPpAv8PHHH1cV+wsuuCBm4JNjQGx+nnnmmST8UEQ8R9pzLMFzIz/PP/98rJbC6MmTP0U58lZbbRUX6804jxX6DiTVmdc6+cotFmLLJL+RONZq/ve//8UFxdixY0uHHXZYjGkvs8wyUfAT5aLUCbDfJNzVKj/MHleO5Q9/+MP43qgjHmx4fV6b+Bz5AUccccQk34cUz4P3338//g+LsFdeeaVUZDxHmovnRmv5+9//Xho6dGhpzTXXjAJ+zz33TLRgL/eM4pH99a9/PVEd/UBQ6DsMVsnUQX/729/OtdLOupJpTNNqEEJqtMlKT5Ak8qtf/SoKElZ+Fiz48ePHl9oNXoSvfOUr0eLFHYaXIY+7lxPypZdeKg02iDUWAE2R+D1VBGSPZa/Vxyc8R5qL50br4Tq94YYbls4+++zYS2SLLbYoPfTQQ5N45rhepsqeZjYUU+g7CCzNlVdeOWarzzfffKUxY8bUFPu99967tMkmmwx6CRWWOy77LBMmTIiNZbBAf/rTn8bbyPgmNo/l36hbsJlg6W633XZxv1mQIJjEFSuJPRx77LGxPLBdsF94SfbYY4+JRJ1SSrLpCc1kczB++ctf9jX6KTqeI83Fc6P1cO2jwmihhRaKLnwaiX3ta1+LJbtc77mGw2233RbLZVkE4Klr5kJeoe8giHMj7rfcckvp8ssvj3HWrNhn3bTAY7BSByvhKn3xTj311BgmwLLK8s4775T222+/0gorrBC748E555zT9lpuFiF0jKNrYCrvqyb2rLzpOsh7eP3119uyv7zuUUcd1VfHDwg5+0xXwTnnnLO0zjrrxPI6LtTsL59HpyQKthLPkebiuTF4100EnPI5oL/IsGHDStNNN13p/PPP73ssFn8rrpcKfQeBC/zPf/5zn6j//ve/n0TsWR3yxUlunYE0UegvTzzxRPyS0mP93XffncTiop0ji5BOAkHMgugjnLjGk6BzbAl/IJjtbiOcPa6XXnpp3Ff2mX279dZbYwUAjYeAC0O793ew8BxpPp4bgwOx+eTtpK0t1Uc0ycHb2Op+Fwp9h1ApHkOTij/84Q+TiD1W8qOPPtrWOC3JJSSI/fjHP57IKkY06e5U3iSnU0gLpayAYtnjFSG7nsEw9J/uJIjZZZN3gBwOemT3Upzec6S1eG60hnSOUhlDx0qGfQ0fPjwu0HHj0zxs5513jtf7Vp3PNszpEFJzhPImFeuvv35spsAI0k033TQ2QTn11FPDk08+2dY+5oxS/MMf/hA222yz8OKLL8afNHy4+OKLY9Oe+eefP3Qik002WWxWQSOczTffPB6/LbfcMlx11VXxmNLMh7kBncTcc88dN2DfP/nkkzDttNPGkaG91Mfec6S1eG60hnSO0txs2223DbPOOmu4+uqr499s3E9DHK73LaMlywfpF+Ux+AQrveRqJiZfbt21E/aFJjgjRoyICYQ0bumG+m1Wzmn1TMkLx/XBBx8sdQNMK+R4Z2P4vYLnSOvx3GgNlNCdd955ff04BtMbp9B3CCkr/emnny6dccYZk9RV7rDDDnFYzUA7JLUCkvDYb2q4q2Wyd+ox32uvveICqh3NcBqFMA6hEsruumEx1Ww8Rwb3WHtuNJ9mlsw1gmNqO4DPPvssus3oB0+P8rvuuisMHfr/oirXXnttuPXWW+NGf/tOg7G088wzT3Ql0xO+m1hsscXCvffe29bZAHkZOXJkeO2118Jtt90WlllmmdBLeI4MPp4bgxN+GgyGoPZteWXpu4Ah6oj8qFGjwsYbbxzOPvvsiYT+ww8/DO+8806cNy+tHS7R6Xz66acDG27RhXiOtAfPjeKg0HfQBWzDDTcM55577kQin6anifQiniMiA0ehbxOff/55n7u+msiL9DKeIyLNQVOxTSDyzz77bIyDbbTRRuG8885T5EU8R0SajhZ9G62V3XbbLdZEn3XWWYq8iOeISEtQ6NvI22+/HTPWjcGLeI6ItAqFXkREpMAYoxcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGZhNVXXz3sueeeHpkCoNCLiIgUGIVeRESkwCj0Uhg342677RZdjTPNNFOYddZZwznnnBM++OCDsO2224bpppsuzD///OG6665r966KdA2fffZZ2HXXXcOMM84YZp555nDggQeGUqnU7t2SBlHopTBceOGFYdiwYeHuu++Oor/LLruEzTbbLKy88srh3nvvDeuss07Ycsstw4QJE9q9qyJdc04NHTo03HXXXeHUU08NJ510Ujj33HPbvVvSIENKLs+kIBb9559/Hm6//fb4N7/PMMMMYcyYMeGiiy6Kt7388sth+PDh4V//+ldYccUV27zHIp1/Tr366qvh4YcfDkOGDIm3/fSnPw1XXXVVeOSRR9q9e9IAWvRSGJZccsm+3yebbLLoalxiiSX6bsOdD1y8RKQ+LIiTyMNKK60UHn/88biQlu5BoZfCMPnkk0/0Nxeo7G3pgvXFF18M+r6JiLQLhV5ERCpy5513TvL3ggsuGD1m0j0o9CIiUpHnnnsu7L333uF///tfuPTSS8Npp50W9thjD49WlzG03TsgIiKdyVZbbRU+/PDDsPzyy0crnmqWnXbaqd27JQ1i1r2IiEiB0XUvIiJSYBR6ERGRAqPQi4iIFBiFXkREpMAo9CIiIgVGoRcRESkwCr2IiEiBUehFREQKjEIvIiJSYBR6ERGRAqPQi4iIFBiFXkREJBSX/w+b3sw5aZS93gAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -638,7 +753,7 @@ "source": [ "## Now let's update our prior by comparing to some data\n", "\n", - "This will require learning about `LikelihoodModel`s in `rxmc`. These encode our assumptions about the error on an experimental `Observation`, and are a necessary ingredient for comparing to the predictions of a `PhysicalModel`.\n", + "This will require learning how `rxmc` encodes our assumptions about the error on an experimental `Observation`: as a covariance built from explicit terms, evaluated under a likelihood functional. These are a necessary ingredient for comparing to the predictions of a `PhysicalModel`.\n", "\n", "In our case we will mock experimental data by synthetically generate some data with noise about a \"true\" $m$ and $b$. Our calibration posterior should converge to be centered about this true point.\n", "\n", @@ -649,9 +764,16 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "d07c4b8c-fb40-4af3-9a76-7c798943a213", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.581645Z", + "iopub.status.busy": "2026-08-11T03:09:07.581477Z", + "iopub.status.idle": "2026-08-11T03:09:07.585234Z", + "shell.execute_reply": "2026-08-11T03:09:07.584428Z" + } + }, "outputs": [], "source": [ "true_params = OrderedDict(\n", @@ -672,9 +794,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "664d9b5e-d7d2-4d08-91f6-763e75b40ab4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.586896Z", + "iopub.status.busy": "2026-08-11T03:09:07.586730Z", + "iopub.status.idle": "2026-08-11T03:09:07.736211Z", + "shell.execute_reply": "2026-08-11T03:09:07.735557Z" + } + }, "outputs": [ { "data": { @@ -682,13 +811,13 @@ "Text(0.5, 1.0, 'experimental constraint')" ] }, - "execution_count": 20, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -729,7 +858,7 @@ "id": "766bb583-3be2-469a-85bb-4f364610f175", "metadata": {}, "source": [ - "Clearly, our prior is at odds with our observation. We will now determine a posterior distribution of $m$ and $b$ that takes `obs1` into account. To do this, we will need to think about a `LikelihoodModel` for `obs1`." + "Clearly, our prior is at odds with our observation. We will now determine a posterior distribution of $m$ and $b$ that takes `obs1` into account. To do this, we will need to think about a likelihood for `obs1` — in `rxmc` that means a covariance model (here, just the reported statistical errors) and a likelihood functional (the default `GaussianLikelihood`)." ] }, { @@ -737,176 +866,77 @@ "id": "4818c696-b984-4145-b911-5307782e0dd5", "metadata": {}, "source": [ - "## set up `LikelihoodModel` and `Constraint`.\n", + "## set up the likelihood and `Constraint`\n", "\n", "We will use the simplest assumption about the error on y: that the experimentalists exactly reported the statistical error, and there is no systematic error at all. This implies that each data point in `obs1.y`, say `obs1.y[i]` can be modeled as being an random variate, each sampled independently from normal distributions with mean `obs1.y[i]` and with standard deviation `obs1.y_stat_err[i]`.\n", "\n", - "This behavior is handled by the default `LikelihoodModel`:" + "This is exactly the default behavior: a `Constraint` automatically includes each observation's statistical diagonal in its covariance, and evaluates it under the default `GaussianLikelihood`:" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "1ca25e05-9b9d-4c22-94bf-0caf31854835", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.737939Z", + "iopub.status.busy": "2026-08-11T03:09:07.737759Z", + "iopub.status.idle": "2026-08-11T03:09:07.741990Z", + "shell.execute_reply": "2026-08-11T03:09:07.741374Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Help on class LikelihoodModel in module rxmc.likelihood_model:\n", + "Help on class GaussianLikelihood in module rxmc.likelihood_model:\n", "\n", - "class LikelihoodModel(builtins.object)\n", - " | A class to represent a likelihood model for comparing an Observation\n", - " | to a PhysicalModel.\n", - " |\n", - " | The default behavior uses the following covariance matrix:\n", - " | \\[\n", - " | \\Sigma_{ij} = \\sigma^2_{i}^{stat} \\delta_{ij}\n", - " | + \\Sigma_{ij}^{sys}\n", - " | + \\gamma^2 y_m^2(x_i, \\alpha)\n", - " | \\]\n", - " | where $sigma^2_{i}^{stat}$ is the statistical variance of the i-th\n", - " | observation, (`observation.statistical_covariance`) and $\\gamma$ is the\n", - " | fractional uncorrelated error (`self.frac_err`).\n", - " |\n", - " | Here, $Sigma_{ij}^{sys}$ is the systematic covariance matrix:\n", - " | \\[\n", - " | \\Sigma_{ij}^{sys} = \\eta**2 y_m(x_i, \\alpha) y_m(x_j, \\alpha) + \\omega,\n", - " | \\]\n", - " | where $\\eta$ is the uncertainty in the overall normalization of the\n", - " | observation (`observation.y_sys_err_normalization`) and $\\omega$ is the\n", - " | uncertainty in the additive normalization to the observation\n", - " | (`observation.y_sys_err_offset`).\n", - " |\n", - " | Here, also, $y_m(x_i, \\alpha)$ is the model prediction for the i-th\n", - " | observation. Thus the covariance matrix is dependent on the values\n", - " | of the PhysicalModel and its parameters, as is the case when systematic\n", - " | errors are present in the observation, following D'Agostini, G. (1993) 'On\n", - " | the use of the covariance matrix to fit correlated data'\n", - " |\n", - " | Note that if there is no systematic uncertainty encoded in the `observation`\n", - " | and `self.frac_err` takes the default value of 0, the\n", - " | covariance matrix becomes diaginal, and the `chi2` function reduces to the\n", - " | simple and familiar $\\chi^2$ form.\n", - " |\n", - " | Note also that this is equivalent to the alternative method to handle systematic\n", - " | errors described by Barlow, R (2021) 'Combining experiments with systematic\n", - " | errors', in which nuisance parameters are introduced corresponding to the\n", - " | normalization and additive offset bias of the observation.\n", - " |\n", - " | The advantage of this approach is that it does not require introducing\n", - " | nuisance parameters, but instead encodes the correlation between the data\n", - " | points in the observation in the covariance matrix directly.\n", - " |\n", - " | Methods defined here:\n", + "class GaussianLikelihood(Likelihood)\n", + " | Multivariate-normal likelihood over the stacked residual.\n", " |\n", - " | __init__(self)\n", - " | Initializes the LikelihoodModel, optionally with a fractional\n", - " | uncorrelated error.\n", + " | Parameter-free — all uncertainty lives on the covariance terms.\n", " |\n", - " | chi2(self, observation: rxmc.observation.Observation, ym: numpy.ndarray)\n", - " | Calculate the generalised chi-squared statistic. This is the\n", - " | square of the Mahalanobis distance between y and ym\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | observation : Observation\n", - " | The observation object containing the observed data.\n", - " | ym : np.ndarray\n", - " | Model prediction for the observation.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | float\n", - " | Chi-squared statistic.\n", - " |\n", - " | covariance(self, observation: rxmc.observation.Observation, ym: numpy.ndarray)\n", - " | Default covariance model. Derived classes of `LikelihoodModel` will\n", - " | override this.\n", - " |\n", - " | Returns the following covariance matrix:\n", - " | \\[\n", - " | \\Sigma_{ij} = \\sigma^2_{i}^{stat} \\delta_{ij}\n", - " | + \\Sigma_{ij}^{sys}\n", - " | + \\gamma^2 y_m^2(x_i, \\alpha)\n", - " | \\]\n", - " | where $sigma^2_{i}^{stat}$ is the statistical variance of the i-th\n", - " | observation, (`observation.statistical_covariance`) and $\\gamma$ is the\n", - " | fractional uncorrelated error (`self.frac_err`).\n", - " |\n", - " | Here, $Sigma_{ij}^{sys}$ is the systematic covariance matrix:\n", - " | \\[\n", - " | \\Sigma_{ij}^{sys} = \\eta**2 y_m(x_i, \\alpha) y_m(x_j, \\alpha) + \\omega,\n", - " | \\]\n", - " | where $\\eta$ is the uncertainty in the overall normalization of the\n", - " | observation (`observation.y_sys_err_normalization`) and $\\omega$ is the\n", - " | uncertainty in the additive normalization to the observation\n", - " | (`observation.y_sys_err_offset`).\n", - " |\n", - " | Here, also, $y_m(x_i, \\alpha)$ is the model prediction for the i-th\n", - " | observation.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | ym : np.ndarray\n", - " | Model prediction for the observation.\n", - " | observation : Observation\n", - " | The observation object containing the observed data.\n", + " | Method resolution order:\n", + " | GaussianLikelihood\n", + " | Likelihood\n", + " | builtins.object\n", " |\n", - " | Returns\n", - " | -------\n", - " | np.ndarray\n", - " | Covariance matrix of the observation.\n", + " | Methods defined here:\n", " |\n", - " | log_likelihood(\n", - " | self,\n", - " | observation: rxmc.observation.Observation,\n", - " | ym: numpy.ndarray\n", - " | )\n", - " | Returns the log_likelihood that ym reproduces y, given the covariance\n", + " | log_likelihood(self, d2, logdet, n, *like_params)\n", " |\n", - " | Parameters\n", - " | ----------\n", - " | ym : np.ndarray\n", - " | Model prediction for the observation.\n", - " | observation : Observation\n", - " | The observation object containing the observed data.\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes defined here:\n", " |\n", - " | Returns\n", - " | -------\n", - " | float\n", + " | __annotations__ = {}\n", " |\n", - " | residual(self, observation: rxmc.observation.Observation, ym: numpy.ndarray)\n", - " | Returns the residual between the model prediction ym and\n", - " | observation.y\n", + " | ----------------------------------------------------------------------\n", + " | Methods inherited from Likelihood:\n", " |\n", - " | Parameters:\n", - " | ----------\n", - " | observation : Observation\n", - " | The observation object containing the observed data.\n", - " | ym : np.ndarray\n", - " | Model prediction for the observation.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | np.ndarray\n", - " | Residual vector.\n", + " | chi2(self, d2, logdet, n, *like_params)\n", " |\n", " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", + " | Data descriptors inherited from Likelihood:\n", " |\n", " | __dict__\n", " | dictionary for instance variables\n", " |\n", " | __weakref__\n", " | list of weak references to the object\n", + " |\n", + " | ----------------------------------------------------------------------\n", + " | Data and other attributes inherited from Likelihood:\n", + " |\n", + " | n_params = 0\n", + " |\n", + " | params = ()\n", "\n" ] } ], "source": [ - "help(rxmc.likelihood_model.LikelihoodModel)" + "help(rxmc.likelihood_model.GaussianLikelihood)" ] }, { @@ -914,14 +944,7 @@ "id": "685dec98-6cf8-49e4-b1aa-3bad227ffe8b", "metadata": {}, "source": [ - "Sorry, I know that's a lot to read. The important piece is right here:\n", - "\n", - " | Note that if there is no systematic uncertainty encoded in the `observation`\n", - " | and `self.fractional_uncorrelated_error` takes the default value of 0, the\n", - " | covariance matrix becomes diaginal, and the `chi2` function reduces to the\n", - " | simple and familiar $\\chi^2$ form.\n", - "\n", - "This means that, in our case in which the errors are only statistical, the likelihood will be porportional to the familiar form:\n", + "With a purely statistical (diagonal) covariance, the likelihood is proportional to the familiar form:\n", "\n", "\\begin{equation}\n", " \\mathcal{L}(\\alpha|y) \\propto e^{ - \\chi^2(\\alpha,y) }\n", @@ -938,19 +961,33 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "8b698c69-7a23-4955-ab7a-15107774bec9", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.743560Z", + "iopub.status.busy": "2026-08-11T03:09:07.743395Z", + "iopub.status.idle": "2026-08-11T03:09:07.745930Z", + "shell.execute_reply": "2026-08-11T03:09:07.745391Z" + } + }, "outputs": [], "source": [ - "likelihood_model = rxmc.likelihood_model.LikelihoodModel()" + "likelihood_model = rxmc.likelihood_model.GaussianLikelihood()" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "211990b6-85ba-47b1-89c4-796c5b396168", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.747662Z", + "iopub.status.busy": "2026-08-11T03:09:07.747493Z", + "iopub.status.idle": "2026-08-11T03:09:07.750438Z", + "shell.execute_reply": "2026-08-11T03:09:07.749818Z" + } + }, "outputs": [], "source": [ "constraint = rxmc.constraint.Constraint(\n", @@ -970,17 +1007,24 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "51b72666-3986-42f1-8262-8de23eb87ee3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.752100Z", + "iopub.status.busy": "2026-08-11T03:09:07.751936Z", + "iopub.status.idle": "2026-08-11T03:09:07.755357Z", + "shell.execute_reply": "2026-08-11T03:09:07.754829Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "np.float64(64.18631209285807)" + "64.18631209285807" ] }, - "execution_count": 24, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -999,9 +1043,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "a845e4ff-1d51-455b-97c8-e7ad561a89ce", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.757071Z", + "iopub.status.busy": "2026-08-11T03:09:07.756908Z", + "iopub.status.idle": "2026-08-11T03:09:07.760621Z", + "shell.execute_reply": "2026-08-11T03:09:07.759942Z" + } + }, "outputs": [ { "data": { @@ -1009,7 +1060,7 @@ "np.float64(64.18631209285807)" ] }, - "execution_count": 25, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -1029,9 +1080,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "dd9fa5b9-10ab-4649-96c0-58f9cb6896f6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.762137Z", + "iopub.status.busy": "2026-08-11T03:09:07.761976Z", + "iopub.status.idle": "2026-08-11T03:09:07.766123Z", + "shell.execute_reply": "2026-08-11T03:09:07.765448Z" + } + }, "outputs": [ { "name": "stdout", @@ -1040,147 +1098,110 @@ "Help on class Walker in module rxmc.walker:\n", "\n", "class Walker(builtins.object)\n", - " | Walker(\n", - " | model_sampler: rxmc.param_sampling.Sampler,\n", - " | evidence: rxmc.evidence.Evidence,\n", - " | likelihood_samplers: list[rxmc.param_sampling.Sampler] = [],\n", - " | rng: numpy.random._generator.Generator = Generator(PCG64) at 0x14FA84891460\n", - " | )\n", - " |\n", - " | A class that encapsulates the sampling configuration for a Bayesian\n", - " | inference problem, including the physical model and likelihood model\n", - " | configurations. It manages the sampling process for both the physical\n", - " | model and the likelihood model parameters, alternating between each\n", - " | model in a Gibbs sampling framework.\n", + " | Walker(model_sampler: rxmc.param_sampling.Sampler, evidence: rxmc.evidence.Evidence, likelihood_samplers: list[rxmc.param_sampling.Sampler] | None = None, rng: numpy.random._generator.Generator | None = None)\n", " |\n", - " | Methods defined here:\n", + " | Gibbs-style MCMC coordinator for a Bayesian calibration problem.\n", " |\n", - " | __init__(\n", - " | self,\n", - " | model_sampler: rxmc.param_sampling.Sampler,\n", - " | evidence: rxmc.evidence.Evidence,\n", - " | likelihood_samplers: list[rxmc.param_sampling.Sampler] = [],\n", - " | rng: numpy.random._generator.Generator = Generator(PCG64) at 0x14FA84891460\n", - " | )\n", - " | Initialize the Sampler with a list of samplers.\n", + " | Manages one sampler for the physical-model parameters and, optionally,\n", + " | per-constraint samplers for parametric likelihood parameters. The samplers\n", + " | alternate in a Gibbs framework: model parameters are updated with the\n", + " | likelihood parameters held fixed, then each set of likelihood parameters is\n", + " | updated with the model parameters held fixed.\n", " |\n", - " | Parameters:\n", - " | ----------\n", - " | model_sampler: Sampler\n", - " | A Sampler object for physical model parameters.\n", - " | evidence: Evidence\n", - " | A Evidence object containing the data for which the likelihood\n", - " | model is evaluated.\n", - " | likelihood_model_samplers: list[Sampler]\n", - " | A list of Sampler objects for likelihood model parameters.\n", - " | Corresponds to the order of `evidence.parametric_constraints`.\n", - " | rng: np.random.Generator, optional\n", - " | A random number generator for reproducibility. Defaults to a new\n", - " | default_rng with a fixed seed.\n", + " | Parameters\n", + " | ----------\n", + " | model_sampler : Sampler\n", + " | Sampler for the physical-model parameters.\n", + " | evidence : Evidence\n", + " | Evidence object containing the observations and likelihood models.\n", + " | likelihood_samplers : list of Sampler, optional\n", + " | One sampler per entry in ``evidence.parametric_constraints``.\n", + " | rng : np.random.Generator, optional\n", + " | Random number generator. Defaults to ``default_rng(42)``.\n", + " |\n", + " | Raises\n", + " | ------\n", + " | ValueError\n", + " | If the physical-model parameters in *evidence* and *model_sampler* do\n", + " | not match.\n", + " | ValueError\n", + " | If the number of *likelihood_samplers* does not equal the number of\n", + " | parametric constraints in *evidence*.\n", + " | ValueError\n", + " | If any likelihood sampler's parameters do not match those of the\n", + " | corresponding parametric constraint.\n", + " |\n", + " | Methods defined here:\n", + " |\n", + " | __init__(self, model_sampler: rxmc.param_sampling.Sampler, evidence: rxmc.evidence.Evidence, likelihood_samplers: list[rxmc.param_sampling.Sampler] | None = None, rng: numpy.random._generator.Generator | None = None)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", " | log_likelihood(self, model_params, likelihood_params)\n", " |\n", " | log_posterior(self, model_params, likelihood_params)\n", " |\n", " | log_prior(self, model_params, likelihood_params)\n", - " | Returns the log-prior probability of the model parameters and\n", - " | likelihood parameters.\n", + " | Log prior probability of model and likelihood parameters.\n", " |\n", - " | Parameters:\n", + " | Parameters\n", " | ----------\n", - " | model_params: tuple\n", - " | The parameters of the physical model.\n", - " | likelihood_params: list[tuple]\n", - " | A list of tuples containing additional parameters for the\n", - " | likelihood model for each constraint.\n", + " | model_params : tuple\n", + " | Physical-model parameter values.\n", + " | likelihood_params : list of tuple\n", + " | One tuple of likelihood parameter values per parametric constraint.\n", " |\n", - " | Returns:\n", + " | Returns\n", " | -------\n", " | float\n", - " | The log-prior probability.\n", - " |\n", - " | run_likelihood_batches(\n", - " | self,\n", - " | n_steps,\n", - " | starting_locations,\n", - " | model_params,\n", - " | burn=False\n", - " | )\n", - " | Walks each of the likelihood parameter spacers one by one, for a\n", - " | fixed value of `model_params`\n", - " |\n", - " | Parameters:\n", + " | Sum of log prior densities for model and likelihood parameters.\n", + " |\n", + " | run_likelihood_batches(self, n_steps, starting_locations, model_params, burn=False)\n", + " | Sample each set of likelihood parameters for fixed model parameters.\n", + " |\n", + " | Parameters\n", " | ----------\n", - " | n_steps: int\n", - " | The number of steps to run for each likelihood model.\n", - " | starting_locations: list[np.ndarray]\n", - " | A list of starting locations for each likelihood model.\n", - " | model_params: tuple\n", - " | A fixed value of the parameters for the physical model\n", - " | burn: bool\n", - " | If True, the batch is considered a burn-in batch and\n", - " | the acceptance rate, log probabilities, and parameter\n", - " | chain will not be recorded.\n", - " |\n", - " | Returns:\n", - " | -------\n", - " | list[np.ndarray]\n", - " | A list of parameter chains for each likelihood model.\n", - " | logp : list[np.ndarray]\n", - " | A list of log probabilities for each likelihood model.\n", - " | accepted : list[float]\n", - " | A list of acceptance rates for each likelihood model.\n", - " |\n", - " | run_model_batch(self, n_steps, x0, likelihood_params=[], burn=False)\n", - " | Walks the model parameter space for fixed values of the\n", - " | `likelihood_params`\n", - " |\n", - " | Parameters:\n", + " | n_steps : int\n", + " | Number of MCMC steps per likelihood sampler.\n", + " | starting_locations : list of np.ndarray\n", + " | Starting locations for each likelihood sampler.\n", + " | model_params : tuple\n", + " | Fixed physical-model parameter values.\n", + " | burn : bool, optional\n", + " | If ``True``, treat as burn-in (samples are not recorded).\n", + " |\n", + " | run_model_batch(self, n_steps, x0, likelihood_params=None, burn=False)\n", + " | Sample model parameters for fixed likelihood parameters.\n", + " |\n", + " | Parameters\n", " | ----------\n", - " | n_steps: int\n", - " | The number of steps to run for the model sampling.\n", - " | x0: np.ndarray\n", - " | The starting location for the model sampling.\n", - " | likelihood_params: list[tuple]\n", - " | A list of fixed values of the parameters for each of the\n", - " | parametric likelihood models, corresponding to the order\n", - " | of `self.likelihood_samplers`\n", - " | burn: bool\n", - " | If True, the batch is considered a burn-in batch and\n", - " | the acceptance rate, log probabilities, and parameter\n", - " | chain will not be recorded.\n", - " |\n", - " | Returns:\n", - " | -------\n", - " | batch_chain: np.ndarray\n", - " | The parameter chain generated by the model sampling algorithm.\n", - " | logp: np.ndarray\n", - " | The log probabilities of the parameter chain.\n", - " | accepted: float\n", - " | The acceptance rate of the model sampling algorithm.\n", - " |\n", - " | walk(\n", - " | self,\n", - " | n_steps: int,\n", - " | burnin: int = 0,\n", - " | batch_size: int = None,\n", - " | verbose: bool = True\n", - " | )\n", - " | Runs the MCMC chain with the specified parameters.\n", - " | Updates the internal state of the `model_sampler` and\n", - " | `likelihood_samplers` with records of the walk and relevant\n", - " | statistics.\n", - " |\n", - " | Parameters:\n", - " | -----------\n", - " | n_steps : int\n", - " | Total number of active steps for the MCMC chain.\n", - " | batch_size : int\n", - " | Number of steps per batch.\n", - " | burnin : int\n", - " | Number of extra burn-in steps to do before active steps\n", - " | verbose : bool\n", - " | Flag to print extra logging information.\n", + " | n_steps : int\n", + " | Number of MCMC steps.\n", + " | x0 : np.ndarray\n", + " | Starting location for the model parameters.\n", + " | likelihood_params : list of tuple, optional\n", + " | Fixed values of the likelihood parameters for each parametric\n", + " | constraint. Defaults to ``[]``.\n", + " | burn : bool, optional\n", + " | If ``True``, treat as burn-in (samples are not recorded).\n", + " |\n", + " | walk(self, n_steps: int, burnin: int = 0, batch_size: int = None, verbose: bool = True)\n", + " | Run the full MCMC chain.\n", + " |\n", + " | Updates the internal state of ``model_sampler`` and each entry of\n", + " | ``likelihood_samplers`` with the accumulated chain, log posteriors,\n", + " | and acceptance statistics.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | n_steps : int\n", + " | Total number of active (post-burn-in) steps.\n", + " | burnin : int, optional\n", + " | Number of burn-in steps discarded before recording.\n", + " | Defaults to ``0``.\n", + " | batch_size : int, optional\n", + " | Steps per batch. If ``None`` the entire chain is one batch.\n", + " | verbose : bool, optional\n", + " | Print batch completion messages. Defaults to ``True``.\n", " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", @@ -1208,9 +1229,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "id": "1ff7c728-b0ac-4c48-8779-19da58277cc9", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.767747Z", + "iopub.status.busy": "2026-08-11T03:09:07.767554Z", + "iopub.status.idle": "2026-08-11T03:09:07.770332Z", + "shell.execute_reply": "2026-08-11T03:09:07.769632Z" + } + }, "outputs": [], "source": [ "evidence = rxmc.evidence.Evidence([constraint])" @@ -1226,9 +1254,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "id": "5470a662-4880-418d-85aa-deadeca0cfe7", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.771869Z", + "iopub.status.busy": "2026-08-11T03:09:07.771708Z", + "iopub.status.idle": "2026-08-11T03:09:07.775298Z", + "shell.execute_reply": "2026-08-11T03:09:07.774722Z" + } + }, "outputs": [ { "name": "stdout", @@ -1237,14 +1272,21 @@ "Help on class MetropolisHastingsSampler in module rxmc.param_sampling:\n", "\n", "class MetropolisHastingsSampler(Sampler)\n", - " | MetropolisHastingsSampler(\n", - " | params: list[rxmc.params.Parameter],\n", - " | prior,\n", - " | starting_location: numpy.ndarray,\n", - " | proposal: rxmc.proposal.ProposalDistribution\n", - " | )\n", + " | MetropolisHastingsSampler(params: list[rxmc.params.Parameter], prior, starting_location: numpy.ndarray, proposal: rxmc.proposal.ProposalDistribution)\n", " |\n", - " | Metropolis-Hastings sampler. The ol' reliable.\n", + " | Metropolis-Hastings sampler with a fixed proposal distribution.\n", + " |\n", + " | Parameters\n", + " | ----------\n", + " | params : list of Parameter\n", + " | Parameters to sample.\n", + " | prior : object\n", + " | Prior distribution with a callable ``logpdf(x)`` method.\n", + " | starting_location : np.ndarray, shape (ndim,)\n", + " | Initial parameter vector.\n", + " | proposal : ProposalDistribution\n", + " | Callable proposal distribution. Must accept ``(x, rng)`` and return\n", + " | a proposed parameter vector.\n", " |\n", " | Method resolution order:\n", " | MetropolisHastingsSampler\n", @@ -1253,84 +1295,70 @@ " |\n", " | Methods defined here:\n", " |\n", - " | __init__(\n", - " | self,\n", - " | params: list[rxmc.params.Parameter],\n", - " | prior,\n", - " | starting_location: numpy.ndarray,\n", - " | proposal: rxmc.proposal.ProposalDistribution\n", - " | )\n", - " | Parameters:\n", - " | ----------\n", - " | params: list[params.Parameter]\n", - " | List of parameters to sample.\n", - " | prior: object\n", - " | Prior distribution object that has a method `logpdf`.\n", - " | starting_location: np.ndarray\n", - " | Initial parameter values for the chain.\n", - " | proposal: proposal.ProposalDistribution\n", - " | Proposal distribution object that has a method `__call__` which\n", - " | takes in a parameter vector and an rng, returning a proposed\n", - " | parameter vector.\n", + " | __init__(self, params: list[rxmc.params.Parameter], prior, starting_location: numpy.ndarray, proposal: rxmc.proposal.ProposalDistribution)\n", + " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", " | ----------------------------------------------------------------------\n", " | Methods inherited from Sampler:\n", " |\n", " | batch_acceptance_fractions(self) -> numpy.ndarray\n", - " | Returns the acceptance fraction of the sampler in each batch run.\n", + " | Acceptance fraction for each completed batch.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | np.ndarray\n", + " | Per-batch acceptance fractions, or ``[0.0]`` if no batches run.\n", " |\n", " | most_recent_batch_acceptance_fraction(self) -> float\n", - " | Returns the acceptance fraction of the most recent batch run.\n", + " | Acceptance fraction of the most recent batch.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | float\n", + " | Fraction of proposals accepted in the last batch, or ``0.0`` if\n", + " | no batches have been run.\n", " |\n", " | overall_acceptance_fraction(self) -> float\n", - " | Returns the overall acceptance fraction of the sampler.\n", - " |\n", - " | record_batch(\n", - " | self,\n", - " | n_steps: int,\n", - " | n_accepted: int,\n", - " | chain: numpy.ndarray,\n", - " | logp_chain: numpy.ndarray\n", - " | )\n", - " | Records the batch of samples and acceptance statistics.\n", - " |\n", - " | Parameters:\n", + " | Overall acceptance fraction across all completed batches.\n", + " |\n", + " | Returns\n", + " | -------\n", + " | float\n", + " | Total accepted / total proposed, or ``0.0`` if no batches run.\n", + " |\n", + " | record_batch(self, n_steps: int, n_accepted: int, chain: numpy.ndarray, logp_chain: numpy.ndarray)\n", + " | Append a completed batch to the running chain.\n", + " |\n", + " | Parameters\n", " | ----------\n", - " | n_steps: int\n", + " | n_steps : int\n", " | Number of steps in the batch.\n", - " | n_accepted: int\n", - " | Number of accepted samples in the batch.\n", - " | chain: np.ndarray\n", - " | Array of sampled parameter vectors.\n", - " | logp_chain: np.ndarray\n", - " | Array of log posterior values corresponding to the sampled parameter vectors.\n", - " |\n", - " | sample(\n", - " | self,\n", - " | n_steps: int,\n", - " | starting_location: numpy.ndarray,\n", - " | rng: numpy.random._generator.Generator,\n", - " | log_posterior: Callable[[numpy.ndarray], float],\n", - " | burn: bool = False\n", - " | )\n", - " | Samples from the posterior distribution using the specified\n", - " | sampling algorithm, updating the state and recording the chain,\n", - " | log posterior values, and acceptance statistics.\n", - " |\n", - " | Parameters:\n", + " | n_accepted : int\n", + " | Number of accepted proposals in the batch.\n", + " | chain : np.ndarray, shape (n_steps, ndim)\n", + " | Sampled parameter vectors.\n", + " | logp_chain : np.ndarray, shape (n_steps,)\n", + " | Log posterior values for the batch.\n", + " |\n", + " | sample(self, n_steps: int, starting_location: numpy.ndarray, rng: numpy.random._generator.Generator, log_posterior: Callable[[numpy.ndarray], float], burn: bool = False)\n", + " | Run the sampling algorithm for one batch.\n", + " |\n", + " | Updates ``self.state`` to the last sample; records the batch unless\n", + " | *burn* is ``True``.\n", + " |\n", + " | Parameters\n", " | ----------\n", - " | n_steps: int\n", - " | Number of steps to sample.\n", - " | starting_location: np.ndarray\n", - " | Initial parameter values for the chain.\n", - " | rng: np.random.Generator\n", - " | Random number generator for reproducibility.\n", - " | log_posterior: Callable[[np.ndarray], float]\n", - " | Function that computes the log posterior probability of\n", - " | a parameter vector.\n", - " | burn: bool\n", - " | If True, the samples are considered burn-in and will not\n", - " | be recorded in the chain, only the current state will be updated.\n", + " | n_steps : int\n", + " | Number of steps to run.\n", + " | starting_location : np.ndarray, shape (ndim,)\n", + " | Starting parameter vector for this batch.\n", + " | rng : np.random.Generator\n", + " | Random number generator.\n", + " | log_posterior : callable\n", + " | Function ``f(x) -> float`` returning the log posterior at ``x``.\n", + " | burn : bool, optional\n", + " | If ``True``, discard samples (burn-in); only ``self.state`` is\n", + " | updated. Defaults to ``False``.\n", " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors inherited from Sampler:\n", @@ -1358,9 +1386,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "id": "9c0ac067-047a-4357-a462-415e32d0481c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.776959Z", + "iopub.status.busy": "2026-08-11T03:09:07.776787Z", + "iopub.status.idle": "2026-08-11T03:09:07.779534Z", + "shell.execute_reply": "2026-08-11T03:09:07.778858Z" + } + }, "outputs": [], "source": [ "def proposal_distribution(x, rng):\n", @@ -1371,9 +1406,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "id": "5362bf0b-76d4-419b-af34-2ee94e3b2dda", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.781050Z", + "iopub.status.busy": "2026-08-11T03:09:07.780883Z", + "iopub.status.idle": "2026-08-11T03:09:07.783689Z", + "shell.execute_reply": "2026-08-11T03:09:07.783104Z" + } + }, "outputs": [], "source": [ "sampling_config = rxmc.param_sampling.MetropolisHastingsSampler(\n", @@ -1386,9 +1428,16 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 30, "id": "784ebdb9-b5f2-4a2f-9882-a65d2f107c05", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.785440Z", + "iopub.status.busy": "2026-08-11T03:09:07.785276Z", + "iopub.status.idle": "2026-08-11T03:09:07.788142Z", + "shell.execute_reply": "2026-08-11T03:09:07.787286Z" + } + }, "outputs": [], "source": [ "walker = rxmc.walker.Walker(\n", @@ -1399,19 +1448,32 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 31, "id": "194af035-fafd-4c64-8b58-0f7af34bb685", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:07.789652Z", + "iopub.status.busy": "2026-08-11T03:09:07.789496Z", + "iopub.status.idle": "2026-08-11T03:09:15.058935Z", + "shell.execute_reply": "2026-08-11T03:09:15.057935Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 20000 steps. \n", " Model parameter acceptance fraction: 0.273\n", - "CPU times: user 6.51 s, sys: 151 ms, total: 6.66 s\n", - "Wall time: 7.97 s\n" + "CPU times: user 7.28 s, sys: 23.3 ms, total: 7.31 s\n", + "Wall time: 7.27 s\n" ] } ], @@ -1425,9 +1487,16 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 32, "id": "b57ce430-2014-4999-9e4f-3f16f0c3c8fc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.060564Z", + "iopub.status.busy": "2026-08-11T03:09:15.060387Z", + "iopub.status.idle": "2026-08-11T03:09:15.063241Z", + "shell.execute_reply": "2026-08-11T03:09:15.062413Z" + } + }, "outputs": [], "source": [ "chain = walker.model_sampler.chain\n", @@ -1436,9 +1505,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 33, "id": "8bd838cf-8ed2-43b9-a545-416b9f5b802c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.064834Z", + "iopub.status.busy": "2026-08-11T03:09:15.064663Z", + "iopub.status.idle": "2026-08-11T03:09:15.068500Z", + "shell.execute_reply": "2026-08-11T03:09:15.067598Z" + } + }, "outputs": [ { "data": { @@ -1446,7 +1522,7 @@ "(20000, 2)" ] }, - "execution_count": 34, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -1457,9 +1533,16 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 34, "id": "122e8c8e-4975-42b0-96ef-611cb9187c85", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.070108Z", + "iopub.status.busy": "2026-08-11T03:09:15.069926Z", + "iopub.status.idle": "2026-08-11T03:09:15.438422Z", + "shell.execute_reply": "2026-08-11T03:09:15.437498Z" + } + }, "outputs": [ { "data": { @@ -1467,13 +1550,13 @@ "Text(0.5, 0, '$i$')" ] }, - "execution_count": 35, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1500,9 +1583,16 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 35, "id": "6b20814a-1595-4881-9190-6f03ee4811e3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.440066Z", + "iopub.status.busy": "2026-08-11T03:09:15.439884Z", + "iopub.status.idle": "2026-08-11T03:09:15.444340Z", + "shell.execute_reply": "2026-08-11T03:09:15.443554Z" + } + }, "outputs": [], "source": [ "posterior_range = np.vstack([np.min(chain, axis=0), np.max(chain, axis=0)]).T" @@ -1510,9 +1600,16 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 36, "id": "21ca84ce-5d9a-44db-8651-f9c80e9b1f68", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.445989Z", + "iopub.status.busy": "2026-08-11T03:09:15.445814Z", + "iopub.status.idle": "2026-08-11T03:09:15.637095Z", + "shell.execute_reply": "2026-08-11T03:09:15.636320Z" + } + }, "outputs": [ { "data": { @@ -1520,13 +1617,13 @@ "Text(0.5, 0.98, 'posterior')" ] }, - "execution_count": 37, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1547,9 +1644,16 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 37, "id": "4aaec946-4f48-47e0-ad46-f6d71e866341", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.638929Z", + "iopub.status.busy": "2026-08-11T03:09:15.638758Z", + "iopub.status.idle": "2026-08-11T03:09:15.641318Z", + "shell.execute_reply": "2026-08-11T03:09:15.640744Z" + } + }, "outputs": [], "source": [ "x_full = np.linspace(-1, 2, 10)" @@ -1557,9 +1661,16 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 38, "id": "2aab97fb-db36-4a05-aef0-8774173188df", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.642802Z", + "iopub.status.busy": "2026-08-11T03:09:15.642643Z", + "iopub.status.idle": "2026-08-11T03:09:15.726232Z", + "shell.execute_reply": "2026-08-11T03:09:15.725497Z" + } + }, "outputs": [], "source": [ "n_posterior_samples = chain.shape[0]\n", @@ -1573,23 +1684,30 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 39, "id": "92fc68f8-9be2-4e5f-9bf0-65eb796f5e0a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.728106Z", + "iopub.status.busy": "2026-08-11T03:09:15.727930Z", + "iopub.status.idle": "2026-08-11T03:09:15.874964Z", + "shell.execute_reply": "2026-08-11T03:09:15.874133Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 40, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1632,7 +1750,7 @@ "source": [ "# Nice!\n", "\n", - "Hopefully this simple example served to illustrate the basic function of the working pieces of `rxmc`. The true power is the ability to compose different `Constraint`s, and easily manage and test different model forms for both the `PhysicalModel` and `LikelihoodModel`. \n", + "Hopefully this simple example served to illustrate the basic function of the working pieces of `rxmc`. The true power is the ability to compose different `Constraint`s, and easily manage and test different model forms for both the `PhysicalModel` and the covariance terms describing the uncertainty. \n", "\n", "\n", "Check out the other demos to see how `rxmc` helps us handle more realistic problems." @@ -1655,7 +1773,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/examples/measurement_to_calibration.ipynb b/examples/measurement_to_calibration.ipynb new file mode 100644 index 0000000..ffb80dd --- /dev/null +++ b/examples/measurement_to_calibration.ipynb @@ -0,0 +1,619 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "78ffc016", + "metadata": {}, + "source": [ + "# From a measurement to a calibrated potential\n", + "\n", + "This notebook walks the **production path**: an EXFOR-shaped measurement —\n", + "reported in its own units, with statistical *and* systematic errors — is turned\n", + "into an `ElasticDifferentialXSObservation` via `from_measurement`, its reported\n", + "systematics are composed as explicit covariance terms, and a small optical\n", + "potential is calibrated against it.\n", + "\n", + "The unit contract, up front:\n", + "\n", + "- **dimensionful** errors (statistical, absolute offset) are divided by the unit\n", + " normalization `norm` when the observation is built;\n", + "- the **fractional** normalization error is dimensionless and passes through\n", + " untouched;\n", + "- `norm` itself is retained as `obs.norm` for provenance.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "9585b106", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:06.821526Z", + "iopub.status.busy": "2026-08-11T03:07:06.821389Z", + "iopub.status.idle": "2026-08-11T03:07:09.182945Z", + "shell.execute_reply": "2026-08-11T03:07:09.182237Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], + "source": [ + "from types import SimpleNamespace\n", + "\n", + "import corner\n", + "import jitr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from jitr.optical_potentials.potential_forms import (\n", + " thomas_safe,\n", + " woods_saxon_prime_safe,\n", + " woods_saxon_safe,\n", + ")\n", + "from scipy import stats\n", + "\n", + "import rxmc\n", + "from rxmc.params import Parameter\n", + "\n", + "rng = np.random.default_rng(11)" + ] + }, + { + "cell_type": "markdown", + "id": "213805bd", + "metadata": {}, + "source": [ + "## The reaction and optical model" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63f8c4a7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.184651Z", + "iopub.status.busy": "2026-08-11T03:07:09.184357Z", + "iopub.status.idle": "2026-08-11T03:07:09.213438Z", + "shell.execute_reply": "2026-08-11T03:07:09.212848Z" + } + }, + "outputs": [], + "source": [ + "Ca40 = (40, 20)\n", + "neutron = (1, 0)\n", + "E_lab = 14.1\n", + "\n", + "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", + "\n", + "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", + "\n", + "\n", + "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", + " 4j * ad * Wd\n", + " ) * woods_saxon_prime_safe(r, Rd, ad)\n", + "\n", + "\n", + "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", + " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", + "\n", + "\n", + "R = 1.2 * 40 ** (1 / 3)\n", + "fixed_spin_orbit = (6.0, -3, R, 0.45)\n", + "\n", + "\n", + "def extract_params(ws, *x):\n", + " Vv, Wv, Rv, av, Wd, Rd, ad = x\n", + " central_params = (Vv, Wv, Rv, av, Wd, Rd, ad)\n", + " return central_params, fixed_spin_orbit\n", + "\n", + "\n", + "params = [\n", + " Parameter(\"Vv\", unit=\"MeV\"),\n", + " Parameter(\"Wv\", unit=\"MeV\"),\n", + " Parameter(\"Rv\", unit=\"fm\"),\n", + " Parameter(\"av\", unit=\"fm\"),\n", + " Parameter(\"Wd\", unit=\"MeV\"),\n", + " Parameter(\"Rd\", unit=\"fm\"),\n", + " Parameter(\"ad\", unit=\"fm\"),\n", + "]\n", + "\n", + "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + " \"dXS/dA\",\n", + " interaction_central=central_potential,\n", + " interaction_spin_orbit=spin_orbit_potential,\n", + " calculate_interaction_from_params=extract_params,\n", + " params=params,\n", + " model_name=\"measurement_demo\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "895e8324", + "metadata": {}, + "source": [ + "## A measurement, as EXFOR reports it\n", + "\n", + "EXFOR entries report cross sections in their own units — here **mb/sr** — with a\n", + "statistical error column and, often, scalar systematic errors: a *fractional*\n", + "normalization uncertainty (e.g. from the flux calibration) and an *absolute*\n", + "offset uncertainty (e.g. from background subtraction), in the same units as the\n", + "data. We mock up such a measurement (`exfor_tools.Distribution` carries exactly\n", + "these fields) from a known truth so we can check the calibration at the end.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c7dff4fd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.215225Z", + "iopub.status.busy": "2026-08-11T03:07:09.215072Z", + "iopub.status.idle": "2026-08-11T03:07:20.015257Z", + "shell.execute_reply": "2026-08-11T03:07:20.014738Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "angles_deg = np.linspace(5.0, 160.0, 20)\n", + "true_params = np.array(\n", + " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", + ")\n", + "\n", + "template_obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", + " x=angles_deg,\n", + " y=np.ones_like(angles_deg, dtype=float),\n", + " Elab=E_lab,\n", + " reaction=rxn,\n", + " quantity=\"dXS/dA\",\n", + " measurement_quantity=\"dXS/dA\",\n", + " y_units=\"barn / steradian\",\n", + " dataset_label=\"template\",\n", + ")\n", + "\n", + "y_true_b = omp.evaluate(template_obs, *true_params) # b/sr\n", + "y_true_mb = y_true_b * 1000.0 # the measurement is reported in mb/sr\n", + "\n", + "stat_err_mb = 0.08 * np.maximum(y_true_mb, 1e-1)\n", + "y_mb = np.clip(y_true_mb + rng.normal(scale=stat_err_mb), 1e-3, None)\n", + "\n", + "measurement = SimpleNamespace(\n", + " x=angles_deg, # degrees\n", + " y=y_mb, # mb/sr\n", + " Einc=E_lab,\n", + " quantity=\"dXS/dA\",\n", + " y_units=\"mb/sr\",\n", + " statistical_err=stat_err_mb, # mb/sr\n", + " systematic_norm_err=0.04, # fractional (dimensionless)\n", + " systematic_offset_err=2.0, # absolute, mb/sr\n", + " subentry=\"toy-subentry\",\n", + ")\n", + "\n", + "plt.errorbar(\n", + " measurement.x, measurement.y, measurement.statistical_err, ls=\"none\", marker=\".\"\n", + ")\n", + "plt.xlabel(r\"$\\theta$ [deg]\")\n", + "plt.ylabel(r\"$d\\sigma/d\\Omega$ [mb/sr]\")\n", + "plt.yscale(\"log\")\n", + "plt.title(\"A mock EXFOR-style measurement of n + $^{40}$Ca\");" + ] + }, + { + "cell_type": "markdown", + "id": "ac41e21a", + "metadata": {}, + "source": [ + "## `from_measurement` keeps the systematics as inert metadata\n", + "\n", + "The observation stores its data in internal units (b/sr). Everything\n", + "**dimensionful** — `y`, the statistical error, the absolute offset error — is\n", + "divided by `obs.norm` (here $10^3$, mb $\\to$ b); the **fractional** normalization\n", + "error is dimensionless and untouched. The systematics are *metadata*: they do\n", + "not enter any covariance until you ask.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "480644cd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:20.017049Z", + "iopub.status.busy": "2026-08-11T03:07:20.016896Z", + "iopub.status.idle": "2026-08-11T03:07:21.846957Z", + "shell.execute_reply": "2026-08-11T03:07:21.846224Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "unit normalization obs.norm = 1000.0\n", + "fractional norm error 0.04 (passed through)\n", + "absolute offset error 0.002 b/sr (= 2.0 mb/sr / norm)\n", + "y[0]: measurement 1834.19 mb/sr -> stored 1.83419 b/sr\n" + ] + } + ], + "source": [ + "obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.from_measurement(\n", + " measurement=measurement,\n", + " reaction=rxn,\n", + " quantity=\"dXS/dA\",\n", + ")\n", + "\n", + "print(f\"unit normalization obs.norm = {obs.norm}\")\n", + "print(f\"fractional norm error {obs.y_sys_err_normalization} (passed through)\")\n", + "print(f\"absolute offset error {obs.y_sys_err_offset} b/sr (= 2.0 mb/sr / norm)\")\n", + "print(f\"y[0]: measurement {measurement.y[0]:.2f} mb/sr -> stored {obs.y[0]:.5f} b/sr\")" + ] + }, + { + "cell_type": "markdown", + "id": "5b9b64d7", + "metadata": {}, + "source": [ + "## Nothing is folded in silently — systematics are explicit terms\n", + "\n", + "By design there is **no compatibility path that re-folds systematics into the\n", + "covariance automatically**: the default constraint covariance is the statistical\n", + "diagonal only. `obs.systematic_terms(support)` turns the retained metadata into\n", + "fixed rank-one terms — the absolute offset mode\n", + "$\\Sigma \\mathrel{+}= \\omega\\omega^T$ and the prediction-scaled normalization mode\n", + "$\\Sigma \\mathrel{+}= \\eta^2\\, y_m y_m^T$ — which you pass in as `extra_terms`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "551698f3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:21.848441Z", + "iopub.status.busy": "2026-08-11T03:07:21.848289Z", + "iopub.status.idle": "2026-08-11T03:07:22.186513Z", + "shell.execute_reply": "2026-08-11T03:07:22.185864Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['RankOneTerm', 'RankOneTerm']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(support,) = rxmc.covariance.stacked_supports([obs])\n", + "terms = obs.systematic_terms(support)\n", + "print([type(t).__name__ for t in terms])\n", + "\n", + "constraint_stat = rxmc.constraint.Constraint([obs], omp)\n", + "constraint = rxmc.constraint.Constraint([obs], omp, extra_terms=terms)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", + "for a, (c, title) in zip(\n", + " axes,\n", + " [\n", + " (constraint_stat, \"statistical only (default)\"),\n", + " (constraint, \"+ reported systematics\"),\n", + " ],\n", + "):\n", + " im = a.imshow(c.covariance_matrix(true_params), cmap=\"viridis\")\n", + " a.set_title(title)\n", + " fig.colorbar(im, ax=a, fraction=0.046)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "293e0e6e", + "metadata": {}, + "source": [ + "## Guardrail: a measurement with no statistical error\n", + "\n", + "EXFOR subentries that report only a systematic error come back with\n", + "`statistical_err = 0`. The old pipeline would let that propagate and crash deep\n", + "inside the sampler; now the `Constraint` fails fast, names the dataset, and\n", + "suggests the remedies.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5321385f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:22.187926Z", + "iopub.status.busy": "2026-08-11T03:07:22.187773Z", + "iopub.status.idle": "2026-08-11T03:07:24.064179Z", + "shell.execute_reply": "2026-08-11T03:07:24.063596Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Constraint covariance over [toy-subentry-nostat] is singular (Cholesky factorization failed). The covariance diagonal is zero on rows belonging to ['toy-subentry-nostat']: these datasets report zero statistical error and no other covariance term covers their points. Remedies: pass the dataset's reported systematics as terms (extra_terms=[*obs.systematic_terms(support)], with supports from rxmc.covariance.stacked_supports(observations)), add a noise_term or DenseTerm covering those points, or compose the full covariance explicitly with include_statistical_term=False.\n" + ] + } + ], + "source": [ + "measurement_nostat = SimpleNamespace(**{**vars(measurement)})\n", + "measurement_nostat.statistical_err = np.zeros_like(y_mb)\n", + "measurement_nostat.subentry = \"toy-subentry-nostat\"\n", + "\n", + "obs_nostat = (\n", + " rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.from_measurement(\n", + " measurement=measurement_nostat,\n", + " reaction=rxn,\n", + " quantity=\"dXS/dA\",\n", + " )\n", + ")\n", + "\n", + "try:\n", + " rxmc.constraint.Constraint([obs_nostat], omp)\n", + "except ValueError as err:\n", + " print(err)" + ] + }, + { + "cell_type": "markdown", + "id": "d98cea7e", + "metadata": {}, + "source": [ + "As the message says: supply the dataset's reported systematics as terms, add a\n", + "`noise_term` (a free noise nuisance), or compose the covariance explicitly. Note\n", + "that the offset and normalization modes alone are rank-two, so a dataset with\n", + "*only* systematic errors still needs a diagonal contribution (a noise term or an\n", + "error floor) to make $\\Sigma$ positive definite. Our measurement has statistical\n", + "errors, so we proceed.\n" + ] + }, + { + "cell_type": "markdown", + "id": "9489bae8", + "metadata": {}, + "source": [ + "## Calibrate" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "17319787", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:24.065831Z", + "iopub.status.busy": "2026-08-11T03:07:24.065682Z", + "iopub.status.idle": "2026-08-11T03:07:24.069721Z", + "shell.execute_reply": "2026-08-11T03:07:24.069224Z" + } + }, + "outputs": [], + "source": [ + "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", + "\n", + "prior_mean = np.array(\n", + " [50.0, 3, 1.2 * 40 ** (1 / 3), 0.65, 18, 1.2 * 40 ** (1 / 3), 0.65]\n", + ")\n", + "prior_cov = np.diag([7, 7, 0.2, 0.2, 10, 0.2, 0.2]) ** 2\n", + "prior = stats.multivariate_normal(mean=prior_mean, cov=prior_cov)\n", + "\n", + "walker = rxmc.walker.Walker(\n", + " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=omp.params,\n", + " prior=prior,\n", + " starting_location=prior_mean,\n", + " initial_proposal_cov=prior_cov / 100,\n", + " ),\n", + " evidence=evidence,\n", + " rng=np.random.default_rng(7),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "84438127", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:24.071394Z", + "iopub.status.busy": "2026-08-11T03:07:24.071248Z", + "iopub.status.idle": "2026-08-11T03:07:40.796744Z", + "shell.execute_reply": "2026-08-11T03:07:40.795972Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 16.7 s, sys: 1.4 ms, total: 16.7 s\n", + "Wall time: 16.7 s\n" + ] + }, + { + "data": { + "text/plain": [ + "0.206125" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "%%time\n", + "walker.walk(n_steps=8000, burnin=1000, batch_size=1000, verbose=False)\n", + "samples = walker.model_sampler.chain\n", + "walker.model_sampler.overall_acceptance_fraction()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f7b9a4c4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:40.798239Z", + "iopub.status.busy": "2026-08-11T03:07:40.798069Z", + "iopub.status.idle": "2026-08-11T03:07:42.595527Z", + "shell.execute_reply": "2026-08-11T03:07:42.594833Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " samples,\n", + " labels=[p.name for p in omp.params],\n", + " truths=true_params,\n", + " truth_color=\"k\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "dccca3bf", + "metadata": {}, + "source": [ + "## Predictive check" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1ec6c533", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:42.600185Z", + "iopub.status.busy": "2026-08-11T03:07:42.600011Z", + "iopub.status.idle": "2026-08-11T03:07:42.979739Z", + "shell.execute_reply": "2026-08-11T03:07:42.978808Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_indices = np.linspace(0, samples.shape[0] - 1, 60, dtype=int)\n", + "y_draws = np.array(\n", + " [omp.visualizable_model_prediction(obs, *d) for d in samples[draw_indices]]\n", + ")\n", + "y_low, y_high = np.percentile(y_draws, [5, 95], axis=0)\n", + "\n", + "angles_plot = np.rad2deg(obs.visualization_workspace.angles)\n", + "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", + "ax.errorbar(\n", + " np.rad2deg(obs.x), obs.y, yerr=obs.y_stat_err, ls=\"none\", marker=\"o\", label=\"data\"\n", + ")\n", + "ax.plot(\n", + " angles_plot,\n", + " omp.visualizable_model_prediction(obs, *true_params),\n", + " \"k:\",\n", + " label=\"truth\",\n", + ")\n", + "ax.fill_between(angles_plot, y_low, y_high, alpha=0.3, label=\"90% predictive band\")\n", + "ax.set_xlabel(r\"$\\theta$ [deg]\")\n", + "ax.set_ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", + "ax.set_yscale(\"log\")\n", + "ax.legend()\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "e95379dc", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- **The unit contract**: `from_measurement` divides everything dimensionful\n", + " (data, statistical error, absolute offset error) by `obs.norm` and passes the\n", + " fractional normalization error through untouched. `obs.norm` is retained, so\n", + " you can always convert back.\n", + "- **Systematics are opt-in**: they ride along as metadata and become covariance\n", + " terms only via `obs.systematic_terms(support)` passed to\n", + " `Constraint(extra_terms=...)` — nothing correlated is hidden in a default.\n", + "- **The guardrail**: a dataset contributing zero variance fails at construction\n", + " with a message naming the subentry, not with an opaque `LinAlgError` mid-chain.\n", + "- To adapt to production: replace the `SimpleNamespace` with an\n", + " `exfor_tools.Distribution` — the fields are the same.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/normalization_inference.ipynb b/examples/normalization_inference.ipynb index 75f20df..ad0cf37 100644 --- a/examples/normalization_inference.ipynb +++ b/examples/normalization_inference.ipynb @@ -10,9 +10,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "c549ae62-7f81-4a8e-a54e-a7331a298c90", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:06.821557Z", + "iopub.status.busy": "2026-08-11T03:07:06.821382Z", + "iopub.status.idle": "2026-08-11T03:07:07.527172Z", + "shell.execute_reply": "2026-08-11T03:07:07.526332Z" + } + }, "outputs": [], "source": [ "import corner" @@ -20,9 +27,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "a55118c3-ccbf-45bf-81a9-bdf6e9daf46c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:07.528701Z", + "iopub.status.busy": "2026-08-11T03:07:07.528499Z", + "iopub.status.idle": "2026-08-11T03:07:07.958886Z", + "shell.execute_reply": "2026-08-11T03:07:07.958243Z" + } + }, "outputs": [], "source": [ "import numpy as np\n", @@ -32,15 +46,22 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "22715d9f-6d09-4444-b9a5-243a1274c05c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:07.960611Z", + "iopub.status.busy": "2026-08-11T03:07:07.960418Z", + "iopub.status.idle": "2026-08-11T03:07:09.174374Z", + "shell.execute_reply": "2026-08-11T03:07:09.173736Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Using database version X4-2025-12-31 located in: /mnt/home/beyerkyl/x4db/unpack_exfor-2025/X4-2025-12-31\n" + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" ] } ], @@ -50,9 +71,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "id": "1f8e822c-4807-452b-b4b9-a6e25af16006", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.175847Z", + "iopub.status.busy": "2026-08-11T03:07:09.175620Z", + "iopub.status.idle": "2026-08-11T03:07:09.178149Z", + "shell.execute_reply": "2026-08-11T03:07:09.177591Z" + } + }, "outputs": [], "source": [ "rng = np.random.default_rng(42)" @@ -60,9 +88,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "id": "31abc19d-08d7-49c4-98f8-0c58d235fcd8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.179441Z", + "iopub.status.busy": "2026-08-11T03:07:09.179298Z", + "iopub.status.idle": "2026-08-11T03:07:09.181657Z", + "shell.execute_reply": "2026-08-11T03:07:09.180998Z" + } + }, "outputs": [], "source": [ "poly4 = rxmc.physical_model.Polynomial(4)" @@ -70,9 +105,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "id": "715c0ed6-62e7-41da-b5c0-4d0e12c0d414", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.182953Z", + "iopub.status.busy": "2026-08-11T03:07:09.182815Z", + "iopub.status.idle": "2026-08-11T03:07:09.185509Z", + "shell.execute_reply": "2026-08-11T03:07:09.184903Z" + } + }, "outputs": [], "source": [ "true_params = [1, 0.5, -0.1, -0.4, 0.1]" @@ -80,9 +122,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "id": "67038d92-ffcb-491c-8d62-eb9a4843e62d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.186991Z", + "iopub.status.busy": "2026-08-11T03:07:09.186844Z", + "iopub.status.idle": "2026-08-11T03:07:09.190165Z", + "shell.execute_reply": "2026-08-11T03:07:09.189599Z" + } + }, "outputs": [], "source": [ "settings = [\n", @@ -115,9 +164,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "abf487e6-041c-457c-9216-5a15e3c08f6c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.191643Z", + "iopub.status.busy": "2026-08-11T03:07:09.191485Z", + "iopub.status.idle": "2026-08-11T03:07:09.195421Z", + "shell.execute_reply": "2026-08-11T03:07:09.194734Z" + } + }, "outputs": [], "source": [ "def generate_observations(settings, true_model, rng, true_params, scale_err=True):\n", @@ -128,7 +184,6 @@ " x=rng.random(setting[\"N\"]) * (x1 - x0) + x0,\n", " y=np.zeros(setting[\"N\"]),\n", " y_stat_err=np.ones(setting[\"N\"]) * setting[\"noise\"],\n", - " y_sys_err_normalization=setting[\"systematic_err\"],\n", " )\n", " renormalization = rng.normal(1, setting[\"systematic_err\"])\n", " y_true = true_model(synthetic_obs, *true_params)\n", @@ -138,6 +193,7 @@ " synthetic_obs.y = rng.normal(y_true * renormalization, setting[\"noise\"])\n", "\n", " synthetic_obs.renormalization = renormalization\n", + " synthetic_obs.sys_norm_err = setting[\"systematic_err\"]\n", "\n", " obs.append(synthetic_obs)\n", " return obs" @@ -145,9 +201,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "b1fa98b8-d52d-44f1-849b-ad89b318c37b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.196840Z", + "iopub.status.busy": "2026-08-11T03:07:09.196635Z", + "iopub.status.idle": "2026-08-11T03:07:09.199797Z", + "shell.execute_reply": "2026-08-11T03:07:09.199178Z" + } + }, "outputs": [], "source": [ "observations = generate_observations(settings, poly4, rng, true_params, scale_err=False)" @@ -155,16 +218,23 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "30849732-090e-4c2d-be1e-f212fb83845e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.201576Z", + "iopub.status.busy": "2026-08-11T03:07:09.201373Z", + "iopub.status.idle": "2026-08-11T03:07:09.204499Z", + "shell.execute_reply": "2026-08-11T03:07:09.203733Z" + } + }, "outputs": [], "source": [ "observations_unreported_sys_err = [\n", " rxmc.observation.Observation(\n", " x=obs.x,\n", " y=obs.y,\n", - " y_stat_err=np.sqrt(np.diag(obs.statistical_covariance)),\n", + " y_stat_err=obs.y_stat_err,\n", " )\n", " for obs in observations\n", "]" @@ -172,9 +242,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "b56c8f2a-f6e3-46a9-bd46-6799a7edf0d6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.206187Z", + "iopub.status.busy": "2026-08-11T03:07:09.205934Z", + "iopub.status.idle": "2026-08-11T03:07:09.209932Z", + "shell.execute_reply": "2026-08-11T03:07:09.208921Z" + } + }, "outputs": [], "source": [ "N_fine = 100\n", @@ -187,23 +264,30 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "d7349134-bbd3-4fef-b7d0-99d501afad7d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.211828Z", + "iopub.status.busy": "2026-08-11T03:07:09.211561Z", + "iopub.status.idle": "2026-08-11T03:07:09.472241Z", + "shell.execute_reply": "2026-08-11T03:07:09.471426Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 14, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -218,7 +302,7 @@ " plt.errorbar(\n", " synthetic_observation.x,\n", " synthetic_observation.y,\n", - " np.sqrt(np.diag(synthetic_observation.statistical_covariance)),\n", + " synthetic_observation.y_stat_err,\n", " linestyle=\"none\",\n", " marker=\".\",\n", " label=f\"renormalization = {synthetic_observation.renormalization:1.3f}\",\n", @@ -230,9 +314,16 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "65d77c5b-4498-4eb7-9e10-23ae52198504", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.473577Z", + "iopub.status.busy": "2026-08-11T03:07:09.473406Z", + "iopub.status.idle": "2026-08-11T03:07:09.476110Z", + "shell.execute_reply": "2026-08-11T03:07:09.475205Z" + } + }, "outputs": [], "source": [ "correct_model = poly4" @@ -240,48 +331,70 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "ed7e3fce-125d-49a9-8742-718e06d3d764", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.477481Z", + "iopub.status.busy": "2026-08-11T03:07:09.477328Z", + "iopub.status.idle": "2026-08-11T03:07:09.483737Z", + "shell.execute_reply": "2026-08-11T03:07:09.482771Z" + } + }, "outputs": [], "source": [ + "# block supports come from the library helper\n", + "_block_supports = rxmc.covariance.stacked_supports\n", + "\n", + "\n", "evidence_models = {}\n", + "\n", + "# Unknown per-dataset normalization: a latent scale rho_i for each dataset, routed\n", + "# to it by identity and sampled as ordinary *model* parameters. This is the v2\n", + "# form of the old per-dataset UnknownNormalizationModel -- rho moves onto the\n", + "# PhysicalModel (rxmc.physical_model.PerObservationScaledModel) and is sampled in\n", + "# the model block (jointly with the physics) rather than as a per-constraint\n", + "# covariance nuisance. All constraints share the one model instance, so they\n", + "# still share a single model-parameter vector.\n", + "norm_model = rxmc.physical_model.PerObservationScaledModel(correct_model, observations)\n", "evidence_models[\"unknown_norm\"] = rxmc.evidence.Evidence(\n", - " parametric_constraints=[\n", - " rxmc.constraint.Constraint(\n", - " [obs],\n", - " correct_model,\n", - " rxmc.likelihood_model.UnknownNormalizationModel(),\n", - " )\n", - " for obs in observations\n", - " ]\n", + " [rxmc.constraint.Constraint([obs], norm_model) for obs in observations]\n", ")\n", "\n", + "# reported systematic errors folded in as fixed per-dataset normalization modes\n", "evidence_models[\"marginalized_sys_err\"] = rxmc.evidence.Evidence(\n", " [\n", " rxmc.constraint.Constraint(\n", " observations,\n", " correct_model,\n", - " rxmc.likelihood_model.LikelihoodModel(),\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(sup, magnitude=o.sys_norm_err)\n", + " for o, sup in zip(observations, _block_supports(observations))\n", + " ],\n", " )\n", " ]\n", ")\n", + "\n", + "# systematic errors omitted entirely (statistical only)\n", "evidence_models[\"unreported_sys_err\"] = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " observations_unreported_sys_err,\n", - " correct_model,\n", - " rxmc.likelihood_model.LikelihoodModel(),\n", - " )\n", - " ]\n", + " [rxmc.constraint.Constraint(observations_unreported_sys_err, correct_model)]\n", ")\n", "\n", + "# omitted systematics absorbed by a single unknown (averaging) model-error term\n", + "gamma = rxmc.params.Parameter(\n", + " \"log fractional err\", float, latex_name=r\"\\gamma\", unit=\"dimensionless\"\n", + ")\n", + "_N_unreported = sum(o.n_data_pts for o in observations_unreported_sys_err)\n", "evidence_models[\"unreported_sys_err_with_unknown_model_err\"] = rxmc.evidence.Evidence(\n", - " parametric_constraints=[\n", + " [\n", " rxmc.constraint.Constraint(\n", " observations_unreported_sys_err,\n", " correct_model,\n", - " rxmc.likelihood_model.UnknownModelError(),\n", + " extra_terms=[\n", + " rxmc.covariance.model_error_term(\n", + " np.arange(_N_unreported), gamma, averaging=True\n", + " )\n", + " ],\n", " )\n", " ]\n", ")" @@ -289,9 +402,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "1cf0e309-c459-4c42-90aa-7cec410bc017", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.485199Z", + "iopub.status.busy": "2026-08-11T03:07:09.485039Z", + "iopub.status.idle": "2026-08-11T03:07:09.488431Z", + "shell.execute_reply": "2026-08-11T03:07:09.487748Z" + } + }, "outputs": [ { "data": { @@ -299,7 +419,7 @@ "dict_keys(['unknown_norm', 'marginalized_sys_err', 'unreported_sys_err', 'unreported_sys_err_with_unknown_model_err'])" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -310,16 +430,23 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "94719fd0-383c-4a7d-aec5-f904bec9a357", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.489984Z", + "iopub.status.busy": "2026-08-11T03:07:09.489815Z", + "iopub.status.idle": "2026-08-11T03:07:09.493318Z", + "shell.execute_reply": "2026-08-11T03:07:09.492611Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "hyperparameters for each model:\n", - "unknown_norm: ['log normalization', 'log normalization', 'log normalization', 'log normalization']\n", + "unknown_norm: []\n", "marginalized_sys_err: []\n", "unreported_sys_err: []\n", "unreported_sys_err_with_unknown_model_err: ['log fractional err']\n" @@ -332,7 +459,7 @@ "for key, evidence_model in evidence_models.items():\n", " hyperparams[key] = []\n", " for constraint in evidence_model.parametric_constraints:\n", - " for p in constraint.likelihood.params:\n", + " for p in constraint.params:\n", " hyperparams[key].append(p)\n", " print(f\"{key}: {[p.name for p in hyperparams[key]]}\")" ] @@ -348,9 +475,16 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "id": "5ccbf1c3-e622-4476-9216-6bbe692570bf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.494912Z", + "iopub.status.busy": "2026-08-11T03:07:09.494703Z", + "iopub.status.idle": "2026-08-11T03:07:09.498523Z", + "shell.execute_reply": "2026-08-11T03:07:09.497852Z" + } + }, "outputs": [], "source": [ "cov = np.diag(np.ones(len(correct_model.params)))\n", @@ -360,9 +494,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "id": "e75ea172-6a1b-4411-a4e4-b38311461ce2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.500201Z", + "iopub.status.busy": "2026-08-11T03:07:09.499992Z", + "iopub.status.idle": "2026-08-11T03:07:09.504289Z", + "shell.execute_reply": "2026-08-11T03:07:09.503599Z" + } + }, "outputs": [], "source": [ "unknown_log_norm_priors = [\n", @@ -375,9 +516,16 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "id": "6c8372b5-8418-4142-9284-642561a76405", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.505849Z", + "iopub.status.busy": "2026-08-11T03:07:09.505662Z", + "iopub.status.idle": "2026-08-11T03:07:09.509179Z", + "shell.execute_reply": "2026-08-11T03:07:09.508156Z" + } + }, "outputs": [], "source": [ "unknown_model_err_prior = stats.multivariate_normal(mean=[np.log(0.1)], cov=[[0.01]])" @@ -393,9 +541,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 20, "id": "0d765083-b158-4170-beac-430689778a0a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.511081Z", + "iopub.status.busy": "2026-08-11T03:07:09.510871Z", + "iopub.status.idle": "2026-08-11T03:07:09.513731Z", + "shell.execute_reply": "2026-08-11T03:07:09.512908Z" + } + }, "outputs": [], "source": [ "walkers = {}" @@ -403,36 +558,54 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 21, "id": "8986c8a1-c24a-4693-a94c-fda660e36d95", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.515337Z", + "iopub.status.busy": "2026-08-11T03:07:09.515114Z", + "iopub.status.idle": "2026-08-11T03:07:09.520762Z", + "shell.execute_reply": "2026-08-11T03:07:09.519950Z" + } + }, "outputs": [], "source": [ + "# combined prior over [physics params, per-dataset log_rho] (block-diagonal):\n", + "# the per-dataset scales are now model parameters, so they are sampled in the\n", + "# model block -- this walker has no separate likelihood samplers.\n", + "n_physics = len(correct_model.params)\n", + "rho_prior_vars = np.array(\n", + " [np.log(1 + setting[\"systematic_err\"] ** 2) for setting in settings]\n", + ")\n", + "norm_prior_mean = np.concatenate([model_prior.mean, np.zeros(len(observations))])\n", + "norm_prior_cov = np.zeros((n_physics + len(observations),) * 2)\n", + "norm_prior_cov[:n_physics, :n_physics] = model_prior.cov\n", + "norm_prior_cov[n_physics:, n_physics:] = np.diag(rho_prior_vars)\n", + "norm_model_prior = stats.multivariate_normal(mean=norm_prior_mean, cov=norm_prior_cov)\n", + "\n", "walkers[\"unknown_norm\"] = rxmc.walker.Walker(\n", " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " correct_model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov,\n", + " norm_model.params,\n", + " starting_location=norm_model_prior.mean,\n", + " prior=norm_model_prior,\n", + " initial_proposal_cov=norm_model_prior.cov,\n", " ),\n", " evidence=evidence_models[\"unknown_norm\"],\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=[p],\n", - " starting_location=np.array([0.0]),\n", - " prior=prior,\n", - " initial_proposal_cov=[[prior.cov]],\n", - " )\n", - " for p, prior in zip(hyperparams[\"unknown_norm\"], unknown_log_norm_priors)\n", - " ],\n", ")" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 22, "id": "a55021b0-5fbf-4c62-a6e1-4754bccf4236", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.522378Z", + "iopub.status.busy": "2026-08-11T03:07:09.522190Z", + "iopub.status.idle": "2026-08-11T03:07:09.526059Z", + "shell.execute_reply": "2026-08-11T03:07:09.525352Z" + } + }, "outputs": [], "source": [ "walkers[\"unreported_sys_err_with_unknown_model_err\"] = rxmc.walker.Walker(\n", @@ -456,9 +629,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 23, "id": "c9b000c6-4219-4e7f-9c47-abe793d631ff", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.527512Z", + "iopub.status.busy": "2026-08-11T03:07:09.527343Z", + "iopub.status.idle": "2026-08-11T03:07:09.530468Z", + "shell.execute_reply": "2026-08-11T03:07:09.529824Z" + } + }, "outputs": [], "source": [ "walkers[\"marginalized_sys_err\"] = rxmc.walker.Walker(\n", @@ -474,9 +654,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 24, "id": "53080b07-1708-48e3-ace7-89e34a9a5494", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.531884Z", + "iopub.status.busy": "2026-08-11T03:07:09.531684Z", + "iopub.status.idle": "2026-08-11T03:07:09.534956Z", + "shell.execute_reply": "2026-08-11T03:07:09.534233Z" + } + }, "outputs": [], "source": [ "walkers[\"unreported_sys_err\"] = rxmc.walker.Walker(\n", @@ -492,138 +679,471 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 25, "id": "5edcfc20-5f56-4851-ac52-4883236950a8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:07:09.536899Z", + "iopub.status.busy": "2026-08-11T03:07:09.536665Z", + "iopub.status.idle": "2026-08-11T03:08:43.365354Z", + "shell.execute_reply": "2026-08-11T03:08:43.364712Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", - "Running unknown_norm\n", - "Burn-in batch 1/4 completed, 2000 steps.\n", - "Burn-in batch 2/4 completed, 2000 steps.\n", - "Burn-in batch 3/4 completed, 2000 steps.\n", - "Burn-in batch 4/4 completed, 2000 steps.\n", - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.449, 0.435, 0.452, 0.455]\n", - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.322\n", - " Likelihood parameter acceptance fractions: [0.443, 0.4335, 0.449, 0.4255]\n", - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.289\n", - " Likelihood parameter acceptance fractions: [0.4415, 0.425, 0.4535, 0.4425]\n", - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.276\n", - " Likelihood parameter acceptance fractions: [0.4595, 0.45, 0.4375, 0.451]\n", - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.298\n", - " Likelihood parameter acceptance fractions: [0.45, 0.453, 0.4525, 0.442]\n", - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.324\n", - " Likelihood parameter acceptance fractions: [0.4385, 0.4445, 0.4165, 0.4395]\n", - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.4675, 0.437, 0.445, 0.442]\n", - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.321\n", - " Likelihood parameter acceptance fractions: [0.431, 0.4055, 0.4555, 0.474]\n", - "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.284\n", - " Likelihood parameter acceptance fractions: [0.4395, 0.4685, 0.4455, 0.4145]\n", - "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.4525, 0.441, 0.4225, 0.462]\n", - "\n", - "Running unreported_sys_err_with_unknown_model_err\n", - "Burn-in batch 1/4 completed, 2000 steps.\n", - "Burn-in batch 2/4 completed, 2000 steps.\n", - "Burn-in batch 3/4 completed, 2000 steps.\n", - "Burn-in batch 4/4 completed, 2000 steps.\n", + "Running unknown_norm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 3/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.285\n", - " Likelihood parameter acceptance fractions: [0.4255]\n", + " Model parameter acceptance fraction: 0.247\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.327\n", - " Likelihood parameter acceptance fractions: [0.4595]\n", + " Model parameter acceptance fraction: 0.306\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.276\n", - " Likelihood parameter acceptance fractions: [0.4475]\n", + " Model parameter acceptance fraction: 0.266\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.279\n", - " Likelihood parameter acceptance fractions: [0.464]\n", + " Model parameter acceptance fraction: 0.277\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.293\n", - " Likelihood parameter acceptance fractions: [0.4575]\n", + " Model parameter acceptance fraction: 0.294\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.295\n", - " Likelihood parameter acceptance fractions: [0.453]\n", + " Model parameter acceptance fraction: 0.286\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.287\n", - " Likelihood parameter acceptance fractions: [0.4415]\n", + " Model parameter acceptance fraction: 0.276\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.304\n", - " Likelihood parameter acceptance fractions: [0.429]\n", + " Model parameter acceptance fraction: 0.248\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.314\n", - " Likelihood parameter acceptance fractions: [0.432]\n", + " Model parameter acceptance fraction: 0.292\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.309\n", - " Likelihood parameter acceptance fractions: [0.4585]\n", + " Model parameter acceptance fraction: 0.288\n", "\n", - "Running marginalized_sys_err\n", - "Burn-in batch 1/4 completed, 2000 steps.\n", - "Burn-in batch 2/4 completed, 2000 steps.\n", - "Burn-in batch 3/4 completed, 2000 steps.\n", - "Burn-in batch 4/4 completed, 2000 steps.\n", - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.292\n", - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.319\n", - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.306\n", - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.319\n", - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.277\n", - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.287\n", - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.299\n", + "Running unreported_sys_err_with_unknown_model_err\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 3/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.283\n", + " Likelihood parameter acceptance fractions: [0.423]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 2/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.281\n", + " Likelihood parameter acceptance fractions: [0.451]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 3/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.291\n", + " Likelihood parameter acceptance fractions: [0.4215]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 4/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.302\n", + " Likelihood parameter acceptance fractions: [0.455]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 5/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.311\n", + " Likelihood parameter acceptance fractions: [0.436]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 6/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.290\n", + " Likelihood parameter acceptance fractions: [0.4425]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 7/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.278\n", + " Likelihood parameter acceptance fractions: [0.4445]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 8/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.267\n", + " Likelihood parameter acceptance fractions: [0.474]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.300\n", + " Model parameter acceptance fraction: 0.305\n", + " Likelihood parameter acceptance fractions: [0.4405]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n", + " Model parameter acceptance fraction: 0.292\n", + " Likelihood parameter acceptance fractions: [0.4275]\n", "\n", - "Running unreported_sys_err\n", - "Burn-in batch 1/4 completed, 2000 steps.\n", - "Burn-in batch 2/4 completed, 2000 steps.\n", - "Burn-in batch 3/4 completed, 2000 steps.\n", - "Burn-in batch 4/4 completed, 2000 steps.\n", + "Running marginalized_sys_err\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 3/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.275\n", + " Model parameter acceptance fraction: 0.294\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.288\n", + " Model parameter acceptance fraction: 0.288\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.299\n", + " Model parameter acceptance fraction: 0.288\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.286\n", + " Model parameter acceptance fraction: 0.264\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 5/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.290\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 6/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.311\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 7/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.287\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 8/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.292\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 9/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.310\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 10/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.301\n", + "\n", + "Running unreported_sys_err\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 3/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/4 completed, 2000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.301\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 2/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.284\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 3/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.289\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 4/10 completed, 2000 steps. \n", + " Model parameter acceptance fraction: 0.295\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.294\n", + " Model parameter acceptance fraction: 0.282\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.331\n", + " Model parameter acceptance fraction: 0.296\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.286\n", + " Model parameter acceptance fraction: 0.310\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.296\n", + " Model parameter acceptance fraction: 0.315\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.289\n", + " Model parameter acceptance fraction: 0.290\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.293\n" + " Model parameter acceptance fraction: 0.291\n" ] } ], @@ -635,9 +1155,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 26, "id": "6ebeb608-b331-4114-827a-31b74773ae0e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:43.367063Z", + "iopub.status.busy": "2026-08-11T03:08:43.366905Z", + "iopub.status.idle": "2026-08-11T03:08:43.370243Z", + "shell.execute_reply": "2026-08-11T03:08:43.369708Z" + } + }, "outputs": [ { "data": { @@ -648,7 +1175,7 @@ " 'unreported_sys_err': 'tab:green'}" ] }, - "execution_count": 28, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -662,13 +1189,20 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 27, "id": "c37c4279-fe7f-4e7a-b261-b368abcc34ae", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:43.371935Z", + "iopub.status.busy": "2026-08-11T03:08:43.371791Z", + "iopub.status.idle": "2026-08-11T03:08:44.883123Z", + "shell.execute_reply": "2026-08-11T03:08:44.882505Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -701,9 +1235,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 28, "id": "a9dd5361-1428-4b53-a50f-a8d2cc71917f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:44.886306Z", + "iopub.status.busy": "2026-08-11T03:08:44.886135Z", + "iopub.status.idle": "2026-08-11T03:08:44.892077Z", + "shell.execute_reply": "2026-08-11T03:08:44.891619Z" + } + }, "outputs": [ { "data": { @@ -711,7 +1252,7 @@ "(20000, 5)" ] }, - "execution_count": 30, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -723,17 +1264,25 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 29, "id": "f716e401-7712-49f0-9771-5e90cb016cb4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:44.894051Z", + "iopub.status.busy": "2026-08-11T03:08:44.893889Z", + "iopub.status.idle": "2026-08-11T03:08:44.902271Z", + "shell.execute_reply": "2026-08-11T03:08:44.901462Z" + } + }, "outputs": [], "source": [ "domain = np.zeros((len(walkers), correct_model.n_params, 2))\n", "for i, (key, walker) in enumerate(walkers.items()):\n", + " chain = walker.model_sampler.chain[:, : correct_model.n_params]\n", " domain[i, ...] = np.array(\n", " [\n", - " np.min(walker.model_sampler.chain, axis=0),\n", - " np.max(walker.model_sampler.chain, axis=0),\n", + " np.min(chain, axis=0),\n", + " np.max(chain, axis=0),\n", " ]\n", " ).T\n", "domain = np.array([np.min(domain[:, :, 0], axis=0), np.max(domain[..., 1], axis=0)])" @@ -741,9 +1290,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 30, "id": "a45db89b-5c4d-43ea-893a-336a88d5432a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:44.904009Z", + "iopub.status.busy": "2026-08-11T03:08:44.903854Z", + "iopub.status.idle": "2026-08-11T03:08:44.906797Z", + "shell.execute_reply": "2026-08-11T03:08:44.906226Z" + } + }, "outputs": [ { "data": { @@ -751,7 +1307,7 @@ "(2, 5)" ] }, - "execution_count": 32, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -762,23 +1318,30 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 31, "id": "2986eac1-ea7a-4f66-926e-8e6cd1121548", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:44.908463Z", + "iopub.status.busy": "2026-08-11T03:08:44.908324Z", + "iopub.status.idle": "2026-08-11T03:08:46.895046Z", + "shell.execute_reply": "2026-08-11T03:08:46.894436Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 33, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -791,7 +1354,7 @@ "fig = plt.figure()\n", "for key, walker in walkers.items():\n", " corner.corner(\n", - " walker.model_sampler.chain,\n", + " walker.model_sampler.chain[:, : correct_model.n_params],\n", " fig=fig,\n", " color=colors[key],\n", " range=domain.T,\n", @@ -831,9 +1394,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 32, "id": "9a63cc20-d38d-4e1b-893d-831306dbb73a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.898047Z", + "iopub.status.busy": "2026-08-11T03:08:46.897873Z", + "iopub.status.idle": "2026-08-11T03:08:46.902313Z", + "shell.execute_reply": "2026-08-11T03:08:46.901650Z" + } + }, "outputs": [ { "data": { @@ -841,72 +1411,90 @@ "(20000, 4)" ] }, - "execution_count": 34, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "norm_chain = np.array(\n", - " [sampler.chain for sampler in walkers[\"unknown_norm\"].likelihood_samplers]\n", - ")[:, :, 0]\n", - "norm_chain = np.exp(norm_chain.T)\n", + "# per-dataset rho posteriors live in the model-block chain, after the physics\n", + "n_physics = len(correct_model.params)\n", + "norm_chain = np.exp(walkers[\"unknown_norm\"].model_sampler.chain[:, n_physics:])\n", "norm_chain.shape" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 33, "id": "00efd03d-7fdf-4f99-bc68-413a75ce2b72", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.904501Z", + "iopub.status.busy": "2026-08-11T03:08:46.904332Z", + "iopub.status.idle": "2026-08-11T03:08:46.907957Z", + "shell.execute_reply": "2026-08-11T03:08:46.907231Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "(20000, 4)" + "(20000,)" ] }, - "execution_count": 35, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "norm_log_posterior_vals = np.array(\n", - " [sampler.logp_chain for sampler in walkers[\"unknown_norm\"].likelihood_samplers]\n", - ").T\n", + "norm_log_posterior_vals = walkers[\"unknown_norm\"].model_sampler.logp_chain\n", "norm_log_posterior_vals.shape" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 34, "id": "328e1d8e-d6b0-4429-a852-394eb3613895", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.910019Z", + "iopub.status.busy": "2026-08-11T03:08:46.909844Z", + "iopub.status.idle": "2026-08-11T03:08:46.913968Z", + "shell.execute_reply": "2026-08-11T03:08:46.913283Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "array([1.02222029, 0.5391869 , 1.26555557, 1.03850914])" + "array([1.0519558 , 0.53718276, 1.2928494 , 1.00432021])" ] }, - "execution_count": 36, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "map_idxs = np.argmax(norm_log_posterior_vals, axis=0)\n", + "map_idx = np.argmax(walkers[\"unknown_norm\"].model_sampler.logp_chain)\n", "N_data_sets = len(settings)\n", - "maps = norm_chain[map_idxs, np.arange(N_data_sets)]\n", + "maps = norm_chain[map_idx, :]\n", "maps" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 35, "id": "868b71f7-0de1-43b9-a593-295f7ff36099", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.915908Z", + "iopub.status.busy": "2026-08-11T03:08:46.915735Z", + "iopub.status.idle": "2026-08-11T03:08:46.919544Z", + "shell.execute_reply": "2026-08-11T03:08:46.918903Z" + } + }, "outputs": [ { "data": { @@ -914,7 +1502,7 @@ "array([1.06789136, 0.53671203, 1.3071512 , 1.05429387])" ] }, - "execution_count": 37, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -925,17 +1513,24 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 36, "id": "7f72afa9-bf06-4e3b-83d2-8344ae36fc06", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.921824Z", + "iopub.status.busy": "2026-08-11T03:08:46.921656Z", + "iopub.status.idle": "2026-08-11T03:08:46.925448Z", + "shell.execute_reply": "2026-08-11T03:08:46.924832Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "array([1.04122028, 0.52298738, 1.27509224, 1.00875858])" + "array([1.04462468, 0.5287628 , 1.28785673, 0.99731649])" ] }, - "execution_count": 38, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -946,13 +1541,20 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 37, "id": "b7acf84b-e98c-4743-9e62-2c3eb16bf677", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:46.927658Z", + "iopub.status.busy": "2026-08-11T03:08:46.927485Z", + "iopub.status.idle": "2026-08-11T03:08:47.583693Z", + "shell.execute_reply": "2026-08-11T03:08:47.582931Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -975,9 +1577,16 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 38, "id": "9861dc77-5683-47b3-84d6-22409195355b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:47.586579Z", + "iopub.status.busy": "2026-08-11T03:08:47.586404Z", + "iopub.status.idle": "2026-08-11T03:08:47.907564Z", + "shell.execute_reply": "2026-08-11T03:08:47.906802Z" + } + }, "outputs": [ { "data": { @@ -985,13 +1594,13 @@ "Text(0.5, 1.0, 'Renormalizing experimental data sets based on MAP of $p(\\\\rho)$')" ] }, - "execution_count": 40, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1007,7 +1616,7 @@ " plt.errorbar(\n", " synthetic_observation.x,\n", " synthetic_observation.y / rho_hat,\n", - " np.sqrt(np.diag(synthetic_observation.statistical_covariance)),\n", + " synthetic_observation.y_stat_err,\n", " linestyle=\"none\",\n", " marker=\".\",\n", " label=r\"$\\rho_{\\text{truth}}$ = \"\n", @@ -1031,9 +1640,16 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 39, "id": "e1708552-11c0-436f-bbc3-58d778e99774", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:47.909398Z", + "iopub.status.busy": "2026-08-11T03:08:47.909244Z", + "iopub.status.idle": "2026-08-11T03:08:47.912488Z", + "shell.execute_reply": "2026-08-11T03:08:47.911972Z" + } + }, "outputs": [ { "data": { @@ -1041,7 +1657,7 @@ "(20000, 5)" ] }, - "execution_count": 41, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1052,9 +1668,16 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 40, "id": "17ae70aa-589c-42ac-b132-f918a3160ce4", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:47.914250Z", + "iopub.status.busy": "2026-08-11T03:08:47.914039Z", + "iopub.status.idle": "2026-08-11T03:08:47.917123Z", + "shell.execute_reply": "2026-08-11T03:08:47.916447Z" + } + }, "outputs": [], "source": [ "def predictive_post(chain, model, obs, n_samples, intervals):\n", @@ -1066,23 +1689,30 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 41, "id": "9c48e1df-130d-445e-8be3-6c35e33642e6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:47.918696Z", + "iopub.status.busy": "2026-08-11T03:08:47.918538Z", + "iopub.status.idle": "2026-08-11T03:08:48.194795Z", + "shell.execute_reply": "2026-08-11T03:08:48.194067Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 43, + "execution_count": 41, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1099,7 +1729,7 @@ " plt.errorbar(\n", " synthetic_observation.x,\n", " synthetic_observation.y,\n", - " np.sqrt(np.diag(synthetic_observation.statistical_covariance)),\n", + " synthetic_observation.y_stat_err,\n", " linestyle=\"none\",\n", " marker=\".\",\n", " alpha=0.4,\n", @@ -1110,7 +1740,7 @@ "alphas = [0.1, 0.25, 0.25, 0.25]\n", "for i, (key, walker) in enumerate(walkers.items()):\n", " intervals = predictive_post(\n", - " walker.model_sampler.chain,\n", + " walker.model_sampler.chain[:, : correct_model.n_params],\n", " correct_model,\n", " truth,\n", " 1000,\n", @@ -1131,6 +1761,411 @@ "plt.ylim([0, 2])\n", "fig.legend(loc=\"upper left\", framealpha=1)" ] + }, + { + "cell_type": "markdown", + "id": "gal00", + "metadata": {}, + "source": [ + "# Covariance-structure gallery\n", + "\n", + "The sections above inferred unknown **normalisations** — a single rank-one\n", + "systematic per dataset. But a `Constraint`'s covariance is assembled from\n", + "arbitrary `Term`s, so the *same* machinery expresses far richer uncertainty\n", + "structure. This gallery surveys four cases the covariance API handles, each just a\n", + "different `Term` (or `support`) on the stacked residual:\n", + "\n", + "1. a **systematic correlated across $x$** (smoothly, not a flat normalisation);\n", + "2. **correlated statistical errors** — and why ignoring them is overconfident;\n", + "3. **unknown / misreported magnitudes** (the free-$\\gamma$ model error above);\n", + "4. a systematic **shared across datasets** (cross-block coupling).\n", + "\n", + "A small helper normalises a covariance to a correlation matrix for plotting." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "gal01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:48.196610Z", + "iopub.status.busy": "2026-08-11T03:08:48.196446Z", + "iopub.status.idle": "2026-08-11T03:08:48.297327Z", + "shell.execute_reply": "2026-08-11T03:08:48.296552Z" + } + }, + "outputs": [], + "source": [ + "from sklearn.gaussian_process.kernels import RBF, ConstantKernel\n", + "\n", + "\n", + "def correlation(Sigma):\n", + " d = np.sqrt(np.diag(Sigma))\n", + " return Sigma / np.outer(d, d)" + ] + }, + { + "cell_type": "markdown", + "id": "gal02", + "metadata": {}, + "source": [ + "## 1. A systematic correlated across $x$\n", + "\n", + "A flat `normalization_term` is a *rank-one* mode: every point is **100 %**\n", + "correlated (correlation matrix all ones off-diagonal). A systematic that varies\n", + "smoothly with $x$ — e.g. an energy-dependent efficiency — instead has correlation\n", + "that **decays** with separation. That is a `KernelTerm` (a GP prior on the\n", + "systematic). Same API, richer structure." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "gal03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:48.299491Z", + "iopub.status.busy": "2026-08-11T03:08:48.299204Z", + "iopub.status.idle": "2026-08-11T03:08:48.645254Z", + "shell.execute_reply": "2026-08-11T03:08:48.644419Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "o0 = observations[0]\n", + "(sup0,) = rxmc.covariance.stacked_supports([o0])\n", + "xspan = o0.x.max() - o0.x.min()\n", + "\n", + "# (a) flat normalization: rank-one, uniform correlation\n", + "c_flat = rxmc.constraint.Constraint(\n", + " [o0],\n", + " correct_model,\n", + " extra_terms=[rxmc.covariance.normalization_term(sup0, magnitude=0.05)],\n", + ")\n", + "# (b) smooth correlated systematic: a GP (KernelTerm) over x\n", + "sys_kernel = ConstantKernel(0.05**2) * RBF(length_scale=xspan / 4)\n", + "c_smooth = rxmc.constraint.Constraint(\n", + " [o0],\n", + " correct_model,\n", + " extra_terms=[rxmc.covariance.discrepancy_term(sup0, sys_kernel)],\n", + ")\n", + "\n", + "S_flat = c_flat.covariance_matrix(true_params)\n", + "S_smooth = c_smooth.covariance_matrix(true_params, tuple(sys_kernel.theta))\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(9, 4))\n", + "for a, S, t in [\n", + " (ax[0], S_flat, \"flat normalization (rank-one)\"),\n", + " (ax[1], S_smooth, \"smooth systematic (KernelTerm)\"),\n", + "]:\n", + " im = a.imshow(correlation(S), vmin=-1, vmax=1, cmap=\"RdBu_r\")\n", + " a.set_title(t)\n", + " fig.colorbar(im, ax=a, fraction=0.046)\n", + "fig.suptitle(\"correlation of one dataset under two systematic structures\");" + ] + }, + { + "cell_type": "markdown", + "id": "gal04", + "metadata": {}, + "source": [ + "## 2. Correlated statistical errors\n", + "\n", + "Statistical errors are usually taken as independent (a diagonal covariance). When\n", + "they are **not** — shared backgrounds, unfolding, detector resolution — ignoring\n", + "the correlation makes the posterior **overconfident**. We draw line data with\n", + "exponentially-correlated noise and fit it two ways: a naive diagonal, and the\n", + "correct correlated covariance supplied as a `DenseTerm`." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "gal05", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:48.647141Z", + "iopub.status.busy": "2026-08-11T03:08:48.646980Z", + "iopub.status.idle": "2026-08-11T03:08:54.150726Z", + "shell.execute_reply": "2026-08-11T03:08:54.150004Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "naive diagonal a0 = 1.101 ± 0.062 a1 = 0.758 ± 0.027\n", + "correlated a0 = 1.048 ± 0.129 a1 = 0.779 ± 0.048\n" + ] + } + ], + "source": [ + "line = rxmc.physical_model.Polynomial(1) # a0 + a1 x\n", + "a_true = [1.0, 0.8]\n", + "xs = np.linspace(0.0, 4.0, 20)\n", + "ell, sig = 1.2, 0.15\n", + "R = np.exp(-np.abs(xs[:, None] - xs[None, :]) / ell) # exponential correlation\n", + "C = sig**2 * R\n", + "y_corr = line(rxmc.observation.Observation(x=xs, y=np.zeros_like(xs)), *a_true)\n", + "y_corr = y_corr + rng.multivariate_normal(np.zeros(xs.size), C)\n", + "obs_corr = rxmc.observation.Observation(x=xs, y=y_corr)\n", + "sup = np.arange(obs_corr.n_data_pts)\n", + "\n", + "c_naive = rxmc.constraint.Constraint(\n", + " [obs_corr],\n", + " line,\n", + " extra_terms=[rxmc.covariance.DenseTerm(sup, sig**2 * np.ones(xs.size))],\n", + ")\n", + "c_correlated = rxmc.constraint.Constraint(\n", + " [obs_corr],\n", + " line,\n", + " extra_terms=[rxmc.covariance.DenseTerm(sup, C)],\n", + ")\n", + "\n", + "\n", + "def fit_line(constraint, seed=7):\n", + " evidence = rxmc.evidence.Evidence([constraint])\n", + " prior = stats.multivariate_normal(mean=a_true, cov=np.diag([0.5, 0.5]) ** 2)\n", + " sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=line.params,\n", + " starting_location=prior.mean,\n", + " prior=prior,\n", + " initial_proposal_cov=prior.cov / 100,\n", + " )\n", + " walker = rxmc.walker.Walker(sampler, evidence, rng=np.random.default_rng(seed))\n", + " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", + " return walker.model_sampler.chain\n", + "\n", + "\n", + "chain_naive = fit_line(c_naive)\n", + "chain_correlated = fit_line(c_correlated)\n", + "for name, ch in [(\"naive diagonal\", chain_naive), (\"correlated\", chain_correlated)]:\n", + " print(\n", + " f\"{name:14s} a0 = {ch[:,0].mean():.3f} ± {ch[:,0].std():.3f} \"\n", + " f\"a1 = {ch[:,1].mean():.3f} ± {ch[:,1].std():.3f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "gal06", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:54.152422Z", + "iopub.status.busy": "2026-08-11T03:08:54.152265Z", + "iopub.status.idle": "2026-08-11T03:08:54.370278Z", + "shell.execute_reply": "2026-08-11T03:08:54.369516Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " chain_naive, labels=[\"a0\", \"a1\"], color=\"tab:red\", truths=a_true, truth_color=\"k\"\n", + ")\n", + "corner.corner(chain_correlated, fig=fig, color=\"tab:blue\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"naive diagonal (overconfident)\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"correlated DenseTerm\")\n", + "fig.legend(loc=\"upper right\");" + ] + }, + { + "cell_type": "markdown", + "id": "gal07", + "metadata": {}, + "source": [ + "The naive-diagonal posterior is visibly **tighter** than the correct one:\n", + "treating correlated noise as independent over-counts the information. The\n", + "`DenseTerm` with the true correlation restores honest uncertainty." + ] + }, + { + "cell_type": "markdown", + "id": "gal08", + "metadata": {}, + "source": [ + "## 3. Unknown / misreported magnitudes\n", + "\n", + "When the *size* of an uncertainty is itself unknown, it becomes a sampled\n", + "`Parameter`. The `unreported_sys_err_with_unknown_model_err` scenario above does\n", + "exactly this with a free $\\gamma$ (`model_error_term`, a diagonal inflation). Here\n", + "we just visualise how the covariance diagonal grows as $\\gamma$ increases —\n", + "inference slides along this family to whatever the data support." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "gal09", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:54.372438Z", + "iopub.status.busy": "2026-08-11T03:08:54.372273Z", + "iopub.status.idle": "2026-08-11T03:08:54.586555Z", + "shell.execute_reply": "2026-08-11T03:08:54.585914Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "<>:12: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:12: SyntaxWarning: invalid escape sequence '\\g'\n", + "<>:17: SyntaxWarning: invalid escape sequence '\\g'\n", + "/tmp/ipykernel_402344/1563835932.py:12: SyntaxWarning: invalid escape sequence '\\g'\n", + " plt.plot(o.x, np.sqrt(np.diag(S)), marker=\".\", label=f\"$\\gamma$ = {g:.2f}\")\n", + "/tmp/ipykernel_402344/1563835932.py:17: SyntaxWarning: invalid escape sequence '\\g'\n", + " plt.title(\"unknown model error inflates the diagonal by a sampled $\\gamma$\");\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "o = observations[0]\n", + "(sup,) = rxmc.covariance.stacked_supports([o])\n", + "gamma = rxmc.params.Parameter(\"log gamma\", float)\n", + "c_me = rxmc.constraint.Constraint(\n", + " [o],\n", + " correct_model,\n", + " extra_terms=[rxmc.covariance.model_error_term(sup, gamma, averaging=True)],\n", + ")\n", + "plt.figure(figsize=(7, 4))\n", + "for g in [0.02, 0.05, 0.10]:\n", + " S = c_me.covariance_matrix(true_params, (np.log(g),))\n", + " plt.plot(o.x, np.sqrt(np.diag(S)), marker=\".\", label=f\"$\\gamma$ = {g:.2f}\")\n", + "plt.plot(o.x, o.y_stat_err, \"k:\", label=\"reported stat. err\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"total std. dev.\")\n", + "plt.legend()\n", + "plt.title(\"unknown model error inflates the diagonal by a sampled $\\gamma$\");" + ] + }, + { + "cell_type": "markdown", + "id": "gal10", + "metadata": {}, + "source": [ + "## 4. A systematic shared across datasets\n", + "\n", + "If two datasets share a systematic (a common calibration), the coupling is a\n", + "single `Term` whose `support` spans **both** blocks — off-diagonal correlation\n", + "between datasets. Treating them independently throws that coupling away. (The\n", + "dedicated `correlated_observations.ipynb` notebook explores the inference\n", + "consequences; here we just show the structure.)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "gal11", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:54.588808Z", + "iopub.status.busy": "2026-08-11T03:08:54.588638Z", + "iopub.status.idle": "2026-08-11T03:08:54.933783Z", + "shell.execute_reply": "2026-08-11T03:08:54.933233Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pair = observations[:2]\n", + "supports = _block_supports(pair)\n", + "full = np.concatenate(supports)\n", + "\n", + "c_shared = rxmc.constraint.Constraint(\n", + " pair,\n", + " correct_model,\n", + " extra_terms=[rxmc.covariance.normalization_term(full, magnitude=0.06)],\n", + ")\n", + "c_separate = rxmc.constraint.Constraint(\n", + " pair,\n", + " correct_model,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(s, magnitude=0.06) for s in supports\n", + " ],\n", + ")\n", + "n1 = pair[0].n_data_pts\n", + "fig, ax = plt.subplots(1, 2, figsize=(9, 4))\n", + "for a, c, t in [\n", + " (ax[0], c_shared, \"shared across datasets (case A)\"),\n", + " (ax[1], c_separate, \"independent per dataset\"),\n", + "]:\n", + " im = a.imshow(\n", + " correlation(c.covariance_matrix(true_params)), vmin=-1, vmax=1, cmap=\"RdBu_r\"\n", + " )\n", + " a.axhline(n1 - 0.5, color=\"k\", lw=0.6)\n", + " a.axvline(n1 - 0.5, color=\"k\", lw=0.6)\n", + " a.set_title(t)\n", + " fig.colorbar(im, ax=a, fraction=0.046)\n", + "fig.suptitle(\"a shared systematic couples the two datasets' blocks\");" + ] + }, + { + "cell_type": "markdown", + "id": "gal12", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "Every case above is the *same* `Constraint` machinery with a different `Term`:\n", + "\n", + "| case | `Term` | structure |\n", + "|------|--------|-----------|\n", + "| flat normalisation | `normalization_term` | rank-one, uniform |\n", + "| correlated-across-$x$ systematic | `KernelTerm` (`discrepancy_term`) | smooth/banded |\n", + "| correlated statistical errors | `DenseTerm` | arbitrary off-diagonal |\n", + "| unknown magnitude | `model_error_term` (free $\\gamma$) | sampled diagonal |\n", + "| shared across datasets | cross-block `normalization_term` | off-diagonal blocks |\n", + "\n", + "Declaring the uncertainty *is* the modelling choice — the inference machinery is\n", + "unchanged." + ] } ], "metadata": { @@ -1149,7 +2184,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/examples/overconfidence.ipynb b/examples/overconfidence.ipynb index 11f8740..e9bc6de 100644 --- a/examples/overconfidence.ipynb +++ b/examples/overconfidence.ipynb @@ -12,7 +12,14 @@ "cell_type": "code", "execution_count": 1, "id": "7bb6c48f-b3e8-424e-962a-747343e60742", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:29.033340Z", + "iopub.status.busy": "2026-08-11T03:10:29.033193Z", + "iopub.status.idle": "2026-08-11T03:10:29.036142Z", + "shell.execute_reply": "2026-08-11T03:10:29.035405Z" + } + }, "outputs": [], "source": [ "from collections import OrderedDict" @@ -22,7 +29,14 @@ "cell_type": "code", "execution_count": 2, "id": "b11241d5-93d5-4e8f-8ca6-380154ca9a19", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:29.037856Z", + "iopub.status.busy": "2026-08-11T03:10:29.037707Z", + "iopub.status.idle": "2026-08-11T03:10:29.696403Z", + "shell.execute_reply": "2026-08-11T03:10:29.695590Z" + } + }, "outputs": [], "source": [ "import corner" @@ -32,7 +46,14 @@ "cell_type": "code", "execution_count": 3, "id": "c549ae62-7f81-4a8e-a54e-a7331a298c90", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:29.697955Z", + "iopub.status.busy": "2026-08-11T03:10:29.697725Z", + "iopub.status.idle": "2026-08-11T03:10:29.700409Z", + "shell.execute_reply": "2026-08-11T03:10:29.699835Z" + } + }, "outputs": [], "source": [ "import numpy as np" @@ -42,7 +63,14 @@ "cell_type": "code", "execution_count": 4, "id": "a55118c3-ccbf-45bf-81a9-bdf6e9daf46c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:29.701673Z", + "iopub.status.busy": "2026-08-11T03:10:29.701542Z", + "iopub.status.idle": "2026-08-11T03:10:30.169160Z", + "shell.execute_reply": "2026-08-11T03:10:30.168460Z" + } + }, "outputs": [], "source": [ "from matplotlib import pyplot as plt\n", @@ -54,13 +82,20 @@ "cell_type": "code", "execution_count": 5, "id": "22715d9f-6d09-4444-b9a5-243a1274c05c", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:30.170611Z", + "iopub.status.busy": "2026-08-11T03:10:30.170462Z", + "iopub.status.idle": "2026-08-11T03:10:31.456765Z", + "shell.execute_reply": "2026-08-11T03:10:31.455781Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Using database version X4-2025-12-31 located in: /mnt/home/beyerkyl/x4db/unpack_exfor-2025/X4-2025-12-31\n" + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" ] } ], @@ -72,7 +107,14 @@ "cell_type": "code", "execution_count": 6, "id": "abee925c-9d84-443e-9e6c-ca3dd5a29afe", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.458299Z", + "iopub.status.busy": "2026-08-11T03:10:31.458063Z", + "iopub.status.idle": "2026-08-11T03:10:31.460632Z", + "shell.execute_reply": "2026-08-11T03:10:31.459993Z" + } + }, "outputs": [], "source": [ "true_params = OrderedDict(\n", @@ -87,7 +129,14 @@ "cell_type": "code", "execution_count": 7, "id": "1f8e822c-4807-452b-b4b9-a6e25af16006", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.462100Z", + "iopub.status.busy": "2026-08-11T03:10:31.461938Z", + "iopub.status.idle": "2026-08-11T03:10:31.465013Z", + "shell.execute_reply": "2026-08-11T03:10:31.464140Z" + } + }, "outputs": [], "source": [ "rng = np.random.default_rng(42)" @@ -97,7 +146,14 @@ "cell_type": "code", "execution_count": 8, "id": "6c697651-05eb-4082-962e-144f86fd7dbf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.466337Z", + "iopub.status.busy": "2026-08-11T03:10:31.466177Z", + "iopub.status.idle": "2026-08-11T03:10:31.469348Z", + "shell.execute_reply": "2026-08-11T03:10:31.468687Z" + } + }, "outputs": [], "source": [ "noise = 0.05\n", @@ -115,7 +171,14 @@ "cell_type": "code", "execution_count": 9, "id": "31abc19d-08d7-49c4-98f8-0c58d235fcd8", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.470724Z", + "iopub.status.busy": "2026-08-11T03:10:31.470580Z", + "iopub.status.idle": "2026-08-11T03:10:31.473989Z", + "shell.execute_reply": "2026-08-11T03:10:31.473286Z" + } + }, "outputs": [], "source": [ "class LinearModel(rxmc.physical_model.PhysicalModel):\n", @@ -139,7 +202,14 @@ "cell_type": "code", "execution_count": 10, "id": "5ee482a3-6a9d-4fd2-bcb1-6fbf4d400502", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.475264Z", + "iopub.status.busy": "2026-08-11T03:10:31.475120Z", + "iopub.status.idle": "2026-08-11T03:10:31.477479Z", + "shell.execute_reply": "2026-08-11T03:10:31.476846Z" + } + }, "outputs": [], "source": [ "prior_mean = OrderedDict(\n", @@ -160,7 +230,14 @@ "cell_type": "code", "execution_count": 11, "id": "591b9219-baf9-4a06-80bb-89b8a76b4248", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.478771Z", + "iopub.status.busy": "2026-08-11T03:10:31.478651Z", + "iopub.status.idle": "2026-08-11T03:10:31.483966Z", + "shell.execute_reply": "2026-08-11T03:10:31.483336Z" + } + }, "outputs": [ { "data": { @@ -184,7 +261,14 @@ "cell_type": "code", "execution_count": 12, "id": "66395e1c-6724-4dbf-89e2-b83b94f8ba89", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.485277Z", + "iopub.status.busy": "2026-08-11T03:10:31.485124Z", + "iopub.status.idle": "2026-08-11T03:10:31.487577Z", + "shell.execute_reply": "2026-08-11T03:10:31.486860Z" + } + }, "outputs": [], "source": [ "my_model = LinearModel()" @@ -194,7 +278,14 @@ "cell_type": "code", "execution_count": 13, "id": "22e4b752-4be1-457e-b934-8316031e2cfc", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.488915Z", + "iopub.status.busy": "2026-08-11T03:10:31.488798Z", + "iopub.status.idle": "2026-08-11T03:10:31.491463Z", + "shell.execute_reply": "2026-08-11T03:10:31.490701Z" + } + }, "outputs": [], "source": [ "observation = rxmc.observation.Observation(\n", @@ -208,12 +299,19 @@ "cell_type": "code", "execution_count": 14, "id": "0fc8e25a-7544-4b80-ad8b-4b48447dc998", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.492723Z", + "iopub.status.busy": "2026-08-11T03:10:31.492604Z", + "iopub.status.idle": "2026-08-11T03:10:31.633177Z", + "shell.execute_reply": "2026-08-11T03:10:31.632503Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 14, @@ -222,7 +320,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -248,17 +346,31 @@ "cell_type": "code", "execution_count": 15, "id": "54636463-a169-43d1-9498-dece057a7550", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.634679Z", + "iopub.status.busy": "2026-08-11T03:10:31.634544Z", + "iopub.status.idle": "2026-08-11T03:10:31.637091Z", + "shell.execute_reply": "2026-08-11T03:10:31.636348Z" + } + }, "outputs": [], "source": [ - "likelihood = rxmc.likelihood_model.LikelihoodModel()" + "likelihood = rxmc.likelihood_model.GaussianLikelihood()" ] }, { "cell_type": "code", "execution_count": 16, "id": "2348c4ad-f2ce-4b38-abc3-2048aa2ed11a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.638424Z", + "iopub.status.busy": "2026-08-11T03:10:31.638294Z", + "iopub.status.idle": "2026-08-11T03:10:31.647486Z", + "shell.execute_reply": "2026-08-11T03:10:31.646900Z" + } + }, "outputs": [], "source": [ "evidence = rxmc.evidence.Evidence(\n", @@ -276,7 +388,14 @@ "cell_type": "code", "execution_count": 17, "id": "ed7e3fce-125d-49a9-8742-718e06d3d764", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.648771Z", + "iopub.status.busy": "2026-08-11T03:10:31.648639Z", + "iopub.status.idle": "2026-08-11T03:10:31.651407Z", + "shell.execute_reply": "2026-08-11T03:10:31.650875Z" + } + }, "outputs": [], "source": [ "evidence_scaled = rxmc.evidence.Evidence(\n", @@ -291,11 +410,80 @@ ")" ] }, + { + "cell_type": "markdown", + "id": "687d0733", + "metadata": {}, + "source": [ + "## The same tempering as a config-level knob\n", + "\n", + "`Evidence(weights=...)` tempers the likelihood **per constraint**;\n", + "`CalibrationConfig(likelihood_scaling=...)` tempers the **whole** likelihood.\n", + "For a single constraint they are two spellings of the same thing — and both\n", + "propagate consistently into the Gibbs conditionals\n", + "(`CalibrationConfig.conditional_posterior` applies\n", + "`likelihood_scaling * weight` to the marginal likelihood, with the prior\n", + "untouched), so the tempered joint is what every sampling block targets.\n" + ] + }, { "cell_type": "code", "execution_count": 18, + "id": "c4713daf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.652760Z", + "iopub.status.busy": "2026-08-11T03:10:31.652627Z", + "iopub.status.idle": "2026-08-11T03:10:31.656788Z", + "shell.execute_reply": "2026-08-11T03:10:31.656280Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "likelihood_scaling = 2/N : 0.173502\n", + "Evidence weights = [2/N] : 0.173502\n" + ] + } + ], + "source": [ + "model_config = rxmc.config.ParameterConfig(\n", + " params=my_model.params,\n", + " prior=prior_distribution,\n", + " initial_proposal_distribution=prior_distribution,\n", + ")\n", + "\n", + "config_scaling = rxmc.config.CalibrationConfig(\n", + " evidence=rxmc.evidence.Evidence(\n", + " [rxmc.constraint.Constraint([observation], my_model, likelihood)]\n", + " ),\n", + " model_config=model_config,\n", + " likelihood_scaling=2 / N,\n", + ")\n", + "config_weights = rxmc.config.CalibrationConfig(\n", + " evidence=evidence_scaled,\n", + " model_config=model_config,\n", + ")\n", + "\n", + "x_test = np.array([2.0, 4.0])\n", + "print(f\"likelihood_scaling = 2/N : {config_scaling.log_likelihood(x_test):.6f}\")\n", + "print(f\"Evidence weights = [2/N] : {config_weights.log_likelihood(x_test):.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "id": "7739ec4d-bded-476c-8a7f-bb8feac5ff3f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.658182Z", + "iopub.status.busy": "2026-08-11T03:10:31.658046Z", + "iopub.status.idle": "2026-08-11T03:10:31.660370Z", + "shell.execute_reply": "2026-08-11T03:10:31.659836Z" + } + }, "outputs": [], "source": [ "def proposal_distribution(x, rng):\n", @@ -306,9 +494,16 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "79791e26-f2d9-42da-b896-51c326a09540", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.661680Z", + "iopub.status.busy": "2026-08-11T03:10:31.661546Z", + "iopub.status.idle": "2026-08-11T03:10:31.663993Z", + "shell.execute_reply": "2026-08-11T03:10:31.663525Z" + } + }, "outputs": [], "source": [ "walker_scaled = rxmc.walker.Walker(\n", @@ -324,9 +519,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "id": "38e27c49-fbb4-473f-9b1c-68ca55ecb076", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.665565Z", + "iopub.status.busy": "2026-08-11T03:10:31.665432Z", + "iopub.status.idle": "2026-08-11T03:10:31.667902Z", + "shell.execute_reply": "2026-08-11T03:10:31.667392Z" + } + }, "outputs": [], "source": [ "walker = rxmc.walker.Walker(\n", @@ -342,58 +544,191 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "id": "214aaf01-78ec-4c0b-a74e-a67d59b0e4a0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:31.669280Z", + "iopub.status.busy": "2026-08-11T03:10:31.669138Z", + "iopub.status.idle": "2026-08-11T03:10:35.105323Z", + "shell.execute_reply": "2026-08-11T03:10:35.104725Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/2 completed, 500 steps.\n", - "Burn-in batch 2/2 completed, 500 steps.\n", + "Burn-in batch 1/2 completed, 500 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/2 completed, 500 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.390\n", + " Model parameter acceptance fraction: 0.390\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 2/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.364\n", + " Model parameter acceptance fraction: 0.364\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.336\n", + " Model parameter acceptance fraction: 0.336\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.360\n", + " Model parameter acceptance fraction: 0.360\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 5/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.394\n", + " Model parameter acceptance fraction: 0.394\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.386\n", + " Model parameter acceptance fraction: 0.386\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.390\n", + " Model parameter acceptance fraction: 0.390\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 8/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.358\n", + " Model parameter acceptance fraction: 0.358\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.342\n", + " Model parameter acceptance fraction: 0.342\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.384\n", + " Model parameter acceptance fraction: 0.384\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 11/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.338\n", + " Model parameter acceptance fraction: 0.338\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 12/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.370\n", + " Model parameter acceptance fraction: 0.370\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 13/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.368\n", + " Model parameter acceptance fraction: 0.368\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 14/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.352\n", + " Model parameter acceptance fraction: 0.352\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 15/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.362\n", + " Model parameter acceptance fraction: 0.362\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 16/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.300\n", + " Model parameter acceptance fraction: 0.300\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 17/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.396\n", + " Model parameter acceptance fraction: 0.396\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 18/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.342\n", + " Model parameter acceptance fraction: 0.342\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 19/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.340\n", + " Model parameter acceptance fraction: 0.340\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 20/20 completed, 500 steps. \n", " Model parameter acceptance fraction: 0.366\n", - "CPU times: user 37.6 s, sys: 2.6 s, total: 40.2 s\n", - "Wall time: 12.5 s\n" + "CPU times: user 3.66 s, sys: 5.09 ms, total: 3.66 s\n", + "Wall time: 3.43 s\n" ] } ], @@ -404,58 +739,191 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "id": "eeee43dd-2c5d-43df-9ed2-7610abe4899f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:35.106658Z", + "iopub.status.busy": "2026-08-11T03:10:35.106520Z", + "iopub.status.idle": "2026-08-11T03:10:38.552877Z", + "shell.execute_reply": "2026-08-11T03:10:38.552229Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/2 completed, 500 steps.\n", - "Burn-in batch 2/2 completed, 500 steps.\n", + "Burn-in batch 1/2 completed, 500 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/2 completed, 500 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.328\n", + " Model parameter acceptance fraction: 0.382\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 2/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.312\n", + " Model parameter acceptance fraction: 0.400\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.332\n", + " Model parameter acceptance fraction: 0.394\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.394\n", + " Model parameter acceptance fraction: 0.352\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 5/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.376\n", + " Model parameter acceptance fraction: 0.358\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.444\n", + " Model parameter acceptance fraction: 0.362\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.378\n", + " Model parameter acceptance fraction: 0.350\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 8/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.362\n", + " Model parameter acceptance fraction: 0.364\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.326\n", + " Model parameter acceptance fraction: 0.340\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.380\n", + " Model parameter acceptance fraction: 0.352\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 11/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.376\n", + " Model parameter acceptance fraction: 0.376\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 12/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.326\n", + " Model parameter acceptance fraction: 0.320\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 13/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.406\n", + " Model parameter acceptance fraction: 0.344\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 14/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.378\n", + " Model parameter acceptance fraction: 0.398\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 15/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.318\n", + " Model parameter acceptance fraction: 0.298\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 16/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.386\n", + " Model parameter acceptance fraction: 0.306\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 17/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.332\n", + " Model parameter acceptance fraction: 0.384\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 18/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.310\n", + " Model parameter acceptance fraction: 0.340\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 19/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.400\n", + " Model parameter acceptance fraction: 0.378\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 20/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.382\n", - "CPU times: user 34.8 s, sys: 2.35 s, total: 37.2 s\n", - "Wall time: 12.4 s\n" + " Model parameter acceptance fraction: 0.372\n", + "CPU times: user 3.44 s, sys: 13.1 ms, total: 3.45 s\n", + "Wall time: 3.44 s\n" ] } ], @@ -466,13 +934,20 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "id": "5a1c1318-3a89-49fb-bfe9-815bd2689807", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:38.554263Z", + "iopub.status.busy": "2026-08-11T03:10:38.554119Z", + "iopub.status.idle": "2026-08-11T03:10:39.693393Z", + "shell.execute_reply": "2026-08-11T03:10:39.692867Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -506,16 +981,21 @@ "plt.plot([], [], color=\"tab:green\", label=\"posterior, $k/N$ scaling\")\n", "fig.text(0.6, 0.75, \"$y=mx+b$\", fontsize=20)\n", "fig.legend(loc=\"upper right\")\n", - "plt.tight_layout()\n", - "# plt.savefig(\"corner_oc.pdf\")\n", - "plt.savefig(\"corner_oc_badprior.pdf\")" + "plt.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "id": "2a678f70-58e3-4c4f-a290-7125f334b823", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.694861Z", + "iopub.status.busy": "2026-08-11T03:10:39.694706Z", + "iopub.status.idle": "2026-08-11T03:10:39.698023Z", + "shell.execute_reply": "2026-08-11T03:10:39.697468Z" + } + }, "outputs": [], "source": [ "def predictive_posterior(\n", @@ -541,9 +1021,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "id": "c80f57d4-3ca9-46ba-8e4f-afe91f169274", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.699471Z", + "iopub.status.busy": "2026-08-11T03:10:39.699335Z", + "iopub.status.idle": "2026-08-11T03:10:39.702290Z", + "shell.execute_reply": "2026-08-11T03:10:39.701847Z" + } + }, "outputs": [ { "data": { @@ -551,7 +1038,7 @@ "array([10, 20, 30, 40, 50, 60, 70, 80, 90])" ] }, - "execution_count": 25, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -564,9 +1051,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 27, "id": "a239e4c5-a93e-4cbf-a7a9-95fe571c82de", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.703609Z", + "iopub.status.busy": "2026-08-11T03:10:39.703490Z", + "iopub.status.idle": "2026-08-11T03:10:39.706322Z", + "shell.execute_reply": "2026-08-11T03:10:39.705900Z" + } + }, "outputs": [ { "data": { @@ -575,7 +1069,7 @@ " 75., 80., 85., 90., 95.])" ] }, - "execution_count": 26, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -587,9 +1081,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 28, "id": "5fafba0a-fc4a-4a49-86cf-1ec706eff1ae", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.707604Z", + "iopub.status.busy": "2026-08-11T03:10:39.707486Z", + "iopub.status.idle": "2026-08-11T03:10:39.709889Z", + "shell.execute_reply": "2026-08-11T03:10:39.709286Z" + } + }, "outputs": [], "source": [ "lower_bounds = np.flip(pb[: inner_pctls.shape[0]])\n", @@ -598,9 +1099,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "id": "b3b2f360-6926-4a3a-ab12-b54150b4392f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.711108Z", + "iopub.status.busy": "2026-08-11T03:10:39.710993Z", + "iopub.status.idle": "2026-08-11T03:10:39.713326Z", + "shell.execute_reply": "2026-08-11T03:10:39.712884Z" + } + }, "outputs": [ { "name": "stdout", @@ -625,9 +1133,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "id": "707ad8cb-8b56-4a88-a90f-64efc51cc4de", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:39.714736Z", + "iopub.status.busy": "2026-08-11T03:10:39.714618Z", + "iopub.status.idle": "2026-08-11T03:10:40.022224Z", + "shell.execute_reply": "2026-08-11T03:10:40.021499Z" + } + }, "outputs": [], "source": [ "pctls_scaled = predictive_posterior(\n", @@ -644,9 +1159,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 31, "id": "ae2f5205-f199-4168-a91a-367d4e3eb91b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.023673Z", + "iopub.status.busy": "2026-08-11T03:10:40.023539Z", + "iopub.status.idle": "2026-08-11T03:10:40.328092Z", + "shell.execute_reply": "2026-08-11T03:10:40.327564Z" + } + }, "outputs": [], "source": [ "pctls = predictive_posterior(\n", @@ -663,9 +1185,16 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 32, "id": "37f7ea46-cddf-4a4d-ad5c-a561ed6792d6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.329758Z", + "iopub.status.busy": "2026-08-11T03:10:40.329622Z", + "iopub.status.idle": "2026-08-11T03:10:40.616031Z", + "shell.execute_reply": "2026-08-11T03:10:40.615425Z" + } + }, "outputs": [], "source": [ "pctls_unbroadened = predictive_posterior(\n", @@ -682,9 +1211,16 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 33, "id": "75a16414-2acf-4fa1-8c9c-e17e39524709", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.617569Z", + "iopub.status.busy": "2026-08-11T03:10:40.617435Z", + "iopub.status.idle": "2026-08-11T03:10:40.619973Z", + "shell.execute_reply": "2026-08-11T03:10:40.619414Z" + } + }, "outputs": [], "source": [ "lower = np.flip(pctls[: inner_pctls.shape[0], :], axis=0)\n", @@ -693,9 +1229,16 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 34, "id": "72e89091-7a24-4454-becb-f8b71b057e5b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.621138Z", + "iopub.status.busy": "2026-08-11T03:10:40.621021Z", + "iopub.status.idle": "2026-08-11T03:10:40.623206Z", + "shell.execute_reply": "2026-08-11T03:10:40.622725Z" + } + }, "outputs": [], "source": [ "lower_l = np.flip(pctls_unbroadened[: inner_pctls.shape[0], :], axis=0)\n", @@ -704,9 +1247,16 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 35, "id": "910d78cf-18ce-4b51-82d1-9b44d9728f74", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.624449Z", + "iopub.status.busy": "2026-08-11T03:10:40.624336Z", + "iopub.status.idle": "2026-08-11T03:10:40.626802Z", + "shell.execute_reply": "2026-08-11T03:10:40.626149Z" + } + }, "outputs": [], "source": [ "lower_s = np.flip(pctls_scaled[: inner_pctls.shape[0], :], axis=0)\n", @@ -715,13 +1265,20 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 36, "id": "1b2a4f2a-d4fc-4db8-9b71-46be0b828e06", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.628270Z", + "iopub.status.busy": "2026-08-11T03:10:40.628119Z", + "iopub.status.idle": "2026-08-11T03:10:40.794660Z", + "shell.execute_reply": "2026-08-11T03:10:40.793817Z" + } + }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQeYY3W5/7+npSczmUwv25eF3aUJiIDSi6IUAbkWRFQUO2IBQe9fuXrlgqCA14YoqCjIBQQUpPfe2/Yyuzu9ZdLrKf/n/WVO9iSTZJLZWXZ29vfZJ89O+inJOd+85fsKhmEY4HA4HA6Hw+Hs9oi7egE4HA6Hw+FwODMDF3YcDofD4XA4cwQu7DgcDofD4XDmCFzYcTgcDofD4cwRuLDjcDgcDofDmSNwYcfhcDgcDoczR+DCjsPhcDgcDmeOwIUdh8PhcDgczhxBxh6Gruvo7++H1+uFIAi7enE4HA6Hw+FwKkKzJKLRKNrb2yGKlWNye5ywI1HX1dW1qxeDw+FwOBwOpyZ6enrQ2dlZ8TF7nLCjSJ25cXw+365eHA6Hw+FwOJyKRCIRFpQyNUwl9jhhZ6ZfSdRxYcfhcDgcDmd3oZoSMt48weFwOBwOhzNH4MKOw+FwOBwOZ47AhR2Hw+FwOBzOHGGPq7GrFk3TkM1md/VicDi7HJvNNmV7PYfD4XBmB1zYlfCKGRwcRCgU2jV7hMOZZZCoW7hwIRN4HA6Hw5ndcGFXhCnqmpub4XK5uIkxZ4/GNPQeGBjAvHnz+PeBw+FwZjlc2BWlX01RFwgEdt1e4XBmEU1NTUzcqaoKRVF29eJwOBwOpwK8cMaCWVNHkToOh5PDTMHSDx8Oh8PhzG64sCsBnyHL4fDvA4fD4eyOcGHH4XA4HA6HM0fgwo7D4XA4HA5njsCFHWeXcfTRR+Ob3/zmu/Z+3/72t3HKKadgLm23d3sbcjgcDmd2w7tiqySlppDV3z3DYkVU4JAdmE2QiDjggANw7bXXzsjr3XXXXe9ql+Ubb7yBww8/vOJjzjvvPLS2tuJ//ud/cOSRR+Lpp5/G3/72N3ziE5/IP+bXv/41fvSjH2F4eBi7mnd7G3I4HA5ndsOFXZWi7qHuh5DUkjVvYB06oukoNEODz+aDLFa3yemxx8w7ZtaJu5kgk8mwTsuGhoYZeZ1qefPNN/HVr361omfbfffdh3vvvZcZVZMQbGtrw5133lkg7F577TW85z3vwWxgR7chh8PhcOYWPBVbBRSpI1Fnl+3w2X1VX9yKG6FUCDE1hmZXMxqcDVU9j94nkonUHCGkiNrXvvY1dqmvr2defD/4wQ+YSCHS6TS+8Y1vMJ8+h8OB97///Xj55ZcLXuOOO+7AvvvuC6fTyZ5//PHHIx6Ps0jWk08+ieuuu451DdNly5Yt7LWvuuoqLFq0iD1n//33Z69Rarm+9a1vobGxESeccELJNOJUy1fudaqhp6cHY2NjLOJIkF8hpWUpgkfmu8Szzz7Lpiwceuih2LBhA6LRKNt+//73v5FIJPKv9eqrr+Kggw4q+17ltqEpHq+88kosWbIEdrudmf7+93//d/65DzzwAFtvc/995CMfwaZNm8q+V/E2pOu0DS+++GIm+ij6SNFFK7Ren/rUp+B2u5lw/cUvfsFTuhwOhzNH4MKuBuySHU7ZWdXFJtownBhmEbu9/Xsj4AxU/Vx6n+nypz/9CbIs48UXX8T111/PTto33ngju49O9hR9osdQ1InExUknnYRgMMjuJ4FDkanPfe5zWLNmDZ544gmcccYZTLyRoDvssMPwhS98gT2OLl1dXUz43HTTTfjNb36DVatW4aKLLsI555zDRGCp5SLx9Lvf/a7ksk+1fNW+Tiko+lZXV8dGY7399ts45JBDmKihdaT/CYrUkdgjcUfijcTl+eefD5/Px8SdKT5pPctF7CptQ+LSSy9lwu4///M/sXr1apbmbWlpyT+fBCAJVxK0jz76KFuWj370o0wQVgttIxJt9Bkg0f1f//VfePjhh/P30+vT9qP1pdsp3Uzbm8PhcOYi8Xg8H5Awf2TPZXgqdieg6Rq2RrayKN9C30K4lNoNj1VdndZ7k9giMUcf4GXLljERQ9c/+clPMvF1880340Mf+hB77O9//3t2Yv/DH/6A7373u0yU0HQBEiLz589nj6HIkwmlPcm8maJABH1Bfv7zn+Oxxx5joo+gyN0zzzzDRNdRRx2Vfy6JNBIZ5aDXmmr5qnmdSsKOoom33norS8dSDd0FF1xQ8BgSOldffTX7m4TOfvvtx9aZhBVF4c4880y89dZbzMi6XMSu0jakSBkJ5P/93//FZz7zGXbb4sWLWYTOhN7DCq07RTBJBK5cubKqdaXl/uEPf8j+Xrp0KXs/EokU4aRlIOFHgvK4445jjyFh3t7eXvW25HA4HM7shUfsZqGoS2QTLBU7Hd73vvcVGCyT4KK04saNG5kgOeKII/L3UdH9e9/7XhZZIkj40MmehMjHPvYxJqzGx8fLvheJjVQqxQSDx+PJX/785z9PSh8efPDBFZebHj/V8lXzOpWEHYlcSuVSHV2xqKP36O3tZWlTgiJ2ZlSORBo9h6J1dDulOBcsWFDyfSptQ3oPeg1TUJXbDiTCSSBTpJAijMS2bduqXlcSdlYoImk2emzevJltZ9quJhTJpB8BHA6Hw9n94cJuFoq6rdGtkAQJ78ZUDUoRmrdJksQiZJR2XL58OX75y1+yE353d3fJ1zLTgyR6SDiZFxJ8xXV2lBqshJmqrLR81bxOOWi5KBpGQpTq64qhaB0JVKqLI15//fV8VI7q1ihy9+CDD7JI3oEHHlj2fSptQ/O1K0GpYKoFJEFIqVS6mI0i1VLcJUvbz9xXlbYzh8PhcHZ/uLCbZaKuO9INp+SE1+6d1nK88MILk65TOo5SmCROKE1qQpGbV155Bfvss0/+NjrhU9Ts8ssvZ+KGnvOPf/yD3Ud/W+eFknChBgCKJtHrWy+UEq6FapdvOlD6kYTVV77yFWZVQjVwVCdn5Z577sGpp56aj2qR+DMjdlTTR4KL6v+mapyotA1pP5C4o7RoKUjQUVSP6hYpqkfrXSliOh0o9UvC76WXXsrfFolEWFSXw+Fw5grxPayuzgqvsZuFoo46aOPZ6X0QqfuTiuMp1UjRJYoYXXPNNSzS9eUvf5nVqlEqkboxqVaNuj0///nPs+dSdIhEx4knnsjquuj6yMhIXlhR+pFuo25YSrnS63znO99hDRMUEaJaMRIJzz33HLvfrCOrhmqWb7pQtI4iaSREKdpGoo6EGokb6q6lNCU1K9x9993s8STeSIxZa9oo2vfpT3+aLQ81eZSj0jakZoxLLrmEPZ9en8Qf3UfLQ+vo9/tZJ+wNN9zA0qckmL/3ve9hJvF6vWy/mNuZlpHq8ahJg89I5nA4nN0fLuxmmaib75uPjF592q2Yc889F8lkktVQkZj5+te/ji9+8YvsPmoYIAFGAoWiWFSvRulFEhQE1XQ99dRTzICYBBoV/5MoNJsZSMSRKCCBRO9BUbAf//jHTBxcccUVLNJFNh0U6brssstqXvaplq8c1HDx2c9+tmw6kfzr9t57bxZdJKgrlSJjVDv3yCOP4J///CezOKH1IEgQk6izeuRRmpailZQSreRhN9U2pG5YigD+v//3/9Df388E3Je+9CV2H4mr2267jdmV0PtTCpc6mykVPJNQwwu9J1mp0PKS0KQfBCQ8ORwOZ08iHo+zQAQRi8WmXe4zmxCMPay4hk62VCweDofZSc0K1V+RWKGCdetJLpqJ4v7N9zN/OasVCYm6nmgPE3XzvfN3qKaORF2XtwuSKCGtpZFW0zh50cnw2ry7bDLE7gL5tJGtCF2mA6VgKdpYKRI31w9sHR0dTICWio6W+15wOBzO7iDYhoaG8rZSxeJtdxF2lbRLMTxiV+V4L5oEQZ2qJLisEyWIFmcLsyeJpGvrZGXPyUTgkT2sps6afqX3o/flTA1F9chGZLqQqLNOlpjrUN3f2rVrWVSXDhLkc0ecdtppu3rROBwOh7ODcGFXBTTWi8Z77emzYmcrzz///A49f0+M1JFf37p161i6mZpByKSY6g05HA6Hs3vDhV2VkMiif7OZ6aYiOXsW1EBCDSIcDofDmXtwuxMOh8PhcDicOQIXdhwOh8PhcDhzBC7sOBwOh8Ph7BbsycbD1cKFHYfD4XA4HM4cgQs7DofD4XA4nDkCF3YcDofD4XA4cwQu7DgcDofD4XDmCFzYcTgcDofD4cwRuLDj7LL5rjTXlsPhcDgczszBJ09USSqrIaPpeLewSSIcioTZNNXimGOOwfj4OOrr63f49b7zne/g61//+owsG4fD4XA4nBxc2FUp6h5aNYhwqvSsWFUzEE5mIYkC6pwKBAE7TJ1DwYkrWmeVuJsJDMOApmnweDzssiNks1koilJw280338wue8J4tUwmw2a9VrNdOBwOh7NnwFOxVUCROhJ1Dlligqv4EnDb0OZzIJ5WEYyl4bVNfkwtF3ofer9aIoRHH300vva1r7ELRdQCgQB+8IMfMCFlQtG2c889F36/Hy6XCx/60IewYcOG/P1bt27FKaecwu53u91YsWIF7r//fmzZsoVF6wi6j4whzzvvPHadXv+qq67CokWL4HQ6sf/+++OOO+7IvyYJLHr8gw8+iIMPPhh2u50NnC9Oxeq6jv/6r/9CZ2cnewzd98ADD+Tvp2Wg17n99tvZujocDtxyyy2YCVavXo2TTz6ZCc2WlhZ8+tOfxujoaH75STzRMptcc801aGxsxMDAQNXbvhr6+vrwH//xH2wb02ucdtppbL1NaJuffvrpuOKKK9De3o699tprp24XDofD4ex+7HJhRyezc845h53ISGzQCb3SgHJTKBRf1q5du9OX1S6LcNnkkpeAx47lbT4YEDAQScIuS2UfO9WF3mc6/OlPf4Isy3jxxRdx/fXX4xe/+AVuvPHGAmHwyiuv4N5778Xzzz/PhAcJGorwEF/96leRTqfx1FNP4e2338aVV17JxE5XVxfuvPNO9ph169YxQXPdddex6yRgbrrpJvzmN7/BqlWrcNFFF7H9+eSTTxYs28UXX8wEyZo1a7DffvtNWnZ6PRJMV199Nd566y2cdNJJOPXUUwuEJ3HJJZfgG9/4BnsdesyOQuty1FFHsc8dbRsSk0NDQzj77LPZ/SSWvvnNbzKxFw6H8eabb+L73/8+fv/736Otra3qbT8ViUSCiWfa3rT9n3nmGfb3Bz/4QRaZM3n00UfZuj/88MP417/+tdO2C4fD2X3g0xg4syYVSxGkI444gp3Q/v3vf6O5uRmbNm2qqoaLBIbP58tfb2pqwq6GRNniJjc2jcSxeTSGRY0elp59tyABRoKChO6yZcuYOKPrX/jCF5hAIkH37LPP4vDDD2eP/+tf/8qec/fdd+NjH/sYtm3bhjPPPBP77rsvu5+icCYNDQ3sf9pH5v6hg8nPf/5zPPbYYzjssMPyzyFR8rvf/Y4JJhOKxp1wwglll50EHYmTj3/84+w6icrHH38c1157LX71q1/lH0ci64wzzpixbUaC9D3veQ9++tOf5m/74x//yLbL+vXrWVTsJz/5CR555BF88YtfZOKVRN5HP/rRqrd9Ndx2220QRZGJQXoNggQzbWv6MXPiiSey2yiSSo8xU7BmRG+mtwuHw+FMFzo3mKU2sViMHbc4e4iwo5M3nRDpBGayYMGCqp5rFRiziV0p7t73vvflRQFBYouiYFTTRpEciigdeuih+fspSkoihO4jKOLz5S9/GQ899BCOP/54JvJKRdesKcxUKjVJsFGE6cADDyy4jdKw5YhEIujv72ci3wpdpwhZpdchMbp8+fL8dVVVWQTSWr9HEcTf/va3Jd+bosMkIEvV+9GPDBJ2JKIovUnbYv78+Uxs1rLtJWnqOklajo0bN8Lr9RbcTtuXlsOERHepurpK25fD4XA4ew67VNhRBInSRhQtotRdR0cHvvKVr1QV5SDhQCc9OqlTOtCsAZsN7OrIXSnK1XvR7aYgOf/889n+uO+++5i4o9QpiZNy3atUF0fQ42nfWaE6OSvV/GKzCqPiZSv3OlRr9sYbb+Sv33XXXSxtTNFIE2tkt9Q6UF0h/cgoxppqfe6559j/wWCQXWb6Fygtx0EHHVSw3KWi0eXel/8i5nA4HM4uF3abN29mqbBvfetbuOyyy/DSSy+xqBGJAiryLwWdbG+44QZ2EqR6sL/85S847rjjWLrqyCOPnPR4egxdrNGhuSruXnjhhUnXly5dyiJGJIApmkU1YGYqdmxsjKUb99lnn/xzKIL6pS99iV0uvfRSVktGws6MElEEyoRek/YVRc2saddaIeFFAo1SuNZ9SGLqve99b8XnUhRyyZIlBZFcauKw3lYJSsOSEKRIMb1WKShiRrWDtC2oSYE+m1TrRqnTarZ9tcvx97//nS1/JSHK4XA4HM6sbZ6gKIVZ30QRuAsuuIBF60jslYNSh/QYeh6lu37961/jwx/+MKvRKgVFnerq6vIXEi7vFqa4S2V1Ju40vbYuyVrp6elhIpnqD2+99Vb88pe/xIUXXsjuI5FBXZa07UhAUYqTUpQUaaPbzTot6l7t7u7Ga6+9xmrnTNFHKUiKnlHB/sjICKuboLQh+dGR6KHmARJAr7/+OquJo+u18N3vfpdFzUjc0PJ/73vfY5E4c/l3FtQwQhG4T3ziE+yHBf3YoGjl5z73OSZi6UI1dVTj9tnPfpaVDbzzzjssklnttidIJJf7sUJ86lOfYp22tC+oA5f2AUWx6TV6e3trWqd//OMf2HvvvaexNTicuQNvKJj98H00ByN2FH2z1kcRJCTMDsxqofqmchYPdEKlE641YjddcZdWKfWo1vy89joHusfiWDMQxoKAB5ZAT4X3qR0SDslkkkW5KFJEkTYq+DchUUJC4SMf+Qirg6PoGNmZmJ5nJGJI6JCQoKgRdWRSAwBBAvDyyy9ngosEDr0X+cX9+Mc/ZlEmEtAkiqjukUQ3RWBrgSK1tG++/e1vY3h4mH0uKFVPgnRnQpFCaiihxg1KQ1N0l0QsrTtF5Gj9qEHhn//8J3t8a2sra16grlmqLTQtW6ba9tR9S5HNclBHOHXD0nJQE0Q0GmXbnKLRtUbwqHuXBCaHw+Fw9jwEo1azrRnkk5/8JIt0WD3CKPpD6UKzpqkazjrrLBZ1oQjTVJB4oMgdnfyKT5hUs0eRkoULFzI/sGoNiquhVhPjWg2KyZaDREapwn7OzmWub/ty3wsOZzazJ3VmzrZ1rXZ5prPc03ntoaEh5lFa6jmzbdtNR7vMqogdiTiq96JULEVAKBVG9XN0sUbcyOvuz3/+M7tOJ0+qhyLzXIo6UaSOIny1RvlqgcQViaw9eaQYh8PhcDjvJrNBdMVnwTLUyi4VdocccgirByLxRj5nFBEg4Ub1RuVSWCTmqK6LxB4VyZPAo65MMtrdmZDI4kKLw+FwOJzdC83S9EclL1QzXW1j2+7ILk3F7gqmk4rlcPZk+PeCszuyO0Za5sq6zlQqttT903nttra2/AhIgkZX0rQjqmeezjLM9lTsLh8pxuFwOBwOh7OzGLCIOoIyflSbT76ncxEu7DgcDofD4cwpMpYZ28WYiUqy+LKmaecKXNhxOBwOh8OZM1AkjsZBVoLEHblykN3VXIMLOw6Hw+FwOHNG1J111lkYHR2t6vE0p9zaWDEXInhc2HE4HA6Hw9ntIVF24YUXlp2NXgoy3Tchdw2yU9vda++4sONwOBwOh7PbQ8MOemscwVgc2ZsLjRVc2HHedX70ox/lR3FxOBwOh7Mzul+nw1xorNilBsW7FfFRIB15997P7gPcjZgNPPHEEzjmmGMwPj7OZsHuKGQwTbNUORwOh8OZKcivrhpMP7ipGisoAkiDFHY3uLCrVtTd+XkgEcS7hqsBOPMPs0bczQT0ZaFfQGT2aBo+TpdsNgtFUWZs2TgcDoeze/OBD3yAmQ9TOrVcnV1jYyN+/vOf49xzz31XIoC7Ap6KrQaK1JGok+2Ao37nX+h96P1qiBDSIPqvfe1r7EJRtUAggB/84Af5DzdF2+iD7Pf74XK58KEPfQgbNmzIP3/r1q045ZRT2P3krE2j2u6//35s2bKFResIuk8QBJx33nnsOr32VVddhUWLFrHxbvvvvz/uuOOOgkgfPf7BBx/EwQcfDLvdzn4BFadidV1nI+XoC0mPofseeOCB/P20DPQ6t99+O1tPmgpCM4I5HA6HwzGhMWHXXXcd+5vOGaWg+7u6umY0Ajjb4MKuFmQnYHPt/Au9zzT405/+BFmW8eKLL+L666/HL37xC9x4443sPhJjr7zyCu699148//zzTJRRBxBFvoivfvWrSKfTrN377bffxpVXXsmiavQFuPPOO9lj1q1bx37BmF8cEo433XQTfvOb32DVqlW46KKLcM455+DJJ58sWK6LL74YV1xxBdasWYP99ttv0nLT611zzTW4+uqr8dZbb+Gkk07CqaeeWiA8iUsuuQTf+MY32OvQYzgcDmd3hsZVkQChC/3NqX3ua3Ed3BlnnMECDO3t7SWff9ppp+Uje+XEH91O5z563O4IT8XOIeiDSGKOPpTLli1jAo2uU5SLBB0ZMR5++OHssX/961/Z4++++2587GMfw7Zt23DmmWdi3333ZfdTFM6koaGB/d/c3JyvsaODEIWzH3vsMRx22GH55zzzzDP43e9+h6OOOir/fIrGnXDCCWWXmwQdibaPf/zj7DqJyscffxzXXnstfvWrX+UfR8Ws9KXlcDgczp4HdarSj3sTCk5Y576anHHGGTj++ONZLZ35POv9ZmSPul/pfGlN25pij84/9LjdER6xm0O8733vK/gFQoKLol6rV69mkbxDDz00fx+lakn8UfSLoC/LT37yExxxxBH44Q9/yCJnlaDXpOHwJNjMmjm6/PnPf8amTZsKHktp2EqDjckgkt7XCl03l62a1+FwOBzO3OWee+5hQozq56qxJ5Esoqz4/FIpskdCkW6fKoiQzGgYiqQwHElhJJqGrlfvnbez4RG7PRj6lWIKwfPPP5+lN++77z489NBDLHVK6dFy3atUF0fQ4zs6Ogruozo5K1SzNxXFIXHrstXyOhwOh8OZe1BJT6mGCPNcQRkdSrNKNUTZiiN7VFd+4oknTnoNQbZDkBVkNB02TUf3aBxv94YRSubm0XrsCo7fpxkBT+G5b1fBI3ZziBdeeGHS9aVLl2L58uVQVZXV3pmMjY1h/fr12GefffK3UWr2S1/6Evvl8+1vfxu///3v2e02m439b61loNckAUcp3CVLlhRcqi1MJXw+H/vFRClcK88991zBsnE4HA5nz6U4UlfOnqRWmIgTRIgOL4488shJok43DNjn7QvXPh/Av94ewj/f7McT64aRymroqHOi1etAIq1Cq2Haxc6GR+zmEPTB/ta3voULLrgAr732Gn75y1+yqBuJO/ol84UvfIHVv3m9XjZGhSJtdDtBv3aoU5YGJ1MHLdXOmcJq/vz57BfRv/71L1bTQB2w9BrkR0cNExS9e//738/SqiTIKCX7mc98purl/u53v8vSv4sXL2YdsdSQ8cYbb7A6QA6Hw+FwqmG69iRKoAtK80JEUyqKE0OD4TRkfxv0ZAyUREpndXT5XVCkXFzMQC57NZvgwq4W1OSsfh+yM0kmk3jve9/LfnVQGvWLX/wiu4/EEs3Q+8hHPoJMJsN+mVDY2fSCo2gcdcbSOBaKon3wgx9kjRcECcDLL7+cicHPfvaz7H1uvvlm/PjHP2YNFZS23bx5M2useM973oPLLruspuWm+j4ShRQlHB4eZtFAavYgQcrhcDgcznTsSUS7G5KnAb2hFPtfi41Pek5G1WHr2BtKQyc2j8bRGsilZQmqm1s3FAMVBRnpOOqdChxFpUazES7sqp0CQYbB5C2npvGuQO9H71sDJNKok4fsR4ohDzpqbCgHRfcq8Z//+Z/sYoWieCTKrF1KVqgbt1RNBPnY0cVEFEX8v//3/9ilFDSUuZahzhwOh8OZW1CAgRrtSp0L6FxETQ/F9iRyQydLoz65cRzOpYch3fP2pOf2hpKQvY0QRBlv9UWwoqsJda5cwKN3PMnuV6OFwwlS6RTO/tjZ7O+/3nYbZhtc2FUDTX+gKRB76EgxDofD4XB2JWSGTz6p1dqTGIYB2RuAkYphnt8JaCpsrXshnMzm062qpmPDSBxaPAQtOoYNw3GsH4rgkIUBpFUNawYnzvlazu91d4ELu2ohkcWFFofD4XBmuWlvqc7O3Z1PfepT+XSrtZaOInUk6ortSRJZDaLDAz2TYte1+Djkhg6s6o+itaEOoiigL5RkNXRaLAjoGuY1OPHC5lx0blswiZFoCs3e2Z96LYZ3xc4RaHwXfbg5HA6Hs+dALgZUl2xCDW5UvlLs6zabpkPsCK+++mr+b6oT7+7uLuk5F06qEGwOGNntNetaZIRF6N7uC+O1reN4oycEkQJ+em75FjW6kMyquOPVPgyEklgQcMMm734yafdbYg6Hw+FwOEy81WLaOxeEpjUSWcqexCSSVJmNCSxpW0PNwKGIeGHzGF7dGmRdsG11joK07nvmNWC/zjqkVB1j8ZxP3e4GF3YcDofD4exmUBSMnA7KmfaaNlYzGS2bNUJTzHnPVWI0loahqZNup9Tq4iYPFjZ60OpzQGIhu0JafA4m+AbCKQxHKzdMZlJpfOPCC1mKeLbM++XCrgS8A5PD4d8HDmc2Q2a8ZE+1M0x7Z7PQzGo6nAvfA8fCgzCeyJR9zEgsAyMzfYsyU9wNRdLMKmV3ggs7C6anWyKR2FX7g8OZdZDvITHXirE5c5udWee1O5nxWh9HESVKN9JlpqNL0xGa09lH64YTkAOdUAKdeHTdKNYORibNaQ0ns0hktHzjxI6IuxafHZK3cbcSd7wr1gKduMhkl0xyCZfLNWleKYezJ0FTRUZGRth3QZb54YIz+yHBQtNvrFCdF3VPXnfddVMOd99dzXh39HHvttCktKzVA7WafST5mrBmKA49FoKejuOrX/kqRJsTT95+Aw5c1FIg7DKaPiM2JZS61aKjTNxRWnaefXtN3myFH6mLaG1tZf+b4o7D2dMhA+l58+bxHzmc3YJ77rmn5O1mndcdd9wxJ8QdmfGSEKL1qsW0dzYITbMWr3i5S+0j0eljtiWCpEBpWgBdBxN1hJ4Is/9f6wmjye9Fp9/Fro/HMxBnMCjD7FAAlpa121Kom+UOKFzYlfgy0AePRmVls7uXKSGHszOw2WxM3HE4sx1K5V188cUl7yMRQcd3qvOiGdm7e2kBLT9Ft0gIVWvaOxuE5uGHH87mgperxbPuo0giDeeigyC66yG5AxBlBXXOwvUhcafpBl7cHISxEHDaJAyGU6z7daayFqa4iwxuQ7+8CGnX7P7scGFXBvoy7O5ffA6Hw9mToPqt4o7McnVeNPJwd4eiWhTdopSmdb3LmfbOBqH53HPPVVWL99///d+44a5HILoaoY71QQ32s3muj7z0NgTFDiO7vVu1rc6O4UQGD60aZMbDlIb123dc3jz//PO44YYb8tev+5//QqBrEY475ayJ2bOFo8ZmC/xnOIfD4XD22IaC3R0Sb6tXr67KtPfdEprt7e0Ft5PQNNOrxdteaZwP+4IDAKlQiF1+5c8Rhht6PJS7wTCQDfbinjv/D0qgi4k7q3Cc3+BGl9/FLEw665xw2aQdFnX/8z9XYGxsrOD2YO9m3PWXG2d1QwUXdhwOh8OZE8y2hoJ3i1KmvTuzA3ZHhKZ120tuP+wde8PWshj2jhU5f7oJlOaFbHKEWU/HMAyowV4WrSsWdwRF6xRJhF2Rdjj9esPvb7B6G1sXgUXqzIaKkfjsK9niwo7D4XA4cwKq8+ro6Ch7P4mcrq6ud62hYE+l0nSI/D6SFNjal0GQ7dBCQ7C1LoK9YzkTbPbOFex/LVoYLSMMPRe5KyfuZoJVq1dhbHTye5cSd+SXR525swku7DgcDoczJyABcdVVV5W8b1c0FOzJkGArTq8StO3/58qrYGteBLm+HWp4mI360sKjsLUtZcbDttbFMFKJgjq6AoxCcUeeddVy9sfOxqmnnopUurzH3XhwvKrXInHX5LFBsOe6cWcLvHmCw+FwOHMG6qYsxa5oKNhToS5VB9XNAYilVbjd2+8biqQQWHEE7B37QIsHKQTHbjfUNNSx8k0V5cQdNVR0jyXgsNvhss2MpPE3+Kt+bJNbgZGeXUMNeMSOw+FwOHOaXdlQUCu7qjZuJpendzwJua4VckMHnt0cxFgsjZ5gAk9vGMGD7wyieywJLTJSIIguvezS/N+BQADlbOgKbp8Qdw5ZxKaROBKZybNhp8OK5SsQaCy/DMXoOzC6bGfAhR2Hw+Fw5jTFdV6cnUdG1bF6MAZDV5lFSX8ohYfXDOGhVUNYPxSFz6FgXoMTRtFUiOX7LM//fd5nz2P/VyWsDAMLAi7mWzdT4k4URXzxC1+sfhlmGVzYcTgcDofDmRG2jsUxGEnlPN4MHfP8TogQ0F7vYJYkHsfU6dJDDz0U3/vepWhoCEy67+uWMWQmkihgUaNnRsXdYYcdVnYZZjtc2HE4HA6Hw9lhUlkNL3UHYZNFQM81NHz8P/4D533iLGhqpmZh9atf/2rS7YccfEjJx08Wd9o016L8MljTxbMZ3jzB4XA4HA5nh1k7EMHqgTAaaewX5TBLGcHVQK2jDE1xt3k0xhoqiidUWEmn0qxDtpZlsKaLZzM8YsfhcDgczi6abWvy1FNPFVzf3dg6NI4PnPpJXP9f30M8lWHdqruiQE0yI3eymPe5szvsuPfee3H7/92OPQEu7DgcDofDeZe56667sHz59gjQySefjAULFuCee+6ZfftCECHItor2Ju8MRCAoDmYqvKDBwQTVrhR3CwKuafnczQW4sONwOBwO510WdWeddRb6+voKbqfr55xzzqyyMTEMA/b2veFc8l6EEtmSdXXrBqPYMpaEGhlhtzkVCdmxnl0u7kwTY0rLzpQVyu4Ar7HjcDgcDqcGSAh5PB72dywWg9vqwDsFlG698MILmWAqhm4zJ2TMFjaPJmBrXcKmSDy3OYjjXC64bBL6QknmTTcUSSOaysJtkwCLhQkJKhJ3FDEjcUdRvXcTh92Be++5h70v1dxRQ0WHb8+QPHvGWnI4HA6HMwt4+umn0dtbfsJCKcG3qxiOpvB6T5iJNJrnOhzN4Kn1I1A1A+OJNGRRhNcho7PeCbVE16tV3G0ZS2DvdgeLpL2bSDU0VMwVuLDjcDgcDuddYmBgYHbNcxUlVoMm23N1aKQraQzYcCSN9cNRxDMatHhudmqX34HxZJY1JsxrcBeINLVMptMUdylVZ+KKRNa7jTQh7tb2Z5jIpOWxQk0VFOGbK+zyGjuzpoBGiLhcLhxwwAF49dVXKz7nySefxEEHHQSHw4FFixbht7/97bu2vBwOh8PhTJe2trZdu/FECUrTQjy1aRyufY6Ee/lRuO+dIdz9en/u8kYf7n9rgI3/iiaz6KjfLnhEUUBHvRMBj72myBuJuw6PhEt/8EOc/fmvIZFIYVc3VCSzc7ehYpcKu/HxcRxxxBFQFAX//ve/sXr1alxzzTWor68v+xya90fdQx/4wAfw+uuv47LLLsM3vvEN3Hnnne/qsnM4HA6HUyt07urs7CxbSzfdGjvJ1wR7R5HPmiBCdBRGyOS6Fjjm74ehSAaGpkJPxpiprywK7KKIIvwuGxY3edBW55yx1Km1oWLbeGqXN1RsCabYsuwoa9auxWxjl6Zir7zySnR1deGmm27K30bt3pWg6Ny8efNw7bXXsuv77LMPXnnlFVx99dU488wzd/oyczgcDoczXWhm7XXXXce6YknEWWvqdqRxQq5rhdLQjnAyC7OXQ/a3w9a8EPGMym6j91Ia5zOx1+qzw0jnumE9dhkOu7LTd6o1LUsNFSSydtTEuPaFMNj7mj53xWnZWrnqqqsgeRsxm9ilETsyDDz44IPxsY99DM3NzTjwwAPx+9//vuJznn/+eZx44okFt5100klM3GWzk1uxORwOh8OZTZxxxhm444470N7eXnA7RfJuueWWml8vrWosEic6fRiM5BoDdBJxDR2Q61vRE8ylPkPJLLtOtXUjsdpGfM2kuNsRn7vVa1bPwEIYmOd31Oxz9/IrL1e8f7Z4EO5SYbd582b85je/wdKlS/Hggw/iS1/6Ekur/vnPfy77nMHBQbS0tBTcRtdVVcXo6Oikx6fTaUQikYILh8PhcDi7WtxR+ZHJ/fffz0qNTjvttJpfazSWgehwQ88kWfeprhvsNookGZkU1g/HmN9cf4hSoIA63o9hut/TgF3BjvjcXfHTK3aZz91f/vKXivdfcskls2J6yC4Vdrqu4z3veQ9++tOfsmjdBRdcgC984QtM7FWiOFxthrJLhbGvuOIK1NXV5S+U+uVwOBwOZzakZU2OPPLIguu1MBSl6JsAPTbOBN1oLI3e8SQEWYEaGcZYPIPNI3EmYIxUAlosiGaPjQm/XSXuzLSsKe5K+dy9+OKL71padtNIfEpxNx7MdQeXg2xsyM5mjxZ21B1kHali1sxt27at7HNaW1tZ1M7K8PAwZFlmnbXFXHrppQiHw/lLT8+O5dM5HA6Hw5ktZDUdPeNJ6OkEDC2LjGZMiLgk9GSUiReHImH9UBTBRBZaMpe1avLYoEVHmbgbjqZ3ubizNlSc/bGzceqpp+KPf/xj2efOWO+FYbBuWWogqUbcTUXxNJE9TthRR+y6desKblu/fj3mz59f9jmHHXYYHn744YLbHnroIVarR921xdjtdvh8voILh8PhcDhzgbFYBpFkFnoqxq577DQVIoFIKpsTdgACbgVDkVSuT0HfniqkyB2JO5oeQffvCoobKqyKrVKEbCZ7LqQJnztT3AWjcSYs6ZJO1SZ6L7roIjYybo8VdrQBXnjhBZaK3bhxI/72t7/hhhtuwFe/+tWCiNu5556bv051eFu3bsW3vvUtrFmzhin6P/zhD/jOd76zi9aCw+FwOLOF2VDj9G5Ph8hSGlPPRZrqnTJroLDL20/viiSi2WtHs0eZ1IRA4q7FZ8dAOIVto+G8oEmlU7tNQ8VMi7vuiQkVJoJdgGAT4G/wT/k6VOtPHc+7UtztUmF3yCGH4B//+AduvfVWrFy5Ej/+8Y+ZjcmnPvWpApdua2p24cKFrMj0iSeeYGbG9Jzrr7+eW51wOBzOHg6dTIvLe2ZTt2ItCDbnlI8JJTLYOpbIzWmdQJZEdPmdTMhZeef1V3DRN75esgmBHttW52CRu92xoWLVO6tYzf60MQxk9Mx2cTdhhULLohs6HJ0OdvnUp7drE6VRga3DBqHINM6s+f/mN7+5y35k7PKRYh/5yEfYpRw333zzpNuOOuoovPbaazt5yTgcDoezO4k6ipSUmrVK041oUhF1os5GAUcWJBlNx4T9HBMVtra98FpPGActssNlkyfV1VHN3Nu9YZZybXIVliHR41NptaAJ4efXXFM2fUn3H3XkUUhn0rvUk806W5bEnQdxjI8Fp3ze5ZdfjkBjAF/8whdZuVatDCWGMBYOYmXTSthEW8GEiuFECJJXgiAKmL8iVyYmeSTY2+0QbSIkpw41PLmhk+r5qZHi6KOPxh43UozD4XA4nB2BIiMXXnhhSVFnsisjKJVQGhfAseAAvLI1xPzoyJLEPm8/CIoTb/SE8eA7Q9g0EmMWJgTNcX16/Sie3ThKziVYGHCzVGslbr7p5oo1aRRAoYgXRe5mU0PFBz/2maojd8GxMfzP/1zBvG6LSalJbI1sQUqdnF4WFKA31ofR5Ci7FFuhrB4OArIdRsZAb7w3J+raaMYukB3PQvbJsHfYIdrFWTMXmAs7DofD4cwo8Xic2U/Rhf7e2VBkhKwmymGNoMwmKNpma+yCkU5i7WCMibXH141CaZwHPRnG/AYnYuksnlg7jKc2jGDbWIL9vWE4is56F5vZWs20irGxscr3j45h1epVs66hYuGSZVWnZU3h+vsbf59PyxowMJwcxpsjb2FtcB16YtuYj58VJWBDVI0iq2fRHeqGOlGrSC+oJfqR1MMQ0AotLSOpJmFrs0HySdCiGr0B1KjKInd0mS1zgXd5KpbD4XA4nB2h2sjIroqglKN7NAHB4YY61of2egfWD8Wg6jq08DBLA1KnaFudm5kLU+p1y1ic+b0tCLinnOFaa83Z9y/7fv5va0NF2jnzjQyapTO33G3FDRXVjB+ju0dHRplI3XflvhiID2B9cD1EUUTAGcBgYohF2NRwTryJDpHVytG20gQNofQ4gukgfGLOPUPyifC4EjDSaUjudjhEH5Q6hYk5EnV5ijYRiW2aIkJzgXcFXNhxOBwOZ7em2sjIroqglCKaymLjSAJ6IucrR12sixqdyGRkJmJIzFB3psOeq7GjlGsyq7Emg+IoncPuYCM6TSgdSQ4TOwKlZe02YNtohDVUkNibSUeMYr721a9Nuu2dN18rqLmrdrbseHCcNT0MxgaZqPPbc92soiDC1mKDllARzUZha1aY0MtoGTR6GqEZGvpj/XB73CzlqjQocMkOaPF+JuzGo3ZkwyKgWZZBQEG0ztw31Ag6XcPpHYWnYjkcDoezW0OREYqQlEtL0u00dWhXRVCKIRPc9YNRhJOZvNccIZrLX2IiAq0DCbypUq8k6qjWbKr0q5WGQOlO2Bafg0Xuap1QYXfYmdC8/f9uL3l/KX+6WCznw2fll9dfP2lChSAJsLXaoDQprD6uFP4GPyKZCLt4FE/+dq/iZY0QzgUuPLrmUdg7Hawpos5exy5emxfjqXG8OfYmnEuckBwS3DK1tBhM3CmywQQepImOYwHwtnohWJQUfQ5pDvCubNThwo7D4XA4uzUUGbnuuuvY3+WEz66MoJiEE1k8uX4Y977Rj1e3jqPBbZvRiQiUUrzh9zfUbN5LXcPlmKmGilLp12og/ziIGWSDPRCddjQdtBKOeU54VnrgWuaGEtiu7mjXNzY1YsXyFQimgixqp4i5+9euXYsbfnsDtLgG0SXiwUcezNXIhVUm6nILCdzwmxvwv7/+X+hx6nbNCeocBpq8BqBlcuJOtkOpV3DCScdDT9O6Gfl5v7u6+5oLOw6Hw+Hs9tDJlCIl7e3tk+675ZZbdvnJlrpaX+8Zx+r+COtipTq5OqdSsTZu7erVWNBQvbij2jJqhKiVQw4+pMJy6/mGipff2YCBUALToXjKVFUoApwLnXDv5YZzkQTJN4Yl71kB0dUKLaqzaJu9yw65gSKZuad84fwvQIOGkcQInLIzL+rosxGNRll3K3SwaJwW05jQsy6bntChJTQY1nTrBH/8w40scgc9A3vzPDQ4RKzc9hJ+2/IG/vMgbYfm/c4kvMaOw+Fw9nCoc9Xj8eRTYm636ai2+y1/f3//JHF32mmnzfybihLk+jZk1O3+c9TkQHNaW+sck6JxfaEkNo/EWDer02IobEKjq2hGail/tvPP/yKal6xk4m5xk3uSr121Q+qtXHrZpQUmxaWw1uqRuLvlhv/FvzoW4j8+ciI+eFRtfnGhUAi1Ymu2sVo3FmWjSRpKFosXuCGLh2Dta28hGtwIySXC3mqHy+XH+Z8+n/nYkW1JPBtnDRPUEf3ggw/mX1NyS7nXnBB1xKOPPooVK1ZMuTwsXSwY2N+7BcfXqzjKNoKG0TfhdhgYcWHWwIUdh8PhcOaMGLRGTHbmclFBP/nNPd8dxFH7OFnE6PlNY9gwFIPPKWN5mw/LWn1MxJGh8Dv9YVZDV0rUES+/8nJZf7arrrwCF19y6ZTirpqRVybL95k8ocNKKVNjEnehPuDGv92JrJrFKccdWfX71dfXl021Si4JBhuLBuhJipZRR6rEOlZJgBlZI5dW9cjw2G04cr/5WNS2CHfc/jcWQTv57A9h/yX7Y5/APmyCxEhyBAIE1ixBI0gpUldO1BF0P024KhXtNb0RfZKKo+qjOKU1imWOJOy6hojuwFatDh0C1QdmMFvgwo7D4XA4nBqIplTYWpYAmopNIwlAGgG5j2wZS2BegwvxjIoXu4PYOJwTYTTmqyeYZKO+yvGXv/yl5O2kK0g0/uEPv8fvfvd7bAkmyoo7qi2jCB+JwVJ1dvQ61dbflTM1Nrtj73rgcRx80MFoqy8fqrKmlUvZrwiKAMc8B+Q6mdW7kYjSUzrUkArZO3Fb1mCPU/wyjCzQ5GyC3SahzU/qz8bq3fbuWs7EXHI4yQRgWk3DY9v+o6OSqKvUvMEWoPslXNgxiOPqI2hyaKQ9MZqWEFMpImtAkA0WvZ1N8Bo7DofD4XBqYPVgBKKrjtWdzWtwoj+UxLZggjU72GQRfpeN2ZNouo6XtgTx0pYxNs+10oSISmlU059t7drV+UH1pWruyNqDxmoRxT0kNYxeZVTqqs1F7rrx0jvrS5oYk7i675l/4ev/+XUmqKh79Mr/ubJgWWjGqr3TnvOFC6nsokW0XN1cu50JOxJhp591Oj75xU8yUZcNZVkUjrArQq7eTbJhNCaiwR6ACJGNBKNmCLO+jqLKU4k6wuXaLlDrJBWnBMbxm6VbcW7wDnyiKQiXDehR7diatCGmkpDLbVBDS1Wvlt8luLDjcDgcDqdKBsMpvNQdgqjYmUIho2BqhCDBJYvbT6miKLDJEIubPGj1Olh36Y5C4i8/qL6MuKMas+9971I0NAQKbg80NuJb3/72jO1nEndSOspMjEnc5SNyInDzvTfjb4/eCrVNhWc/D5yLnDmBN4G7zsPGcpFPHHWeOh1ONsuXAmR6Uoc6rrJxXR857SPwdfhYZyuJugJTYLYQaSbuaBOMRiQ4JCccsgM2aXt9o6/FB0+zp6KoI+699x4k3nkC3+wYxC17b8alXQPY15VAWnKhW3NgRFegZg0YpXyfS9646+CpWA6Hw+FwqhwB9tq2cdiVnEghXzWaBDEV5uN3FLOGzhR3m0djJdOyJO72P2B/fPw/Ps6u//CHP8SBBx6ITHZm68Dmt9Sjuc6BJ158Aw/84zbm50ZzU59d8yxEWWA2INmIyurlHE4HMgMZ6KoO1yInkoLAxnLRMi5atAiZTAY/+9nP8q9N6de6jjoWgWMGw+U2s5ZGax0wGjMwGAJa63Oimginw8zL7v3veT/uu/O+kk+vl1UcWRfFB/1bsE/PK3A26YhoIralbNAgoMvhgiRHoKazs02/lYVH7DgcDoczJ6GmBZqvWo34mopYWsVzG0fRE0xgUaMrb5q7ZYZev1Ljg9WfzWSqyB2lZU1WrFxRcL3YV271mtWT3jMQCFRM31ItHy3P5lWv4+83/xZRTYbS1gSl2QZRolwrkB1XYaQMaGGSSLl6OrIvSWhJlno1VAPz5s1jXnHW5TNr6ihS1+xqzqdfy0Fp2Ta/iIxK4s5g1jIk6kLpEOrt9ThwnwNx1llnwTvR7CPCwEGeOL7bOZCPzu3nTiCsitiUsmEkqzBRJyr0SB2B+sBuI+oILuw4HA6HMwcR8FZfBE9vHEHv+NTea1tG4ywiZ0KF/CQKyXeOLiTqto4lMD/ggkDj5ScmIqzb2I1Nw9EdFnef/vSnS6+FxZ+tWJxNJe6qHetVyvbkvM+el39/mqkq1xcm+M47L3c/GSKr0SC02ChszS2QfQGmLJioy27fJuQNR6lQSrVSpK5cBK64UWIqUVdK3G0ciSKYyok603x47733xn988Eic3RTEH/bqxs8Xb8MZjeNQBB1bUzZsTdsR17fXzpGoo/WwSXb4PF60t7VBlicnOZubmzHb4KlYDofD4cw5bC2L8XZfBJJsw9rBKDr9LiaEykXjXuqmAnkJH1jaxOxKVg9E8PKWIPOpY9YZIljH68svvpj3diNx96dfXsmsT+jvP//6arid5TtfTVLp1CTPunImwVQbR6KO0qulmCotW46pPO8OPfRQVqtHwi3ujbOZqikxBTWo5u8vNEQOQ3Z7KbkJNZ6BkZ38+hShq4RV1FkbJaqFxJ3LFcPwaAL18MPr9ULQNbRGN2Lh6CtoGH4JRscIsoaA0ayMpF769U1RZ2T1/DJQEwY1WGzctKngsW6XC9r2qXCzAi7sOBwOhzOnIKFl69gHfpeCOrcTfeNJ1rna1VDammM4kkIomUEoCTy9YQTt9U680ROCxy6js942aQ6rtQnSjNzRe97/9Cs44/j3lxWQtWLWxhVH6oqh9+tqsGP9cAibRsDEXalnlLIcqQSJyc69O3HJtZcwj7nTzz8d//jNP3IRtyJxSIJMsEeQGc5CkBsg2A0Y6dKmxJQSjRbZi6S1dIGoK1tTVwFKvyb1EBY01kOMqGjf/CQOSrwMf7Ifoq4iLMrYmLKBpHo5rKJuUvq11tbiXQQXdhwOh8OZM4STKmztywA1A59TYY0L6XQae733aKQ2vYJYLDrJtJimQsiiwKZCbA0m2PWA24Z68rioYg6rKe7uf+gR7L/f/ljc7J0RcVeqNq4cY6kRZIRB+KSlLHLX4Zt8el+zes2UryM6RWY5wiZh/MfZrCZO8kpMzDU1NzGLknRPuqAuULALsLXYkRnOQI+nmKgTHQHm+VZK3K3cd18mkq2ijnzopivqqPHi6v+9GrJHxA9OOQ4HJp5H19hbUNJR6KKMhMMHTbKzfagjND1RtxvBhR2Hw+Fw5gaCiDf7YxAdHqjB/vzNTV4b5LpWNsi+mGRGQ/dQGN/40gXQUzHcdvvfIct25kdXyxxWEnfB7tVYt2kzBHExS4/OVORuKgwYbIxWTItiUb2OsaiE7rEEa+6g5TIZD40z/zi5ToGe1aGn9VwdnJ7zlZMDCuzNZOMCdMe6oQQUZh6sRnLp13pbPUS7yOxLemO9WLb3MjS2NyJq5HKRejynhkjM0V/lxF2xqAumguUtTapASwzgjNYQPmgbw+FbByEbKrMpiblbkFQFiLoAOyufm2akrgKynoVNLG+jsivgwo7D4XA4cwKloQMvbQ3D0ApPtA5FYsk3e9dy9IwnsczlYp2YxEg0jWhahZ6Os+s09qtY1FU7h5VElDMTQSqrs5q3d0vcpdQUYpkY+z+uRrGosRNr+zMsPaxGevOP89f7oTTZmAGwqAhMwFAzA4k82kCyS4ZGI710gwk38ppjdXETQoe2GZkIUzPFhtAG9Kf6cegnD8XTTz49ySNuKnHHXk8R8PrG17F04dLKliYlEAyddbae0BzFRzf9CnrdEFRNQFJugzZhTkxb3qHQDF8D6awA6zQ3aoRQVTUv6iRFQoOvAUODQ1O+twQDfkWFT9LhzoaxKuvGgz1ZfAKzA94Vy+FwOJxZN4eWRARd6O9qkDwB2Nr2gt8pQ3LVQfI0FNyvhocg2j14csMYXtk6jlQ2J0QGwslcxdUU0wOqncPa0uRnNW6muJsJK5SpiGaiSGkpuBQXS2mKosGmYIguFe4Vi9EXHWWPa13UCluzLSegBIEJOkMzIEgCRElkETMa6WVkDATsASbqSpn6UqRP1VUMJ4ax75J9cdoxp8GtFKa3fT4fTvvQUdBTY0zcCfb6ko0Sb7zyBpoc1Xe/ujJh7D34JE5dcy1+sbQHpzeMQ4GALQkbtqVtyEqOgseTrnYoAnTDQNrSNEw2K+x+RUSgKYB57fPg9VDzRxkMA3Y1joX2NOY5MsgaIv4x6sc/uj6JzwcPwb1bZo+c4hE7DofD4ey2qJqONQNROBcfAkFWsLSJuhRHWdp1OJrGPPv2E70WGUGdU8ZrW8YxGktj/856NgrM65jaQHiqOaxWbzeqiyNxR7Vu70bkLpQJsc5dt+xGLBtDLDsRfbSNQLTb8cK2bibehuLbILlIgAhTTmIgUU0ib/IdgFKvsPTvAt8C2CU7sxJZuHBh3mD4E5/4BDMd3rx5c8nInbX7NTwSRm9vL9rb28svi6HjYIrO+cP46Oqr4dTiyBjABkNGIiliYbMfOnIRVV3XsXHzZvb3kiVLWATWFHfJDIlYR24MGIx8+tXr9EISRCb+CjGgkGBWY5AovSs68VzUg0fHfXg24kFUVPBRpR6ZMt21uwou7DgcDoezW0Jec2RJ8uqWcRiaysZcsXThxKD6oUgadlsKdZZpXtTpWu+2MW+7cCKLeFpFwDn1qdCcw0pdsZTFLSXuyNvNbHYgy5F3Q9xR5CyYDMKpONkorfH0OJu2kElnILlFZAZ6IEs6XtzWDVEeZpE6aoRwCk7EUGrwfXloBiyJOkHJecyRqDOxNnmYpsOxic5Xq7gzZAGyO1bQKGE+rhiqWTzKG8Ki4RfwocXbYBNoo3sxagsgratIZOMs4lgNogDYaTcLIgTZgbSWmWRpYmITdDQoGtySDocax7irA92NB2GzZ2/84KE/sMeY4lQWFOiZ2dVpMbtkJofD4XB2O8jjq5a06UwxEktj43AMjR4b9GSk4D4Sdy0+O5tlSpE7K7IkYkEgN4WAumbpejWUm8NqQt5uVkxxVykte8ttt+B3t/4OcpH3HHWaVkM0G0VSTeaH3tMIrtHEKPrj/TDSBlOgixs9MIQMxqN2aHGZRerOP//8/GvQVIYpEYDR9CgTdWQ+bBV1lT4XJiTuDDUIW6AJMOoLGiWsjzOnQlza1Y8zVl+NvV7/PVyhLRjLyticsiMqOZExNCiiXLWoMyHtSdE6UZaQUQXWOGI2SgiGBmc2gkWONNrsKsZVGX8aDODfe30Z9638Fla3HYOoI9d8Y404BhyBaTV87Ey4sONwOBzObgmJumRWY1G4UjR77Wirc7DIXXHNHdHosaPVV1iTVY24+9Wvf5W/fulll+b/JouQU089lV3IhLgacUd1amuDa7EluiV3RqZpB202uBa7cuJsCtVA9XUUSZOEXDqZ6uzoNrpQIwR7TDYCjzsBv9MLCC2AZM83jxBdXV2TXrenp2dS+lXVs5MmSlSis7Nz+0souUidnhyHlvFBsOVq7shEmCJ8fWtew1mNQdy41xY2FeLUAKWXgU0JGatGUsxMmNLJWV1lHbSyqKBmDAOiTP+lIZFCFWzwSRrqk0PwpUYoOYt/Bevxvc2d+NSaRfjNQAteCZLUFGbMRPndgKdiORwOh7PbMRZLY01vEBd9+QIYmfIjw1p8DqQz6ZJWJ9PFmnZcvs/yKR9fnJZt9+ZOvWQxMpQYYiKLdaF22Jl4IZsREk+rRlbh4ksvRmYwg9tvvx0OS70gCT4Sb2RzQilYE7tkw1hyjAk80oSSW0I4E0ajuxEOhxPQKEXbXtBIUIo77rijQNSRDmq0N1Ut6qzbqVAMjUCwZVlalhbw/COX4rDNt+KorQ/B10lNCQJGSkyFoO0iyAKL1NFlcj1cZQwS3nou/WrXMmgxgnA7kohrMnq9S9HTfAi6PXvhvx/8dcHzbr31ViY+TzrpJHQu6NxhE+V3Ay7sOBwOhzPraudkfzurm6P5rU6nAbGoPo2idYmMVlHUWSN35Roq3i2s4m7LWILVukk+CTE1hlZvKxJCgnWsUhME840TwRohKHJH4oyEX4PRAM3QkNEyzPuN6unob5YOzCOg3dOObDbLnid5JNTZ6tjMVLpNi/czYTccFljkDloaGzduLL3QFlFHkTqrgKwWU9Q5ZCciIxEmhvzaKI5xDuHkzggOTW6GGEtim6ahWy09FcIUddSlO51InQEgm03Ak41goZhEGgIi9ib8pk/Gc+pSHPHe89DZaMPq1atKPj8ajeLOe+7EkR8+ctaLOoILOw6Hw+HMKkbjGTjm7QdBceDfq4bREUixDtbWOgd08lgbT2LTSAwBT/VCo7ihgiJ5tVJqxut0xN2a/nEogU7I/jHIoszSeVSzpoZUJhhMMUQWIjTNQXJJ2BTehG3xbfnULKVePTZPzv+tzHgtEnXU/UqibjtkYdIPRTaYwKO/H3/88SlFXS2RulJjws77+Ll4+o9X4rj6CD622AY9PAQVEiLCAsThwphaWAdZStTVWlMHw4BNjUPJhNhWS9n8uG1Yx9NhL4465uv4y/3XA1IEh2gCBkI6Hn30sdLLYLFmme2ijuDCjsPhcDgzimYxCH7qqadw4oknQpKmthQx6R5NQLA52PQIqp+jDlaa57pPmw+RpIotYzGWvmxy1XYKszZUENMRdzsKibuFARcknxNKYydc0vbGAauoIzHUaG/MecnFNNaFKisyi+hNBYk6Sr+WtzQx0OxDPi0bi2+f0jGToo489fx6FodL4zhr8w04Y/E2OAQDDlsHVk/MbJ2vkP1IBoKowNCzOy7qDANuUUNA0VCfGkJCVLDOtxcGmw9Dn285rn3gOvawIydqEili2VoHrN48jIROPnY0RWP7exVbs8x2UUdwYcfhcDicGeOuu+7CN77xjdwVScbJJ5/Miuivu+46nHHGGVM+fzyeYalKLR5m1102CQ1eB8LJLF7bNs4sQ1q8DjZNwmxQqAVKy9ptmBFxR52rlDauFUmkVOsQIHYhGJPhshtVFeZXK+pC6RBLv1byqaPMtpmWNSN3JHJmQtRl1CTcoTfx4dBafKp1PfyyivpkFmuzEhK6iEWKDzpypsmKDHhcdowrDmgUDJsQd7WKOoUsSmQNDekhpGQd65IOvNFyDDb4FsPu35tFRCkVXQq7IsBmhADJtn1bUMtE0f6wirpLLrkEiqIgnqz9M7iz4cKOw+FwODPCPffcg3POOSdXI9fQCaWxC8lNr6Cvr49ZalBB/lTirns0jlhagzEx4sukzqmwy0xgijlT3Fl97qqBRmrZmmiOqoKNkY35lOdUUBqVGhvWB9fDVmdAHe1DRgUGQwY8ju1py2rTfSRUrrzyyrzQSOgJjMZHcfufbq8o6qxLVCDuEv1QvPq0RV1AzuLYQAwnr7kWrelR2KGjWzCwJWXDAnsTEnpupmwxikTjzrwYDU5U2AlqVaKO+lXrZQ3+1BA0m4rhrIzXm47Bj198DettPpztPxDtvvaqrFn8PlfBttAzA1D80m5RU1cMF3YcDofDmREuvvhiJuqoNs7WugSSxw/Z1wR1vJ+lTr/5zW/itNNOK0jLUpp1zUCEWY8E3HasH46i3jUzAo5IqcmJqaHlxV3aWb1xMHWskh2JaBfZnNXB5CDcK9xQwyp64j2Q62VoscKW04SawEhkGN+9/GLIPhnnnnvuhFjIsjTgQCSL/mgYRlZANpSZloigSF1cj5eM1GUymbwALCvuPO2wN8+DoQ0gG4xXLeoEXUNLdBPmDb+Mo/fpht+uwZNKIeMIICHaMToxBWMq6rwujI6MQFBsEGgKRDbDRJ0iy2hqatrudcfq5hKwZ6NY4MggrEnY4D8QP3t1PV6KunHBiSdhvW1TSRPlSpDlitdlQzTeD9nXAZu/E3p8sGB/UHcsNVLMdriw43A4HM6MQJE5QmleCNnjh6HprLuVhB0JPvJGe/rpp3H00Ucjo+pY1RfCY+tGYJdFbJbisMkiu71twg5kR6Ho2EB6APNcubmg5cTdttEI87kzGyzKQRMd7O12dqJXx1WmF3WqFFMEiC4RW6Nb4VzkhJbQmAedT/exOjOaDBFNR5moozFd9eThZuomMQPBPg6k7NCzZN6bSwPWgtXSxCW6qnpOQQpZoPFaI4DYCj3ZDEOn/Vi6mcHElQlhyegqLB59CfWJQQhaGlsVYGvajgXOtpzVSa1paorUCSIMg8zmdHR0NMPlcjFZLmkZONUoZC3D5sEOuxfg56/LeCbiwaeP/zieCv9iWibKJvTD47jjjsU9990L0TYM6G2T9sdxxx2Hu+++G7MdLuw4HA6Hs0MINhdEmxNGNsX+tjUvgBobp8GdLGInOn35yRADAwOsEeL1nhA2D8eYH1lWMzCvwQFJEHIzSmnc0w5C9W9k+htWw7DDtsM+dxk9gy2RLSxFSNG5AtPekSyLcJHtCN0nOSWsH18PWyxnX+K2udmgexrlVbCMisCEn8fmRHNTHR4WC2u8qqGUpUk10HzW3EKYNXUGMkO9EG1thTV3ZWa2vvfhb7E0qC/QhDVDIaQkGdAV6FmdWbnUCm1H2rYUqWPjICQbFNkGVyYMu5aALkiI2pvQ3fgebPPvi2GlGXffc9UOmyibrF27Fo8++VguHZ5JIxOlubq5tKxLiuGkE0/A4sWLUYyiyDjzzDPx9et+DrfbjdkAF3YcDoezhzPdLlaKxrGLNwBBtsOg6nddy3U4psfYYwRfgIm7DAk7SUbC2YQHVw+yyNyCRjcb0k6mveTvRlYgLmqKqKY8rAyr16xmJ3l7q42N22p0NWIkOcoEULm6s3I+dzSHlYQCCZXeaC/G0mM5j7lKpr0GWMSu0dnIiuvNBohiwWUW5tMUhWZXM7KZ7R5z28VdZcpbmkwNG/9WolFCy05uqGhUsji6LoqPbvhfnDYxszWsSqx2br6tASkpRqHLnKibBjRNgi5UUwdNh1dKISAn4UsLyNi82Np0GLYGDsSgbwl008fOsj2tM2wbazRRJtatW4d77rtnUo2juT8Oef+HsddeC6FpU7g6zxK4sONwOJw9mIIuVqDqLta+8QQcC/aHIMjQklEY8TACTc0Yj6SgJbbPbTVSCciBLhaxa1t+KDJ181EnS2jz5WabEosaPQXibkeGNF3xP1dAaVKgBGzM441mqI7r45D9uRmp1frceVwa1o2tY/VxFHVLaSnUKTnxVI1pLwm6cuOmyFTYFBFUB7Z+3Xo8+OCDTERZxd36DRt3wNKkNGY354aNG8p0v+Zq7mzuVhzU6MBxjm040hti0Tm9f6RgKgStXoT29Q6IOhLOJKBdhoYOmba9gZgm4oWwC9KKj+NtZSXs9V743WU+FUXpV9s0TJQfffLR0o0rE/vj5dfexPwF89Ho3j06KLiw43A4nD1Y1FG3arFlx1RdrP93x1341tV/YJE5NTSYv/2Iw96Lf957L6uJyp8bE2Eo9S0QFx6Ej376fCxs9ECWCk/SZGFiFXcdvupOTS+++OLkbtVWG2twoMaGbd3bsPfee8OjeKA0KMiOlUlTGgaURgWGSk0cMrqD44iN9kGQw/lImFNxQlf1HbYCoUjdaHokLyI2rN9QWLdlEXcPPP7aROOHMS1Lk3JQhMvR6Ci5Hi1KFsfUR/DBhk1Y5NKhUHQuK7DonHUqBIk6QRExHgxNW9TZZQPOdBBuQ4UmObAmZcfD4z48FfZiW9qOSz72XtgzEsZjtHx6gbgjcXrZ9y9js3aTmeQO7Y+0kirf/aqlER3ZiL7+YWgtgZL7gzz7ZhNc2HE4HM4emn698MILS/qwsc7WMl2sJAbP+fK3YF94INTIcMHzSNRNejlDR53bjk9+/Dwcf+T7yi6PVdx1jyUgKHYY2fInTF3XcfNNN29/vk+Co9PBxJ0W0VhH5UMPPYRly5axqB2lLGlkV6n1HUsFYe+0QxAF9KfXIKEprFt2QaAR9gkRSmJoKDm0w6KOIkM0FssUEY8++ujkBxZF7qxpWVPU1dvrq26UsELrMZYYg2qo+fWQBSNfO/f+uhh8ksZmto6mZaQEF1NxhpDK1b5ZRN10InVkUeLKRrHIlYEhAqrsxWqa0+rdB995+PZJI8VyYk6fJO5oPUjUUe0jRT13ZH8YU1maaGnmc5dRA5P3RybCIrCzCS7sOBwOZydANUymRUMsFps1hdUm1J2aL6AvgbWL9aijjmJCJ6uquPCyy6G0LIaRTgL61DVHP/zhD3HggQfmB8JXwhR3a/szUAJdyI71lH3sqtWrMDaWq+OTG2Q4OhwsmMLGck0QiUSwbds2uANuJtqo7m44OYz5jvn5x5Aw2BbbxkSKGqVaryzsdg3tPhd++8e/Q0+N4TsXfgHj2XF230yM16KJEqaIKGufUSTuaJSaVdTV0iiRRwBr1tBFnYmhNiGNY5qj+EhTDJ1yggm8kCqhO2VDS0srkkNDZBgDQXKwi6GlIAj6NESdAbuawAJHmqXZVUPHAwk/nhj34v1HXwbB4WbrUmpObClxV+dCXtS1uFogTqSGayFjSYdX41NHPncBCt5OmBib+4MuNml7WcFsgAs7DofD2QOh7lQrcqAT0NSC1Kr5OJrN+sS6Ybyzdj3CngUQRQlqMGdtYqWUu8WKlSuqEnVWcbcg4GLROhJ3iYwGRwnXivHgOPufUqj2Dhpmj5JpyZHoCFSvmutkNcAsSQKeAEvPEtQUEcqEcs81AJ/Nx9J8WSnLRJ3oCGBzMAi3OzvtyJA5XqvcRImyWMTdptE4nJ4IvJIbv/zZL9ndF110UfULMdEooatJvNeIYknfwzh5WTeLznkDzVg7kEHKIpBclh8iTNBJDoiyg9mzULfzlKKOTKq1NDrtGdgFA4qRwdNRNx5L1sP/nk/gL88/yLb5+6j7tYrFN8VdMKpjNBGE3ZETdWyiRNEoslrT4V5PZX86n8/HfO5UVZ20P0hgh9Xau4B3JlzYcTgczh5IW1tb/m/R7oajYzkgSkhtfZP5zpk0trTi7d4wVM2APR2GGh6q3Z+sRkjcZYO9UBo6WVrWYbezGatW/A1+1hBBoo7EFvnDTXodtwTDYRTUoiXVJLrDm9HobGKCoC/WB6/sLRmxMTIhSD4FobiBBiYixGmJuqHEEOt+ndYEA6rfMoYQpiYU2Q9vvaPmRgmyc5nXaODYumFcsPVWNGSDzFh4owFsTtmw0B5ASs+NcCuLkYZAws6wQ2Omz6Whmjx3JgS7noIqyFiVsuORkA9LDvsKLn/u75A8Ms51tk8S4bScP/jBDwqmaRRDkToSdcG4jgX2nKibiXT4cVP401GXOJUmlNwfLifCiGE2wYUdh8Ph7IF84AMfYN2v1CghN86DYHfDyCThmLcfUoYOLTzE7m9esj+e2xTEwkY3Qg3+nS7q8pC/XbAXDlncboViEXfti9sR2CuAeCJeVtR5m71Y0rkEHsmzXRDa/RhJjLILoUgKXMrkWjXTQgNCCPP8PsSTMkR9ckTQWrNHqetSos4m5jp0S4m6qaYZMJ86l4r5ATsyGTeGIlrJAv5SiLqKjuBqNPc/hRO7NsBrqPBlDcRtfmQFGeNqdYIkV1NHI77SMAxbPi2br7mbGO1FFyIjObCx+TB0+5bjOw//HzQIOF90M1FHXbwUMSURVwtmTR1F6kjU0f4YlwobKqabDl+2bBlrFqLO5OJ9cfrpp7MGnLL7I6y/a1+JauHCjsPhcPZAqCGCLE3O/vTnYGuaDy0eYvNZJW8AjoUHQQsP4pLLv89EXSSVZRGLFctXINAYQHBsrOTJjIIaM3qSEww01wHDMbVA3MWzcWwMbcShRxyKh+9+uKxp7xHvOQJ+h7+gFk0WZTTZmwoeX1yrRiKCUqdmowT53MUyAkbDZHxcDyMdyj/2xhtvzP9NXcRWERFMBZmoI586TdVKisH9998fzzzzTMnVN9eDxFCTuw66W0TPqDalz127LYPj/RF8dPXVcKeGmLfgtqyBzVkbFtsDzDuw2h01uVHCrLmzw20kEJAzkAQgokl4LORjl8OPvxhweNl2JVHHJmNka7dmMbE2SpjpVxJ1Zs2dpwqHkzTtj2wQ537qM5P2B0HibeHChfjZz35WcDuJvlK+geb+2DamIVFjqePOZkfsgjgcDoezkxswSFDRhRnKzhDD0RT6Q0mccPIp+Mn/3oT6xhYm6ggtOga/244vfOsHUObth6yuQ5FE1q1qQMAXv/BF9riphgvQ5AfykyvVhToVmq7B0WmHe2833h57E1FjE3QhxcRdKJXEhtAGxLIxHLDXAWUjdSe8/wQcuM+B+Q5aE2qmqLRMpoiwNkpQavBXv/gp3EqW1dyRuDOhxphJ664IeH3j63lRV1xTZxWDJOqcTiccDsek9Tjs2MMKxJBdEdhs2XwBv1EYnescfxvHbPozbl7Wja+0D8OeGkFY9iDiakcwK7P9VwvFok6WZdgFHa1SFItsMfhsIsbrl+Ka3lZ8Zu0i/GBLJxN2NPJr0mQMpW7GRB1BkTq/R2DiLhjTy0ZNiyOnpfaHSaVaUHMW7wXnXoBLL7qUpY7Z/qgXoOm8xo7D4XA4u4hwMoun1o8gnMjCYZPQtHR/XHX5Snz+3HMmdbFS5x9pgVRWY6KKxN17D30fvve9S3HDDTfku1JNvv6Nb+D6665nf9ubbZD9CsbT43A6ausa7I33QmmxsRQrWZUk1BhkpRd2YR5e2NoLXR5Duy/AfOWskIg45uRjsGz+MhapM0dFMfPfCW699VaW/jzppJPyKba88BOAd7a8g6bWxpKNElTjZTZU0DOskbviGq43XnkDh+9zeEkRUSwGk8nCmrXT/uM0Jk4phfzMPwujeSQmzAL+4QhF57I4tj6M01dfg/rMKIvOUe3cFtWBNsUHB9XF1SjoiG092/KiDlkNzXag1SciHFHRn1HwyLAPz2YXY5+Tz8cdz/x60vix4giX1+adtjVLsagzIXG3efNG/PPFd/KR1DssUdNaRF0liruRrdhlAS777MrF8lQsh8Ph7CFQpOqdvjDGYhnMD7iQyupshJciaCW7WEUxJwgo/Ulp0DX94zj7899jtW8333wTzvvMeQWvf8jBh7D/6WQuNygQFREDiQG0+lrzJ1SaMiCJEpvmQKTUJGLZODvx04l7NDmK3lgvi+4YGYPd5na4WdSm3ka+YTEo2TqoLhEiUx2FkaElHUsKRF3xiZ6gOiq6neqqCCb8JrpGH33iEdizDhx31HGlt2E6xN61lLiz+qKFR8LMTmb+/PmTooaVoPVwBVxsHcr51Nn0JA6V1uC0gQQ+u08PfEIK3oyIuK0eWciICAmWj7NJdrbdaR5vLdCu0kUNXmjwS1nqqcG4KuHvW0U8HurEy1E3MmRChxj2U1Bytux0J2OUsmYpJerM/fvve+5goq7U/li1bhUa5jfssKijSF0pUWciTz19b88Rdj/60Y9w+eWXF9zW0tKCwcHCdnuTJ554Asccc8yk29esWVNQ3MjhcDicyZBtyfrBKFp9DsiiCI89d6JLpac+8ZK4WxhwMeNg6lZNamk4FjjYYPts0NLtSQKpSWHCgixGqM6MLgFnAIPxQWyNbGVjn+hEyWxAEiMsokKzVRfULWDXSQSRqCPMDsnvfPc7CGdC6GxwIRZXMDCuo9FjTKpFM0++JGKtkbpS3HfffbloWdHM1Ew2WrFLspS4K2V2a43MVfIMnJS2tNWV9KmrSw6ic/hV/HnvbmYj0pgKYTMkdGd9WGQLMK++tJpi297I6tMSMk5ZR8CuwQEDsayAV2NuPBzy4dmwF0G1WDIYaPZR7jxTIO5MMTTdyRjm/qB0eLunvaSos+7fcvvj6defxlkLzpq2qGO1gZkwGt2NNc/i3aMjditWrMAjjzySv17N4Gka2Eu+MiZNTYWFsBwOh8OhKJGBVf1hVqPntstY1UfV/2B/10IqncLZHzub/U3CztY+D8/3boJzoYvcZpHcmkBmJIuElmCju+ikTCKLpj8QFIGjhofuSDdkQWZRu1AqxE7ciWyCCQCKqmwKbcLWLVvx/MPPT1qGjRs2YuXKlexvj2JgMAQMhgHJ62JdisWRIaqlq9RtSpQSddX61FnFhCELkN2xSWa3pkF1uVo8K6XEKeESNRzmi+HYdTdA3PQ8vJKOpCJgIC1DcrZgPLMFgmRDSjUgShkYhs5E3UTDalVQfV6zkoVX1pEVRfRk7Hhg2Itnwh5sTtkrpnIpqGs1UmZWIBYxZHa/VmumbHYj0/6gdHg5S5Pi/VtqfyQiCSRHkhA90xN1VpG9O7HLhR0VY7a2ttb0nObmZtTXby9e5XA4HM5kNo/G8WJ3kEU3SGtoOrCwsUR6zzDYSC09PbUaEB0qJM8o+mIjMLQmZMZ6oTTZINcreHvsbfY6JOhMUUcnxrHkGILJINyKO28tYtY+eWyefESlf20/HrrroZLvSxE0Ol9QdoZSxK31wNqBOBR/B7LjfdDihWOdphJSjGmKOquYIBFhCzRBT8rIhkbyoo7q+MjU1sQq8iqJupxRsoHG2BZ0jLyOv+69GS22LBoiKWzUBQxnbYVCi4SclkJGUyHogItGsVUj6gwdflllFiV1mSAGDQkPJhrwVKQOrw7aoBm11OUZTNyd8dmvIJZNwWtzTUsMFXcjV/KpK7V/S+2Pu+68Cx/5yEcmZfVM37xaRPbuwi4Xdhs2bEB7ezvsdjsOPfRQ/PSnP8WiRYsqPocKe1OpFJYvX852TKn0rEk6nWYX64gZDofD2d0ZCCcRTalIpFV4HDIWNnqYsa8JWZS82ROCQ5FY6tU6A7aYYHqcTXCgkAel0Rz20ia4kleCY54DtkagxUcncxmi1MYMjQUJCA4FoSdIaBgF9iJeycuEm3miLlXQXk3q1Jz9SusQzUagOILQEilAaAGkwhqvSkJqJkQdewklFxkiEaFlfBBs2XyNF9mYWCFPwKlEhCeVxpGBKD687ldoTPZB1lLYJmnoTdsgOJoR1kqLVVGmOi8NgmGHqlUSZAYULQl3NgbB0BASgCdCXrj2OwuXr3oWsYw0PRNlth4i2x/1chMSCTfSdoM1elRLqW7kSpTav6X2RyoVytdTVlOyNUlk74bsUrsTEnJ//vOf2Zf597//PautO/zwwyd1Wlmd0qkT684772SDqOkLTo7RTz31VNn3uOKKK1BXV5e/dHV17cQ14nA4nJ3PcCSF+98awJ+e7caDqwfx+NphPLtxBLG0mk/BvtUTwmgszTzYTEqJOkqL9sQmLCJEYEt0C+tCLEbySXDMd8AWsEFPa2j3NEKN9OWtNwwN+Mcd/ygQdSbU2VpJ1FWbOjVnv5pdin6qQxvtzdd4wRLhoWgZRc12pqijmjqH7ERmdCTfLWtaoZCNyfXXX88K/MtZaeREhIjlWgTfqO/DLXtvxmVdA2iJbUFGcmLc0YqhrIJs2eiZwRpUaL85ZBucNmqUAPOZK061tihZLHZm4FATGPPMw/PzPorz1i3E9/vm4Xln2w6KupwYov2xpMkLmyywGsh0ldvVamlS7di24v1rrXHMlNgf9KNgKusdaxfv7irqdnnE7kMf+lD+73333ReHHXYYFi9ejD/96U/41re+NenxJOSsZoH0ePKsufrqq3HkkUeWfI9LL7204LXowMDFHYfD2Z3pCyWh6gaWt9dhIJyCJAhYMxDFSCwDt01mXZADoSTa6hw5M9oKDMQHmCUJNUEQ46lx1uCwpH4xhInf/pFMJBepa7BBz2hMDG3r3jZpUH3ONLf8ybOS9URVqdOJ2a/wgzVfOODIpwHNZSAxodDACEFgliaTumItok5OKshUWftV8BKKgE9+8ZNw2pyok+twzc+uKVnAb+2+pXObNdpkF6M4pjGEk+xjWObIoMHtQH9Yx9aUDaKTto3AZrKapIosUQgmwC2NEhSwZeWT9LdkhyMbg1OLsz3So0m4a8yPRYd/BaH6xcyI8JxvH8H2h6iL0xZ10Uy0IG1ppsmpBpLEXZtfrBi5K/apo2WpBuv+LdW4YhTtj0gkxH4UmF3KxexwF+8sYlYZFLvdbibwKD1bLe973/sqPp5SvNRoYb1wOBzObmM4TCdp1/aa4oyqs9o5n0NBi8/BxFswkYXLJiGT1VmULhjPwO+yTZqvajZCnHrqqTj1tFPRF+pDT7QHLsmVO6kbuZq4nkgPNoe6oRka4mocG8Y3FIg6iqg8/vjjuRecEHdm5K5cof1UfmJTpk4ts19J1A10D+C3v/3txD05cUeRu1dW9eYjRZR6I1GVj+xMiDp3nRsnH/lhnHzSydXtA/NdKJU9ISKCI0E0OZpApiv5+0lMFEWKzGgRdfqKMHCgJ44bTvTiL4s34tv1vXhfsw3etgWI183DSFZhkxpMobtl69b8a/QPDBQsC0XqWO2ktVGCaiWNFDqlMBbak2y6whb//nh84adxztpF+HV/C0Y885mos+4PipIVi7ri/UHnThqvVbw/Sk2UyIk7YcrIXTnz4Wqh/Xv6WafD3eKe1LhSan+U+/FgRoCn28Wbq2CdPezyGjsrVAtH1iU0w7BaXn/99YJh1hwOhzNX0HQD9va9IfvbMRhJYbHbje7BID57wdeghoZw++23MXFHUOSORJ5ZT1cWw2ARFqqpWz2+GjbFBo+y/SRul+1sYD11sFKaNkV1XvFtBaKOKDhJThG5q8Yk1kytlUvHWme/kqib7E+XE3fPP/Mkc1d4777zWKQoPyrq6p8xUXf08Udj/0X7w6HktlO5GaGnnHIK/vnPfxbcduNNN+YjQ//+v3/jGc8zk2rpSkXu7MkxtK29BzfutQWL3Wk0BoPo03VsTStY2N4xacQXbdtytl+EmX6l7UmiThYMuDMh2PUUsoKCN5M2PBwOwLfyImQ8LQi4VST0B8vuj+LxWsT555+Pa6+9lv39iU98gtW+q6pa9USJ4sidaU0zU6LOXA9fhw/vf9/78cCdD5SMOBqW/QGlrqL5cDnfwErQeiSyk6Ope6yw+853vsO+PPSFHh4exk9+8hOWKv3MZz6TT6PSgGqqwyPoQ7ZgwQJmkZLJZHDLLbeweju6cDgczlyC6uTe6Y/A1rYX85R4qy+KzqZ69IZo+Drlmran6aziznq9+CRIqabeUC+ci52ABGYK7La7J1lR0Em2wd6AbdFtzJbEKTmnrkUrI+6KZ6aW8xMrmzotmv1KJ+A/P5g7J0wmJ+5ee+UF1qzQbqYBLenXFfNX5EVdpRmhS5YsKVw+RUDGni6IDJEYLDXnlfmoQcehfgHHOcfwfvcoOscHEHKnEDQUiPYWjKQnj74yGR0dnVLU0TQIp5bAQkeuYSQjObCh5XB0+1bg2w//nY0P+2ZjALGYgSHWMyiU3R8aJgszaz0mnaOt160NBpUmSljF3WhMwncv+T7bHzMl6kxxumLhCjxgPFD2sUY6BJfHA4evDeNxnU2sKDVRolpLlsIu3lHoVGA6i9ilwo4MG+mXAH2IyYuO0qovvPBCPgc+MDDAcuImJOZIDJLYo9l6JPDIYPLkk2sLp3M4HM5sh/zn3uiNQIuHYGRT6BtPsoaI3lASempySqmUuDOgoz8+wMYyRbNRpNQUdE2HntRhqAY7KZaDpkNQqo9EUKOtsboGgyJxp2cGmH0F1aKVE3V0MjVNiC+55JJJETRTRBxz2DFs9uvWrVunaLIwEB3eiPGxIQhoQUs9MDaFhUalGaFEqRqucjQpWRxTH8XJ/s1Y5FJhkwSEshJGFD+GdI1t92ZJqfh+1shYwXIqAlyShgaaL2EzIBk6ngx58WjIh45ln0DnvH3Yc82ZsCSiqMatZ1Sren/MdNdoceSO9kc4OzJjoq5cxLGYk455Hxq8udmy1P4tytGyY8KqwSpOXfLUZQR7jLC77bbbKt5/8803F1y/+OKL2YXD4XDmMlvH4nhtWwg+pwwjk4BgF1DnUrBhOMYsTkoJu1LiThXHsC64DrIkwyE54HF62EmQxEVV1hNGFm3utpIF7VSDVbJmaULcyb4O2PydkASlJhFhjaBZRcQByw6oocmCbD3GIcvNWDsYgtup7nD3ayVRJ8HAwd44TvCH8f66GOokjXWyjmZkpGCHbHeiQVbYdqeu4VKNEJVQBB2NDh1uidJ+AtYlHXh43IdXtzZi4/iEKPn7XSyVfdxxx+afR4ERSqE2ew0INjvbH2PDQRy45IBpj9eaTteoKe76QzrbH15vFl2+mRF1xRFHT9HnkmoDTzzxRIvViY6+8TgEJYrO+h0Xdc3OZgxlJ8/J3ZXMqho7DofD2dMZi6XxUneQxVzqnQrkehm2FhtsSgbJrMSaJCgVRxMetkS2wJCodNuAXbSzUV11jjq0wo51I8OI6FsR8DgLauisJ0EzUnbRRRdVHLxO3mLFkH9ocQ2aiSBmINqGAb0NeoYK83Pp0GqhCFq5yFA1TRa5x7kg2kYB0YCWaYKhU3QyPaOirlHJ4rj6CD7cEGYpUap1C6kSulO2fNRMkFTYnRLGRqOAQafc7KRGiJLbAAYzD6aLIQkY1hTcMejHk0EPViWcE6nVwv1Ckcy7774nf/3WW29l2S1Ku4tuie2Ph//9Fp4VnsVJJ1nFztTs+OxXI78/jHQzQPujxhmr1dRqnl+iNtCaRqZIHYk6I1sHXXUDNWrL4jSyYNBKcGHH4XA4c55kVoOtfW+owe0zQlMTt1EUjgyE3e5cpyVZlyQyGuJpFW/1hhBOZDE/4EI8FYetycbEBc1ZXdGygnW1kqgj+5FNwU346y1/Za993mfPQ1JPspPYPO88pIw0wnERPpsLqJz5q2nwerkatEliKJNGJrqNGeYOhgwWsaHIzY5GhqZqsiB8dT44Gh3IGhns3dKCkZBgqfurjoyWKSnqKDp3oCfBonNH1kWZ8KLo3HBWhiraCtKogiTAW+dBNBzKiTrJlqt0swhlii758n5sBhsZ1mg3IOgawpqEh5N+PJWqw3ODTiTStUyDyEHpd8VL+0Nl+0NytSOheXHHHXfirLPOrErcVZr9SpZj1YohdWJ/jEeVqqxQahV1U9UGhidq6ihSR6LOTMuaNXfVrof1R0+mTNp8V8IjdhwOh7MTWD0QhXvlsUhve5uJOMmm4aUt43B0Lme9Dw+sGkbAF0dW00GevhlVQzqb+3ue38lOSCSyaNqDGtYwlBxCV6aLCQdbsw1GxkDAEcj7z1EnawYZuGU3QpkQbHagFR789o9/Z5YPF3/zAjZGaUcGr08FWU/c/9R9BWKotY4K53OzXasRd1NFhio1WZjr8b7j3sfSyObJt8WXyZsYmz53lSBxOpoeKViPgJzFsfVRfKghhMXONGyCgbAqYUvKBn0iOrdowTxs3rw59xqSAEEWkIwnJ0ybs7lHFYk7qjGvd9nhzkaw2JFBXBcxWr8X/vhWGC/CjzFRmdE0srUG8sGHHi7whi0FszSZmP1aqmvUuh/M1K9VTJUSQ/b63OehlLgrNeqrWlFXiXBRo0QuUqdXLe5mouHj3YILOw6Hw5lh+kNJrB2MQU9HYJ+3L57dFETAl8HGkQS01DD0ZIaN+oqnNWYqS6PAyJfO7pHyY8HoZNYf62cCjma4kuDqi/VBzWYhOkWo44XWE9bB6yZZOZv38QrFDTTV79jg9alEhD1gmxThMgv46SQ+lbirFBmyYvrTTbIpEYBjTzsWrV2tBSdfej9T0AyGgS6l/LgrUwzJogItlMFB7gSO90dwVF0E/ono3GhWRrKCka4p6qimLqtt308k5kxxJ1OqVUrBJ6Vhi48g5mnFDYMang57cfpJFyNR/xYSr76IbH9kZmsDLQ0uCc2DLVu3obOD/Acnk7c0sdWxz9U777xT8T0p9UvRVBLetI/KiaFaTIx3iqibICfmtos7j233F3UEF3YcDoczg6RVDW/0hBBKRyC7+6AlM3ihO4SugIp6VxbO+Qq0hAgbDV93e5hzPwk2qo/z2GgigZ2dQOhkFFEj0JI5geOz+dgJjrpIzShdqZNvOR+vUAKQlRInLwEYTY9WNXi9HFYxVKoWrRpxN1VkqJhJNiUTEce2jrYyJ9+cFYpgZPHz3/wf+/uS73yzIIpprkeTkcEx0XU4bml3QXSuV3WxyKqJIssINDYWeM5ZRd3k8WoGvEIKATkJQZEwrsq4e8wHvePDkJcfgz/ed00uHZ4aZeL0vAXn4bqfX8eeSUK2bJSy1oYPi7jrH1PR3rb9AdSZTNtkNDZaMFGCSgYeffTRKd/bnLZx5llnwt/lLyuGqhF3O1PUlRJ3qn3ydtjdRB3BhR2Hw+FMk8FwCk5FYh2rJmv6I9g8EkICfVDqqWB9BK11EjKaim3RXhZto8s7Y++gKd3EjIBpegGzF4EBSZDYxAfCp/i2R74mmhgUIdddWWqcUzlI3NW7MOnkZYohtcrB61OJiIAtUNYKpJK4Kxan1fqJ5W1KLD51lSOOBppp+FCJtKysAO9tS+J4RwiH28NY2D+EIWe6IDq3aNH8fKq1o6MDLperYP4oGTqXEnUOUUdAVuEQDcR0ES9FnHgk1o7ns4sQjEdxTsMKtIvypHS4tRu52lGYVVuzTIg7xe4q8Lkrlw6vZpbv9oUAHnnxEZzWfipa3K1l90clcTdToi6ux6e0NDHF3WgYbEIFfV+I3VHUEVzYcTgczjRIZFQ8u2kUbpuEo5c1s9TqcCSFt/vCiBtDiGZCyIxlIdfJ6Ot/HQ2te2PdKJ0s6QSexpboFvQn+9Hp7WSRuhwGNENn4o4oFjh+ux9ZMVtxnFM56t0CZKodM09emVBeDDXatw9et3rKVazJKyEi/viHP056zLp167By5cqy4s7aKDEd6wmrqKsm4kha0pqWXWaEsHDsRfxxny1YKKcg6zrrbB23N6EnXX7sG3WbbpdCuUidaqh5UUcyvUFRUa8AKc1AT9qGh8br8FTYy7pmacEFexQefyd8gS7oRnaSOC3VjTxTfnuEz23Hfnu1oHdMzTeXlEuHVzvL19wfyXSCff7tvin2RwlxBzGzw6JOKlOeUEncqdntE0NKdYfvLnBhx+FwONNg03AMm8dGWNNCo8eO/Trr8fq2cfRHR/Bm9/N47rHnKAgALaHhr//6C1xOD/Y9+DhIFImxDaPB0YB2X3vRSUvIi7pKTDXOqZqTl+RTACHExBClgWulVNdoqZP/3XffDVmW892XVnG3cSQGQZ6+hYa1NrCWiKMEHQeJ63H66N+xaMsquLUQgnIKIykJST0nZiM927uZTRJl5vua6VcZEnxQ0WBXmcAZy8p4u+EQ/PbFPrwec0Ml2xcLFBk67KATEIzpGESw5nQ4icvkhCderaKOIH83h01kDS5U96c0dmI8HUazZ3I6vCqbmSKRnU5UZwNiFXfbxjIQ7MPw2HZM1EkVyhMq/fgxa1I3B4Nwu7c34OxOcGHH4XA4NRJLq3hxSx+GU91wKApe2JKzMnm9vw/vbHoSjzz4CBN0hJE2WAdeKpvA84/cDVtLJ/MT88lNO2wSW2mcUzl8LgOSLQLR6UdmjMTQeM2vUaprtBIPPfRQQT0cRQNdrgSGRxPwKA3Q4tvHo9U2zmmkJlHXZstg/5GncNOybixwpNEcjSIMOwakZgwlaT30itMfBoeGJt2mahm4FB0NUNGcDSIl6ngu6sEj43V4NuLBVz7yJcyv34S1JebREvuvWIBt4SBCEQNq3FPT/rCKuuNPP55FCl985EXWEWwVf5QuTqVyptWlTHtZ+tMYguTqQDbVAK/fB83S9FGVzUyRqKP9Ua3noCnu/N4MhoaCQMaJjlb/tL4f0SrLE8pBkWz60UPNRg27oagjuLDjcDicGnm7dxirRrbA5cxCFzLYEulGOBXDeLYXzz77VF7UmWgRDbqis4iKHh+Enm3CcESA3Va+O3NnmMSaYogidSTqBLkBgrXmbgYaJUpBM8BphKR1PZJ6HAsa6xGJOmv2mMtPxqiiNlDUs+gKrcKP5vfhMF8MC/rHMOhIY1SVYdjqIYoSFE2BIDlgaDSHtzqRKeoq7Nkw3GoCqqCiO2FDd9vJ+M9nn8e2tL1io0e+EWLCN9Du0DFPaqi4PzZu3Fhxf2hZDe9b8T4cuPjA/PuYBr00jrP4NqslSUJP4JOfPRNOsR6JhIf5DgbchctBjz/uuONYBLYaUUfikcRgtVBN3UhqCC31NuiZegyFgDZ/bd+PWssTykWA6fsxz+9DPCljXKpshZLRctWJomV77mq4sONwOJwaGInF8fDG1VCFMAKuJnbbqDGGkJpAaGwQkWFWiV5AYZosAxj9sMlTWz1MxwqkHGbN0HYxNM5EBKWdwonqXsO6Ho32xqpEnYmZpi2ufXKJGZYGZLNM9alf0FrQTrVo5USdLzmM+cE3sGj0ZXiTwxj3h1ntXNDejL5sAoIiQhBEFpExBIMJuqnEnXUahDs1jLDiQXfTEbjqpTV4K+7EhScfhW3p10o/VyxqhCjRKFHJmubxxx+vuD9efuxlHLbisIL3MQ16S91Wrms0bTfY57K4oYIo6XlXQtQRFBG0vk8lihsl4MqZWtfy/ZhueUK5CHCz145YZvts2VLijppvwgkDLX4Ndc7ZI6dmz5JwOBzOLoTSVXRwp+7UcvRHh3Dra2+gJzyOpU1+Kn9ntze6AqzmbLyECX/p2icDLT5gLC5UPHnpup4/aW3s24hl85fBI01j4LhlooRVDG23QhEKugFLvkTRetSaJqO0XKnaJ1pvs5mBxERnoLy4K+5SLJ5h6xR1LAy+gaWhN9Aa2QCbloQq2BCz1WNzKie46V1J1NGK28UJs2DKRGopJuwmi7vcNAhqhKBPBk2DeCRWB33lRxBuPgiK4scb8VzDSbWU8g0kgVfJmqa4frF4f1D6lTpX29tLe9JVawVi1kD2jGpTR1IFwNPiQUZPF0TqCmezVqZk96uAqn3uZqI8QbdEgNWoHYLkw1jUgN1GdXe5bnL6wNS7BETpozHxEU1kDMxvElDn0/L+k7MBLuw4HM6cg2wnxpJj8Dv8kxoD6CAez8bhkBxQJCUvoP694TWMxMfx0RXvnVSbE8lE0B3qxoNrNmDjkI7FjfX0QvjJFT/J14zZFfukmqJKBe25gnGh7Mlr7dq1zIDXFEOP3/84XhRfZOmwmqhgobHdCiUXuSNRUUrc0cm31sJ8K3Sy9zX7ytc+TVhvZFSUTANaI47JTBJ/u+FvTETkZtwa2NuVYgbCJ/ojWNn9FybWUrIHIUcr5RChT5yJSTOQKKQV1bM6u69gW1jEnU1PoEHOwCUabBrEmzE3Hh734QW1DkGHA59rPASNrsaqrVmq9Q0sa01Txeeq6s7VKfzd6HNoNlSUjaROfK5OPvVk/N9N/8f2R6k0byUqWZpUa2I8E+UJwxM/Ftq87fjc57+B1noRsgREEgbiacDvye2PYMxAS50IRRag6QYWNolY0AIMxWv8DOxkuLDjcDhzjtVjq/HYtsfQ5m7D4vrFcCtudhIhQRdMBZHMJtHgbMBh7YdBFhx4cM06/HttN3SoMPAMTtnnULhkF94aGMSbfX2Ia8NIqAmMheqwoMEJuyyUPKFbC8yr6VIsd/IiUUc1WKaoM09aUURL1zjVGBkqps6FfBqwWNyx2qfk5EaJamaEmnzghA8gko1UPvlq6fz4sUlpwBIRR6+kYVnwFfzvkm1Y7kqis6keqtSEmOKDTp5wRbBAEEu/CjlRVwKyKKkXYqi3CaD4XF/KjoeDXmZRsj5ph+SW8/tjcMsgGlc2Vr0NpvINLB6lJccn+6qxl6jwuaq2WWEq094pI6lW30DH9ghwcZq3EtX41E0l7sz12JHyhGFLBFjXbHAowN4dEpw2gXUrv7U197qSaDCxt3KeVJCWjaQjGE/X3oC0M+HCjsPhzCkGYgN4qvcpJuYoWrdqbBXSmTQuu/SHgFiH//f9y+FyeLBpeAAbB5+BR+jEv1dvgt0uot3XgNe3jiOi/gvRBLBtRIEIGQ7ZCbvYgnqHwA745TDnmN55z51VR7iKT14UxbNG6na0UaIaCw2bzYbvf/drGAllcONf7mTiznryJUuX4vUoNQWBhIU1akSROhJ1DR0NcIvuKdejZBpQMJiI6Bvsw/4L90NLYgBfbx/C8f4w9u4ZwagngdGshHFHa0EtWfG2MNOvJCQKMAzY1TjrkqVnj6sS/jnqwZOpRXgl3YJUbJCJzuL9QVMYVqxYgamgxgXmDWgRQ1bfwGp91dyKing6XvZzRT8oSFiV6uadjmlvqUhqa72My75/Gfoj/fjb3/86baucWsyHy4k7qzitZlJJMaXMh8cSOho8Yv47Tn8vbQPe6VHhcYiTRF0im8CWyBbI0uySUrNraTgcDmcHoAPt031Ps4P2Uv9SdptLqkdPNAVDPACizYetg14oigzNaEJ3OgSvPYUmfxxGNoBk1mB1M2/1pOBCMzp8HvictdWSLVy6EMeccgxefelVhEfC+ZMviZxjjz22ZMTNevJ6a/0QEtB2WNRV2zVazsdrOJqGpgTZyXd4y3BV6dfzzz8f1157Lfub0nIk6CiNXcvJtyANSKljZQRemwrbE3dg6dt/wiHNIjItQURVESF7I7akJrzlykSKaFtktPT29OtEXSTV4/lSo5ChIi068HLUjUdDPjwb9iKo0qmRxFzOuDdnBaIW7A+KylZd01bUYFCtGLLuj4MPW4nnXru/7I8FStFPFS2r1bS3OJLaH9Ih2kZr/lxZmc5EiWJx53LFkNS3RxxrTYfrE9+PtJZBq3u7pUlWAxp9hduw3S8go9IMZ6r7KxR1NDWGSjqcihOzCS7sOBzOnCCUCuH14dfRH+vHfk37IaMaGAoZ2DqqIRgxIEh26IlhtNQLUCh6AxGthp+d6HxKgEUl1g6GYAgqmmxdCHhscNmFaZ20Fs1fxGwnrvnZNex2s/aoUjTFPHmt7R6H4u9AdrwPWjxT83aotmu0HJT2M2QB28YjaPQ5EB0ZwT/v/WdVz7UKi7qWuryoKz755qNYwESdXCFbNq+HlujDAR11ONoVxTHSNjTJWRgQ0DMmIablJjd4pjBzpm1B+4S6X0nUyYIBdzaMxY400oaAkKMZW5sPwWbP3rjsoZvyom9iS+RGbjV25vzdSuyPamrapmuiXLw/Xtu4GTDqkQ2NlBTZJTtWZ8C01xTbLfTZJGUlGljcUPvnakfHhJnfDzK1Jv9DssqZvB655gbR1Qo9OVp2f/RHhzGe0OGTW5CUbLC7SdQZkEUBPqcw6TO9sLnwc2aKOqfkRIenA6Nl3mtXwYUdh8PZLTtYN4Q2sP/p13YsE8NzA8+xA+4+Dfsw+471/RrGYjqcioDmutJNAXRioTFddLAPZ4fh9VJnYjMkQWG1Njty0tIsw+KrrT2KZiPw+OLQEilAaAGkfhYxqZapukargWq4ZHeMRYv6tyXxzGOPF8xDrYZpRYYmsGVisL1yG3671zD2dqZAg7uiqoRtKQFagfBCdaIOAnx6BrIjtx1V0Y6/jzTgybAXJ550EWSbY0J0Tn5tyS1CkIahJZpL7o8pa9qKGiWmO4uX9kcqPAgt44Ngy3XP1sKOjm3LfT/G8t+PUFyYZIUyFTMx+5W+H4ojhHr4kUi4mTWLWXMnKF4INg8bGaenxyGU6I6l9dgSHEEsrWOvpgAavQ5sGtRAX9VkGnDZAW+RsCvGKurm++ZDzxcuzB64sONwOLMeOiBbTwT98X68PPAySwmR0/xYaoz9ct6/aX/mAbaqR2Mp1WafwGwIslmhKjHU5WsBdFvJQfVTnbSoKcN60tJQWwrVrBla2rUEz6efR0L3bq8zq0LclZptWeusUWv36wJ/PR666+8Vu2VnLjJkYKUriUO33Y2OoRdxQssAe8+xtIQ+TYIgOQGJ5rNtn55QCV3XYGSjaNASIEOTtOTE02EvHgv5cMAHLsIvHvwte9wJFSJ+3iYv0mIaWkyFFu9l+8K6P6asaavQKFEtqWzKUlM3wkRdrftjR7tGrY0r5vejZzRbk6n0TIg68/vR4Khn297qc6dpBgTFBTW4GgfON6DH+yAH9iv4QWJ+zyMpHYcsCGB5hwvkJhRJGhiL6tTkjkV+saJtSbGoI2sk05JoNlH71uVwOJwZhg6YlM4YT42z6JuV3mgvHtn6CHoiuS5M8ot7Z/QdGDDgUlzsxLM8sJzV1I3HDbwzIeoavTlRV2sBtVnAT6lcOnlMZZpLERU68c3ESYvSlmTRctJJJ04IiEyuxmuqsUYTJ99KA8sp9fmTn/wE6XRpkVjc/drf249osDdf40XdmTM9zqleVrHP2Iv4zdKt+OWSbVg5/CSgJtCj2rE1aWOROmpuYL5yAkXPHFNOg3Cmg/Al+uDWU4h65uGVBWfgnuUX4ZLuLjw4XoeM7KxKnC5cvtAihoxJ+6NiTZulpi49lpl22nJ1z+qCmjrmc1fD/tjRrlGrVY71+1FghWK8e6LOTOubVkE2OecDORwyoCWGoEW2MONv2kaGmkQqW/g9T2QzaHYH0Ol3skkRsiRgQVOuU5o0YH2FCROlRN1shUfsOBzOuwZFtUiokZXIPN881m1J198YeYPZBtBBXxZl5rdGB086mL898jaSapLdTwdgEg894X5sG3YjixD2aW1Bg70JW4Y1dA/rrFaGRN1Uqc9Sos7EOqi+UuTOtJ6g9ajmpGX9dU+F91R3R3VoxdYTZO561lln4sEHH0JC2x6587ntOPbYY3D33fdstxwp8qmbarbljTfeOOm2VetWoWF+Q0H3q1k/ZprmThUpqnackwADrfFufKdzAEfXR7G0dxQjLupslSEpfqSNDNRssnD4g6FPNhC2vF4dTYNIDrIGiqDkxMbmwzHWchjGvItgCFJNxfVmxHHVK6uK1iMn7szI3YJFe02yKWHvU9Qocfcd1dvTFIuhTCozqVGipv0xkQ6fbtdosVVOKSuU3KCV0mnZnSHqimvuto4YUCmYG+nOL4ORjUNPjiCWAjyu7d9zt9gCv8sOn2v7d7nBI6CjQcBYtHwadncSdQQXdhwOZ0ah9IdqqEwkmFAUjqJsWyNbEUwHMZ4cx7KGZejydmHD+AZmU0EHforCUURuc2gzNoU2QTM0NDga0OZpw0B8AC8MvAARIkaiBraMJuFRGrFF92LYrmE4osNjF+C2afjv/95emP+LX/yiJlFXrbizpi3pxDfVScs0HDa59dZbmWnvAYcfgGcffpaJCDI6JqFQOF/0anYCPe7kT8ItxfDoow/kX+OOO+8oe/ItR6kJBg899yCOFo/B/kv2z5+frfVjU4mJasY5ObMRfDQwjg81hHDE5j8g2jiOiCZi3N6Irek4RIUGdhnwurwIikFmMl1Agbizw2kkUJcexSJnBhFVwqb6lXjDuwA9vr3h93bVJCLWrVtXsB7lxCmJ7TvuuJPtj8Ew0KUUzjJdu25tVY0SZC9j9awrJ4Za3a0ly9iq3h8T6fDpdI1OaZUzYYWSVYWSadmdKepM6LebTRGwuJm2QaGXnJ4chqobGIwPQzVy3/PxqMIifda5rmZzRJ3LKGlltLuJOoILOw6HM2NktSzeHHmTpVTf25ab4EDRtpcGX2J+Tx7Zw04aTa4mpNU0VgdXI+AIFIwBIisIj83DIlBU+E4RPILMhkncDUSH0Tfmgd/hxfwGL6JJYDyuo8mbS61MdQ4rVYtWjnLirjhtOdVJi4RDsc0JnXxTQiov6kqR82XLRYo0NYn7nnwFWmKiM7MoMrRl4xasXLkStWA1u33h0Rew/+L98/d1dnbmzZbLiQk6KZ5w6gl44oUnSo5zEnQNrdGNWDD6KjqDb+GkrgGoBpCUWrEpNdHZSlKdupTJZi6js78bGxsxODg4aXkVaGgQI/DKIlKGhDFHK37VK+LJuA/HHnkinDZnSRExKapW9EOEPOmq8Q1kM14n9kfxrF9N0/DEK0/sUKNEsRjyd/nLPrZ4f8xkowT96KGaugs//83KPxa0NJrrjEkTKt4NUUdQByx1se7V6cK9997LbkulctFcPT2GlDEGPaljYUOuNlCRaYrE5GUhQUdRu7kg6ggu7DgczrShA18sG4NH8bCT/GtDr2H9+Hp2n9qn4uDWg9n1LeEtaHQ2oifWU/VB0hrxM5EECdGEHUbWj86Al72nj2WZhJoLwacSdeXEnd+bwUiqtGlvOUg4FKzHFCKCxIdpB5LDwKvP3A+YDRWJfihevUBEmIa51Tr/l5o12tvbWyAqyWzZakRcLCY++OHDUN9aP2k92m0ZrBx8AnuNv4a65CAkXUVSdmFLygYdAhaxWrnccvYO9DBRZ2R19PcPQJZlJuzyy0nTICjVKmsQRQmqtwW3bFLxTGYJ9jngM/h76JdQ/FLV6fBiKCWe0BM1+gYWzvolK5B1PW8jmUnMqL9bOcPlUvuDmoZszpkbr1X190NGwYSKpvo0+37sbFFHJFIGlrZvNxTOIwD2ZhEedwLZRBfUrA2prMFq6DyVyzR3e1FHcGHH4XCmBUU63hh+A5vDm+GQHSzSNpoYRYe3g51ke6I9eK7/OVZXR+nUSqJuPKazRgdr7Qt1qyXSBjwOgdkQjCZH0B8bQibZDr/Tw6JzNVFjLVopcbdtLIOhoSBa6m0IOP1Vuz2YUS9iuhMlolEqZqLmhHbYm+fB0AaQDZKxslFgmDt//vwpX6vaWaO5Wr+zWAq5OHJ38FHHwxHwoM7mYOthE3QsCK/CTxb04hBvHAt7g9BFBUnFB5U8BA0DOoYLXp+icxqlWLN6vqaOukwHBwfgkXQ0yBrznotoEvpbDsH4wqOw1bMUv3zyOkBKYn5Wh62lE3p8sKp0eClGoiPT2h9mAT+Z9pK/Wyg+s6JuqqkexCmnnIJ//vOfbH/0heNQ0nG0uGdmvFYt3w8zLRvPZDE2FGHfjx0RdYPRCGT44fN6C4435DVppr6TmVwavLmu8FiiGRrsrXYIdgEHd7YgkrSjd8xgjRQt9WJBGnYuijqCCzsOhzMt6EREBz/zFzXVxnX5uvKRNqqfoxOFz+ZDX7yv7EGSDtCreykaI+CABbkZjSm6rUdjsxrp4J1FBKFUDG65HZm0B+31Kn7yk6vY8611aWWxzrasshZtEmIGgn0YyDihZ+oBpXabgx0dE0bjtWgSA0QyYG2GofexCQkmf/nLX6bcJpVmjY6PT555ub3W72f520Q5itYOJ4xsHerjIXy2ZQQnNUSw/9ZbMF4fQUilEV8tLMJWCjpJm+lXq6gjcdigaHCLOtKCDKPrQFzzXD+ejXhw7slfY+tkplIFMQOR9oduh55tAgxhWiLCcBg7tj9so8y01y7Mg6FTerl638Fa0pbWqR4mS5Ysye8PQY7AyDbAUO3vrqibgPaHZBsBkp7c94N+pAm1749gMgRR96PJ40UkmZtjTIzFDOY3Rz/yKP1KP/w6GsQCQ2FN17Atuo2JuvRAGnUOJ1rqZbTUGxgJa6ypaq6LOoILOw6Hkz+oUsqUIm5U91YppUcH0DVja1iXZ3FdlQmdoEjUVTpI0gmeulnDSfJyMLBpCNi7XcLGIQ3BuI6WOgFjyQjG4lF4lXroqpvZkFBdXdUU1aJN56Rlnnw9Nhs6Wv0YCmHyoPqdLurM9TCQGeqFaGub0ueu2GOrkqgjnnnmmZKvY00J0nq4vQKONrqxT+hBtEQ2INs+hqRmIKrUozuVi+wFJgQKReo2btxY8HqxVCwv6gTdgH8i1UoGxIMZBX8f9+GpsBcHLjsdd4zeNnlTTKyH0yYjPbwNkmv7oPpqfAfN9aC05ZLOJXhOfA5RbI+qVoNZq0mF+Xu3tCDokuFtXIzo6KaqTaVrqUUr9300P1cddW5IghujYZVZoVTrczcjom5if7hsMrrqct+P3GzZ6nwgrelXQfNjfoMPTT4Ba/s1ljpNs2ZjAYtaRHa8YO8pAG2WEV90TKLmLF3ScfM1N+eskCYg8edzynuEqCO4sONwOOzgTl2rq8ZWwRv0Yp53HvYJ7MNSqKXoi/WxVGuLu6XmgyTZkdChnlKpo1GDpUn8LrInAXpGdSY2esZ0NLgF5jSf0ELoqKNaGx97PjVKjIb1qk5eOzrOqdzJt81vFA6qnwLqfqVGiR0RdXUddQU1XFp2u/VGsbijZg2qVbN24U4l6qbGwLKGLI5tjOJ4+zhW9vaz/RgRPdis1gFaFgtL1EUWw9KvmgqXlkWDokIWgLAm4d/BOjwe8uGlqBtpI3fCXhqPTxpDZl2PRnsjoBYPqp9aTFi7RnO+gYW1hNOp1WyrN3DQe/bD088mqzKVnpFJDEW+gTQqT81ObqjYmaKOIvXW7nC7TWLfj1pMvk1R55bqocPDvOUavLnjA5kHazqwtFXE4jYyEDawrl9Hk09kViVWUZfUkljoW1gg6qplrog6ggs7DmeOQwfvlJpiByo6eZRqSiAvOaqVo/Spqql4svdJZjdy7Lxj0entZHYla4Nr2QGY6unIU466VcudCEo6tBsGhsMGuod0ZkNAI6sSaZILBhy23EmN0ixbR3R4nAJS+mR/N8LvrvLkNQPjnMqdfCeZtFZwaSURYbU0mW6k7oCDD8BT9z1lWY9CXzWrmCBBl0wmZ0TU2dQE5o+9ieuX9WClOwkXNMRVERFbAJByn6UFXR4WSaUTcCXsCtCgZNBsxDAi6lidcOGBYB2ejngwmp38uSwe2VW8HnkxZBlUP5WYoJnCphgKD4URcAdK1hLWWqtJ73f4gYshSRJeevn1ipG7UpNKaqWcbyB9r0wTY2qoaKrfuZG60TR1h4vIhtIF34/ibnL64UZdrFnVYMbC9Fmg/7ebKNcjlfSiIyCiqS5nSbKwWUQoriPgFTGviY5fOWsSCkRTIwRtcy7qJsOFHYczh6GD5lsjb2EoPsRSOdRVSsbAJLYCzgB7DIk+itbJgsxONAOxAZZCJR+xZ/ueZRMdtkW2MQsT+iVMxcl0UmAeW1WKOqqZ2zykoSeoQxYBRcp1E5IQoJSLNWXisgFxtbSoq/rkNQPjnKaKqFhNWsulAc3IkCnqigvgfT4fjj322ElWKMXrQeL0wCUHoum0Jtx///1IJBIVxd2OizoD9eMbMfCvX+E4fwRLmz0IeeMYS8sYyFIkQ4BHlPOjixQW3BCQyRoQRAWGdZSZocMvq/DbdfbWgykZQ0tPwH+9+gbWJLZ3xxZD24YsV0pFhkqtRzWm0q+veR3PvPZMXgyRlyBZulDErriWkIRecRSvkmkvQe936H4L0NbWjlv/fgfbH2d99JSC1zEnlZSzZqmGqXwDzQaXUAKQFR0eKv3bGenXBjfiSRe0dD1Eh152f/QFDfa9dztENPpERFMGq5+LZiIQ5Nz3PJ32suYpEm5mg0PAK2BxC0XmcpYybN1FAXu156TLbBF1sWxhU8uuhgs7DmcOYhYRvzX8FjMEJqsRgqIM5DNHFiQkzOiASifMwfggOj2d+YPkorpF7CAZTAbx2vBr7HHz6+ZPeRKig+SmUDcUuDDfP48dJGOpXHPEaJTq8VRc+/PKTQ9TibpyJy+K5BWffBvtTTutS9HaDVgqDWj1EzNPvtYC+E984hNs8sRUs0attYEkPsin61//+pd1S5SN3NUq6mjE11F1UZzkD+Owtb9CujmImCFhRPGhL5mCoZV/ARJ3rKRPoumsBhQtBZcag6hnEVEEPJGsw8NDXjw/7saXTjwZaxI5U+BynHjiifnavu2RocL1KGX0W07ckah7+JmHJ0W4KEJHwouE3OLFi4s868pHgMuJIXq/tnohP36sua1r2pNKSvnvWWs1y9W3mt+Pehd1nBtQ7ca0fBwrfT9sTY0wNAlLA3VQg6sg1e/FutjrLF9pEmONPgHdQwb27hCxd6fMfrxpuoGNo6N4c1sUSPuRMjwsAreiUyqY/kACb3FraZkyW0TdSGIE8ez2koHZABd2HM4shoRYqdRppQNuX7QPG0MbmVijgzYdsKwnEKqbowMRmf1SJE6HDr/dj95Y76SDZIOzgV2qPUiuGV6Pq665C1rKj8u+dQGa/Q5sHdEQTRpo9gnQtepqbaYSdaVOXoDOOuisjvlkwVIrNdc+lUgDUm1gKT8xawE8DZAvVxBfqTaQIkwltsQkcUdditWIOpr3cIAngePqIziqPoqArIL0G1m7xGGHIIvoFO0VRZ2JXVTRIkbhtgFKJo5xTxtedS/BVatXoWdULCmyS9l4nH766UzEkpgxxZBcpW9gqchdOBMqiNSV4qGHHsIFF1xQUWRTiHJK094JcZcfuRUW2GxZ6/6YrjVLrQ04FNmWSRSHkatJzYRq9nEseYyJjMLQZCS3vI4VHR+HFt0GiDYWhfO4jIIZzeSnvXKeiP3my3mLorHUCDLiEA5d0oLxkA+ZLLC8S2LWRtUwW0TdcGKYXdyKG7MJLuw4nFlIPB5Hw9IG2Fvs6HmqB3XeyiKH0qkUoVsXXIex1Bjsop1F5MoJGzoQmQejHTlIUlcrDc9OaUlsHO/GcNAHXe0E9CgGqHM0qkKWgOa63OxWvcS5yDTjpZPW2Z85m822rMUx3zx5BaM6RhNByHLt6VdzGUhEfPKLn6w5TWaKiZ7RLH52w60QpGGce9anp+0nZhWnxethTU+WE3eyrwOibRhGJl1WDDUrWTar9YP+MBY7U7ALBsKaiK0pG+tOFSQBgizAUA1kkuUbAQRDh12Nswu9TW8WuHu8Gcpen0e/tx6SkkTP6JqC9WAzbivYeCxbtmzS2DbWKFHlLrWKu40jMYQiGxEbjlXcH5FIpMCgecetcnL7Q5GNSftjuv5u0+mqttakSr7p+Tia0P4gL8lU2oF07wbosX5WO0do0a0IeIFgzMiXV6QpNQ9gfpOUF3UkhOiHEwlL+o51+nK1mVRvt7uJuqHEUG4UIh0EZxFc2HE4sxBKjzq6HFAaFPTH+/PCjg4mlEY9pPWQ/IGZDvhPbHuCFWO7bW50ebqqPlDt6EFy87CGLSNpBNPDcMp1SMX9bPg29Cw7uFOXXjUUz7asFYrUkagji5RO3/TSr7WmyUqJCZczAsnlgJZohlspnyYrh5kmo5NvOXFaeRqBAT0zAHfzImTTbchQJMXyEoqg42BvAifUh3F4XQx1koasIWAsKyOhb39dq6ijSN3o2Nik97GpSbi0GERDQ1p2oztwEDbVrcR3HvsXEoaEM911iCRQcn8U1JyViVrWOrat5P5wxTA8mkAs4oYWn7pPtDhyuONWOdQkRClZFdAn749qoe/4jkyU8FEUzRaB6PTDZkzPx5H2x2B8CMmEE0ubfFAj3YUP0LNY1Cxg3aDAOlmp4SGUMNDuF+H3lBZ1BEX3pCp37WwTdS2uFtZVPRwvNN7e1XBhx+HMQigtqvgVQAM2RzZjr+a9WMqUmhw2hzYznzmyI6FfimuCazCeHmdNEbUcpHb0IEndahsG0xhNjkIW7AjF/ZAEnZxKa3qdmZhtSWLI7shggb0FkZhQk49XcWRoumkyWo+kHkZ2vA8QWjBco8+d1UKDlqEacVqcxsyJUwmH7DcPTz26jvm7UdSoQ4ri2PoIPtQQRpc9w6Y5kIlwd8qGXEwFZUUdYdYBkoFwQNHgknTYtCSGPQvR3XgQev0rkbDVs8hnwvg3E0MOewoNrnasXttfcX8Ue9xZu0ZrGdtWen+EsKCxHltisFjTlH8xaxfuTFjl0P4IZkbYZAwyUTb3R63rkesandwoUarG0FqXZ64Hfa4ghJAZU5FI2ZhlkFmTWg4yDqfoW52LfqBlmJDJZBxor2vAXq06E3LF+N0CVnRJzFx8MKSzJqmuQG7aQylRVwuzUdQ1u5rZj7DZRs3C7rzzzsPnPvc5HHnkkTtniTicPRw6qW0Ib2AD0bWohsHEIKuHS6pJVhPnsXnwxsgbzJqEauW6Q91ocjXtkKgTNRGnnnkqu+/222+Hw1F5oKKqGVjTl8RgfAwtPgnNLkqTCegdy1bt7TYTkYhSfmKinqlohWL6oZkNHPTc6USGrOa/a7eshbfZmzv5RhOA1I+sKlQlJkpZaIiW6FklrGnM0886Hfc/dR9bj4OXHYQmyYvIK4/jyNYRHOwYhE9SkdIEGHVt2Dw8VnoxSog666xW3RAwmFVw27APS474GiJ1C3I+FmW6Rt12G2575cn8/igl7p54/PHCZbB0jVLtZ6VNRyPUqAGlOOpXXKvp28uL55+vA/USl9sfBV24M2CVU1gbmAGMfpx7wXehGxL0fD9xZazr4RJrFzJm9yt9xs3aQBJ1Zk1qOXEXT5MJuMFE2baxNJLGMHuuVw5gWZsCrzNT9j3JX27lPLCGKRJ6VCoxV0XdbKVmYUcdRNStRB1Dn/3sZ/GZz3wGHR0dO2fpOJw9EBJvFAVTw5S+yZ2DKP0aTUdZXRwdrClKt7R+KTMoVQ21puLdUgfJlJaqaRk3DiewdiSIJq+4PW0pgA1GN7sBqb6m0qQvOmnF9XjJSERVlBBDP7niJ7m77GS/EEDYdAUpw3QjQ2vXrs2b/1Ia+d9P/BsOw4FjDz829wAtjeY6I+9zV0nclbLQqDYKYAoaEhH2gI0JkK5UDAcNPIyPZ16He+kIxsdDGNfs2JySWYR3kacOKCHsCkWdDpeYi87ZRANhVcKjIR8eGffhhYiHGQhf4u6EUiTqrLWBtB4kvKLB3vz+KCXuopMijtvT4RrNkKpAsV1JuQYc8kk89vCV+NejL5fdH/ku3BmyyplcG2iw78dYPGf1QzWApoVHKYrXw+yKrZZyliY5MVde3JGgo2jdXm0imv1pDKf7ER7zwmWvx4IWCa1+AZkpBmtQGvbAhQKzOKHPBBd1s1zY3XnnnRgbG8Mtt9yCm2++GT/84Q9x/PHH4/Of/zxOO+20qWc2cjh7EKYxcLWdrdTJump0FZyyMyfq6CDpCLBJD+Qr55JdGE4OY753PkvJkiCrNP1hZ/zy7R6J49Vto/DaZbR5CtOW1m7AwTDQpeQGdZcb50SNEtONRFQSQ9utUCanZc3C/VoiQ8WizqwRs3YpRuKRAj86u4zJNiQl1qNYDNUKrUddg4D9YxtwiH8z63Cd3xeCKtsRszdgcyIKQZKZyEQZAa/YZWjQIWsa/KIKj6IjpQvYmLTjofE6vJJtxUYSvlOIiOLaQDNNbO6PSpE7qzWLmQ6nIWOVUrbFdiVtC9vKdlXvu2Iv9v9jz71TELmjSB2JOhKG6Ux6RqxyykWA6fvRWi+wbt1K4q7W7vBipvKpKyXuyEB8LJrraN27Q0JjXQpboluwsMmJNmcDUlkRi1pyHnMU0b/33nvzr2f924Q6XHmkbjeqsQsEArjwwgvZ5fXXX8cf//hHfPrTn2b1Ceeccw6+8pWvYOnSpTO/tBzObgIdmElA0fQGOrAe2nZoQeifRBr5H9EJgLyo6ERG3awvD76MtJpmYs6EJj1QfV08E2eizkwDkNgjAVitGJhK1AmKF6KzifnOlcrE0oF/3UACr2wdg11SsLChsUzaMtcNaJNLn7yKGyWmE4moRgzlrFCMSWKCRECtkaH8axpGQaRuyi7FCZ87U9xZB1RU0ygxxdKgProZX1s4guOdISwbGMCYL4ZgVkbQ2cqiT7TP2CO1FATJwS7FQzLoY9leZ4cUC0IXgOGMgnvG/GxW61txJ6vBO+WUD2LjP/85pYgorg201qxVEndlJ0pYeLwoZVvMw08/jFPaTmHF7OXEEIm7+fPn41d/vIPtj7NOORJLFudSucWfqx2xyrFGgK0dk2bquJK429mirljcUTc5pV5J0DW4RSxtE+F0pNAd2ZJPWwr1ItQaOlcJLup20+aJgYEB5v1DFxqjcvLJJ2PVqlVYvnw5rrrqKlx00UUzt6QcziyEDuR0AKODJ11o1BbZjpDoovo3j+JhETg6QK9oXMEOulsiW7A+uJ6dREjg0XBrehyd4En8dXg7mAmtFXpcKBMqqO3o8FRfAjGVqIskDciN+0F0NOK1LQbmN6to9olwO3Ida1REvXU0iXcGxuB1SFjgb2Ri6KdX/rSM2XDptNNMNEqUigyVY6R/Y35ChSkmrCJivGccnSs7CyJDlWCpxWi0Nj8xi7jLN1QIRs2NEiZkK3JKYBwfCkRw2OYbkPEGEc0ICNsasCWVi5A1l+g0NcUdeYZRXZxLUNFo15ixsMPegHX2g/CndyJ4YkhEQi+sP1qyZElVIqK4NpC8+ihVao7pKiXuXF4XVGd2Sr+9SR2rFmh/JJFEYiyBBYsWVNx+TruY3x/2ui5m12Ogts/VVP6H1gjwjTfeWDJ1vNdeyyaJu50p6qg0gr7Lpu0IkZvwIEISDCxpETGvUYIuJEvWok1M/asKLup2M2FHv64p7HrTTTcxQbfffvsxAfepT30qb5x522234ctf/jIXdpw5DR3IXxx4kaVEzXQr3UZju+igTCdsanigrtZn+p5hYooO/CTqKBpAB176nw7GJAIdcLDGiGJIAIS0QlFXC6aoi6RTULILkHE44FIKu1tX9xoQFR/0WA9sErB5SGczW+2yAEUWEIylMZYeY7/yyb6iOE1WiuK0E1lPRHegUaJSZKgcFOUx0rG8mDBkAbI7lhcRjz36GFauWFn1MpC4qNUk1iruWEMF1QMqIzU1SpCJcGt0ExaH38a8sTfwoXkD0EUBaakOm+K0MwW4xakP55KeRJ0WgtOpIW0Y2Kw58eBIHfZ5/8VIe1qw4oA07q8wUstKqQkGxbWBFAk77rjjClLUVnFH+0N1bt8f0+l+te4PI2nUtD/+euv/AXoGnzrvBNo4NYvscqbW1ghwsSC1po6t4o6+H9TFOxOirtHRwpbF2uw0HmcKFo2+nLijWjryjzt0qcx8JklYzoYGA94osQuEXVtbG+sGo3E4L730Eg444IBJj6FfI/X1ZSYPczi7MXTwJFGT1bJ4ZfAVNuGBRnGRmKMDKh1MzYOheZBscjQx0ffywMuIqTG0udtyNXQT0OuVGw0k18tM2HXWd+7QQTKUTCEabMevbrgNejqI63/yNbQGHBgYN7BxQEM8DejJIfYcl11AnUdkY39SWSCWTjOX+GZf7QPLc+IOzCSW/MQ666fXKDFVZKgc1hovEhG2QBP0pIxsaISd5OgkS1G49vb2ql5PcArTMollaGk0+jTIPhcgtiJgn7pRoknJ4hhmIhzCYRt+B1lXkRTt6NEd0FQBCxTqVhmrvMxURyZpaFByy2vYHPh7tAvP6B14fTgBNZrEJfYGKEUeeZNGahW+aMkJBsVWG1azYSvl9ketFItsa+q3KnGX6Ie9eR6bDrGivQXbp99utxIxzatrmVRSTfMLBUZo29CPH/P7QdYsVYk6UYEg2VgUTpQMCIKR/340O1swFlEQl7cbBZOoa66jyBzQP66DPoKJjIF9OiR0NebWmYu63a/7dcaE3S9+8Qt87GMfq2iH4Pf70d1dZF7I4eymUNRtKD6EnmgP66CkmjcRIvOao3SoWYvjFLeLteKDJEUuIpkIFrgWVC2MSNSRlx1FEXZE1I3EMggH56N/lArGByA6/FjdZ2AsoaEvqMNB8xxL6EqquZHlNJKZITiV2kWdCY3XUhwh1MOPRNLBxiuZs0ynm16q1TuK0q8UqSMRoWV8EGzZfI1XpRSfFUqTuQIu1v1KjRJTMUkYCEBUo1FMA9CTzQjFbfA4CtUMPY5MhK/63Ifxg3l9OMIXYzYjZCKckL1QJRtryNF0AXqW4l7la55kLQ1HJoJFjgyimoSnw148EvJh6fu+gBvf+D8YmguG4GPWLDvSjTzdho9y+6Naz75iUUdNEJT6rWk9vDrbH265HuNRBQEyEp6B8XMlJ1iUmHRBPyrqW+u3fz8SbqTtpRuO8ottq8N5n78AdW4FWRUIh3So4igEKff90FT6XFFtHxBJGLAptKoCFjSJcNtpTiswFNaxpFXkom4OirppCTtqkuBw5jJU7EwHbKp16Y32MvuRaDbKonKUTqU6Os3Q0O4ufVIr98uXUizVQtEQEnXZ8SwTdtMRdRuDW7FtTIOW6kImK8NlVyHRgT/ezw7uPaM6Gjy5FEw2K+z4zNQSmDVDDY56VqpRq89dtYXglSgszB9hIsJa4/WPf/yj6vWgwvwTjzyxYoqy9EJYLDSCcRh6HzIqMBgyEHDnxF2XPc2icyf5w3jPlj8j1BBmJsJbUjboELCICvK1NARBnBB1k5FgoEFR4U9SqlZByNGE/+038GTYi560nYkhdbgPWkyFFu/NN3VMZU2z4+O1qt8f5TjmmGPwz4kGjlLpcOpsLTfFotJ60P7o8its1u9QDabSlb4f1f5YGImOAH7kvx/0eSjXLUvpVNHVBkONY3mHgK5mGamMhue7hzEWMrCsOff9GE3oaPSKzE/unR4V0RSwsFlk33XaPjSTtdEnoKMhZxzMI3VzS9QRfPIEhzPBeGocbwy/wSxH6CBNYoKEhc/mY2bA1QibmTpIkrAjUaeGtkcQqKHi7LPPntJEmETdqqEebBgQgEwzbr3p1+xk8JWvX5T3VatzAnZ7+fWZKVFHPnVu0Y1f/uyX7LYLv3lR1T53MyHqPHUeZOzpghoua42Xy+VGlCZFTLEe1oL2ur3rWH0UdceaTQEERYyOPfbYgnoycz0mW2ikcdvN18HjacbFJ+2FKxf24D2eBLyyxkyEY4oPm1Pbo4K0+TNaGqIowUYvVAClWnX4U8MwHBk2Hmx10xHobToIvc55uOVfVxeIoacefCovhoqtaSru5R0erzW5+7V4f1QSd2YDR6lInWlXUg2lJkpsn/WrVfXDY6rvRzUpYVoPw2EU1NRR2UKpblnqWg1GAS0xAC20Ae1+AaKgYyS9DS5XFv5EJ5SJmjoaEkLCrr2B6uhEJlipKcIUvU6bwGa3ElzUzT1RR9R+tJ5BfvSjH7EPm/XS2tpa8TlPPvkkDjroIHZSo7bx3/72t+/a8nJ2f+igHsvEcqnVSA9LjxIDsQE80P0Anux9kj2GInOtrlYmzihK826KOjq4UDTEKuqqhUTdG329WNUD2NCMjnqFiTqrrxqJO4pM6MW+FzMo6kyfuuJCcFGYWAYtw8TE/2fvPeDkOsuz7+ucM73PbG/qXbJlSS6SbcndBoONKaGEAB95TUkIxXy8IYZ8HyEfwRhIYtMCGAg45IWACxhs495xt8FVVtf2NrPT6ynf735mz+yZPrNFWq2eP7/F2t2Z2XPmOeWau1w3ibuFjNSpTrViYT4TE+kgtuzYw3zuqlGtS5FExMc//vHC91Rz/MlPfrKsnqyyhYaG9fYUPtbej5/1PoxLDv4Qu31pZDXgUMqCoawF0dRMqpl5P5tFFqlj78P0DdoqqPBkQ1htz7IRX4PutfhKfzfev3cVnlz+Lox612Hvvrz3W/WGj2JrmlrrMR/jtUpFXel6kLirtR6l+6G/782IOuN6GPeDRFQnLfH0h5+5nB+FCRY19oMmlazpXVN8fkw3HJGtiL4e4QQZBgNrOgF58s/QcjGWMdC73De198Jrt7DH5GQNJpMAtz3f8bq2S8Kpy0xw28sjmVzUzZ+oIzuqxcRxj9ht3rwZ999/f+F7sk2pBtXtkaXKRz7yEWaQ/MQTTzDPvLa2Nrzzne88RlvMOdEgqxAayRVMBTEcH0Y8F2cXZxJBJODIM44sSMii5PSO0yt2ptZjvi+SHpGK4psjlpLx5+FhHJkQELC1otNjKcz4LO0G1NOAFCGgm4mO0bR3LqKutk9dsZhodWkLln7NpXJVuy1JTGxc3Ylnnq0cKapnPWFsNKDartI0YKlPnVvNYX3oWXxnTT82OlJwiioSqoiBlBmy6AI0FRryNjejY/lGFnr7WzvbYLfl/QpFTYUlF8MqWwayJiBm9uEHwypLtb7twr/GXb+9YWb/NA0PPPBAA128M9Y0JLbLaiDncbxWre5XY+SOxExbib6jKSul+1HpfZ+LVQ6JOz2KSR9+elu0ooaQRj/0GI+NUvT1OGf7OexDY7WGI4rc9U8ocNkFnLbCjIBDIc8ath5kqaRKasG6qMUjYzikQjYJrI5OF3LU/eqt4P/NRd08ijpVZdeJxcRxF3Ymk6lulE6HonN0IuuzETdu3IjnnnsO3/zmN7mw41SPYI3/Ca8HX2efqmhyA43fIjFHF2W6Wbww9gKz7iBRt1hmEJb62BUQLRDtrQXjWb325sBIDq+MTiKWFtDnC6DFWUMMKRkWmaAUDd086CZClJr2zjb92phPXWUxUclCo1HeeOONov1oxEKDbnqlPnf6fszFT0zvGtUEGacocVzTPoILfFGsG5jEpCuByZwJo1m6/E6LEm3GQJj85oyRuuDEJNwCsMxrhd1qQkpy4s6QFw+EvTj7/M/gP+/Op7mNM1sJKsxPqsmGunj1SNFgEMWpyHker1VvPWYmhgAmswqXxRABzh0jq5wqH35mG8l2ub1Iam5ouThEU4xF6kjUbdu4repz6O91eDXsjYPNa+3yC8iQ1hYAa6eVbcs6/7rC9YpSr1Qzm8xo6PGT92R1sctF3fxbs8hK89mVJS3s9u/fz6wGrFYrzjrrLHz1q19lKdZKPPnkk6yWotRa5cc//jGLCvBxZicX1B1IUJdqtYv5y5Mv45XJV9hJWyra6KSkmawOi+OEGSwtkbWKZyWm4oBjugl3KCTjuf4QTOYsNnS0wWaqL4b0miKKmJG4c9kyZeOcmiGbzeKb3/lmU1YgZWIiOVzRQqPap2SjgFmxYgWLTjUj6nRKa7z02sC5iLqeVg2nTT6F05OHEEiOItoeQlQWMWVtxZF0osJGUHfmjLiDloHFrCEgZuEQFaQUEU+NCgituwCZdRfiK/fkS1B2GrzrSicckEBudj2Ms35TuUq1gZXMqBsfr6WvR2mHa/nEEOTHXbkkfPJ/f5KJbKrVPGZWOSUffvzuLCbSsytPuOrdf42f/+TbMPn82HXepTh1zaqKkbpSoilgebuINV0mFpWk9CuJOsEqsJGCxuuVzyHAYRFYLZ63ZParES7q5l/U0VhHZki9iDiuwo6E3M0334x169ZhbGwMX/nKV3D22Wez6RU0tqyU0dFRdHQUz8Wk7yndNDk5yTz2SslkMuzL2GLOWZyQN5xZqn3D0Cc3ULfqwamDsJvtOKX1FKz0Fgszeq29ob14aeIltNhbKoq6uc5MXeiLpGANQLK3MT85Ip3VIFETh8WNwZCGrhbymVPwwsAEBCmHFf6ZLsV63ltGcdcfzGI4FoGWE5ALZ2dnaVIhTdYIBTGhZpmfWDIrY3mgq6aoo1mt+lgv3c3f4XAglUs1LepKxZ3Z24ahSKJxP7ESm5LrP/wmfHntCHY5Y1g+NgpI5CfmxsEUhZ4EuIUax4imAkoKAasEn1mBqioYTUn49ZQPj0Q8eC1pg2dsFB/bVNnz0Djh4Fd3/IpZs8xmPVgq0tWNA8EYBIuVdY3OZbyWSTCVrcfVV19dyLxUMkL2OQWYzAKGphIQzDH0+nyznik8W6sc4/kxNhZCh695USeYnDDTXVY7BEHwoav1L2BG9RpCEmYUdaOudZoSsaHTxJod6HpF6VcSdZmRTJEPJmGzCGihsC418VSopyO4qFsYE+UVnhXs+reYOK7C7s1vfnPh36eccgp27dqF1atX42c/+xk++9nPVnxOaT2F/im1Wp3Fddddhy9/+cvzut2c+SWRSMC/0g/7CjtevvtlLGup7kVFs1fv77+fda4ucy9jacOnR5/G/qn9TFx1ODugQcNrk6+xmrmALVBm/nsiiDpWBO1by4Rdf1DDRgcwGtHYPFfyopuIkheVjIOhETbofn1H66xq0SBmIVjHgbQVaq4N0Jr0NJuHNBmN16JJDGTaq2TbANVCvh1VRV0lq5G5iDodSpMJJgs02QNVdgMNvp26TcnlgQg2H/4pEp4IwlkRYTavVZpOm9eqA9NYvV2LWYFZ1BAVLHgo2YX7ggE8OZ5Biga4Gj6YVvNI0yNgeg0Xjdeay3oIQg5qtp1Zs+iefM2KutGBUTx5/5Nl63Hw4MGaRsgUcQz0BCCYE9ByXqiyE6qp+ZnCc63VLJwfWTvUrA9w0Di4Rp8sQLB64XZGYHIlkB0LY2uvC8NhSvGS0TnNa81PdtFLKuIpDb0tIjMJJ39Jimjr1yuqqfvpv/606vWqwyfCJKpM5JXCRd3CTcagYAQXdjVwOp1M4FF6thJUi0dROyPj4+OsTq9ShI+49tpri0QiXRhrOqpzjjlZJctEnbXLiufHn4fXlS+6L2UiOYGnRp5iJsGbWzYXTkpKa1Cq5s+Tf4YYJOtgkRly0sxVEn4nmqgjBkJavpYuG8ORCcDjUDEUAqvTgZqDIGp4vn8csYyKXm8b7A2kX6vdfF0WC9rbvLhPrN0NWLNRwjz7iRL5LkUN2bFBOC3mqj5e9CHOGKnTmU36tdp+yJEgerzOfBoQ6vSg9HIschLLgi/N2JRICjKChIjJjf5kigXf/HUiO2ZBQ8Akw2VSWar1jbQND+QCeCzmweCUDZKjG7BnAVbvNrNTxhSmMf1q3I+51KLl068a1rR48GA205zPXYmou/f2eyuuh+5HVw2KOLraXTh3+7lYsawbL+8dwItPP1SxrnLLli0LIupoP+haQ+dHT6cfY+HKDUelkECLJDVIzi5AjEC0jRSsi5a3CuhpNbFxXmQSTAKvw5sPTNB0CPKe29grFWrkmrle0XPpqxQu6hZ23FmzZuknRY2dEUqZvv7669i9e3fF31NEr/SCQGNZTj/99Ko1H1S7R1+cxcvR2FGYW8xID6XZTf7Z0WdxatupMIkmZgpMqQ+6UFNkjiJ2m1o2FZ2U9HuKzNEXnWT02EoX8hNF1E0lVAxMUnowWrAqOTyRH/ulkT2LAOSECUzFJfgtbWhxWmZ90zLOtiztBqx18yptlKg2Eq0UoxA5cvQIXJ2uoi5FvaHCKO5qpZXnU9TpYkhPA5aJO01DW/wwVgRfxPLQn2DPRBD0xjBFJsKKDZooYLnJwURdyU4X/plOJuEzyfCbFLapY1kzbg/68Wjcgzds7ul0OO1HvoBfNxDONzNoZR5pxujdfIg6oxWIVTIXtuHl/RPYtrELtjqT4HVRZxbMFSN1lThwIG/JUrof8fE47rz1TuzcGcTTL+4tWKEYu5fJM5A+2BvtTuarq7q0O7zLnzcP1huOKp0fqWxe1NEsZjW3D5JtCt3OdxSsi0jAuW35rlWvU0A8TY8HnDaNHSY03ms2oq4aXNQtrhm2J4Ww+9znPocrrriCdbpS5I1q7Cii9qEPfagQbRsaGmJ1eAT5Rn3nO99hETiyPKFmCmqcoBobzokB3diHE8NsegOdXHTR3Te1D2qS6ovApjmQvxz5zNFFkC6o9D+6YdBc1g2BDTVPytIInc6JcpGk+pp9wwpohrgu6gJOIJzSmDeV3qWoIl9T5zBbGnfbr3HToq7gelYopaKOfOqaFRGFOjABuO2e2+DwOLB72+5CYf5MQ4WMf/uPX7LtueZTfzuvoo6uOfoHxGq1gXkxpzJx58hN4dT0K1g9+Sz8ySGY1Cyykh1RaysOp2MQzSJzBNVyKvOaM0LRtfGJcThYqlWGJXwUOUHCw2Ea7+XFU1EnRLcXWVuxiTJDKRd3Ho+7yCONyhiaFXWVatpKrVloPfJrlbemefjBe/HMM15cePYWnLJ5XcXXNXaNpiZSiEUbqzt66KGZSFyl/Xj66afZdaOaibE+c5XOg/m0yintDi9tOCo9PyhSF05qWNMhwu2J40v/34dqWheRLcmqdgkv98tsJjPNcm2drpM7Ua5X9eD7cRIKO/q0SQaT1PhAXnQ7d+7EU089heXLl7Pfj4yMsFoLnZUrV+Kuu+7CNddcg+9+97usm/Zb3/oWtzo5QUZ0kX/cvtA+HI4cZt9T4wN1E4WyIcjR/CdaitKt8K5gHWB0kabn0oWFvkjUdbnKG2SWysUlnFDxcr+CfSMKOj0zKmVgYIB1imcpHWYY5+Syzd9Nq5YVSqm4061AyKeuloigc7e0w52lEQ0TDKLDUfz+6O9rdmdm5PmN1BknGFSqDaTtXrNiGTbnDqBz6nn0Tb0KtxYnk002r/X1/iDtCVatchWJutJIXTIWgRwaxnKTirQm4FDKij9MefFoxI3hrKWwH3/xnstx+69vr7wfJeLu4kt2FXmkUflKs5E6qmMunWGrdyMbrUBmUr55cZcE8PsHnmU/KRV3pVYgrydeb3g9SmsDS/dDj/JWm1Chz1ztW9Y3Z1FH78EH/vYDVbtfq4k72sZgTEOnV4TLHcJkugHrIoDZmEzERIxHVGZrwppXTpDrVT34fpykwu6Xv/xlzd//9Kc/LfvZeeedhxdeeGEBt4rT6EmrR9SqQdEQSp1SRI6N6FKy7IsaHKiriy4+lA5st5V0gwoC66TTLy4UGaKL01K7uNDNgNI2ySyQyqgYDGpIyxrU2BH8+oFXCmkniki7PW6cceEZcxrnRO99I5YmtSITRn+3el2KbLvdblx00YVVx1KV+onpYrDQnensxnhEKPjc0evF0/GGRV2l6FSt2sBl1gzMD34bW9oS2BAww2ExISE6MIZ2mM1U+zTTCEECokzUaRq8ksLmtQrRYYyrIu4M+fBw2IOXEnY287VMZEvmsv0osgNRMnCIMWw/983wdfRBkoRCIwPNGp1L+lVfD4rUdbu6gap2XFphPR588lWsXbumkJat5O/WyEgtI42K02riLhaLzk7U0XVm2jKmUZ+60vOD/OZCCbIMEuD3hRDMNC6G6Dhf0ynBYweb37qYr1fNwPfj+LKoauw4JwYkSJ4ZfYY1KOzo3FGW/qSRXYcih1itHF0gVnlXwWqysjos4wWXLlr0Ve0T7Yl+cckpGnODT6kh5KTi/aDoXP+kivGIxh5HkK1BcGgf/nDHLUzUFW5e2TDSUhqP//GxOTn/T2Zm/MTqWTZUEnexXLTItNc4UaK0TkqHZqn+5je/bUjUFYvBiwpiwmzSCqnI8y46D/f+8Z6GI3WVGqWM6dex/jHmE3e2J45L/NFCI0RaFXBg0oRARw8TKWYFyFKn8vTbRpE6Og90UUfjvVrNMqSxfaARvH+MunDflBdPRFyIq1LNiGOrtbVsP4x2IJTVYBFbGWXrEc1F56FRIi/06dw8eGSmW7WcmcjdS/vGsHV9J+sarSSGqLyG1tE4S7cazUYcy8RdNgzZrswqUic6qBNcQzyTQUybqTk1nh96M0ROAZuWQgJOPz8GgwpeHwZWtoloawkjrjZ/vaLXc9lMx/16tVSuu4tpP44XXNhxmobGcx0KH2IRIEoLbW/fzlKoJOjoRHgt+Bqb9EA3/zM6zoBJMp1UFxc9LXNoXMWhySgEUxznrJ3Zj8PjCg6NqczShAr1rZTOm37eT++9p+zmJXnMgBCe8zgnk1geGWpU3B2YiMNsCyNgq+zvZqyTqrwR9UVdsRj8zfR3Gtqn07ImTw8cHT6cf+4FrDA/R6qoSu1cLRERzoahxGWsUpNY/ueb8fMNk+iwyBCgIZSTMJGzQJuOrE1MTMBJwo4tvYBMToVosQCCDKtgQoskw2NR2HivgYwF94x5Wf3c0Ux1cVGaRq4kso11k/rYLKsZZethTIdXMv2t9p6UN0rkt7eaaXCpuMtlkszfjaxAWFd1iRii7SXz+ErR0tL1oO5XapSoJurotUq7f43nh7PLjUCbv3lRZw1AZRG/JA5PTaE7kN8PWmfykyMhT2KazpeAmzpOBUxE8yJPIaO56XNkORN1U4gpJ+b1aqlcdxfbfhxPuLDjND13lYQbecV1ujqZXxzdJDJy3mGeJjlQVKfH1cNq5U62iwtF345MKDg6riGajcFsnYKS9SOV8gBeYCKq4uCoym7SAZdYloY0RjgoEkGiTrT7kQ2SGJpqej/qRYaqTXKgCFFeTAhwOOIYn0zCBz+LwlSipiBoQtRVgrLAanYEFn8vogkHTlmzA1tXb8U3vvGNirVztUSEz6NBu++/8W+do9jiTMEpqUgoIoYyZuS08kaRnCwjlUrBYbfDJAHpXBZukwC/lkUgG8SUJuCOoA8Phj14Pu5kAq8Wc+3iLVsPn61ilK/We1KpUUKnsRSqhja/hrgcYv5uZAVSSZxSpyqlwsmipjRyR4LzrgfvYpG6nVt34p7flNvYGI3sqfa6bCumz481G86FFZ3NlSfQY0UT1PghmFsU2M0SnCKZgQuYjGqsscFlE1mKlM5TMv+lbtXlbRqiybzgk9V8Ul4zTTaVfi2Fi6EZuKibH7iw4xQxHB9mI7rIOqQS/dF+ZvxL3atUG0QXsjdCb7CIHVkckPBrt7fP+pMWicOwEj6hLpJkQJvN5a0ODo/nvanI7FY059OWJrsbAxMa3DaVRepIFNNNo6Y4mhZDFKkjUSeYAhCsWtmg+lo0EhmqNsmBBBxFXLpWdiGlhtkkhmTS2ZCP13yKupnaQAlqYhStDi/zE2t1lf/90qiOjgQN29vSuCAQxx5rGAExxyJywZxUPK+1CoosQ1RzMGVCcCkZjKop/CnThmz7FfjnRx/BlNzYZXQ+rFmoxtG4HmQN84UvfJGthzE1Xn0jZholuj3d+OLnv1j0a2PHbTU8fg9srWa4RIGZ9tJ6kBVIqe+gLu6o6a1UhHcs6yikX09bfxrc73KXCUCPx8NGSNJr0HYV/X76uNp1ziasW7YGiZQJU1J138HS40S0BaCmjsDsC0NLqjiluwUDQQFxmrUaELG2S2ImwaWIgsCi7EvhQ6gRvh9LI1Knw4Udp8BIfAQPDzzMBABNdejz9LEmB6qho0/3iVyCRetskq0w+osO/OXm5YWLi8PkmPXFxeQzsZtOr6/3hLhIkpAbnlJYzROlVXPsU7wGizWGuFw8QD6WUlkKltI4Hd7KQqIQLSkTQ1NM1FWyepjr4PVqkxzoBnr73bdjz2V7sGX1FrYfGWuxj9exEHXFtYFZdHkFJmZGI9NRFyVTcaQW0W3JovOVW/Cfm45ghT0Di6YimhPRn7ZAaWB8gAiN+c11alPQ0iaEzF4c7TgfX37qeRxQO/D2089CWHoVkMPHTNQZaxwbWQ99YgTrgP369UWNEpUiXMaO22r7cfoFp8MiWfPnqENgYr+aqXSl16zUjVwqAPW6Qj0lXfR7w3G1bc021h1Ooq6eqbROPE3iLg7JOQQtpSIzmsHyFhHpnMhm1K7skGCS6h8fXAzl4eJ08cGFHacgaJ4be459mnVb3TgYyXezUiSOvujklTWqQxJYmnW+PzGSqDP7zayIe7GKOprZSo7x5DkVS6sYCWnMYJQ+2VNRtdMKJORY0c1Xh1I5obiGFpdQ1XeOFZx73KxRolQMlRaMz2bweinVJjkYC9pfeOIFnL3x7IoNFS3O4hRepYhj6X7UGv7eSG3gjM8dZox7p8UdvS41MZzlSeASfwRnuhPwBg8iaxcQzJiQlBuJMurjvWTQpKeYZsGrrafhNc86JNvPIqmE/alXSWbB52hMbJeKOo/bgwsvvNBQR9i8qKu3Ho00StSjdK0oUkeibtXyVTM1dUJeVNLfryXuGplUYhSAel1h2e9Ljit9P4y+g7XEHUXXw6kcJNso1GiKiTo6riwmAdtWUtdz9fGURrioy8NF3eKEC7slDFmJUJSNomgs8iaZ2SSHtJzGVGaK3Szo5+QlR80OVB9HgoYu2E6zk934yU+O0qv0PD1KN9+ijkQIiToau0M3ncV2caH3YSSYxt9d+28wuVfgvX9xFew2MxN0JDL0G0Glm6+OWRKqRuoKfwcadl28Cw8//lDFCJdR3IVp/FBJlIaiMl//t68zEfEX73x33chQaU1fpS7FSCLCHqd7SxrFxEhYt/7Q2ChAMgyvF6mrVAfWbG1gqc+dkhjCGnMU5/liuMwfQbc1x6JtYdWEI4oVqgxo053H1TBNj/dyS9TFLOL1pB13T/kgnnsFnL2rZgbIG9KdXgegpoM1xV2pqHvfe/ORKFmu6itSBh1XCTUBp+jEt7/xbfazz3/+82zajnE9aGKIvh6NNErUw7hW73rvu+Botxcidca0fl5s1xd3xuOq0UklpftRKwLciLgLxrOQTVP48uf/Bj32Nrz/fe9nP3/11Vexbdu2MoPpSnBRl4eLuhlyyuIaK8aF3RKELoDUtfqniT8xU2BKpdLFXB/PRUKNLB9oAgTdA5Z5lrFoXKezs6yzjfzkKGK3kLUddNPRZykupouL7jNHliXUDCFZA3nDWE1gw7uNN69Kos44Cku/EVdDd8zv7OvE5XveggfueQCxXHG9kR7lIRERTgImc/HNy5h+rdQoYaxBI7GWSpFxRX3ridIIG+13bOIgHvzjK4WoWSOijv26gWhII7WBJCbsqQHs6TDj0u4JnGKZhFOUkVRFjGRMyIkSBJMATdZqiDoNHknNe87RsZg1446gHw+G3Rgwd2DnRbvYetTqtqzmq1ZpP9i5ViESVQuWtsxG0OpsreobqIu7gUmlbPxYrUaJeujbSfthbbFWFHWNirv5HndWbT9qibtULoOhaBDre0QE9w3h+pv+v8LvvvzlL7N54x/96EfZ6MoFE3WaguHoMK+pW0K1galcigVKFhNc2C0hUnKKjeoaiA2wWjhW/+Zezi7qVICuT3OgEV0k7kiArHCvKKRAKHp3PE5KitItJlFHKVe6MQxPqRiPUu2cBqcNUFNjTLlQ2tV486oVqWuE0jFIyzYsw9qVa8vqjfQoD4kHqgUy3rxK06+Vbr7GGjRqkHA4it+vajff0k5Jqsv77e23sBq3olmmwsxkDLr5vvNt76xrd6G/vi4edTG066yz8cjvHymPOGoq2qMH0TtJKeIDaDPLZCqHkGzDKI2o0DQIklBT1FG6llKtdklDXBHxZInn3Hve+x7spBm2Wq4hCw2juLM7nIhPDRX2w2514Pyzz8dvdS+/JiikLS3eMt/Asn0yC2xiCCRL0XpUmihRC/rwoZsf09+rO6mkAXFnnCk8W1FH50e5OBUaFnd0fhyemoTfYUZu6Aj+9evls4eDwSCuu+46Nsqykribq4igze2P9UOVVN4osYT240j0yKwsvRaSxbU1nKaJZqMYT4wzMRdMB5m4Y52pjnaWTiUskoV9GQ/mjJpZNBeXarMUj7Woo3L5oaCKwZCKcJLGmVG6TYDNJSKX028iM4PqByZz+PWvvgPJIeOv3/fX8yLqdBFRr97IOKg+q2SQEcbyTS410q+lkbdkMllX1FF3LP39inV5xnFXrm6IZoqoaIWbbyVz4FopP2OE67TVp+ER7ZHCY7osWZznjeFtr98Af3ockprBUVFl3nFkMSJIEgRWKpCBIGllok5vhPCa8p5zQ+Q5N+XBQ2EPjhg95wTA3mYvE3XG6GstcXfpuz+M39z2U5iccVx0/sVsP8hK5rdoTtjt699XWI9GjysSUaXroTdKiGr9FGMpxghwrUkltcQdWbPEDDOF9ch1Qx28JedHi7UNgqkFgjl/2xIgMr85ah6vJe7o/EhjDKpsx9YVAfzzPxR3Apdy0003MYsV4zk4H6LO2mll7+k6/7pFcd1drLXMJ9p+2CQbG4+5mODC7gRmIDrAJkCQuKMbENWtMHuNKqnTxXpS1pqluFD7Ec8msD90FF5bfj80TWQzWmkaBJnRBkg4VemM0wv4944kYPb3IDc1NK+irurjK3jNZZUcjoSmEHDasMzrnVW3Za00GU2AMIrKsro8EnfJYVjblwFiJ7JjgzUjQzT3thR6/UrpV5uoYhdNhDjyc7xp/WF4JAU+al6xeJAV/BjPJQqvoSlpiBY7BMkGNZeGxgxkNbgkFS0mqhEFwrKEO0Ne/DHTicfGBeS0EqEynUY+PHAYZ248s+mxbSTunLYcLC1tUFMmbFmxBZIkFa2bjvFnpe8Jrcd9j983uwhXyXqQGGK1gWpzNUCNRIDriTsyUSa/vV5f7ZnCjZwfrbYOBCMC1EwEamIImpyGYHEjlQW0ROV6OvoZiTo6P5wWO3q8AQSH97PIXC1odjnV3FHd6HylX0nUCVaBZVAWy3W3WRbr/eN470ePq4fVpy8muLA7QaEpD1RDRynWFZ4Vdet2+Ek5Mx5oKJzEi0NjkDN+rG1rQVAQMBZRMDCpIuAqrp2rBo1zMttCUJJpQOhAJqehRgndnEVdRa85vxtnXHAG2trWQFQCiCbr9ctWF3Vm2YxsIlv2+/Xr1xd9X9bRSmLIrUJTRqCm2iFauqDkZmq8SqmUmjXOsCVLk7W2DM4YuQfnbDjEInUtkSQOacDhtAWrbRQ5EljKtWgzSLkJGWiKlfkpBiwZOCUFSUXEy0kH7g158VjUhcmcGZ/5zGfwYGkDh6E28NE7H0WbqY1ZbDQDidOsOA41RabUHkSTAtrygfKaa2l8TyqJ7DfeeANbtmxpcCOK1yOcsMBla07t6zNT60WA658fYWainEzZyqxp6qHXBtL5EbB2IBI3o90tQw6+BE1O5R+UnsTmXgFHJgWMTqmQpPxYPupOp+thZjqSTR96ojEfOvpEBI+EGvr7U1NT8yYiKP1Koi4zkmmq3GUpi6GltB9qXZ+CYw8XdosQ6rChT8tUmzKRnGDpVfrE3WpvxYbABnisHrwy+QqCqSBrfOCirjaUPoymgFBMxdFgGkemgrBIdvR6AswPbTQsgwI8rW4BZvK4aLBL0U91T5ODLPVFr9NnrmzSOldRRzf2UmsMEhEZcxqPPfQYrrzIj86+VkxGVDZjliJH1Wa3GjGKiEsvuBS///3v2c9pWkC12riiejtjo0QoAU0dKqq5a2QbdJ86ryLjLHEKl66KYLMzhd7xKQyaZDYRQrR1YEpOVH8NSWBz3H2CAo8QhiaaMZpz4X/G7BC2vhk/uJumFtRYlwoNH/feey8TtY02OhitWbKTExAsuUKDi8tSey3rRU4feOABbN68ubmu0en1oAkJ5DNXywqlkqijmanULT8Xvz0aP0ep/MFgztDUUc84uIUWFOPJCWiSijZbB8JxMzMNXtkqzIi6aajTPOAxIZzU2PxlGuU3FtHgdmTZNAjaj05/C0bIloVMriP+hvbB7/fPm4hgAnMkAy3T/Ju5VMXQYt6PlJxixzB94KRzqtfdW8iCVdqPShH54w0XdscBuoBRFyp9Ii6FLgLPjDyDw5HD7KCirtap9BQTdZPpSQzGB1k4f//UfnQ4O+qmSJbqSSkqIq5855Xsd7/61a9gs82MViqFbmyvDymIpbOIK5NodUvocrWw985tz0fx6P5NI4Oa71LMz84sbaiYL1Gn39iNlKYt77v3Pnzykxsg52a6M+vNbi0VEcZRYbVq4wrD3eOxCt2vhpo7ZzceeujhmttgtgBndaZwxfgD+GDXG/Cb5MJEiJC1A6PZ8q7dUuwmDa3WHDMfdrT04Hf7o7hvyodnlbVIi3Z8bA158D1d9JzBwUHDm1m5izcajeLQoUMsMkpcc801Vc1/4+k4vnfzd4u6kY0NLrJVq7qWjaTDKfVNKfDu7u4mu0YzrKFiMq5VtUKpJuroHFXk5tOnlRqJjNY0RZFtuv4JIrseqqqG8Wg+pW7yiGys18buDkQSZrS6RazvlsB8a6YxnvP0/267gL4WkflMvjKYxN6xEDw2K3r8rSxy2uUTWV2qf/Nm1v1aKx3b2tqKtpVt83a9ous1F3WL6/7hqHIfZNZW8RG2nS32FowmRtnfpjpVug+StytZiPk8PnYNt8DCumIXG81X1HJmDR0QB6YOsOkOdx++mzU8lEbqnht9DvvD+5n1CB185G22PrAeG1s2sgsEWZa8NPkSG/tVL6y/VEVdM/uRzGg4OKawT1+wUFqGRF1xdx/V0jUq6oxdijPkGyrI5JTEHd285kvUEcaatkoWGiRC6MZPNy7dVy2Rq/6ZrVREkJVKI6Ok2N8XBFx62aXVLU2mGyqoOzOl0R29/H3ts2bwoe4gbt54GNe1HsHpkVeYjxxNhDiStiCmSPSHqm+DpsCRjWC1I4s2q4yBtAXfHuzArWs/iS8e6cPDETcS8TEmJsYjpNiL3+dEItGQNUsjRsq1atGYkHAJLHJHkVSinm9gtVq0WttSvWt0xgqFInckrKpFLktFXTM1dTrVusOp5i5vJJ1lke10VmU+jKI1AMHkwHgEzBPR69AgiK9Dzb2GPp8fExEzHBYBG3ok2CyNRU4lUwpO7xGs7dIQsLey9U/lgG6/yM5xaoggS5NavOd/vQcT6Yl5u17x9OuJc/9Iykm4LC6c0XUGTms/DZtbN7MayVAqxEz7ScSd23su2p3t7FgnyzA6d9ocbayJYrHAI3YLBPnEGUdvkah7bPAx9glA71B9cuhJ5LpyTLCRmfDBcH7aQ4+zhx00pQcz3VT9Nj/7qgcXdXmXeRrjFYxloVnGYJ3jTatWl6LeUGG0ehCr1Aw1I+oaHUul3/hr+apVExE0j7PeKCnjfvj7/Nh9wW48+9CzyBq89goYu2WnU3AOUcZOT4IZCG93J+GxKEgrIsZSEkydnZjM1YvO5RshfKlxCIKGuGjDb5MBPBT04NkJGxsRdo21pejx9HfNJq2wDZ//3GdYR+bBgwcbGndWavNSCl3Q6bwlr0d9PUobIaiA3xhJbWQ9KlFtW4wfFipZmuhNNkYrFIqOHStRpyNYvNA0hX3Qen1IxbKAhlzwz9CyEZy6/KOgzY4rAxBMcWQGM9i6zIqjQRHLWkV4HEJTH0JdFjs2r+xBVibjZjr/gVbPzGuQlQlZmvzwhz8sitxRpI5EXff67vkVEWbgjjvuOGk+TB/v/aB7LWW5KDhCk5Ka2Q9qRKRZ525zPoNBjRG07Q/2P8j245S2U7CjfQdznCDvOgrGkBCkIQDN+FMuNFzYLRCUTqUL5BmdZ7Cb+PNjzzNR1+fuKxzgVD/39PDT2Gvdyw5E+sRNByOl+k6mk9JYo6A7wJPQmOt+jEdI2GWQk8bhlOZ206I1qXfzLbV6aHVpZYPXF0LUld74q4m7SiLiqquuYk0CjdhPGEXEjvU7sGP1jrLh7sXibginBFzY05rCRc4BdFhyLBAXhhmHM2YojfiqCSpc2TBW27JsIsSYawVeDZyC58wd+OkTv6/TbamhvUIasLu3u66oqxfFpPWgNZ0YmcCT9z9ZWI9KtYnGSGq99aiEbjlTOq2iNAJcydKENdm43ay7WRfblJbtbdHY8XosRB0JScFkhRI9jG0rBFjMEtrcGtTpmrtWj4qxzAiQShdq0Tx2ATtWk6G6MOvrld0CrOowYWU7lVoUvw6Ju61bt+K9730v+/5LX/oSetb3zGukbrFfd5faflBtHD3HOu0QodenV9sP2k+yCKMMjNWUvybTVCaqqdOPFzofNrdsxr7QPjgtTuzo2MGEHBGwBbBY4cJugaCLLkXf6EChXD1F40j9Gw9wCt+SoTB9wmh1tLID8mQ7KWliAX1yLnWAv/ojV6NrU1fF/aCauBx5lAkmCJKV1dBlVRkeh8gaIIihkIrXhtMI5ybR4jIXaoa+ev1XG5oEUXrTopO/EcsGRZHxk+99nd1A3/7O9wAmK+tSrDV4vR7U/UqNEtVEHYmQ0ht/qbgTTbGKIoIGq3/lK1+puw2V0sgZuXKXY7s5hz3e/HivNY4sHCYRcVnEcM4C2US1UoCaq15wLECDTU5gpS3/+hmTAz8ba8EjEQ/2XPBXSGhJNl6rdD0qWalQhl0XNJQG7DHlL+b1JhjUimLqIntkaAQP/vbBqmVrxm5WfT1c/l7Ep6qvRyVKLWeqRYBfef2Vis+n9K/esEHvhd5Q4XdnMZFeWFFHUCqUmh7kyEGs6xJhs9F5Z2ZRrFq1aHMRdUaqRVKM69u+qp2LuhPw/qFDH1BG46NYF1jHSpeosfD2/bczEbbKu6psP+i+SzXrLbYWjCRGsMK7gr0GZdPofm2Evj+752wWme9ydeFEgAu7hUIAS5nSwUN5eIrE6SlYI9ThqnMyijpyei8lGArihp/dgPd+4L1481lvLtqPVFbDn48oiKc0WLrPYeLupX6KxNBtk+xKRJgkDS8dpQhPGMvbpcJNS4Ey65tWtXFOlcmnAU2SyvzEyHqi0cHrlUTE9vO244+P/LGq9QSJELp5lXZn6WLC7CVjVwvkSHDOfmLGiKOxCcEiqDjTncBFvijO9sbhlRTktHwjxHBWgmiyQ7BogJypKuoKEyFEDSZNxmMRN+6d8mD77s/gP/7wHyzCdeCX/8nE0Kc++qmy51efcqGvh4a9o1Nw2uWCqCsddF8vimmMnD774LM1u0ZLu1lpPXbtuAQPP5tpaj1KLWcqRYCp6LtaY0YRSr6hYiSaw9hYCB2+hRV1RDJDU1smATVbtyHqeFyvTD4Tez97fb0nxXV3qe0HbfdQfIgJujO7zmRNiVQGRQ2HFLkr3Q+K5FHz4vb27exvPDb0GBN6JOzoWGbd4CVsatmEEwnePLGQb64gstQr+czpUyCqcbKdlCRCjJG6Uod28n2687/uLCtIJb+qqbgKEzOWV6HJSXR4gU5fPloXT6sYDWdhd43DZpKgZqlLsfnah7mOCaNxToJ1AhAzULPtgGpp/iWmRcTKvpW48qIr4Xa5yyJ1ZE2i+60VdXtOQ5EhwRSBJnuhyrMbvF6t4SMei7Go2oc7JnDzhsP42qpBvCkQAZVwHUpb0J+xIKFKrCYOIjnJUgekpSw6Z8/FsMqWQadFxljWgv8Yacetq/8Wnz/chwfCXnznRz8tS1s+9thjze2IoEG00HrkoGTboE2vB029qCukqqTDY9EK9YUVulmNrFrbgh1nrYbF1FFzPWhdK29EvjaQIsDG9Sgzjq6FmIVgHQdU84KcH8aZxPmOV7BU9GK8XpGoM/vN7IPXyXDdXWr7QccXOUX0ufqwrX1bwWnCZXGxeri0Umx+TzVxlCE7veN01hxBEbi1vrUsik8/L82qnajwiN0xoN6BcjKelFRLZyxcFsxuNgZJsg9BsMis1iadSRc5wKezGgaCKhw2AXY2CzRRlGqh7lanPYu4NgavxYJlHj/Gwvm0E9W+HTtRl7/5qlqOTWIg095mfO4qjXPq3dCLVStXlc2PNaaZSiNPuhiiyJAqZ6sW8Nfaj0q1gRY5id6pV3FG9kE41x1mTQ0pRcBoxoRMyTQHCgQJZpGJcEVOoaWtG6HgBOxaEq1mhXXD5rJZ3B3y4v6wB8/GnGwihOvnM8XmWTFblrZ87rnnGtsHw3ooWg4bOtowERYKDRWNFjwXmyg3btprXBPdKuf0DWuxZdkp+MnPb2Pr8c4rLi6LNlaynDH61JVGgBvp4CWuuOoKhHIhuCwW9HQWnx9UczfX84PKJMhHzm7RWPScJkPYLIBqOObmZfC6nGKZkLlcr+jYJlGXm8qx9/NkuO4utf0YTY6y4/D0ztPLtnu5ZzlzoaBrqX6u0OtTDR2lXnXW+NcwezGyFpvVuLhFCBd2x5mT9aTUnd0ZggjJtxrWrtXQcg6kDr9UqLUxPm4soiKeppuQgJI6ckalQvBWVxbf/tGvWQH9333k3YXH6nM/S2vt5irqjDffVit1KapsEkOjPne1LDQqzY81zjA1RnnKC/Nrd8vWigxRbaBNNKE9egDLQ3/CstCf4chGWdfxfupszdJlpHyfZkRdvqaORFyXJQm/NYWUJuGNhBl/CHnx6KtujOeK6x11odJog0E1SsWQ3WxFhyc701BR4TiqZqLcrKgzNrWUWuU4xFyhocLTUn+mbqlPXWlav14Hr74fORp5Zjg/uvwaOy6p4aeSuBPMLmYYrEfhap0f1CQxEdXYMR6Ka6wDlr685Mqk5L2+yDpiODo8p+sVRfOPxo7CY/fM6XpF7yeJOjncwEGwRK67J8p+UPSM1Z7bW6uWCdCxSOfi9o7tFZ0i2h3tzJaEmha76VxXMqxLltKqRg9ZStdSGvdQ5FBZfd2JChd2x5GlelI26uyuQzdYa+cyQAtBzXZDtEShZPshWrzImTsQiquwmYV8tM4qVIyyVOvuMw5GH69j0tqoqMtmsxUHwpfefGdqKvM+d8GEUFfczWWck97FWU0M1bNCqSSGVosiNow9gdWTz8KbGoOk5pA12RG1tkIRRESVyuk/XdQJqgaXmkPAlt+OWFbDr8f9eDS7Bi8nHJATI1XXY66i7qqr3oaEkMD7Pvi+ooij7qvGjgnd584w7sq4vnr6dXR4rOn10LtZg4lgRascfT0SOTM+cc0X4LIoVY8rapSo5FNXZhxdJR1L++Ht8aKns6fs/KDjsZK4oy5iweSEpiTZueNwRjCVjsAMP1TZBRi0JQm/iZiGFreITb0SBkMK9o/kaykLViMC2HgtVVLnJOqsXVa2lnO9XpHQ56Ju9vcPippSvRpZhJDdx3zdP8hCiEZm+mw+dn+j9CgdX/QYOhdoCgSlWulafUbHGazcqRKiILJJTYlsgnnG0vlzSusp6HKWN0Cs869jhv+zqYNejHBhd5w4mUUdQUXl1P0aiqZgXbYOENLITZL1fA4m31pI7h64vO3IWFbguYMyE3TRpIYOX2VRRxeDqt19075qOXkmBVd6h56PSF2tm28ln7tScTfXcU4keOuJoVJxV/4iQCQ1gvM8EVwghXDlG9+FTU1BEUxImT2QjRc+Qy2VyWQqdOXS20/ptz63CUo8hpgs4o9RF+6b8uJPSgfGomlASkFy+quux1xFHe2HbFdq+AaW+9yVzjI11tQ9/9DzTa8HdbPSTa+WVU61CRX6VIt6PnWFbRUE9vcqjSvT9+PM7WdWnFZTSdzR+xdKAEr8KJT4EMzWKI6Gsuxm2+n1sLKIyZjKpkJQpC4Y1+C05s2EaV7rijYJ0SQQSZJ1yUztLB3jdBOdbfqVRB1F85e5l835euURZxrXTpbr7nztB9Wq0fOpdpw8W9d411TdD1o3iprRcadHfnXbL+N+0PFNjyPO6jqLNRz+afxPOBQ+BEmSsNy7nD1vKDbEpkNQbRxF2mrR5+5jr0t/YzwxzrpmKwUGyG+WooNLBS7sjgPH+6RcDBcXSit+8K8/iu//5l4IVg9yYwPTN61po1pBxCV7tqMrILG6nUQG8DqEMgsE3U/MbrHX7u5TMmj3agWTVqOYmI+auuHYMH59669qWmiU+twZxd18jHOiC6wuhuyCHXEU111dccUV+N3vflck7iIFX2AN6xwZXNiZwF8d+jEE/yBrbFAFP8K2zqJJEJSCLZ0DSxGjI4cOwm9R4DOrkDUBsmsl/mNfCI+E3Tia0YVVuqqJsb4e8yHqKDoVaPPX8Q0s9rkzirvSRokc/aNJOld0NmSVQz53Jkr3RvITKvRIaiM+dfWaPvRIHYm60zeeXvX8KBV31EHsd4BZlJjcCgL+EfS09qLX42PnIaVaXx1QMBFVQYcqRerWdYvsd4RZEtgYsGBMhc2iFhqiyNJkttcrSr+SqMuMZtgEnrler9Lp4sL6k+G6Ox/7QcclpS3JRoTSoC+Nv8TWhq6fLrOrYMqvP5ZsSChyRrVtdG7uDe1lkVs6L6lpgfaDRBU1QdDzqV5Oj8Kd3X02+zDiNDnR4+5hxy/9Xbpm0/QlfYZrLWwmG3uv6etkgQu7Y8zxPikXw8WFhNrwlIwpx3JsP/uteP2px5E1iCG3w8QsPPRuT2qK8FbYTf3mS2nLRiwbrKYZTzP9Rk4XiISaqCrqjDVstWrR5BppsnrijroUC5E6sx9f/Ze8114zsML83Exk6OrPXI0bbrih6DFr1qwp/FsXd9lYAld2ZHGpewSb3Wk4JBUOtR2vZ0ysiWGN2VXHT0yDU1Thy0xghT2LKEy4O+bHvaMunL3707j57m9Xf2oFcSc5xTmLOlqP004/DR3OzrqpFaPPnb4Ns22U0OscqRGifKZwbUonVFTyqaNocC2oVpSifJlMhjXZ0Plx8VUXY1nPsobmSuvi7uiEAotZwOYegYk6ajDocrWizz/TYEDp1U19wN5hBQGngDWdUlkE2kVNThZg32Q/E3XUEDWX8VrMO3E003TklODX3fm5f1DEjTxZW22tTHRRSvSc3nPgm/ShP9rPmhnob9D1mF6b3nfyaKUOVaOxL01dIpsROi5JnNE2dTo62SgvY+SMRCKJwlJm9QH8JIILu2PIyXpxycp5ywNZzaec9o3kcCQ0BZsthz2nbsB5mzfU7PZspGu0YR8ug5gwt/ZiKhNBu6t1Tt2vM40Sjd1xjOKuP5i3nqAuxdlG6gqF+eaZyFCt94+mOWx3JXGBbxjvGv835HpGoQkqgoqEkaSEle0B5LTazRXUCBEwyXBTR6wqYtTWg+9HrHg06sUINTtrwM4GPk2XrocgjUOJyw2Jup07d7Ku6UJdmWE9tq3Z1kS9jFbYBpOnByOJyVmJOr2btbRRopGpHqUTKg6FQnA6iy1NmomG6x96qKauEVGnQ+KMUqkr20VopvGaXaNtHpGJN6u5spmwfr2imrqf/utP53y9oveCi7pjd/+g5gUy7w1YAwjY81MWqFaNoqXnLTuvINTo+KTIHdWvUUnMkegR7J/anzcCh4BT204tPJag9C2JQWpUoLFc1I260ruSWZAYH8eZPVzYHSOWkqgbDA/iK//wFVZ4/Ktf/Qo2W/XhxzSrtX9CZddjEneprIKxRBgZWUaPrRU2k7UozaV3e8528HpDULpNG4Pk6EEuHYDb7ymLztWdTFEya7SS+XQ9cUfO/2QSi6ydWU/M1kRZj3BRGqP6FAYN/vQo85y7zB9FjzXLxJlZcOCQbIEqWaHmMtBqRYU0DRYlBVsuij5rFhM5E+4I+vFw3INNO6/CbX/8TZEYMvqZ6VQyBDauh5Jsh5Io9+MrhUyEaarD7t278x8KBODSt1+Khx9/qGLXaH00qNkRWPy9iCadyMXEIhFRcbvrpMNn82FBy4YhecwIJzQEZjl+Lv+hxwJNloo+9FCkPJPL1z9KVaxNqIvVZRfhdE011DVKInC+rld0HTHOVK10vWpm5upSu+4ea1FHjREb/BvY82jkJUWyQ6kQrlp7VcV6NIqu0YcI2j7qQn1p8iU2XYnqIUuhyO22jm3s3xSdJgG4mGatnuhwYXcMWGoXl0a7ycYjKg6OqqApUpQG1aAijUm0mLOwah1IpEyYklS4mtBE8XQc37v5u7OOqBAsouKg6QNDsIjOpn3u+gf6684aLRU2+jB2/eLFxGl6jDn/q1kf8xMj6wlxDjNsf/SjHxV+p/uiuSUFu70xXOyL4pID30Oie4J5zpFFCXnO9Uo2KMIUtGwGEC3k41v+fqk52HNRmJQsciYbht3rcP3zVjwecSEhkcGrCadKlrL1MG6PDqXXSz3ojOsBoYNFzizqFFKpQgFg1XoyZgEzLbL9bb6G0uGVyEe4JKiJUbTaPJAcxTV3F1xwAatPbCYd3ix6NzKEMJb5PYXzg9K07PeGySKlx5MOq9VMTEAQ2yGnMogkBbSZNeYnR40MFGGbjGqg/+X7w6mSkixJhHyDUkqDzxtFQuNdo4vtujvX+wdF09b41lTcD/pAQmO46EMAfUglY98trVuYiS+Jsz8O/ZFF796y6i11a9XomOzz9DGrEYru1RNss5l6wqkNF3YLzFITdY12k5Hf3P4Rurlp8DrE6ULwCeS0mZohummVdgM2E6mbtagr1HBl2XilybjG0qItzpkX1CN311xzTfELCMAdD9xRV9SVCht9GPtll12GlWtXFjVKwEHdsnk/sVZXYzul1wYaC/P1iBJF4ra5EjjfG2MzW2lMF71XOaEFB1OkoqcHXJvzXWrktaepal7USRZWDE+3e69JgSs6AJPFijilB1vPQL//VIyb2/CH279e1GDQaqUJBsXbWCnCRaLOmEItXQ9I+ZRoFmSHQ95nWqFurTHfwNmKOr2mLosOr1DWUGGsTyyd/nHhhRfid/f9riwdXlr7VotSq5x2txXxrMDODzICHBvYh3vuuafi8aTXorJ5mYkxJFI2ZMZHoMaHYZaollOD2QSs7RbRG5DYuUkWQnQ7tVnIRFjF0UkN0ZSKnBaHZJ25XjUbIVuM16ulct3V94OOFZpBToKpXs2ivh/0AZDqiEOZEBtjqYspeq2xxBhUqEzI0c9JAFIdHKVQqf6NupjpQwU9d1PrpoYja0vFOuREhAu7BYQ+AdFMuqV2cWHdZAIdOpVvomRLcmBUYZ/+6SZZbSxVPhKhlnUDzre/W6U0mX7zNXYDjlXwuSvq/ixJvxpFRKUB9KXChoTMrb+9tSAiPvORz+QvsELeYoLEJU2oKPVVK8VYmG/DTBp8uTWD830xXOaPoNeahVnQEFNE9KctUCBglclRJOrozk7iUpsOBFEa1iYowOQRrLLLiMoCbu8HHkv74T/n7VjTm58AglyurGu0mU/dr732Gj72sY/h3//j39l6nLr2VDz3+HNVGyqoGaAS1X0DG6dSo0SlhopKaWW9HtToU0dmp/NllaOfHy/vHcBjD94PLRMrO55I8JLwpQ8LJOpSKTv6vB7Iodeh5WLYulzAaFRkXat0LjIxYBFYfZyOpgnwOTW80D8FsymIFX4+XmsxXnfJYoSiZiTCHJKDlbDQsdNub4fVNCOi6GdHIkdYNygJQNoP8pkjqw+aiUqvSV5usiqzmjlKq1JkrtfVW1G00c82tm5sevs5xw8u7BYIukhPpiex3r9+SYk6gm5ypsAmCCY7c5rvtWrM0iyeJnGiYDCksS5Xmt1KaZ5qs0YrdQNWYq7+bvXSZLq4G5hUyqw3HnroobqirvYA+hlqiSG9oWIwiMI2fP5znymr8ystzB/e9zIuD4RxoS+K01xJuEQVaVVg9W/pKvYYuqijSJ0giBCp/s6ksAgd2ZQMpJz4Q2ITHghaMESLStz6WwD0BXziU5+YddcoEY1GsX9gf0EMvfHnN4ofUCLuHn7o4VmZ9jY7UeLzf5+vq8w3O8w0VNDXj35yc9nzU6lUXZ+6Zsa2VfKp8zkEvPj0Q4XzQ2Dnj8hq8TQ5P83h3gfuxeXtVyGddmCZz4+1HSoTdQR5y23uq32ZZzdz8wTa28bR5WpfcterpbAfdLyTHQjNHacRWHTu0995I/QG216avKB/qKAPsBSVo3o4amCg/aBt2NyymdXOPTr4KIv40+8pZXpm15nwWJr39OMsXriwWyDo0xC1hC+li4tOOAlI1KEmmPBSv4bJhIJ0FkhkNGQVMiQVmGCrNUC+WjcgFY23Gerd5sPfrVLXaCkk7igtW+pzx6JudURdI5SKOhJDxgkHerMGTagojLvKaTDqOr1RQojnsDEzitXj96Nl9Cloy8aZsJ6STVXHe+XRDKJOgQNkUzKJFbYswrKE34d8eGDKg+fjDsgWD1sPwRosiqTOZbyWcT1IlOliKIYK0xIM4i6p0JtC0U+tITHUzHqYakaAZ8RdSvICEjn2zkQPKf26R9yD9cvWF44r3Vi4sY0oHttWyaeOaulioUEW0Rbt7YCcghw5wLZJsHho2hfSTgtGRxM4/5RerOowQ9KqR3trnee9nqUlhpbSfgzHh9n35PGmCzgSY8xWZMyBVydfLfycBNuGlg3Y1r4Njw08hoScwBmdZ7AuVEqxrvWvZY9f7VvNfj6b/eQsbriwW6g3VjTNau7cYr646IyEKV9lhpocZa7yZFJqMQlw2wGLaaZ2oxFRV+qrRqLRZM4XjFcaEzaXrtF6aTLj+LGCuKPO0QUQddUwjruitGyfWWPbFUmHYYkdwPsto7i4bwo79v8IEhRERQn7p1Ot9aC1kEQNfi0Lt2U6smfvwQ2DEjMRDsoGFVlh/FhjYqgxkd3iaKkf4apkYjy9HrXEUD2MVjmVagOLKY7c6TV3+n688MQLOH316XOeYVvNp05P59P7r1m80DIRyKHXoCZHIPl6YPaLUCMprLRsxJY+M4u+NeO7u5TFUDPMxwzbavtBEbTJ5CS7H1Akrdn9oO5USqsaRZ0OXRPJKuRA+AD7+xR/pygyRfZockNGzmAoPsTEHEHHB9mS0OuQsON1cEsTLuwWCOOQ4aV0kaTOuokIoE5HcUh0uBzFN9dmRV2l8UpZJYOMUD77tRLVOgRLu0YbwigmSDiYqYZLOyairlRMWEzA1GQcW+TnsHPqWfQlR5BqGWOCLGH2QjVZWVGzgkjd1/NYgUAmCIuYxmTWhLuCPjwYpsL/v8Ftv7+x8rMM4k4zCTA54w2JoWozS3UxZIcd62iM3BzWo5YYqgUbP5cL4YPv/1ATEeBicZe3ZpHZcRVJRDA4WN+epVZtYNH5IZggmJ3M+5GitWSzUkDJQokdZtujaVOQbEko4fwkhuWd7qbtIriow7zNsK103aWsDY3Ion+v8q/C4fBhJtCoFpTKWejaRLVvem1opfWgcVx0Pzi3+9yqgrXF1sIsRZh3XCrI/j51stLxQM0OawNri+5HtH+bWjY1vY+cEwcu7BYJi0XUHQ2PYyo7hm7XzMUlnMj70FG9znBIQZbuhUrlsMBsRV1RWlaUmYFxwGlDb2tr3cL8Sh2C+piweuOcqoqJ5DCs7ctgta9ArP/AMRR1gAQNW10JvD1yG7om/wxHLgKTJCFr8eBgOt/Vukay5K1RatzMqTu2xSTDZdGQ1kSMO1fhhj+P4ZGIC1Elf+pfWOe9ZZEikwBLSxvUlAm58ETd9ag0s9TY/XrJmy/J25RMU2t4Pfu93YzY9HpA7ER2bLDicVUvDTq3CPD0bNnW3rz/4dRQvou3SvdvNfTzo1JtIKXeRUc7e89jaSCaVhFo78u/P8ksNDUDNR1iUxz0makk6lpbWtns5Wbgom6aeZhhW+m6q89HpYYEmrpA0TryaqOpDTQui5og6BgOp8NY4V1RWA9Ry5ew0BdBr7GxZSN7TDVIwNGYrefHnmdmv1vathSN2ppNkIFzYsMNZBYBi0nUPbU/jrHxbpjVVhY12D8q4/lDCp49IOPJN2QMhTSWcl0IUUdkpiN1AacIUQkYZpnmeeONkkL7kg7BvXv3zsvsV7NbhaaMYOOqrRAtXTXq1uZH1FGt3U++/v9i4+B9+Mn6w/j31f3YOP4oLEhhytKGCXMnUmw0VQ0hZ8p3KnskBStsGWYinBBN+O9YGz5xYBl+v+Zv8LuQryDqSrt5SUBU2g+K1KmpKShZDwRLfcM/8pijTk399Yyi7opLriiIb6MQrMWeC84rrIeSMLH1oMHzzVBJ1FWj2jFG487YZIwkdYV35LuXp82LG8F4frBJDpoNor2D1ZVSB/lUElAiB5EdexqnrxSwoUdCKgecf9HlEM1uJuogxotEHR1XH/nIR4qEcj24qJtJv87HDNvS6y5de+hYo6jYnr49LCVK4opq3qgDlYba0zFIqVWawkBijx5P18sOVwf7Gd0PKIVKxwmlTut9mCJjYPKoo5QrdbxyTm64sDvOLBZRN5YYxytDEQiqH2rOhUf35piQe21AZSOD/E4BkgTmh+Wo4DY/H6KORASlqOjmu7q1FQG3yNKyU4n8p1dKXzzwwAM1X+O+x+5jLulzEnV6TV0ogR0begsNFY2KO13U2Uz2IlFHnmc0McGIQ1RwkS+C61YM4KfrD2PXyJ1MlIUUM0YtAaStAdhtVjayKUOe0FUu8DQmbHOnG6ttWdglFWOtp+IrwWX40Og6fOdwG16N2itG94zdvKUCyyhOs5MThQaXUrFdCRJvH//4x0t86pSKg+pLhWDxRgC+Xl9hPeToEFsPsqZpVNw1I+qqHWMz+yEjNzlYaHBx+1rR29tbdxtKzw/aFhLJFAV00KmiAaupN2JqL6Dm4Lbnx3qt65TQ2bcaF1z8JngcmbJI3bXXXotdu3ahUbiom7nuUvpVpK78iFzXD45sQug6TfYhta67VA+XyqVwZseZrDHBeB2kujb62Y6OHdjds5tF2ShKOBgbZNcrOiZIxJ3Xdx6rf6Nt2tq+lQm9etAxTY+luap8jiqHp2JPUlFH44X6JxVmHqxIk9g/EUQm1YE+nws2i4B4SsVAUIXVpMEkSjBJApsgQZSOvpwvUUcigj7Z6jdfP7ue5U2M6b/RyYGaKTu6+aaQQjKYxIpV5amLSl5kpftR2ihBEzNKi+d37dqJJ598suZ+kBi6+NyLcdtttxV5nsmyzMx/tzhT2Dn8e5y34RDaLPmfTckSQtYODMkpCCYBZpHej/wpSuKaOo8FyQZNT4NrGmw0Z9GWYdoxaXLjplEFD0Xc2HX2u3H/S78uSvcVefJVYHJyEu985ztx7733sgkfxojjFW+9gk1eyDe4CAXfQb2bt9I81Fiu3DewlhBcuXJlYWYwMyW+9Ra2HnJR2jJfc5eVyVpHKzKVnquoK3ShlhxjpeKU0I+J7ee+GTmltuCvdH4EE1lmSSKH38COlQIkswlKjpS7VpRiW94uQqF1tnRh27b34N+u+xcm6r70/34J27Zt45G6OTR8ZJDBl//xy0w4UX1dJeiawUarKTks8yxjz/OYPaxWrvS6S2lTOr52du9kDQ2VoOgdfelQhI2MgUkQklccCTpKo57dfTb7gFppdFc1elw97IvD4cLuJI3UHZ1Q8MawiowahdURhllrZ7NGSdQRNC9yfbdWmIhAPm/UKFHNT2w2ok6fzWoUQ8bZlkaTVhJ3wanapr36zVdLVb7ZVxpxRWk3mjlaWtBeVFNX0p155lmVhV1p+lUXdfoMXFc2jO6JF3DTuiNYY0ujayKCAUnBUMaMnJZ/bz2awkSdJpOgztfGqJpWEGUk7GwmM1ypSVgEGWnRjofCbtw35cUZ530GP77nu0wMnaHJZfvx8MPlfnBGHn/8cRY123PhHtz35L1FaWR98kK+wUWr6Ts428YVYzqxp7en+kQJJQM5NoiMtLyiqfRsRV2lerlKoi6PhrdcfAZae/owGpGrmkrroi6aluE15yN1tJ7JDKDEjrJaVRJw1FWelsvPL4rUdgYyiGj9cEjWQvqVaup4+nX2oi4ux5k4I1FlEkzYG9rLrqG0FhSdo+H0JOooXUvemWf1nsXq5Q44D+DFsRfx8uTL7FpFz6Fr30R8gl3Dz+o6i9XQNQo9h1K0r4dex9bWrYXaOPovNUBwOLOBC7slLOrSWQ2xtAZFnTE7JeFGM1wPj2uAFENWjSAXa2Wirp1GKRnQTXNpIkJFcWfwE6sk6nThRhgjO8ZxXY1MMNDF3bjJU3FCRenNt1rNU6Uidyryl0wS/H3+2ma3BnE3XkFMnHn2mfjTgRfLauqsgopdnji2PncjTjVPwpJLYMyeRjAnwWrtwFhuJq8pSAKbVEKiTlOKt0GYNhH2mSJQBDMmpF4MdJ2Fo74t+Md7f8wes1Uw1RyvVSvaWXiP0vEyUVeK14GqvoPVxp01hQBMZiZrTpS45Vf/B25vC7buvMzgOzg3UUcYj53qoi7Pxg3rIUnCjKl0OgRF1WAuEXVpOQsbOuCyWtgHJYp8k02Qkhhp6Dw/GjsCv92ODmvHrCxmePq1+LqblJOwSTZmCbK9fTs778knjsx8yS6Efk8pURJ+BF3bdOuq9YH17N9ktUNTG+j16HHLvcuxMbBxVlYrFN2jKB73k+PMF1zYLVFRF4ml8NfX/CtEeys++MEPssJ66mrtCggYD2vMW0kwh9Hh8sFjcTODW0WRcd1Xi4VYJXEnVjBXnU36tdI4p2qQuFu/oh1P+3sRn8pHjirdfKmOjaJjOopSR1gIwP1P34+3dV9Z3+x2WtzlZKHIxJjE6RtDbxj2Q8Ma2/R4r0AEXeYcTFPDUNv7MGVrR39mWmAaat5I1FGkjqIHRlFnUjKwZSNYacsiqki4O+TFfWEvNpz+WeQEKwKCXNiP1/tfn9N4rWYaPkp9B12W8nFnDtbs0exGoCz9Wi2FHIsE8fj9txYiqXrNXTOirnSOKx07FLVMqsmG0sh0fpCpNEVSJVsAY2ENVqsKh0VDUptg0RyL1oE2nxUbeyRW/kDirq9FANR8V62OzWYrms1aep7nss1ZuxD0wSushLlPneG6SxYjZBFCzQv69Zc6SZ8YeoKJNIq6USNCNfsYSo/u7t3NBDNNF6LrBn01azejQ8/joo4zn3Bht0RE3RQN9RYFeB0Cq587MJq3TlATo2xGpMkksJFf+4dVJOU4JEtxgwFdk6ppoFJxF3CWm6s2y2wmGPhdInbt2IgHHk/l/dVM5TVcl156aeECSx2yd911V10RkcokkQ3mYO1tYD+UDNq9WqGhQs2OwOyXkIwm4Y6ncG4ghkv9UWx0pOAUVSRVESNZE7KaiF6ZGirKRYYu6vLpVxOzO/GbZfhTI1BFC0L2Ltw4JODhsAf/12f/EReZzUzEPP3SEfz22RcBk5V1jT78+EPH1G/P6DsoW7WycWfGujv9g0KjNY7GiGNhrFslDJFUSsu2+TKYSDcfqdOhY2fXhbvw8FMPN5xGTmUBleqwgi/hzDXvRjwLvDgYQk5V0OftQEYzY0WbyBoiNvZK6PJr8DpMRSKukfM8h+aEnclnYsKu19e7ZMyHqQGBas/oAyWtLQm0eoLKuB90bNKxcXrX6WwKgzFqFkqHWEcpbWc96G9SJyp9cTiLDS7sjhELeZGk1OqrAwooYNHlyzc5DE3lbzaUwtQvRGRToopRZGdhBaKLu+Gwin0TEQgWK+tSbFTUGcdnzWWCwbYtq3Df/ffB7G2DYLJAjgQLkToSdbqVBom6mvNbS8aEHdp/CMt761/QCYuU9zQzeXrg9ndhu3YA59pCOKcnDp8p74wWypkwWjLeS5HlGqJOhRMKfOkJaLYsQrIJr7Wdg8G2HRi0L8P//O6bRc/bt+8NPPD7W5lpL/m7kRUIrUelRgkSVRSx/da3vlUxHTtbvz3dd9BkFnB0MgGTt4Wtx2y68kprHI0Rx7o+cdPiLpHNITgWRYdvdqKOePH1F/HUS09DzfmhaQJmgo4zqXe2ooLA5iS7HRr7wCSH97FJLF6nirRpBD3tOSSjvQjHzVjdIaLVIxRq5gIuYcHFEIk6s9/MPngtFVFHjVV0jJA4o9mo8Wwcw4nhmg0Dxv1os7Uho2awrWNb2XPotXd27Wx6+zicxQgXdktG1GmwWwT0T6qQ1XwdFNkmGJm7v5sG0TIJCArUbDs0daj5lzCIiPrjnCpDkToSdZrshSpn8a53XcxEHH3pIuaee+6psRHls1+feeYZdHeTpUl9fvSjm7DRGcEFbWO4yJlEBxKQtBwisoQjaQvUKrYoEvOZm4Gc6elHAWThsihIKSJGncvxb38247GIGx97y7tYlEsr6Tilom62f7Qe5glm2qum9PXIF/A/XBLlImFPBs6lYncuoq54PaKF9WgWvQGnZo1jHQQxC8kyAaRcULM+wCE0az3IRN19j98HNeOEkkxAiRxhpsBQFRahFaiwXVWhUQpVENHh/QCiGaCnZboRwjDBYHvPSqRabDg8rmJ5m8QE3bESQyR+SNTlpnJ5v7wTRNTRcUAlIhS1pk5Vo6iTBIm95lmdZ7FOUhLt1IX6+NDj7L/GTtNK+0GTGeh9oZo6SrNyOEsZLuwWmIW8SNKM1tcG86Iu4MpHJ0jcUZpOKbFgmKuo0wvBZS2LdW0B3JfNVBxUX4tGGiUanf1KkSESEVTA72npq2tZUUvU6VTyLzNapHSYc9jtjeHSliNY58zALqhI5ESMak5kVceMDUkFSGza7fbp19PgMWvwpcdhkjKYyEj47VQLHgh7cOkFH8Xvfndj0ai0Utj+xWPT+6GxSQxk2mucZRqrEOWiaCbZiNzzhz+w389W1Bnfk71H9sLd7kaP14VcZKJqQ0VVDA04dWscq73E9H44LCb0ef0YC+etUCjCTJHmRqD03uMvPA4lrkGDDUp0P5R4f83nbOmjyRUmqIrMRHbpBAOHGSw612jt1XxFuJg9x1QOcrg8QryYRB1dU9jILDnFnkPvvNvsZpG4odgQi66129vZ46g7ldW++WdEGYk5+tmTw0+ybabaOZfFxfzfSveD5qeSQKTmh9nWwnE4JwqLRthdd911+MIXvoBPf/rTuOGGGyo+huwaLrjggrKfv/7662Vu9ouBhbxIBmMqnjsgs7Rrq0csHySvlHcpzlXU6ZYmNHi90qD6+WqUaNxCI1zmq1YzdVdD1BGVxOB///gHON8bxUX+KM50J+ChVKsoslTpUIbWgiJDOVY8X+QxV0JrayskVYYtG8VqRxZJSBhyrcK3Xhpj0bmYkl/X/h/nO1yNo9JKjYNjsWjZfii58kH1tfzivnnDN2e9HrptDNXU3f3w3bBpNly651J88X//HTOTppo7U2KmoaIqJQ04dFxV61SttqalVjlWS76GjWpBqSa0EXFHx9WBwQOIj8ehKT6ouSCUeHGXbTWcNgGJlFp1gsGxFnUU4aL3YbGJOjLhpdcnSMARZNdC3akUnaPH0rWFGhOoQ/WuQ3dBkiTWoUp1dKe1n8Z85EohaxFTj4lF7WhMVygVYqO7SCym1TTbD4r20fVnc8vmukbEHM5SYFEIu2effRY//OEPceqppzb0ePIeo5oqnba2Rej3o4FdoGxm24KIupeOyiwNS6KOInTVbl7GLsX5EHUzg9dnBtXX8rmbbaNEKdVmv1byVatod1JH1BWjYbMjxbpaL/JF0WHJsU7gsCLhqGqDJgtQcwYXN43GXaWriDsNXklBr5SAkEkgLLnxX/EOPDjpxpv2/A3u+n3xh5hSAUNi0zh3ldZDtisV9qN4UD39+wN/+W4sX15eN5jTcgUxZM1Z2fc6dF5deOGFZbNeS7fR2I0cTURZipeigfkPWGqhoaKRRgm9ASd/XJVDH+bIHLnRCDAdh3Q8NiLu9ONKSAtQUiJEqwlK9AigNSaMSKyMZcbwT1/9p0VTi0Y1dbUaM461qCORRWuzvWs7E1kUfaPuU4qwkaijL2P0nqJyb13zVvxp7E+sOeHUtlNZ00Q1ulxd7GurtpUJyEcGHsFgYhCntpzKhDUJPjL+rSQMOZylyHEXdnSTeP/734+bbroJX/nKVxp6Tnt7O3y+RnM9xwdKydAnxo2ejXO+SPY4lyEri4inVXazoqJtapRY1y2ylFO1m1dpl2KzVJsooaq6qNGQiQzAEVhRVdw12ihRq2vSmEa2Ie8tVctXTbesKETgGhR1beYc9nhjuMwfwVp7BnZRRVwRmYGwLIgQzCLrRSkSdVXEnVlNotUswy5piMki+n2b8Jp/M16QWvHzx3/DxOmbmk0JTactA21+WHM2ZHOlEcYZceduXY2Orr6KxyW9hi6GPvHpTxQi5MbpGLXSr9X83WhiBY0H030HJyOo6DtY2ihRrwFHN0cueivMArw9Xmw/bTse/O2DZcdVI+JOP67sog9mkwmSrQVyYhhqcgyNQAJlODq8qBoMFmOjRDAVRK+7l/m8NRrBpHFbFKkjf81G3xMShyTe3rzqzXhm5Bn2gTabyTLfuc2tm2dV+sHhnIgcd2H3iU98Am95y1tw8cUXNyzsaJROOp3Gpk2bmAdVpfSsTiaTYV860Shzl11wKN3Q6+yd1UVyPJbAn4eHoSkeOMV2DKoaK7TPyfm7F9km2C35i1S1tJNei0Y339mKukoTJajb1NiY8D+/pHShB2eedwW5gBWJOxIRc22UMIq6kcMjFZsiqAO02FdNm2kUqCPqyED4LE8CF3ij2OWNs+gavc3BnAnDar6rle4HNUXdNIKmwIs4AjSEQAOG0mb8YcyLB8MevPmid7F0uFN0ztq0t5C29HTjsovKGyGM4m7Hnt1M9NPxYVwPEgBmg8g23mhJEFe78Q4ODtY17aVzi+r/KEpI4k7OoWxChf5hYU6NEmYBF191MZb1LGMRnbO3nF3xcbXEXTgdwWgsCpPmh9vhxtb1bjz828MIhaibuIFtMjRKcFFn+BDq6mHvCwkympxA60xrTkKt2dq22c48pXTuRcsvYjNbSRRSh/VsLJk4nBOV4yrsfvnLX+KFF15gqdhG6OrqYinbHTt2MLH2X//1X6z+iGrv9uzZU7V278tf/jKONXQxsZubr+cIpxJ4/MA44kk3Ol1+5EwiyPrMbiG3egFSSdSh0s0rlos2Pc6piCoTJapZiFDN1wO//z+46K1/WRB3ELNFkaHZNkoYRV01+xI9TWf0VevoW4d3vuuduP+p+5HKJsvSluvtaZzvi+ISfwxdLNWqIVyhq7URUUfikKJzNklDVJbw4JQH96XX4JmYG8n4GCSnWEiHGyOOAwMDjb0RBnGqpy0LjRD33FOhNlDDGVuWIZgQCpFUWg/dtJdGJDUrshOJRN1JDKWpZLJCMUZSW7wzEeB6jRIWi6XIOJj+Tb54X/+3r7MPCz2dPUzU1TuuKp0foXQUA6EE2lxerO/woNMnMSugj33oKna9qIuAskaJpRqpo79Bwoz+RiVhZtwPGrk1lBhi4m4yNcnOXaptI6FFqdJjCZ0jXMxxTlaOm7Cjmxo1SlD6hhzXG4HSPPSls2vXLvY6368GIZQAAFF9SURBVPzmN6sKu2uvvRaf/exni6IKfX2Nz/KbLbMRMolsAk8fGUEi6cSGDj/MUvWLfem4ri6/id28DkzEYbaV16I1TJWJEgWLjapoeObR3+Ndf/W36A9mIVjHYZuFT10lUeexePDTe37alK9aKKbC1NKCy6+4HL/80S+ZiPjw29+E0KO/KBgIO0QVCVXEcCZvIFz2VtQQdTTiizzraMyXognoz1jwh6l8dG4wYwEkGZLTDnNrLwRpnK1HacSxps/ezB8qijgab1Z6I8Q3vvEN9j0JPf01876DAhMz+nq4LHl/N0Vu/rgQ7WJDkxhK6xv1SGoooSGcm4TVNtOA0yzGCHDpTOFGxd3LQ3EoQhxr253YsdzPmh+M1xO6XtCHx2AwWPQan/rUp5gPIK3H9Tddf9wjdcdiogSlUOncpWNuKJ4XbEZxZ9wPamIgTzky+N3VvYvVuj07+izLNGxt28qixBwOZ4kLu+effx7j4+Ms+mYc//Too4/iO9/5DovIUVdUPXbu3Imf//znVX9vtVrZ12KA5khS5IKaH2JpYFOvxOxJ9Ivkn0YGEYp4sLIlUFPUVTL//fd/vx6S24Hz3/oetMAPt68xsVyvoL0hC5FpYtEIEuHDSFicQNaO9hb3nEUdpWOOHj3a0JxTY83dZDKEUELFSpcP5zkiOM8bwzviv0Kyb4QZCFOqlSZC+P0BZKemGhZ1NjEfnbMIGhvxdc+UF/dNefBMzImcURxSV6o2BsnRAyXZjuHDo7jjt9UbEirSQG2gcRB86QcWEnd+dxZjYyG2Hj2dfiaG8hbKjUORuseff7yuqCsd56ajZcNQpRDCCQErrNMRYCkfhWuU0trAZj84Ufd4Wk0gq8ZxxionTu1tKYt+6+Ju69ateO9731v089NPP33RROqOxUQJ8pOjjlQy7aVzkCxFaDaqWTKz/c8pOWYhQtFf2gaK1FFN3JldZ7JGB7IVoaYJaiCj+joOh3MSCDtKob788stFP/vwhz/MohAUgWpE1BEvvvgiS9EudqhzlYyER8IqeZyy2awOC7ChR2IXwNcnj2Ii6EWLPQCntfmLPUuTOWQsb7Eim3ViLKqUDaqvuX11Ctrruv9P1z6NJUewun0tM4kdj6oAvU4V641KVPLba+RvG/cjmJjECvUo3pIdwuoDfwZWjUDUFHLJKku12m02TNURdZSmpcic16Qgpwk4kray6NxDYTdGspZCpCpn2E5aj13nb8eTD78ACB146I+vNrUezXXx1hBD6TE2iYHWg/zdqOauGUmkp1/jk/G6EWDjOLfS/bBZ0wg4upFImTAlqdMNFo3vR1FtYMkeRJIakhmNjcWTRMAsUckCCdv8eUaNRmPRGItkX7DGjbVtrTX/nlEsGxslqlmaNMqxnCgxEh9h7xtF3Y1TPKju7FDkEOK5OIuukTijfxtnndLzKJW6rX1bYWbqOT3n4IWxF5iwa7W1svP0leArTCTS+brOt441KOjnLAlv6malblTqeuVwOCeBsKOuxS1bthT9zOl0oqWlpfBzSosMDQ3h5ptvZt9T996KFSuwefNmFqWiSN2tt97KvhY7I1MahkIqMyy1mASksxoGgxpcjiSCuaMYm/TCogXQ6m4+RUWfrvU0WZvTC9UpYmBSMQyqr00jBe0VLUQqdL+67W50OtuZ8/9gUG14G2qZKNf72zpkS9I3eDcujr6K3kwQFjWHJKzYp7iRk2WsNLuhgsaszWCz26uIOg12RUaLVYFJyNff3RH04f6wB93nvQe//f2dRc+7+uqrC92luhjasGwDHo89DkjDSMLgMVdD3FFZQjqTLog6W86Oy99S236kEnRzptmX+sxUWg9qpqB0ZKurMZHYSE2dfi5Ts0qpl2RpBNhlszJRRzWQpJobEXe6qKP98Jj9kOxd0AQBOSVvjE3/pXOJPiCRmIumNDa7NStr7AMUaZVELga3dxKn9vjQ45mFNZIAZp9Boi4zkpmVF9qxnChBooxef7lzOY5EjzAjX1qLsfgYEkoCNtGGtb61cFqc7AMcmTPT+U81i1RyQaKQBBkJNV3sUZ3cJcsvKXxPj9vQsoGlaClSV5qmJWiCxGwbIDgczgncFVuLkZERlgLUITH3uc99jok9cvEngXfnnXfi8ssvx2KDbja5adeIRFrDwTEFNnNe1BE2i4BQMoNnjozDY3NDzbawIu5mO8eYT12uuFGCaoo66XqqD6qnkEUDlia1CtrLLEQqiDq71YFTVpyST5MJQAdZDSrZ/ISKOrZgtUyUa/1th6gw42AyED7Ln0TPyBhEyYqM2YOkZGP1XTk5yt6LeqVltNlUnxcQc3AJMtKCgL1JG4vOPRJxYzKXrxO6Zu06AMXCTl83oxgqeG8ZBtXXE3dGUXflhW/D+tXrK9qP1NwPs8BEgN1in5mZKuQbB6jmjkyl60VSGxV1xJVXXslq/RqJAOtWKI2IO6Oo81vbMD6lQE6OMGuZYAywWTWEYjRhQsTyNrEotUrTWBSVRM4EJlJj6HTOrhbNmH4lUadlmo+czudECZXmBQr597cSFIFLy2mc3X02S4GSCN0b2suinesC69gXdazSeujbcSRyhI3mSuQSbFvp/KtUF2e8NtG/SezRF4fDWVwsKmFH3a1GfvrT4oL5v//7v2dfJwKvDynoD5pw2jIZyQwQT9MNaObCSDeKrDCGVMoOGwJo8xTfmBqh4FNnLm+UIHGni4nBYA6/+AkV2GsFvzjWfPH165mIePdfvptZaNQqaG9k1ujFey4uSqGzCRjT2zAeEaqKiXomyqV/mxoXTnGmmOccGQi3U1erJCCimhCzd0GSDDckTYOm5lgSNKeQeDOz74uhEV8qWiwKe9x4WsId4QAeDnvwcsIOrcGhozXFUCPiriT9unr56qaFvr4edFMuiLpp8g0VwGAQNSOpRqucRhpwkslkUxHgRsSdHnE0CRZY0YapuIBuPyAHX4EgSqz7maLgDquAlR0UrSt+n2g262RmHJPpuYs6itT1OfuOq6gjgUtNRGpaZV/98X70mfqK0pzRTBRTmSk2D3WldyU7dk7vPJ35uNFz6T2odDzRdlGU76XJl2ASTDi351weaeNwTmAWlbBbSmiagFhKwKOvyXDZBBZRMNaw0IXaZrKgszXAbr56JK9RjDffqq7s02IiJwtlN/JmnP91Si02jJE6EnUbN2ys9E6wv2s2aRXHXTVqokx/++q3XwL5ud9gj30Mq2wZ2ESNGQgnPR2YjESh5VT4aVB7pa1QczDTPZWGuevfCxpc2SmstmeRFCQMulfhP19K4XHDiK/ZpMMriSE94lhV3M1DTZ1xbFu1rlESd7UiqeVj2+pjTJU3GgGuJe7ouBqMUkemHR5LC6wOEavaRbQ4FUDNUsAOazoFHJwQ0BMQ4HUI824FYhR1C5V+pXQmvV/Gn9PP6L2j/9L/SKyNp8bZfkSSEWRHs0juT2KTfxMG0gOsc5WEG0XbqKGBRN2mlk2Faw2lQ9f619beVUHAltYtLCVL15IV3hVN7yuHw1k8cGG3gATcGtwWkXXBJjIaE2/xdBzfu/m77Ob7mY98BlamNpqjqZuvkkG7VytKyzbr/F9r1uhF51+M01afVqfZRUO7QUzo4o72QRdDkbEIWpwtLO1otHGxiwp6wq9jRfBFdKX2wbI2jtFgBsGchKQqQjRL6LI7oE2G2Q2/XmekoGTgMQvwizKgKUhJdvxXvB0PR324ePdncffD30KzVEqHV2oWYnVylSJ3glZR1NHoPKo3nZn0ke9OpukQpZEXEkNkf/HB93+oLFJXSrVIqp4ODw2HGhZ1JFj1TthKk0pqdb6WijuaLSvaXTC3BADVjPUdrej0m9Dqnq5LTc/sM9Wqupwm1oA07/5uhkaJ+Uq/0npRo4FRxFF9Gn2Yog81AXuACXPqIqVmB1o/6ko9GjnK0qc0fislppDuT7OI3fa27VgnrMPB8EHWrUrp6jN7ziz8rWahEV/n9p7LInZ8QgOHc2LDhd0Co0ci6OaVVTJIKvNj2tuMT53VhMKNfCSiweKYm/O/cdbolhVbqoo6oyAZGhwoEjRkBXLr728tiCHjwHvqQt3qSiL182uw0xvDpm4vi7JlTE5M2TswkEmw1xSpyUEEu6nVE3VkIuzJhrDSkkBMs+CxZBfuj7jQecY78Mtn7mTrcWmFNJnRG86Yxm4kHV5qsmsymXDXXXex1GXhvXB1QzSTyNbK1uOBBx5g7y15PeoY3ye9oaJW+rU6xZFUWg8S2gFHAL95oPFGDdoOEhLVxs/Vw+eg5+YtgMZVFW/7q3djRRuwtbsbbnvtyxMZdi+EaS9NTphPUUdijnzd6JyjTlQSUTSsnt4j6hzdN7WP1bnRQU7RMoq40e9IYP55/M+sAYL2aUv7lumu4DwuuNh+UvqVZrDOtVFhNlFJDoez+ODC7hiJOxJ1R0JT8Nhs82La6xCbtFugSFFyGJPJCKSshtWB2s7/c/UTKx09posjJiZae5m/Wzw0VCSGPJkgHH/8Mf5zfQQrbBlYhXyqNWppAfS6uemZpbqoo/SrUGEbSCwcPLCfWZSsspFzm4CY2Yf/GNGYTcmgqROWljZcJntqrkctM+uKjRJ1op3U1U2G2vp6WNuXAWInsmODZetBqdtKHd/081JR16xprzGSKlpkth520YvoWLQpz0AyDJ+tqKMOVrIpyY/5kqGYJrG5V8OpXX3HdRLDfDdKUCSO0qpU93Y4chh+mx/RXBS7unYxvzeyJHl18lW2zWv8a4qaFqjejY4tGmS/3j9jzq5DojpgCzS9nRwOZ+nChd0xgN0ohDEEnDaoWS8ES/lg9GatQIxRo3rRMja6imq43Co8ziQEpYuZxZb6qtVL+VWaNWpMm1I0q9boMYLGa9EkBjLtJX83t6UfZztDuNAXxXZXEm5JQUYTmIFwSs1vo1s0zTiXaVqRqKsUqZOULJy5CFbZssxEmCxK7gl5cdZ5n8HP7v52Xgw541BTJohyYFbroYu6v37fX6PV1VpzPYxTQq655pr8D6fXQ1NGoKbaIVq6oORqW6GUYhR1s40AkxWIvh7JlAfxaLEdzGxnCpci0/Bclg7PH0+pbN6mZGOvBIs5jf7YAPx2C9YEjv94LfKpKxV1ZENzxx131N6GxDj2Tu1l74HLMTO8nurgOh2dbCIDRcVeD77OBB15xBHUWXpe33kVX5N847Z3bGeC0WVpzPaHw+Gc3HBht8AYLRt6W1sRjMhlg9Fn6+9WjbJo2a23FGq4ut2tMEsWDEzmihoqSp+jp/x0f7Ji64nqs0ZrjR7TxRDiOWwV3sAFbRr2uENoESm1qmJKlnAobanahUp/MqNmK4o6YdpEWB18FQlNQKZnA747TNE5D4amTYTPEE0lYmgCfocwq/XQI3WzSn8ZGyVCCWjqUENWKLVE3WwiwDO1gTKUxCAsJiAr+Bo3la4yU9gYNZ2MUk1n3jhY/xk1E0WTGtZ0imj1pnE0dgTt7sUzM1VU8hsrSALMATM73tjrmzpYOpUsRUjQklgj4UUcDh9GUkkymxHydKMIHHX1UslERs1gtX81e39IpJHvG0XpGt1XEuxc1HE4nEbhwm4BoS61sWS4YBJLF+jSwehtvvkVdVRwX2RmW9JteeTAEVaQb/S5e33vGxXHXVFKjiJvV73rKnh6PIX9qDVrtNroMYrUrfblcI44gYv7ptBnzbKu1Lhmw6DsRk7JMn+yajBRp2SgaWqRqKMRX95MECttWUQUCXeHvLgv7MXZ538KP7/r21W7RnUxROPH9PWIFLt2VGQ2XaNGjN3IlowVWRbpa9znbj5FXWltIHXLSlI73K2rEZs8WFXcuV0uxBLxijOFjYTiGjwOESvbRdjMJKDATLrHIxp6AiI6Axkm6ubDCmQ+Z6bSJBiT1wTRJiI7nkUumGPpThJqFK2mYfe0jlT7RvtOkTqKWF65+ko2M5UQIOCpkaeQkTMIWANM7BH0fEq3cjgczkLBhd0CQZEJKmrutbsKYuir13915vcAwkkyxK1u0tqsqNML7gtUsNCg35Oxs9Hnrta4KxIRDz/3MN7Z+86COK01a7R0/JdHkrGnPYlLW6LYbErACQVpVcBEzoQ0883TIFC3qmSDpqQriztNY5E6EnUWEhCqhoBJgc+kQNYETFlb8Z0hAQ+GPRibNhHeWWJ7QvsxmZmpDTTuqj6oPpwUIFirp2X1rtFmGleKNwKYzEwW1uOyN70Jv/vd75oyMZ4PUVfNKodq3bp8Is48YxsefjRVZk2j78SuPRfioWcehSAmymYK68RSGiRBwLouES2GaSrUzUojwCCmMJBYfKKOTV5IjEBTNcRfjiMzmmEn6/k95yMjZdi+0ntGJsAUrXt54mUmbt+6+q0FUUeQeKNoJpkDU4NEM53nHA6HMxe4sFsgZFWGWTBXFUMkHshktZpJ62xEHVGIllXxRaPfU1Stu7u7ICaqjbvSRUQiksCPb/wxPv/3n8/Xt9XxNDMLKquXO88Xw3n+OAIWmem1YEbCqEJp0eJUKwk6EnbVxB1Lv0IDWbE6DNG54Lo34fFUO37w8OuYKgkSHjhwoGw/TIbawFLy66EV0rKl4s5ootx044phPWRDN/KaNSWRmxJx5xBjiMWi8y7qakUcSdyddWrex+yZZ1+cidyJZojWANsPR7sfglmCHA+wKG4pVDtHTRFUP2cUdWwfBAEWSwqHo3MTdSSayN5lrqKO5qS229tZByqJNXpdEm4k6uSwzD6o0KhDwo0ZEUydrWd2nsnsQahGbpV3VdHrk38cCTpimSdvB8PhcDjHguarrTkNQakYn81bs6Cd0rJ+l8DE3VRCnbOoM/zxmma3RVG1aTGhp2V10dWsiMhmMviff/1HmO/7N/yfzf345qoBvL0tDItJQ3/KgsNJC2tkKBV1OrqgI3HHZntNQyO+HNkozKMHkRg+hKC1A/8+1IkP7l2FH2W342u/ew5Tsbz9iRE9Embcj1Zra839MKZlKXLXrIlyI+nXVmvtbuR3vf2KwnrsOPfyWa/HXKxydHH3tivfwo4Jwd6BS97yF1BSIxC0l7CyK4jU4WehpRMIJWYi1OTVOBYmz0ZgWauIvhZxQSYxmHwmJsDmIureCL3B/N/IH85qyo8Mowg7pVzP6jyLibp6kN/czu6dVVOrdKzs7t3dUMc0h8PhzBc8YrdAmKlQv4EuxVKTVtEUW1BRVzopoFKkSM2OwOyXGhIRbeYczvXEceXBH+Cta4/AKaqwuH04PCUjCwmarEGb7oishyTI8AU6EAxNwaol0W7NwSxqkEQzbpv04b6wB7sv+AR+dee3ytPO89Q1qqdl9cidcaLEbEWd0QyaxEAtmL3K9Hp0di/DRW/9SzzzxO+QMacK++Fxe3DhhRcW11LWofTDgu6vV62bl8QdWaEINLIqF8ee01rxwN172UfB1b4eqLEw5NxroCbX4SkV5Fhit+QnrHT5RTYNotQodz5EnbnVDLPfzFLAsxV1lB6ldb10xaUsfdrmaGMpWBJ3VAOnZWehmjkcDmeRwIXdQtGE+bsu7oamEhDMMfT6Fk7U6ZMCjIPljeOuTJ4eWPy9UBOjyIWpoaH8z5iUDM73RnG+L4Zdnjg8kgJfIod9iojRrAnLOtuQjQ42JeoCgQBaAn7YsjF4LTHkRAlHsg78btyFdTuvwVfv+wl73LlUkDdNLb+1uUS4dHFn9rZhOJZoulFCt36pNzO1JkqGNbhoQjfOfsvb8eCdv2Dr8b73vo/Z0BjXrx6ziQBnchqCcQG54KtQwnuRM50LwYqi8VpqehIbegRkZBFepwi3XWDirhJzEXUkuiiadjB4kDU1qDkVbrO7qnCjtCp9EVTbpgt6PVJH78ebVrwJp3WcViT2Kb1KJLLlEWAOh8M5UeDCbpFAkToSdVrOC1V2As3WWjc4a1SfFFD6M4r+CGIWomUcULug5toAbabmjuxE2uOHsSr6GpZNvoDLVw4y7RqRJRxJW7DC1oa4Qp5oAmRNbkrUUWfrCocKU2oMKZMDd8U9eFBejWen2pCJjuAac3Mit5qo0ydBGH3laq6HyQIt54Mqk4hozueu0ZmptTciC8E6BSFtLawHifJmRkbVE3UkQEvHfmVlDaGEhuWtgBx6CdZ2sappb7tHgM1W+zIyF1FHYmwwPshq1s7tOhdfeOALsHZZMZochdvhZsIsmA6yWakEfU9TGOiLTIHTShridMUJTX8gLl5+Mba2b+WjszgczpKEC7tFgH7zpUgdibpqDRVGisyEB/rLRB2lW0s7VPVJAZV+RpYmDz37EJLRJLKxfkiOfFr2L/esRu6523GJP4pd+74Ps5pDRrLiYMaMnFZSGC8JEEwCKyivJ+pIKFJXq3+6szVia8OB9p142tKJH7z4O+SmUhAtuYqD6mu+7jxagciRILo8tqZ97kpNe0XW/dsctB+UwnVZ7Ghv8+I+cWbW73xH6hRVY6lUEoxkJByKaaxGblmLxkQdjdfqc/bN2ySGekKO9psgMUeecfQe7uzayYbd56ZyzI7kscHHmOCjaJ7H4mGNDC6zi6W6qVuVnku/o/2fSE4wYXpq66lwWBxsAsRs0sAcDodzIsCF3XGm7ObLInVqTXFXZCYsAHc8cEdZpO7qq6/GDTfcUDbvtBJ00yOfuqs6r8LPvvszuEUFu8yv4qKuHC7OvIZszxhymoC0qRsJycZETk4LlnUBk6ijSB3dVEuhOamUPqSZra1mGTZRg+huwV39Mu6d8mD3JZ9GUIkhlU0V9oMmMZQOqjeip5DnIuro5m+c0GEcE0bpV2NDRSO+g5VMeykV2wyls1/JKkevgRyLAr0t2ryIOhJxtE/kL0evKIn5f7f7RKzuBI6EZ2amzmaOaD1RRz6PtI0k2PSU6HBimBn4UlqUonDrfeuxrWMbsyLRoW3Z0bEDTww/wfaPBJvPVnlhaN/pb3M4HM7JAhd2xxHdF6305lvaUGEUd0XjumqkXw8ePNjQvFM9MuQ0W7BRnkJr9wizKSHxRX9A1vpwJOeBqmSwRrJBpDSgQQyx16iTfqXo3PruAJLjA1A1Af0ZC+4M+bD6XZ/FPz/2M7Yf6zJTTAwVpy2LB9XrUzJKU8j1RJ1x3Jkx/Ujv5Y9//OPCz2+/+/YiUVfuc5f3HXRV63+YXo9apr31MJoo67NfmVXOdENFVgZGwxpanFrV/WtE1JHPHHWxkh0JRecoEDgeUdnrr+sCRpL98z4ztVTUDcQH4LP40B/tZ00MVEdHou3MrjOZhQiJ7mppZxKDF/ZdyARgpQ8SHA6Hc7LCr4jHCaMvWqWbbyVxVzSuq05NXcH4tgb03PXtOewOPoPtiYNwp8YRbptCTBExkLGwFOkKmxOaQLVztrxYKrnP1kq/Uu0cCUSLoEHUVNw/5cF9U148FXOyNO41075oRjFUnrbMD6qHki1Ly1IKmaKR9zxwDzLmdJGou+KKK2q+B6XzbEsjdaUU+Q66pLK6NKOlSTXT3nqUmiiXdfFON1RMxjUWuatkKt2IqNOjdJt6JTYBQp/f2u0XkZVlDMb7q85MbUbUSdQVDY3ZipD9jyZocJqccJqdzFiYTIE3tWzCnyf+zDzlSKDRSC4SdWzv6tQSLtSYLfKtM0ZyORwO50SCC7vjQC1fNGNhP0ViSETo4i46OZBPPTbYKFENWy6GvrHn8J31A9hoTqJ3fBKqZEHC7MGhdKTosVR7pRsIk6iyWcpFnTH9StE5ey6GVbYMS98eTVtx95QXa87+FP75vp/VFUOV0pa0DXoqsjQtu3LtSry17a245Ze3FEXqysx/a8yzrSfqjL6D5KtXGkkttTSZrairZ6JM0MQQshMZmFQguZdDSY4VREg9UZdTNEQSGhNym/sk9jrljQr9ZTNTdUSHCEEUCh2ntUQdNSxQrdvmls3ocfewVD11mx6NHcVUegorPCtwVtdZLMV6tvlsPDP6DBNqq3zFRr8cDofDaQ4u7I4xRhHRiPUEiQc5l8X3f3Irq/WajaijGz9NgzjdncSpf/4htmgDMGXDiFjibBrEMLxw2GpEKWg+q5Jm6bpMjoxZi0UdRepMaha91iyLzlGc5c6QF/dOefF8jIaICfnoXI3xWvXFUHlallKFNL+TDGabaZQwzrNtVNRVi6RSDR51v1Ia+dP/6zNzEnWNmCjr4q7do0G0eKCpMkbCGmCKQpXCCNhmRB3zZssByazGRLlZFOCyi1jTKaLNI9Ydr0UdpfkNBEZToxCtIvN4CykhfPe/v8sEpM2StwjRRd2hyCHW2ENNCptaN7Gh91QrqLOhZQMTdiTi9Lo9+vee3j0sQtmI1yCHw+FwqsOF3TGkWRFhjBTpBfySxwwI4QZFnYZNjjSU2/8J/71hEt3UZTrWj3HRjLBsQjaTD79Fh4dZc0Nra2uNl1IxNHCIRe46OtuYqBNkFX5BhtemwJmLYu90dG71OZ/CV+77aVPjtSp1+1baHz0tS357w7FJeBw2+K3+prpf9W7hRtZDt0ipJO5CMRWTyRCstnz361xFHYlTm9VW9vcqISsC5NhR5CZeRE/75TgUTEPIBOBwupigi6bygs5mFuB1kJCj/wrMa06iEGgdUUeQsDN5TBCdIquFi/0pxt6r87rPY+KOauOCqSCrc6Nh9/3xfjZijMZrrfWtxZa2LWX1b/Q9GQKXwuvkOBwOZ37gwm4BSCQS+PrXvwGT24f/+2NXs8J24+B1XURQ5IjMZhvxJdOyYSbqbN5OxEdIDE1VfWy3JYvd3hizKFlty8AuqkiqIkZlE3ImEyCDmbwaoY7V0dHROhtBz8lAklPoMymQhCzCsoTfh3xoOf1D+N8P3JmPzln81V/DEHEsHa9V1O1bZe4raRKajEEmytGEA31e6qhsxowkP3ljtiJbhyJ1JOpCCRUrrB1zbpRo1polltagMFuaOIbGnsHO9TsRiboxFFJZbwsJuC19ElpcIhzW6vVqlUQdNTYMxYdAPRtqVkV6MI1d7bsgT+ULHHtcPVjnXIf1gfXoj/VjPJH36+t0dTIrkW5n94LVv3E4HA6nNlzYHQOqDV7/xS9+wSw7LrvsMmzYsKHq8/VaNIrUnb7+XDwykYRg1YoG1bslBWd74rjQF8U2V5J9TzVuoZyEYdXEaqMEs0iBpjJR1wgiNLRYFXjNWTjEFMbaNuMVzw585fZHMZkz4Rr3eii4q/aLlKSRjeO13njjjaojsoxNEJqk4QN/+1cwCRao2QDGwkCrq7kaQ0+HB652F+Lj8VmJOt18mCJ1JOoSKROmpNq+g/UaJWqJOorAiY4OQJXZv196dR8eeuRJiJYgTG4zbv7ezfit9Ftc/ZGPYsOaM5nXXXdAqjoFQieZTWJ/eD/ziqMoG4lTirwNJYaYyFvtXI3I0xG2bZXsTvw2P/tCeQCOw+FwOMcJLuyOkaVJaDhUUURQrRd1Z1J3ZyVxV1qYf8aWdaym7PGnX0EmrGKbeZjZk+z2xNDCLEqAKVnC4bQF+Wo3gMqWZivqzEoGy6xZmCUNYc2M20NedJ7xcQy71+HohIIpy1EgN8w84GphbJSolEauN/fVaM1iJ9NemhPqEJj1xyj1e5T43BnrBY2RUVoPEjLnbj8Xd956Z9W/VWs99IkSevqVRF0jptLNNkropGiym0z1bipeeOUIHnzoEXJ8g7VThpzQIMdkBJUgrv/adbj22muxa9eumq9H+zAQHUA8F2dD709tO5W9J2T4S7/b4N/AauOUjDIrg2cOh8PhHD+4sFtAJLvIInUBRwC/eaD2wPZ77723bCqEPsGgaNaopuHiVXa8y2qC8/U30GOKscaIaA7oT1tYKpTwer2IRCKzEnUUnQuYZXgkFXY5jj9n7bgvG8CDEy6MR0V83rMWhw4ewD33PQRIHtbMcMstt1Z/wZJGiUq1gbXmvhrF0MjQCHZu3pkvsheATh8wGMSMz920uPvBD35QFhndc+keBHoCrOh/+cblsL/LzlK/xr/t8Xhw6aWXNizq6vkOltYNDowM4AN/81ewSFb4zeW1gSRIaRKEsQ4ulgbU5CjrgH36jw6IdjIPmUQumkN2JAtLK0UvVRYRvummm3DWWWdBFCsLTNoHqo2jCNylKy5Fq6OVNTdQIwqlVKmuboV3BftZIsNnpnI4HM6JBhd2CwTTHba8pUl0LFpXuESjURZZ6u7uLptgQFYgfi2Hc1pieNO+76MjNQCTnMKwGMe44kR7Vzcmjh4qej2nw4FoLNKEqNPgFFUW9TMJFPUz4dZJL9J9l+Cm0CuQ42oh4liUNpXiTFTNGAhrRTVxtRolZtNg8OyDz2LX5pmIlCgK6DD43OniLpVKFb1GUk3ivsfvwyXnXsJEHUHibeXKlfjGN77Bvn/f+95XteaxmqjTqSbujHWDtB93PPhb2C0OXLzzYrSsbim8SdQYA9GE8Sg1bGiQhLx5cCaX/7fkDAJqFLHwMzC3tENNhZioo4YGc6sZtj4ba3SImqJ48qUncfbWs4v2gwQjTXIYS4zBa/PiwmUXsmidDu1Pn6e6kTX3duNwOJwTAy7sFgoR0NJ5S5Ox+FhDTynMdp0WQ5CTOFOLYeXIg7hsw0E2WzUQyyFt8SBm82Iok4AgKsgpJCTN0AwecBabtSFRJ+nROZOKtCJgb9KOu0I+PBxxI2q1QnrmVSgGUVeWNp2eiGAUdw899FDdRonZdo3mtBwTwMuXz4yJ2r9/X9k2GNOyxkaJx+57DKdtOK0geoyRrWXLls1K1FUTd2MD+womyGw/WjzsPYiMpnHrbXfgrW99KwSTHYLFDzUzyZohdqz8ECCZsHdQQTRJNiUaHPYU5GgQ5oAZgpREdnQ/RJuYnwqR05jAy45mIbkl9n5HI1FmCkyGz7Tt5G1Hos5hcmCNfw1Oaz+tIasdDofD4Zx4cGG3UKiAksoLqlAo1HC3pqrKOK0ji92eSfzVoZshj5HZq4YIJBxJWyDaO4rGepGYM9O0JsmSn0Og5li0MKdma4i64uhcUDbh1+Ne3B/24qWEndXm1eoaLYs+loi7eHy4rFGi/3B/zX0vnftaa0xYQQBPR6LyQlOrKO5K9yOKaJkwrEWjoq7cCkXDPQ8+NbMfrX4IggW5WBKC5AC98Y888Tz+5u8+gzaXgn/87IfY9gZcAmw2kTUgvzoog7K4NkeYiTg1rcLWY8vP0VUV5CYNZs4aoEQV9nVu17mwOW2s25W2lyJzW1q2MKNgLug4HA5nacOF3QLBnEGm05aPPELF7rXZ2GLBm6R96Hr1Z3hrzyFYyeRVEbE3Y0JWq12QbyJhp2Tz4k4ABJPCIk+6qCOPOrIzoeic3yzDZ9aQUUXsTdjZzFaKzil2P7O50JCenRWIUdzRaDAzNXxohfRrvRFnxrmv9Wa/OhyOimbDpeIO2hgkh1y2H0ZhOJ+izijuhocGkVSsEJ1+mJwJiDYPssMvA9ow5DCNKAOmBMCTOwvL2/ogWkmQS6yhgfa9O2BBOidiJJKCz5GPyslBGS29LdB8GhL7E0zoGaE17+3txeXnX84im4OxQWY7QiO6uE8ch8PhnBxwm/cFpla3J1mSvNkfxjdX9eO/tgxie//taE2PYSoj4mDKgrjFX1fU6bA0rJqFaLECmokZxU7/Bmt62rHcmsFyWxa+1g6MbbgSz+78Aj66fwV+E/TjzX/xAVx55ZVIp2cp6oziLjkMk8cB0dmJ3JTScPqVGkfe8Y53MHFSS9QRd9xxB6tdqyzS8uJOtMgw+3ugJE1l+0GR0YUSdQVyEWhyCJaWNgi2PuRCQcT+tB+pA1FItizMLTmYAzkMRvchlA0yOxqKsJK3HZn+0uitnlYZdu9BrPGvZOuRC+Vw9duvhpJUkJsoHr2mp5BvuOEGSJLETIMp7drp7OSijsPhcE4ieMRugSlNL5oEDdtcCZznjbEvSodSBCpntWJC9MAsWZGQk7Nr1jAp0JQsNM0MVVbRbs7BLamwKUk8m3Tg7pAXp134j1AcfjaTVrdDodqyffv2zdm0l6Vf3TR+bARqqh2ipQtKLt9Q0QibNm1i3Zn3PXlvTX83o0VMJZEmOUUI0jiUZDsgdADSTM0ddb3S/i6kqCMfOVjsMDmT0Cg8J/UgufdxZAbzxwKlUGnuKo1i2/1/78YF6y7AXz78l4Xu1Hg2jtdCr+HliZchicAa78zc26vfejVLp1732eswNDVU+DlF6kjUkTieL3jDBIfD4Zx4cGF3TNCwxpbBHl8Ml/iibKYqCbyYIjKLkoDPD5tkmxYQQvOvrqnTjRIaHGoKrZYknEkFk7DidxN2dJ35UVx7PxXxC/jtv32XPeeaa64peg2BRk3NVdTpNXWhBDR1qKxbth4kany9voYnMZBFzCc+8Ymi+rwZcSpDSQyW1dyRlUmtSR9zEXX6KK9wMgvBbYHd14dUNIf0wF4k9h4uPI4ib8JUPm369gvfziJsOmRDQl/n2M5Bj7MH0UwUrbaZUW9OsxOf+ItP4AOXfYBZ2hB33XUX2y/j63A4HA7n5IQLu4VCtKDNrGFnyxQu9kewwZFmDQspVcB4zoS0mk+ximYRgigyAUHebKrBWLfRSJ2spNAh0kQIBQlFxAsxO/4w3I4nsqsRSUbxGSdFqKqLmW9+55tMDFlVK2KJ2rYsRmw2G0vfljZK5NOv5d2ypUrNOIeVRN1YcoxFrRodr0UWMYODg4X6vEoRR30b3G1rcOGuzdiwYV3V19N9A5sVdSToIkkFQ9EIbNYsJPsIul0K3nbGCvzoX3+F9OAEIOeqpk0rQTVxlEo1/g0jxuft2bOHizoOh8PhMLiwWyBOc8Tw1b4DaBHiyMkKQrIJo1lTkcAiUSeZJbgd7rzhbjNoGjxmBS0WBY5kEIezIn4d8uHBsAdvpGzs7wjWKPNHe2nv0aovYxRD5194ft0mByM04eChhx+qPlGighVKJcWmizqqC/Rby017a0E1dlSfVz2NrOFdV+yBI7ACORnMF85qriByDb6BRlGnaAoS2QSLlEliXkxp1KWcicAsWKAodsRSCrLaFHatasWu5asgSFnWtbrirBXY7d6ET33qUxgyjPZdiLQph8PhcDgEF3YLREBKo0VMYcrWh2BwbKZN1iDqqHWlxdsCqQlRJ6oynHIMkpxCwqzhuaQLD4604/5RE+JqcfSHZsnSX33mxX0QrL6i2bJEqRiiGjer1Yp7/vAHxOp0jlKtmsPpqDkmrJq4+/zn/x5ms7lM1NGYMEVuLg1MNXYkskpFHdXf6R5yK5YvgySJbPzYyJSKLr9YJO5Ys0bAjKScRI+nB5IgMWGWkBNIySm4zW4m+qi7lMTdeCIITbFjMq1AMk2i3Sfj1K52XLzqHDjMMx27BIm3iy++mKdNORwOh3NM4MJuIdEUOJxOQOxGZGocci5bJOra/G3wuNyNvBAb70WNFp5MEDGrDy94T8G/v3oYr49LgFY9zUpiLj4FFrkjkaeLu1g2VjHCVTqNoRqXXHoJkmKytqibxmGVcMH52/CHh19k4o41F1QQdRS1VNC4sCNx6enwIJQMFfZDkAQIlnz9mhGaUEHjx0bDKIg7SVKYYCPjYGoqplFj1JVKY7VIh4uwocO6FlbBjYQyhAMTkyy0R9G7UzrWYF27C6p5BGk1gp3dO8tEnQ5Pm3I4HA7nWMGF3QJjNQGCww6btQ9Dg4dpalR+KkVOhbuSqDPUUuWScXRacnBKKqudezLqgnXHe/AneztkwY7Xx3/aUNpSj9zp4k40xRDJRao2ShinMVBErNRS5G1XvQ3+Pj8saUt9Uedw4NOf/jQTN5s2bmSiKpgQ4BczmEgXi7pm2X3Jbja8nsa2sf0QaHStBDWjIpQN5bPeWmVxd2QyBYcjDo/Zh/RRE+RYEp2mLehpdSCaziGSlOG12RBwOtDhseI0BPDq5OtIqwlcsPI0rG3thJUZCPax2rzZbD+Hw+FwOPMNF3YLjQBYzUBKAySrHZpGY6Dk0swsgwTU+MQ4PJLConNaeBCTsgm/mvDjgSkvDio2XBw1YZnbhTZLoKlaNF3cmb1tEEwWeM3TYqgOV199NasHM+4PiTrWYODsqOtTZ+zWpPQnRcr6g1mMjYXQ4WtM1JWKS4rUkagL9ARYlI3sP6gJYzQ6ih9990dsvJbP4oPJV+5hR+Iu4M4ilEnCrPTCZfIjPdiP3Phh9AXcGI+p8Nmd2L7OjRWtTnhsZvYc4oyVAWbiXBqZ46KOw+FwOIsFLuyOEYKQBQSaM2Zh9iTMjdZAKhaGGhrGcpOKuCrij1EX/hDysv8mValg2vvw/Q+XdY1WiqoZ0e1AKFJHok6TvVDlRlLAMx2c+W/y3a9Do0PYumorJEh1t4EaG4oQsxCs40DWDjXrAxw0KqMBcXnjDWyf3/e+9zFBR5E6XdQR9L1ZMiM7nGVibp13HbJjWVY7N54ahw8+1nErQEA4O4VTu3qQTrRCEDQ2e1VNRnDemhaEcyLa3FYm6Eqh59MXh8PhcDiLFZ4/WgAUZSZKlEomWS2ZBhVqhmq3VAiSLe9Tommw5hLwpkZhjo5gSjbhx6Ot+Oi+FfjcoT42u9Uo6qr5u11wwQU1t4fsQPRGCTkSRC4ygXCSumZ9je+UwdLk/t/cjx987wdsXJpRfOlQ40Il9Jo6l8WMDZ1+yLLAGhr0mruyP2kRWNQtlAmxFKvJb4K11Vom6uh1M3IGK9wrChE6SvFmBjNI7k9imWsZ62SlZohwJsyihKu8a+CxWXD2Sj8TdYTNLGF1m6uiqONwOBwO50SAR+zmmdtuu43ZW+w6t5N9PzIxCskkIeANQGMCJg2ryYxWmwZfahSy2YHXTCvwrUM2Fp3T/e106ok6Ys2aGb8zI5SypFRoa29rSaNEmM0fLW2oqMSBAwcq+tTFcrHi2a6GyF5fX1/Z61RqlOjy57tUqeaNat/0lCdBQpSOzsxoBht9G5Han2L7QClgqgGkBgaCUqPhdBgrvSvRYeuAaHezr6NTaZgCPdByGaz0rITZYkZGzbDHy7IFw+EsVre7sL6zcsMDh8PhcDgnIlzYzbOoo2hV3ky2Mx8PJQPhTA7jo6PwmRT4TQpUZDGYc+MV3+UI923H8/1BPBi+vez1GhF11aCU5apVq1h0azIxWdYo4XUAajpYV9w99FANn7oGqSTqjDV3RnFHUHROy2os4iZPyWixteS3P65gZ+dOjGXGMJmcZNYjOTWHHncPlnuXIxxLQ7Q6kRl8DbtXeZE+/DwsHWvQH0phRbsFcs6CSBIwSwLOXBnA5m4vcplU0/vD4XA4HM5ihQu7eUy/UvenPiFA7wewyjJrhLAKGqKKxAyE7wl58VTMhfedczHUlASLPW+DMl+ijqB5qCTqKPVY6Bqt0y1bvhFAxpyZs6gLpUNVu1/NJg1dfgEjUxoTdy5rhpUfpgfSUGLl20z70upqRdAZxFBsiL3eat9qKLKAiVgWmZH9yI7sw/KAHbnJfijxKfT67RiNpOG0mliUbm2HGz0+O3u9XH6ELIfD4XA4SwIu7OaJxx57jI23MqKoQJtJxtGMBXeHfHgo7MZw1lL4fYcHzPpDc/XA7W1BLBJsWtR94AMfYKO5SiHT3oSaYLVoDrF6utEo7sIJDW162V3FMWHNQTVyR2JH2Hgsi82CydQkm4PqtrjYH0jmkvmmB9GMLn+ARe6OJJMsSldJ1OmQgXC7vZ1F8khIC5BwJJzA2nYnsqP7ih6rpmPYvSaAlGaG32GGw8IPeQ6Hw+EsXfhdbp4YGRkp+n5fwoZfhbvw1LiI5+JOyBVMhPO+atRAAGw/53I8cs+vIIjZhkUddbtSZI7q28juI5fL4frrr2f1aZFsBK3OVtZgQD+vhS7uwknAZFbhMKtNizrycqO/S6KUmh3MLWZINgld9i4s9y9n4k6FisHYIMaTE6yDlZ5DtXGUpk2rUXjdZkQmzFCVdkAYKPL0qybwSID2h5Lo8tqwfZkLUMsFIfnNBZz5CF0pTqezbA4rh8PhcDgnKlzYzRNdXV1F3w9krfhOsANyLB+Fq4ZumosVfVAueydeeu0+pCLhhtKv1O1aZEdiGBNGKUu9a7QRSNz5HEAopmIUoYKoc1qdiOfiefNftwTRJEKOytDkmY0THSITc2pOhTwpo9vRjcxIhtXEnfF3Z8Bpzzc6EAFbAEciR5DIJbDKt4pF3twWN14Pvo6sksSmjh78RrXAHOhFLjQE0e5BPzVC+LsAQcJEPIMes7XQaBFKZGExCcxjzmmqmFDmcDgcDuekYdHYnVx33XVMpHzmM5+p+bhHHnkEO3bsgM1mY80B3//+97EY2L17NxtjVSq0GoFEit+dg7fdjl3nXIVcjKxQALu9cpSpmkeccWZqM6JOH8PlcWhQpRBLycoJF4vUnXfBeUy46Wa/2fEME3i69xw1OhCrPauROpBEdiSLle6V+caHsMwaHIzQ3NVNLZtwWvtpTNQRVHu30rsCPpsPK3xdyAUHINicsC4/FTTra0uXE6kDTyN95EVYJQlHQkkcDSYwGk0jnMphW58fXd7a7xWHw+FwOCcDi0LYPfvss/jhD3+IU089tebjDh8+jMsvv5yJqBdffBFf+MIXmLXIrbfeiuMNTVe48cYb2b+bFXfUYEDjtTp8AtqcPkiObhpTgVSq8Y5NEnWUfq02Jqwq02O4JIeE4cQwrLY0lvk9EK0BmFtb0drXWmhmSB9KITOcF2zeLi8uvupiNr4rfSTNonSa3NifpBSqjbz8CpsgYJlnGU5pPQUOkwOCyQotk0Dq0HNI7n8KW3vckMOjyE0cxqWb2nDhhjac0uOFx2bChk4XNnR5Gt9fDofD4XCWMMc9FUvTCt7//vfjpptuwle+8pWaj6XoHNWU6SOuNm7ciOeeew7f/OY38c53vhPHm3e84x245ZZbmNhMlfjJXXjhhUW+b9WsQDJSDlCykJzdUBLDgJJpSNTV6n41m82FGryv/+vXmZynhgt9DNePv/tjqBmFNTKsd6+HZtEgSlHICTc6LeuRfCMBzfCyn37/pyF2i6wT+K7+u5oTklUQILLGikQuBdHuQvrIn5AdO1Q87BWA3Syh1ecE2jHTgTyLKCmHw+FwOEuR4x6x+8QnPoG3vOUtuPjii+s+9sknn2SGu0Yuu+wyJu7qNQgcS3H32muvFfnJffKTnywfrVXF3214eHBa0OXFHUXuGhF1xkkM1aDpDKxOzizi5cMvYyo1xf4m1cNlRrOQohLrVJ3KTCEzPo5M/yjSGRtEe6Dodbafsh2b2zZjY2DjnEWdrKhFzQvxnICfff87GH3jxTJRVwoJOi7qOBwOh8NZJBG7X/7yl3jhhRdYKrYRRkdH0dHRUfQz+l6WZUxOTpY1MBCZTIZ96USjUSw0+tB7Qu9aNfL5z38eqqhWNO3Nz1vVmLgjYVcrcme0NNG7X6leTrSKUFQFZsyMxnpt72t44MkHkBvPIheScef/+T2c7S7IEzJL3xK//sGv0bqpFbvP3I3MUAZaNo12lwWSu5X9XomHimrl0mp61u9ROqdgPJaBrKowiQKWBZxQNQ3xjIxty/ywmI77Z45FDe/m5XA4HM6iEnYDAwPM0Pfee+9ljRCNUiqS6qXjqCnjy1/+MhYTtUx7XS7yeEN1cTddE0fdqSTsyKyXRJ2iKew1RZcINaWyLlW34Ga1bK/tew1/ePAPyIbIwDfDauFYI8REDmp6ppOU/ONC+0O47cXb2OQHos1lgRKbrCjuyhAlCCYL0jmV/Vu3HiHxFoxnmWjTl8ksiVgWsKPH78CL/VOYjGcgCgK8DjOWtTiYmbC+tolEYt7XgMPhcDicpchxE3bPP/88xsfHWYerDtVsPfroo/jOd77DomzGyBfR2dnJonZG6DVMJhNaWloq/p1rr70Wn/3sZ4sidpVmmS4U5CtHXHPNNey/5PM2kZqA3WKvOImBOmtnKBF3yWGY3SrkhAzYqadBYYJ2IjnBHk22IalDKagJBWu9a9noLaqbe+ThR5AZyyA7lhd1OiQAi9CA7Fi2IL50dDGnizsdm9WGO+64g/07FEvA5O+Elk4gks6xxwqihCPBJCwWGe1uG3as8MM5bRBMEbk2V962hATd4/snkFFUnLWyBS7r3A9LHtHicDgczsnIcRN25MH28ssvF/3swx/+MDZs2MBSlaWijti1axd+97vfFf2MIn6nn346axCohNVqZV+LAX2iBE1a0EUd1bNR2tQKK27813xXrY5oF1laFRiHYOqE5OxDbnIQqSMxJsI2+DcipsbQ4elg6Vg77FAi+ShZt6sbXd4uvPzayxh7fox1tjZKJb9eo7ijFOoy60yUNZLKYSKWQXZ4H7Ljh3DphhZ88o3HIJqsOHd1AC6nk431spnL15RY2+5CKJHJz3RtqT4l40QVc4t1uzgcDoez9Dhuwo6mJmzZsqXsBkiRN/3nFG0bGhrCzTffzL7/+Mc/zqJ5FIH7yEc+wpopfvzjH+MXv/gFFjtZZWaiRJu9jYk6iqZJkNDqaMVYbAwmvynfL0BfImAX7Qj3h/PpV+cgREcXLjv/g/jNT74PLZfBKu8q1t2qR/3SmeKaN+oyTYfTTYk6I5/73OdgtVnLxN1YNAOrJY0Ojw2xdA7hZA47lvmQGXod0FR0tXjZjNZGoagd1dUta3GixbU4RDiHw+FwOCcix93upN6Yrv7+/sL3K1euxF133cXSmt/97nfR3d2Nb33rW4vC6qRepC6shPHB93+oEKlLySnklBzWB9ajy9mFDmsH0v1pCDRRQQIzB/7m9d/Ex/76Y9OvkgWEQ9j61xtxZ0sfM/F99ZVXsW3btoJZcCX8Af+st7v0uaLDB8FsYzNXRyJpVjuXyik4fXkAG1otTNTNForm9fi4yTCHw+FwOEtG2D388MNF3//0pz8te8x5553HOmlPFGhqA81NNQmmgqij5olYNsbmpHY6O9njnGYnchPFli0Oc0laUtNw41e+AA1OmFv68M9f/RoCXhc++pGPsjR1JTZv2oyW1haEgsF6o1cLUI1dS2sre64oivj5/9yKwVAMX/js30GeGkJO0eB3WPDacBTnrm3Dlh4vlOzsO2Q5HA6Hw+HMD9xTYgGRHCKb3UqzVanJgWrpaO5qNBNlkxboi6YuNMNUMIRcaJClYkncTUXj+NrXrmNp6UqQMCPhRzTi46s/5iNXf4Q9l7pVqYZuW58XyX1PInX4RWzuckNWNazvdGPnqhYWbdPryOiL/j2fLORrczgcDoezlODCboGQp3JI9WcQ/3McidcSLN1KjRI5NYd1/nVY41vNonizQtMK4s4U6INgtuKmH90EVa2cCqVo3j/8w7UIBIo7h90eN1xuFyRPG8wtvYBkYpE6eiw9h2ax5hQV56xtxbZeD7RsClBl7FjuxVkrAzhvfTva3LwmjsPhcDicxcKiSsUuJcgEWErP+MSt861DVInCIlkQsBVPcpiLuDMHepm4CwYHcPDgwYL9SCkk1LaethXv+6v/C4Jkxv/z+c+y+ryxcAx/+6nPIBcawsc+9//g4p2nsUjd0VCCje/ataYNK1udRV5yJlHEactmX7vH4XA4HA5nYeDC7hhBtXV6Pd28YRB3lJYdm5jCKTWfIMDkaYWaScLbs4rVykXSCrIjB5Cb7MdFZ2zBwFSapWOXtzhYpyp1vnI4HA6Hwzkx4MLuRMcg7lIWD5JZGY5pE+BSgokssyzJDL/BOlsPTSawMuBg3nM0JeLMlT44xtLMOHh9p4eP9eJwOBwO5wSDC7slgAANXjGN9atX4eBEAqvbnGXiTlZUxDMKsuOHIYdHcN7aVgzGFHS5xMLoL6fFhAs3FM/i5XA4HA6Hc+LAmydOMEo7W2e6WK/G6nY3LCYBLw9FkMgUW6eMxTLo8tpYLR3htplw+ooAfPbKEzs4HA6Hw+GcePCI3SLkV7/+FZvDWjpJgvD5/ZgKzUx1oC5Wsiah5ghV1Vhjg8dmwlOHQjhjhR9umxkhSsGqGjZ1ulhXK4fD4XA4nKUJF3YL9s6aGzOOa1LsJVNJ/OVffxxaJoX/94v/wDpbqYuVRN2RUIJF5bb2+fCngSk8fXgKHR4rOj12Zk/S66k8q5XD4XA4HM7SgAu7hUIQYPJ25uerzuMA+HBKhiBKED0tWL52PRN1mZyCwXCKjeQ6d20rfA4L62ZtdVrZmNhTe3zwOsxFliXNwgfZczgcDoez+OHCbgEgEfTrX/wCj+8bxfe+8S+sa3U+IAEXS8usq5VMiYPxLLJqCmlZxboON7Yv98M7XTNH0yDOWds2L3+Xw+FwOBzOiQEXdguEKALdXisTYGRF8vLLr2DH9u0swmYkGM8gmpahKTmITh/UZLTo94IpP9khK6uYSKZYx2tu4gj72Wl9XozEFZy5KoC17W5I4vylfjkcDofD4Zx4cGG3QDz91FP48c9/hVxwiJkHf+27/wmP+D18dLrRgaCGhkg6h81dXsSSSWhyFiZ/N8KpHHyiGUeDKYgON0vlTsSzaPM6sbXXBWj5aRZbezzYZrFV9a3jcDgcDodzcsHtThaA2267DV//xjcRDofZPNdccIBF7qKaHV+7/mt48skn2eNGpmL47N9+BOdu7MbWdjOSbzyBzMDLeO31NzAaSWFVqwOpfU8i8dojeNOmdly8qQMe24w9iSAIXNRxOBwOh8MpwIXdPKMoCj796U8XNUwUxJ3JClOgFzf96EfscVQvR6O8oOSwY8cO9t/s6H5c/6n348sfeTuCrz4OJTEFLZtEq8tSJOo4HA6Hw+FwSuHCbp557LHHMDhoaJagDla7p0jcRVQbnvnzK3BZJcjhUfawkZGRwlPUZARD+1/BBz/wV/O9eRwOh8PhcJYwXNjNM0aBxixPfJ0QJAkmX0dRWvbVkTj6fFaomcoWJNp0xK+vrw+yLLNOWw6Hw+FwOJxacGE3z3R1dRX+LTl9UOJBpPtfhpqOw+TvBAQRajbFGiEmDr1a87VI3A0MDLAoIIfD4XA4HE49uLCbZ3bv3o3e3l4WrSNz4szAq5CnhpE68iKUZBSi1Q6fmMEnr9yJVGis+Sggh8PhcDgcThW4sJtnJEnCjTfeyOrkMoOvsogdoSbCSB98Bsm9j+OGv/9fWNfpRVdXZ9NRwLmgT4+gLz21W+lnHA6Hw+FwTky4sFsA3vGOd+D/3PjPaLcVjxLraW/Br//7Z+z3xDnnnFPzdcjOhGrsKArI4XA4HA6HUw8u7BYIEm+vvfZa4fu77roLhw8fLog6PbpnFHFG9O9vuOGGosdxOBwOh8PhVIMLuwXEKMj27NlTU6B1dhanZalO75ZbbikSghwOh8PhcDi14LOoFgnPP/88uru7C9G9Sy+9lEfqOBwOh8PhNAWP2J2A0T0Oh8PhcDicSvCI3QmG3sXK4XA4HA6HUwqP2HE4HA6Hw+EsEbiw43A4HA6Hw1kicGHH4XA4HA6Hs0Tgwu44oihK4d9PPPHE8dwUDofD4XA4SwAu7I4Tt912GzZt2lT4nvvVcTgcDofDmStc2B0nUfeud70LQ0NDFX//29/+9phvE4fD4XA4nBMfLuyOQ/r105/+dE3Lks9//vNFaVoOh8PhcDicRuDC7hjz2GOPYXBwsOZj6Pf0OA6Hw+FwOJxm4MLuGDMyMjKvj+NwOBwOh8PR4cLuGNPV1TWvj+NwOBwOh8PR4cLuGLN792709vZCEISqj6Hf0+M4HA6Hw+FwmoELu2OMJEm48cYb2b+ribvrr7+ePY7D4XA4HA6nGbiwW0CcTifrfqUv+rfRs+6WW25Bd3d3xee97W1vW8jN4nA4HA6Hs0Thwu44QeLutddeK3x/1113QZblMhHI4XA4HA6H0yhc2B1HjOnWPXv28PQrh8PhcDicOcGFHYfD4XA4HM4SgQs7DofD4XA4nCUCF3YcDofD4XA4SwQu7DgcDofD4XCWCFzYcTgcDofD4SwRjquw+4//+A+ceuqp8Hg87GvXrl24++67qz7+4YcfZqa+pV979+49ptvN4XA4HA6HsxgxHc8/TqOzvva1r2HNmjXs+5/97GfMnPfFF1/E5s2bqz7vjTfeYEJQp62t7ZhsL4fD4XA4HM5i5rgKuyuuuKLo+3/5l39hUbynnnqqprBrb2+Hz+c7BlvI4XA4HA6Hc+KwaGrsFEXBL3/5SyQSCZaSrcW2bdvQ1dWFiy66CA899FDNx2YyGUSj0aIvDofD4XA4nKXIcRd2L7/8MlwuF6xWKz7+8Y/j9ttvx6ZNmyo+lsTcD3/4Q9x666247bbbsH79eibuHn300aqvf91118Hr9Ra++vr6FnBvOBwOh8PhcI4fgkbDSY8j2WwW/f39CIfDTLD96Ec/wiOPPFJV3FVK51IDxR133FE1YkdfOhSxI3EXiUSK6vSOBxSdJFFLxONxPiOWw+FwOBxOGaRdKDjViHY5rjV2hMViKTRPnH766Xj22Wdx44034gc/+EFDz9+5cyd+/vOfV/09RQLpi8PhcDgcDmepc9xTsaVQANEYYasHddBSipbD4XA4HA7nZOe4Ruy+8IUv4M1vfjNLjcZiMdY8QV51f/jDH9jvr732WgwNDeHmm29m399www1YsWIF65ilFC5F6ih9S18nIk6nkwlZDofD4XA4nBNe2I2NjeEDH/gARkZGWO6YzIpJ1F1yySXs9/Rzqr/TITH3uc99jok9u93OBN6dd96Jyy+//DjuBYfD4XA4HM7i4Lg3TyzmAkQOh8PhcDicE0m7LLoaOw6Hw+FwOBzO7ODCjsPhcDgcDmeJwIUdh8PhcDgczhKBCzsOh8PhcDicJQIXdhwOh8PhcDhLBC7sOBwOh8PhcJYIXNhxOBwOh8PhLBG4sONwOBwOh8NZInBhx+FwOBwOh7NE4MKOw+FwOBwOZ4nAhR2Hw+FwOBzOEoELOw6Hw+FwOJwlAhd2HA6Hw+FwOEsELuw4HA6Hw+Fwlghc2HE4HA6Hw+EsEUw4ydA0jf03Go0e703hcDgcDofDqYuuWXQNU4uTTtjFYjH2376+vuO9KRwOh8PhcDhNaRiv11vzMYLWiPxbQqiqiuHhYbjdbgiCsKDqmsTjwMAAPB7Pgv0dTuPwNVmc8HVZfPA1WZzwdTl510XTNCbquru7IYq1q+hOuogdvSG9vb3H7O/RInNht7jga7I44euy+OBrsjjh63Jyrou3TqROhzdPcDgcDofD4SwRuLDjcDgcDofDWSJwYbdAWK1WfOlLX2L/5SwO+JosTvi6LD74mixO+LosTqyL7H5/0jVPcDgcDofD4SxVeMSOw+FwOBwOZ4nAhR2Hw+FwOBzOEoELOw6Hw+FwOJwlAhd2c+B73/seVq5cCZvNhh07duCxxx6r+fhHHnmEPY4ev2rVKnz/+9+fy5/nzHFNbrvtNlxyySVoa2tj3kO7du3CPffcw9/XRXCu6DzxxBMwmUw47bTT+Loc5zXJZDL44he/iOXLl7Mi8dWrV+MnP/kJX5fjvC7//d//ja1bt8LhcKCrqwsf/vCHEQwG+brME48++iiuuOIKZgxMQw1+85vf1H3Ocb/XU/MEp3l++ctfamazWbvpppu01157Tfv0pz+tOZ1O7ejRoxUff+jQIc3hcLDH0ePpefT8W265hb/9x2lN6PfXX3+99swzz2j79u3Trr32Wvb8F154ga/JcVwXnXA4rK1atUq79NJLta1bt/I1Oc5rcuWVV2pnnXWWdt9992mHDx/Wnn76ae2JJ57g63Ic1+Wxxx7TRFHUbrzxRnaPoe83b96sXXXVVXxd5om77rpL++IXv6jdeuut1Giq3X777TUfvxju9VzYzZIzzzxT+/jHP170sw0bNmj/8A//UPHxf//3f89+b+RjH/uYtnPnztluAmeOa1KJTZs2aV/+8pf5e7sI1uU973mP9o//+I/al770JS7sjvOa3H333ZrX69WCweB8bwpnDuvyjW98g334MfKtb31L6+3t5e/rAtCIsFsM93qeip0F2WwWzz//PC699NKin9P3f/zjHys+58knnyx7/GWXXYbnnnsOuVxuNpvBmeOaVJojTLP4AoEAf2+P87r853/+Jw4ePMi8oTjHf03uuOMOnH766fj617+Onp4erFu3Dp/73OeQSqX48hzHdTn77LMxODiIu+66i80SHRsbwy233IK3vOUtfF2OE4vhXn/SzYqdDyYnJ6EoCjo6Oop+Tt+Pjo5WfA79vNLjZVlmr0e1EZxjuyal/Ou//isSiQTe/e5386U4juuyf/9+/MM//AOrLaL6Os7xX5NDhw7h8ccfZzVDt99+O3uNv/3bv0UoFOJ1dsdxXUjYUY3de97zHqTTaXY/ufLKK/Htb397vjaL0ySL4V7PI3ZzgAopjdAnptKf1Xt8pZ9zjt2a6PziF7/AP/3TP+F//ud/0N7ezpfgOK0L3dj+8i//Ev9/e/cTCt0Xx3H8+/gzkX+LRxml2EwoTUb+LCTRrNhY2EkUC0VC2SoldpMNsxKlZsNS0lBGTUrU0IRS/kWjWNIoC/fXuWV6Hp5+ZYa50/F+1dWdmas5na879zPn3nNNTk6ao0JIjX1FjWar11SIqK+vl7a2NvF4PLK0tMSonYV1OTk5keHhYZmYmDBH+zY2NuTy8lIGBga+uln4BKuP9XwdjkNhYaGkp6d/+BZ1f3//Iam/sdvt/9xejUj8/v07nmYgwZq8UWGur69PVlZWxO12068W1kWdClenLEKhkAwNDcVChfpgVPuK3++X1tZWapTEmihqlEGdgi0oKIg9V1lZadZFnQp0OBzUxIK6zMzMSGNjo4yPj5uPnU6n5OTkSFNTk0xNTXEmyAKpcKxnxC4ONpvNnMq8ubn51/PqsRoa/xd1K43326uDlLpuJTMzM55mIMGavI3U9fb2is/n47qUFKiLuu1MOByWw8PD2KJGH8rLy831hoaG72jmjxLPvqLCQyQSkaenp9hzZ2dnkpaWJiUlJd/e5p8gnrpEo1GzBn9S4VDhv4VaIyWO9UmbpqHptPSFhQVzSvPIyIg5Lf3q6sp8Xc1i6u7u/jAFenR01Nxe/R63O7G2Jj6fz8jIyDDm5uaMu7u72KJuswHr6vIes2Ktr8nj46M507Kzs9M4Pj42dnZ2DIfDYfT3939D636uz9ZlcXHR/Aybn583zs/PjWAwaNTW1pqza/E11N9+KBQyFxWZPB6Puf52C5pUPNYT7BKgAkFpaalhs9mMmpoa88PuTU9Pj9Hc3PzX9oFAwHC5XOb2ZWVlhtfrTeTtkWBN1LraUd8vajtYu6/8iWCXGjU5PT013G63kZ2dbYa8sbExIxqNflPrfq7P1kXd3kTdpknVpbi42Ojq6jJub28taLmetre3//c4kYrH+l/qR3LGBgEAAPCduMYOAABAEwQ7AAAATRDsAAAANEGwAwAA0ATBDgAAQBMEOwAAAE0Q7AAAADRBsAMAANAEwQ4AAEATBDsAAABNEOwAAAA0QbADgAQ8PDyI3W6X6enp2HN7e3tis9nE7/fTtwCS6pdhGEZy3xIA9LK+vi4dHR2yu7srFRUV4nK5pL29XWZnZ61uGoAfhmAHAF9gcHBQtra2pK6uTo6OjmR/f1+ysrLoWwBJRbADgC/w/PwsVVVVcnNzIwcHB+J0OulXAEnHNXYA8AUuLi4kEonI6+urXF9f06cALMGIHQAk6OXlRerr66W6utq8xs7j8Ug4HJaioiL6FkBSEewAIEHj4+OyurpqXluXm5srLS0tkpeXJ2tra/QtgKTiVCwAJCAQCJizX5eXlyU/P1/S0tLM9WAwKF6vl74FkFSM2AEAAGiCETsAAABNEOwAAAA0QbADAADQBMEOAABAEwQ7AAAATRDsAAAANEGwAwAA0ATBDgAAQBMEOwAAAE0Q7AAAADRBsAMAANAEwQ4AAED08B+wokL4nG4VcAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -766,20 +1323,25 @@ "plt.xlabel(\"x\")\n", "plt.ylabel(\"y\")\n", "plt.legend()\n", - "plt.tight_layout()\n", - "# plt.savefig(f\"ci_scaled_vs_non.pdf\")\n", - "plt.savefig(\"ci_scaled_vs_non_badprior.pdf\")" + "plt.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 37, "id": "023b3cd0-3daf-46d1-b748-6857a69a4d54", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.796167Z", + "iopub.status.busy": "2026-08-11T03:10:40.796024Z", + "iopub.status.idle": "2026-08-11T03:10:40.934389Z", + "shell.execute_reply": "2026-08-11T03:10:40.933670Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAvKRJREFUeJzs3Xd8W/W5P/DP0d7ydrwdZ9lJnMnIIBASQwKUhCxSxi20tNACJdDS3sKvvSFtL1Bu25u0wG1py2ghFBxiQlOSQJgJZBMybWc48d5D09rn94ciWbKOpCNZsmTneb9evLCPzjn6yjLo8ff7fZ6HYVmWBSGEEEIIGfEEiR4AIYQQQgiJDQrsCCGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCVGiBzDcXC4XWlpaoFarwTBMoodDCCGEEBISy7IwGAzIzc2FQBB6Tu6yC+xaWlpQUFCQ6GEQQgghhESksbER+fn5Ic+57AI7tVoNwP3D0Wg0CR4NIYQQQkhoer0eBQUF3hgmlMsusPMsv2o0GgrsCCGEEDJi8NlCRskThBBCCCGjBAV2hBBCCCGjBAV2hBBCCCGjxGW3x44QQsjI4HQ6YbfbEz0MQuJOLBZDKBTG5F4U2BFCCEkqLMuira0NfX19iR4KIcMmJSUFY8aMGXKNXQrsCCGEJBVPUJeVlQWFQkHF5MmoxrIszGYzOjo6AAA5OTlDuh8FdoQQQpKG0+n0BnXp6emJHg4hw0IulwMAOjo6kJWVNaRlWUqeIIQQkjQ8e+oUCkWCR0LI8PL8zg91XykFdoQQQpIOLb+Sy02sfucpsCOEEEIuQ4cPH8Yf/vCHRA+DxBgFdoQQQsgIcPDgQTz//PMxux8FdqMTJU8QQghJev/74Zlhfb7Hbpg4rM/Hhyewe/jhh2NyvyuuuAKPPPJITO4VzsGDB3HmzBncfffdw/J8lzMK7AghhJAh+vLLL3H8+HGsWLECu3btQltbGxYvXozZs2f7nWe1WlFVVYW6ujrk5eVhxYoV0Gg0fuccOnQIX375JaRSKSoqKjB+/HicPHkS77//Prq6uvDUU08BAJYuXYo5c+aAZVns2rULx44dQ0ZGBm688UYUFBQEjG3VqlXYunUr2tvb8eSTT3K+jnDjC3YvkSh0OHHw4EFs3749osAu1Ovq7e3FH/7wB6xatQpTp04FALhcLvz2t7/FzJkzccMNN2Dz5s1IS0tDYWEhPvvsM9hsNqxatQr5+fm8xwAAJpMJ27ZtQ0NDA4qLi3HrrbdCqVR6H/d9nl27dkGj0eC+++7D008/jZUrV6K5uRmHDh3CFVdcgYqKioieOxq0FEsIIYQM0Zdffolf/OIXuPrqq7F3716cOnUKc+fOxd/+9jfvOTqdDrNnz8avfvUrdHV14cUXX8TkyZNRX1/vPee3v/0tlixZgtraWpw+fRqrVq1CVVVV0Oe1WCxYvHgxfvrTn6KzsxOffvoppk2bhl27dgWMbd68eTh69ChcLheAwKVYPuMLdq9YC/e6UlNT0dzcjNWrV8NsNgMAnnnmGfz2t7/FtGnTALgDrkceeQS33norampqsH37dkyZMgVff/0173GcPXsWkydPxmuvvYaenh789a9/RXl5OZqamrznbN68GevWrcPKlSvR1NQElmUBAE8//TTWrFmD//qv/4Jer4/RTyY8mrEjhBBCYqCrqwt/+ctfcNtttwEArrrqKvzkJz/BmjVroNFo8Mwzz8BqteLYsWNQKBRwOBy47rrr8LOf/QxvvvkmAOCvf/0rnnvuOXz3u98F4C59ce7cOZSVleHmm29GXV2dd8YOAP7rv/4LVqsVR48e9dY++9Of/oQHHngAFy9e9Bvbu+++i/nz5wcdP5/x8b3XUD399NNhX9fGjRsxa9YsPPbYY7jvvvuwYcMGbN26FdnZ2d77NDc34+zZs8jNzQUArFmzBo8//jh2797Naxz33XcfvvnNb+I3v/mN99g3v/lN/PznP8err77qPdbb24szZ84gJSXF7/rc3Fzs3LlzWLO8KbAjhBBCYiA1NRXLly/3fv+d73wHP/zhD3HgwAHccMMN2LFjB+666y5vvTKRSIT77rsPP/7xj73X5OfnY9u2bVi0aBFKSkogFotRVlYW9Dm3bNmC/Px8PPPMM2BZFizLorOzE/X19Whvb/cGOXl5eWEDMT7j43uvhoYGvPzyy97vDx48iHPnzvkFpddcc03QpUk+r0uhUGDz5s2YO3cuqqqq8N3vfhff+MY3/O5z4403Ijs7G4cPHwYA3HvvvVi2bBmsViukUmnI19DR0YE9e/agrKwMv/71r73jMJlMOHbsWMDzDA7qAHcgOdyle2gplhBCCImB7Oxsvw9xuVwOrVaLlpYWAEBLS0tAu6jc3Fz09fXBZDIBAF5++WVoNBrMmjULY8eOxaOPPoru7u6gz9na2gqpVAqHwwGn0wmXy4X09HSsX7/er3tBRkZG2PHzGR/few0V39c1c+ZMTJ8+HZ2dnfjRj34UcJ8xY8b4fZ+TkwOXy4W2tjZeYwAAiUTiN47Zs2fjvvvu8zs32M9kOH5Wg9GMHSGEEBID7e3tYFnWG9z19/dDp9N5lwFzc3O9wYJHa2srUlJSvJvxCwsL8cYbb8DlcuHQoUP44Q9/iO985zvYtm0b58xPVlYWJk2a5DcTFi0+4+OrsLDQb0zPP/88XC4X73HyfV2bNm3CuXPnMGfOHPzgBz/ABx984PdzGhzAtba2QiAQBAR8wcYAAEuWLAmYCUxmNGNHCCGExEBvby+2bdvm/f7ll19GSkoKrrrqKgDATTfdhM2bN6O/vx+Auy/uyy+/jKVLl3qv+fLLLwEAAoEAV199NZYvX44LFy4AALRaLQwGg99zrlq1Cq+88gqam5v9ju/bty/i8fMZ33Dh87pOnDiBn/3sZ/jzn/+Mt99+G4cPH8bGjRv9zv/ggw+8M6YA8Morr2DhwoXeZdi9e/fi17/+NecYcnJyMHfuXPzP//wPbDab97jNZsORI0eiel1PPfUU9u/fH9W1fNGMHSGEEBIDGRkZWLduHd5//31YrVZs3rwZL7zwArRaLQDgiSeewPbt23HllVdiyZIl+OKLL9DU1ITXX3/de49f/vKXMBqNuOqqq2A0GvHmm2/i97//PQD3nrTOzk7ce++9KC4uxtKlS/GLX/wChw8fxvTp07Fy5UrIZDLs27cPkydPxty5cyMaP5/xDZdwr8tqteKuu+7CN7/5TaxZswYA8Oc//xnf+ta3sHjxYkyZMgU6nQ4ZGRlYuHAhrrrqKly4cAGnTp3CZ5995n0eT2D385//nHMcr732GpYsWYLp06djyZIlMBgM2Lt3L370ox8FlLLhY8OGDUhJScGcOXOi+8HwQIEdIYQQEgN5eXnYtWsXdu7ciba2Nnz55Ze48sorvY9rtVocOXLEWyfu+9//PlauXOlXJ27nzp348ssvceDAAUilUvz4xz/GpEmTAADFxcU4duwYPvzwQ/T29gJw7+P74IMP8Nlnn+HgwYNQKBT49re/jZkzZ3rvOW/ePKhUqoDxDi5QzGd8we4VzlVXXcWZXBBMuNd1+vRprF69Go899pj3mttvvx29vb2orq7GlClTvOP9z//8T7z55pvIycnBP//5TxQXF3uvueaaa4IGdQAwYcIEVFdXY/v27Thz5gxmzJiBp556yq9O4J133om0tLSAa5988kmUlpb6HVu/fn1cgzoAYFhPwZXLhF6vh1arhU6nCygKSQghJLEsFgsuXLiAsWPHQiaTJXo4vP32t7/F66+/HlGNNBI/TqcTCxcuRH5+Pv7+9797s1hnzpzpl3zhdDpx9OhRzseGW6jf/UhiF9pjRwghhBAyStBSLCGEEDJE0S5RkvhZsmTJZbkyR4EdIYQQMkTz5s3DvHnzEj0M4iMR2bzJgJZiCSGEEEJGCQrsCCGEEEJGCQrsCCGEEEJGCdpjRwghhJARIZnKkyQrmrEjhBBCCBklKLAjhBBCLkMdHR1UUHkUosCOEEIIGQHa29u9HRRiYevWrVi9enXM7keSA+2xI4QQkvw+eWZ4n+/6J4b3+XiorKzE888/j5qampjcLzs726+nLBkdaMaOEEIIGaLW1lacOHECgHuJ8/jx47Db7Zzndnd346uvvkJbWxvn43a7HbW1tbh48aLfNRcvXoTFYsH+/fuxf/9+v+vNZjOOHTuG5ubmkGOrr6/HwYMHwbIs5s+fj//3//5fROMLdi+SPCiwI4QQQobojTfewG233YYlS5bgiiuuwJIlSzB27FgcPnzYe47L5cLDDz+MvLw83H333Rg7dixuv/129Pf3e8/59NNPUVRUhJtuugk33ngjpk6diuPHj+Po0aN455130N7ejkcffRSPPvooPvvsMwDAb37zG+Tk5OCuu+7C7NmzMWfOHL+g0DO2m2++Gddddx0eeeQR2O32gKVYPuMLdi+SPCiwI4QQQmKgrq4Os2fPRkNDA5qbm3HDDTfgnnvugcvlAgC8+uqr+Mc//oHDhw/j9OnTqK2txb59+/Dss8967/H444/jvvvuQ11dHc6cOYN33nkHDQ0NqKiowI9//GMUFRV5Z+zWrl2LzZs3449//CO++uornDx5Es3NzZg6dSruvffegLEtXrwYFy9exP79+yGRSALGz2d8fO9FEocCO0IIISQG5HI5fv7znwMABAIB/vu//xunT5/G/v37AQB/+9vfcM8992Dq1KkAgMLCQjzyyCP429/+5r2HzWbzu+ekSZPwjW98I+hzPv/881i6dCl6e3tx6NAhHDlyBAsXLsRnn30Gg8HgPS81NRWPPfZYyPHzGR/fe5HESYrkCbvdjs7OTuTk5IBhmKDnsSyL8+fPBxzPzs6GWq2O5xAJIYSQkAoKCqBQKLzf5+bmQq1Wo66uDvPmzcP58+dx9913+10zZcoUtLS0oL+/H3K5HM899xzuuecevPXWW1i8eDGWL18espl9bW0t2tvbcfLkSb/jV199NXp7e72fjfn5+RAIQs/l8Bkf33uRxEloYGe32/Gzn/0Mf/nLX6DRaCAUCvH73/8eq1at4jzfZDJhwoQJyM/Ph1Qq9R5/7rnnsHLlyuEaNiGEEBLAZDL5fe9yuWCxWKDRaAAAarUaRqPR7xyj0QiJROL9TFu6dClaWlpw4MABfPjhh7j77rvxne98B8899xznc8pkMnzrW9/CLbfcAiB4NwY+gRif8fG9F0mchL47DzzwAN555x3s378fTU1NOHr0KOeM3GCVlZU4d+6c9x8K6gghhCRaS0sLqqurvd9/8skncLlcmDFjBgDgyiuvxAcffOB3zc6dOzFr1ixvsGQymSAUCjFv3jysX78eP/nJT/Cvf/0LgHupd3CiwsKFC7FlyxY4nU6/44ODTD74jI8Pp9OJw4cP4/DhwwHjIvGXsBm76upqvPLKK3j33XcxefJkAEBaWhp++tOfhr3WbDajubkZubm5IZduCSGEkOEikUiwevVq/OpXv4LVasVPf/pTfOc730FhYSEAYP369Zg1axYeeugh3Hbbbfjss8/w+uuv+wVTc+bMwdq1a3HVVVfBaDTi73//OxYtWgQAmDp1Kurr6/HPf/4TxcXFKC4uxq9+9SvMnTsXjzzyCFatWoXW1lYcPHgQn3/+uTdrli8+4yPJL2Ezdjt37oRUKsXNN98MnU6Hzs5O3tfedNNNmDFjBpRKJdatWwez2RzHkRJCCCHhlZaW4n/+539QWVmJl156CQ888ACef/557+OTJk3Cvn37YDKZ8Ktf/Qrnzp3DRx99hIULF3rP+eSTT2Cz2fC73/0Or776Kh544AH87//+LwD3vrlNmzbh73//Ox577DF89tlnKCkpwZEjR1BWVobKykr8+c9/hkKh8M7yAe69ftOmTQsY7+ACxXzGF+xeJHkwbIIqC/74xz/Gtm3bsGTJEmzevBkMw0ChUOAPf/hD0KVVs9mMF154AQ8//DDkcjkOHz6MW2+9FStWrMCLL77IeY3VaoXVavV+r9frUVBQAJ1O5933QAghJDlYLBZcuHABY8eOhUwmS/RwePvtb3+L119/PSG9V51OJ44ePQog+B670TIevvf2PW/69OneVmyDr0mmn12o3329Xg+tVssrdknYjB3DMDh//jwYhkFXVxd6enrw8MMP44477sCZM2c4r1EoFPjJT37izcy54oor8LOf/Qyvvvqqt07QYM888wy0Wq33n4KCgri9JkIIIcmB9nklP3qP4iNhgZ0nwHriiSe8EfJPfvITMAyDTz/9lPd9iouL0d/fj46ODs7Hn3jiCeh0Ou8/jY2NQx47IYQQ4ouWKEmySFjyxOLFiwEAvb29yMvLA+BOq7bb7d5pRpfLhbq6Om+dOofDAZHIf8h79+6FVqtFZmYm5/NIpVK/NG1CCCEk1u68807ceeediR4GIYkL7KZOnYpvfvOb+N73voff/OY3kMlk+OUvf+ntkQe415QnTJiAV155Bffeey/+8Ic/oKGhAcuWLUNKSgref/99bNq0Cc8++2zC9xQQQgghJHaSYf9bMowhUgktUPzqq6/imWeewWOPPQaBQIArr7wSf/7zn6HVagEAQqEQ48aN887grVu3Di+//DKeffZZdHZ2oqSkBP/+979xww03JPJlEEIIISRJ+eaIGo1GaDSaUV0qLaGBnVQqxVNPPYWnnnqK83G1Wo1z5855vxcKhfje976H733ve8M0QkIIIYmQoIINZBTyLRp99uxZSCQSFBQUIDU1NYGjChSr33nqC0IIISRpiMViAKD6pCRmBnfrsNlsOH/+PHp7exM0Im6e33nPfwPRSuiMHSGEEOJLKBQiJSXFW+lAoVBEtWzmWz7DYrGMiL1R0Uq218p3POHO43qc770dDkfYcTY0NGD8+PERjyHWWJaF2WxGR0cHUlJShvwcFNgRQghJKmPGjAGAoGWs+HC5XOjq6gIAXLx4cVQ3rk+218p3POHO43qcz73NZjO6u7uD1rf15XQ6Ix5DvKSkpHh/94ciYZ0nEiWS6s2EEEISx+l0Biyj8WU2mzFr1iwAwFdffQWFQhHLoSWVZHutfMcT7jyux8Nd88EHH2DdunW896v9+te/xs9//nMAwEsvvYT58+f7zZgN189WLBaHnKmLJHahwI4QQsioYzKZoFKpALgzIZVKZYJHFD/J9lr5jifceVyPh7rG6XSiuLgYTU1NvMeakZHhnZEDgPz8fGzatMnb2jRZfrYjoqUYIYQQQkis7NmzJ6KgDoBfUAcAzc3NWL16NbZu3RrLoQ0rCuwIIYQQMuK1trYO+R6eRcxHH310xPavpcCOEEIIISNeTk4Or/M8TRCCYVkWjY2N2LNnTyyGNewosCOEEELIiLdgwQLk5+eHLI+TkZGBP/7xj7zuF4sZwESgwI4QQgghI55QKMSmTZsAIGhwt2nTJhQUFPC6H98ZwGRDgR0hhBCSACaTCQzDgGEYmEymRA9nRPDd9/b5558H7INbuXIltmzZgtzcXM7rly9fHnZmj2EYFBQUYMGCBbEb+DCiwI4QQgghSW/r1q2YPHmy9/ubb74ZxcXFARmsK1euxOnTp/2u8xVqZs/z/caNG3l3gLA7wxdCHk4U2BFCCCEkqW3btg2rV69Gc3Oz3/Fg5Ul8g7L58+cH3C/YzF5+fj62bNnirWMXisvFYn9dN/ae7Qp77nCiwI4QQgghSe2nP/0pZzeJoZQnGTyz9/777+PChQsBQR0jkkCgSPE71thjxpuHGrDvfDecruTq80C9YgkhhBCS1AbP1PnyLU+ycOHCiO7rO7N37bXXci6/SsZMgKxoOrafaEd5YQZOtejQ1Nsf0fMMJwrsCCGEEDLiRV2ehBFAnFnM+ZDTxUKSMwEAUN9jRouhLcrRDR8K7AghhBAy4kVbnkSSNRbSwmmcS6rnO00QSBRDHdqwoj12hBBCCElqeXl5UZcnMVqdkIyZwPkYy7KQ5k+GQCLH+c7AkjPHmvXRDzpBKLAjhBBCSFJ77rnnAERenkRWMhtvHW2HfNyVEGqyAh4/32mGQKYGEBjENff1o8NgDbjGbrdhw4YN2LBhA+x2W3QvKI4osCOEEEJGsHBFe0eDu+66CyzLYsyYMX7HQ5UnESi0kOZM8i6xysfODMis/apJ5/26w2BFS587KUJntmPPmc5Yv4xhQYEdIYQQMkLxLdo7nOIZaB45csT7dbDyJB6iFP89d0JVOs52DCy3Hm/qQ+egGbnD9b348lwX/r7vIlp1lpiNezhRYEcIIYSMQFu3bo2oaO9wjSmegSaf8iQe4pQxAcf2X+xFS18/3j7UiI+qOwIeP99hxIELPXAkWW26SFBgRwghhIwwTqcT69ati3nR3qFIpkDT4XJBqA3cU2ewOPDWoUY098WmDp3NZseyZcuSqt8vBXaEEELICLNnzx40NTUFfdy3aO9wSLZAs01nBSO4PCu6UWBHCCFk1BntCQV8i/H6nmcymcAwTFxml6IJNKN9j4SaLAjkmpDnNCZxZ4h4o8COEELIqOEJXrRarfdYMiQUxBrfYrzRFu2NVKSBJt+9eIxYBggG9tE19lqgmnI9VNOXILWkPGiQ2tg7MhMfYoECO0IIIaPGtm3bOI8nMqEgHhYsWID8/Pyoi/bGWiSBZiR78eTjr4bmiuWQ5k2GOKMQH9T2AAIhGKEYiglzoSi7NmC/nNnmQJcx+erLDRcK7AghhIwKTqcTP/3pTzkfS1RCQbwIhUJs2rQJQORFe+OBb6A5b9483nvxGrpNEKflgRHLICueAcWkawLafonT8vHusTb8fd9FfHmuCw3dZtR1msAiNlmtLp/nq6+vB8u6YnLfeKLAjhBCyKiwZ8+egFkgX8OdUBBvK1euxJYtW5Cbm+t3PFTR3njhG2h++eWXvPbi/frX/40bv7Uu4PGzZ89yXtdttOHAhR6881UTPjzdHu3L8FNdXY0XX3zB+/0bb2zGxo2bUFNTG5P7xwsFdoQQQkaFaBIKRrqVK1fi9OnT3u/DFe2N91jCBZqDf/aMWAbJmPEB9/rv51+GwREYorz3HvdSe6xVV1ejsvJt6PUGv+MGgx5VVcm9nE+BHSGEkFEh2RIKhgtX0d54ZsCGEi7QHPyzlxXPhHzcVVBMmg8IRGAkckhySyEvmTVsYx6MZV3YuXMnOFaLOY8lm8uzyAshhJBRZ8GCBcjLywu6HMswDPLz84ctoeByFao7hO97JFSnQ5JVDAAQZxRBo80GI5YC4N6nBwxPYFVf3wC9Xp/QMQwFzdgRQggZFYRCIZ577jnOxxKRUEAC+b5H8pIr4BvEMWIZQgV1sfD0089gw4YNsNuDZ80ajca4jiHeKLAjhBAyaixfvpzzeCISCi5n4syxkORM5Hxs+fLlkOROglCVPsyj4kelUiV6CENCgR0hhJBRLZEJBZFK1N64WI7H6nBCPnYG5CVX4OPaLr8SJS4Xi73neyAfO9vvmrVr13q/1mjUCFI1JejxWCoqKoRGo0noGIaCAjtCCCGj2uB9XiS+Dl7sAyOWAwCq2wx47cuL2HmyFUfqe7H1aDOONekCrikoKPB+XVFxA4DEBVAMI8DSpUsTOoahoMCOEEIIITHRZbTiRIt/iRBdvx3VrQZ8fqYTjT3msPcoLZ2ENWtuh1qtDnhs2TLupfZYKysrS/gYokWBHSGEEEJi4vMznX5dJfgkK3ApKyvDgw8+FHB8woQJQx7jSBpDNKjcCSGEEEKGrKnXjPru8DNyfAkE8VsHtdnsePrpZxI6hnihGTtCCCEkAXx71n7++ecjuoetyWRC6bW3YsOGDbDZ7Ikejh+JRIz169fjySefSPRQhgUFdoQQQsgw27p1KyZPnuz9/uabb0ZxcTG2bRuellmx1tzXD5F2TKKHQUBLsYQQQsiw2rp1K1avXu23Fw0Ampubcffddw/LGEwmk7dem9FohFKpHNL9Dl7si8GoSCxQYEcIIYREYChBkdPpxLp16wKCOgBgWdbbISOZCJQpkOZMRF2XCaUyOcTCgcU+q8OJow19aNFZEjjCQGKxBOvXr0/0MBKCAjtCCCFkmOzZswdNTU1BH+cK+BKpx2SDasoiMGIZdpzqwGfndchUS5GllgEMcLpFD5vDlehhEh8U2BFCCCHDpLW1NdFD4NRpsOJshwEXukwQMgwmZKuRrZHivePtl3q4utmdLFr6LGjpS64ZuqF48sknIBZLEj2MmEl4YFdXV4e//e1vuHDhAmbOnImHH34Ycrk86PkulwuvvvoqPvroI8hkMtx+++1YsmTJMI6YEEIIiU5OTk6ihwBpXhmMVsel7xgcvNiL4639cPnMFrZeWlq12x0cd4icb3mRxx9/PCb3JNwSmhX74Ycfory8HG1tbVi2bBlMJhPuuuuukNd897vfxS9+8QvMnTsXxcXFWLZsGV566aVhGjEhhBASvQULFiA/Pz/oXrpY77ETSP33/wlV6ZAVz8RbRzsgGzsLyvLFOFTf5xfUkdBYdmDpubGxMYEj4ZawGTuz2Yy7774bDzzwAH7/+997j/f29ga95tixY3jllVfw6aef4rrrrgMACAQC/OxnP8M999wDqVQa93ETQggh0RIKhdi0aRNWr14NhmH89tTFOqgTpYyBrHimX9AmzS8DADhdLKS5pTF9vsuF72TSW2+9lcCRcEvYjN327dvR0dGBH/3oR37HU1NTg16zY8cOZGRk4Nprr/UeW7NmDXp7e7F///64jZUQQgiJlZUrV2LLli3Izc31O56fn4/XX389+hsz/h/psqLpECpTcfJS79Y+sx3i9ILo758EkmGGzGAwch5PlhqECQvsjh07hry8PPT19eEHP/gB7rnnHmzcuBH9/f1Br7lw4ULAFHZhYaH3MS5WqxV6vd7vH0IIISSRVq5cidOnT3u/f//993HhwgUsXx5dg3mBTAXl1EWwOd3LhHVdJghV6QCAAxd7YbY5cLRJByD5yqlEIhlnyDz+8z//Mym6hyQssDOZTDAajVi7di3Ky8tx3XXX4eWXX8b8+fNhs3E3C7ZarVAoFH7HZDIZhEIhLBbuDJ1nnnkGWq3W+09Bwcj+a4UQQsjoIBQKvV9fe+21ft9HSjJmAkSaLPz7RDusDicO+BQMtjlc2F3dgdp27pmmZFVTU5voIUSkqakJe/bsSfQwErfHLiUlBTqdDtu3b8c111wDALjxxhtRUFCA7du3Y+XKlQHXaLXagD14fX19cDqdQZdwn3jiCb/lXr1eT8EdIYSQUcPhckGSVQIAaNFZ8I999egx+U+QnO8wwukaGQkSnuxZtVoV9ByGAZIx36O5uTnRQ0jcjN2MGTMAAOPHj/cey8vLg0wmQ3t7O+c106dPR11dHQwGg/fY119/DQCYNm0a5zVSqRQajcbvH0IIIWS0ON9pBiMeSB40WGJToiTRgu1lA5IzqAOAxx57DFu3bk3oGBIW2C1ZsgQ5OTl48803vcfeffddWK1WzJkzB4B7ufa2227Dxx9/DABYvnw5JBIJ/vjHPwJw17T73e9+h9mzZ6OsrGz4XwQhhBASB4xEEf6kS061GsKfBMDlM2PHlYRgt9uwYcMGbNiwAXY795aoy4Hvz8Fms0d0bVdXF1avXp3Q4C5hS7FyuRxvvfUWVq1ahTfffBMymQxfffUV/vd//xczZ84EANjtdmzbtg233XYbACA9PR3/+Mc/8B//8R+oqqpCX18fbDYbduzYkaiXQQghJIkkw+b1iDACyArL/Q9J5FDPuAl9ZjvCtaHtMlq9xYRDqa6uxs6dA5+VyZyEEKn6+nqMGzcODJPQ0rwABvr9Pvroo1i+fPmQ9k1GK6GdJxYsWID6+nrs378fAoEAU6dORXp6uvdxpVKJqqoqzJo1y3ts+fLlaGhowKFDhyCVSjFnzhxIJKOnFQghhJDobN26FY888kjA8W3btuHOO+9MwIjCE6fnQ5pXBl3/QBAnzZ8CRizFjtMduOcaDcRC/4DF6nDiaEMfOgxWtOmCV5LwqKmpRVXV1qDLlzU1tSgvL+d+MIHUalXI5ViPN97YDI1Gg6VLlw7L6p1cLg9ZwYNlWTQ2NmLPnj1YuHBh3MczWMLDW7lcjuuvvx7XXXedX1AHAGKxGLfddpu3pIlHSkoKbrjhBlx77bUU1BFCCMHWrVuxevVqzs3rd999d8L3PQUjzhwLMAIcqu8DAJhsDkizxwEAekw2fFTd7lfE2Olisf1YK/ad78b5DiNM1vAzlLt3fxhyT9ru3bv9uikki0WLFvM+12DQo7LybVRXV8dxRG7XX389r/MS1Rc44YEdIYSQ0cVkMoFhGDAMA5PJFPfnczqdWLdunV8ANNijjz6adMu0ZpsT4lR379gz7SZ0G6042qgHBAPLd9WtBmw50oQ+s3vP2+7qdjT0mCN6Hr0+9B48vV6P+vqGCEcffxMmTOB9ruet37VrZ9yDVLVazeu8RPUFpsCOEELIiLZnzx40NTUFfdx3aSyZnO0wertFsGDxaW0nTrUEBmFNvf14fX89tn3djNMt/IrsuyIsbfLaa69FnCgQLa7AKxbBGMsCOl38g9T8/LyQjzMMg4KCAixYsCCu4wgmoXvsCCGEkKHiu+SVqKWxYGrb/WczG3rMcLi4Axy7k0VdJ7/Zz8GJEsnGt9eqx4svvhhw7OzZs1Hd32iMbyFm3ySNwe19PZ2xNm7cmJDECYACO0IIISMc3yWvRC2Ncek0WNFptMbkXmKxBOvXrwfgDuoqK99OaJ03iUSM9evXw263eYsN++JKiOjvD8zsfe+96HqvqlTchY3DlXuJ9rl838X8/Hxs3LiRs8nCcKHAjhBCyIi2YMEC5Ofno7m5mXOfHcMwyM/PT9jS2GAmqwP/Pt4S8/uyrAs7d+5MyuK9sdr3ptGoYTAYOF8jwwAajQZFRYUBj/Ep9xIsEB3MNyi8//778cxPHgTg7vd74403JmymzoP22BFCCBnRhEIhNm3aBGBgKWywRC6N+bLYndh6tBm9Zu79bL6zSvX19REFRPX1DdDr+e3B42so4/HV1BR5qy2u4K2i4gYAXEug7n8vWbI0oJ6dZxYzWBJJpD1pPUGhACwyrQ2YnuqebRxqv99YoRk7Qgi5zJlMJu/yldFohDJcVdwkYzKZsGrVKgDu5dbBe+lef/31hC6NedgcLlQdbUaXIXAJ1mazB8wWRVqfLZK9ZWvXrg1bpHjwLNdQ6sXFat9baekkrFlzO3bu3OEXqGk0GixZEjguPrOYu3fvxtSpUzgf49rnpxXZMEOjQ7lKj+zz7yBPMTxJJ3zRjB0hhJBR48iRI96v33//fTgcjqQoTsyyLHacbEVbkC4RwRIFIqnPFmxvGZeCgoKQj9fU1HLOcun1erz99ts4ceIE7+eKdGzhlJWV4cEHH/J+f9ddd2LdunWcwSafWcxQ5V4+/vgjAAADFhMVBqwd04TvF1zE3JQeqEQOXLhwYQivJD4osCOEEBKx4a5Vx5fvUli8l8ZE2my06iww2xyw2J3oNlrRobdw7vP7tLYzZFarJ4AYLJL6bEVFhdBoNAHLlB7BjnOJRVFj32VcV5Bs31BCjVcgGHiwqKgoaDsxvjOFwc4T9Pfg2tQuPFRYh5VjWjBWYQLDDLwumy02CTCxREuxhBBCSIREKTlQTlmIrV+3Qizu9ntMJRVhQrYKaUoJLHYXekw2VLeGnjUK1TrLtz5bcXFx0PMYRoClS5eisvJtMIz/HrVIgjqAf1HjYOMZvIxbWVnpN5bhSvDgO1OoVCq8XzNgMVFpxHS1DmPlZr9AbiSgwI4QQgiJgMHigGLiPADc0ZLR6sDRhr6YPy+f2aeysrKge9AWL66IaWs13/H4zs7t2bMXe/fuCRq8yWQyv/ImCoUcLIuA/qsrVqxEeXk572xVLp5ZTINBHzKYfPfdbVi2eC6uTe3CNLUOKpEjqudLBhTYEUIIITw5XSx2VXeAEUuH/bn5zj6VlZWhpKQEzz77LAD3HrRx48bB4YhtsOIZz+DZuXAdPkSigdDDMzabze4dr0dp6aQhjzHULCbgnp2boDBilrIJeccOIz/V/wSpVAqrNfhyq0QiBRBZi7d4oz12hBBCRi2HM3Z9Q+u7Tdh8oB7t+tjvq1KrgwdtDANotdz12YIJtwct3P44jUYdcvnWUy8uXCkRLr7Lzp6x+Y431jyzmCrVQI9Xrcjmt3euWG4Cg8ApvZKxJSHvPXbs2JiPd6gosCOEEDIqtegsePNQY9TBndHqQG2bAQfquvHOkSZs/aoZXUZbzGq7+Vq0aDHn8VD12YaCq62Xb2ZusHpxA49XAEDSFkQerKysDMu+cQtKlQOZrfNSu8MuuWZkZGDK5CmQSrlnaNPT0uIx3CGhpVhCCCGjjkCmxo5THXBCiAMXejB/fEZE1zf2mPH+iVaYbU6/41y13TyefPIJiMWSqMY7YcIEzuPB6rMNFVeyhm8Lr2D14nwfj0dB5HiQ2nXINtUgR/cpCrIj7/iRkZmJ1NRU7P1iLwBgypSpOHXqZKyHGTMU2BFCCBlVGJEEyikLYbE7IRYLcfhiLyZkq5CllgW9pq7TiA6DFZlqKfrMduw92wXXoKmocH1Ya2pqUV5eHnZ8fJMBPPvPYjVT5zvTyMfgvXqDixpHW3RYrXa3BYsnhnUirf8isow10FpaALDoEUc/s+rb0USr0cRghPFDgR0hhJBRRZpXBoFsYD+V1WbFuAW3wXjsAxiNBs7OGofre9Hc2x9w3COSDgaxCsRC1WeLRmMjdxFeD9/XxtUJY3BR42iLDk+bNg1ffPFFVNdy8R3rL3/6EPKs55FpPAOxy//91Gq0MXvOZEaBHSGEkFHDYndCkjMx4LhQlQ5p4VTOa9p7dLj/0f8EwARdTo2kg0GoWnOJZDTGtpA031Iig8UyqAPcs3OlSgNmaHSY1b4FQgF3MBysj/BQuBghOq3JFUpR8gQhhJBR43iLEYxQzPmYLH8KWjlaep3rNCFYTTqPoXYwSAYqVWx7AHtKibi/HvwYv3vU1NRG/fypYhsWpnXi6s5K3JZ9KbOVZ4QpkfgH71KpFGWl/PcxNlnk2NE5Bvuy1uJQlzyicccbBXaEEEKSSrTtyhiRFKfaQpzPCLC7pgtWh39CxNmO8M/Bd9kxlj1RY62gIHS5lGgmtDylRNRqtd9xjUaDFStWhL2eT2syXwzrQIbpLKZ2/hsPFFzAnJQeSJzBl9CDmT17tvfr8vJyzLl6DjIyQifY9NnF2NubjoOZq/F6SyGOGbRwCoa/nmE4yTV/SAghhERJmj8ZdmfoGRu9xY5dp9pxS3kOhAIGOrMdHYbwden4LDt6arslK99acbFs6xWsIPL58+fDXutZvs7Lyw15XrrYihkaHa5s/SekjAMup5PzPKfTiT173QWSF1yzAIIgvYIZnxnaFG1K0KjWIZCgTzkeLdKx+FNjBwBgjkjNeW6yoBk7QgghI5qLZSErnglpHr+ltPMdRmw/3gKH04Xadn7ZmaGWHT0qKipimuwQT1wzi8uWLY/6flwFkfnu6Qu2fN14sQ7pxlpM7fw3vldwEVdqeyF2xb449GAulsF5sxLb2nNwMOcO1KVfB4N0TNyfN1Zoxo4QQsiIZbE78a/j7byDOo+6ThPeO9YCk5V/m61gfVg9ommB5UnWsNttEV87FPfffz9+97vf+x0LVksvWnz39A0OMjMlVkxX65D2xX+jWyGCNkz3h1gxSdLwUXcWThvVMDnd4RHLjLwwaeSNmBBCSFLxfDAbjUbOUiLxtOtUG5r6It9jBQD13ZH3+AxV28237MZQihUPB66ZRd+9bo2NjUN+jnB7+gCf1mQnjmG6ug8zNDrkSAcSXKxWJ6prqoc8lmCMDhGaVVPRqy2DjtHgkK7G7/H6+nqMGzcubs8fDxTYEUIISTqMRA7WFjpgO3yuDfc8/NNhGtEA32XHwbXdRjLfNmO+hYijxWdP36pFV6CkZw/sp/+OcZnRBeiRcrACdMrHorKtHnVmJZ5IudodhHPMmr7xxmZoNBpvC7WRgAI7QgghSUcxcR6c5r6A7g8eun479p7vGeZRDa/hngHkajMWKyqVynt/EeNCmdKAmZo+rNachL7ZANYe/6BOL83Czs5sVJvU+GHKQpw3H/Z7PFjpFYNBj6qqrXEfX6xQYEcIISSpGK0OiLRZEGmz8f7JDtx2hRxS0UB2o93pwq6TbbA5o28RFQ2+rcBIoPvvvx+v/uEZzNTocOf8Ypw5edb7mM0Wv/2FVpEKnYqJ6FROgBFyfG3g7vHKsi7s3v1hkMeiKwWTKBTYEUIIiSmnTymKzz//HDfeeCOEQcpOcHHXlXN/ktb3mFF5uAnLZ+RCLRPD5nDhvWMtaI5yXx0ZXiLGhckqA2b27IC44CIAIENdhjM+5wwuFjxUVpcQtSYVUjJvRr+ycCAqC5Gg4u4sEjxDOlalYYYDBXaEEEJiZuvWrXjkkUe83998883Iz8/Hpk2bsHLlSl73GFwwuNNgxT8PNmLp1DH48nwXWvoCu0eQ5KKwdSNddwI/LKqDVOCExtYR9NwUrRZSqRRWa/SlTFwsg4v9CqSmXIc/1nfCwQowQ5oDMc+ptkg6hkgkYqxfvx4Ahj2bmQ8K7AghhMTEtm3bcPfdd4MdNL3R3NyM1atXY8uWLZzBncPpgkjoztLsMdnQaQz8gDdaHdhypCk+Ax+hfJeGkyEL1zM7N63jPWidPXA5nTgn4C4k7IdhUDK2JKrs106bFHXqK/BiQzuMThEK5SVwsJHXEkzmjiGRosCOEEJITPz0pz8dCOqEIoi0Y+DoaQLLsmAYBo8++iiWL1/utyzb0G3GjpOtWFyWhfFZatS06RM0+vjyDcIef/zxYXkeD98kDI+zZ88iVjyzcw8X1kEmdEJt6wQiWHoHELSdl1Qqxfhx45GRmek95hDI0CYvwitNDWi3yfC4qhxG564hvQZ3ZxF10OXYWHbqiDcK7AghhMREc3Oz92tZ3mSI0vNh7HHPsrEsi8bGRuzZswcLFy4E4A7q3jvWDLuTxfbjrZhTYsOZNn6dIMjQfPzxR0O6XuByINN4AdnGaqhsHe7ZOSGP2bkIlJeXIy01DWAYsIwAvbJCdConok9eAJvDiXbbpzF7LoYRYPHiClRVVXE8FrOnGRYU2BFCCIkpRiKHJK8UjEAEkTYbDl2797HW1lYAwMlmHT6t7fD2dmVZYN/57oSM93IUbWmTLIkFM9Q6GN98AE1CJ8ZesyDi2Tm+UrQpMMhy0KmcgG75WDiFMp9HYxtEVldX46OPdnM+ptFosHhxBbZuDSx5IhZL8N5776FicnZMxzMUFNgRQshlLtosVkXpNRDINXD0tcHeVQ+nwR2YyQqngRG4P14kuZP8Ajt1+hhsOdKExp7Iuz7wEYuOCYngciXvOp+YcWGySo8ZXe9BlF/v95jT6cSevXti+nx9djFOGjWQj1kDl5x7iTaWampqUVW1NehS6403LsGECePjPo5YocCOEEIuY9FmsfYaLRCn5QOMAEJFCqS5pVAL7eg8ewyS7IHenuK0PAhkKrBWE/KnXIU6QR6ccQrqgNh0TBhu1dXV2LlzR8DxWO6D83jyySfQ3NyC1157Ley52RILZmh0mKwyQCpw4sz+wH1s3T2xKRLtEEjwtT4FJw0aNFnlAIBrRRqIY3L30Hbv/jBoUMcwwAcf7BpRbcUosCOEkMvU1q1bsXr16oizWLdu3Yp1z/wZkPrPpky5cgEOuNwfxQO3ZCDNKwNYF5Z+7wk4YzgxFaxTgGdP1Llz51FWVha7J4yDULNF7723LS7PGSpRQMI4MUVtwNWZVqSwfX6PcRUSrq2tCTjGl4tl0CvLR4+mDO3iXOzs4p/1LBZLYlZyJFz9Op1Oj8bGhiE9x3CKPCeYEELIiOd0OrFu3bqAoA6A99ijjz7qt0wLXAoG134TepE24LoDB/aDZQOzBzMnzcbd634R0yArXKcAANi1a6dfY/tkFGq2KF4YRoCKihv8juVJ+3FLZht+WFSHJRntuHrimLg9v1Gcho+7M/FiQwlOZyxBt3I8WCa555mMRlP4k5JEcv8kCSFkBDKZTN66WEajEUqlMsEjCrRnzx40NQWfIeHKYvUEg+KscWCE/BbJ7rrrTowbNw4ME9t5BD6dAnQ6PerrG5CXlxvx/YerRlyiuh2Ulk6CTODEFJUeMzQ6ZEr8awemp6XF9PlsQjkO6VJx0qDBf2Qsx0Fd7JeZ40mlSr7/hoOhwI4QQi5DnuzUSM7bs2cPmjt6oJo2i/NcrkCkqKgo5kEdwL9TQCQdBUaCWNTDU1ta3XXniuogYgZmNKdMmYpTp7h7qUbDxQhQY1TjhFEDR+bt+Kg7OQtMazRqGAwGzt9fhnFnxRYUFA7/wKJEgR0hhFyGcnJy/L6XjBkPp6kPTkMX53nnOoz416kuaK5cDk8f10Ti2ylgNHUUiJRnptFut0EucKJcrcPM9i1QuYxwOZ2oZfyXqbUaTUye1yDJRI+mDG2SQrzb0eY+GCa49+yZ4yqwHG8VFTegqmpr0CLES5YshUCQ+N95viiwI4SQy9CCBQuQn5/vLiosFENWNB1gWRiP7YLLagLDMMjPz8eCBQvQprPg/ROtcEg0SIagDuDXKUCj0aCoqBAOhyNu4/DdwxdNqZVws0VDWo5lWWgtTUjTncLDRechZFgo7Lq41J0zOkQ4adTghEGDB7KWQSyWwBEkqcG312oyKC2dhDVrbsfOnTsCfp9WrFiJsrKypOwJGwwlTxBCyGVIKBRi06ZNAABZYTkYkRSMWAbllOshEEsBABs3boTdBbx/ohVOF3spmNIErcQ/nBX6uRIABo9jyZKlcVkG9vXSSy95v+ZbasU3GJw+fQaA2P7slEIH5mh7MKt9C8o63kemuQ5CJvYb9hysANUmNd5qzccLDSX4tCcT3XZpzJ8nVjyzguvXr4dE4r9HtKysDA8++FDANaWlk4ZreDFDgR0hhCQpk8k9c8YwDEym2GflrVy5Eq+9uQXpEwf2zAnkGuQtvBPPvPwOKm6+FR9Vd0DXbwfgDqaWLl166euYDydiwT50NRoN1qy53ZuF61v8t76+PuJM2aeffgYbNmyAzWYPeCxYB4dgpVgA/2Bwz549kMvlkMnkAectW7ac/yBZFtr+Jkzq/ggPFtZhYXon5I7o++6yCAwEJRJ3AkmzRY6dndn4Y30JMOcHuNCvBJvAmVzf93coBapDLbf6BoXxSqSJFVqKJYSQy5TJ6oBywlV46KEJePbZZwH4Z7G+vPdCwFJgWVlZ0GWrZcuWY9u2+NRe42twFu7g4r9vvLEZGo0GS5cuDRr4xaIY7e7duzF16hTOGcPBwWB/f7/fz9nzGhwOR9ifp0rowDS1DrPbK6FgzXA5nTGZnTty5Ijf91ahGoIJi/DnncfRax8IbCZMmDDk5xqKwe/vSCxQHWsJC+xcLhcOHjwYcHzcuHHIzMyM2TWEEEL89Zhs2F/XjXMdRjhdrN9MhW8W6+Cgzndj+49//CP87ne/93s80R/ygP/4q6urUVn5dsDrMBj0qKx8G2vW3A4AnIFfRUXFkMah17tLrRQXFwMI3TKMZf3304XPJGZRIjdhcq97dk7AsJA5DDHdO2ez2WB1CVFrUuGkQYNGqxw4VwOWTZ7ZqmDvr0dNTS3Ky8uHd1BJIGGBndlsxty5czFlyhS/rKVf/OIXuOWWW2J2DSGEkAEWuxPvHm32Lq9GK55713yDoGhrybGsCzt37uT80PcEUtu3/ytgtgxwB35VVYEN3yPlW2olXOcCPkkSEocRY/Qn8WDhBWhEdmRYGiCI4d45FixYlsHFfgVOGjWoNangYAfe52RYfvcI9f56hJo1Hc0SvhT717/+FXPmzIn7NYQQcjmq7zYhXSWFSioCy7LYcbJ1yEFdPAXrmxrp7Iu7gHHwPWYsC5jN/UEfi0UQ4zsBEW3nAgYsxilMOPO3hzFOYUL5vLmoF8X+/euySXGgvxAvNrTD4OQuPh1phm4s234NFu79BdyzphcvXsTYsSUhzxttEh7Ytba24tixYygpKYFarY7bNYQQcrmxOVzYebINDheLOSVpsNhduNhljugesSiIy1eopbWqqq0QiUS825INtTDxULs+eEqteETaucB3dk4dh0AOAMxOIaqNapwwaNFmk+GW6XkwOL+O+n7x7NAxGN/3t7JyC2699daA3xvfoHO0Sfj85H333YdvfvObSE9Px1133QWdTheXawgh5HLzVUMvzDYnbA4XPj/ThYMXeuL6fEPJSOSztBZJ79fhKkwcbGavoqLCbwkwXOcChnHPzo1XGFHW9QFmtryJQv3RmAd1LkaAHnkxqtMr8Hz9OHzYnY02mwzAyCrmzHes/f39qKx8G9XV1XEeUfJIWGAnFArx8ssvo7u7G9XV1Th16hS++OILPPzwwzG9xmq1Qq/X+/1DCCEjHcuyMFjsaOo1cy6t9tucOFLfO6xjGkpGIp+lU0/vVz7C1dyLlWABhlwu8wtCfRNUBo9JK7LjmtQuPFh4AavHNCPN0giGo9zIULRaZfigKwuHxtyBM5k3okdeBNegEiX5+Xkh75FMe+wifX8j+aNgpEtYYCeXy/Htb38bzKV3ZcKECfjZz36GysrKoFXCo7nmmWeegVar9f5TUFAQnxdECCHxIBBCkh1YfuOfhxrx1z0XUHm4CS/vvYA3Dzbg0MUedBrczdwPXeyBzRG/D7KzZ2PbxD2a3q+hMk1D1dzzfK9QyIdcbPn+++/3fq1QDNSie+ONzfjlL3+FEydOBFyjUqnAgMVEhQFrxjRh3YQWfHdOVsDsHDvE9WCrUIkWzXR8lb0SrzUX4St9KhxC9+ycZynyySef8J7vO8MY7GeWLHzf33Ai/aNgpEv4HjtfY8aMgdVqRVdXF8aMGROTa5544gn86Ec/8n6v1+spuCOEjBiS7HGQ5pb6fch3GCxo01n8zmvTuY/tPdsFtUyEfpuT836+e+aGsifq448/iuq6YCLt/conySJYzT2NRoMlS9xBQWXl27xbd/nO+PjWmvPgSsbw7A0cP94dnGtFdvz6jitQu/NvUIkcKC8vR1pqGlwu/yC8q7MT586fC7hfd0/o5XSnQIRTBg2OGzUQjFkLsUQaVeKCSqXyq7en0WiweHEFtm4derZwrHje33/96z3091vCnj/UfZcjRULLnSgUCr9ju3fvRkZGBrKysgAATqcThw4d8tap43PNYFKpFFJp8rY4IYRcPkwmkzcwMRqNUCpDb6h3sSykeaUQSFVo6rOgVKWCyWRC8YyFkORMDBqYGSzx643qfY4gHRei5VlaMxj0QfumehISIkmyKCsrQ0lJCWcBZgARFVv27RjhqXe3ePHisK9t9673cVXOzVg7pgnFcjOKTCfQLHK/RynalIDpsK6uLlTXcO8Jq62tCTjGsgx00jHo0UxGuzgP/+pscT8whGm2+++/31unkCuITRZlZWUQiUTYvHlz2HNH0h7CoUhYYPeXv/wFhw4dwrJly5CSkoL3338ff/7zn/GnP/0JAoH7PziDwYC5c+filVdewb333svrGkIIGS3OdZggkLo/jE63GlCanwG70wVxZnFiBxYHnqW1UDNonlk2PkkWpaWTvMFbsALMQGDg58FVbHlwMOuud1cVdBzpYitmaHSYojqHnIs2jFXwK3lSd6GO13n9Ig329GTgpFGNhzJvgVgsgTNGZUV8f0bhCyaHF88s1MLC8Ikpg7OUR7OEBXbr1q1DVVUVKisr0dnZiZKSEuzfvx+zZ88eGJxIhKuvvtrbVYLPNYQQMlocbRrI+L/QbUa/zYlznSYwouSp/j8Ug5eFQ7UrW7FiJcrKynDx4kXeSRaerg/hhOoRGgpXcClkXChTGjFD04d82cDSLFef2WCsVmvwx1xC1BhVOGnUwJ6xAl/0XQAQu1ZoI9HgxBTf98UzablkydLLplBxQvfYrVixAitWrAj6uEqlwv79+yO6hhBCRoOaNj26jAOzL04Xi9OtepxuTY59Qmq1KubLsUDwGbTS0kkAokuyGA5pYhtmavowVaWHXBi4v1EsHij6q4uwOoOLZXChX4GTBg3OmFVwXuoGEW5p2BPscfXCHa1BDtfewCVLlvKufzgaJFXyBCGEjHai9Hw4uptCnnOm3YBdJ9sDjn9V34teY/hN4nwNpfDwokWLwzaoj1aoGbRIkyziSci4MElhxEyNDgXy4IWfxWIxzpw54/3+1KmTvO7fYZXipFGD00YNjM7Aj+vBgbVe7780/MYbm6FQyP1msDwB4NKlozPY4dobOFqD2GAosCOEkGHS0NMPZem1MNfu9R6zO11450gT5BIhpuZpYbW78OHpdrg41vmMVv/N6zabPSYZrtHg2oM2HCJJsoiXNLENM9R9mKrWQ8ExOzeY3R58GbarqwtZ2dne701OES66snCwQ4x2q2zIY+XK1DUY9KisfBtr1tzuzdaN1lCKUsdDrPcGjkSX3ysmhJBhopg4z1s82Opw4pMzXQAA+bgrYbI6wLIsPjjVjladBXWdJrz3dQt2nWrjDOqiYbfbsGHDBmzYsCHmvTq5rF27Nu7PEao+nUc89lOJGBemqvS4K6cR9xdcwFUpvQFBnUQSGFiLRNx9Vz3qLtTBBQG65MXY0paHF+pLIL7yHnTYZHGrHef59dq1a2fIWoB8+Balrq+vH3IRYE+Sxfr164f1D5XRhAI7QgiJA3FWCcSZxdhytBVNvWbsPdvlnXFjRFJ8cqYb++q6cabdEOZOI8dw1Qj1JFlw9Qr3JFnESobYior0DjxUWIdvZLWGXHLlSuRzOILP1jVb5HivOQVVzgWoTV+Mc2YVXGBQWjop6OuLVbKgJ8mksZF/0d6amtqQj7/xxmZs3LjpsmrflYxoKZYQQmLM7nRBVjQNAGCxO7H1q+aAWbj6HjNaDMlXF2ykCJdkEQyf5Wsx40K2+Sz+I7cBeT6ZrRKJBDbbwMynVCpFydgSb805BuGn2AwOMU4a1Thh0KLH7n7uEpMdgyuxBnt948ePx5EjR8I+D19GI78SLCzrwu7dH4Y9z3eZdyTv4RvurQ2xRIEdIYTE2PFmPQSSgWLqziEud40Uw92LM9oyJcFkSyyYqdFhskqPSbq96Jb570+bPXs29u3bBwBBO0ZwsbkEOGtS4YRRg4v9CmBQABgs0YPr9YXr5xoplWqgSLZEIvbWmhu8dO/u5Rt+dpll3Uvkg2sJkuFDgR0hhERJb7FDJRH5fQAbrQ4cqe/zfj/SyksMJRnDt/yGh2+Lr2QkdFmRbqzBPXn1yJEOZByzCAzGfWfkuDpG+GJZBg0WOS6wOfiqQwCbi/v99yR68O3qMLifa7TbMT1JJgUF/JJMIikfE00tQRI7FNgRQkiUPjzVDpGQwc3lORALBegx2bDhtR2o2j7Qw9S3vMRQMxCTHVddu8EtvpJFvrQf43s/R7a1AXBY0SL1LyPDtdwZrk8rAPTaJThh0OCkQQO9U4yVK1fiQNXWoEFYRUVFREG/76yoXC7nzHoNx7doL99Zz2jKx1wuvVmTDQV2hBAShcYeMxp63Bvpq442Y3ZRKn7/1kfY/FZgD1PPvqMVK1YmYKSJt2vXTr/9YonavyQXOJFnOoX78i8iU2JFtuksBEIhuBZTfffSeXD1aQXcS601JjWU6Tfhz43dfo95EiG4uml4Ho+E76yob1B31113wmazY9eunX7P46lj198/cK5v0V6+2dLuMjNqXsuxHpdLb9ZkQ4EdIYREYe+5Lu/Xzb39aOox4V/vc/cw9ew72r179zCOMDlEk30Z6wForS1YltWCiUoTxukPol0SvGUX79syDHSyfLRKi/GH+jY4WAEmS8Zwnjs4EWLt2rV+ZUIiEazbR3+/BeXl5Rg3bpz3eTwFem02e8Axzywh3x6uDCNARcUN2Lp1K49zL6/erMmGAjtCCInQuQ4D2nT+S3fuzeWhe5iGeny045t9GStipxmZpjPIMtZAYu1Fryo2ZWW6bFKcNGggG7MWrCwVdrsNDjb8Uqrvkmc8ysLs3r0bU6dO8XseT4FermPR4DO7eDn2ZpWJhYkegh8K7AghJAKdBiv2nO0KOB6P/URcPT5HKt/sy/hhkWppRG7feaT214O5lAAx1FzdfqcQp41qnDRq0GqVAwAWCZUIXXp4eOn17mSFvLzcYX1ehcJ/n9/l1ps1TSnBlWNTEz0MPxTYEUIID3anC/vruvFVfR9cLAu73eaXQRrr/UTV1dXYuTMwCaOioiKmzxNvkWZfhuP7c/f0uFUJHZiu1mG6RofJXR9AIBz6DIqLZVBnVuKEUYOzJnfh4GSXiGSFH/zgB6OmN6tYLMF//2oDUhUSsGBhtjr92viJBAzK87WoaTOg3+aERCTALdNyIBXRjB0hhCQdl4sFwwAMRwmLi10mfFTTAX1/8C4CfHqYqtUaXsux1dXVqKzkTsKoqgq/xylefDMyuXqEDs78jCb7MoLRINXahBXZLZigMELAxKZWYJtVhpMGDU4b1TC7gn9ExrqMC9+9bqEkIllhtPVmLR2jxuIyd+9eh9OFw/W9OHyxBwqJCN+YnoMstQxzStKx73w3xmhlyFBJEzziQBTYEUJGPZPJBG12AaSF5Tj9ybsoyh5YOuk12XCqRY/TrTqMzVChoizLG9z125z4tLYDNW3h92d5ephWVr4dNMCpqKgIu/mcZV3YuTN0EkaseQrT+s6GcfHNyOTa/K9Sqfw290eTfRmMZyla6jBgQWoXpqn1KO/5EAal+71ZcM2CqGfqbEI5DvSl4aRRg04bvw9qz562sPf26XQRT5HWw4uGJ/gM93sykk3MHmjjJhIKMKckHWVjNJCKBd69dDKxENeXDu4VkjwosCOEjHr1PWYoyyvACMV4+6sWXFFih0QoQF2nEV3GgYDjZLMOLpbFjZOzUd9txoen2/2WYsLx9DAdXNrCE+DwqWPHJwljOPnu8xuckekJMj1juv/+++OyLCcAiyPv/hniLBsWTs7C/NTu8BeF4WAF6FKMRY9mMjqFWfikpz6i6xO1py2YSOvhkUAKiRB5KfKA41pFMu2mDI8CO0LIqMWyLI429uGjUx1ghGLvsa8b+oJec7pFj06DFZ2G6EpiDC5t4Rvg8Jm1SqairtXV1dixY0fQxwfPIPJdlgs3i+VpNp8qtmGGWoepaj2UQneAXVMdmLgSCYM4A7u6slFtVONHaYvc9fSinE1Mpvcq0np4o5nL1g+BJDBAG0wiEsDmGNheMD5LFYctA8OPwntCyKikt9jxzlfN+Ky2E2yE01zRBnUeQykvkSxFXWtqalFZ+TYMhtDL0LGeQWScNjR/8TbuzGnEAwUXcHVKjzeoi5ZnqfWvjcU4mnErjupTYHENfcN7vN8rT4AbzPz58+P6/CONQ9eO5eUZMNfsCXvu+CwVvjN/rN8Mne8y7EhGM3aEkFGl02DFyWYdTrfq/f4aHyn4JGEMx3Ls7t0fDuuyr8rWiVzDBQibD+F65fkh349lBOiVFaJTOREdojERL7Wq1aqgxYCB+O9pY1kXdu/+MOQ5x48fj8tzj0QOfQdMJz9CtloKp6ELrD14q7XrJmViVqF7n+2SqWPw+v56iIUM8lPDz/KNBBTYEUJGBbvThZ0n23CuI3mWx6LBJwkjGp6lzx//+Ee8zo+kdVS0pAInpqj0mK7WY3rHexAIheiwDq2QsUmSgU7lRHQpxsMhlLkPRrHUOm3adHzxxRdBH+e7p40re5gP917L0O9BuNnUy4m1xb/dm727ifO8kkylN6gDAK1cjOsnZaFN38+ZET8SUWBHCBmRWnX9kAgFSFdJYbI6sO3rFrTrLeEvTCCugsNcwUGoJIzFi8Nn1obim9nqMZTSHdHMIGps7fhGZismKY0QC/xnVSWSyHvImpwiNKumolc7GWZJesTXcwkV1AEDe9p8y5Rw7aGMtnVYMu3fS3ZqmQiO7ma/Y1yBnVDA4LqJmQHHJ+dqUJSuiNv4hhsFdoSQEcflYrHjRBt0/XakqySwOVwwWAKXxJKpLEOogsOeQO3JJ59wb+ZH8CQMm22gll40s0Fcy4tVVVshEol4Ze1GS+Sy4gpNL2ZodJjR/T7Mau7M3xStFlKpFFZr6H2OTpZBl6wIW9rqcd6sxBMpV3t/dpEKt5fNI1yPV7738ZSXCSVZ9lqOBOW5GgD+f104dO2QiAR+R2cUpCBFwf07opSOnnBo9LwSQshl41ynEbpLxYK7jf6zJFydCRIt2oLDg5Mwampq/YLDaGeDuOzatRMlJQ96v9do1DAYDCFn4wYHppznWFqQZapBiuEcbBkdQc/r0/UhLTUNYBiUjC1BdU0153mdNimO6bU4ZdTgodRFOGf+KvyLC4HPXjaPUD1eI7kPH+69luqQy7FqtTpuy7GxKJg8HCQiAa4Yl+1NkDKZLi3lsy4UpSlwsdf9/weFRIirxqYlapjDigI7QsiIc/hib6KHwJvLxUZccJhrprGmphZVVVuDBlpDWU5lWUCn06OxscF7rKLiBlRVbQ261LpgwQJcf/1CzuQBpdCBPMMx5FrqIHPoAAAu1hlyDCdOnIBUKsX4ceORkZHh95jJKcJpoxoNTB7Kr70VhyNcig61XMpnLxsfsbqPB8MIUFFxQ8igedGiRdi2bVvMnnMkKstRewsHD1aS4Q7sMtVS3Dg5O+h5ow0FdoSQpNZhsOBCpwkzClMgFQnR2GNO+r10vhobY1NwOFyWqqcTwlCK1BqNA4kLpaWTOPf5eSxYcM2g5xpo8TVeYUSx7nDQThDdPT2cx61WK06dPoWy0jI4WAHOmZQ4adTgvFmJO++6C/PHjYt5Fmqs9rLFY09cuNp0EyZMiPlzjiQysRBXjw2+p7IwTY4FE0SYVZg6KurT8UV17AghCWe2OdBvG5jRYVkW9d0mVB1twhv7G/Dl+W68vr8BjT1mHK7vgd1uw4YNG7Bhw4Yht6qKN99gaSjCzQbp9Xr88pe/GtLPo2dQwFVWVoYHH3zI+/3atWsDrpE4jLgmtQsPFl5Aec+HmKQ0QBimb+uFC3VBH2uxyvHXr63Q3PkSJn/3jzhnVoEFE7c+pLHayzZce+K43oPL1bUTM0LujZMIBbiiOO2yCuoAmrEjhCSBD0+3o77bjKJ0BTLVUtS2GdBntvudo++3452vmoa9pdZQqVTKYX0+3yVZ3yxcPvbuDSzs6vuh6NljJgCLtP6LyOs9D7W5HpYQLb5cTif2DLqvzeYffOodYpw0aHDCqEGv3b25vaSpY1jadYWrGxjZfULviYuFUPv8RosxWhnkYiEudA38UcQwQI5WhpY+92x9UboCU3K1AdcqlcqIC5KPNhTYEUIS6ky7AXWd7v+B13WavF9zGYn/vy4oGN6Cw54MVwB+iRaxIHPocV1aJ8pVepR1fwSBUAhXlIO3uwSoNalwwqhBfb8CgP+syuClzXBtyKIVqm5gpPcJtyeOhKaUCnHN+EyU5ajhYoH3jjXjYpcZDANUlGVjap4WHQYLjlzsxbzxGeFveJmiwI4QMqycLhbCS7NAFrsTn9V2JnhE8SUQMDEpOMwnS9Vj+/Z/ob+/P+IghTPwZB2YrNRjukaHK7u2wpHiv1wrEApx3XULAbhn58Jp7FfghFGDGqMKNjb4ZvZ4LW1y1RIMVjcwUuXl5RCJREO+z+Xqpqk5KEhz15MTMsA3puXiva9bMCVPg9IxGgBAllqGm8pzEjnMpEd77Aghw6ZDb8GrX17EP/ZdxL7z3fi0tgNGa3xaMiULm82Ot992lzoZHKxoNBqsWLGS130qKm7gdR7LAmZz5EHdYGJTG754/iEYNz+AZdmtKJKbwUR5U71DjC970/GnhrF4o7UAF5AXMqjztOuKterqarz44gve7994YzM2btyE6upqXvsJ+YjVfUaKXK0UpurPwTrt4U8OoSxH4w3qPMRCAVbOyvMGdYQfmrEjhAyLUy067DzehF/9+mkA/sV4Lxf3338/fve73wMYKDjMN8vTk6X6r3+9h/7++GQFSxgnJqsMmK7RYXzd67Bqoy8r4xCIoVOOR6u0GC82tMN3qXXRosUhy3TwbdfFp9CvR6hagpWVb2PNmtv9CjQPZS8b177EaHjKtCRToW0vlxOm6s/wjSn/C0dPE2ytZ0KenqGSoCBNAYVEBLPNAV2/HRe6TGBZd3brtRO5l1ZHS5uv4USBHSEkZrr69CiadyvAutB84H2kaNRgWRafnenE0YY+OCPczD/a+AYr0WR5lpWVQSQSYfPmzTEdV560H9M1OpQqDZBcavF16tTJiO/DMgzqzEqcNGggGnMnhFLFpSxd/w/ncGU6wpX5iHhcrCtsLcHBBZq5RBJIjnb9F4/C0dfm/d7aXA2JUACu/8JXz84PmI0DgC6jFV+c68LYDCUUEgpHYoV+koQkIZPJ5F22MxqNUCqHN7MyGuc7jdhxrBnitHwAQNXXbVg2S4K957pCJkT4zkYkahYvVmMYjpmVwsLYLFHKBU6Uq3WYptYjQxK6fVc4FpEWncqJaJEW4+22dgDAbQIRgi22crVCC9euayjcxYND1xIcXKCZBFeUpgiYoWMdNpTnaXC81ex3vCRTyRnUAUCGSorlM/LiNs7LFQV2hJCosSyLsx1GHLrYgw69FXb7wOb5TqMVf99Xn8DRjU6+y3zBsjgVCnmQ5AkWYxVmTFPpMFFpDFtvLhSHQIJe1UR0KifCKM0GENjVIRiuAC6eZTz4Fg+OVc3B0UwpFWLRJO5l0xn5GtR0WmBzuGd9GQaYOy54AWESHxEHdufOnUN6ejpSU1PjMR5CyAjy+dkufFU/ctp7jTYqlQoGg3/QsnLlSohEIr8sXI3QjnK1HtPUOmjF0W9yZxkBzpuVOGHQQphzB0QS7pkYXzU1tVE/X6zwzbAd7pqDQ5WIpeEbJo+BIsiEtkwsxC3lOdh1qg1mmxMTs9XIUsuGdXwkisDuvffew5NPPonbbrsN9913HxYvXgyBgJJrCRnJoln6Pd7UNyKDOt96aENZduUqmzHcfJMxPEpLJ0EsluD21atx9rO3MU7QghK5Gcyl2blJk0pRW1sT0fN02aQ4YdCAyVyDyjZ3eRqWCf/xwbIu7N79YUTPFQnPzz3cXsVwRYgZxp2JW1AQ+0xcX8Ox1cC3L26oY+GoZSJ8Y1ouPjzdhi6jeyZ2eoEWYzOUMJmCz2wWZyjxH3OLsLu6A3NLaLYuESIO7B555BGMHz8eL7/8Mm655Rbk5OTg3nvvxbe//W0UFxfHYYiEkGRT323CJzXJVX9uODMHq6ur/Yr/vvHGZmg0GlRUVAzL83twBTQyuw55pjrM1p6BYEk29n5x1u/x9LQ0XvfudwpRbVTjhFGDVqscALBAGH6Gzpd7b1v86rl5fu5Lly5FWVlZ0PNCFSH2JF0uWbL0sms9FYxKKsLq2flIUUiwanY+Kg83AQAWTMjkdb1CIsKy6fHvGkK4RTzVJhKJsGzZMrz77rtoamrCD3/4Q2zZsgUlJSWoqKjA5s2bYbGMnAbdhBAfQnHYUzoMFmw/3hp1x4FE49q4HwlP2YzBAYvBoEdVVWK6DogYF6aq9LgrpxGz27cgV38MYmc/71IRUqkUAOBiGZw3K/Fuey6ebyjBB93Z3qAuGnz3tvFx9uxZzuOeciXV1dUhr/cUIVar1X7HNRoN1qy5PWRgeDnJT5Vj1aWgDnAHaatm5+Pm8hyIhe6QwdO2i2VZZGVleb8eCUlel4MhJU9kZWXh8ccfx9KlS/HQQw/ho48+wscff4z09HQ88cQTeOyxx6gGDSEjhCg9H4rxV6O6zYArxnH/D1rXb8e2oy3ezdEj0VAyL/mUzRhOKns3bkxvx2SVATJh+K4PwWSOm4439l7ASaMGBkfscupi2T3i448/4jzuW66ktHRSyGXZsrIylJSU4NlnnwUwUEsw0rIzkWDZgf9W+C4dD7c0pQQlmUpMydUiTRm4VKySiqCSUq7lSBH1b1dfXx/+7//+D1deeSWmT58OhUKBd955B729vfjNb36DZ599Fm+++WYsx0oIiZN+uxOKcVeCEUnxcW0X3j3aDIvdP1Dotzmx7etmb6cIu92GDRs2YMOGDbyzIYdbsFkej0g39vMpmxFvQpcVszS9uDevHrO63sMsbV9UQZ3FKcTX+hT8o7kQLdMeRMGN3wejiG1SnHtvmzr8iTwMThLx5SlXUl8fvlyJ73JrNLUEI/XSSy95v/btdDHcynLUUMv8g7PcFBm+Pb8Y98wrxoIJmZxBHRl5Iv6NPn36NO666y7k5OTg2WefxS233IKLFy9ix44dWLlyJbRaLb7zne/gkUcewbFjx+IxZkJIjO091wNGPLDkdqHLhH8ebECf2R2wXewy4fX99eg2JmcAF0ywWR6P3bt3+82ohBPLpcVIaaytGNf9Ca5s+yduzOjAGGnkW15YlkGvNBfvtefg+YYS7OzKRvOlpdZ4tMJiGAHvVmjhgnA+In1/nn76mbj/YTI4IOW7dDwUWRopBD7TxwKGwdxxGbi+NMt7TCxkcOPkMd4lVzJ6RDy3unv3blgsFlRVVeHGG28MmhG7atUq9Pf3D3mAhJDYCJb5Wt2qx5mOwA/EXrMdbx5sxNgMJapbg89SJbNQszwAoNe7Z3ny8vht9I5XY/pglEIHpqr0mK7RobzzfQiEQrhckc/O9dolOGHQ4KRBg/vTluC06QTneUNthcWVfcm3i8R77wVvMcZXLN8fTymRaJJyXCE6rESydBytGQUp6DLavFnrZTlqaOViaOViTMhW4Wy7EfPGZyCVZuhGpaiyYh955JGw59FGVEKSi9XhhEChhavf4P3+s9pOnGoJHrRZ7M4RG9TxFcksD5+yGZ7jntIWEc8GsS6k9jdgRXYLxiuiLyLsFEjQLivE6831aBpCAkSyUKsDa/Z5eMqVFBXFt1wJX+E6WPguHUdaTYJP7bqidCUmZKlxrsMIo8WBq8YOZEIvnJQFp4vFzIKUiJ6XjBy0G5KQUcxid+LAhR6caTOg12iGeuYtgMuJrV+3wsYKoe+PvljtaPHOO+/g8ccf53Uun7IZ0UoR2bD3/36McrUesxdciW5l5GVCWJZBrywPPZrJ6FEUw+Zwocm6x++coWYFx0u4/YmLFi3Gtm2Bs3q+5UqSJSmBbweLeCztZ6gk3kSHxaVZqGnT+y23qqTuUiSU2Dh6UWBHyAgRSRFhu9OF40067K1tw/pf/hoABoIXgRCtOsuw9WT1XcriG0DFSqhZnmh5ymbs3LnDr+SJRqPB4sUV2LqVX8mTp59+BkLGhWceXIU7cxpRIOv3FhGOlO9S68MZS33e28DZwnj1Y423CRMmcB7XaDRYsiR0HbvhxreDRaRLx5b6Y7hlajZUSgUkIgEUYhEMVru3zhwAFKYPPHdxhhI5KYGdHyioG90SFtj19/fjpptuCjj+s5/9DEuXLg16nc1mw/PPP4+PPvoIMpkMa9euxe233x7PoRIyYlgdTnxV34djTX3otzlhd0RfAmM0KC+fhi+//DLm9w1WNsPhcPC6PlNixXS1DlNUekzq+ww9cnP4iwaxuQRok4/HGy2NaLTIAQR+WCdDO694Go5yJdEI18EimqVje+dFWJtOoThd4fdHnVYhRl6qHM297j3tRWn+RaSlImEEIyejQcICO6fTic8++wwvvPACJk+e7D1eWloa8rq77roLX331FTZs2IDe3l7ce++9aGpqwo9+9KN4D5mQpGaw2PHu0WZv+x+CuAR1HpGWzZAwTuSYa/Ct3HrkygYyWo8cORJwbnd3t/fr8vJypKWmXVpzZKCTjsH7nWNQbVRjXcoCNFoOcD5fvNt5xdrgpW0+hqNcSTTtuHx/N0J1uuA7dpVUBPP5Q0Efn12UiubefogEDPJSR/5+SjI0CV+KnTVrFubMmcPr3EOHDmHLli3Yv38/rr76agDuGbynnnoKP/jBDyCX0y80GeUEQohTAzM4u4xWvHu0GQYLvxmj0ShZZ6c01lZ8I7MVk5RGTNDtQ6fMv0yJzRYYiNeeGXgtJ06cgFWohmrqjZCXVcAIOY4bjod93ni38xqKaIK4kUql8t8OEOnSMcMAFaUZgDP4ftiSDCXSlO69dZ7uEOTylfDA7he/+AVEIhHGjRuH7373u5gxY0bQcz/44ANkZ2d7gzoAuO222/D4449j3759WLRo0TCMmJDhwYikYKT+f6xIMoshzZ/s187L6nCi6quBwsGJMNx76HzLSdTX12Ps2BLes1PDEVSohA7kG75GjuUCJNYe9Kkjzyx2sAKcMalwzKBBg0UBnDuJNeLJGD9+XMjrPN0N4rExn09GJh+Dgx0AWLZseUByhO9sWbIWwQ7nwe9/H099/3aIM8finh+si2jpmGGAGyZnI08b+qOaYRjMKkyF9TLfekHcEhrYTZs2DatWrUJOTg527NiBq666Cm+99RZWrFjBeX59fT1yc/1nK/Lz872PcbFarbBard7vQ1WNJySZSHMnQajyb9guyZkIgUyNsx0mzLq08Xp/XY9fUJfIZIXhUF1djZ07d3i/f+ONzVAoFDCb+e1Ti0dQ9/TTz4ABi/9+eC1WZzejRGFCke6Iu+5chPdqs8pwzKDFaaMaVtfA/ihP7bOSkgdDXv/GG5uh0Wgwa9asKF5J7HHVdLv//vvxu9/93u9YsOSIkcxl68fy8kw82XYOtrZzuHvxazjWaka/jTsAEwoYsCzgYlkIGAY3TslGWY4GJlP4LNuyHHVC/7gjySNhgZ1CocDBgwe9zaeXL18OAFi3bl3QwM5mswUst0okEggEAs7lDAB45hl3ZXGSvCLJ9rxcWB1OSHImghFJ0KqzYLxSiVadBUKlu+XTV406zBybhR6TDV839CV2sMOouroalZVvBwRnfIO6eNCKbJiu1mOaWoepvR9Br4x8pszsFOKUUYMTBg06bIFZjMBA7TPfGmnBujXo9Xp8+umnkMtl6O+PvEPFYJ6afJEaHIR7nDt3PuJ7hSr6m4xYhw3GY7uQoRr4uU3L02DuxBz0mW1o6DHj45oOv9/lq8emYWZhKtr17ves4FIihFKpBBvmLxKRUEBdJAiAIfSKHfITCwTeoM5jyZIlaGxsRE9PD+c1qampfpuKAXfPWpfLhdRU7h6HTzzxBHQ6nfefZK3hRIivE80GMCL3/6QPXOwDAJxsGdgv1WOy4XynEZ/Udvoty45mLOvCzp07k2JvFsM6kGk+hztyGvH9gouYl9oNlSiy2RKWZVBnVqKqPRfP14/DR91ZQYM6X7410sK1TEskTxDOtc+Pq8uEb2u3+vp6v++rq6vx4osvBFyTrPsqAcDaXA3Wxv0HR4pCgmn5KZiSq/UeU0lFmFWUColIgII0hTeoIyRSCd9j56uzsxMCgQASCfdfHTNnzsQLL7yAvr4+pKSkAHAnVAAIujdPKpUGBJCEJDObw4VjzQNbBpr7+lHbZsC5Tv/lmA9Pd8BiH1l7agZ/eI8bF3q/mO+y8l133RmTrRRD2WOntHUhy1iDDPM5MPZ+tPMoU+I706LT69FnF+O4QYuTBg30TnHEY/CtkRauRt9QZuu43iu+e8OiCcJfeukl79ee5WRP6SuuWVoAqKraCpFIlFQ17ABALhbC2hI+6LxmfAbOdxrRb3Ni7rh0SnwgMZGw36J///vfOH58ILOrvr4ev/nNb3DTTTf5LcstXLgQO3fuBOBerlWr1XjuuecAAA6HA8899xzmz5+PiRMnDv+LICQODtf3BARsu061BczMjbSgDgj88N64cRPnrIvdbsOGDRv8enTyreYfa0KnBdmGUyhv24rytq3INp6G0MVvI39XZycOHT4Eq0uI4wYtnvxQhz81jsWXfeneoI5vrViGAbRaTdgaaeGsXbuW13lc7xXfxvXujNzgQThXkDY4SDUY9Hj77bexffu/QgaIu3bt9AtCk8G8iWPAOu1gWTbk1hK5RIhrxmcgXSXB5BzNMI6QjGYJm7HLz8/HAw88gPb2dqSkpKC6uhq33norXnzxRe85DocDn332Ge69914AgFarxVtvvYU77rgDlZWVMBgMSE9Px/bt2xP0KgiJrVMtOhy8ELgVwTlC9heFm5Hj+vCuquLXqYFvNf9wuLIvA7AstJYmZJlqkdpfDwHrDqJdTif27HW36Jo3d17IW3R1deGDr+txXJ+KGpMadpb772iuDNHBfGuf+dZIi8a4cSW8mttzvVeVlW9jzZrbw86QxSIj1xPMmc39Ic+Jtucql2hq1g2mkoowPV8b/sRLpuRqkK2RDfl9JcQjYYHd9OnTsW/fPjQ0NKCzsxMlJSUB++RUKhU++eQTv6LFFRUVaGpqwvHjxyGVSlFeXk7tUciocL7TiN2n3ZupB5fzCLdkmSy4ltMWL14c9PzBMzGhXmtBQSE0Gg0MBj3nDA7XEuuaNWtQWVnpd4wr+9ITkGpFNkjOvo8ZWhOkzshnCFmwMDjEOGHQ4O97GbToCzjP8x0rV4bo4FZog2ufrV+/HizrwsaNG0PWqlOr1TAY+NeyC5WgwLIDmbmlpZNCLstG2iprqOJR2iUSqQoxZhelQShgkKGSQBTBkirDMMhU03YhEjsJ32NXWFiIwkLupQWRSISFCxcGHJdKpbjyyivjPDJC4sNid6KhxwyDxQ6j1QmL3Qmbw4WLXSa4WJaznIdGo0FFRUUCR80P94xcFe/rQ71WgYDB0qVLUVn5Nu99ckVFRWHPETIufP6P53BHTisKZf2wHLmAo1Ipxo8bj4zMTF7jdtecU+Lfu7pxomss3O29gi+V+3ciCAwCfIO9YG2zGEaAioobQvamXbRoUfjZSR++GbfBxs1nhqyoKPIgfCiiDyRZsK7g71Neqhw6s91bRkQiEmB6fgrOtBug63cXDBYKGNxcnoMsTfjEF0KGQ8IDO0JGK7vThX8da8GcknTkpgyU6fnwdDvOdXDPMAQr5xHJkmUyiebDO9RrLSsrw5o1t2Pnzh0BM1W8llgxMDuXJbFgmlqPKSo95EL/D3er1YpTp09hyuQpIYO7dqsMxw0anDJqYHHFrienbxAXqm1WaemkkPeJtDYc332M4WbIGEYQcRAejWh6rvqyttQCHPvz0lUSLJiQibEZSjhdLM52GNBpsGJWYSqUUhHK87WoPNwIg8WB+eMzKKgjSYVScAiJA7vThfe+bkF9txnvn2iF2eb+i/9YY1/QoC5UJmG8S3wMXvpN5Gb0cK+1rKwMDz74UMBxPkGMVODEgTeewT159fhOfj2u0PYGBHW+zp0/FzAgk1OEQ7pUHMlYhleai3BEnxrToG6o+CZHcOG7j5HPDJknCFer1QGPLVu23Pu1RqMOmkDCMIBCIQfDBE8yiaTnqi9Xvx6Wi1/D2lwNkWDg+jSlBHdeVYixGe6fhVDAoHSMBgsmZEIpdc+FaOVirJ6djym5GswqTIn4uQmJJ5qxIyTGdP127D7djoYedykMg8WBHSfacO3ETHx+pjPoddFkEsZCsKXfpUv597OMtXCvlWujefBglEWR3IxpKj0mKo0QC/gHrVarFX06HbQpqeiTF6BFWoIX6tvhAoOZ4nTe9xksVrNYns3+vokQBQXc+/qCXesrXMZtpDNkZWVlKCkpwbPPPut33DcIr6i4AVVVWwN+Jp5A7hvfuBUAOGdpV6xYGd3vKOuC+cw+gHWBtVsxJVeN0+393hZefPbIpSgkuHHKmMifm5A4o8COkCGwOVzoNFrhiTNONutR3aoPyGJt6DHj7cONcITYnJ6IDeChln75ZkBGIp7Lcr6JGwCQIrJBVPMeflBwAVpx8AbqofTYJfjaNR7q3CWwi5Sw221wYWjJWsmc6+UbMAcLtCKdIQuX7VlaOolzeX1wwghXgBhuKToYa3M1nMaBYvczCzQ422XB1Dyt37YJQkYiCuwI4cnpYtFttIJhGHeSQ6sep1v1sNr5zQDZHKHPG+5MwnBLv3wzIMPxDRD4lPaIlsFghIRxokxlRLlah3xZP3D6ArQR1gC2uQSoNalx3KBBo0WBexbNgkwUuzZ37kzhipBJD7EikYh5lTbhMvi9GhxoxdLgmT2uhJFYlQNJUYhhaTjhd0wpEWH++AxMzeNfpoSQZEWBHSE8GIxGjLnyJojTC6PumxnOUDMJI/3w5rP0GyoDkqs0BtcYfb/nKu3BJbKZPRZFsn5MU+siXmr11WSR47hBi2qju+acpyBwtBvzuXgCFocj+Zu188nMjSXfwC1UwshQMAzwjRmFYF1O6PV6aLXuQO7zzz/HjTfeCCF1fiCjAP0WExKGy8Xiw+pOiNMj+4D3dE/YsGED7PbwnQo8mYTurwc/FtFTcxpcPJhvfTOuJeJgvTtlstDZgVwf1tG+No3Qjvkp3fhBwQXckduIKWp9xEGd0SHC/r40vNQ4Fq+3FOK4QesN6oDIlx253jffY0MJWCL9fRoqvpm5I8n0/BTkpsixdetWTJ482Xv85ptvRnFx8bDMohISbyP/v1RC4qhV14/3jrUE9GmNl2CZhBqNBitWrBzSvQcXD/a06gtn8BJxqObuvr1J+WZnci1B+2ZN+mJYJ9LMdZjctQs/KLyABWldEe+fc7IMak1qVLbl4YWGEnzak4keu/8MrEajiWp/4eDXEov3bTh5EirWr18PiSTyPrbxxjqscJp64TT1gnVG9r7LJULMH5+BrVu3YvXq1WhubvZ7vLm5GatXr6bgjox4tBRLCIdzHQYcuNCDDr016Dm+S5+xXJ4Ntt9oqMt3g/e2mc3hG9gPzoAM19zddwmVb3Ym1/Ls4NIlmRIrxvbtxxjrRYhcFricTjBMZFkYnTYpTlyqOWdyBv9fH9eyI99lbq7ly2jet8bGxoivGe0YMDCd/gxOQxcAQKhKg0T4FPj+FpTlaCBkWKxbtw4sxy8wy7JgGAaPPvooli9fDqEweUrYEBIJCuwI8aEz2/FJbQcudCWm4bwH134jrjZj4ZbH+NajC7anraKiwu85hlqShStgCfYaJIwTk1UGTNfokCO1INd4CoIIP2xtLiFOGd2JEK1Wd7ajWq0CQiRwDGXZke/ype97yfUzeeutt6J6/mTn+QMomqXkqblqb1AHAE5jD26akoUPantDZpsPXK/Bnj170NTUFPQclmXR2NiIPXv2cHY9ImQkoMCOkEs6DVZUHmnkneU6nKKtNdfYGPxDzJdcruCcwRtcTmKoJVnCBywsiuVmlPZ9hh8W1UWdCNHYr8BxgwY1ZjXsLv/g6vrrF+G9994Lem1NTS3Ky8ujel4+Br+X4X4m8R5PMmFdDjAc5WTUMhHmjE0NOJ6fKset0+Xo67djjEaGfrsT/z7eArvTP9DLTZEhXSVFa2srr3HwPY+QZER77MhlRW+xo6HbjHMdBrTq+r3Hdf12vHu0OSmDupqaWs49bZ5ac9XV1UGvDRXA+PLtzRpqb1wkJVnOnj3L+1ytyI4FqV14sPACvpnThKz+yIM6u1CJfX1p+HPjWLzRWoATRi1uvnVFwHmffPJxyPvs3r07bp03gr2XiRpPsuk/dwiWxpMBxxeVZkEi4v64Ks5QYkZBCsZoZRibocTyGXkQC/2Dwym57uzXnJwcXuPgex4hyYhm7MiIZDKZvEGG0WiEUhm6zpjF7sT+um4cb9L5FQ/OTZFhekEKDtT1eBt9J5vduz/kVWuOi8Vi4Tw+mFo9ELCF2hsXSUmWjz/+KORzChkXJihMKO/Zhe8XXIh4zxzgToQ4b1biuEGL5d//OT77/Ua/x7najIWro6fXh29yD0RXIy7Ye8lnPHl5uZFdOMJMzlHD3nkBYARIV0qgv7RaO29cOkoyVTCZBrZHhPpvviBNgeUz8rDrVBsMFgckIgEmZruTkRYsWID8/Hw0Nzdz7rNjGAb5+flYsGBB7F8gIcOEAjsy6pmsDry+vx5mW2BP0JY+C1r62hIwKv5Cze741pqL5oPf0yIqXCupgfNDN3f3/T5YAJUtsWCaWofJKgPkQidSrS0RB3UmcRp2d2XhtFENs8v9vzFGELv/nRmNRr+A7fHHH4/JfSOZqRs8ntGGdTnA2vohEQmQpZFhwfhUzwO4fmIG3jvVhfI8La4uibx1W0GaAvfOK8bXjX2w2F3e2T6hUIhNmzZh9erVYBjGL7hjLtWl2bhxIyVOkBGNAjsy6u0918UZ1I0mQ/ngX7JkaURV/T0lWbh6dwajEDgwRW1AuUqHLGnwTONQ7EIZetUT0amchD5Gg8P6moiuf/LJJ9Dc3ILXXnst7LmRLDmHS4SIheHuShJzrAvwSSSRiAQwnfwETkMnvjf/TSiVSr8ZuWyNFDeX52B8ZvSvWyQU4IritIDjK1euxJYtW/DII4/4lTzJz8/Hxo0bsXJlbMvTKJVKztlBQuKFAjuScE7nQNA1UAE+Nn8xt+ksqG4NnsU5WkT7we9poh5plqL7GjuqqqqCniMAiwlKI8pVepQoTBBEsdTqYhlc6FfgmF4L4ZhvQiS51MczygK97qVkdciA1FPihU+ZkkgTIaIRyXiAwELU48aNi/mYImXrqIO9sx7ZmqdgcQqwpDQDjxk6Q17jWT6Nh5UrV6KiosLbeeL999+P6f93CEkkCuxIQm3duhWPPPKI9/ubb74Z+fn52LRpU9i/nEUpOWCdwT/sWJbFJ7Ud3uXBeNWd8xWP5TuNRg2DwRB0T5vng//kyVMR37ukpAQbNmyI+DqWdeGjj3ZzPpYpsWKaWoepKgPkwuj2LfaLNPi8JwMnDBoYnO5CuSwT+kOXz2wZwwhQUXFDyCK0g0u8BFNTU4uqqq1B98xxZbOGei+HOh6PwYWoNRqNX3JMIth7WuDQtWP1zFwIJTLIxMKEz2L5BnHXXnstBXVk1KCsWJIwQ6kAf6xJB+Xk66CaVoF9dT1+CRGAO6g7XN+LNh2/5IFkVlFxA4DgbcaWLHG3Idu9+8NhG5O7nt3ArJdM4MRMTR/uyavHffkXcaW2N+KgzuYS4IRBi80tBTiUsRJf9qV7gzr3c9aHzA7lO1sWLNGE7+Me4RIhuLJZg72XsRiPx+C9jQaDHlVVieumIBQwcPQNlA+RiSmAIiSeaMaOJITT6Yy6Avyes53Yd77Hu2fnq0YdGvUOlOVoUDZGA7PdgU9rO0dFUAe4P9i59rRpNBosWeKuY3fx4sWoN+ZHw2g0grlUc26aWocJShNETHQlOfSSLOzoHIPTRjXsrPs9ZTn6Cbzxxmbv18uXc7cci9batWsjXkYN9/PmymYN9l4OdTyuEAV6PdnTiZKfIgdco3uPKyHJhAI7khABFeAZAQQSOVxW9wbqYBXge0w2fFXfF3C/PrMd+853Y39d96Xr4zn64ReszZhniW44sybl9l7MEtUhp7AOKlFks3JTpkzFqVMnYXSIcNKowXGDFt9JvwXHDP61+F544cWQ9/ngg10RjzsUvu3PIsX1vgx+L7mCuEjH09jYEPJxz38P99xzT1y2IIRSlC4f1ucj5HJHgR1JiMGV3SVjxkOkzYa5Zk/I8/ad74YrRNQ2+KFge97ivdcuHrjajEVSQ20ohC4rMkznkWmqhcrWCchZ7FcKYQ1R+08ikcJmG8iAdbEMnJmTsbWtB2fNKrCXOgxw7Y0LV3+vv39kzMYGS2rxfS9jEVQajfxa4CWibEpxmmLYn5OQyxkFdiQhfCu7MyIJZIXlYEQSCJQpcJn6OM/rMFhwtmP4lhuDsdnswxJMRUqtVoUsvqtWuzfu88dCa2lGru4C0vovQMD6LKcxDErGlqC6JnjXi7Fjx6K2tgZ9djGOG7Q4YdDggbQbcMZ8zO+8ePVFXbVqFZRKJdavXx/RdVzvbyRdNDz4ZrNGU+h4MJUqdIHugfMiy5529esBoTj8iZcIGAalOWqc7zTCanchQy2FWkYfM4QMJ/ovjiSEbwV4acFUMCIpAEBWUA5zzR5vBfiymVd599ztO9896pZYY2nRosXYtm1biMcXhXzcQ+Yw4JrULpSr9JjatROCINmCGRkZQe/hYAVw5s3Gm5+YUG+RA5dm56IJkKIVy9pv4bpocIk0m9WXJ9jjK1yBad/sab5kYiFMpz8FwEApfRq2MFsoszRSVJRlI1sjQ6/Jhu3HW1CSwS/gJITEDgV2JCE8FeBvv/teSHMmeo+L0/MhVKWCtVtx98//gM0HmyCXCJGbIkddJ7/lpkRIhlk8rvZZfB8XMy6UqQwoV+lxZdc7cKR2c57ncjqxZ697uXze3HkBjxeWz8Mrn57DSYMGD6UsRL3lsN/j0QRI0Yg0iAknXBsyLpFmsw6F79Lu4I4gvtnTfANNoYDB0tJMrLO4X/eK6WPw8TkdsjUylI5RQyUVodtkg67fDrVMhHSlBKkKiXccqUoJ1l5ZCIvDCTijqzlICIkOBXZk2Bksduw52wVz7mx877l/4N/v+2YIMsi9YimWrV6LzLFlAIB+mxPnO4Z/b1A8atJF8pyxEC67Umtrw82ZbShVGiARuKdkmAinRW0uAaqNahw3aHHHym/j0LbfBj03mgCJi0IhR39/PwDuRJmhzJYNRTTZtbEgFkuwfv16b8HkYNnTfF07MRN5KQNLsFq5GHfPKfI7J1UZem+qRCRwd5gwUWBHyHCiwI4MK7vThX8da0W73r35feKkMhQVB8/2JEPDtTFfI7RjqlqPcrUe07t3wKTWRXVvnSQ7oEzJcFm69CaIRKKgZUOGc7bMV7yya/kKlz09mEIiBAv3H08eGSoJpudrYTabYzImaqlFyPCiwI5EzGQyefcvGY1GKJX899F8VN3uDeo8uLI9h9twdKWIt1DFe0WMC1n957F2TBOK5WYwUbT3AgCbUIF9fWk4btDivvSbccxwOqrxhDN4OXGw0tJJEIslYcuGxEqoxJRwYx1u4f57yk2RYWqeFgVpCmhkYrTq+vH2oSZvtvn88RlgElD4LlwASAEiIfxQYEfiqrHHjK8aeqGRi+FwsqhujT6rNRFLox6+QQrfRu9cPTvjGbT6tpLy6K49gJsy2lCqMqK073P0KCLfp8iCQa+8CB2qSegUZuOznotRj0cul/EqVSKXy2E29/sdmz9/Pr744gu/Y7EuGxJMsMSU4Yx/fIsQh/t9ctn6Aafd75hKKsLyGbnI0sj8judo5Zg3Ph17z3YhL1WOkszYJZ0QQoYfBXYkbsw2B3aebIMxRK2zZMSVCOEbpPCdFeLq2bl0aWR7nSLhmVFSCR2YqtKjXK1D+qlaZGsiu4+n60O3TYL9/QWQTFwIh+jSh72d/34prhkuT1AXbpZrcFAHAHPnzg0I7IZLsMQTjUaDxYsrQra/8+x/GwrP3jmPUL9PQgEDc/XnYO0WyMVCOACIhQxunR4Y1HlcUZSKxh4z5o5L9x6jGTJCRiYK7EhcsCyLXadGXlAXTLhN/1yzeFw9Oysr3/YGNLFY8vXM4ggZFyYqjChX61EsN0MQ5VKr3SXAP/bUYV97IZqtcqDyCDSas7wD0nDLrwzjno0TCkUR1tRLLK7X5dm/Fq5O3VBVV1d7f29YhxWMSAKA8f4+rVlzu997c/3EDDiN7qzmW6ZmY0dNDyrKsjFGyx3UAQDDuAM/sZD2thIy0lFgR6IiK5wGZz/3B7Pd6cKhCz242BWbzdcjAZ9ZvEh7dvIJ/PQXv8aSjHaUKQ2QCaPvx9lmleGYQYvTRjWsLv+6dYMD0pD3aWsL+TjLumfj7rjjDrz55psAAIVCEbON+tHyrRtn55iV5FpW7u+3xH0/KMu6sHPnTu/P3tp6BoC73qPn92nXrp0oLZ0EgUCAuSXpmJQ9EMBla6S4e04RtPLwRYYpqCNkdKDAjkSs02CFNH8ywAjwyZkuLJ4iQ1+/DV0GGy52m1DfbYLdSUs4XGKxsqUUOpBrOIEcax30umpoNH1R3cfiFKJFUYpXm5rRZgs+mxNJQMq3tZVvIJfooI4PrhnbqqqtEIlEGD9+nPdYpIWFw6mvb4Ber/d+b++4AJfFBJEmCyJtNlgW0On0aG9uxIPL5qEoXQmTyf894BPUEUJGDwrsSERYlsWnZ7uBSzMVp1sNONt1PsGjGpkiysJlXUjrr8fK7GaMV5gwVncQAqEQFknkH9qN/QocM2hRY1LhUe1ctNnC71vjG5Dyb201OjoS7Nq1EyUlD8bt/r69XR36TrguFQw2n/kSqulL4LKY4NC1YbK4C0Xpo+NnSggZGgrsSESONenQYbCGPzHOhjvjNFHkth5kms4g03wWQpsRXUr/mSOtRsvrPianCE3KqXipsRU99viVcikoKIRGo4HBoOcMBj2trcK1wIonTzLDUItBe2bLGhsbYjg6f75t0ewddQPPbeuH4dC73u+L8nNACCEABXZkELvTxbnXxuli8XVjL/bX9SRgVIGGO+M0VvjUPJMLnJis0mN6x7vQOPu8x7nSEkLVG3OxDC5emp07a1LhR5or0WP/LLqB8yQQMFi6dCkqK98O+lqXLFnqV6ZEo1HDYDAMeZk61sugfPFdfuaLdQz84VRU5A6U9X29sHXVB5zr6am8YMGCmI6BEDJyjb4pDjIkW4404d2jzWjsMcPmcKFDb8GpFh3+se8iPj/TBZsj+qKzsRQs47S6ujouzxdNvbLB1wS7h81mxy83PIXX/+cnGNf+AR4uOo8bMjqgsnH3aw1GInHPxPXZxfi8JwP/1zAW1qsfQq1JDRe4n9w3m1ejUQcdYySvv6ysDGvW3A61Wh3w2IoVKwOC74qKGyJ+jmQSq2VlqUgIU83n0B94B3dckYdFpVnIS1Vg6dKlsPc0gXH5J8d4gvqNGzdCKBRy3ZIQchmiGTvi1dhjRpvOXWfsQldsZyFiwbdA62CDMwRjvSyrUgXvPMD3Gq6aZ+liK8YaDuOhwjqoRA5kWi7ibBSlSpwsg8L5q/CrzXtQ368ALgVyweqvefhm81ZU3ICqqq0x6aQwuLWVB1err9LSSViz5vag7cGGW01NLa/zYrGs7DT3IVcrQ4ZWiZm5Cjza3QQASFNKUJClxPSCFCwqzcY12U48+eOLaG5u9l6bn5+PjRs3YuXKlVE/PyFk9KEZu8vYyWb/HqGH65NjmTWYcHuZPHue6uu5zxtKi6v777/f+/X8+fN5XbN06U3er++6606sW7cOpaWTIBM4MVPTh2/l1uN7BRdRYDwBlSi6Wmj9Ig0+7s7EC/UlqEldhPp+JRBkdu7s2bMh79XZ2YnVq9dwzrQtW7Y84Jhn6fPJJ5/gvJ/vcms4ZWVlePDBh7zfr127lve1scSyLuze/SHv8wcvK0fC3tME49H3sWJGDpZOzYFKyv13dqZaim+tXYnTpwfat73//vu4cOECBXVD4CnAzLJsRG0RCUl2NGN3mTrTbsCHp9thc7owqzAVnQbrsNedi3TzOt+9TL6ZhL64apHV1NSivLw87D19ZwD5dkCorKz0fl1UWIgUSzPS9afwcFEdRAz/INPldGLP3j3e7x2sAJ2KEnRry9EtzMBB3Tle9/n4449CPr5nzx7vrGJVVZXfY+Fm/mIhXHswroSZWHOXF+E3a+hZVuaqexeOgGFgufBVRNf4Lrdee+21tPxKCOFEgd0o9nVjHwQMUJ6n9dtkb3O48PmZTgDAnjNdSFdKUN2qD3abqPkGbp6SHkPp98q/lAZ3r0u+tciiwdXHFABSRDZMU+tRePyPKMrSwOV0RhTU+Wq1ynDCoMFpowY/SrveXSJliC2+BtPr9Xj33aqw5yUCV8JMRUVFTJ8j2B8FXLiWlfmanq/xli4hhJBYosBulOro1eG62+8HIxTj+ec24Map+d4+kQcudMNgcS/9uVgW/z7RCruD5QzEkkm4vUyePU9FRQPnOZ3huzHEohbZ8ePHvF+LGRdKlQZMU+tRIHfPgrbWGVGUOSfi+zoEUrTJi/G3pkZ02qQBj/vuO+RqazaacCXMVFUF79EaDlcP12B/FPDhNPZAKxfD6mLgHLQfVCoWIFMlRZvOAqlYgCsKUwKup96shJBYoMBulDpwoQ+M0F28tqXPgjcONEAtE6EwTYGaNv+lJqs9OTJdw/Fdqhu8wd8zIblkyVLvsml1dTW2b98e8p6xqkVmMBiRL+3HNI0OpUoDJAL/n6nVakWfTgcNx/61wDExaLDIkZW2EHrNBNgcLnTaPgXgH3APbgzPp60ZH/GILeLxh0KkLdr4KCoqhFqt5tHH1v+H5DT3wXhsF+6+Kh8yuQKVhxvReikRCQCunZCJqXlaOJwumGxOiFyRL98SQggfFNiNAizLYtepNmRrZJien4IukxU1bYHLPAaLA6daYr/kyke0y6/BcGWcLlkyUMfOt3E6H2fCJBb48t3rpRbaMVWtR7lajzRx6A9rmy3040aHCA2qafhTYyt0DgnGKsZBzIgABF7H9/V5EhxY1oWNGzcFLRw8UsX6tdTU1MLhcM9mO029sDZXw2nsgUCugUCmgstihNPYDZE22+86S90ReII9oYDBTeU5eONAPax2F4rSFZia5y4kLRIKoJULAIhpdo4QEhcU2I0CBy70oLrVgOpWA0616CEUMGAxuj807r//fvzud7/3fq/T6b375AY3Tufj0MFDvM/920t/QplSj2lqPYrlZjA8y5N46sz5crIMumRFqGyrR51ZiR+rZ0Pn+CTkfaJ5fQwj8BYOJtx8g2XLxa9hbR7IQnX1+/9BZO+8iBn5Wpxq70dJhhIOXbvf41q5GDeUZeOD0+1YXOYfBBJCSDwlTWB34MABdHZ2oqKiAjIZd0Nyp9OJHTt2BByfMWMG8vPz4z3EpFTXacT+uoFCtp1J0O5rOISqUze4cTq/+4We/WlsbESutB9TVXpMVhkgE4bfu+dLKpUiRauFy+We7eu2SXDcoMUJgwYPpi7CebM7Q5JP5mc0rw8YKBy8Y8eOkEuNfOvYxSszNRF8g2WX1QhrS03Ya+aWpMLCCnFFnoLz8QnZaqQoJNDKI+/nSwgh0UqKwO7LL7/E4sWLYbFY0NjYGDRI6+/vx6233or58+cjJSXFe/yxxx67LAO7bqMVO0+1jaqltViIJLPRI9jP0LPUqvniWXwrL/p9USVjS+AUSNAhL8TrzfVosso5z+OT+RnN6/MIVjjYI5I9a76t3BLRygvgH4SG4xssWxtPATxqHgoYBrdOy4HZHLxMUKY6MOGFEELiKeGBXV9fH/7jP/4D//mf/4kNGzbwuua3v/0t5syJPMNwNDFY7Kg62jxiEh+G01AyGwHg4L69mKJy75srkvFfag2mzSpDzoTlqNeUwuIEmqx7g57LJ/OT7+u75557OBMWfJNQ1Orw3TGA4MWNPa3c1qy5Pe59eoMlzMSCJ1h29etha6+LYExM0mWzJtt4CCHDK+GB3Xe/+13ccccduOaaa3hfU1NTA5PJhHHjxqG4uDh+g0si5zoMqG0zojxPiyyNFO9+3eItWTLcfEtseJbjhtrCi0/WJN/SHp7G6ZElCrAokpsxVWXApOZ/QJI1tIDZ5hLgtFGDr/VatNlkyFWWQiyQAM7AWb9QHTG4Mj/5vL7BZV+C8d2reNddd2LcuHHe5AFfwYobx7uVmy8+LdqiIRQw3mDZ0ngSgzNeCSFkJEloYPd///d/aGhowD//+U98+umnvK/79a9/jZycHHz99deYP38+/v73vyMrK4vzXKvVCqt1YN9ZNHuTEq1Db8HOk22wO1mcaTdALGRgdybmw2dwiQ3f5bh4zthEUtrDN1Eg3FJdutiKqWo9pqoMUIvsQx5ns0WO4wYNqo1q2Fh+nQGamppDPj54/HxeX0VFBa8gy/ecoqKioNeEKm7s28otnn9ocQWhDCPg1TkkmEy1FKtn54O9phhbf7MO+q56zvMYhqFZMELIiJCwwO7EiRP4r//6L3z55ZcQifgNQyQS4b333sOtt94KAGhra8P111+P73//+0H/an/mmWd4L/Emi9MtepzvNGJmYQpSFBJs+7rFL5BLZFDHVWIj3stxkZYuAQYSBbgay8sFTkxW6TFVrUeO1BLkDvz1O4U4adTgmF6LLnvoPVUuV+CLiGbPXKjXBwytK0K0hrL3bzBPmRZfvq27QgWhfGWopVg1Kx8ysRCAEJue+2+sXr2agjhCyIgWv3WTML73ve/hxhtvRG1tLbZv344DBw4AAD766CO/Zte+ZDKZN6gDgDFjxuDxxx/H9u3bYbdzz7Y88cQT0Ol03n+SoTq/0epAu547oLDYndhzthPnOoyoPNyE1768CKM1cGnMbrdhw4YN2LBhQ1S9KiMVqsSG59iuXTtDLivG+nnD8W0sz4DFD1dfi9uyWvBw0XnckNEx5KCusV+Bf3Xk4PmGEnzUnRU2qKuursaLL74QcLyvry+q5/d9fQCwdu3aqO4TK0Pd2zicsjRSrJqVB7lkYFZ15cqV2LJlC3JzcwPO/9vf/jacwyOEkKglbMZuypQpaG9vx5/+9CcAQFdXFwDgH//4B2w2GyZPnszrPqmpqbDb7eju7saYMWMCHpdKpZBKkyczrctoxbtHm5GukmDFzMBM3v113TDbBkpp2BzhAyWbzR73VmDhSmzEazku2tIeHipnH65P68QUlR43SDPwpYpfg/dgzE4hThm1OKrXosce+ufsu0xaU1OLqqqtnAEqV4/ZYPcZzDcRoqCgIOR9hiLULBZXK7dwuNp5DZdp+VpcNzETImHg37UrV65ERUUFtFqt3/FbbrnF+7XRaIRSya9vMSGEDLeEBXaD/wLevXs3brjhBrz66qve0iUOhwM7d+701qnr6elBWlqa33X/+te/kJubi+zs5C8C2qrr92ayGq0O9JhsSFMOBAddRiuONeoSOMLg+C6zxXI5Ltr7iZwWZJjPIdN0BvL+dhhTeoY8joZ+Bb7Wa1FrVuGWW29Dz3vv+T0ebi/f7t0f8pp1jGfm51CEW5r0beWWCBq5GPp+/1l7hgFUUhE0cjFUUhEUEiHyU+UYnxW6rZtQyG9vJCGEJKOEZ8WGYjQaceutt+KVV17Bvffei8rKSlRVVWHZsmVISUnB+++/j8rKSrz++utgkuUTMAiL3Yl/H2/1lidhWeDrxl4sKnUHpA6nCx9Vt8OVpHt7+C6zxXo5ju/9GLBI669HTt8FpFoawFxaEg433ymRSIK2+jI7hThh0OKYwX92buLEiZzjHJxgsGzZcmzbtg0AOPfBcYlX5me8CAQMVq1aHfdSJ6GU5aixdGoOOgwWXOg0QS4RIlsjQ7pSwjkrRwgho1nSBHaZmZm45ZZbIJcPFG4Vi8W45ZZbvEtMDzzwACZPnozKykp0dnaipKQEp0+fHhHV73dXtweUJ6luNWDeuAxIRQLsOtWOlr6hb+SPl3AlNqJZjovF86aLrZim1mOKSo+y7t0QRDjbMnZsCWprB7oMsCyDeot7du6MSQUX+P3BMLjFGQBMmDAhorEAwPXXL8J7l2YDQ5UfSRYuFwuFgrvzQqwJGAaWi19DIB+YcZOJhbh2YiYAIEstQ5aau2sNIYRcLpImsJs+fTq2b9/ud0ypVAYcW7BgARYsWDCcQxuyk806nG0PXFK0OVw42ayD0erAmfah7f0KZfD+O7vdFvGevFAlNjyTpfFYjuN6Xpknq1WlR65saMFw+qWlfaNDhOMGLY4ZNNA5An8e4ZZaY/W6d+/+0Pt1LDI/h0Osl9+5ZKgkWFCSgZ80nwbAYFyGEg06OxZMyIBCkjT/GyOEkISj/yPGSU2bHocv9gIA+szBs1b313UnrHxJpIKV2NBoNFiyJH517MrKynD76tWo+awSY9GKCUojhEPsBgG4Z+e6ZQV4py0P58xKsDxn56Kh0ah5Lceazf1xG0O8xDsbtiRTiZum5sBu9fxsWNxQlolTHVZMydXE9bkJIWSkocAuTsw2JzoN1oDjg2fLgNhnsMbT4F6jvoViY2Hwz0fDGpFpOoPZ2rMQLMnC3i/OAACmTJmKU6dORvUceocYxw0aHNdrcX9qBc6av/Z7fHCbLcB/v1w0KipuiHifXE1NLcrLy+PS6SPc8/IRbvk92sxXR18bUhUSmB0MyvM1WDgxCwIBA7vPf05CAYO549IjvjchhIx2FNiRiPmW2BjKcqFvzTtPwAIMLLU2v/Z9uKQWlF+zAAKhEC6fBBmtJrKZGifLoEtWhLdb61HXrwRCzM5x7ZebMmUyZsyYAQC86wYOLrLb09MTUYeV3bt3QygUYteund5jnk4fFRWBCRVcRX0jxbIuv+XgcGK5/C4WS/DPP/0WS6fmAHAnFFHywwDqAUsI4YMCOxI3XF0WfIO5//u///N+vfmNNzA1U4A75uTj4aI6iJihFTp2OZ3Ys3cPeu0SfK3PxAmDBg+mLkJd/1dhr43XbNi11y7AkSNHYDDw20+p1+tRWVkZcNxg0KOqKj5Zsu66gfzGt2LFyiEvvwsFDJyXfk8y1VIsLhsoW0RBHSGERI4Cu1GKK6iK5Bq+S37BkjAG93b1ePHFF71fm839SBdbUa52J0KoRA7oT9VANMStbiwjQJeiEG+2XES9RY5Qs3ND5ZuQEozv8vLy5UNb0gXcSRzxqu4TSSLEUNuWlWQqsXTqGFzsMuNshwELJmRCnKTBHM2WEUJGCgrsRqFgQZVnzxafazxLfkuXRp4UEaq3a3+/BXKBE2UqPcpj1KvVw8Co8L9bD7tn5350B+otB2J271iJpgQKl3jFGLFOhBifpUKnwQrdoOLBOVoZbi7PgVgowKQxakwaE7poMCGEEH4osBtlQrWuqqraCpFIhPHj/ev+BQvE3EuBb2PNmtt5B3dWqxVvv/12wHEBWIxTmFCu1mGcwhSTrFYAsLsEqDWpcMyghSNzJQ7o6mJy38tVuLqBkVBKhVgyZQwEDHCkvhc1bQYIBAwUYiFuKh+TtLNzhBAyklFgN0x8l+PiKVzrql27dqKk5EHv9y4Xi507d4a9prR0Eq+9Z42NDX7fZ0ssKFfrMVmlh0LoDHJV5IziNHzQlYVTRg2sLuGl526M2f2HU7gaecMpVL3CSM0tyYBE5P6dubokHVeXUBYrIYTEG/3JPMqE2vjOsoBOp/cLvhobG6DX68Ne88tf/opXNqjRaIJS6MBV2h7cl38R386vxxXa3pgEdU6BCMf0Wvy9uRAnc1dj/NIHIFWleB9/6623hvwciRBs+VOjUQfdSxfPDnqeeoVqdfTLoxkqCdWYI4SQBKDA7jJkNJo4vx4Ku9WCzf/zE4j2v4iHCuuwKL0TmZLAOn7R6BOk4mdbqrH6tUbs6BqDFqscNTW1qKx8O2gge/bs2Zg893C4//77vV+vXbvW+3VFxQ0AAoO44WiLXFZWhgcffMj7/TfX3g5HbwssF7+C6eRHMBz9N64oSoFaJoJCIsSEbBXmjUtHWY7G3SViQqZfWZyRymg0gmVZKJXKRA+FEEJ4oaXYy5BKpeT8OhpjJBZMVesxp+NtCMc0D3VoXhanEKeNanxt0OJbGbfimMG/aG64JeePP/44ZmOJN98lbk9fZMCddRqs08fixYF17PjyLRwcahZWIGAAlxOWxpP4zxW/xZ8f+dTv8auLU3H9ZAWY4Yg0CSGE8EKB3WXE0ymgoGCgU0BBQejN8lz7rCROE67W9mCqWu+dlRO7hp7dKpVKkTLuCrzy2XmcNqrhYINPKIertca3VlyyC9bpw+FwxP25pSIhjKc+hlPfCaVEyHkOBXWEEJJcKLAbpYJtfF+yZKnfEplAwPDaLC9kXMgw1yHHegFqcz0s6Z18RgEg/O77fqcQWVcug3D8QnQKtDi+PT5JJp7ODPFOZBlc02+oYtXpg0uwtl9qmQhLJmXiUT2f95kQQkiyoD12I5RvMWGubFCuDfnBOgWE2ix/7zeuwdKMdvywsA6Tej5BiqURDM9UyUkTJ4Z8XJo/Hf/qyMHzDSUwTVyOfmkmr/uS+EpTSrD2ygKkKZOrj7GnSDDteSOEkOAosBuBqqur8eKLL3i/58oG9d2Q7xGqU4DvZnmtyI75Kd14oOACVmiqMUPTB1kUWa3p6YHlLUxOEQ70peGlxrEwXfUwThk1cIZYcg0mVMYoAN4Znb4tzi4nQgGD3BRZwM8wSyPF7VcUQC0TJ2ZghBBChoSWYkeYUF0dfJ07dz6i+wpdNozpP4s7cxpRIOsHE6MCwgDAsgwaLHJ8rddi+i334ZO3A/ufRqqi4gZUVW0Nuny8aNEib+uuwUujnuXH6upq/OUvfwm4diRl1ALRLf1eUZSKeeMzYLY5UN9thlDAQCkVIVMl9daeI4QQMvJQYDeCsKwrbDFhj/fe49OPlEWKpQk5+otIM18EHFa0yc1DHaaXTSjH/r40HDNo0Wt3Bx63FBbF5N7BMkY9wrXuChUgh/vZBduXNlKkKsS4amwaAEAhEaEsh+rN+aK+sISQkYz+NE8ydrsNGzZswIYNGwJKUdTXhy4mzJfc3odrU7vwUOEFTOnahQzTOQjY2GRZsiyDOrMSVe25OJC5Bp/2ZHqDulgbXGvNtwZc6DHyD5BHo8Vl2RBROy9CCBmVaMZuBIgmi3Nw0CITOMGe+xhTUvuhMLfClNoNAOjT9SEtNW3IVW8tQhX29qbjuF4LvdO9P4tluEtkxJJvxqhvDbhQwgXI0QR8CZnFY11ABBmyIgGDmYWpKEhTDOlpjUYjJS8QQkiSosBuFGPAokRhQrlKj/FKE9jD53BCLPYLXE6cOAGpVIrx48YjLS0t5P327N0DAJg3dx4AwMkyOGtS4ZhBC0fmauztrY/ba4klo9HI+9xYly4Jx1OShY/+uiNwWYzIVD+FPsvAm6qQCKGVi6GRiyERCiAWCZCtkaIkQ0X75wghZJSjwC4OTCYT5s6dC/nY2SEDg/r6eowbNy6iumQajRoGgyHkrFL2pW4Qk1UGKIX+S6x2uz3gfKvVilOnT6GsNLAUCpd+kQafdmfihFEDk/PSr1CMCtX6lnGJl2C9WUeSFLkYtrZzAFjcPisXFlYEiUgAuVhIy6yEEHIZo8Augd54YzM0Gg2WLl3KWV+OiycbdDC10I7JKoNfN4hI1V2oC/qYk2Vw5tLsnCB3LZY8+i0sinGh3+rqauzcuSPg+L59+7xfx2IGrago8m4bieY09UKo0Hq/v7JQA0/x588//xw33ngjhML4L30TQghJbvSn/TCpqanlPG4w6FFZ+Taqq6t53ceTDarRqCFhnChX6fDNnCY8WHgB16d3Rh3UAe6Zu8HMIi0+6s7C8/XjsK0jFxf7ld7ZuXBFkiNRU1OLysq3OTNcv/jii4jv51ufrr6+3u97hhFg6dKll772v87z/e23347169cP6zJsKP3nD8F44iPIxUK0nj+NW6+70vvYzTffjOLi4qh7xxJCCBk9KLAbBizrwu7dHwZ5zP3vXbt28iuWy7owt1iJTd+cjB8W1eGWrDZM0NhiWnfOyTI4bVRjc0sBDmeuxCFdKvpd/rNBfIokR2L37g95zZIFC5AHe+mll7xfv/HGZmzcuMkveA7WbUOj0WDNmtt5z6Dy4RsAt7a24P+3d+fRUZZn/8C/M5PJJJlksu+TnS3sRiCgRDEGwqJQw6KCLVKXHvXV0FZrofWN1uJaLajoae15LVUwSgyl/YmAbDYVcEMU2aMkJCGEJSEz2We5f3/EGTKZJZNklmTy/ZzDYZ77ee6ZK3kyM9e51//93yewevUqp+tHBfvDoL0Eg/Yigs5/jZcfuwc1NTUW19TU1GDRokVM7oiIhjh2xXpA5yxM+5vSCwE0NmpQWXkWiYkJNq+JlLdjXIgGk88XIwAdMBoMkEs7E8FJkyZZdFf2Vb3OH99qQvGtVoUWo/0/jRMnTmLLllKXdlc6+v10tWvXLowdO8bmuMSuibFWazlBwtQy2jVpy8zMRHp6Op577jkAwLJlS3s95rEn3buXTd3veXl5Tj/H2ISr68wVrfoNDE31VtcIISCRSLBy5UosWLCA3bJEREMUEzsPcHYWZvfr/IztiNWeRoTmOO5LqgAA+BtagW5f2hJYT1zw9/dHR0eHVXl3eiHFyaZgfNMUiivyOKtlQGx1sTrbutbf7llbNJrOBDg1NdXq3F/+8lfrCj8SorObdceO7Rg1aqQ5eeu6XEpKSorLkzpbiyBrtRqrcZK6ixXouFiBOya9hqCgIPzz6xpo2/RQyKUYHnN1aZHuLXVdCSFQVVWFsrIyzJgxw2U/B8BFe4mIBgt2xXqAs7Mwg4ODAWFEemATFsScw+Tad5HW8ClCOi72+jXT0tIdnr/YocDOSzF4tTId/+9SPKragmy2ItnqYnW2da2/3bP22EuUe0qgu7aMupvVIsjCiJZTB9BefRR6zUUY21ugCvLHqy/8EYsmJaHl1H7oG84hUumPqGAFFmapoVTIkBmvgn8vZ7nW1ta6/gciIqJBgS12HtDS0gKJRGK3xUMiATIi5LhBdQ4R5/fBGN/ZKvNp2T4AV9eN641IG2vS6YUUP+gi8a02HOWNV1uqQkNVyM+fDb3eNbtP9IVKFeJ0wqhUXl1gty/Lo/RmHbu+6r4IcnvtKegunkHXxWY0AJJWL0dS+GSr+uFKfxRkqSGTSABYL1HjSHx8fN+CJiKiQY8tdm524sRJlJRstpnUKWV6TA5twM8TK1A0TSCh6bvOrlYXu9ShwK5LMbg0bRXG/vzPWPTA1YH7y5YtRWFhIUaNGml3gocn5OXNdPraf/5zq3kiRFVV71vfPLGOXdfkUeha0Xb2iM3rHLWuRQUrEK60nJWbmJgIiZ01AyUSCZKSkpCTk9OHiImIyBcwsXOz7uPRpBAYqdRiYWwNHkr+AXlRF3HjxGGIio526esaJH44og3F2zXJ+Ft1Kr7UhCMhdTgkEqnNcWU9TfBwt1GjRmLJkiUIDAzs8dquS8Q0NTU7/RoSSWfrZEpKcn9CdUrX5LG14jBgsN3qFh8fbx6/JoTocauuF154AQCskjvT8dq1a102caI3cRER0cDAxM7NTMlSvKIVsyLr8HDK97gt9hyGK5sglXR+acrlcpe9Xl17AHZcikVJx3X48GIcatp7TpSAvnVPumizCbPMzEwUFhb2eF3XJWJ6m3Dk58926QQJW9ThgViRPwkhzVVoqzwM3YUzVtf0tXVtwYIFKCkpQUKC5exptVqNkpISFBQU9Ct2IiIa3DjGzo2CZXqMDdZgbIgGUQ4WDnZm9qojBqkchzVh+EarQu2PidzX72+x8To6q50ibJU5KzAwEC0tfe86trUvatfWREdMEyGcnanZ2x0++iIy2B85w6ORFtWZbK57YiUWLVpkNb6yt61r3WekFhQUIC8vD6GhnTtRbNu2jTtPEBERACZ2bjM2QoeFyT9A6sTCwf7+fdvd4FxbAL7RhuFU47XYful8n56jq5CQYKv13xyZOPEa7N+/v9+v2x8tLS3mx/a2AsvJycFNN81wa0tdZnwIbs6MhbzLDNaCggKUlJTgkUcesVimRK1WY+3atf1qXeuaxN1www1M6oiICAATO7cJ8hOQSgQUCoXNrbpMFAoFwkJD7Z7vTi/1R0PwSNQoMvCPcxcAAD/s/cTu9b3Z93TmzFm9WnjY3iB+R2y10vVHcLCyy2PbiWlOznSXJnXhQXJcPywKbToj6jRtiA5RYEJSmM1r2bpGRESexDF2bpbew3pywzKGOTVYraYtEB9eiMMXcXfiTMR0NPtHms85amXrzZqypn1ou2+z1d3VSQgpTj2vO2ZpmmJISro6EeL+++83P7799ttd/ppymQRT0iJw19QUDI8NwTh1KPJGx9pN6kzYukZERJ7CFjs3i4qKwpjRY1D+fblVy13mqEyr2bBdx1K1GmT4rkkF/6if4O1zlwEAt0r94M60oPs2W/bk589GcnLPs0tVKhVuumkGcnNz+xxT91ZHUx6cnz/bYkxe11a5pKQkp5/f2NEKqVxhVR7kL0N0iAIxIQFIjghCQlgA/Hq5WDAREZEnMbHzgKjoaISHh+O/n/7XsjwqyuL40sWLKP++HNVtgTisCcPx5mAYhBTKM1d3nqisrERGRoZb4+2aLNkad3fbbQXIzMyETnd10oetLl+JBJg9u/+zULt3sapUnQsqmyZCmLp2u8bjLIlEgpbjnwCQICSgCG0GIELpj5tGxiA5MqjH+kRERAMJEzsP6Wk82rlLjXj3wDl8rYnHZZ1l69G//vUv8+ONGzdZ1XU06aE3Y+xsuf/++/HSSy9blAUGBkAIo0WZrfFtpgSwv7rGsGzZUmRkZLhszNyUlDAYmuoBAEuyEnCuSWB0ggoyJ2fnEhERDSTsV3IDg8Fgfnyl8YrDzEqjiMPpiBvx6CdS7LocY5XUOSM392ab5a5YZ85WArVx4yasXbsOJ06cNJd1Hd9mMmrUyP4H0C0G04LKznGc0SaEBSAr+erElQC5DOPUoUzqiIho0GJi52KlpaUYPXq0+fjIkSM4+NlBXLp0yVzWapDh8yvhOBS7EMdi5+OrSwo0aPq+f+nw4cNtlqtUKtx2W/8WrD19+rTNcq1Wgy1bSs3H7l70tzeM7c2YmhoKzZf/gqGl0eY1USEKzBkXD6mrV1kmIiLyInbFulBpaSkWLVoEIQTSotPM5e3t7Th+4jiq2wLxtSYMJ34cOzdVHgY53LMpvanLUq/X9+t59uzZbbNcCNfvPOEKuvoatJwow/iEv0K0N6P56B6EBPih7WojKkbFhSBvdOeac83N/VscmoiIaCBhYuciBoMBhYWFVjshmGa2fqMNxaUO292s7tiUvnddlva5aikVT4hQ+qPl1KdAl/F/oqMV88fH4bu6NoQFyhGjCjDvDEFERORrmNi5SFlZGaqrq83Hl1ql+FddPE62dLbOOZKSkgyVSgWtVtPrZGn58uXw93fdXrODVaC/DHPHRAIG6xbKsEA58seEeT4oIiIiDxs4A6MGudraWovjH7R+ONas6jGpAzrHp82ePfvHx86/pkqlQkpKMuRyfxQVFWH16lW9itlXBPnL8JOJiQgN7H2Ca9qHVQgBpZIteURENLgxsXOR+Pj4ftXPzMx0ateHrvLy8tw+aSEkxH43safG2EUEydF0ZBc66sqtzkUG++OOycmICw3wTDBEREQD2IBI7FpbWzFz5kyMHTsWdXV1Dq9tamrC6tWrkZ2djRtvvBGvv/661bg2b8jJyYFarba7Xp0zSVBmZiYefPAhp1/TVcuJOOLOpVR6InRtaKv4GreNj4ZBcwGt5Z9jalo4JJLO/Vonp0ZgyaQkhAaxK5qIiAgYIGPsCgsLUV9fj6NHj0Kn0zm8duHChaitrcULL7yAhoYGPPDAA6irq8NTTz3loWhtk8lkWLduHRYtWmSV3PUmCTp16pTD89dffz0+/fTTvoTYJ46WUrn55jyUlpbaPN8fxvZmtJ39FrqLlYAwWqwrd21yGK5Nj4VSMSD+dImIiAYUr387lpSU4LPPPsMzzzyDW265xeG1ZWVl2LlzJw4fPowJEyYAABoaGvDoo4/i0Ucf7VU3pjsUFBSgpKQEjzzyCC52aUR0NgkSwohduz52eM23337bq5hM4+8Ayy23Vq9eBbncv0/bcLlqKRV72s4ege7CGbvnmdQRERHZ5tWu2IqKCjz88MPYuHEjFIqed1zYu3cvEhISzEkdAMybNw+tra04ePCgO0N1WkFBAY4dO2Y+XrZsKQoLC53qNq2sPAuNRuvwGq3W8XlHjMar2WZlZSWEMNos64mrllKxJSQoEM3nTrtlbT8iIiJf57WmD71ejzvvvBOrVq3C2LFjcf78+R7rVFVVWU1SMB1XVVXZrNPe3o729nbzsUaj6UfUzpHJZObHtpIgU2tZd+5MZo4fP47t2z8yH2/cuAlBQYEWy6ts3LgJKpUKeXl5boujJ2MSVJDLpOCywY6ZZvMSERF15bXE7ve//z1CQ0Px8MMPO11Hr9fD398yIZLL5ZBKpXbH5j377LNeH3/nLHcsVAx0JnWbN79vtUZeS0ur1bXdtwpzh6SIIFybEo6wQDlkMgk++KoaV1p0kEiACeowAJaJS3Nzs1vjISIi8hVeS+yKi4shhMC4ceMAXP3yzsvLw4oVK/D4449b1YmMjMTly5ctyhoaGmA0GhEVFWXzdVatWoVf/epX5mONRoOkpCRX/Rg9euaZZwEAjz76aI/Xdi5UHOKwOzYkJKRX3bFCGLF9+3anFz7uzVZh9sbv2SORAFPSIjAtPdJigslt1yTi/S+rEBMS4LIZrmzRIiKiochrid3OnTvR0XE1GTh48CDuu+8+rF+/HmPGjLFZ59prr8XatWtx6dIlcyK3f/9+8zlbFAqFU+P3BgKJRIq8vJkOJ1nk5uZi69atTj9n57i93nU/9zUfMmgvQtdwHjB2TqoYHhOMxnYBhVyG5IggDIsJRqzKer25sCB//GRiItr1PY/vc2SgJnMDNS4iIvI9XkvsRowYYXFsGmM3cuRIxMXFAeicKDBt2jSsWbMGCxYswPz58xEdHY2ioiK8+uqraG1txZo1azBr1iykpqZ6+kdwGZ2uw+mWPXvLj9jTn3F7CxcudGq7MqlEgimp4Wj6dheAqwnMrMxop3dziLGR8BEREVHvDIgFiu0xGAw4evQoGhoaAHS2fGzduhXbt29HdHQ0oqOj4efnhw0bNng50p75+8tRVFSEoqIimxMnHLn99tvNj7vOWnVmFmt/xu05U9dPKkFBViImp4TBlNQ1NTVxiy4iIiIvGDALgk2bNg1Hjhwxt9YBneu/HTlyBGq12lw2ZcoUlJeXo6KiAgqFAgkJCd4I16O6jgn861//an5smsU6e/ZsZGZm2qzbOW5PBa1W43QXq0RydR9aiUSKoqIiKOUC/7NoJoQwQipZbb525phYJEUEcYIDERHRADBgWuyUSiXGjh0LP7+ruaZUKsXYsWMRFhZmca1EIkFaWtqQSOq602qbuh1rsHnz+zh+/LjN6yUSKWbPnv3j456f33RNfv5sSCRSKORS3JwZgzsnJUJ3uQr6+hrMHRMDP6kEk1MjMCpOBeDqODJ3tNS587mJiIh8yYBJ7Mg+R92tpla4HTu2Wyw23FVmZiYWL15itTNHUFAgAgMDLcpUKhUWL16CzMxMjIgNwfJpqRivDoO0S1aYEhmE2ycn4fphkX38iYiIiMgdBkxXLNlXXV3j8LwQQGOjBrW1teblR7rLzMxEeno6nnvuOQBXtwXr6NDhD4U/BwCsePRJZGRkQCKRIjs9Atdl2F5CBuBkByIiooGIid0g4OzM1p6uk0q7tLr9uCPGiNhgtP7wJQBg/vXjcayuFZNTHSd1RERENDAxsRsEnJ3Z6sx1xjYtDE31iFMFIEIVhBvSVOZz0zMiMDIBSI3iODYiIqLBiIndIKBWJzo833UWqyOhgXI0HdkF0dGKhdfEQ6lUWs1mZVJHREQ0eHHyxCAgkUi7PO5+rvN/0yxWe0ID5VgwPg6iw3p/WCIiIvINbLEbYEwLGXfdjaKr4OBgiyVPVCoV8vPtr2MHALGqANw6IR5SQ8/7uRIREdHgxcRuEDAlewDQ3t6O5559BpBIzTNbu7bUxYcGYPrwKHxT1YjyC00YGReCvMwY+MmkaG5mYkdEROTLmNgNMpHBCmi/3gbl2FzzzFaTCKU/FkxMRKC/DOrwIDS366FUuOYWcyN7IiKigY9j7NxAqVTiwIEDWL16lUufVxUox/zxsTC2atBy8lNIugy4Cwnww21ZnUmdOQ4XJXVEREQ0OPCb34267gRRWVlp1W0KAP5+UvhLbN8GYdSjrfIb5AyLhJDJMTpeBbnQAQAMmouYnBKG7863YGJSOCalhiNALrP5PERERDQ0MLFzk3379uH14h3m440bN0GlUmH2bMuJDlnJ4RgfF4D/OfA+/FTRiFQWQdMBBMhlaP5uNwzayxifqDLvkdrcrDPXnZQcikkZsQhmyxwRERGBXbFuUVpaitWrVkOj0VqUa7UabN78Po4fPw4A0Ot1uH50UufCwkY99FdqEd9cjtyRUVg4MR4G7WWHryORSJjUERERkRkTOxczGAwoLCyEgPVEA9Pcgx07tkMII1IiAq3WlZs3bx5uuX4CPvl4myfCJSIiIh/C5h4XKysrQ3V1NfwTRto8LwTQ2KhBZeVZ+PnV27ympqYGd911lzvDJCIiIh/EFjsXq62ttTgWunYYmqy7VHUtGrzwxKM2n8O0rEhSUhL0er15fB0RERGRI0zsXCw+Pv7qgTCi5eR/0XxsH4xtTRbXBbVfQk1Njd3nEUKgqqoKZWVl7gqViIiIfAwTOxfLycmBWq2GBBK0VnwNfWMdhK4dzcf2Qeg7AIMOqrY6jIsPcer5urcAEhEREdnDMXYuJpPJsG7dOixethyivdlcbmzVoPm73TC2N+P/3nsXERERTj2fRQtgP3H3CCIiIt/GFjs3KCgowOaNG5CQkGBRnhARjJL33kVBQQFycnKQmJho9zkkEgmSkpKQk5Pj1lhNyZ4QgmP5iIiIBjkmdm5SUFCAY8eOmY+3bduGM2fOoKCgAEBny94LL7xgs65pq7C1a9dCJuNuEkREROQcJnZu1DUpu+GGG6yStAULFtisp1arUVJSYk4CiYiIiJzBMXYDzLZt2zBr1iy21BEREVGvscVugLHVskdERETkDLbYDTKc2UpERET2sMWOiIiIyEcwsSMiIiLyEUzsiIiIiHwEEzsvMhgM3g6BiIiIfAgTOy8pLS3F6NGjrcq3bt3qhWiIiIjIF3BWrBeUlpZi0aJFNme33nXXXQgICODixERERNRrbLHzMIPBgMLCQodLlqxcuZLdtERERNRrTOw8rKysDNXV1XbPCyFQVVWFsrIyD0ZFREREvoCJnYfV1ta69DoiIiIiEyZ2HhYfH+/S64iIiIhMmNh5WE5ODtRqNSQSic3zEokESUlJyMnJ8XBkRERENNgxsfMwmUyGdevWAYDd5G7t2rWQyWSeDIuIiIh8ABM7N1IqlRBCQAgBpVJpLi8oKEBJSQkSEhKs6rzzzjtc6oSIiIj6hImdlxQUFODYsWPm423btkGv12Pp0qVejIqIiIgGMyZ2XtS1u/WGG25g9ysRERH1CxM7IiIiIh/BxI6IiIjIRzCxIyIiIvIRTOyIiIiIfISftwM4efIkjhw5grCwMEybNs1iWZDu9Ho93nnnHavy6dOnY9iwYe4Mk4iIiGjA81pid+nSJSxbtgznzp3D6NGjUV5ejoqKCmzatAn5+fk267S1tWHFihWYO3cuoqOjzeXDhg1jYkdERERDntcSu/b2dhQVFeG6664zl91777146KGHUF5e7rDuE088galTp7o7RCIiIqJBxWuJXWJiIhITEy3KUlJS0NbW1mPdgwcPorKyEhkZGcjKyoJUyqGCRERERF4fY7dz505UV1fj1KlTKC4uxhtvvOHweolEguLiYsTHx2P//v1ISUlBSUkJkpOTbV7f3t6O9vZ287FGo3Fp/EREREQDhdebur755hvs3r0bH330EaKioizGznUnl8tRVlaGgwcPYsuWLTh9+jT0ej3uu+8+u3WeffZZhIaGmv8lJSW548cgIiIi8jqJEEJ4OwiTxx57DBs2bEBFRQWCgoKcqrNhwwbcc889aG5uhkKhsDpvq8UuKSkJjY2NUKlULou9L5qbmxEcHAwAaGpqcjgjmIiIiIYmjUaD0NBQp3IXr7fYdbVkyRJcvHixx8kTXQUFBcFgMODKlSs2zysUCqhUKot/RERERL7Ia4lddXU1ujcWfvbZZ/Dz8zNPqujo6MDf//53c6Jnq87mzZuRlpaG2NhYzwRORERENEB5bfLExx9/jL/97W/Iz89HVFQUDh8+jHfeeQdPP/00IiMjAQAtLS1YsWIF3nrrLQwbNgx79+7F+vXrMXfuXISFhWHbtm3Yv38/3n//fW/9GP2iVCqtElUiIiKivvJaYrdixQpMnjwZW7ZswdGjR5GWloZDhw5h1KhR5mv8/f2xfPly8+LDP/3pT3HNNdegtLQUp0+fRn5+PjZs2MDWOiIiIiIMsMkTntCbAYhERERE3jZoJ08QERERUd8xsSMiIiLyEUzsiIiIiHwEEzsiIiIiH8HEjoiIiMhHMLEjIiIi8hFM7IiIiIh8BBM7IiIiIh/BxI6IiIjIRzCxIyIiIvIRTOyIiIiIfAQTOyIiIiIfwcSOiIiIyEcwsSMiIiLyEUzsiIiIiHyEn7cD8DQhBABAo9F4ORIiIiKinplyFlMO48iQS+y0Wi0AICkpycuREBERETlPq9UiNDTU4TUS4Uz650OMRiPOnTuHkJAQSCQSt72ORqNBUlISqqqqoFKp3PY65Dzek4GJ92Xg4T0ZmHhfBiZP3BchBLRaLRISEiCVOh5FN+Ra7KRSKdRqtcdeT6VS8Q04wPCeDEy8LwMP78nAxPsyMLn7vvTUUmfCyRNEREREPoKJHREREZGPYGLnJgqFAkVFRVAoFN4OhX7EezIw8b4MPLwnAxPvy8A00O7LkJs8QUREROSr2GJHRERE5COY2BERERH5CCZ2RERERD6CiV0fGI1GrF+/Hvn5+Zg1axbWrVsHvV7v8jrUO9XV1XjwwQcxY8YM3Hnnndi/f7/D6/V6PTZs2IA77rgDs2bNwi9/+UucPXvWQ9EOHf/+979x22234aabbsJvf/tbXLlyxem6f/7znzF16lRs2rTJfQEOQc3NzXjqqaeQm5uLW2+9FcXFxU7V279/P+6++27k5ubi8ccfR2Njo5sjHVoOHz6Mn/3sZ7jxxhtx7733ory8vMc67733HpYsWYIZM2Zg6dKl+PDDDz0Q6dDR0dGB9957D3PmzEFubq5TdYQQ+Mtf/oI5c+Zg5syZeOmll6DT6dwcqWUA1EuPPPKIiImJEW+//bbYtGmTiIuLE7/4xS9cXoecV19fL9Rqtbj11lvFhx9+KB577DEhl8vFp59+arfO4sWLxYoVK8S7774rduzYIRYuXCjCw8PF999/78HIfdumTZuEXC4XL774oti6davIzs4W1157rdDpdD3WLSsrExkZGSI4OFi8+OKLHoh26Lj55pvFuHHjRGlpqVi/fr0ICAgQr776qsM6b731llAoFOLJJ58U+/btE6+88opYunSphyL2fUeOHBFKpVI88MADYtu2beKOO+4QkZGRoqqqym6dl156SQQGBorXXntN7N27Vzz77LNCJpOJjRs3ejBy3zZp0iSxePFice+99wqlUulUnd/85jciIiJC/P3vfxfFxcVCrVaL5cuXuzfQLpjY9VJ1dbWQSqVi8+bN5rItW7YIiUQifvjhB5fVod75wx/+IKKjo0V7e7u5bN68eSIvL89uHa1Wa3Gs1+uFWq0WTzzxhNviHGpSU1PFr3/9a/NxTU2NkEqlori42GG9+vp6kZqaKsrKykRkZCQTOxfauXOnACCOHz9uLnv66adFRESE6OjosFmnrq5OBAYGij/96U8W5a2trW6NdShZsmSJuP76683Her1eZGRkiJUrV9qtk5OTI+6++26Lsvz8fLF48WK3xTnUXLlyRQghxBtvvOFUYnfhwgXh5+cn3n77bXPZRx99ZPWecyd2xfbS3r17IYTAvHnzzGVz5syBn58f9uzZ47I61Du7d+9Gfn4+/P39zWULFizAJ598YrcJPDg42OJYJpMhMDAQHR0dbo11qCgvL0dFRQVuvfVWc1lCQgImTZqEXbt2Oaz785//HMuWLcP06dPdHeaQs3v3bgwbNgyjRo0yly1YsAD19fU4dOiQzToffPABdDod7r//fovygIAAt8Y6lOzevdvivSKTyTBv3jyH75VJkybh8OHDaGlpAQDU19fj+PHjmDJlitvjHSqc3cbL5JNPPoFer8ctt9xiLsvLy0NQUBB2797t6vBsYmLXS5WVlQgPD0dgYKC5TKFQIDIyEpWVlS6rQ71TWVmJhIQEi7KEhATodDrU1tY69RybN29GeXk55s+f744QhxzT37at++Lo7/61115DTU0NnnzySXeGN2TZe6+Yztly7NgxjBgxAgcPHsT8+fMxe/ZsPPHEE70aL0n2NTc34/Lly71+rzz//PPIycmBWq3GNddcg7S0NNxzzz349a9/7e6QyY7KykoEBQUhLCzMXObn54eYmBiPfd/7eeRVfIhOp7O5unRgYKDdlqG+1KHesfU7NiXSzvyOv/rqK9xzzz1YtWoVrrvuOrfEONSYfu+27ou9hOCbb77Bk08+iQMHDsDPjx9P7tCX90pbWxuqqqrwu9/9Dr/73e8glUrxxz/+EVu2bMGXX37Jlrt+cvRecfT5VVxcjH/84x946qmnMG7cOBw8eBDPP/88srOzkZ+f79aYybaB8H3PT85eioiIQH19vVX55cuXERkZ6bI61Du2fseXL182n3Pk8OHDmDVrFu6++26sWbPGbTEONabfe319PZKTk83ljv7ui4uLIYTAT3/6U3NZY2MjXn31Vezdu5cz/lwgIiICFRUVFmWm94qjzzCtVou3334bI0eOBACMHz8eqamp2LNnD+bOnevWmH1dSEgI5HK5zc8wR98Rv/rVr7By5UoUFhYCAHJzc3H27Fk89thjTOy8JCIiAo2NjTAajZBKr3aKevL7nl2xvZSVlYX29nYcOXLEXHby5EloNBpcc801LqtDvZOVlYUvvvjCouyzzz5DamoqwsPD7db79ttvkZeXhzvvvBOvvPKKu8McUsaMGQOFQmFxXwwGAw4dOmT37/7BBx/Ehx9+iLVr15r/KZVKLFiwAE8//bSnQvdpWVlZOHbsmHlcFtD5XpFIJJgwYYLNOpMmTQJg2a0eFxcHiUSChoYG9wY8BMhkMowfP97mZ5i994rBYIBGo0FiYqJFeUJCgs2GBPKMrKwsGI1GfPXVV+ayiooKXLhwwXPf9x6ZouFDDAaDyMzMFIsXLxYGg0EYjUaxdOlSkZGRYbGEQ15ennjzzTd7VYf67j//+Y+QSCRi27ZtQgghzpw5I6Kjo8XTTz9tvmbPnj0iOztbXLhwQQjRubxAVFSUeOihh7wS81Dws5/9TIwZM8Y8s2zt2rVCoVCIiooK8zUrV650OPOPs2Jd6+LFi0KlUomioiIhhBAtLS1iypQpYt68eeZrLly4ILKzs8WePXuEEEI0NzeLhIQE8cwzz5ivefnll0VAQIA4c+aMJ8P3Wa+//rpQqVTi6NGjQojO5X78/PzEli1bzNe8+eabFjP9Z8yYIaZNmyY0Go0QovPejhw5Utxxxx0ejX0ocDQrdu7cuWL9+vVCCCGMRqOYMGGCmD9/vtDr9UIIIVasWCGSk5NFW1ubR2JlYtcH3333nRg+fLiIiYkRsbGxIj09XRw+fNjimtDQUPMHp7N1qH9efvllERgYKEaMGCEUCoVYtmyZxfINmzdvFgDM60JNmzZNSKVSkZ2dbfFv1apV3voRfE5DQ4PIzc0VSqVSpKeni9DQUItlf4ToXJ4hPz/f7nMwsXO9HTt2iOjoaJGcnCxCQ0NFdna2qK2tNZ+vqqoSACzu1eeffy5SU1NFWlqaSE9PFzExMaKkpMQb4fsko9EoHnzwQeHv72/+DOu+9FJRUZEIDQ01H3///fdi6tSpQqVSifHjxwulUiny8vJEXV2dh6P3XatWrRLZ2dkiLS3N4vui69IlsbGx4vHHHzcfnzx5UmRmZoqoqCgRHx8vUlJSxBdffOGxmCVCCOGZtkHfIoTA8ePHIYRAZmamRV86AHz55ZeIi4uDWq12ug71n0ajwffff4+4uDjEx8dbnKuvr8epU6eQlZUFf39/fPfdd2hqarJ6jsjISAwfPtxTIQ8JFRUVuHLlCkaNGmU10P7EiRMAYLH8RldfffUVEhISrO4n9U9HRwdOnDiBoKAgDBs2zOrcoUOHMGLECIsxqkajESdOnICfnx/S09M5wcUNLl68iOrqapvDSKqrq3H+/Hlz17jJ+fPnUVdXh8TERERFRXkyXJ93+vRp8xjUrsaNGwelUgkAOHToEKKjo5GUlGQ+L4TAyZMnodfrkZmZCZlM5rGYmdgRERER+Qg2GRERERH5CCZ2RERERD6CiR0RERGRj2BiR0REROQjmNgRERER+QgmdkREREQ+gokdERERkY9gYkdERETkI5jYEREREfkIJnZERP1w8OBBfPTRRxZlZ8+eRXFxsc0t64iI3ImJHRFRPwQEBOAnP/kJSktLAQA6nQ4FBQUoLS1FcHCwl6MjoqGGOzgTEfXDxIkTsWbNGtx3333Izs7GK6+8grq6Onz88cfeDo2IhiCJEEJ4OwgiosFMCIFZs2ahtrYWJ0+exMcff4wZM2Z4OywiGoKY2BERucCBAwdw3XXXoaCgAB988IG3wyGiIYqJHRFRPxkMBsyYMQP19fUoLy/HgQMHkJWV5e2wiGgI4uQJIqJ+euaZZ3D69Gns27cPd911F5YtW4bW1lZvh0VEQxBb7IiI+uHzzz/H9OnTsXXrVsyZMwfNzc2YOHEiZs6ciddff93b4RHREMMWOyKifvj3v/+NNWvWYM6cOQAApVKJd999Fw0NDaiqqvJydEQ01LDFjoiIiMhHsMWOiIiIyEcwsSMiIiLyEUzsiIiIiHwEEzsiIiIiH8HEjoiIiMhHMLEjIiIi8hFM7IiIiIh8BBM7IiIiIh/BxI6IiIjIRzCxIyIiIvIRTOyIiIiIfAQTOyIiIiIf8f8BJB5z5OzFLIUAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -801,15 +1363,21 @@ "plt.xlabel(\"x\")\n", "plt.ylabel(\"y\")\n", "plt.legend()\n", - "plt.tight_layout()\n", - "plt.savefig(f\"n{N}_ci.pdf\")" + "plt.tight_layout()" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 38, "id": "22ca7234-5e2a-4249-a15e-9e7c773bd166", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.935793Z", + "iopub.status.busy": "2026-08-11T03:10:40.935651Z", + "iopub.status.idle": "2026-08-11T03:10:40.938704Z", + "shell.execute_reply": "2026-08-11T03:10:40.937930Z" + } + }, "outputs": [], "source": [ "def coverage_counted(y, err, lower, upper):\n", @@ -821,9 +1389,16 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 39, "id": "fafbe724-cab5-481d-8f43-ee8a07de0c69", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.940118Z", + "iopub.status.busy": "2026-08-11T03:10:40.939997Z", + "iopub.status.idle": "2026-08-11T03:10:40.943106Z", + "shell.execute_reply": "2026-08-11T03:10:40.942190Z" + } + }, "outputs": [], "source": [ "def coverage(y, err, lower, upper):\n", @@ -837,13 +1412,20 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 40, "id": "653ddf7d-568e-40c6-bd59-50d8bc93bf57", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:40.944421Z", + "iopub.status.busy": "2026-08-11T03:10:40.944303Z", + "iopub.status.idle": "2026-08-11T03:10:41.175228Z", + "shell.execute_reply": "2026-08-11T03:10:41.174577Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -879,8 +1461,7 @@ "plt.xlabel(\"inner %\")\n", "plt.ylabel(\"coverage %\")\n", "plt.title(f\"$N = {N}$\")\n", - "plt.tight_layout()\n", - "plt.savefig(f\"n{N}_ec.pdf\")" + "plt.tight_layout()" ] } ], @@ -900,7 +1481,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.3" } }, "nbformat": 4, diff --git a/examples/robust_likelihoods.ipynb b/examples/robust_likelihoods.ipynb new file mode 100644 index 0000000..78a8863 --- /dev/null +++ b/examples/robust_likelihoods.ipynb @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d8f105f7", + "metadata": {}, + "source": [ + "# Robust likelihoods: Student-t vs the multivariate normal\n", + "\n", + "The multivariate-normal likelihood penalizes a residual quadratically, so a few\n", + "outliers — mislabeled points, an unreported background, a transcription error —\n", + "leave it **confidently wrong**: the posterior stays narrow around a biased value.\n", + "The **Student-t** likelihood keeps the same covariance $\\Sigma$ but replaces the\n", + "Gaussian functional with a heavy-tailed one carrying a degrees-of-freedom\n", + "parameter $\\nu$: small $\\nu$ means heavy tails, $\\nu \\to \\infty$ recovers the\n", + "Gaussian. Sampling $\\nu$ lets the *data* decide how heavy the tails need to be\n", + "— and, as we will see, the multivariate-t's honesty shows up as **wider,\n", + "truth-covering uncertainty**, not as outlier rejection.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2bdf89cc", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:43:52.311562Z", + "iopub.status.busy": "2026-08-03T17:43:52.311358Z", + "iopub.status.idle": "2026-08-03T17:43:54.650591Z", + "shell.execute_reply": "2026-08-03T17:43:54.649500Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], + "source": [ + "import corner\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "from scipy import stats\n", + "\n", + "import rxmc\n", + "\n", + "rng = np.random.default_rng(21)" + ] + }, + { + "cell_type": "markdown", + "id": "8e3985d0", + "metadata": {}, + "source": [ + "## A clean linear signal with a few gross outliers" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7594ebbb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:43:54.653141Z", + "iopub.status.busy": "2026-08-03T17:43:54.652804Z", + "iopub.status.idle": "2026-08-03T17:43:54.806038Z", + "shell.execute_reply": "2026-08-03T17:43:54.805138Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "class LinearModel(rxmc.physical_model.PhysicalModel):\n", + " def __init__(self):\n", + " super().__init__(\n", + " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", + " )\n", + "\n", + " def evaluate(self, observation, m, b):\n", + " return self.y(observation.x, m, b)\n", + "\n", + " def y(self, x, m, b):\n", + " return m * x + b\n", + "\n", + "\n", + "model = LinearModel()\n", + "m_true, b_true = 1.0, 0.5\n", + "noise = 0.05\n", + "\n", + "x = np.linspace(0.0, 4.0, 25)\n", + "y = model.y(x, m_true, b_true) + rng.normal(0.0, noise, x.size)\n", + "\n", + "outliers = np.array([5, 12, 19])\n", + "y[outliers] += np.array([10.0, 12.0, 9.0]) * noise # one-sided: a fake background\n", + "\n", + "obs = rxmc.observation.Observation(x=x, y=y, y_stat_err=noise * np.ones_like(y))\n", + "\n", + "xg = np.linspace(-0.2, 4.2, 100)\n", + "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", + "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", label=\"data\")\n", + "plt.plot(x[outliers], y[outliers], \"o\", mfc=\"none\", color=\"tab:red\", label=\"outliers\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "34ea6351", + "metadata": {}, + "source": [ + "## The same constraint, two likelihood functionals\n", + "\n", + "The likelihood functional is orthogonal to the covariance: both constraints below\n", + "share the identical statistical $\\Sigma$; only the function of\n", + "$(d^2, \\log\\det\\Sigma, n)$ differs. The Student-t brings one likelihood-side\n", + "parameter, and the **full-tuple convention** applies everywhere: every\n", + "`Constraint` method takes covariance parameters followed by likelihood\n", + "parameters, in `constraint.params` order — including `chi2`, even though the\n", + "chi-squared statistic ignores $\\nu$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b0ee0605", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:43:54.807838Z", + "iopub.status.busy": "2026-08-03T17:43:54.807661Z", + "iopub.status.idle": "2026-08-03T17:43:54.812937Z", + "shell.execute_reply": "2026-08-03T17:43:54.811975Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian constraint params: []\n", + "Student-t constraint params: ['degrees_of_freedom']\n" + ] + } + ], + "source": [ + "nu_param = rxmc.params.Parameter(\n", + " \"degrees_of_freedom\", float, latex_name=r\"\\nu\", bounds=(1.0, 100.0)\n", + ")\n", + "\n", + "c_gauss = rxmc.constraint.Constraint([obs], model)\n", + "c_t = rxmc.constraint.Constraint(\n", + " [obs], model, likelihood=rxmc.likelihood_model.StudentT(nu_parameter=nu_param)\n", + ")\n", + "\n", + "print(\"Gaussian constraint params:\", [p.name for p in c_gauss.params])\n", + "print(\"Student-t constraint params:\", [p.name for p in c_t.params])" + ] + }, + { + "cell_type": "markdown", + "id": "89342ff5", + "metadata": {}, + "source": [ + "## Sampling $\\nu$ alongside the model\n", + "\n", + "$\\nu$ is a likelihood parameter, so it goes to a `likelihood_samplers` entry in\n", + "the `Walker` — the Gibbs framework alternates between the physics block and the\n", + "nuisance block.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "08a8ecf5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:43:54.814637Z", + "iopub.status.busy": "2026-08-03T17:43:54.814441Z", + "iopub.status.idle": "2026-08-03T17:44:01.618243Z", + "shell.execute_reply": "2026-08-03T17:44:01.617393Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian m = 1.002 ± 0.008 b = 0.566 ± 0.019 (truth b = 0.5 is 3.4 sigma away)\n", + "Student-t m = 1.002 ± 0.028 b = 0.562 ± 0.067 (truth b = 0.5 is 0.9 sigma away)\n" + ] + } + ], + "source": [ + "model_prior = stats.multivariate_normal(mean=[1.0, 0.5], cov=np.diag([0.3, 0.3]) ** 2)\n", + "\n", + "\n", + "def make_model_sampler():\n", + " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=model.params,\n", + " starting_location=model_prior.mean,\n", + " prior=model_prior,\n", + " initial_proposal_cov=model_prior.cov / 100,\n", + " )\n", + "\n", + "\n", + "nu_prior = stats.multivariate_normal(mean=[10.0], cov=[[49.0]])\n", + "nu_sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", + " params=list(c_t.params),\n", + " starting_location=np.array([10.0]),\n", + " prior=nu_prior,\n", + " initial_proposal_cov=np.array([[4.0]]),\n", + ")\n", + "\n", + "walker_gauss = rxmc.walker.Walker(\n", + " make_model_sampler(),\n", + " rxmc.evidence.Evidence([c_gauss]),\n", + " rng=np.random.default_rng(1),\n", + ")\n", + "walker_t = rxmc.walker.Walker(\n", + " make_model_sampler(),\n", + " rxmc.evidence.Evidence([c_t]),\n", + " likelihood_samplers=[nu_sampler],\n", + " rng=np.random.default_rng(2),\n", + ")\n", + "\n", + "for walker in (walker_gauss, walker_t):\n", + " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", + "\n", + "chain_gauss = walker_gauss.model_sampler.chain\n", + "chain_t = walker_t.model_sampler.chain\n", + "nu_chain = walker_t.likelihood_samplers[0].chain\n", + "\n", + "for name, ch in [(\"Gaussian\", chain_gauss), (\"Student-t\", chain_t)]:\n", + " z = abs(ch[:, 1].mean() - b_true) / ch[:, 1].std()\n", + " print(\n", + " f\"{name:10s} m = {ch[:, 0].mean():.3f} ± {ch[:, 0].std():.3f} \"\n", + " f\"b = {ch[:, 1].mean():.3f} ± {ch[:, 1].std():.3f} \"\n", + " f\"(truth b = {b_true} is {z:.1f} sigma away)\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9e6a0c15", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:44:01.620568Z", + "iopub.status.busy": "2026-08-03T17:44:01.620348Z", + "iopub.status.idle": "2026-08-03T17:44:01.822830Z", + "shell.execute_reply": "2026-08-03T17:44:01.821741Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " chain_t,\n", + " labels=[\"m\", \"b\"],\n", + " truths=[m_true, b_true],\n", + " truth_color=\"k\",\n", + " color=\"tab:blue\",\n", + ")\n", + "corner.corner(chain_gauss, fig=fig, color=\"tab:red\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"Student-t\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"Gaussian\")\n", + "fig.legend(loc=\"upper right\");" + ] + }, + { + "cell_type": "markdown", + "id": "883c01ed", + "metadata": {}, + "source": [ + "Both posteriors are shifted by the one-sided outliers — but the Gaussian is\n", + "**confidently wrong** (truth excluded at $\\sim 3.5\\sigma$) while the Student-t\n", + "inflates its uncertainty until the truth is covered ($\\lesssim 1\\sigma$).\n", + "\n", + "This is the multivariate-t's character: it carries **one** radial tail factor\n", + "for the whole stacked residual, so it cannot single out and reject individual\n", + "points — it broadens the posterior instead of relocating it. Per-point outlier\n", + "rejection would need per-point machinery (e.g. a free noise nuisance via\n", + "`noise_term`, or explicitly masking suspect points).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a1f32cc9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:44:01.825295Z", + "iopub.status.busy": "2026-08-03T17:44:01.825036Z", + "iopub.status.idle": "2026-08-03T17:44:02.702670Z", + "shell.execute_reply": "2026-08-03T17:44:02.701239Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(nu_chain[:, 0], bins=40, color=\"tab:blue\", alpha=0.7)\n", + "plt.xlabel(r\"$\\nu$\")\n", + "plt.ylabel(\"posterior samples\")\n", + "plt.title(f\"heavy tails demanded: median $\\\\nu$ = {np.median(nu_chain):.1f}\");" + ] + }, + { + "cell_type": "markdown", + "id": "fd330f6e", + "metadata": {}, + "source": [ + "## `chi2`: the fit statistic without the normalization\n", + "\n", + "`Constraint.chi2` returns the generalized chi-squared (the squared Mahalanobis\n", + "distance) under the same $\\Sigma$. Note the full-tuple convention: the\n", + "Student-t constraint requires $\\nu$ in the tuple even though the statistic\n", + "ignores it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b945e231", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:44:02.704495Z", + "iopub.status.busy": "2026-08-03T17:44:02.704334Z", + "iopub.status.idle": "2026-08-03T17:44:02.709510Z", + "shell.execute_reply": "2026-08-03T17:44:02.708453Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian chi2/n = 10.98\n", + "Student-t chi2/n = 10.98\n" + ] + } + ], + "source": [ + "map_gauss = chain_gauss[np.argmax(walker_gauss.model_sampler.logp_chain)]\n", + "map_t = chain_t[np.argmax(walker_t.model_sampler.logp_chain)]\n", + "nu_map = float(np.median(nu_chain))\n", + "\n", + "chi2_gauss = c_gauss.chi2(tuple(map_gauss))\n", + "chi2_t = c_t.chi2(tuple(map_t), (nu_map,))\n", + "print(f\"Gaussian chi2/n = {chi2_gauss / obs.n_data_pts:.2f}\")\n", + "print(f\"Student-t chi2/n = {chi2_t / obs.n_data_pts:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1ab2a3ba", + "metadata": {}, + "source": [ + "## Predictive comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "57661fd9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-03T17:44:02.711407Z", + "iopub.status.busy": "2026-08-03T17:44:02.711236Z", + "iopub.status.idle": "2026-08-03T17:44:02.833905Z", + "shell.execute_reply": "2026-08-03T17:44:02.832486Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def band(chain, levels=(5, 95)):\n", + " draws = chain[:: max(1, len(chain) // 300)]\n", + " ys = np.array([model.y(xg, *p) for p in draws])\n", + " return np.percentile(ys, levels, axis=0)\n", + "\n", + "\n", + "lo_g, hi_g = band(chain_gauss)\n", + "lo_t, hi_t = band(chain_t)\n", + "\n", + "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", + "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", color=\"gray\", label=\"data\")\n", + "plt.fill_between(xg, lo_g, hi_g, alpha=0.4, color=\"tab:red\", label=\"Gaussian\")\n", + "plt.fill_between(xg, lo_t, hi_t, alpha=0.4, color=\"tab:blue\", label=\"Student-t\")\n", + "plt.xlabel(\"x\")\n", + "plt.ylabel(\"y\")\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "id": "9e4a0f63", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- **The likelihood functional is a drop-in choice**: `Constraint(...,\n", + " likelihood=StudentT())` keeps the covariance model identical and changes only\n", + " the function of $(d^2, \\log\\det\\Sigma, n)$.\n", + "- **$\\nu$ is an ordinary nuisance parameter** — give it bounds on its\n", + " `Parameter`, a prior, and a `likelihood_samplers` entry, and the data choose\n", + " the tail weight.\n", + "- **The multivariate-t buys honesty, not outlier rejection**: one shared tail\n", + " factor widens the posterior to cover the truth where the Gaussian is\n", + " confidently biased; rejecting individual points needs per-point terms.\n", + "- **The full-tuple convention is uniform**: every method — `log_likelihood`,\n", + " `chi2`, `covariance_matrix` — takes covariance parameters then likelihood\n", + " parameters in `constraint.params` order, and raises on a wrong count instead\n", + " of guessing.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/sampling_algos.ipynb b/examples/sampling_algos.ipynb index 1e0ea57..d47e2a5 100644 --- a/examples/sampling_algos.ipynb +++ b/examples/sampling_algos.ipynb @@ -242,7 +242,9 @@ "metadata": {}, "outputs": [], "source": [ - "likelihood = rxmc.likelihood_model.UnknownNoiseFractionErrorModel()" + "log_noise = rxmc.params.Parameter(\n", + " \"log noise fraction\", float, latex_name=r\"\\log{\\epsilon}\", unit=\"dimensionless\"\n", + ")" ] }, { @@ -252,15 +254,16 @@ "metadata": {}, "outputs": [], "source": [ - "evidence = rxmc.evidence.Evidence(\n", - " parametric_constraints=[\n", - " rxmc.constraint.Constraint(\n", - " [observation],\n", - " my_model,\n", - " likelihood,\n", + "constraint = rxmc.constraint.Constraint(\n", + " [observation],\n", + " my_model,\n", + " extra_terms=[\n", + " rxmc.covariance.noise_fraction_term(\n", + " np.arange(observation.n_data_pts), log_noise\n", " )\n", - " ]\n", - ")" + " ],\n", + ")\n", + "evidence = rxmc.evidence.Evidence([constraint])" ] }, { @@ -333,7 +336,7 @@ "\n", "\n", "metropolis_likelihood = rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=likelihood.params,\n", + " params=list(constraint.params),\n", " starting_location=np.array(noise_prior.mean()),\n", " proposal=proposal_distribution_log_noise,\n", " prior=noise_prior,\n", @@ -348,7 +351,7 @@ "outputs": [], "source": [ "adaptive_likelihood = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=likelihood.params,\n", + " params=list(constraint.params),\n", " starting_location=np.array(noise_prior.mean()),\n", " prior=noise_prior,\n", " initial_proposal_cov=np.array([[1]]),\n", diff --git a/examples/systematic_err_demo.ipynb b/examples/systematic_err_demo.ipynb index 615a275..811b5ac 100644 --- a/examples/systematic_err_demo.ipynb +++ b/examples/systematic_err_demo.ipynb @@ -200,10 +200,25 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "69d96b52-427c-4345-8622-d2726544a77c", - "metadata": {}, - "outputs": [], + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:08:57.685052Z", + "iopub.status.busy": "2026-08-11T03:08:57.684884Z", + "iopub.status.idle": "2026-08-11T03:09:00.461343Z", + "shell.execute_reply": "2026-08-11T03:09:00.460616Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" + ] + } + ], "source": [ "from collections import OrderedDict\n", "\n", @@ -225,9 +240,16 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "81124826-23ca-4713-9b4b-9ed6626dc567", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.463594Z", + "iopub.status.busy": "2026-08-11T03:09:00.463332Z", + "iopub.status.idle": "2026-08-11T03:09:00.467741Z", + "shell.execute_reply": "2026-08-11T03:09:00.467131Z" + } + }, "outputs": [], "source": [ "def plot_chains(walker, model, true_params):\n", @@ -249,9 +271,16 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "dbdd23dd-ecef-43e4-9954-572e7fe1da0f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.469457Z", + "iopub.status.busy": "2026-08-11T03:09:00.469307Z", + "iopub.status.idle": "2026-08-11T03:09:00.472158Z", + "shell.execute_reply": "2026-08-11T03:09:00.471582Z" + } + }, "outputs": [], "source": [ "def plot_posterior_corner(walker, true_params):\n", @@ -266,9 +295,16 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "72a48951-4660-4d4e-bb8b-4c8980282eb0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.473618Z", + "iopub.status.busy": "2026-08-11T03:09:00.473479Z", + "iopub.status.idle": "2026-08-11T03:09:00.477590Z", + "shell.execute_reply": "2026-08-11T03:09:00.477012Z" + } + }, "outputs": [], "source": [ "def plot_predictive_post(walker, model, x, y_exp, y_err, y_true, x_true=None):\n", @@ -316,9 +352,16 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "9f859e53-c6f9-4d88-b7bf-bbc5bc9ab686", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.479244Z", + "iopub.status.busy": "2026-08-11T03:09:00.479091Z", + "iopub.status.idle": "2026-08-11T03:09:00.482357Z", + "shell.execute_reply": "2026-08-11T03:09:00.481750Z" + } + }, "outputs": [], "source": [ "class LinearModel(rxmc.physical_model.PhysicalModel):\n", @@ -338,9 +381,16 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "931eb9c2-6dfe-4538-98c1-c940333f5406", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.483849Z", + "iopub.status.busy": "2026-08-11T03:09:00.483706Z", + "iopub.status.idle": "2026-08-11T03:09:00.486203Z", + "shell.execute_reply": "2026-08-11T03:09:00.485466Z" + } + }, "outputs": [], "source": [ "my_model = LinearModel()" @@ -348,9 +398,16 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "6e6b4a56-38df-44ef-8cd0-0454ab01ad2a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.487761Z", + "iopub.status.busy": "2026-08-11T03:09:00.487619Z", + "iopub.status.idle": "2026-08-11T03:09:00.490169Z", + "shell.execute_reply": "2026-08-11T03:09:00.489481Z" + } + }, "outputs": [], "source": [ "rng = np.random.default_rng(16)" @@ -366,9 +423,16 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "138cb996-aab0-4a80-b0ae-eb07677b33cd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.491723Z", + "iopub.status.busy": "2026-08-11T03:09:00.491579Z", + "iopub.status.idle": "2026-08-11T03:09:00.494136Z", + "shell.execute_reply": "2026-08-11T03:09:00.493380Z" + } + }, "outputs": [], "source": [ "true_params = OrderedDict(\n", @@ -381,9 +445,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "1ee04e0a-9d10-479c-b0d5-cd4e2b2bd55b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.495610Z", + "iopub.status.busy": "2026-08-11T03:09:00.495466Z", + "iopub.status.idle": "2026-08-11T03:09:00.498045Z", + "shell.execute_reply": "2026-08-11T03:09:00.497448Z" + } + }, "outputs": [], "source": [ "prior_mean = OrderedDict(\n", @@ -402,9 +473,16 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "5107c785-2e6e-4c10-a5b0-c8eaf906549f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.499407Z", + "iopub.status.busy": "2026-08-11T03:09:00.499248Z", + "iopub.status.idle": "2026-08-11T03:09:00.502299Z", + "shell.execute_reply": "2026-08-11T03:09:00.501656Z" + } + }, "outputs": [], "source": [ "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", @@ -414,9 +492,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "37bd2c80-2873-4f73-b994-2101b42bec7f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.503959Z", + "iopub.status.busy": "2026-08-11T03:09:00.503806Z", + "iopub.status.idle": "2026-08-11T03:09:00.507359Z", + "shell.execute_reply": "2026-08-11T03:09:00.506602Z" + } + }, "outputs": [], "source": [ "systematic_fractional_err = 0.1\n", @@ -431,9 +516,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "7247bee4-67b8-4ac6-8f21-74373b733177", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.509189Z", + "iopub.status.busy": "2026-08-11T03:09:00.509040Z", + "iopub.status.idle": "2026-08-11T03:09:00.748450Z", + "shell.execute_reply": "2026-08-11T03:09:00.747747Z" + } + }, "outputs": [ { "data": { @@ -441,13 +533,13 @@ "Text(0.5, 1.0, 'experimental constraint with bias')" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -503,37 +595,56 @@ "\n", " \\begin{equation}\n", " \\Sigma_{ij} = \\delta_{ij} \\sigma_{stat,i}^2 + \\sigma_N^2 y(x_i) y(x_j)\n", + " \\end{equation}\n", + "\n", + "9. Unknown *constant* statistical noise, inferred alongside the model (option 2b):\n", + "\n", + " \\begin{equation}\n", + " \\Sigma_{ij} = \\delta_{ij} \\epsilon_0^2\n", + " \\end{equation}\n", + "\n", + "11. An additive **offset** systematic, included as a rank-one mode with a constant basis (option 5):\n", + "\n", + " \\begin{equation}\n", + " \\Sigma_{ij} = \\delta_{ij} \\sigma_{stat,i}^2 + \\omega^2\n", " \\end{equation}\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "id": "b5f05c68-32ab-467d-8635-94f6ffd9c4de", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.750539Z", + "iopub.status.busy": "2026-08-11T03:09:00.750376Z", + "iopub.status.idle": "2026-08-11T03:09:00.754153Z", + "shell.execute_reply": "2026-08-11T03:09:00.753542Z" + } + }, "outputs": [], "source": [ - "# 1 and 2\n", + "# 1 and 2 (reported statistical errors)\n", "obs_stat_only = rxmc.observation.Observation(\n", " x=x,\n", " y=y_exp,\n", " y_stat_err=y_stat_err,\n", ")\n", "\n", - "# 3\n", + "# 2 (unknown statistical error: reported errors ignored, inferred instead)\n", + "obs_unknown_stat = rxmc.observation.Observation(x=x, y=y_exp)\n", + "\n", + "# 3 (normalization systematic supplied as a covariance Term, scales with ym)\n", "obs_sys_norm_correct = rxmc.observation.Observation(\n", " x=x,\n", " y=y_exp,\n", " y_stat_err=y_stat_err,\n", - " y_sys_err_normalization=systematic_fractional_err,\n", ")\n", "\n", - "# 4\n", - "obs_sys_norm_wrong = rxmc.observation.FixedCovarianceObservation(\n", - " x=x,\n", - " y=y_exp,\n", - " covariance=np.diag(y_stat_err**2)\n", - " + systematic_fractional_err**2 * np.outer(y_exp, y_exp),\n", + "# 4 (the \"wrong\" fixed covariance, built from the DATA -> Peelle's Pertinent Puzzle)\n", + "obs_sys_norm_wrong = rxmc.observation.Observation(x=x, y=y_exp)\n", + "wrong_cov = np.diag(y_stat_err**2) + systematic_fractional_err**2 * np.outer(\n", + " y_exp, y_exp\n", ")" ] }, @@ -547,50 +658,59 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "id": "34d5d663-8735-4c87-b05d-12a886204959", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.756076Z", + "iopub.status.busy": "2026-08-11T03:09:00.755921Z", + "iopub.status.idle": "2026-08-11T03:09:00.758754Z", + "shell.execute_reply": "2026-08-11T03:09:00.758096Z" + } + }, "outputs": [], "source": [ - "# 1 and 3\n", - "likelihood = rxmc.likelihood_model.LikelihoodModel()\n", + "# 1 and 3 - the default Gaussian likelihood\n", + "likelihood = rxmc.likelihood_model.GaussianLikelihood()\n", "\n", - "# 4\n", - "likelihood_fixed_cov = rxmc.likelihood_model.FixedCovarianceLikelihood()\n", - "\n", - "\n", - "# 2 - a special likelihood model that takes in the noise fraction as a parameter\n", - "likelihood_unknown_stat = rxmc.likelihood_model.UnknownNoiseFractionErrorModel()" + "# 2 - free noise-fraction parameter, sampled as a covariance nuisance\n", + "log_noise_fraction = rxmc.params.Parameter(\n", + " \"log noise fraction\", float, latex_name=r\"\\log{\\epsilon}\", unit=\"dimensionless\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "ea87d212-bb42-4174-b274-f785b8e29e8f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.760562Z", + "iopub.status.busy": "2026-08-11T03:09:00.760403Z", + "iopub.status.idle": "2026-08-11T03:09:00.765403Z", + "shell.execute_reply": "2026-08-11T03:09:00.764617Z" + } + }, "outputs": [], "source": [ + "(support,) = rxmc.covariance.stacked_supports([obs_stat_only])\n", + "\n", "# 1\n", "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_stat_only],\n", - " my_model,\n", - " likelihood,\n", - " )\n", - " ]\n", + " [rxmc.constraint.Constraint([obs_stat_only], my_model, likelihood)]\n", ")\n", "\n", "# 2\n", "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " constraints=[],\n", - " parametric_constraints=[\n", + " [\n", " rxmc.constraint.Constraint(\n", - " [obs_stat_only],\n", + " [obs_unknown_stat],\n", " my_model,\n", - " likelihood_unknown_stat,\n", + " extra_terms=[\n", + " rxmc.covariance.noise_fraction_term(support, log_noise_fraction)\n", + " ],\n", " )\n", - " ],\n", + " ]\n", ")\n", "\n", "# 3\n", @@ -599,7 +719,11 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_correct],\n", " my_model,\n", - " likelihood,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(\n", + " support, magnitude=systematic_fractional_err\n", + " )\n", + " ],\n", " )\n", " ]\n", ")\n", @@ -610,7 +734,7 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_wrong],\n", " my_model,\n", - " likelihood_fixed_cov,\n", + " extra_terms=[rxmc.covariance.DenseTerm(support, wrong_cov)],\n", " )\n", " ]\n", ")" @@ -618,9 +742,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "id": "f237192a-4f2f-4b2c-8d0f-30d3e71ca123", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.767237Z", + "iopub.status.busy": "2026-08-11T03:09:00.767062Z", + "iopub.status.idle": "2026-08-11T03:09:00.769908Z", + "shell.execute_reply": "2026-08-11T03:09:00.769230Z" + } + }, "outputs": [], "source": [ "def proposal_distribution_model(x, rng):\n", @@ -639,9 +770,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "id": "194af035-fafd-4c64-8b58-0f7af34bb685", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.771842Z", + "iopub.status.busy": "2026-08-11T03:09:00.771676Z", + "iopub.status.idle": "2026-08-11T03:09:00.774653Z", + "shell.execute_reply": "2026-08-11T03:09:00.773960Z" + } + }, "outputs": [], "source": [ "walker1 = rxmc.walker.Walker(\n", @@ -658,19 +796,32 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "id": "25f3b9a2-5bf0-47a3-94f4-17bc1f864d20", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:00.776494Z", + "iopub.status.busy": "2026-08-11T03:09:00.776325Z", + "iopub.status.idle": "2026-08-11T03:09:04.497031Z", + "shell.execute_reply": "2026-08-11T03:09:04.496394Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", " Model parameter acceptance fraction: 0.336\n", - "CPU times: user 3.33 s, sys: 124 ms, total: 3.45 s\n", - "Wall time: 3.46 s\n" + "CPU times: user 3.72 s, sys: 25.3 ms, total: 3.75 s\n", + "Wall time: 3.72 s\n" ] } ], @@ -681,13 +832,20 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "98de6f5c-2c40-44bf-9120-bd2f1c809273", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:04.498537Z", + "iopub.status.busy": "2026-08-11T03:09:04.498385Z", + "iopub.status.idle": "2026-08-11T03:09:05.597104Z", + "shell.execute_reply": "2026-08-11T03:09:05.596500Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -702,13 +860,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "2106dc08-96ce-49df-8ae8-5a2cf7f45783", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.598567Z", + "iopub.status.busy": "2026-08-11T03:09:05.598415Z", + "iopub.status.idle": "2026-08-11T03:09:05.770222Z", + "shell.execute_reply": "2026-08-11T03:09:05.769551Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -723,9 +888,16 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 21, "id": "0c8ab69c-5fad-4b2e-a505-b7df7b266a86", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.772006Z", + "iopub.status.busy": "2026-08-11T03:09:05.771852Z", + "iopub.status.idle": "2026-08-11T03:09:05.988574Z", + "shell.execute_reply": "2026-08-11T03:09:05.987835Z" + } + }, "outputs": [ { "data": { @@ -733,13 +905,13 @@ "Text(0.5, 1.0, 'option 1: fixed statistical error, systematic ignored')" ] }, - "execution_count": 22, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -773,9 +945,16 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "id": "3750e61b-6028-4493-8bea-faa5d8ed6bbb", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.990533Z", + "iopub.status.busy": "2026-08-11T03:09:05.990369Z", + "iopub.status.idle": "2026-08-11T03:09:05.993357Z", + "shell.execute_reply": "2026-08-11T03:09:05.992820Z" + } + }, "outputs": [], "source": [ "noise_prior = stats.norm(loc=np.log(noise_fraction), scale=1)" @@ -783,9 +962,16 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 23, "id": "1424209b-d14f-449e-a433-5265b1162bc0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.994650Z", + "iopub.status.busy": "2026-08-11T03:09:05.994512Z", + "iopub.status.idle": "2026-08-11T03:09:05.996913Z", + "shell.execute_reply": "2026-08-11T03:09:05.996403Z" + } + }, "outputs": [], "source": [ "def proposal_distribution_noise(x, rng):\n", @@ -794,9 +980,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 24, "id": "396e21a8-3866-4f04-9ad3-8e401ddb8ccd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:05.998435Z", + "iopub.status.busy": "2026-08-11T03:09:05.998305Z", + "iopub.status.idle": "2026-08-11T03:09:06.001312Z", + "shell.execute_reply": "2026-08-11T03:09:06.000753Z" + } + }, "outputs": [], "source": [ "walker2 = rxmc.walker.Walker(\n", @@ -809,7 +1002,7 @@ " evidence=evidence_unknown_stat,\n", " likelihood_samplers=[\n", " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=likelihood_unknown_stat.params,\n", + " params=[log_noise_fraction],\n", " starting_location=noise_prior.mean(),\n", " proposal=proposal_distribution_noise,\n", " prior=noise_prior,\n", @@ -821,9 +1014,16 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "id": "92db7ab4-b071-4fc0-900c-1dde26ec5438", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:06.002626Z", + "iopub.status.busy": "2026-08-11T03:09:06.002490Z", + "iopub.status.idle": "2026-08-11T03:09:14.493812Z", + "shell.execute_reply": "2026-08-11T03:09:14.493183Z" + } + }, "outputs": [ { "name": "stdout", @@ -831,20 +1031,44 @@ "text": [ "Burn-in batch 1/10 completed, 100 steps.\n", "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 4/10 completed, 100 steps.\n", "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", + "Burn-in batch 6/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 7/10 completed, 100 steps.\n", "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 10/10 completed, 100 steps.\n", "Batch: 1/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.350\n", " Likelihood parameter acceptance fractions: [0.8]\n", "Batch: 2/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Likelihood parameter acceptance fractions: [0.78]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.490\n", " Likelihood parameter acceptance fractions: [0.86]\n", @@ -853,7 +1077,13 @@ " Likelihood parameter acceptance fractions: [0.83]\n", "Batch: 5/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.280\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -865,7 +1095,13 @@ " Likelihood parameter acceptance fractions: [0.79]\n", "Batch: 9/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.81]\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.490\n", " Likelihood parameter acceptance fractions: [0.73]\n", @@ -874,7 +1110,13 @@ " Likelihood parameter acceptance fractions: [0.85]\n", "Batch: 12/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.88]\n", + " Likelihood parameter acceptance fractions: [0.88]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 13/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.280\n", " Likelihood parameter acceptance fractions: [0.91]\n", @@ -883,7 +1125,13 @@ " Likelihood parameter acceptance fractions: [0.82]\n", "Batch: 15/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 16/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.390\n", " Likelihood parameter acceptance fractions: [0.85]\n", @@ -895,7 +1143,13 @@ " Likelihood parameter acceptance fractions: [0.84]\n", "Batch: 19/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.89]\n", + " Likelihood parameter acceptance fractions: [0.89]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 20/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.400\n", " Likelihood parameter acceptance fractions: [0.79]\n", @@ -907,7 +1161,13 @@ " Likelihood parameter acceptance fractions: [0.9]\n", "Batch: 23/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 24/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.350\n", " Likelihood parameter acceptance fractions: [0.8]\n", @@ -916,7 +1176,13 @@ " Likelihood parameter acceptance fractions: [0.78]\n", "Batch: 26/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.89]\n", + " Likelihood parameter acceptance fractions: [0.89]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 27/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.370\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -925,7 +1191,13 @@ " Likelihood parameter acceptance fractions: [0.83]\n", "Batch: 29/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.200\n", - " Likelihood parameter acceptance fractions: [0.86]\n", + " Likelihood parameter acceptance fractions: [0.86]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 30/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.320\n", " Likelihood parameter acceptance fractions: [0.86]\n", @@ -934,16 +1206,28 @@ " Likelihood parameter acceptance fractions: [0.85]\n", "Batch: 32/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.85]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 33/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 34/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", " Likelihood parameter acceptance fractions: [0.8]\n", "Batch: 35/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.8]\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 36/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.310\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -955,7 +1239,13 @@ " Likelihood parameter acceptance fractions: [0.9]\n", "Batch: 39/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 40/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.410\n", " Likelihood parameter acceptance fractions: [0.86]\n", @@ -964,7 +1254,13 @@ " Likelihood parameter acceptance fractions: [0.88]\n", "Batch: 42/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.83]\n", + " Likelihood parameter acceptance fractions: [0.83]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 43/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.340\n", " Likelihood parameter acceptance fractions: [0.81]\n", @@ -973,7 +1269,13 @@ " Likelihood parameter acceptance fractions: [0.82]\n", "Batch: 45/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.83]\n", + " Likelihood parameter acceptance fractions: [0.83]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 46/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.420\n", " Likelihood parameter acceptance fractions: [0.84]\n", @@ -985,7 +1287,13 @@ " Likelihood parameter acceptance fractions: [0.86]\n", "Batch: 49/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.86]\n", + " Likelihood parameter acceptance fractions: [0.86]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 50/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.310\n", " Likelihood parameter acceptance fractions: [0.84]\n", @@ -994,7 +1302,13 @@ " Likelihood parameter acceptance fractions: [0.79]\n", "Batch: 52/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.89]\n", + " Likelihood parameter acceptance fractions: [0.89]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 53/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.220\n", " Likelihood parameter acceptance fractions: [0.83]\n", @@ -1006,7 +1320,13 @@ " Likelihood parameter acceptance fractions: [0.74]\n", "Batch: 56/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.660\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 57/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.390\n", " Likelihood parameter acceptance fractions: [0.85]\n", @@ -1015,7 +1335,13 @@ " Likelihood parameter acceptance fractions: [0.85]\n", "Batch: 59/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.87]\n", + " Likelihood parameter acceptance fractions: [0.87]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 60/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.250\n", " Likelihood parameter acceptance fractions: [0.84]\n", @@ -1024,7 +1350,13 @@ " Likelihood parameter acceptance fractions: [0.85]\n", "Batch: 62/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.84]\n", + " Likelihood parameter acceptance fractions: [0.84]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 63/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.490\n", " Likelihood parameter acceptance fractions: [0.84]\n", @@ -1033,7 +1365,13 @@ " Likelihood parameter acceptance fractions: [0.82]\n", "Batch: 65/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Likelihood parameter acceptance fractions: [0.78]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 66/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.300\n", " Likelihood parameter acceptance fractions: [0.72]\n", @@ -1042,7 +1380,13 @@ " Likelihood parameter acceptance fractions: [0.81]\n", "Batch: 68/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.85]\n", + " Likelihood parameter acceptance fractions: [0.85]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 69/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.300\n", " Likelihood parameter acceptance fractions: [0.8]\n", @@ -1051,7 +1395,13 @@ " Likelihood parameter acceptance fractions: [0.78]\n", "Batch: 71/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 72/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.450\n", " Likelihood parameter acceptance fractions: [0.79]\n", @@ -1060,7 +1410,13 @@ " Likelihood parameter acceptance fractions: [0.79]\n", "Batch: 74/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.92]\n", + " Likelihood parameter acceptance fractions: [0.92]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 75/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.220\n", " Likelihood parameter acceptance fractions: [0.83]\n", @@ -1072,7 +1428,13 @@ " Likelihood parameter acceptance fractions: [0.83]\n", "Batch: 78/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.8]\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 79/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.290\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -1081,7 +1443,13 @@ " Likelihood parameter acceptance fractions: [0.77]\n", "Batch: 81/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.84]\n", + " Likelihood parameter acceptance fractions: [0.84]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 82/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.390\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -1090,7 +1458,13 @@ " Likelihood parameter acceptance fractions: [0.86]\n", "Batch: 84/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.83]\n", + " Likelihood parameter acceptance fractions: [0.83]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 85/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.360\n", " Likelihood parameter acceptance fractions: [0.81]\n", @@ -1099,7 +1473,13 @@ " Likelihood parameter acceptance fractions: [0.84]\n", "Batch: 87/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.81]\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 88/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.370\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -1108,7 +1488,13 @@ " Likelihood parameter acceptance fractions: [0.84]\n", "Batch: 90/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 91/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.320\n", " Likelihood parameter acceptance fractions: [0.82]\n", @@ -1117,7 +1503,13 @@ " Likelihood parameter acceptance fractions: [0.81]\n", "Batch: 93/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.81]\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 94/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.280\n", " Likelihood parameter acceptance fractions: [0.89]\n", @@ -1126,7 +1518,13 @@ " Likelihood parameter acceptance fractions: [0.83]\n", "Batch: 96/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.8]\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 97/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.290\n", " Likelihood parameter acceptance fractions: [0.77]\n", @@ -1135,12 +1533,18 @@ " Likelihood parameter acceptance fractions: [0.88]\n", "Batch: 99/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.260\n", - " Likelihood parameter acceptance fractions: [0.81]\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 100/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.390\n", " Likelihood parameter acceptance fractions: [0.89]\n", - "CPU times: user 7.14 s, sys: 353 ms, total: 7.49 s\n", - "Wall time: 7.23 s\n" + "CPU times: user 8.51 s, sys: 70.6 ms, total: 8.58 s\n", + "Wall time: 8.49 s\n" ] } ], @@ -1155,9 +1559,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 26, "id": "1a119f59-97fb-4791-9a18-3936d8083509", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:14.495247Z", + "iopub.status.busy": "2026-08-11T03:09:14.495087Z", + "iopub.status.idle": "2026-08-11T03:09:14.500168Z", + "shell.execute_reply": "2026-08-11T03:09:14.499467Z" + } + }, "outputs": [], "source": [ "def plot_chains_with_err(walker, model, true_params):\n", @@ -1195,13 +1606,20 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 27, "id": "9f73ec88-faa9-4c74-b677-61706a3f1223", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:14.501674Z", + "iopub.status.busy": "2026-08-11T03:09:14.501524Z", + "iopub.status.idle": "2026-08-11T03:09:14.971962Z", + "shell.execute_reply": "2026-08-11T03:09:14.971410Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1216,9 +1634,16 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 28, "id": "5d0920bf-a6cf-4fbd-a9d4-dcc213b655e3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:14.973831Z", + "iopub.status.busy": "2026-08-11T03:09:14.973674Z", + "iopub.status.idle": "2026-08-11T03:09:15.362339Z", + "shell.execute_reply": "2026-08-11T03:09:15.361416Z" + } + }, "outputs": [ { "data": { @@ -1226,13 +1651,13 @@ "Text(0.5, 0.98, 'posterior')" ] }, - "execution_count": 29, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1254,9 +1679,16 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 29, "id": "ccee96fa-f877-4cfe-a0bc-d250ca9066b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.364059Z", + "iopub.status.busy": "2026-08-11T03:09:15.363888Z", + "iopub.status.idle": "2026-08-11T03:09:15.586546Z", + "shell.execute_reply": "2026-08-11T03:09:15.585806Z" + } + }, "outputs": [ { "data": { @@ -1264,13 +1696,13 @@ "Text(0.5, 1.0, 'option 2: unknown statistical error, systematic ignored')" ] }, - "execution_count": 30, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1288,27 +1720,84 @@ }, { "cell_type": "markdown", - "id": "52954ccf-9f53-47d2-aa58-d57ac5cd2394", + "id": "c9732c59", "metadata": {}, "source": [ - "## Run option 3: correct formulation of the systematic error" + "## Run option 2b: unknown *constant* noise\n", + "\n", + "Option 2 inferred a **fractional** noise\n", + "($\\Sigma_{ij} = \\delta_{ij}\\,\\epsilon^2 y_m(x_j;\\alpha)^2$, via\n", + "`noise_fraction_term`). Its sibling `noise_term` infers a **constant** noise\n", + "floor,\n", + "\\begin{equation}\n", + "\\Sigma_{ij} = \\delta_{ij}\\, \\epsilon_0^2 .\n", + "\\end{equation}\n", + "Both are *additive* on top of any reported statistical diagonal — so to let the\n", + "inferred noise **replace** the reported statistics, build the `Observation`\n", + "without `y_stat_err` (as `obs_unknown_stat` is built), or pass\n", + "`include_statistical_term=False` to the `Constraint`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "061e55aa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.588203Z", + "iopub.status.busy": "2026-08-11T03:09:15.588033Z", + "iopub.status.idle": "2026-08-11T03:09:15.591783Z", + "shell.execute_reply": "2026-08-11T03:09:15.591325Z" + } + }, + "outputs": [], + "source": [ + "log_noise = rxmc.params.Parameter(\n", + " \"log noise\", float, latex_name=r\"\\log{\\epsilon_0}\", unit=\"dimensionless\"\n", + ")\n", + "evidence_unknown_const = rxmc.evidence.Evidence(\n", + " [\n", + " rxmc.constraint.Constraint(\n", + " [obs_unknown_stat],\n", + " my_model,\n", + " extra_terms=[rxmc.covariance.noise_term(support, log_noise)],\n", + " )\n", + " ]\n", + ")\n", + "# the true absolute noise scale is noise_fraction * y; center the prior there\n", + "const_noise_prior = stats.norm(loc=np.log(noise_fraction * np.mean(y_exp)), scale=1)" ] }, { "cell_type": "code", "execution_count": 31, - "id": "a0642bf9-b6a0-4830-b5b1-ac1994c4e8c9", - "metadata": {}, + "id": "dc755e2d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.593503Z", + "iopub.status.busy": "2026-08-11T03:09:15.593357Z", + "iopub.status.idle": "2026-08-11T03:09:15.596519Z", + "shell.execute_reply": "2026-08-11T03:09:15.595886Z" + } + }, "outputs": [], "source": [ - "walker3 = rxmc.walker.Walker(\n", + "walker2b = rxmc.walker.Walker(\n", " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", " params=my_model.params,\n", " starting_location=prior_distribution.mean,\n", " proposal=proposal_distribution_model,\n", " prior=prior_distribution,\n", " ),\n", - " evidence=evidence_sys_correct,\n", + " evidence=evidence_unknown_const,\n", + " likelihood_samplers=[\n", + " rxmc.param_sampling.MetropolisHastingsSampler(\n", + " params=[log_noise],\n", + " starting_location=const_noise_prior.mean(),\n", + " proposal=proposal_distribution_noise,\n", + " prior=const_noise_prior,\n", + " )\n", + " ],\n", " rng=rng,\n", ")" ] @@ -1316,58 +1805,718 @@ { "cell_type": "code", "execution_count": 32, - "id": "1d51307d-67d8-4336-8e23-05fb441eb815", - "metadata": {}, + "id": "8c5b3773", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:15.597976Z", + "iopub.status.busy": "2026-08-11T03:09:15.597818Z", + "iopub.status.idle": "2026-08-11T03:09:23.667111Z", + "shell.execute_reply": "2026-08-11T03:09:23.666489Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.750\n", - "CPU times: user 3.45 s, sys: 22.2 ms, total: 3.47 s\n", - "Wall time: 4.39 s\n" + "Burn-in batch 1/10 completed, 100 steps.\n", + "Burn-in batch 2/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n" ] - } - ], - "source": [ - "%%time\n", - "walker3.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "dcc445eb-6592-4973-8943-9fe17110ee57", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker3, model=my_model, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "8aed8b4b-50f2-4752-a61c-7fab12e179c5", - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/10 completed, 100 steps.\n", + "Burn-in batch 5/10 completed, 100 steps.\n", + "Burn-in batch 6/10 completed, 100 steps.\n", + "Burn-in batch 7/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 8/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n", + "Burn-in batch 10/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.72]\n", + "Batch: 2/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n", + " Likelihood parameter acceptance fractions: [0.86]\n", + "Batch: 3/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.240\n", + " Likelihood parameter acceptance fractions: [0.83]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 4/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.240\n", + " Likelihood parameter acceptance fractions: [0.87]\n", + "Batch: 5/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.87]\n", + "Batch: 6/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 7/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 8/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 9/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "Batch: 10/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.82]\n", + "Batch: 11/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.260\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 12/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.230\n", + " Likelihood parameter acceptance fractions: [0.86]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 13/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 14/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.77]\n", + "Batch: 15/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.240\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 16/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 17/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.290\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 18/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 19/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 20/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 21/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 22/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.88]\n", + "Batch: 23/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + " Likelihood parameter acceptance fractions: [0.86]\n", + "Batch: 24/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n", + " Likelihood parameter acceptance fractions: [0.84]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 25/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.250\n", + " Likelihood parameter acceptance fractions: [0.77]\n", + "Batch: 26/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 27/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "Batch: 28/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 29/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.85]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 30/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 31/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 32/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 33/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.87]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 34/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 35/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.86]\n", + "Batch: 36/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.290\n", + " Likelihood parameter acceptance fractions: [0.87]\n", + "Batch: 37/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 38/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 39/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.240\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 40/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.86]\n", + "Batch: 41/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + " Likelihood parameter acceptance fractions: [0.88]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 42/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 43/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.520\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 44/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 45/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 46/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 47/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 48/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.74]\n", + "Batch: 49/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.86]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 50/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.87]\n", + "Batch: 51/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.78]\n", + "Batch: 52/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.91]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 53/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + " Likelihood parameter acceptance fractions: [0.91]\n", + "Batch: 54/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.9]\n", + "Batch: 55/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.360\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 56/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.85]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 57/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 58/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 59/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 60/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 61/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 62/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 63/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.310\n", + " Likelihood parameter acceptance fractions: [0.82]\n", + "Batch: 64/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 65/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "Batch: 66/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.89]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 67/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 68/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.240\n", + " Likelihood parameter acceptance fractions: [0.76]\n", + "Batch: 69/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.84]\n", + "Batch: 70/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.85]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 71/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.360\n", + " Likelihood parameter acceptance fractions: [0.79]\n", + "Batch: 72/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.9]\n", + "Batch: 73/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 74/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + " Likelihood parameter acceptance fractions: [0.88]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 75/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + " Likelihood parameter acceptance fractions: [0.91]\n", + "Batch: 76/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "Batch: 77/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.210\n", + " Likelihood parameter acceptance fractions: [0.87]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 78/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.570\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 79/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.290\n", + " Likelihood parameter acceptance fractions: [0.78]\n", + "Batch: 80/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.81]\n", + "Batch: 81/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.180\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 82/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "Batch: 83/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.270\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 84/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.250\n", + " Likelihood parameter acceptance fractions: [0.78]\n", + "Batch: 85/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 86/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.86]\n", + "Batch: 87/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.87]\n", + "Batch: 88/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.88]\n", + "Batch: 89/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 90/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.230\n", + " Likelihood parameter acceptance fractions: [0.77]\n", + "Batch: 91/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.77]\n", + "Batch: 92/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.82]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 93/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 94/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.300\n", + " Likelihood parameter acceptance fractions: [0.8]\n", + "Batch: 95/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + " Likelihood parameter acceptance fractions: [0.85]\n", + "Batch: 96/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 97/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.83]\n", + "Batch: 98/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + " Likelihood parameter acceptance fractions: [0.75]\n", + "Batch: 99/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 100/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.89]\n", + "CPU times: user 8.08 s, sys: 98.5 ms, total: 8.18 s\n", + "Wall time: 8.07 s\n" + ] + } + ], + "source": [ + "%%time\n", + "walker2b.walk(\n", + " n_steps=10000,\n", + " burnin=1000,\n", + " batch_size=100,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "0e27db1d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:23.668685Z", + "iopub.status.busy": "2026-08-11T03:09:23.668540Z", + "iopub.status.idle": "2026-08-11T03:09:24.097945Z", + "shell.execute_reply": "2026-08-11T03:09:24.097205Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_chains(walker=walker2b, model=my_model, true_params=true_params)\n", + "plt.figure()\n", + "plt.plot(walker2b.likelihood_samplers[0].chain)\n", + "plt.axhline(np.log(noise_fraction * np.mean(y_exp)), color=\"r\", ls=\"--\")\n", + "plt.ylabel(r\"$\\log{\\epsilon_0}$\")\n", + "plt.xlabel(\"$i$\");" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "2280e6d8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:24.099536Z", + "iopub.status.busy": "2026-08-11T03:09:24.099385Z", + "iopub.status.idle": "2026-08-11T03:09:24.302912Z", + "shell.execute_reply": "2026-08-11T03:09:24.302349Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'option 2b: unknown constant noise, systematic ignored')" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predictive_post(\n", + " walker=walker2b, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", + ")\n", + "plt.title(\"option 2b: unknown constant noise, systematic ignored\")" + ] + }, + { + "cell_type": "markdown", + "id": "52954ccf-9f53-47d2-aa58-d57ac5cd2394", + "metadata": {}, + "source": [ + "## Run option 3: correct formulation of the systematic error" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "a0642bf9-b6a0-4830-b5b1-ac1994c4e8c9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:24.304694Z", + "iopub.status.busy": "2026-08-11T03:09:24.304543Z", + "iopub.status.idle": "2026-08-11T03:09:24.307551Z", + "shell.execute_reply": "2026-08-11T03:09:24.306753Z" + } + }, + "outputs": [], + "source": [ + "walker3 = rxmc.walker.Walker(\n", + " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", + " params=my_model.params,\n", + " starting_location=prior_distribution.mean,\n", + " proposal=proposal_distribution_model,\n", + " prior=prior_distribution,\n", + " ),\n", + " evidence=evidence_sys_correct,\n", + " rng=rng,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "1d51307d-67d8-4336-8e23-05fb441eb815", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:24.308991Z", + "iopub.status.busy": "2026-08-11T03:09:24.308869Z", + "iopub.status.idle": "2026-08-11T03:09:28.560186Z", + "shell.execute_reply": "2026-08-11T03:09:28.559514Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/1 completed, 10000 steps. \n", + " Model parameter acceptance fraction: 0.752\n", + "CPU times: user 4.25 s, sys: 7.86 ms, total: 4.25 s\n", + "Wall time: 4.25 s\n" + ] + } + ], + "source": [ + "%%time\n", + "walker3.walk(n_steps=10000, burnin=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "dcc445eb-6592-4973-8943-9fe17110ee57", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:28.561691Z", + "iopub.status.busy": "2026-08-11T03:09:28.561553Z", + "iopub.status.idle": "2026-08-11T03:09:28.851942Z", + "shell.execute_reply": "2026-08-11T03:09:28.851222Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_chains(walker=walker3, model=my_model, true_params=true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "8aed8b4b-50f2-4752-a61c-7fab12e179c5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:28.853382Z", + "iopub.status.busy": "2026-08-11T03:09:28.853241Z", + "iopub.status.idle": "2026-08-11T03:09:29.011651Z", + "shell.execute_reply": "2026-08-11T03:09:29.010961Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAfwAAAIVCAYAAAA08U3EAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAq6JJREFUeJzs3Xd8U1X/B/BPkjbjdrdpCx2hQEspyLAMmYqgMhyPA5xFUQRcuBVxPIALFAURF24BlSFDwS2CwKOAIquSTihpWqBJunOzc39/9HevSZs2SXeb7/v16kub3tzcDPK559xzvkfEcRwHQgghhHRr4o4+AEIIIYS0PQp8QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMAnhBBCAgAFPiGEEBIAKPAJIYSQAECBTwhpNXa7HRs2bIBare7oQyGE1EOBT0gAsVqt2LBhA3Jzc9tk/2azGbfccgu+/vrrNtk/IaT5KPAJCSDV1dW45ZZbsGPHjjbZf3BwMG666SYMGDCgTfZPCGm+oI4+AEJI9yGTybBhw4aOPgxCiAcU+IR0AJPJhK+//hrDhg1DWloajh49iqKiIqSnpyMjI8PjfWw2G/766y+cPXsWsbGxGDlyJGQyWYPt1Go1CgsLERoaikGDBiEmJgYAUFFRgW3btgEAjh49KgRz3759MWLECLd9ZGdno6CgAAqFAqNGjUJERESjx/7PP/8gJycHF110EXr06IGvvvoKQ4YMafA8vB1/U/tNSkpqxqtMCHHDEULaXXFxMQeAe/3117np06dzY8aM4caPH88FBQVxt9xyC2exWNy237t3L6dSqbiePXtyU6dO5VQqFRcfH899++23wjaVlZXc+PHjucjISG7q1Knc5ZdfziUlJXHPPfccx3EcV1hYyF133XUcAG7o0KHcTTfdxN10003cmjVrhH3k5ORww4YN46KiorjJkydzI0aM4EJCQrj33nuvwbGvWLGCu/nmm7lRo0ZxgwcP5jZv3szV1NRwALilS5f6ffxN7ZcQ0nIU+IR0AD7c+vbty3333XfC7bt27eIkEgn31FNPCbeVlJRwERER3KRJk7ja2lqO4zjOYrFwN9xwAyeXy7mcnByO4zju2Wef5cLDwzmdTifc12KxcOvWrRN+1+l0HABu+fLlDY6psrKSS0pK4kaNGsXp9Xrh9vfff58TiUTc7t27Gxw7H9gOh4M7ffq0x8D39fib2i8hpOVo0B4hHSgjIwNTp04Vfp84cSJuuOEGvP3227Db7QCATz75BFVVVXj99dcREhICAJBKpXjjjTdgs9nw9ttvAwBKS0shl8vBMIywP6lUiqysLJ+O5ZNPPoFWq8Xq1auFywAAMGfOHAwYMACrV692275fv36YNm0aAEAsFiMlJaXR/fpy/P7ulxDiH7qGT0gHGj58eIPbRowYgU2bNqGwsBDp6ek4evQo5HI5Bg8e7LZdUlISEhMTcfToUQDAbbfdhnXr1qF///6YMWMGJkyYgAkTJiAsLMynYzlw4AAkEglOnTqFoqIicHU9gACAkJAQZGdnez12T3w9fn/3SwjxDwU+IR1IoVA0epvVahX+K5fLIRKJGmzLMIyw3cSJE3H8+HGsXbsWe/bswVtvvQUAeOKJJ/Diiy96PRaTyYSgoCBs3bq1wd969+7t1uoHgNjYWK/79Of4/d0vIcQ/FPiEdKCCggKPt4nFYvTq1QtAXdh+88030Ov1UCqVwnYWiwVnzpzBf/7zH+G2/v374+WXXwYA1NTU4IknnsBLL72EyZMnY/z48R5Dl5eamoodO3bgvffeQ2RkpNdjb2pfrvw5fn/2SwjxD13DJ6QD7dixAzqdTvi9oqIC69atw9SpUxEeHg4AuOmmmwAAb7zxhtt93333XZhMJtxyyy0AgNOnT7v9PSwsDNdddx0AwGAwAAAiIyMRFBSEqqqqBsdy1113QSKR4KWXXmrwN6fTCY1G06zn6OvxE0LaFrXwCelAs2bNwnXXXYdrr70WEokEa9asgUwmcxsgN3r0aDz33HN44YUXUFJSgjFjxuDIkSNYs2YN7rvvPlxzzTUAgGXLluHYsWOYMmUKUlJSoNPp8M477yAzMxOTJ08GAEgkEkyaNAmfffYZEhMTERkZKczDHzhwID755BPMmTMHx44dw9SpUxEWFoaCggJ8/fXXuO+++zB//ny/n6Ovx08IaVvUwiekAyUmJmLjxo2orq7G0aNHMXPmTBw7dgy9e/d22+7555/HH3/8gdjYWOzduxdyuRy//PKL2wj3NWvW4O2334ZYLMZvv/2Gs2fP4tVXX8WBAwfcxgp8/vnnuPfee/HHH39g+/btOHLkiPC3rKwsFBQUYPLkycjOzsaff/4JpVKJb7/9Vgh7hmFw0003oV+/fg2eT2OldX05/qb2SwhpORHHD8MlhLQbrVaL5ORkrF69Gg888EBHHw4hJABQC58QQggJABT4hBBCSACgwCekA9D1akJIe6Nr+IQQQkgAoBY+IYQQEgAo8AkhhJAAQIFPCCGEBAAKfEIIISQAUOATQgghAYACnxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkAAQ1NEH0J04nU6UlpYiLCwMIpGoow+HkE6F4zjU1NQgISEBYjG1NQhpbxT4rai0tBTJyckdfRiEdGrFxcVISkrq6MMgJOBQ4LeisLAwAHVfaOHh4R18NKQ5zFY7blm5CwDw5SOTIJfSP5HWUl1djeTkZOHfCSGkfdG3WSviu/HDw8Mp8LsoqdWOIDkDoO59pMBvfXS5i5COQRfSCCGEkABAgU8IIYQEAAp8QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMAnhBBCAgAFPiGEEBIAKPAJIYSQAECBTwghhAQACnxCCCEkAFDgE0IIIQGAAp8QQggJABT4hBBCSACgtT9Ju9BoNNDr9V63UyqVUKlU7XBEhBASWCjwSZvTaDTIyMgAy7Jet2UYBmq1mkKfEEJaGQU+aXN6vR4sy2L9+vXIyMhodDu1Wo2srCzo9XoKfEIIaWUU+KTdZGRkIDMzs6MPgxBCAhIN2iOEEEICAAU+IYQQEgAo8AkhhJAAQIFPCCGEBAAKfEIIISQA0Ch90umo1Wqv21CBHkII8Q8FPuk0lEolGIZBVlaW122pQA8hhPiHAp90GiqVCmq12msJXirQQwgh/qPAJ52KSqWiECeEkDZAg/YIIYSQAEAtfNJl0eA+QgjxHQU+6XJocB8hhPiPAp90OTS4jxBC/EeBT7okGtxHCCH+oUF7hBBCSACgwCeEEEICAAU+IYQQEgAo8AkhhJAAQIFPCCGEBAAKfEIIISQA0LQ80iIajcan+fCEEEI6FgU+aTaNRoOMjAywLOt1W4ZhoFQq2+GoCCGEeEKBT5pNr9eDZVmsX78eGRkZTW5LNe0JIaRjUeCTFsvIyEBmZmZHHwYhhJAm0KA9QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMAnhBBCAgAFPiGEEBIAKPAJIYSQAECBTwghhAQACnxCCCEkAFDgE0IIIQGAAp8QQggJABT4hBBCSACgwCeEEEICAAU+IYQQEgAo8AkhhJAAQIFPCCGEBICgjj4AQtqaWq32uo1SqYRKpWqHoyGEkI5BgU+6LaVSCYZhkJWV5XVbhmGgVqsR1yOhHY6MEELaHwU+6bZUKhXUajX0en2T26nVamRlZUGv11PgE0K6LQp80q2pVCrqqieEENCgPUIIISQgUOATQgghAYACnxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkABAgU8IIYQEAAp8QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMVziEcajcanVeYIIYR0DRT4pAGNRoOMjAywLOt1W4ZhoFQq2+GoCCGEtAQFPmlAr9eDZVmsX78eGRkZTW6rVCpp+VlCCOkCKPBJozIyMpCZmdnRh0EIIaQV0KA9QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMAnhBBCAgAFPiGEEBIAKPAJIYSQAEDz8An5f2q1Gla7U/j96NGjkAa5nxNToSFCSFdFgU8CnlKpBMMwyMrKgiRYhknPbQEAjBs3Dg6bxW1bhmGgVqsp9AkhXQ4FPgl4KpUKarUaer0eVrsTi348DwDYv3+/WwtfrVYjKysLer2eAp8Q0uVQ4BOCutBXqVQwW+3Ajz8CAIYOHQq5lP6JEEK6Bxq0RwghhAQACnxCCCEkAFDgE0IIIQGAAp8QQggJABT4hBBCSACgwCeEEEICAAU+IYQQEgAo8AkhhJAAQIFPCCGEBAAKfEIIISQAUOATQgghAYACnxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkABAgU8IIYQEAAp8QgghJABQ4BNCCCEBgAKfEEIICQAU+IQQQkgAoMAnhBBCAgAFPiGEEBIAKPAJIYSQAECBTwghhAQACnxCCCEkAFDgE0IIIQGAAp8QQggJAEEdfQCkfWk0Guj1+ia3UavV7XQ0hBBC2gsFfgDRaDTIyMgAy7Jet2UYBkqlsh2OihBCSHugwA8ger0eLMti/fr1yMjIaHJbpVIJlUrVTkdGCCGkrVHgB6CMjAxkZmZ29GEQQghpRzRojxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkABAgU8IIYQEAJqWR4iffKlESHUMCCGdDQU+IT5SKpVgGAZZWVlet2UYBmq1mkKfENJpUOAT4iOVSgW1Wu3TWgRZWVnQ6/UU+ISQToMCnxA/qFQqCnFCSJdEg/YIIYSQAECBTwghhAQACnxCCCEkAFDgE0IIIQGAAp8QQggJABT4hBBCSACgwCeEEEICAAU+IYQQEgAo8AkhhJAAQIFPCCGEBAAKfEIIISQAUOATQgghAYACnxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkABAgU8IIYQEAAp8QgghJABQ4BNCCCEBIKijD4CQ7kqtVnvdRqlUQqVStcPREEICHQU+Ia1MqVSCYRhkZWV53ZZhGKjVagp9Qkibo8DvJjQaDfR6fZPb+NLiJC2nUqmgVqt9ej+ysrKg1+sp8AkhbY4CvxvQaDTIyMgAy7Jet2UYBkqlsh2OKrCpVCoKcUJIp0KB3w3o9XqwLIv169cjIyOjyW3pmjEhhAQmCvxuJCMjA5mZmR19GIQQQjohmpZHCCGEBAAKfEIIISQAUOATQgghAYACnxBCCAkAFPiEEEJIAKDAJ4QQQgIABT4hhBASACjwCSGEkABAgU8IIYQEAKq0R0gHo2V0CSHtgQKfkA5Cy+gSQtoTBT4hHYSW0SWEtCcKfEI6EC2jSwhpLzRojxBCCAkA1MLv5DQajU9dvoQQQkhTKPA7MY1Gg4yMDLAs63VbhmGgVCrb4agIIYR0RRT4nZherwfLsli/fj0yMjKa3JambRFCCGkKBX4XkJGRgczMzI4+DEIIIV0YDdojhBBCAgAFPiGEEBIAKPAJIYSQAECBTwghhAQAGrRHSBdBi+wQQlqCAp+QTo4W2SGEtAYKfEI6OVpkhxDSGijwCekCaJEdQkhL0aA9QgghJABQ4BNCCCEBgAKfEEIICQB0Db+D0LK3hBBC2hMFfgegZW9JW6L5+oQQTyjwOwAte0vaAs3XJ4Q0hQK/A9Gyt6Q1+Ttff9++fXTCSUgAocAnpBvxZb4+9QQQEpgo8AkJMFS5j5DARIFPSADyp3IfDQIkpHugwCeEeERd/4R0LxT4beDo0aMIDQ1t9O80v550BdT1T0j3QoHfBi655BKv29D8etIVtGbXf21tbWscEiGkmSjwWxHHcQCAVatWYejQoU1uGxMTg8jISFRXV7fDkRFfma122M11BZGqq6thldI/EW9kMhkUCoVPXf/Av/9OCCHtS8TRv75Wo9VqkZyc3NGHQUinVlxcjKSkpI4+DEICDgV+K3I6nSgtLUVYWBhEIlGr7be6uhrJyckoLi5GeHh4q+23rdFxt6/Oftwcx6GmpgYJCQkQi2ndLkLaG/VXtiKxWNymLZfw8PBO+UXuDR13++rMxx0REdHRh0BIwKLTbEIIISQAUOATQgghAYACvwuQyWRYtGgRZDJZRx+KX+i421dXPW5CSPugQXuEEEJIAKAWPiGEEBIAKPAJIYSQAEDT8lpRW83DJ6Q78HUePv07IqRxLalnQYHfikpLS6nSHiFeeKu0R/+OCPGuORUrKfBbUVhYGAB02kpnxDuz1Y5bVu4CAHz5yCTI69XS9zbGVa/XQ6/XQ6lUIjY21uvjtcWY2dZsFftzfN4el68EyP87aQz9O2ob3j7bpGvw9d+RJ/SOtyL+C68zVzojTZNa7QiSMwDq3kd/Az88PBx9+vQB4FvwGo1GGI1GhISEgGEYr9uzLOt1+84a+L5uR/+O2oa3zzbpWprz75wG7RHSgYxGI+x2O4xGY5tsTwghvIAO/KqqKuzYsaOjD4MEsJCQEAQFBSEkJKRNtieEEF7A9ulUVVVh8uTJyM3NRXFxMUJDQzv6kEgAYhjGp6785m5PCCG8gGzh82Hft29f1NbW4rPPPuvoQyKEEELaVMAFPh/2mZmZWL9+PaZPn44333yzWaOlLRYLqqur3X4IIYSQziigAt817N9++22IRCI88sgjyMvLww8//OD3/pYuXYqIiAjhh+YOk0Cg0+lw8uRJ6HS6jj4UQogfAirwrVYrrrnmGiHsAWDkyJEYM2YMVq1a5ff+Fi5ciKqqKuGnuLi4tQ+ZtBDHcT7/dMT+OorrcRqNRpSVlcFoNDZ4Dk6ns8FtOp0O58+fx8GDB6HT6brE8yWEBFjgx8bG4umnn24wf/GRRx7BTz/9BLVa7df+ZDKZMFeY5gwHBpFI5PNPS7AsC51OB5Zl/X5sfzU11c/T/mNjY1FbWwuGYaDT6Vrl+RJC2l5ABX5jrrvuOvTq1QtvvvlmRx8KIQD+DeGioqI27z73d6pfbGwsRo0ahR49evhUTZAQ0jlQ4AOQSCSYP38+1q5di4qKio4+HEKEEDaZTLBarW0a+AzDIDY21q/pfrGxsRgwYAAFPiFdCAX+/7v77rshkUjw4YcfdvShECKEsEqlglQq7fBgLSoqwr59+1BUVNShx0EIab5uXXiH4zifry2Gh4djzpw5Qh10QjqD2NjYDg97oG4hG7PZjOLiYqSkpHT04RBCmqHbtfCNRiMeeOABhIeHIywsDM8884zP912+fDluuOGGNjw60t15GmzXHSQnJ0Mul9PUU0K6sG4V+A6HA1OnTkVJSQk2bNiAxx57DC+//HKjlfRef/11lJSUCL+Lxd3q5SAdwN/FbbrKCUJKSgrGjx9PrXtCurBu1aW/du1aAMCWLVsgFosxbdo0HD9+HJ9++inuuOMOt23Lysrw2muv4aOPPsKxY8cQHBzcEYdMupmQkBBh+Vpf8CcIZWVlCAkJ8XmZXNK9aDQa6PV6r9splUqoVKpm7c9qdwr/f/ToUUiDxD7vj3QP3S7wX331VbeW+uTJk/HKK6802DYuLg6//vorcnNzKexJq/F3cRv+BMFisQg9AxT4gUWj0SAjI8OnXh6GYaBWq5sM6cb2JwmWYdJzWwAA48aNg8Nm8Wl/pPvoVoH/0EMPYdSoUW63xcXFwW63e9w+IyMDGRkZ7XFoxEf+VGxrbrEXlmWFVrhruNavGOepgpw/A0F9oVAooFAo3HoGOlvVuvrHYzKZhGNVKBTC7VR8p3n0ej1YlsX69eub/D5Sq9XIysqCXq9vMqAb25/V7sSiH88DAPbv34/C/Fyf9ke6j24V+Ndee22D24KDg92+sE6cOIE1a9bgrbfeascjIx3FUwi5Xmfnu947KmT54+usy956e/064zF3VRkZGcjMzGyz/ZmtduDHHwEAQ4cOhTSIxiwFmm7/jotEIjidddeuTpw4gcmTJ2PChAkde1CkQ/lbWa4z6QyD/Lry60dIIOtWLXxPRCIROI4Twv7NN9/E9OnTO/qwSAfiB8d1RZ2hdd1ZeyMIIU3r9i18sViMmpoaCnvSIkVFRdi/fz/OnDnTocdBrWtCSHN1+xZ+VFQULBYLhT1pEj+QTyKVe/y7VquFyWSCVqttdC56Y4MBfaHT6aDT6cAwTJPT89qidd2S4ybtz9uqnv6u+kkCR7cP/FGjRkGtViM1NbWjD4V0YnxXudnmuWBOUlIStFotkpKSvO6jOd3tOp0OFosF5eXl6Nu3b7t22XeGywTEO6VSCYZhkJWV5XVbhmGgVCrb4ahIV9LtAx8AhT3xip8WJ2ukhZ+SkoKUlJQGo/ldW8f+Ft1xFRsbC51Oh6ioqDbvsq/fom/JcZP2o1KpoFarW7VADwksARH4pGvpiC5mvqvcbPVcs6Exrq1jf5eYdeW6SA7//Pnjam31W/Q0CK/rUKlUFOSk2br9oD3S9fhbj74jtcUgurZ+/jTwj5DARC184lFrV7zzdX8sy0Kj0aC8vBxpaWlNLg3ryz59rYzH78tbpT2n0+lWulmhUIDjOBiNRnAcJ7SUOY7zaTEmp9PZ4PgYhgHLsmAYxu24fNmfL8+XYRgoFAqfXxeqoNd8vtTIp0F2pL1Q4JNOxWg0ora2FhKJBCaTqU32z4cp38LlbwsJCYE4SCpsazKboZCFud1fLBY3CECWZWG324V9+EMkEjXYX1euE0D+5W+NfBpkR9oaBT7pVEJCQhAXFweWZdvkC1Cn06G2thahoaFCqPKBbTQaERbxb+AbjUZER4Q12Ef9kwa+Rc7vn66JE8D3GvkADbIj7YMCn3QqCoWi3Rc04gO7fqu6sVZ2/RY9/6PT6YTbu3Lguw6adF0chzRPa9fIJ6S5KPBJl9OSUfyxsbEN7ufahe46Sp9pJOxcr7H7cntn4str5zpokAKfkO6DAp90OS0pFNMa18cb24fr7fxgO76Cnuu0u6YcPnwYOTk56N+/P4YNG9ai46yPZVkUFRVBJpMBaHzKH83LJ6R7osAnnVJTLVHXQPKntd/YgD2dTgcAiIuLcxu05wudTgeNRoOKigoAdUWeXEvv8hX0+ND3dmzHjx+HzWZDTk5Oqwe+0WiETCaDxWJpEOb1X0fX2Qauz8WfkxdCSOdC8/CJX06ePIkdO3bg5MmTrb5vlmWFgU5NzUVnGEYocuPPnHXXa++ut9XW1qK2trZZ8971ej2qq6uRm5uLqqoqlJSUuP09NjYWMpnMa0Dyx5acnIyQkBD079/f72PxJiQkBOHh4UhJSWnQVe/L6+h68kII6XqohU/8UlhYCKPRiMLCQgwYMKBV9+0aOr52K/vT/dzYaHqJROL3+vJ8i1yhUCA8PBzp6ekAgMTERLftfG0N88c2evToRp+Lry3sxno9Gmu5A769jnz5X2rdE9I1UeATv/Tt2xeFhYXo27dvq+/bNXT4cGJZFjqdrlVWj/M0mj42NhZKpRJ2u38ldfkWeUhISKOr5/myD1/GIeh0Ouj1euj1eoSGhvp0ecDfMQ6+vI7UlU9I10aB38m1dsW7lj5uRkaGMG2O36a1HpevAOe678ZGjPtTec7T4/DX8o1Go9CNHRYWBqfTKWzndDrdfgcAh8MBsVgMhUIhLJnLcRxiYmLctnM6nZBIJAAAg8EAvV4PpVLpth3/3Pjehcam9BkMBthsNohEIuF4+N4FT8/X9cSpsfexfsVAnl6vF04oqBAMId0LBT7xqKPKqXqqOseHV3OOia9kV39VO77rWqfTQSaTQSKReFw8R6PRoLS0FAkJCVCpVML++LK3YrEYBoOhQTi6Pm5+fr4Q/q7b1Z//39jzjImJgV6vFy4bVFdXo6ioCCkpKQ1ODvhj89Za91QxkH89rFarWy8CldYlpHugwCftorlz51ural39bm7XFekqKytRVVUFg8GA2B4JbvcrLS2F2WxGaWkplEql0AJnGAYxMTEwGAxCq51lWRQXF8NkMiEpKQmxsbFgWRYRERGoqqpqcFLA92jwLe3Gniff2jaZTCgrK0NlZSUiIyN97rL357Wn6/SEdF8U+KRdtGTufGuoPyiNP56goLp/Alarte4aeXik2/0SEhKEFj7LsnA4HG4D/JKTk4Xnw88ycDqdKC8vF2YSxMXFNWiNsyzbYIpgfa5BDUCYQx8TE+NXPQF/Xnu6Tk9I90WBT9pFRxdz8dRTUFlZCaVSCaVSiaqqqgbX64G6LnjX+/Ih7Rr+/N/4BVBMJhOio6MbfVx+P94W3OGD+syZM6ioqBBOTjx15Telo197QkjnQIFP2kX94CsqKoJWq0VSUlKzR7nzmnO5wGg0wuFwwGg0Ii4uDjKZDHa7HYby8gb75oNdqVRCLpcLXfD1B9gxDCNcZ/d08uDKlzK8fFCzLAuJRAKr1ep32POP1ZnL/RJC2gcFfhdXfzBaez9mc4OEH+Gu1Wq9Br63x/Ony5rfl+vSu3z4m81mOLh/B6jl5ecjMuzfx3Rd19zbcqYmkwlms7lBz4BrbwA/8I9lWZSVlQGoq/ZXfxv+sfnehtbAjweo/5j8sbb0/SWEdD4U+F1c/WI17f2YzQ2EpKQkoYXf0sfzp8ua35dCoXA7SeK74i32f1vmBQUFSIiPxahRo6DX6+FwOJCXl4eamhokJCRg6NChjT6OyWSCw+GATqeDyWQSpsGpVKoGz8FoNKK2tla4H388/LV0ftBea46Wd33M+sHe0eMtugKNRuN2AuiJWq1up6MhxDcU+F1cR1yfbY3HTElJ8bkr39vjeeqybqyVyu8rIiLC7XaVSlVX1tdsbfQxWJaF1WqF1WrF+fPnodfrG31s14F9MpkM586dQ48ePdyKCPH3CwkJQWhoKIC6OfcSiQR6vd7vwXP+tMxdH5N/XV1nLgQFBdE1/0ZoNBpkZGT4VJ3RW08QIe2JAr+L64jrs635mL6ElC+PV38/nlqp3h6LYRhYbA7h99TUVCTEx7oFeGxsLCQSCSIjI+FwOFBcXAygbq68UqmEXq9HQUEBLBYLzp8/j/DwcPTu3RtpaWkA3IvtuHbd8yc/ISEh0Gg0wvH68zr72zLnezj4bV1nLtBI/cbx6z2sX79eKELVGKVSCZVK1U5HRkjTAjrwLRaLsFRooPC1ch/HcT51Ifu6P6fT2WB/JpPJbblWhULhcwW9+vs7c+aMcJ07PT1daJErFAphAB3fjW0wGJCcnCxUqjOZTB4XjUnt2xdyaRDKy8vhcDhQVVWFiIgIyOVyYRS+xWKBRCJBeXk5oqOjUV5ejuDgYOTl5eHMmTOIiopym7evUChgMpmE43I4HMLoe9fufKlU6lbvny8O1BS+bLDVavXaA+OpgqGnCn2+vh9A4BXoycjIQGZmZkcfBiE+C9jV8v766y+kpqZi7969HX0oAYGvPCcSiWAymaDX61FWVua2XCv/d3/3x+/T4XDAZDIJ1eaUSiUUCoVbdTyz2QypVAqWZd2q4TkcDhgMBjgc/7bwKyoqUF5eDpZlYbFYEB0dDYvFAqn03yV0WZZFTU0NoqOjIRaLER0djdDQUMhkMshkMphMJkgkEpSVlaG4uBgikQhKpRIhISEQi8WQSCRux8HX9OdPAvjeAL4yXlM//MmBVCoVSuTypYP5/+cxDCN027veH6ibQaHX6/16PwghnV/AtvDffPNNmM1mTJs2Dd999x0uvvjijj6kZnOd4ta7d++OPhyv+NYlAISHh/s9Gtx10Rn+fsnJyUILvzEMw0ClUjXoKtfr9SgsLATDMBAH/zstz+FwwFBdV9WOL73LsixMJhPEYjHKy8sREhICqVQqPG79/6anpwsV+WQyWZPd9AzDCAPB+Oem1+thtVo9FujxdInCdayBpzr9/D4aK/jjugQudesT0r0EbOCnp6ejV69e+Pvvv5sd+haLBRaLRfi9urq6tQ+zgfrV14xGI/Lz8wEAxcXFnS7wPU05a2zgnK8auw7uy7S1+kV0WJbF2bNnhd+dMAvbSiQSKBQKnD59GgAQFRWFyMhImEwmyGQyoSs8JibGrXKeVqtFbW0tgoODERMTA5VK5VaW1/W1cZ2ux/+4PjeDwSBckggJCXF7/z1ds3d9fV0fz9fxAFRal5DuK2ADv3///ti8eTO2bt2K66+/HtOmTcOOHTvw5ZdfYtasWRgzZozXfSxduhRLlixph6P9l+uXPFDXcouOjhbqt3c2/HVzkUjk1ir3NpCuqQF2fKAxDIOcnBycPn0akZGR6N27t18D3fjueABCK10cLAOOngFQF+S11ZVC4R2z2QyFQiHUznctq8t3oVdVVQGoW5yG75YHGp9J4OnExbWan9PpbFAzwHUaJv854Ef/u16Pd23B+zrinkrrEtJ9BXTgZ2dnQyaTCaE/adIkXHTRRbjwwgt92sfChQvx6KOPCr9XV1cjOTm5rQ4ZgOea8BkZGWAYplNeb9XpdMjJyUHPnj099j40NrLc2yj7mJgYiEQinD59WrjGnpaW1mTYe2pR6/V6pKSkIDQ0FEql8v9Xy6sLfIPBAIetblCe0+lEfHw8FAqFx8sGDMOgqqoKEokEwcHBwhx9b5cY+C531yl+rs+BD19+P67vP7+tTqcTXiuj0dhgX65h79ryd72diu0Q0v0FbOCnpaXh1KlTsNlsCA4OhlKpRHh4OE6cOIE///zTp+59fmBWe6ofCK355ez6pe9prfX62/jy2OXl5ZDJZKioqPD495CQEJSVlQkD9zyNGOcf98yZM8LrLZfLAQC9e/fG6dOn0bt3b6/znfnLC1VVVUhLSxOmTLEsK+zPFT8IsHfv3rBYLGAYpsF2ricRqampwup5CoUCZrO5wT5d8fsrLy93u95ev8XPMIzwunjqKXB9rc6cOQOLxYLy8nL06dOnwfK7Go1GeA35XpfGLg+QwOBLgSCaXtg9BGzgS6VSJCYmIicnB6+99hrOnj2LoqIi3HbbbZg2bRp++OEHjBs3rqMPs115mqrF44PeaDRCJpP5HAxJSUmoqKhAfHy8x/vwLc36j1s/2PjHtVgs6NGjh3BMfMhnZ2djx44duP/++5sshMO3wl1L1TIM4zY6nzd69Gg8cN89uO2224Rt629XfxEdrVaL7OxsREdHIz4+3mOIuxZsUSgUbt34er0eNTU1CAsLc7ue39gJWP3Xiq8FEBUVhaCgoAaXSfjXkH8/6l8e8KXrX6fTCdf5qfu/6+I/01lZWV63ZRgGarWaQr+LC9jAB+q69WfMmAGVSoWvv/4aCoUCW7duxQMPPICEhATvO+hmPLWq67cAAf+qsKWkpCAuLq7JMPE1bCwWi/Al5XQ6hWvgGzZswBtvvIGamhps3LgRW7duFVru/HOQyWQICgoSlrv1FKAsy6L0nE74Xa/X47nnnkN2djY++OCDRo+rsrJSGLhXWloKu90OiUSCxMREIczrj5jn17Q3mUweBxu6nhSEh4c3+bq44kvy8l33rvjHiI+PFy4B1b884Asayd89qFQqqNVqn0oEZ2VlQa/XU+B3cQEd+Pfffz/eeustbN68WQgAmUzW5Jd7d+b6pc9xnBDyRUVFQrGY5q7Wxs+H9+VxefVPOGpqaoQuarlcDrlcjpdffhmvvPIKgLou6iNHjmDkyJFYu3Yt0tPThfn2rhX4goODcerUKZSXlyM5OVnoJSgsLMTsufdAefVzAICZt9+OtZ98hI0bNyI7Oxvvv/8+Bg4cKJSkZVlWmG7HP4+EhARUVlYiPj7e7fnp9XpUVlYKv/OPWf/Egw9/lmUhlUpRWVkJjUbjVlu/KfxJDn9/1y5914F8HMf5FfKuaCR/96FSqSjEA0i3LLxjt9vx22+/Yffu3UKr1JMpU6Zg586dTXaXdjSO41r9x9fHDQkJQVBQkFA8Bvi3Gh7/43Q6fXpMh8MBp9Pp9YefP26321FbWwubzYba2lpUVFSgqKgIVVVVqK2thUajwW233SaE/ezZs3Hw4EEMGjQIOp0OV199Nd5//304HA4oFApERkYKBXP4ffOBbbfbkZOTgxtvvBHHjh4VXoNly5Zh+/btiIuLwz///IPJkydj/fr1bscnk8lgtVrhdDqh1+sRHR2NYcOGISIiQjj24OBgyOVy4TkCdZUCZTIZgoOD3V4nfhaAUqlEUFAQzGYzbDYbysvLG33NXAvr1C/e4/p+1dbWQqfToba21qf3jR8AyLKs2+1KpRIZGRlQKpV+f64IIR2n2wX+sWPHkJGRgcsvvxwTJ07ERRdd5LFsalfhrbqa609rPy7DMIiNjYVKpYJUKkVsbGyDx3StAKfX65GTk+NWpc11O5PJBIPBIFTD8/Tjuj+FQiGE1rlz51BcXIzTp0/j5MmTmDx5Mnbu3AmpVIpVq1Zh+fLlSE1Nxffff4/rr78edrsdy5Ytw0svvYTQ0FBUVFSgoKAAABAZGYng4GAhzI4dO4apU6ciPz8f8f8/PgCom1o3YcIE7N+/H2PHjkVtbS0eeOABPPbYY7Db7UKLOTExESKRCFqtFv/8849wyaCqqgolJSWoqKgQxiqIxWIYDAbU1tYKBXw8/fD7lsvlsNlsYFkWBw4cEKr1uf64XjLgXzO+R4B/X/iCQXa7XXhcb58nfr9Go7HdP3+EkNbXrQJfr9dj8uTJeOKJJ2AymXDo0CHk5OTgxRdfbLBtTU0NJk6ciO+++64DjrT9sCwLnU7n08pejYmNjcWAAQO8duHq9XpUVVUhLy/P40kWHyB6vV4Ioabw9ef5bmeFQoGCggJcf/31yM/PR48ePfDNN99g5syZbvf54IMPsHjxYojFYmzatAlXX3011Go1rFYrysvLheekVCqhVqsxZcoUlJSUIC0tDTt27GhwHD169MCOHTuEKZhvv/02Lr30Uhw/fhyFhYUwGAzC8+fnzfOj+W02GwoLCwHUDWCMjo5GRESEUD2vKUajEZGRkVCpVDCbzTCZTCgpKfH4OrnW43edcld/rn/9gXxA3TV5tVoNnU7ncb+0ah4h3UO3Cvw333wTN910E+bOnQuJRIIRI0bg7rvvxk8//dRg26CgIEgkEjz88MOw2WwdcLTto36hnqY09sXvK6VSCYfDgYiICI9h7hpMdrsdGo1G6BHwpn///jh27BiWL1+OyspKDB8+HLt27cLIkSMbbCsSifDggw9i48aNiIiIwMGDB3HzzTdDrVZDoVBAKpVCLBYjOzsbc+fORXl5OYYPH46ffvqp0ToKQUFBWLx4Mb788ktERUXhzz//xDXXXIM9e/agtLQUAJCYmIigoCBhYZ3o6GgYjUY4nU7hpIBhGKGCX2P498FoNAqBm5CQAIVCgcTERI+vKz8mQKPRYM+ePThz5ozba86fBMTGxjaYl5+Xl4eqqqoG70NISIhP1QsJIV1Dtwr8Xbt2uRXCAYBhw4Z5DDCFQoFvvvkGu3btQnBwcHsdYrvjr8P70krT6/WwWCw+BbAnsbGxGDp0qDAKvD4+mPjr0yaTCVVVVcjPz2+ytW8ymbBgwQJ88MEHcDqdmDVrFrZv346ePXs2eTyTJk3Czz//jIEDB+L8+fOYNWsWdu/ejdDQUBw4cADz58+HyWTClClTsH37dqGCXlOmTJmCgwcPYvjw4aioqMCzzz6LNWvWwGg0wmazua3Cx8+z51vnQN3nTqFQwOFwQKvVepyrz78PJpMJsbGxYBgGycnJGD16tNsAK5Zlhd4S/j3j/5udnQ21Wg2WZRuEvCuWZREREQGHwwGlUtnkSV9r9BYRQjpOtwr8zZs3o1evXm63RURENBhQ5Prl29aV8Toafx3el1aaUqmETCbzWsCmKZ5akZ6OSalUIjk5GU6nE+Hh4UKImM1mGAwG4ef8+fO44YYb8NVXXyEoKAirVq3C+++/73PBoz59+mDfvn249tprYbVa8cADD+Diiy/GAw88AIfDgaysLGzdutWvbuuUlBTs3r0b9913HwBg3bp1ePfddxEfHy8ssgMA+fn5yM/PR3V1tVuLnmEYWK1WYRR9/ZBt7H3gA951bj9/iYQfqNe/f39ERkZCLpf7dPLGMAzi4+MxdOhQxMbGCov1eLqfP71FhJDOp1tNy/M0d14sFgsjowHggw8+wIYNG7Br1672PLROg1/73VOlPNdCKhzHtVq5Vddyrq77cZ2Cxt9eXl6OqqoqHD9+HIcPH8bOnTtRWFgIuVyOb775Bpdeeqnfjx8WFoaNGzfilVdeweLFi5Gfnw+pVIqFCxfimWeegUgkclsEyRcymQxvvPEG0tPT8dBDD+Gdd97BTTfdhPT0dCgUCmGuvVwuR0VFBU6dOgWg7jq+QqFAUlKSENx5eXnCLAj+PfA0XoIP+NzcXJjNZkRFRQk9JsC/0x/519S1MFFj6tfc5wv3eLqfP8V5CCGdT7cKfE9EIpHQwv/ggw/w0ksv4ddff+3go2qZoqIiFBcXIzk5GSkpKX7dV61Wo6SkBImJiRg2bFiT27ZWuVVPi8S4lqRVKpUwmUzYunUrNmzYgL1797p1KctkMqxbt65ZYc8Ti8VYuHAhxo0bh++++w5z5sxBnz59mr0/3j333IOtW7fit99+w8KFC7Flyxbhb3369IFcLkdZWRmqq6tx8OBBt8V3gLoTsIiICFRVVXkNZz7IXcsU9+/f320bvrXPMEyD3q76PNXVb6p6XnPn7RNCOoeACXzXsG+NL/qOVFxcDLPZjOLiYr8Dv6KiAlarFRUVFV5b8M1p0el0Oo8LwVRVVYHjOLfW49mzZ7Fjxw7s2bMHf/zxh9u14ZCQEEyePBlXXXUVpk6d2qLLDK7Gjx+P8ePHt8q+gLrP11tvvYVhw4Zh165deO+993DvvfeitrYWMTExSEpKglarxcGDBxEZGYny8nKhBK9UKoVEIkF8fDz69OnjNUz51zM1NVU4aXPlWkLYtTofP58eqGvBu47gP3/+PKqqqtCvXz+3oOffR18L/hBCOr9uH/gSiQQ6na7bhD1Qtywr38L3l2tY8NXr9Ho9evXq5bHOfWMhxJ8s8K1DvrV4/Phx1NTUIDg4GJmZmUIARURE4PTp08ICLytXrsSGDRvcxlckJSXhyiuvxNVXX41LLrnE44I2nVF6ejoWLFiAF154AcuWLcMll1yC0NBQWCwWJCUlCd34/JQ6g8EAqVQKq9WKpKQkhIWFue3PU9iaTCahNd5YdTS+ul79QZquywC7tuZdV/jT6/Vuwe56Ld9b4LueOFJ3PyGdV7cP/LS0NAwcOBDbtm3rkmHvqYJZr169hO5a/u8cx0Es9j4GU6VSCfdlWRZarRYOhwM6nc6t/jx/LdiVwWBwa6Hz3f38Yjp2ux0OhwPBwcEIDQ2FRCIRQruyshLh4eE4dOgQXnjhBWHa2IUXXogpU6Zg2rRpGDx4MIxGo1BspqnpkufOnfPphMBkMvk07bKyshJhYWGw2P5dHKemuhrWYInbdna73eOsjocffhgbNmxAfn4+li9fjscffxy1tbXCMcrlciQkJMDhcAjhq1AoUFtbK/w/z2AwwGazwWAwICoqCgUFBSgsLERUVBTS0tIafd4KhUIogew6bkWhUAgnFfzfnE4nGIZBv379hBX+XD9rDMMI9f69VdHz9dIPVeMjpGN1+8Dv27cvjh492mUrgbVFBT1+nyzLory8XAgw1+pqfEU811a+a6vPdVlZviqf68lAUlKS27Vqh8OB9957D8uXL4fdbkdiYiI+/PDDBisS8tX2vJHL5T5dT7bZbD69hsHBwXX1/oP+DXy5QgG5h8Dnawm4CgoKwltvvYXJkydj27ZtuOKKK5CZmYmKigqh0E5ISIhQlEcqlaKqqgoOhwOVlZVISkoSnk90dDQMBgOio6MhEolw+vRpmEwm1NTUYMiQIW6vj+tYCP7SjOvz5Svs1Z9Pz1fa42dw8Ptxbf2npKQgKCjI6+tHg/kI6Rq61bS8xnTVsPeGn9LFdwHz/+/rPGm9Xo+QkBBIJBK3kd6uxXFc96VUKiGVSoXw4O/jWlSmR48eDcK+tLQUV111FZYuXQq73Y5rr70Wf/zxR7dbfviSSy7BzJkzwXEcVq5ciYiICMTExMBqtQqvY0xMDGJiYhAUFISYmBjYbDZhTr7rNv369RNew5SUFERERGDIkCENlrvVaDTCokL16fV6HDhwwGNxI5PJ1KD+vus+GqvK5wn/WaABfYR0bgER+N0V35Wq0+nc/uvrPGmlUomIiAj069evQevM0xe+UqlE//793QbQ8fXZ+VZmVVUVtFqtcBKwY8cOZGZm4vfffwfDMHjrrbewdu1aREVFtcIr0PksXboUMTExyM3NxdatW4XSwFKpVKj/wJcMVigUkMvlwpx8/u/19evXDxMmTGgwIp9lWdTW1iInJ8fje873yPCr9NW/r+v7xq/Kx8+O4Osp8K1/X08kqTgPIZ1Xt+/S7874rlR+UBX/38a6VusPBvM0BYsPAr5VajKZ3JaQ1Wg0wqA/lUolXDfm54ADdQMlz549i8WLF+O9994DAAwePBiffPIJ+vXr1yavRWehVCqxbNkyzJkzB88//zyuvPJKxMXFoaqqCjExMSguLkZpaalwwiOVShEdHS2cWBkMBo/jJ1yxLIvc3FycO3cOFosFCQkJHk8W+OmOCoWiwSwH1/oH/OfF0+A9lmVx5swZtyWAm9JaUzkJIa2PWvhdGF9Fj18Ihv//xr5odTqd1+prrl36er0e1dXVbtuXlJS4LeLCzyvnwz4mJgZSqRQffPCBEPaPPPIIfv75524f9rysrCxcfPHFMJlMGDp0KG6//Xb89ddfcDgcKC0txfnz5/H7778LgyD5Fj8AYTU7fuleTy1llmVRWloKi8UCmUyG8PBwj9MWlUolLrzwQvTv39/jZ8J1Wd2mqvvJZDJYLBafrtHXL+VMLX5COg9q4QcQvnRqY3PaXXsAYmJi3AZ88eRyOc6cOYP09HSP+4iJiUF1dTU+/PBDAMD69etx0003tWk51nPnzmH16tXYs2cPxGIxZDKZ8CMWixEaGup2W2xsLO6+++42m18uEonw/vvv45577sGePXvw008/4aeffoJKpcLKlStRXl6O8PBw1NTUQKVSoaCgAFqtVlh0p6qqCmfPnoXT6URiYiJMJhOKioqQkpKC9PR06PV64XkOGDCgQYEdvra+axW++vjLAcC/3feeXg/+RMHXaov1p3K6tvh9LYdMCGkbFPhdFD9Ar6nKaPXxPQGeBjHyq6bxJV7T09OFa8Z8DXe+237AgAGQSqUA6q7hu3YnMwyDZ599FlarFZdddhluvPHGlj7VRhkMBrz99tv47LPPPC5C05R169Zh+fLluPLKK9vk2JKTk/Hzzz8jNzcXH374IdatWweNRoMHHngAn3/+OZxOJyIjI4W17m02m9BbUltbi4qKCgQHB8NkMiE/Px82mw15eXnC+gO9evWCxWIRVupzDX1+mWK+yE9jQW2xWFpcPc/b59B1BD9f758Q0jEo8Lsovnue/7JtKX7VNNcSr/z1erlcjp49ewq12V17CfjpYufPn0d8fDwOHz6MTZs2QSQSYdmyZW0yQ6KyshIrVqzAZ599JnQVjxgxAvfddx8iIiJgsViEn8rKSgQHB8NsNsNqtcJiseDrr7/GyZMnMXv2bEyfPh0vvfSScKLT2tLT07F8+XI8/fTTGDduHPLy8vDEE09g/fr1CAsLQ3V1tRC4/KWR0NBQ9O7dG0Dd9EYAQgvf9Zr7+fPnAdTNgnANfKVSifLycmGZYn7/Go0GWq1WmAKYkJDgdSVFfkxHY9fkdTodrFZro59D1xOK6upqv18/QkjrocDvomJjY1sU9vUH8PGrpvXu3RshISFwOp0oKChAVVUV5HI5kpOThS9v125ihUIhDDRbuXIl1q5dCwC4/fbbMWTIkFZ5rryamhqsWbMGq1evRlVVFYC6wYBPPvkkJkyY4PHkoqqqSugq591zzz14/fXX8dZbb+Grr77C77//jqVLl+Kqq65q1eN1FRUVhe3bt2Ps2LE4fPgwnnjiCSxatAghISHCfHf+Oj6/HC4vJiYGgwYNEsZWuIb7kSNHUFVVhTNnzgi3e1qUCICwHG92djYSEhIgl8s9Vuyrv9iR6/z8+lr6OSSEtB8K/E6usepk/PVZk8mEkydPgmVZ9OrVy63lzXelulZxczgcEIvFbtXc+JYlv53T6YTVaoXT6cT58+eRmpqKiIgImM1mlJWVCdPJ+OPLy8vDggULkJeXBwAYNWoUlixZAqvVKjyuwWDwqRV97ty5BuFiNpuxceNGfPTRR8LCMb169cK8efNw8cUXQyQSCZX76ispKUFERESD26+88kqkpKRg+fLlKC0txR133IHbbrsNDzz4sLBNWVkZZEHu41qtVqtPvRZms9mtnj1Qt5rjp59+iuuvvx47d+5E7969MX/+fKEioWt1vPr4981VcnIyzp07B7PZjHPnzgnd/fx0yvot8qSkJJSUlEAkEiE4OFgomFT/M8a36nU6nfBe8GMwXD9LAJocJ0AI6Vwo8Ds5b+HCj7R2Op1uLa3GpkfxFdZiYmKg1+sRExPjVqed31YsFkMikSA0NBTnzp0TgtbhcAjT8EpKSvDEE0/gq6++AlDX2nvppZeQlZXVIJyCg4M9lqStTywWC+MD7HY7vvrqK7z11lvC/PCUlBTMnz8fAwYMQM+ePb3uz2azNXqiMXjwYLz//vt4//33sWPHDnz++ec48Odh9M16DQDAKBjIgt2fh0gk8lhprz6JROKxYuCll16K5cuX49FHH8Xq1auRmZmJmTNnet2fWCz2uL+ePXuioKAAUqkUZrO5rlpgI58ZviSzTqcTTvQ8bctfd7dYLLDb7aioqEBUVJTXqXbePqvdtQAWIV0FBX4Xx4+wZlnWrVvVW7lT15YZv6Sq6yp3wcHB6NOnj3ANv6SkBGlpaWBZFsHBwVixYgVefPFF1NbWQiwWY968efjvf//bKgV1OI7D3r178eqrr6KgoABAXev4/vvvx7XXXougoKBGW/T+UigUeOihhzB8+HC88847KDp9Gn3//282uw2y4NYfWX733XcjJycH77//Ph544AEMGjQIQ4cObda+VCoVGIYRiujwLXBPKyHWX+TGteveFf8ZqF/nISQkpFmDRQkhnQMFfhfHMAwGDBgAjuPcWlCeunRdV7hz/Rt/ndZqtQrBwZeF7du3r1C8RaFQ4ODBg3jooYegVqsBACNHjsTq1atb7Xp9Xl4e3n77bfzxxx8AgMjISNx333245ZZbhJZ/Wxg2bBh++uknPLf4efDj/W+5+WZ8sOZd9OjRo9Ufb9myZcjPz8fu3btxxRVX4JNPPsGll17q14h51+Vw61dF9NTDYzQahboKCoUCDoej0ZUSAQizMlw/V0VFRa06WJQQ0n6o8E4A4UOADwl+uh3wb4vfNThYlkV8fDwSEhIgk8mQlZWFK664Amq1GrGxsfjwww/x888/t0rYnz17Fg8//DBmzpyJP/74A8HBwZg9ezZ+/vln3HHHHW0a9ryIiAgsf3W58PvJkycxa9asNhldHhQUhE8//RSpqakoLy/HY489hvLycuE9aaxQDf93vV4v1NEH/h2ox6tfAIe/jS/jazabcfbsWTgcDr9qJMTGxgq1DAghXQsFfhfTksplfAi4BrrrCYDrIihmsxkmkwkSiQQ9e/bELbfcgk2bNkEsFuO+++5DdnY2br/9dp9WtmuKyWTCypUrMXbsWGzcuBEcx+HKK6/E999/jyeffLLBwLf2pFQqkZOTg2XLlrXJ/qOiorBp0yZhCdwtW7aAZVmh5e0a/K5BX1NTg7y8PDgcDlgsFrAs22CBHL4KY/2eHIVCgbNnz4JlWfTs2RMSiQQhISE+f65iY2MxYMAACnxCuiAK/C7GtavWX3wJVz4EGIYRaubXD5by8nJIpVIoFAp88skn+PPPPxEREYE//vgDb7zxRouv1XMchx07duDiiy/Gq6++CpPJhOHDh+Pjjz/GihUr3KaldZTlr9UN3tu8ebNQ4Ka19e3bFw888AAA4Pjx42BZFqdPn0Z5eTlqa2tRXFwsVDzkC9dYLBZERERAIpFApVLBYDDg/PnzKC4u9vp4JpMJoaGhAIDw8HChO78lnytCSNdA1/C7mJauPe5av50PfqlUKgS+RqNBQUEBysrK0Lt3b8THx+O///0vAODll1/GhRde2OLnkJeXh6effhr/+9//ANQNyHv22Wdx7bXXQqvVtnj/reWikRdh1KhROHDgANasWYMlS5a0yeMMHjwYAJCdnY3y8nLYbDYAdVMUjUYjTCaTMEefH2jpOqtCoVDAaDQ2mDLnaeCea+Gk+oM8y8rKhJr5tPANqY8ft9MUpVLpsbYD6Rwo8LuYxkqhus67b+rLml8ytaKiAhERETh37hwSEhKgUqmEhVLy8/MRFRUFrVaLpUuXwmg0Yty4cZg9e3aLjp1lWaxcuRLvvfce7HY75HI57r//ftx3332dNmAefPBBHDhwAF9++SXuv/9+hIWFtfpjDBw4EEDdmAGj0Qir1Yq4uDhUVFQIl1169uzZ4HKMRqMRvmA9rUfvaeAeP7q+/tx7flQ+rXRH6uM/W1lZWV63ZRgGarWaQr+TosDvJup3yTYW/nwLLzIyEiUlJUJPget2o0aNQnFxMf7880/s2rULUqkU77zzTrOv13Mchx9++AFLliwRVtm74oor8MILL3T6L4bRo0dj2LBhOHz4MNasWYPHH3+81R+jb9++kMvlMJlMQs8Kf0nD4XAIg+34yy8Mwwgnbnq93m01PNcg97c3qKW9R6R7UqlUUKvVTa6yCdT1AGRlZUGv13f6f9eBigK/DXAc12iFPFe+FCLxZT+A+5e1a/jX7+aNjIwUSs0yDCMUYHE6nZDL5eA4DmlpaRCJRLjvvvsAAI899pjQA1BfSUlJkwV1NBoNXnjhBfz2228AgB49euDhhx/GuHHjYLPZUFhY6LZ9bm6uUMWvKTqdDmfPnvW6XUlJiTCSvSk2mw0ikQg2x7+vt1p9EsESEf7zn//g8OHDWL9+PS6//HKMHz/e6/5qamp8qizIv+4ZGRk4cuQISkpKMGzYMMhkMiQmJiImJgZyuRxmsxkOh0O4Ti8SiSCTyRATE+P2GXE6ncLnyrV6Yv3PkafPlaftff388cdEuieVSkUh3g1Q4Hdyvn6JKhSKBvOwQ0JCGtxfIpEIt3kqi8oPDlu2bBkqKirQv39/PP74442GF8dxHlv+FosF77//Pt59911YrVYEBQXhjjvuwJ133tngJMSV2Wz2qdvcbDYLg8+aolAofBoAqNVqIZfLIXZwwP/PxJfJ5ZBKRBgzZgzS09ORm5uL7du3Y9q0aV73V39efGP4krkXXHCBEPgxMTEQi8XC+2cwGGA2myGXy8GyLCQSCaRSqbCaoSu+kqI3vn6uXLfzNCaAENJ10Cj9dlZUVIR9+/ahqKjI5/v4OxXP05QsnslkEqZ7eZrzzTAM/vjjD+zYsQMikQirV6/2ew78b7/9hqlTp2LVqlWwWq0YO3Ys3nvvPdx3331Nhn1nJRKJhPK327dvh8FgaPXHGDRoEIC6gXuu75vJZEJtba3QtZ+cnAypVOp3/frmfO7qo5H8hHRtFPjtrLi4GGaz2acpVLzW/KJ1nXtffx4+UBduCxYsAFBXAnbUqFE+79tkMmHBggWYPXs2NBoN4uPjsWrVKnz66aedYppdS4waNQqpqakwm814++23W33/rgP3WJaFwWAQSuWGhoa6XVfnB+n5ozmfu/o8FfMhhHQdFPjtLDk5WVhu1lfN+aLV6XRQq9UoKipy6x1gGMatu7mystLtfi+88AIKCwvRs2dPLFq0yOfH02q1uPHGG7FlyxaIxWLcdddd+PHHH3HllVd2i2u7rq38NWvWCIsJtZYLLrgAQN3rWFFRAbvdDpPJBKDuPePHXbieoOXk5OD7779HTk6O1/0353NXX1M9R4SQzo8Cv52lpKRg/PjxSElJ8fk+zfmi1ev1sFgs0Gq1Qu8Ay7LIy8vDiRMnhNXnIiMjhft8/PHHePXVVwEAr7/+usdlZT3hOA7z58+HWq1GdHQ01q5di6efftqna+xdyZgxY9C7d2/U1NRgzZo1rbrvnj17IjIyEg6HA6WlpQgKCoJCoYDJZEJNTY1Q+MdisUCv1+PMmTPIyckRCvV405zPHSGkewnYwP/++++bXH+8s/Dn+r3rtkqlEjKZDElJSULvgNFoxNmzZ1FVVYVTp04JS6AyDIO3334bc+bMAcdxuPfee3HVVVf5fIwHDx7EiRMnIJfLsW3bNr8uA3QlYrFYmIv83nvvteq1bJFIJIxvCA4OFioiKhQKof49UNfb43Q6YTQaER8fD4Zh0Lt371Y5hpaUbSaEdH7NHqW/c+dOrFy5Uqi+NGDAADz66KM+jWDuaBs2bMAtt9yC2267DWvXrm1xPfi21Ni69t62bWz50p49e6KiogJlZWXIz89HWloaNm3ahKeeegoA8NBDD+H111/360v/448/BgBcf/31SExM9OPZdT2XXHIJ1q1bh6KiIqxduxb33ntvq+3b4XAAqOu2NxgMwsyLpKQkmEwmYVVDi8UChUKBIUOGCJ+JnJwcnD59Gr1790ZGRkazHt+fz1p3pdFofJpvTkhX1KzAX7VqFRYsWICsrCzceOONAIA///wT119/PZYvX4758+e36kG2tmXLlmHx4sV46aWXAKDZoW+xWGCxWITf22JVNW/FUDytcc4vhuLaAuWnUg0ZMgQikQhr165FbW0tVqxYge+++w4A8Mwzz2DJkiV+XXMvKirCr7/+CgC48847W/BMuwaJRIKHH34YDz/8MFavXo3Zs2e32kp+fK18u90uXMNnGAYmkwmlpaWQyWRQKBQNqu4BwOnTp8GyLIqKipod+IFeeEej0SAjI8Onk11+oSlCupJmBf4rr7yCtWvXCmEPAPPmzcMVV1yBRx55pFMH/oEDB6BQKLBo0SJceOGFmD59OoDmhf7SpUvbrL46r7FSurz6rXp+W51OB7vdjsrKSkRGRjZotfXp0wcrVqzAiRMnANTVyedH5/tj3bp1AICJEye2WtdyZ3frrbdi6dKl0Gq12Lx5M2677bZW2S8f+DabDUVFRUhISEBMTAwMBgNqa2tRU1OD5ORkj3P8e/fujdOnT7foGr23z1p3x09RXb9+vdeTJqoZT7qiZgU+y7KYMmVKg9unTJmCuXPntvig2tLgwYOxatUqAMA111yDr776qtmhv3DhQjz66KPC79XV1T6Pgm6qgplrq91b1Tm+m1culwuBAdQVnGFZVlh0RaFQCCcGxcXFuPfee3Hy5EnIZDKsXr0aN998s1uPQHl5udfHLi8vx7Zt2wAAkyZNwsmTJxvd9sSJEw2eM8uyqKmpEcKstrYWOp0OFosFtbW1MBqNqK2thcVigUwmg0wmg1wuh0wmg0QiQXh4uHAbf3twcDCCg4MRFBSE4OBgWCwWnDp1Svid/6n/PtvtdkilUtidAFB3KURbXIygeh+HoKAg9OzZEzNnzsRrr72G1157DZdcckmD/VmtVvTo0aPJ1w+o68aXyWTCMfC3hYWFwWw2w263Q6FQQCKRQKFQICYmRrjWz18CAIC0tDSkpaX5XOURaP3KeN4e15+qfR0pIyMDmZmZHX0YhLS6ZgX+iBEj8O233+KWW25xu33nzp0YOXJkqxxYW2EYxu0YPYW+0+nEyy+/jMcee6zJ7k0+hOoTiUQt+jL1VBpXo9FAq9UiKSnJrWXBt8ocDofbY7qWSeWZTCb8/PPPuPfee2EwGBAfH48vv/wSI0aM8PjcvAX+F198AavVirS0NIwcObLJ58xXkOOPY+fOnT5NJ3M9dn6aWkuFhYXhzjvvRJ8+fYTbLBYL+vTpA6uDA0pqAQApvXtDKnF/TkajEVKpFDNnzsSaNWtQWFiIvXv34oorrnDbTiwW+1xpLyio7p8hH/gxMTEICgpCdHS00Jrv1auXT1MzOY5r9SBvzRLQhJCO43Pgf/rpp8L/jxgxArNmzcL333+PESNGgOM4/PXXX9i4cWObLC7S1uqHvsVigdVqbbJGfFvydC1Vq9XCbDZDq9UKgc+vmGYymZCUlCQEKs9kMrldj3zvvffw4osvwm63Y+jQodiwYUOzB9lZLBZ88MEHAIDp06f7HDKlpaXYsmWLMP9foVAgJCQEoaGhCA0NhUgkQt++fREeHi78KBQKmM1mIfRNJhPOnDmDsLAw4Tnyf7fZbLBarbDZbLDZbGBZFhzHCb8DdXXu165diyeffLLZXdhhYWHIysrCu+++i3fffReXX355i4OWD/zY2Fi33gF+el5Tx8oXUmIYxufpkFQql5DA4nPgP/vss26/x8bG4tdffxUGbPG3ffbZZ8JguK7kmmuuwZdffonp06fjmmuuwebNm1ttMJa/XK+l8i2npKQkoYXP40vj1tbWwmq1CtO4XP/Oj/hetWqV22j6d999t0Vf8lu2bMH58+cRExODiy++2Ov2HMfhzz//xM8//wyHw4HIyEhMnz4dPXv2dNvu/PnzwvrwTQkPD0e/fv28bqdWq5GWlgagbmEZk8mElStXQq/XY9OmTbjjjjuaHdSzZs3Cxx9/jGPHjuHHH3/0eJnLV06nU5gmWlZW5hb4DMOA4zgh1PnbXN8/lmXhcDjAsqzPgU+j8gkJLD4Hvlarbcvj6HB2ux0bNmzo8LBvjKfVqviRwlarFWFhYUIY8MFQWlqKmpoavPTSS9i/fz+AupH4CxYsaFFrlOM4vPXWWwCAq6++2mtPCMuy+Omnn4SV8dLT03HNNdf4tCpea+IXpLn99tvxxhtv4OjRoxgwYECzL0PFxsbi9ttvxwcffIDHH38cycnJQolcf7lej+eLIrniV8tTq9VgWRYJCQkYOnQogLrBZlqttsFCQY3N1HD9PZBH5RMSaDrvBPQWOHbsGJ544gk89thjPs+Z3bZtG6xWa6cM+/r4lj0A9O/fH6NGjRJG6POtej7sH3/8cezfvx8Mw2DTpk144oknWtz1/PHHH+PkyZMICQnxqVX77rvvorCwEGKxGFdccQVmzJjR7mHvSqVSCce9fft2t7D11+OPP46xY8eCZdkWzdgwm83C/7v24vDkcjkkEolwucm1JLLBYBBWM3Tt4SkrK8P58+eh0Wg8rsVApXIJCSzdLvDfe+89XHLJJcjNzcXWrVsxYsQI5OXledzWdSGRGTNmYOvWrZ067Pmgz83NRU5ODjQaDYB/a63zhVqCgoIQFxeHJUuW4J9//kFUVBT27NmD6667rsXHsH//fmH63oIFC7wuZavVavHjjz8CAG655RZcdNFFnaK2/qRJk4QTJP51bI7g4GAh6LOzs5t98pCfnw+gbroXwzA4ePAg8vLyhEV0eCkpKUJ3/48//ojc3FwoFAq3AZ718Z8JaskTEti6VeAfPXoUzz77LA4dOoRvvvkG//zzD+Li4rB48eIG25aVlWHo0KFu0+oaW/O9s+Bb7xUVFXA4HB5HrfNTt15//XUcOHBAKHd74YUXtvjxz5w5gzvuuAN2ux3Tp0/3qd4CP+uhV69ebqPiO5pEIhHGAPgzW8CTXr16QS6Xw2w2N/vkge+JysjIQGlpKcxmM4qKioQCPHyXfkxMDEaNGoWysjIUFBTg2LFjQnnd+i31uLg4xMfHo1evXtSSJ4R0r8B/88038fLLLwtf5AzD4O6778aRI0cabBsXF4fHH38chYWFbvPXOzO+pZaamor4+PgGc/5NJhMMBgPefvttrFmzBiKRCOvWrcPYsWNb/Ni1tbW49dZbYTAYMGTIELz55pteW+pFRUXYvXs3AHTK6Zr9+/cH0PLAl0gkSE1NBQDk5uY2ax98DYMBAwYgISEBcrkc8fHxqKqqAvBvlz4f2hEREQgKCkJERAQYhnH7G6+xLnuqmU9IYGp2Lf3OyGw2N6gN0KdPn0YXOVm4cCGcTmenrqXvylslNJZl8fvvvwtTI1944QVce+21LX7ciooK3H777UKPyeeff+5Ta/Gzzz4Dx3EYP368x7r+HS09PR1AXY2DCtaOszUO2J3/zic/X+tAkLjupIYJFiFC3vjnJD09HdnZ2cjNzW3WaH0+8NPS0sAwDAYNGiRU2GNZFlFRUQgNDRUu62RkZCAlJUVYZKf+rA6grtegsLAQffv2dasc11Gj8+kEg5CO1a0C//PPP2/Q6mQYxm1VPLvdjsOHD+Oiiy4CgE4f9k6ns9GWNMuyMJlMUCgUcDgcOHv2LObNmwe73Y7rr78e8+fPb9DtbzAYfBqnUFBQAJlMhqKiIjz55JPCKPAXXngB1dXVQkBlZ2cLhWNcabVa7Nu3DyKRCKNGjcLJkyebrMTHCw0NRXZ2ttftevTogfPnz3vdzul0ora2ttG/R0REwAIp/hYNxN9/uwfS2qP/vnZicLgmsRJSzuJx2lt8fDyAustKWq0WIpHIp1rrNpsNUqkU//zzD4C6ojuFhYWIioqCXC4X3vuamhrY7XawLAuZTOa2qI5erxcKLTmdTlgsFhiNRuTk5MDhcOD06dNCbwbg/+j81iqqQ4FPSMfqVoHvKRhFIpEQ+Ha7XegB2Lx5c7seW3M1VbXPZDKhrKwMVVVVCA8Px+233w6dTodBgwbh3Xff9TgmQSqV+jRC3ul04sCBA3juuedgNBrRo0cPLF++XJjT7ioqKqrBbWvXrgUAXHTRRcjIyMDWrVsbHVTmas+ePV63AYDU1FSf5utXV1c3WVyoT58+KDhXDYib/qfghAhRcT0hs1V7fL5DhgwBUDfOgf+7L89XKpXCarWiqKgIAJCYmIjq6mqYTCZccMEFQm0Fg8EAo9EoVPBjGAZisRgmk0kYzxESEgKRSISqqirY7XbExsbi3LlzCA8Ph8lkgtFohF6vh1KphFKpbPfBkzSGgJCO1a0C3xOxWAyO44Sw56fetSWz1Q6ptelxAb62mhpr4WuKi5GjzkHRmSKEhYbiiy++wMmcPCjjeuCz9V9AIpXDbGs4YtxicwCSpkeScxyHDZu31BXq4TgMHTYCzy9ZgsjIKFjt7sft4ET/X3/+X6dOn0b2yRwEyRS48ur/wO4EREFSiCSe5+s7nU6YLRawLAtJcMNSxZ6IgqTgvIQ0AEAcBGcTQ1WSU/rgtP4fnx7T5gDETsBS/wkD6NUnFZJgGbRnz6O61gSZXAaz1fuIfYfTAfVJNcRBUsTExCA9YyAKT51CWFgYLDYHoqOjAQBVtSz0egNiYmIQGh4JoO5zJg6WwWJjESyXobyqBiaWBUQiACIMGDQEvfqkwmG3w1BZDYPBAKvFAou9DKHhke0e+OKgzjsDhpBAIOK6eRHs7777DrNmzcIll1zS5vPsq6urERERgYlPb0KQnFozhLiym1n8+vKNQo9UY/h/R962a21///03hg0bhsOHD3fLxXPMVjv+80rdFNmvF0yGXNq67T3+9aPVBttWS/59dPsWvkQigU6n6zJFdQghpCvia0hkZWV53ZZhGKjVagr9dtbtA3/06NF46qmnsGTJknYL+y8fmeT1zMuXjhX2/6+7MgwDppHrweMvvhjHjh7FlKlT8emnn3rtpq2sqICskWv4zzzzDD5fvx7h4RF48sknMHbsOK/HuH//PrfBaW+88QZyc3MxfvzFuPXWf2dMvLp8ORT//7gVlZU4W1oKSVAQevToAYVcgeDgIIhEIp8G9rkKCQ3FpEmTGv17TXU1BgwY0OQ+DmSfQuTFd3t9rKzBcsjs1ejbt6/Hvy986in8+uuvuHvOHMyZMwd9+3jezpXD6cC8ufOwffs2XHzxxdi0eTPkMhn+/OsvaDQaqFQqjBg+HA6HE0FBdWMy8vLzYbNaESyVop/LmIpffvkFZosFwUHBmDq16ZkCbbGqnjfV1dXo8XK7PiRpRyqVCmq1WqgC2hi1Wo2srCzo9XoK/HbW7QM/PDwcS5cubdfHlEuDvHaX+RL4NVVmBIk4OG0WyCM8V7S7fOIE/P3nQfyxfy8qDboGi9HUJwuWQB7sucDQ6YI8OGwWPL/4OQwYMADSIO+BIBFxwprxZ86cwcns4xCLxbhy6hVua8lzdis4x/8/rsMGh80CuTQI4SH/fyLjtIMD4LBZvD6mK1ViGkTOJsZLOO0Qo+E1d57VasWpgjxkel//B8ESINgJyIIajgkoKirCr7/8BIfDgYuGZ0IWJIZc6r2Qk8MB3HlHFnZ8vRW7d/2Mq6ZOxpIlS5CcnIwB6WlQKBSQS4OEZXT1ej3Ymrq5+b2SE90+Z2l9eyM/Px/R0ZFw2q0A0OhqeB0R+NZW7kImnY+nNT9I59G556QFuJCQEGE9dB7LssjJycGRI0eg1+uxePFiDBo0COXl5Zg7d67bFER/8fXZfZlO5sn3338PoK7ITv2lel3xPS1Wq7VZjwPUzV4YOXKkTyvmNeXvv/+GxeLfSYYnb775JhwOBy6++GKMGDHCr/tOnjwZ3377LcLCwnDw4EHcf//9OHPmjDDH3pVWq0VNTQ3Kysqg1WqRm5uL3Nxc6PV6pKenY9SoUejbty+MRqPbfPv69Ho9Tp486XGhnuagYj6EdH4U+B3Ely9IhmEafOnzhVeqq6uh1+shlUrx8ssvQ6FQYPfu3cIqds3BV3WLjIz0+756vR5//fUXAHgtPMOvrmez2Zo9xzsxMdHjIjP+YFkWhw8fho2tBprqJQAgEQGKRno8jh49ip9//hlisRgPP/xws45lwoQJ2LVrF+Lj41FYWIgtW7Z4/GwoFArYbDawLIuamhoUFRXBarXCYDAAcK+bz58weppvr9frYbFYWi3wmzq5IIR0DhT4HaS5X5D8krjh4eFQKBRC0ZU5c+YAABYtWoRjx44165j4Fn5zAv+nn36C0+nEgAEDvHbpBQUFCd3JzW3lt8Zqe3/++SdsNhvCZSIMMB3GnRfKkTX43/1mDZbjzgvrfuYNV3istMdxHFasWAEAuPbaaz3WKfDVhRdeiFWrVgEAvv76a5w6dUpYQIeXnJyMvn37okePHggODkZKSgqkUqnQo6JQKIRyuk2thqdUKiGTyVqlAiK/DK/FYqEFegjpxOiiWhvgOM5ry1WhUIBlWaE6mqvc3FwUFRUhJSUFffv2dSugI5fLhW7s8vJy2O12hISE4Nprr8Xhw4fxv//9D3feeSd+++03j1/0VVVVbkux8hwOB6qrqwHUdZeXlJT4NMixqKgIubm5QsGcPn364M8//2ywncVicav6J5FIYLfbUVRUBJFI1KyWfkFBgddtwsPDcfbs2Qa3G41G4cQoIyMDpsoy6IvUsHMiACkAAIMmB0Gif4+rGHV1HRISEoTb9u7diyNHjkAmk2HWrFnCCZzT6fT4OtdX/3LC5MmTkZCQgNLSUuzcuRNXXXUV9Hq9UC+fXxwpMjISEonE7dIJ/7nz5bWMiYkRLt14297btX6j0QiZTNbg8hMhpHOhwO8gTdXFLyoqAsuyKCoqQlpaWqPlf/nlXfnW3quvvorrrrsOeXl5+O9//4t33nmnwX2io6M9VuArLy8X/j8pKQlVVVU+tdYcDgfy8/Nht9sRFxeHjIwMjwERGRkpFJEB6rrzdTodbDab18cQi8UYPnw4BgwYIOx73759PlWyi42NxeTJkxvc/tFHH8HpdCIjIwO33367cM3c5gRQWbdNdHQ0guu99MHBwcIofY7jMHfuXADAPffcg9GjRwvbWa1Wn06YOI5zez8kEgnmzJmDJUuW4KuvvsK1116LyMhIBAcHCyVzRSKR0FVfXFwMrVaLpKQkpKSkCK1tTwP16vN10J637VxL9Ta1bWdYFpmQQEaB3wmlpKQILXygrsuUZdkGJwn87/yX/AUXXIB169ZhypQp+OCDDzB58mT85z//8ekx+ev3ISEhwjV2X9jtdvz9998AgBEjRvj8pd63b19ERtZVexOLxcKPw+EQejX4H5lM5tcxeaPVavH7778DAKZPn97sIDp06BCOHz8OuVyO++67r9WO76677sLSpUtx7NgxVFZWCivx8ZeBgoKChK54rVYLk8kErVaLlJSUDlkYhx8vQAjp3OgafhsrKirCvn37hFrpvkhPT8fkyZOF1dxYlhUWTqmPPxmQy+VgGAYTJ07EvffeCwCYN2+ex+5sTyoqKgB4rovflIKCAhiNRoSFhbkt0OKNVCpFz5490aNHD8TFxUGpVCI6Ohrh4eGIjY1FdHQ0IiIiEBoa2qphDwBbt24Fx3EYNmwYevfu3ez9fPjhhwCAG264wa33oqXi4uJwww03AACWLVsmXMP3NAgvKSkJCoVCGMDY1EA9Qkhgo8BvY8XFxTCbzSguLm72PviR155G6+v1etjtduF6McuymDlzJlJTU2EwGLBs2TKfHoNv4UdERPh8XE6nE8ePHwcADB8+3OOlgs4mPz8fR48ehVgsxvXXX9/s/ZSWlmLHjh0AgLvv9l60x1/33HMPgLpiOoWFhQA8r2+fkpKCcePGCb1BTQ3UI4QENgr8NpacnAy5XI7k5ORm74MfmV8/8IuKinD48GGcPXtWGLVuMplgs9kwZswYAHWr1nkblGW1WvH5558DgF8t1d9++w2VlZWQyWQ+rVzXGfz4Y10t8XHjxnktUtSUDRs2wOFwYPTo0bjgggta6/AEI0eORO/evWGxWHDixIlW3z8hJPDQNfw2lpKSIrS+XLlel8/Ly0NeXh769euHfv36gWVZGAwGVFRUIDEx0eM0N4ZhUFxcDIvFInTHGwwGVFZW4p133sHGjRsBAFdddVWT16iNRiNmz56N3bt3Izg4WLgc4I3dbseaNWsAAMOGDYNM5tsqdzydTofz588jNTW1VabY+YLjOGFk/7hx3ssGN2XXrl0A6sYAtIU//vgDp0+fhlgsbvGxNldRURGKi4uRnJzcoksfhJDOgVr4HYRlWTgcDrAsi7y8PBiNRuTl5Qm3FxUVwWw2N7gGr9frkZOTA5ZlkZKSgtDQUCgUCmi1Wnz88ccYM2YMNmzYAI7jcPPNN3scqc+z2WyYNWsWdu/eDYVCgfXr1zdZl97VN998A61WC4VC4XdlOZPJhNzcXJSXlyM3N7fZxXf8xRcskkgk6NWrV7P3U1VVhcOHDwMALr300tY6PAHHcXj22WcBADfddJMwlqO9tcblKEJI50GB30H4edUMw6Bfv34ICQlBv379hNtTUlIgl8sbdDvr9XpYrVa3UqoVFRXIysrC008/jfLycgwYMAC//PIL1q1bh7AwzzX4gboiPXv37gXDMPjqq68wYcIEn46dZVl88sknAIDMzEy/WvccxyE/P1+oPVBVVeXzwMKWOnXqFIC6et8tGQi4d+9eOBwOpKWltehSTWO+++47/P7775DL5XjmmWca3U6n00GtVrdatbz6WuNyFCGk86Au/Q7iOsVu6NChiI6ORmlpqbCCFF8UpX5RHqVSCb1eD6VSCYvFgqeeegqfffYZnE4nQkND8d///hcPPPCA10Bbt24dPvroIwDA22+/jeHDh/t87F9++SUqKiqQlJTkdd3r+s6dO4fKykqIxWL07NkTJSUlOH36NKKjo9u8a58P/D59+rRoP7t37wbQNq17h8OB//73vwDqBu41tjIf8G95XL1e3yoV8+rjL0fR/HlCugcK/A7icDjcvkjPnz8Pm82G8+fPu9WIt1gsCAr6920KDg5GREQENm3ahCVLlghLUV533XV44YUX0LNnT5hMJreqdq5OnDiBf/75BwsWLAAAzJo1C8nJyQ0Ghp04ccJj4Zjq6mphgN/ll1+Oc+fOQavVen2+JpMJBQUFQms+PDwcYrEYUqkUVqsVx48fR2xsLJRKJfLz873uz263uxULakxMTIwwJZJfejc8PLzBNMmqqqq6GQ+cCEDd0sYGg8Gt0h5QV+mQv34/evRo1NbWenxcm82G0NBQr8dns9mE1/ns2bN4++23cfLkSURFRWHOnDlwOBwwm80wm82IjIx0KzbkevLnelmEApoQ4gkFfhsQiURev3QlEonbwL34+HiUlpYiPj7erbKeRCJx29dff/2FhQsXCteQMzIysHLlSmRmZvrUTX327FksWbIEDocDl156Ke644w6Px2q1Wj2O2N+6dSusViv69OmDcePG4YsvvvBpZH9JSQnsdrtQWc7hcKCqqgrBwcGwWq0wm83Q6XQICQkRCs00RSKR+LRSXlBQEAYNGgSbzYaysjIAdS3z+pdKampqMGTIEFjtTvzw43kAwOhRoyCttxRufn4+SktLIZPJcMUVVzQ6/c3hcPhUCbCmpgZr167Fxo0bsXfvXiG4b7zxRqHsst1uh0gkalBMJzY21mPL3pfAp5MCQgIPBX4Hch2457qONH8iANQFB8MwcDgcePHFF7F69Wo4HA6Ehobi2Wefxf3334/g4GChDn5TamtrsWTJElRVVSEtLQ0LFizw64v/7Nmz2Lt3LwBgxowZft3X4XDAbq9bkU4ulwv35SvpWSwWmM1mYZvWdubMGdhsNoSFhaFHjx7N3s+BAwcAAGPGjGn2XPfq6mp8/fXX2Lx5M3755Re35zxkyBBMmjQJl156qVCXX6lUCtUUdTpdo0FPCCFNocDvYJWVlW4LoOj1ehQUFCAiIgJisRhhYWH45ptv8OyzzwqjpW+44Qa8+uqrSExM9PlxnE4n7r33Xpw+fRpRUVF46aWX/L5mvnXrVjidTgwZMsSvkeNms1momS+TyRoU6JFKpbDZbHA6nTh37hw4jmv1Fih/mSA1NbVF+z548CAAYOLEiX7dz263Y/v27di4cSN++OEHt0VzBg0ahCuuuAI333wzkpOTYTAY3C7JMAwjrIzIL2lLgU8I8RcFfgdzXYp2z549+PXXX5GYmIj09HTIZDI89thj+OGHHwDUjS5/8803va4378krr7yCnTt3Ijg4GC+++CLi4uL8un9BQQEOHz4MkUjk99zzI0eOAIBwzb4+kUgEhUIBo9GI2tpaaLXaVh8Zzge+L5cBGmM2m4V1A/wN/LvvvhtffPGF8HuvXr0wY8YMXHrppRg2bJgwSBP4t0XPX+7hxcbGUtgTQpqNAr8D8Qvf8F/qx48fh91uR0lJCSZMmIBXX30VP/zwAyQSCR566CE888wzzaqRnpeXh1dffRUAMH/+fAwcONDvfWzduhUAMHbsWL96FrRarTCoT6FQNNq6lkgkwgC+3NzcVg38wsJC/PXXXwDQovXqd+zYAYvFgoSEBL9mJxgMBiHs7777bkydOhWjR49GRUUF7HY7DAaDEPiuQe96EgBAeO+pTj4hpDloHn4Hci2ZyxfSiYmJwcSJE5GcnCyUxwWAa6+9ttlf9Js2bQJQN6r+iiuu8Pv+BQUFyMnJgUQi8Xn1PaBuhgHfIg4KCvJaa58frNiai+WUlZXh+eefh8lkQkZGRrPL4J4+fRorV64EANx///1+XRYIDQ0VejYeffRRXHbZZRCJRDCZTDh37pzbtq7jOupzXQnPdXudTudxe0IIcUUt/E6CZVlcdNFFGDNmjNCymz17Nn755Rds3rwZd911Fw4ePOh36HMch6+++gpAXdW25vjuu+8A1E1Dcx1v4M2xY8dgsVgQFhbm07r3DocDgH/1/Jui0+nw3XffwWq1on///li4cGGzFvixWq145plnYLFYMHLkSGFhG1/JZDJkZmbiwIED+P3333HllVcK0+2ioqJw9uxZKBQKt5M/TwMCXded53XEcriEtAa1Wu11G6VS6bG0OGkeCvwOpNFoUFpaioSEBOG6bf0v7TfeeAO///47CgoKsGDBArz11lt+PcahQ4dw5swZhIaGYurUqX4vxFJcXIyjR49CJBJh6tSpPt/v7NmzOHPmDABgxIgR+OOPP7zepzUDv37YP/300z5Nk/PknXfeQW5uLiIiIvDf//7Xbdqkr8aMGSME/owZM8CyLBISEqDRaMCyLIqLi2EymZCcnNygK5/nWqyJ5+kkgJDOjD+xzcrK8rotwzBQq9UU+q2EAr8DlZaWwmw2o7S0tNEv+aioKHzwwQeYNm0aPvzwQ0ydOhVXXnmlz4+xefNmAMCVV17ZrBYg37ofNmyYz6vL2Ww2oU5Av379fOoV4DhOqCrY0sB3DfsePXq0KOwPHjyIdevWAagrRdzcAXPjxo3DihUrsH//figUCrfj4Wv8G41GHD9+HKmpqY1+HurzdBJASGemUqmgVquFomGNUavVyMrKEqqPkpYL6MA/dOgQjhw5gssuu6zJEqb+4jjO64IwTqcTiYmJOHv2LHr27Cm08gwGA9LT05GYmAiTyYSamhqMHDkS8+fPx+rVq3HPPffg0KFDDUbZ6/X6Bt3VNptNGGx3+eWXo6ysTOg+9ub06dP4+++/cejQIQBAYmIi9u/f32C7yspKoaANr6SkBCaTCVKpFMHBwcjJyYHT6YTZbG7y9QDqrvXX1NSgpqamyeOzWq0wGAwNbq+oqMD+/fths9mE8RC+VORzOp2oqamB1fHv+6YtKcFzzz0HALjmmmuQmZkJo9Ho0+UJm83mth2/wFBeXh5KSkqE9y8sLEwI7MLCQtTW1uK3335DbGwsevTogaSkJCgUCp8+UzwqqkM6O9e6I6T9BGTg22w2zJ07F1u3boVUKsUjjzyCAwcOtOua7hKJpEGxHX4Al1arhUqlEgLSbrfj5Zdfxu7du5GdnY358+dj69atbl/sDMM06Gr+/fffUVFRAaVSiYkTJyIoKAi9evVymwrYmK+//honTpwAx3FISkpqtGV77tw5hIeHC78bjUYhYHv06AGn0wmn0wmbzdZkVzgf+OHh4T5dOqisrMSwYcPcbissLMTzzz8Pm80mdOPX1NRgwIABXvdnt9uRnp4Oi80B/O8oAOCDDz6AwWBAWloaVq5cKRRAcn2+jbHZbG4lkePi4jBw4ED8888/+OKLL3DzzTcjKSkJYWFhwoA+kUiEgwcPwmg0wmg0QiQSISYmBqGhoW1Sm4AQElgCcpT+ww8/jLNnz6KkpARarRaZmZn45ptv/N6PxWJBdXW1209zMQyDCy64AJGRkUhKSkJOTg727dsHjUYDhUIBuVyOzz77DFKpFDt37sT333/vdZ/bt28HAFx99dVu4eMLlmWFuetDhw716T52ux2lpaUA6i5F+HNdmW+9NvdadHZ2Np5//nmwLNvia/a8Xb/8AqlUinfeeadVus3Hjh0LADh8+LDHFQJjY2Nx0UUXITU1FUlJSYiLi3N7PXQ6HU6ePNlmq+MRQrq3gGvhazQarFmzBiUlJcLiJoMHD4bNZsOKFSswaNAgXH755T7ta+nSpViyZEmrHZtri/+7776Dw+FAdXW1MHI7MTERN954I9avX48//vgD06ZNa3RfRqMRP/30E4C6hXX8xXfD9+jRw6dStBzHobS0FHa7HVKp1O/CPnzg+7LgjKvi4mJ8/vnnwpiB1gp73sKFC5s9la++cePG4f3338fx48dhNpthMBgajFeIjY11G4jneqKh0+mo0l4zaTQan64ZE9KdBVzgnzlzBg6HAwaDAfHx8Thy5AjWrVuHIUOGQCwW47HHHsNjjz2G1157zeu+Fi5ciEcffVT4vbq6utUKxvTp0wenTp2CSqWCwWBAQUEBwsPDhYIv3kbb//jjjzCZTEhJScGQIUP8euzKykoUFBQAgM/31ev1Qjd0YmKiXyPZXa9N+9rCZ1kW77zzDvbs2QOO4yAWizFp0iTMnDmzRWHvWtd+9JgxmDt3brP3VR/fwj916hQsFgtKS0sRHR2NoqIiaLVaJCUlISUlpdGpdlRpr3k0Gg0yMjJ8qlXgqeARId1FwAX+qFGjMHToUFx88cUYOXIk9uzZg6VLl+Khhx4CALz22mt44okncPfdd6N///5N7ksmk0Emk7XJcfbv3x/9+/eH3W5HQUEBJBIJiouLhRZwbm5uk/f/7bffAABTp071+9rvL7/8AofDgejoaLelehvjdDqF1lNUVJRfNfpdR+cD8PnSw549e3D8+HEAdbXoZ8+e7VcFwMaOZfHixUBqXengV5a90qwpeI05e/assFLg6dOn0atXLwB1YzbMZjO0Wi1SUlIanWpHi+Y0j16vB8uyWL9+vdcKiTTvm3RnARf4wcHB2Ldvn3ANPC8vTwh7AHjwwQexYMECFBUVeQ38tqTRaIRWHz+tje+ZAOC1FcIHdUlJid+Pzc+HDw8P9+lkQSwWIzw8HNXV1SgvL4dCofBpYBvgPqPBn3AdMGAA8vLyhKCsrq5uceC/+uqr+PLLLzHpubrAT0xMaNH+eCUlJdiyZQsWL14Mh8OBIUOGYMqUKcL7mpSUJLzXAE21aysZGRnIzMzs6MMgpMME5KC90NBQzJgxAwzDoKKiwq2r78iRI2AYBhdddFEHHuG/rb6zZ88iJiYGSUlJkMvlKCwsBOB9EZiLL74YALBv3z4hwH0VFhYGoG7qm68SEhKEkC8pKUFeXh5Onz6NkpISlJWVCS1514DnR/ADdWHvT+CnpKRg2bJlSE5ORkVFBRYvXoxvvvnG56lr9W3btg1vvPFGs+7ryZkzZ/DGG2/gkksuQZ8+ffDEE0/AaDRi/Pjx+OCDD2A2m4UV8VJSUjBu3DikpKS47YPK5hJCWlPAtfBdDR8+HFarFdOnT8crr7wCjUaD++67D2+//TaioqI69Nj4Vh9f7Iaf185PefO2PG1mZibCwsJQUVGB7Oxsv67j88HtuoSrNyKRCAkJCZBIJKioqIDD4RDKx/IaC2ORSNSsrvPExES8/PLLeP/997Fv3z6sW7cOsbGxGD16tF/7+fnnn/HOO+8AAB559FEc9/tI6hQUFGDbtm3Ytm2bsIYAb9SoURg7diwuvPBClJSUoFevXigvL2+yyJDrtfzWGoRICAlcAR348fHx2LRpE26//XYMHjwYsbGxWL16dbNrzvuKZVm3BVA8deGqVCoolUro9Xqh7Or58+eFIPE2VS44OBhjx47FDz/8gD179vgV+M1p4QN1wd2jRw/ExcXBarXCZrMJ/62oqGj0Pi25Ti6XyzF//nyEhobi+++/x65du/wK/IMHD+KVV14BULd2wf333Yd5nx3z+f46nQ7vv/8+tm/f7jaQUiwWY+jQobj66qtx4403IjU1Fbt27QLLsrBYLJBKpV4rClLZXEJIa+p2gW+1WvH555/jzjvv9Gn7qVOnQqvV4syZM0hJSfG4Xntr41tuVVVViIiIaHSxFP7EgOM41NbWora2FufPn4dMJsNFF13kVsmturq6wYC3UaNG4YcffsDu3bsxe/ZsAHWXCrzN4+Z7Efjr403hpw42Jjg4GMHBwaiqqoJIJGq0lc/fznGcUN2vKeHh4Thw4IDwO98Tcvz4cezatUsISYVC0ejMiZycHPz3v/+Fw+HA+PHj8eijj6LK5blUVlVBFuR+MsJxnFtQ33///UINB4lEgosuuggDBw7E8OHDccEFFwjFgTiOg0qlgkajgUqlQmpqKkwmE8rLyxEeHu7Wgs/NzcWpU6fQp08frz059flzSYMK+RASWLpd4D/44INYs2YNTpw4gRUrVjS57YYNGzBlyhRERkZ6vSbemviWGz9oKyQkxOOXb0hICGprawHUfTlv2LABQN30Lr4VzouLi2sQ+P/5z3+wePFiHDt2DDKZDBEREYiOjvbaPcwfi91ux5gxY5psgYtEIp9G8hsMBp8qGf76668+rWin1+vdgpxhGCQmJqKkpASFhYUYNWoUACAiIqJBRT6gLlRffvllWK1WTJw4EStWrEB0dHRdpb3/FxkRAVmw+7FwHCecFFqtVuzatQsA8PLLL2P27NngOA67d+8WLmm4nkAOGDDArepfVVUVOI5rMP2uoKAARqMRBQUFbgNHKaAJIS3RrQbtGQwGfPPNN3jzzTfxxhtvuM2Rr6+srAzz5s3DFVdc4VNt9NbEz/Xlp1k1NiKbDzG+njpfXOayyy7z6XGSk5ORlpYGh8OBvXv3+nx8/MkEx3F+d+t3pEGDBgHwXqNAq9Xi1ltvFcrzrlmzBsHBwX4/3oEDB2A0GhEbG4vLLrsMv/76K7RaLS699FJceOGFXlvnISEhsFgsMBqNbgPz+vbti5CQkFZd34EQQrpV4H/xxRe49dZbMX/+fHz44YdNhn5cXBy+//573HXXXc36sm8vJpMJBoMB1dXVfgc+AEycOBFAXcvZV1KpVGhl8yPJu4KBAwdCLBbj3LlzjV62MBgMuOWWW3Du3Dmkp6fjs88+a/YUuF9++QVAXQW9kydPwmg0Ij8/H0qlUuh9aGqEPcMwCAkJgUwmcxvTkZGRgauuusrrnHFCCPFHtwr82267DY888ggA4K677vIa+mPGjME999zTnofoRqfTQa1WN3lN3WQyweFwQK1Ww2QyIS4uTmjJ+sI18P25vssXFGpqhbvOhmEYoVXcWCv/ySefxKlTp5CYmIjPP/+8RbMx+MAfP348gLoKevzrxrKsMMK+KSEhIQgKCqKBeYSQNtetAj86Otqt+Iqn0NdqtZg/f36z52u3Jr1ej8rKSuTm5jbaEjSZTDhz5ozQuh8/frxfo9rHjBkDmUyGkpISHDvm++hzvlqet/rjnQ0/pZAvDezqs88+ww8//ACRSIRPP/1UGOjXHJ9//jn+/PNPAMCECRMQHh6OCy+8UAh8hmF8CnKFQtHkZR1CCGkt3SrwPXEN/Xnz5uHSSy9F3759O8UAKKVSCYfDgcjIyEZbgmazGQzDCNfVKysr/XoMhUKBK6+8EgDw4Ycf+ny/Pn36AKgr3NMZTo684TgOv/32m3BiVH8a4ieffIKnn34aAHDffff5tGRuYz799FPMmjULHMfh7rvvRmRkpHAtni+eQ0FOCOlsut0ofU/uuusu6HQ6PPXUU1i5ciUefvjhjj4kAO4rowF1Xfz1V0iLiopCeXk5RowYAcD7gDRP7rnnHmzduhVbt27FlVde6VMRl2HDhuH48eMoLS1Fbm5uh5YZbkxtbS20Wi20Wi2Ki4uFKYSTJk1yq5T4wQcf1NXIB3Dvvfdi4cKFzX7MdevWYcGCBQCAO+64A6+99hqys7MRGxsLuVwuDNQzmUwwmUzC+6nT6YSFb6gePiGkIwRE4Gu1Wnz44YedKux5fNEdnU4Hu92OM2fOAIAwij86OhoxMTFITEyESCRCWVkZzp0759OStbzMzEwMHz4cf/31F77//nthTn5TFAoFRo0ahb179+LXX39Fenp6h/aKOJ1OVFZWwmAwwGAwQK/XY+fOnQ22u/zyy4UpeUDdIjv8dg888ACeeuqpZj+Pjz76CM8++ywAYM6cOVi0aBHMZjMSEhJQWlqKhIR/a++zLAuHwyFMudPpdLBarULo8zUW6p/gtZa23j8hpOsJiMD/6KOPcP/993do2Hv7AuZb+izLQiKRQK/Xu7UEGYZBamoq8vPzceLECb8CHwDmzp2Lv/76C9999x1mzpzpU4GhsWPH4sCBA+3Wync6nbBYLMJSu/zrUV1djYqKCrdV9XhxcXFISkpCYmIiVCqVW1Gc33//XZgn/9BDD+GJJ55odti/++67eP755wEAt99+O1577TWYTCZhiqVKpQLLstDr9cJJHN/CBxoubdvYEritpa33TwjpegIi8BctWtTRh9DgC7j+dXGFQgGj0SiMik9MTATHcbDZbEJIXXDBBcjPz8fRo0cxYcKEBvtvKsQvu+wy9OjRA+fOncO3336LSy65pMnjraiogNlsxsCBA3HkyBH88MMPHgsE8SV/vbHb7Th37pzwe2VlJQoLC1FTUyP81NbWegx1XnBwMKKjoxEVFYWwsDCMHj26wfLE/Ot34MAB7Nu3D0Bd2D/44INNrg1gsVjcFvMB+MV9RFi1ahVeffVVAMCsWbPwxBNPQKFQCJdG+PvwrXqWZREZGSmEPcdxUCqVwgqHHMe1edlcKstLugu1Wu11G1rW2DcBEfidQf0vYJFIBJFI5Nby12g0Qp114N8Fc/iQHTJkCLZt24aTJ082CPeoqCiva8nPmzcPS5Yswa+//or58+c32do9f/48IiIiMHjwYDzyyCNCy7X+8qJhYWHCAL+mlJWVYciQIaisrMTGjRvx448/egx3iUSCnj17CgWHEhMTkZycjAsuuAApKSnCMdfU1Lh1obtauXKlEPaPPvoolixZ4vX4lEolQkJCYLbahdtiY2PxytKXhLC/4447MHfuXCiVSkgkErAsK5RF1uv1KCgoQFRUFNLT0xEUFNTk6+u6fkJrXirh9xUSEkJhT7o0pVIJhmGQlZXldVuGYaBWqyn0vaDAbyeNrXFev+XPl9Llb4uMjBS25UvTHj/evPXcZs2ahWXLluHkyZP466+/hIGATQkLC8Pll1+OnTt3Ytu2bbjwwgubFVA2mw1fffUVtmzZIhTzyczMRHp6OuLi4oQfhmE8lsL1BcdxWLFihVBS+amnnsK8efOatS8AWLR4MVYsr1tYZ968eZg5cyYGDhyI0NBQAP/OtWdZFiUlJQD+nVXRFWY2ENKZqVQqqNVqr1OD1Wo1srKyoNfrKfC9oMDvYK4t/5CQEKHbl/+bKz7wc3JyYLVa/V7oJyYmBldddRW2bNmCtWvX+hT4ADBt2jT8/PPPKCoqwksvvYTLL78cw4YN89qjANR1d//555/YunWrsMhO3759ceedd+KCCy5osH1zC/1wHIfly5dj1apVAIBnn30W9957b4tKA6964w0AwIIFC3D11VcjNTXVbYYDwzBCC5+v4+9aB4IQ0jIqlYpCvBVR4Hew+i3/+r0ArnX+k5OTERERgaqqKqjVar+WvOXdeuut2LJlC37++WefAyosLAw333wz1q5di9zcXOTm5iIiIgKXXHIJ5HI5IiMjERkZ6VYQyG63Q61WY8eOHSguLgZQ10WelZXld/GgxlRWVmLnzp04fvw4jh8/LkxZXLRoEebOnev3/mpra7H4+ReByAl1N4hEWLFiBW699VbhfXK9DOH63tEXEyGks6PAbwMsywoV31qTSCTCgAED8Mcff+D222/H6tWrcfHFF/u1j7S0NIwZMwa///47Hn74Ybz//vs+lZe97LLLkJmZid27d2PPnj2orKwUloXdtGkTgoODERsbi7i4OIjFYpw8eVJorcvlcowbNw5z5sxpMMiuOcxmM9atW4fPPvsMVVVVwu1isRiLFy/2adqhp31Onz4dvx84hEnPTQAArF+/Hml9UgC4n4jp9Xro9Xq3gXiujhw5gvz8fKSmpnq8PEFT5gghHYECvw00tWBKU/fxJQQWLVqEW2+9FWq1GpdddhluvfVWLFu2TLiu7Isnn3wSd9xxB44dO4abb74ZH3/8sU8t/ejoaNxwww34z3/+g7///ht//PEHTp06hcrKSthsNpSWlqK0tFTYPjw8HMOHD8eUKVNgMplaHPYOhwPbt2/H6tWrhRH//fr1wxVXXIGBAwciMzPTp6V6Pe337rvvxr59+xAR/W+AS4OlwomLa7Dn5+ejrKwMFRUVHgM/NzcXJpMJarXaY+CXlZWhtrYWoaGhQmU+QghpaxT4baA5rTZf5k1rtVqEhoZi8+bNeO211/DDDz/giy++wM6dO/HMM89g7ty5Pq0lP2DAAHz55ZeYPXs2Tp8+jZtuugkrV670+Zp+UFAQRo4ciZEjR+L48ePo1asXysvLUVZWhrKyMphMJvTv3x8pKSlC131LVt3j15hfuXIl8vPzAQDx8fF46qmncMMNN/j0nJva96OPPoodO3ZAKpVi0aJF+OH/Ow0kEnGzTlLS09OFFj4hhHQWFPhtoDmB78u86dLSUqGb/LXXXsPNN9+M119/HcePH8eCBQvwxRdf4PXXX8fIkSO9Pl5qaio2btyI2bNnIz8/H1lZWbjrrrvw8MMP+x1yEolEKBk7cOBAv+7bFIfDgf/9739Ys2aNUCM/IiIC8+bNwzXXXIPevXu3+DGWLVuGjz/+GCKRCM899xwmTJiAH76uq3Z44YUXora6EjExMW73SUtLQ1RUlMfWPX+/oUOHNjpOIS4ujqbNEULaXbdfPKerYBim0cVWDh06hM8++wxlZWWQy+Xo06cP0tLScMstt+DgwYN4/fXXERERgWPHjuGyyy7Dgw8+CIPB4PUxe/TogY0bN+KGG24Ax3H46KOPcN111yE7O7stnqLPNBoNVq5ciYkTJ2Lu3Lk4fPgw5HI55s6di59//hl33XVXq4wF+Oijj/Dyyy8DAJ544gksXLgQMS6V+mJiYpCenu4W7HxPhUqlajTwvWEYBkajEX///TeKioqa/wQIIcQP1MLvIL7O0+Y4DgUFBbBYLKiursa0adMA1E13+/vvv5GXl4fMzEx88cUXWLVqFX766Sd8+umn+Oabb7B48WLMnDnTbd58/WpzQUFBWLRoES6++GI8//zzKCgowI033oiJEyfiP//5j9fucovFgpqaGq/Pw2KxNNmtb7FYcOjQIezatQu5ubnC7ZGRkZg2bRpuv/12xMXFAYBQ8MaXKXcWiwUOh6PB7d98842wZPLMmTNxww03wOl0Qu4y7a5+5T2gLvD5anpNLULkdDqbrFeg1WphMpmg1Wp9vo7fGVZ4JIR0XRT4HYSvtOdNcHAw+vbtiwMHDiAyMhJVVVVCy/LYsWOoqamBTqfD0KFDcc899+DGG2/EG2+8gezsbDz44IM4fPgw1qxZg+DgYABodBGc3r1745prrsEjjzyC7du346effsL58+exatUqpKWlNXp8w4YNcysO1BiTydSgMh7HcThy5AjWr1+Pbdu2CScOIpEIEydOxMyZMzFlyhSPrXmLxSIsGdwUp9MJuVzudtvevXsxZ84cOJ1OXH311bjpppsQFhYGiUSCUJdudolE0uCEJyQkBCzLIiQkpEGXvevAS4VC0eT7m5SUhOLi4mYNMiSEkOagwO8CxowZg+joaFitVmE6GFBXWz87OxupqalITEwEy7IYO3YssrKysHz5cixevBifffYZzp07h02bNnkdya9UKrF27Vp89dVXeOSRR3Ds2DFMnjwZCxYswJw5c1pl7jwAnDt3Dlu2bMGXX36JnJwc4fZevXph+vTpmDVrVpsF4dGjR3HdddfBYrHgsssuw2OPPYbExESfTh6AujUPGrv27jrw0tsSxCkpKUhJSaGKfISQdkOB30UolUq3sAfqTgTGjBkDoK4lywcyy7K4/vrrER8fj4ceegg//vgjJk2ahB07dngdKCYSiTBjxgz0798fzzzzDHbv3o3nn38eP/30E1auXNns4jIsy2Lz5s3YvHkz9uzZI3SVy+VyXH311bj11lsxduxYmEymNqlhAABbtmzB7NmzYTQaMXr0aLzyyisIDg6G1WqFyWRCTk4OQiO81yRw5dqq93fBGpqPTwhpTxT4nczJkydRWFiIvn37YsCAAcLtjRV5qY9lWWg0GjgcDowdOxbffvstZsyYgb/++gvjxo3DV1995dN0sfj4eKxbtw6ff/45lixZggMHDuDSSy/F4MGDMWjQIFxwwQVudeU9cTgcOHjwILZv344ff/zRrT7ByJEjMWPGDFx//fWIiIjwejwtYbPZsGjRIixfvhwAMGHCBGzatAm1tbXCOvYmkwlWqxUlWq1f+64/p54P7qZa7nzQG41GyGQyWsKWENIuKPDbgT8tucLCQhiNRhQWFroFvj+PJZPJYLFYoFKp0L9/f+zfvx/Tpk1DYWEhJk6ciC+++ALjxo3zui+RSCSUwn300Udx4MABHDp0CIcOHRK2CQoKQmpqKjIyMpCRkYH+/ftDLpfj+++/x7fffouysjJh25SUFMyYMQMzZszwaYW91nD8+HHcf//9OHr0KIC61fNeeuklBAUFQafTISQkBCaTCTExMTAYDODE7v8kXFfEa61Q5rv+gbrXLyQkBDqdDjqdTpjeSAghrY0Cvx34UlSH17dvX6GF7ws+kPhry/z+4+Pjhf/v168f9u/fj6uvvhp///03rr76aqxcuRKzZs3y6TF69eqFr776Cnl5eThx4gROnDiB7OxsnDx5EtXV1cjJyUFOTg62bdvW4L4RERGYMmUKpk2bhmnTprXbSHOz2YxXXnkFK1asgN1uR3R0NObOnYuHH34YVVVVYBhGCHkAKC8vh1KphDhYBqBuHn5uXh5kQXXFd1wvp/Bd93q9HgqFAvHx8UI3vi8nd/z9IyIihMF9RUVFsFgsQugTQkhro8BvB/5c2x0wYIBfLXt+iVaTySSEjKeg6dGjB7Zu3YoHHngAO3fuxPz585GTk4MXX3zRp1XvRCIR0tPTkZ6ejunTpwOo67Y+fPgwSktLoVaroVarkZOTg4qKClxyySW4+uqrMX78eEilUphMpnYL+4MHD+Lee+8VpvdNnToVt912G/r16wetVgupVIrQ0FDhdaqoqEBYWBj0ej1S+vx7ucNmtcJpq+ua50M/MjJSCHt+iqPrtDpfTu5c3yO+6z82NpbCnhDSpijw20FrdQfzrfn6+/U2J5xnNBpx//33Izk5Ge+++y7efvtt5OXl4ZNPPmnWdXSRSISEhAQMGDAAl112md/3b21GoxGLFy/Gu+++C47jEB0djWXLluHOO++EyWQCy7IwGAzCvHyDwSDM5Q8ODm5QUc/hcCCldy9hvfuoqCihCx5Ag0GUgH8nd66oK5+QllGr1V63USqVAb2qJQV+F8K35isrKxEZGQmWZaFUKhss29qY0tJS2Gw2XH/99Rg9ejTmzZuHn3/+GRMnTsTLL7+Myy+/vNWm3rU1juNgMBhw6tQp4Wf9+vVC5brbbrsNy5YtE2oEKBQKKBQKtzXs+ROAnj17Ijo6GhKJBGarXXiMxKQkKJVK5OTkCAEeExMDsVgsVEasjz8Jo+l2hLQP/jswKyvL67YMw0CtVgds6FPgd3Icxwld4XxI8a1K114DjuMaDRm+dcsHUUREBEaNGgWr1YoFCxYgLy8P06dPR//+/TF//nzcdNNNcDqdHivU1edwOHwKN4fD0az9mc1mHD16FKdOncLp06eF/54+fdptaVxeXFwcFixYgLlz5wKom66Yn5+P7OxshIeHY+jQoUJLXqFQCP/vdDobvIb86+U6JdJbBT1CSPtSqVRQq9XQ6/VNbqdWq5GVlQW9Xk+BT1qPL1X0fA0N1xZ3UwuuSCSSRvfJ9wz07NlT2AfDMJg4cSLeeecd7NixA19//TVycnJw//334/nnn8d9992HefPmNejmri8+Pt6nMQB2u92n5xwZGQmO4/DLL79g48aN2L59e5Ole+Pi4pCRkYE+ffogISEB48ePR3p6uts18sLCQpSUlODcuXMICQmBwWCAUql0a6GLxWKIRCL315thIBaL3brbXU/AeEVFRdBqtUhKSnK7nu/L86WTh5bRaDQ+fdGT7k2lUgVsiPuDAr8LaGmBlpCQEBw5cgTnzp3DwIEDhfDiq73NmDEDhw4dwsaNG/Hll1/i3LlzWLRoEV555RXMmjULDz30kE/T6Ph57TU1NUhJSfF6suDK4XBg7969QsiXl5cLf4uPj8egQYPQq1cvJCcnIz09XailL5PJcOmllwpd6Z5enz59+qCqqkoYp8BXLGzONXOTydTgvWhOXXzSchqNBhkZGW7jWhrDMEyzFzsipLugwO8C/JnW5wnDMKioqIDD4cCpU6fQv3//Btv07t0bd999Nx577DH8+OOPWLZsGfLz8/HOO+/gvffew3XXXYdZs2bBbDajpKQEpaWlKC0tFVrOJSUlqK6udttndHQ00tLSkJaWhtTUVKSmpgq/h4aGwul04uDBg9i0aRO2bNmCc+fOCfeNi4vDjBkzcPPNN2P06NENxhZoNBrs378fDMMgOzsbGRkZwt/qz5vnawQAgE6ng16vh8lkwv/+9z8kJSWhV69ewt+0Z8//ux+TCXKpe8ldT+9FUlKS0MIn7Uev14NlWaxfv97t/fck0AdrEQIEeODzg986u+aO/HbFz+/31FIvKipCSUkJEhMTkZCQgDvvvBPTpk3DunXrsGHDBvz999/YsmULtmzZ4vVxwsLCEBoairNnz6K8vBwHDx7EwYMHG2zXs2dPiMVilJSUuN13woQJuOmmm3DllVfCarWC+f9u9fqSk5Nx+eWXIy8vD1KpFBaLBfHx8cLlCz706+O75//3v//BbDZDq9W6Bb7NZQU+o9GI6Aj3wPf0XvA9JaRjZGRkIDMzs6MPg5BOL2ADv6CgABMnTsTXX3+NCy+8sKMPp0mNdVW7Vmfz1F2p0+mg0WjAMAx69eqFjIwMjwPsSkpKYDKZUFJSIgRXTEwMHnnkEVx55ZXYv3+/cI0/NjZWODFISEhAeHg4IiIiEBUVhczMTMTHxwOoa2UXFBQgPz8fR48exYkTJ4QTi/Lycpw9e1Z4blOnTsWkSZMQFRWFiIgIZGRkwGq1wm63Q6PRAECDa+78ba6j7vnXqLGw5/GL25jNZrdWeWxsLCwuLXxPJ1j8SH9CCOlqAjLw+bBfuHBhpw/7puh0OqE6m6fA1+v1qK6uhtFoFMLRk8TERKGFD9QFZm1tLRQKBSoqKiCRSHDrrbdizJgxSE5OBsuyMJlMUCgU4DgOJSUlkMlkbkvJMgyDwYMHY/DgwbjhhhtQVlaG4uJiaLVaREVFgeM4nDp1CgMHDkR4eDhMJhN0Oh3kcrnwXPjHkUgkHq+56/V6YfQ8/9xcQx+Ax/oELMuiZ8+eSE5OdttnbGwswiKigG/qTjIYH2obEEK6lkCerx9wge8a9vfeey+AukFXp0+fxoABA/waaGaxWIRqawAaXMNua96qsymVSqG1y7dWPQ06q98lzV+nNplMQqvbdU15k8mEmpoaGAwGJCYmQqVSeWxVu9ahVygUQhe9zWZDYmIiUlJSYDKZEB0dDQAN5snHxsaCZdlGr4/r9foGSwbzj8t363sKfNfHIIQEBpqvH2CB73A4cPXVV6NPnz645557YDabcc8992Dt2rXgOA4ymQzPP/88nnzySZ/2t3TpUixZsqSNj7px9aeLNfV3ni8DAENCQoQWflJSkhCarvPXDQYDpFIpzGYzYmNjwTAMfv31Vxw7dgxDhgzBxIkT3YI3MjISffv2RUlJCcxmM6RSqbB/Hl/bnr8Pf5LSWBVAT0sGA94DnWVZt/u5FuJxHbRHCOk+aL5+gAW+RCLB+++/j2nTpuGBBx5AWVkZrFYr8vPzERoaiuXLl2PBggWIjY3FnXfe6XV/CxcuxKOPPir8Xl1djeTk5LZ8Ci3mywBAhmGE+vf8SnKu4ckwDJKSkmAymdxa/seOHUN1dTWOHTuGiRMnNghefj/8gjWeAlmhUAi9JjqdrskpV40tGeypVr2r+j0D/AlG/UF7hJDuJdDn6wdU4APA+PHj8d1332HatGlITEzE8ePHIZVKAQCvvfYaNBoNXn31VZ8CXyaTQSaTtfUhtypfB51xHAeTySR07SsUCpSXl8NgMCAmJgbR0dFQKBRChToAyMzMRHZ2Ni644AK3qnUcx8HpdEIikQjjA3Q6HUwmk1sPAn98/EI2drvdbX69a3h7KoDjK9eegfqXECzUwieEdFMBF/jAv6H/66+/CmHPmzJlCvbs2dMxB+aBr6HW2tvZbDahdR0ZGYmgoCBhhTi9Xo+4uDgA7sE7YcIETJgwQdiHwWBATU0NwsLCoFKpIBKJEBYWhry8PJhMJpw/fx5KpRJhYWENHt91CVlPJygikcingkSeqh7GxcUJxw8AoaGhwn/DI6OFQXue7kuV8QgJDN1xcF9ABj5QF/pjx45tcPuff/7ZKVZ+62hGoxEymQxBQUFCmLbGEq4Mw6B///44c+aM22BCT9t564loaUEiQgiprzsP7gvYwAfQoKDLhx9+iG3btuHQoUMddESdh6dr/f4u4apUKlFQUIC//voLgwcPFoqjtNZSsK1RkIgQQlx158F9AR34vO3bt2PZsmWQy+XYt29fl3nz2pIvLWxvQkJCcP78edhsNuTm5nqthubvmgGtcYyEEFJfdx3c1zUWP/fDqVOncMMNN6CystLn+1x22WXYsmUL9uzZg7S0tLY7uG6IH91uNBrdbtfpdFCr1YiPj0dISAjS09O97su1i54QQkjr6naBf9ddd+HHH3/EFVdc0WToW61WzJw5E4cOHUJoaKhQZY74x3WuvSt+6ltCQsL/tXenYU2daRiA37AWiMgSlU3rihV1XIaKWwV0FKsoKo5SN6x1o+I62tZlFKeD01pal0t7ueAoaq3iSF1ALSq1ZbSMoCIuFbdWE5SIAmICignP/HDImCYR1JCTmPf+Zc45hAdMeM7y5Ts0atSoWs1o6OLiQnZ2dnyKnjHG6sBrdUr/0qVLVFhYSFlZWdSnTx/q168fpaen671BTnl5OV28eJGioqIoPz+f7O3tTR/4NWBokhtDk+LU9Fx8ip5Vy83N1XyCQh++zz0zB5Y0mv+1KvzMzEyKjY2ldu3aUUZGBvXu3dtg6bu5udHRo0epoKCAy/4VGBppb6yBecx6BQcH17gN3+eeCeVFR/OnpKQY5W+iQqF46a99rQp/ypQpVPm/mdLatm1rsPSfPHlC9vb25OHhoZnHnTFmXjZs2EB//OMfn7uNuRw5MetT29H8RUVFNGzYMOrfv7+Jkhn2WhU+EWlNpKOv9E+cOEF/+9vfKCsry+iTqFTPBGfqm+jUBX1T0hrarqbfo1KppIqKCsFO2b/I//OjShWpHj0dj1BWVkaVDq/dW0Qw1e+Lml5b1ev9/PyoZcuWtX5e9nz82jY+Nzc3vZeMn9WyZUs6deqUZkrxV5Wbm0szZ86s9d/oZ4nwMl9lYS5evEi9e/cmiURC9+/fp9TUVAoMDDT695HJZGY/lz5jQpNKpXrvfliN30eM1aym95E+VlH4RESrV6+mJUuW0JEjR+qk7ImIqqqq6Pbt21SvXj2jnj2ovimPVColV1dXoz1vXePcpmXuuQHQw4cPycfHR2fSq2e9zPvI3H92fSwts6XlJXo9M9f2faSPVZzTSUtLo2XLltVp2RM9nbnvRfe4XoSrq6vFvGifxblNy5xzG7rV8bNe5X1kzj+7IZaW2dLyEr1+mWvzPtLntfscvj4qlarOTuMzxhhjlsAqjvAjIiKEjsAYY4wJyiqO8C2do6MjLVmyhBwdHYWO8kI4t2lZam5jsMSf3dIyW1peIs78e1YzaI8xxhizZnyEzxhjjFkBLnzGGGPMCnDhM8YYY1aAC58xxhgzMw8ePKCKigqjPicXPjOptLQ0OnjwoNAxrIZMJqPPPvtM6BgmoVarKS4ujkpKSoSO8kIuX77Mt/qtY3v27HmpueeF8uDBAwoLC6OFCxca9Xm58C3Qnj176K233iInJycKCQmho0ePCh2pVtLS0mj8+PHk7u4udJQXkp+fT3369CEnJydq3bo1rVy5ktRqtdCxaiSTySg0NFToGCahVqspOjqaMjMzLeYjWEVFRRQWFkZt2rShgIAAmjFjhtCRapSenk75+flCx3ghy5Yto+HDh9PUqVMtovSry14ul9OmTZvo4cOHxntyMIuSmpoKHx8ffPfdd0hPT8egQYNARJg/f77Q0Z4rNTUVEokEJ0+eFDrKC5HL5fD29sby5ctx8uRJfPzxx3BwcEBwcDCKi4uFjmeQVCpFy5Yt8Y9//EPoKHVOpVJh9OjR6N27N5RKpdBxaqW8vBwdO3bEnDlzcO/ePWzevBlEZNavqfz8fDg6OsLLywuXL18WOk6txcbGIiwsDLa2tpg8eTKqqqqEjmRQaWkpgoKCEBMTA5lMBnt7e6xevdpoz8+Fb2G6d++OxMRErWUrVqyASCTC3LlzBUr1fKmpqXB3d9eUfXFxMebPn4/g4GBERUXh1KlTAic0bNmyZRgyZIjWsqysLEgkEgQGBkKhUAiUzLDqso+PjwcAqNVqJCYmIiwsDP3790dSUpLACY2nuux79eqlKfuTJ0/ivffeQ3BwMBYuXIgHDx4InFJXQkICgoODNY+rqqrg5eWFc+fO4ccff8SjR4+EC2fAjBkzMH/+fHTq1MmiSn/NmjWYPXs2vv32W63Sv3XrFlQqldDxNJ4t++qdkjFjxqBVq1ZG20nhU/oWpqioiFQqldayWbNm0Zo1ayghIYH27NkjUDLD7ty5Q2VlZXTx4kWSyWQUGBhIOTk51KVLF7pw4QL16NGDDhw4IHRMvfT9voOCgujYsWN09epVio2NFSiZYaWlpVRaWkq5ubn0+PFjGjlyJH3xxRfUrl07srW1pejoaJo+fbrQMY2isrKSbt++Tbdu3aKioiLavHkzDRgwgOrXr6+5/NKjRw8qLS0VOqqWnJwc8vT01DzevHkzlZSUUHh4OPXp04c6duxIMplMwITa1Go1paSk0Lx58+jo0aPk7e1NISEhFnF6/6233qILFy5QVFQUbd++nTZt2kSjR4+m7t27U2ZmptDxNHbv3k2dO3emtWvXau4SOXv2bLp69arxxj0ZZbeBmczEiRPRpk0bvUcAY8eORcuWLQVIVbP169fD1tYWLVq0wNKlSzXLHz9+jAEDBqBBgwaoqKgQMKF+e/fuhZ2dHc6dO6ezbteuXRCJRLh06ZIAyZ4vLy8PEokErVq1Qq9evbR+tytXrgQR4fjx4wImNB6lUonQ0FA0adIEEolE68jzwoULEIvFmDVrloAJdSUlJUEkEuH999/H+++/D7FYjGPHjgEArly5Al9fX0RGRgqcUtvFixc1/75//77FHOnLZDL4+PhoHi9fvhxEhNDQULM+vV/tnXfeQd++fY3yXFz4Fub69etwcXHBuHHjdF6sV65cARHht99+Eyjd/z18+FBn2fr169GwYUOd02jnz58HESE7O9tU8WpNrVYjKCgIrVq1QlFRkc56f39/rFmzRoBk2qRSKQYNGoTKykrNsurSP3HihM72TZs2xZIlS0yYsG5Vl/68efN01s2cORMdOnQwfagaJCcn46OPPkJUVJTOGJwvv/wSjRs3FihZ7egr/fj4ePz73/8WOJkuV1dXFBcXIz8/H35+fpgyZYpFXNMHgJSUFBARLly48MrPxaf0zVhOTg5FR0dTZGQk/ec//yEioubNm9PmzZtp+/btNHHiRHry5Ilmew8PD7KxsSGxWCxUZCJ6Ohq/efPm9PPPP2stnzx5Mu3bt49sbW21ljs6OpJIJCJvb29TxtSRn59PgwYNos6dO9PVq1eJ6Om92Xfu3EkKhYJCQ0OpoKBA62s8PDwEv8929Wj8AwcO0O7duzXL27dvTxkZGdSxY0edr3FwcCBfX18Tpqxbzs7OlJqaSmPHjtVZ5+joaJY/65///Gf6/PPPSalUkpOTk9Y6uVxOnTp1EihZ7Xh4eGid3p8+fTrt3LmT/P39hY6mw9/fn1JSUqhPnz4UHx9P69at05ze37Fjh9DxnisiIoKaN29Oq1evfvUnM8IOCKsDSUlJkEgkmDp1KoKCglCvXj2UlJRo1u/YsQOOjo7o0qUL0tPT8csvv2DIkCGYMGGCcKH/Z+DAgfDy8oKrq2utRuWPHz8eI0aMMEEyw+7duwcfHx+sXbtW7x7/5cuX0bRpUzRo0AAbNmzAtWvXsHz5cjRv3lzQgXvPjsbv168funTpUuPX/Otf/4K3t7dZDmYzttu3b6Nhw4ZIT08XOopBH330Edzc3JCZmYmqqirs3r0bEonELC8V6XP//n14eXmhffv2uHv3rtBx9Prggw9gZ2enM2A1KyvL7I/wgaeX4ZycnHD//v1Xeh4ufDN07do1NGrUSHOaTKlUwtXVVecPQF5eHgYMGAA7Ozu88cYbiI2NNYvRvXPmzEFCQgL+9Kc/GSx9lUqF7OxshIeHo0ePHigtLRUg6f/Fx8cjIiJCa1llZSVu3rwJtVoN4Oko2unTp6N+/foQiUQICQnBr7/+avqw//P7j94dOnQIRISff/5Z7/bXr1/H4sWL4efnh6ysLFNGNbni4mJ8++23aNy4MRISEoSO81xlZWXo2rUriAhOTk7w9fW1qI+vxsXFmXXZA0BJSQn27dsndIyXVlZWBk9PT4Pv7driwjdDn3zyCb766ivNY7lcDolEgiFDhuDtt9/GqlWrtLavrKzEkydPTB3ToA0bNiAmJgbl5eWa0j927BgGDx6sGfx248YNjBkzBlu3btUUqpBGjRqFmTNnah4nJibC3d0dRIQmTZpoXZesqqoSfMfq8ePHaN26tdbn7KuqqtCmTRtERUXpbF9ZWYnY2Fh89tlnuHfvnimjvrLqncMXsXHjRsyaNQtnz56tm1A1kEqlkMlktd5epVIhPT0dBw4cQHl5eR0mM+zq1auYNm0awsPD8fXXX9fqyFculyM0NFSwsj906BCioqIwYsQI/PTTT4JkeBGVlZVYtWoVBg8ejJiYGBQUFNT6a2/evPnK358L3wx99dVXKCwsBPB0go6QkBAEBQVh48aNmDlzJkQikVkMFDPkp59+wjvvvAMAmtInIoSHh5tFuevzl7/8BQEBAaiqqsKuXbvw5ptv4uDBgzh9+jRCQ0Ph5uamd9CekJ4dNV1t/fr1sLOze6GyMXeTJk2Co6Mj0tLSatzWHAZ+KpVKtGjRAi1btqzx/0GtVuPMmTMmSmZYRkYG3NzcMHbsWAwfPhwikQh///vf9W57584ds3h9LV68GN7e3oiJiUGXLl1gZ2eHnJwcvduePXtW8M/cK5VK9OzZE4GBgZg2bRq8vLzg7+9vcAevLl7LXPhmLiUlBVFRUVqjr6dMmYJOnToJmOr57t69Cw8PDwBPC79v375o2LBhra/pCyEnJwdEhDVr1qB79+5aRwulpaVwcXHBjh07BExYO+Xl5fD09DT7mRdrSyqVws/PDyNGjKix9C9evAhbW1vMnj3bhAl1bdiwAQMHDqxV6SckJNR6Z6aulJeXw8fHRyvDvHnz4OLiovV3p1pISEitdmbqUmZmJnx8fDQHRiqVCu3atcPQoUN1tpXL5XBxcUFUVJSgpf/xxx9j6NChmoOey5cvw97eHps2bdLZdufOnbCxscE///lPo2bgwrdAK1asQLdu3YSO8Vyenp64fv06+vbti3HjxkGhUGhO75vDUZg+MTExcHBwgKurq86pNi8vLxw6dEigZC9mwYIF8PT0FOzUsDH99a9/RVxcHFQqVa1Kf9myZYiLizNhQl2dOnVCTk4OpFJpjaVfXl6OiIgIQedE2LZtG0aNGqW17NKlSyAi5Ofn62x/6dIl9O3bV9Br9iNHjtTZAV++fDlatWqld/stW7ZgypQpgg3Qq6yshJeXl85Zwl69eundQVWpVIiOjsbu3buNmoML38I8evQIHTp0wIYNG4SO8lzdu3dH06ZNMW7cOM0ebXl5OWJjY832GvKTJ08QGRkJIkJ0dLRmXMQXX3yBtm3b6j3aMUcFBQWwt7fHxo0bhY7yyk6cOIE7d+4AQK1LX2h79uzR/Ls2pS+05ORkHDlyRGuZUqkEEemdcMoczJgxQ2eirl27dpnt3AWlpaV654gYO3YsYmJiTJaDC9+CyOVy9O/fH8OGDTP7j5Ls3bsXH3zwgdleszdErVYjPj4ezs7OaNKkCQICAhAQEIAbN24IHe2FjBkzBkFBQULHMDp9pS+Xy7Ft2zaBkxmmr/QzMjLM4tq9IWq1GkSkNegxOTnZrAYH/96+ffvg6+ureaxQKMx+ZP6kSZMwZcoUzeO8vDycP3++zr4fT7wjkKtXr9K6desoOTmZFApFjdvPnTuXevfuTX369KHdu3dr5lo2tcLCQkpMTKStW7dSUVGRwe0iIiIoMTGRbGzM4yVWVlZGSUlJtGnTJrp165bB7WxsbGjBggUkk8lo7dq1tGrVKjp37hw1a9bMhGn/7/Hjx5ScnEzr1q17oXumz507lxISEuowmTBsbW1px44dFBERQcOGDaOkpCQKDQ2l3377TehoBvn5+dHx48cJAIWEhNA333xDUVFRpFQqhY5mUPX7tqqqioiIli5dSp9++imVlZUJGeu5bGxsNHmVSiUNHDjQeHPQ15FnM58/f57CwsI0k37ViTrblWAGbdq0CfXr10fPnj1Rr149SCQSJCcn6922+gjZHOaZP3LkCNzd3dG9e3c0aNAAzs7O+PLLL/Vua05H9ufPn4ePjw/efvttNG7cGHZ2dpg7d67eU/TmlPv27dsICAhA+/bt4e/vDyLCmDFj9E6YY065TUGlUmkuv3z66adCx6kVqVSKN998E2KxGJmZmULHqRERIScnxyI+Zw88vSunl5cXFAoFgoODMWnSJLM/Ezp16lRMnDgReXl58Pb2Nvo1+9/jwjexK1euoH79+prBMCUlJYiOjgYRYfny5Vrb5uXlISAgQO/Hr0zt4cOH8PT0xNGjRwE8HUuwaNEiiEQiTJw4UeuNdefOHXTo0EHnuqBQ2rZti3Xr1gF4Woxr166Fo6MjwsLCtHaklEolevXqZfSRsS9r8ODBWrc83rNnD9zd3dGxY0etwT9VVVUYPXr0azMyvzbkcjkCAgIspuwB4NixY2jYsKFFlD0AiEQiDBs2zCLKHgDS0tLg4eFhMWUPPB0o3LNnT5OUPcCFb3Jff/01evbsqbN88eLFICJs3bpVs6ygoACtWrXC+PHjTRlRr4yMDEgkEp3l27Ztg42NDRYsWKBZplAo0KtXL3Tt2lXwN92tW7dARDoz+f3www9wdnbGyJEjNctUKhVGjRqFJk2aaO6tLiQHBwedzxVfunQJXl5e6Nq1q9YZiiVLlkAsFgs6858pjRw50qLKXqlUonnz5hZT9gBgb29vMWUPAN9//z2IyGLKHgCmT58OOzs7k5Q9wIVvcrt27UK9evX0TiU7depUiMViyOVyzbLCwkLBZ3UDgHPnzoGI9J5tWLlyJUQikdbH7RQKxSvP+2wMDx48gK2tLfbv36+zbv/+/RCJRNi1a5dmmUqlMpvR1N7e3lozLlY7c+YMnJycEB8fr7XcGDNxWQpL/MihpWVOSkqymLIHnp51XLNmjcWUPfB0dsO9e/ea7PuJAKDuRgiw31MoFNSsWTMKDw+nzZs3a62rqKigFi1a0Jw5c2ju3LkCJdQPAHXu3JnEYjH98MMPZGdnp7W+W7du1LZtW0pMTBQooWHDhw+n3NxcOn36NNWvX19r3dixY0kqldLx48eFCfccn3zyCa1fv57Onj1LTZs21Vq3dOlS2rhxI8lkMmHCMcYsjnkMobYiYrGY1q5dS1u2bKGlS5dqrXNycqIBAwbQzZs3BUpnmEgkoo0bN1J2djaNHz+e1Gq11vrIyEizzE1EtGLFCiotLaWIiAidkdHmnHvRokXUsGFDevfdd6mwsFBrXWRkJBUUFJBKpRIoHWPM0nDhC2DEiBH0+eefU1xcHH344Yf06NEjIiJSqVSUm5tLXbt2FTihfoGBgfTNN99QcnIyDRkyhIqLizXrsrOzzTZ348aNKTU1lc6ePUuhoaFaBW/OucViMR06dIgUCgX16NGDzp49q1mXnZ1NgYGBOmdaGGPMED6lL6CkpCSKjY0ld3d3evfddyknJ4eaNWtGycnJZvP5dX2OHTtGY8aMocrKSoqIiKBbt25RWVkZZWRkkFgsFjqeQXl5eTRixAiSSqU0ZMgQqqiooNzcXMrMzCRfX1+h4xkklUopKiqKTp06ReHh4SQWi+nIkSN0+PBh6tixo9DxGGMWggtfYHK5nLZu3Uo3b96kbt260XvvvWfWZV9NoVDQtm3b6MKFC9S2bVuaMGECvfHGG0LHqlFlZSUlJydTVlYWNWnShCZNmkTu7u5Cx6oRADpw4ABlZGSQm5sbTZw4kfz8/ISOxRizIFz4jDHGmBUw/0NJxhhjjL0yLnzGGGPMCnDhM8YYY1aAC58xxhizAlz4jDHGmBXgwmeMMcasABc+Y4wxZgW48BljjDErwIXPGGOMWQEufMYYY8wKcOEzxhhjVoALnzHGGLMCXPiMMcaYFeDCZ4wxxqwAFz5jjDFmBbjwGWOMMSvAhc8YY4xZAS58xhhjzApw4TPGGGNWgAufMcYYswJc+IwxxpgV4MJnjDGmY//+/fTrr78KHYMZERc+Y4wxHR9++CH9+OOPQsdgRsSFzxhjjFkBLnz2Wti/fz8NHTqUDh06ROPGjaPQ0FBasGABVVRU0MGDBykyMpL69etHK1asIABCx2XMYhQWFtLhw4cpMzOTqqqqhI7DXoGd0AEYM4a7d+9SWloaFRQU0MKFC+nx48cUGxtL6enp5ODgQPPnz6eHDx/StGnTyMXFhSZPnix0ZMbM3vbt22nRokX0hz/8gU6fPk2tW7emw4cPk7Ozs9DR2EvgwmevDZVKRd999x35+voSEVFubi4lJCRQQUEBNWjQgIiIsrKy6MCBA1z4jNXCL7/8QmfOnKFGjRpRUVERde7cmVatWkXz588XOhp7CXxKn702vL29NWVf/bhx48aasq9eVlhYKEQ8xizOuHHjqFGjRkRE1KBBA5owYQIlJycLnIq9LC589tqwt7fXeiwSifQu42v4jNVO06ZNtR43a9aMbt68KUwY9sq48BljjOlVUlKi81gikQiUhr0qLnzGGGN67du3T+uMWEpKCvXo0UPAROxV8KA9xhhjel27do2GDh1KAwYMoO+//57y8vJoy5YtQsdiL0kEvqDJXgNFRUUkk8moU6dOmmVyuZwKCwupQ4cOmmW3b9+m4uJiateunRAxGbMY06ZNo+HDh9ONGzcoOzubnJ2daerUqeTv7y90NPaSuPAZY4wxK8DX8BljjDErwIXPGGOMWQEufMYYY8wKcOEzxhhjVoALnzHGGLMCXPiMMcaYFeDCZ4wxxqwAFz5jjDFmBbjwGWOMMSvAhc8YY4xZAS58xhhjzApw4TPGGGNW4L9o2OwyJkLtRgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -1380,118 +2529,1029 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 39, "id": "30e58a3f-a243-4ce9-bc27-b0336f1c596b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:29.013063Z", + "iopub.status.busy": "2026-08-11T03:09:29.012906Z", + "iopub.status.idle": "2026-08-11T03:09:29.220335Z", + "shell.execute_reply": "2026-08-11T03:09:29.219575Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'option 3: systematic included correctly')" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predictive_post(\n", + " walker=walker3, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", + ")\n", + "plt.title(\"option 3: systematic included correctly\")" + ] + }, + { + "cell_type": "markdown", + "id": "b367eb21-44ab-4146-bbf6-8ad8d0806f67", + "metadata": {}, + "source": [ + "## Run option 4: incorrect formulation of the systematic error" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d731b920-451d-4884-aa1a-9fbdb6db2361", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:29.221844Z", + "iopub.status.busy": "2026-08-11T03:09:29.221671Z", + "iopub.status.idle": "2026-08-11T03:09:29.224360Z", + "shell.execute_reply": "2026-08-11T03:09:29.223751Z" + } + }, + "outputs": [], + "source": [ + "walker4 = rxmc.walker.Walker(\n", + " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", + " params=my_model.params,\n", + " starting_location=prior_distribution.mean,\n", + " proposal=proposal_distribution_model,\n", + " prior=prior_distribution,\n", + " ),\n", + " evidence=evidence_sys_wrong,\n", + " rng=rng,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "cc8396c2-f7de-4047-92ff-a7e4e30c782d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:29.225791Z", + "iopub.status.busy": "2026-08-11T03:09:29.225632Z", + "iopub.status.idle": "2026-08-11T03:09:32.595207Z", + "shell.execute_reply": "2026-08-11T03:09:32.594603Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/1 completed, 10000 steps. \n", + " Model parameter acceptance fraction: 0.735\n", + "CPU times: user 3.37 s, sys: 40.1 ms, total: 3.41 s\n", + "Wall time: 3.37 s\n" + ] + } + ], + "source": [ + "%%time\n", + "walker4.walk(n_steps=10000, burnin=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "6b19450a-7289-4441-ac48-89ebaa03575c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:32.596660Z", + "iopub.status.busy": "2026-08-11T03:09:32.596527Z", + "iopub.status.idle": "2026-08-11T03:09:32.881801Z", + "shell.execute_reply": "2026-08-11T03:09:32.881124Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_chains(walker=walker4, model=my_model, true_params=true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "fce5ffbc-b15c-4fc8-89ab-0d4a5e92dcc3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:32.883231Z", + "iopub.status.busy": "2026-08-11T03:09:32.883080Z", + "iopub.status.idle": "2026-08-11T03:09:33.130689Z", + "shell.execute_reply": "2026-08-11T03:09:33.130095Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_posterior_corner(walker=walker4, true_params=true_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "647aa074-8511-4a2c-843f-4c11424938e1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:33.132085Z", + "iopub.status.busy": "2026-08-11T03:09:33.131944Z", + "iopub.status.idle": "2026-08-11T03:09:33.339384Z", + "shell.execute_reply": "2026-08-11T03:09:33.338730Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'option 4: systematic included incorrectly')" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_predictive_post(\n", + " walker=walker4, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", + ")\n", + "plt.title(\"option 4: systematic included incorrectly\")" + ] + }, + { + "cell_type": "markdown", + "id": "09070172", "metadata": {}, + "source": [ + "## Run option 5: an additive offset systematic\n", + "\n", + "A different systematic: the whole dataset is shifted by one unknown **additive\n", + "offset** (think background mis-subtraction), rather than rescaled. The reported\n", + "offset uncertainty $\\omega$ enters as a rank-one mode with a constant basis,\n", + "\\begin{equation}\n", + "\\Sigma_{ij} = \\delta_{ij}\\,\\sigma_{stat,i}^2 + \\omega^2 ,\n", + "\\end{equation}\n", + "via `offset_term(support, magnitude=...)`. With `parameter=` instead of\n", + "`magnitude=`, the magnitude becomes a free nuisance ($\\omega = e^{\\theta}$),\n", + "exactly parallel to options 2 and 2b. As with the normalization bias above, we\n", + "shift the data by one standard deviation of the reported offset error, and\n", + "compare accounting for it against ignoring it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "aa75c73f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:33.340864Z", + "iopub.status.busy": "2026-08-11T03:09:33.340718Z", + "iopub.status.idle": "2026-08-11T03:09:33.345858Z", + "shell.execute_reply": "2026-08-11T03:09:33.345285Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "free-offset constraint has 1 nuisance parameter(s)\n" + ] + } + ], + "source": [ + "offset_syst_err = 0.3\n", + "# one common additive shift, chosen 1 std deviation of the offset error above 0\n", + "delta = offset_syst_err\n", + "y_exp_off = y_true + rng.normal(scale=noise_fraction * y_true, size=len(x)) + delta\n", + "y_stat_err_off = noise_fraction * y_exp_off\n", + "\n", + "obs_offset = rxmc.observation.Observation(x=x, y=y_exp_off, y_stat_err=y_stat_err_off)\n", + "obs_offset_ignored = rxmc.observation.Observation(\n", + " x=x, y=y_exp_off, y_stat_err=y_stat_err_off\n", + ")\n", + "\n", + "evidence_offset = rxmc.evidence.Evidence(\n", + " [\n", + " rxmc.constraint.Constraint(\n", + " [obs_offset],\n", + " my_model,\n", + " extra_terms=[\n", + " rxmc.covariance.offset_term(support, magnitude=offset_syst_err)\n", + " ],\n", + " )\n", + " ]\n", + ")\n", + "evidence_offset_ignored = rxmc.evidence.Evidence(\n", + " [rxmc.constraint.Constraint([obs_offset_ignored], my_model, likelihood)]\n", + ")\n", + "\n", + "# the free-nuisance spelling of the same mode (constructed, not fit here)\n", + "log_omega = rxmc.params.Parameter(\"log omega\", float, latex_name=r\"\\log{\\omega}\")\n", + "free_offset = rxmc.constraint.Constraint(\n", + " [rxmc.observation.Observation(x=x, y=y_exp_off, y_stat_err=y_stat_err_off)],\n", + " my_model,\n", + " extra_terms=[rxmc.covariance.offset_term(support, parameter=log_omega)],\n", + ")\n", + "print(f\"free-offset constraint has {free_offset.n_params} nuisance parameter(s)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "fd5dc9b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:33.347138Z", + "iopub.status.busy": "2026-08-11T03:09:33.347009Z", + "iopub.status.idle": "2026-08-11T03:09:40.111772Z", + "shell.execute_reply": "2026-08-11T03:09:40.111052Z" + } + }, "outputs": [ { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 3: systematic included correctly')" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 1/10 completed, 100 steps.\n", + "Burn-in batch 2/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n", + "Burn-in batch 4/10 completed, 100 steps.\n", + "Burn-in batch 5/10 completed, 100 steps.\n", + "Burn-in batch 6/10 completed, 100 steps.\n", + "Burn-in batch 7/10 completed, 100 steps.\n", + "Burn-in batch 8/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n", + "Burn-in batch 10/10 completed, 100 steps.\n", + "Batch: 1/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 2/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.760\n", + "Batch: 3/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 4/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 5/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 6/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 7/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 8/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.720\n", + "Batch: 9/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 10/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 11/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 12/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 13/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.730\n", + "Batch: 14/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.790\n", + "Batch: 15/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.760\n", + "Batch: 16/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 17/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n", + "Batch: 18/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 19/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 20/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.690\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 21/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 22/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.880\n", + "Batch: 23/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 24/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 25/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 26/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.860\n", + "Batch: 27/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.770\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 28/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.760\n", + "Batch: 29/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 30/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 31/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n", + "Batch: 32/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 33/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.860\n", + "Batch: 34/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 35/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.790\n", + "Batch: 36/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 37/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 38/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.770\n", + "Batch: 39/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 40/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.730\n", + "Batch: 41/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 42/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 43/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 44/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 45/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 46/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 47/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 48/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 49/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 50/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 51/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.710\n", + "Batch: 52/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 53/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 54/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.730\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 55/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.730\n", + "Batch: 56/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 57/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.860\n", + "Batch: 58/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.830\n", + "Batch: 59/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 60/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n", + "Batch: 61/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 62/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 63/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.790\n", + "Batch: 64/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 65/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.850\n", + "Batch: 66/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 67/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.760\n", + "Batch: 68/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n", + "Batch: 69/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 70/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.720\n", + "Batch: 71/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.770\n", + "Batch: 72/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n", + "Batch: 73/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 74/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 75/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.730\n", + "Batch: 76/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 77/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 78/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 79/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 80/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.880\n", + "Batch: 81/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.710\n", + "Batch: 82/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.850\n", + "Batch: 83/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.810\n", + "Batch: 84/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 85/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.740\n", + "Batch: 86/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.790\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 87/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.860\n", + "Batch: 88/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Batch: 89/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.760\n", + "Batch: 90/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.790\n", + "Batch: 91/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.750\n", + "Batch: 92/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.840\n", + "Batch: 93/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.780\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 94/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 95/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 96/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.870\n", + "Batch: 97/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.820\n", + "Batch: 98/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.750\n", + "Batch: 99/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.770\n", + "Batch: 100/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.800\n", + "Burn-in batch 1/10 completed, 100 steps.\n", + "Burn-in batch 2/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n", + "Burn-in batch 4/10 completed, 100 steps.\n", + "Burn-in batch 5/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 6/10 completed, 100 steps." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Burn-in batch 7/10 completed, 100 steps.\n", + "Burn-in batch 8/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n", + "Burn-in batch 10/10 completed, 100 steps.\n", + "Batch: 1/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 2/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.350\n", + "Batch: 3/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 4/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "Batch: 5/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 6/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 7/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 8/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 9/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + "Batch: 10/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.360\n", + "Batch: 11/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 12/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 13/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n", + "Batch: 14/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 15/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 16/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + "Batch: 17/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.540\n", + "Batch: 18/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 19/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 20/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 21/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 22/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + "Batch: 23/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 24/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 25/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 26/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 27/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 28/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 29/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 30/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 31/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n", + "Batch: 32/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 33/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + "Batch: 34/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 35/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.510\n", + "Batch: 36/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 37/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 38/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 39/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 40/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 41/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + "Batch: 42/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.520\n", + "Batch: 43/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + "Batch: 44/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 45/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n", + "Batch: 46/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + "Batch: 47/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.540\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 48/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "Batch: 49/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.330\n", + "Batch: 50/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n", + "Batch: 51/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + "Batch: 52/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + "Batch: 53/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 54/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 55/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.380\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 56/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 57/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 58/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 59/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 60/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n", + "Batch: 61/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 62/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 63/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "Batch: 64/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 65/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 66/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 67/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 68/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "Batch: 69/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.520\n", + "Batch: 70/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 71/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 72/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.520\n", + "Batch: 73/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 74/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + "Batch: 75/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n", + "Batch: 76/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n", + "Batch: 77/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 78/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.490\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 79/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.360\n", + "Batch: 80/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 81/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 82/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.480\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 83/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n", + "Batch: 84/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n", + "Batch: 85/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + "Batch: 86/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.450\n", + "Batch: 87/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.420\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 88/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 89/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "Batch: 90/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 91/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.460\n", + "Batch: 92/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.340\n", + "Batch: 93/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.370\n", + "Batch: 94/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + "Batch: 95/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 96/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.430\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 97/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.410\n", + "Batch: 98/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 99/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.470\n", + "Batch: 100/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.400\n", + "CPU times: user 6.78 s, sys: 83.6 ms, total: 6.87 s\n", + "Wall time: 6.76 s\n" + ] } ], "source": [ - "plot_predictive_post(\n", - " walker=walker3, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", + "%%time\n", + "walker5 = rxmc.walker.Walker(\n", + " rxmc.param_sampling.MetropolisHastingsSampler(\n", + " params=my_model.params,\n", + " starting_location=prior_distribution.mean,\n", + " proposal=proposal_distribution_model,\n", + " prior=prior_distribution,\n", + " ),\n", + " evidence_offset,\n", + " rng=rng,\n", ")\n", - "plt.title(\"option 3: systematic included correctly\")" - ] - }, - { - "cell_type": "markdown", - "id": "b367eb21-44ab-4146-bbf6-8ad8d0806f67", - "metadata": {}, - "source": [ - "## Run option 4: incorrect formulation of the systematic error" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "d731b920-451d-4884-aa1a-9fbdb6db2361", - "metadata": {}, - "outputs": [], - "source": [ - "walker4 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", + "walker5i = rxmc.walker.Walker(\n", + " rxmc.param_sampling.MetropolisHastingsSampler(\n", " params=my_model.params,\n", " starting_location=prior_distribution.mean,\n", " proposal=proposal_distribution_model,\n", " prior=prior_distribution,\n", " ),\n", - " evidence=evidence_sys_wrong,\n", + " evidence_offset_ignored,\n", " rng=rng,\n", - ")" + ")\n", + "walker5.walk(n_steps=10000, burnin=1000, batch_size=100)\n", + "walker5i.walk(n_steps=10000, burnin=1000, batch_size=100)" ] }, { "cell_type": "code", - "execution_count": 37, - "id": "cc8396c2-f7de-4047-92ff-a7e4e30c782d", - "metadata": {}, + "execution_count": 47, + "id": "fe674eb4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.113236Z", + "iopub.status.busy": "2026-08-11T03:09:40.113093Z", + "iopub.status.idle": "2026-08-11T03:09:40.317497Z", + "shell.execute_reply": "2026-08-11T03:09:40.316800Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.733\n", - "CPU times: user 2.67 s, sys: 72.3 ms, total: 2.74 s\n", - "Wall time: 2.78 s\n" + "offset accounted m = 0.473 ± 0.108 b = 2.357 ± 0.299\n", + "offset ignored m = 0.472 ± 0.099 b = 2.332 ± 0.056\n" ] - } - ], - "source": [ - "%%time\n", - "walker4.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "6b19450a-7289-4441-ac48-89ebaa03575c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker4, model=my_model, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "fce5ffbc-b15c-4fc8-89ab-0d4a5e92dcc3", - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1501,28 +3561,52 @@ } ], "source": [ - "plot_posterior_corner(walker=walker4, true_params=true_params)" + "for name, w in [(\"offset accounted\", walker5), (\"offset ignored\", walker5i)]:\n", + " ch = w.model_sampler.chain\n", + " print(\n", + " f\"{name:18s} m = {ch[:, 0].mean():.3f} ± {ch[:, 0].std():.3f} \"\n", + " f\"b = {ch[:, 1].mean():.3f} ± {ch[:, 1].std():.3f}\"\n", + " )\n", + "\n", + "fig = corner.corner(\n", + " walker5.model_sampler.chain,\n", + " labels=[\"m\", \"b\"],\n", + " truths=[true_params[\"m\"], true_params[\"b\"]],\n", + " truth_color=\"k\",\n", + " color=\"tab:blue\",\n", + ")\n", + "corner.corner(walker5i.model_sampler.chain, fig=fig, color=\"tab:red\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"offset accounted\")\n", + "plt.plot([], [], color=\"tab:red\", label=\"offset ignored\")\n", + "fig.legend(loc=\"upper right\");" ] }, { "cell_type": "code", - "execution_count": 40, - "id": "647aa074-8511-4a2c-843f-4c11424938e1", - "metadata": {}, + "execution_count": 48, + "id": "771d2caf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.318840Z", + "iopub.status.busy": "2026-08-11T03:09:40.318702Z", + "iopub.status.idle": "2026-08-11T03:09:40.539397Z", + "shell.execute_reply": "2026-08-11T03:09:40.538767Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "Text(0.5, 1.0, 'option 4: systematic included incorrectly')" + "Text(0.5, 1.0, 'option 5: additive offset accounted via offset_term')" ] }, - "execution_count": 40, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1533,9 +3617,14 @@ ], "source": [ "plot_predictive_post(\n", - " walker=walker4, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", + " walker=walker5,\n", + " model=my_model,\n", + " x=x,\n", + " y_exp=y_exp_off,\n", + " y_err=y_stat_err_off,\n", + " y_true=y_true,\n", ")\n", - "plt.title(\"option 4: systematic included incorrectly\")" + "plt.title(\"option 5: additive offset accounted via offset_term\")" ] }, { @@ -1549,9 +3638,16 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 49, "id": "70caf730-cc72-4d96-a3f2-6f1eced45e3b", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.540921Z", + "iopub.status.busy": "2026-08-11T03:09:40.540776Z", + "iopub.status.idle": "2026-08-11T03:09:40.544039Z", + "shell.execute_reply": "2026-08-11T03:09:40.543430Z" + } + }, "outputs": [], "source": [ "systematic_fractional_err2 = 0.1\n", @@ -1566,9 +3662,16 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 50, "id": "29594275-7fa2-48f0-acd0-ff7bac4df1c3", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.545318Z", + "iopub.status.busy": "2026-08-11T03:09:40.545187Z", + "iopub.status.idle": "2026-08-11T03:09:40.547746Z", + "shell.execute_reply": "2026-08-11T03:09:40.547062Z" + } + }, "outputs": [], "source": [ "x_full = np.linspace(-1, 2, 100)\n", @@ -1577,9 +3680,16 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 51, "id": "74d3bc67-aaaf-48a0-82ee-abc34bb72599", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.549000Z", + "iopub.status.busy": "2026-08-11T03:09:40.548884Z", + "iopub.status.idle": "2026-08-11T03:09:40.718650Z", + "shell.execute_reply": "2026-08-11T03:09:40.718004Z" + } + }, "outputs": [ { "data": { @@ -1587,13 +3697,13 @@ "Text(0.5, 1.0, 'multiple experimental constraint with opposite bias')" ] }, - "execution_count": 43, + "execution_count": 51, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1631,32 +3741,31 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 52, "id": "87e72ee0-7265-4bee-99ae-38f88f56ac3a", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.720200Z", + "iopub.status.busy": "2026-08-11T03:09:40.720056Z", + "iopub.status.idle": "2026-08-11T03:09:40.723567Z", + "shell.execute_reply": "2026-08-11T03:09:40.722970Z" + } + }, "outputs": [], "source": [ "# 1 and 2\n", - "obs_stat_only2 = rxmc.observation.Observation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " y_stat_err=y_stat_err2,\n", - ")\n", + "obs_stat_only2 = rxmc.observation.Observation(x=x2, y=y_exp2, y_stat_err=y_stat_err2)\n", + "obs_unknown_stat2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", "\n", "# 3\n", "obs_sys_norm_correct2 = rxmc.observation.Observation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " y_stat_err=y_stat_err2,\n", - " y_sys_err_normalization=systematic_fractional_err2,\n", + " x=x2, y=y_exp2, y_stat_err=y_stat_err2\n", ")\n", "\n", "# 4\n", - "obs_sys_norm_wrong2 = rxmc.observation.FixedCovarianceObservation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " covariance=np.diag(y_stat_err2**2)\n", - " + systematic_fractional_err2**2 * np.outer(y_exp2, y_exp2),\n", + "obs_sys_norm_wrong2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", + "wrong_cov2 = np.diag(y_stat_err2**2) + systematic_fractional_err2**2 * np.outer(\n", + " y_exp2, y_exp2\n", ")" ] }, @@ -1670,32 +3779,40 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 53, "id": "2d1be262-56ab-4c30-b39f-b4ee2ced788e", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.724958Z", + "iopub.status.busy": "2026-08-11T03:09:40.724799Z", + "iopub.status.idle": "2026-08-11T03:09:40.729780Z", + "shell.execute_reply": "2026-08-11T03:09:40.729184Z" + } + }, "outputs": [], "source": [ + "N1 = obs_stat_only.n_data_pts\n", + "N2 = obs_stat_only2.n_data_pts\n", + "s1 = np.arange(N1)\n", + "s2 = np.arange(N1, N1 + N2)\n", + "\n", "# 1\n", "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_stat_only, obs_stat_only2],\n", - " my_model,\n", - " likelihood,\n", - " )\n", - " ]\n", + " [rxmc.constraint.Constraint([obs_stat_only, obs_stat_only2], my_model, likelihood)]\n", ")\n", "\n", - "# 2\n", + "# 2 (shared noise-fraction parameter across both datasets -> case B)\n", "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " constraints=[],\n", - " parametric_constraints=[\n", + " [\n", " rxmc.constraint.Constraint(\n", - " [obs_stat_only, obs_stat_only2],\n", + " [obs_unknown_stat, obs_unknown_stat2],\n", " my_model,\n", - " likelihood_unknown_stat,\n", + " extra_terms=[\n", + " rxmc.covariance.noise_fraction_term(s1, log_noise_fraction),\n", + " rxmc.covariance.noise_fraction_term(s2, log_noise_fraction),\n", + " ],\n", " )\n", - " ],\n", + " ]\n", ")\n", "\n", "# 3\n", @@ -1704,7 +3821,14 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_correct, obs_sys_norm_correct2],\n", " my_model,\n", - " likelihood,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(\n", + " s1, magnitude=systematic_fractional_err\n", + " ),\n", + " rxmc.covariance.normalization_term(\n", + " s2, magnitude=systematic_fractional_err2\n", + " ),\n", + " ],\n", " )\n", " ]\n", ")\n", @@ -1715,7 +3839,10 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", " my_model,\n", - " likelihood_fixed_cov,\n", + " extra_terms=[\n", + " rxmc.covariance.DenseTerm(s1, wrong_cov),\n", + " rxmc.covariance.DenseTerm(s2, wrong_cov2),\n", + " ],\n", " )\n", " ]\n", ")" @@ -1723,9 +3850,16 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 54, "id": "2f0f6a89-f6c8-4306-bec5-95257ab685e2", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.731148Z", + "iopub.status.busy": "2026-08-11T03:09:40.731020Z", + "iopub.status.idle": "2026-08-11T03:09:40.733637Z", + "shell.execute_reply": "2026-08-11T03:09:40.732868Z" + } + }, "outputs": [], "source": [ "walker1 = rxmc.walker.Walker(\n", @@ -1742,19 +3876,32 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 55, "id": "d56972b8-c1ca-4e24-b18b-18661e5c1230", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:40.734879Z", + "iopub.status.busy": "2026-08-11T03:09:40.734763Z", + "iopub.status.idle": "2026-08-11T03:09:44.461818Z", + "shell.execute_reply": "2026-08-11T03:09:44.461059Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", " Model parameter acceptance fraction: 0.151\n", - "CPU times: user 4.27 s, sys: 148 ms, total: 4.42 s\n", - "Wall time: 4.79 s\n" + "CPU times: user 3.72 s, sys: 18.9 ms, total: 3.74 s\n", + "Wall time: 3.72 s\n" ] } ], @@ -1765,9 +3912,16 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 56, "id": "756f57d6-b493-4cde-adda-599fc6a34c95", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:44.463328Z", + "iopub.status.busy": "2026-08-11T03:09:44.463156Z", + "iopub.status.idle": "2026-08-11T03:09:44.515567Z", + "shell.execute_reply": "2026-08-11T03:09:44.514991Z" + } + }, "outputs": [], "source": [ "upper1, med1, lower1 = np.percentile(\n", @@ -1779,9 +3933,16 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 57, "id": "18cb26c9-6240-4c58-a157-eaa97eaa1bfd", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:44.517091Z", + "iopub.status.busy": "2026-08-11T03:09:44.516956Z", + "iopub.status.idle": "2026-08-11T03:09:44.520148Z", + "shell.execute_reply": "2026-08-11T03:09:44.519511Z" + } + }, "outputs": [], "source": [ "walker2 = rxmc.walker.Walker(\n", @@ -1794,7 +3955,7 @@ " evidence=evidence_unknown_stat,\n", " likelihood_samplers=[\n", " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=likelihood_unknown_stat.params,\n", + " params=[log_noise_fraction],\n", " starting_location=noise_prior.mean(),\n", " proposal=proposal_distribution_noise,\n", " prior=noise_prior,\n", @@ -1806,326 +3967,771 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 58, "id": "6326cf53-4e85-428c-9a22-50e377b4d8b0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:44.521481Z", + "iopub.status.busy": "2026-08-11T03:09:44.521362Z", + "iopub.status.idle": "2026-08-11T03:09:54.296171Z", + "shell.execute_reply": "2026-08-11T03:09:54.295520Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", - "Burn-in batch 7/10 completed, 100 steps.\n", - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n", - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + "Burn-in batch 1/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 2/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 5/10 completed, 100 steps.\n", + "Burn-in batch 6/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 7/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 8/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 10/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 1/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.67]\n", + "Batch: 2/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 3/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.67]\n", "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.81]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.75]\n", "Batch: 8/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.490\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.66]\n", "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.62]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.77]\n", "Batch: 14/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.470\n", + " Likelihood parameter acceptance fractions: [0.78]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.73]\n", "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.64]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.8]\n", + " Model parameter acceptance fraction: 0.520\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.520\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.64]\n", + " Model parameter acceptance fraction: 0.280\n", + " Likelihood parameter acceptance fractions: [0.83]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.78]\n", "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 27/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 27/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.570\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", + " Model parameter acceptance fraction: 0.530\n", " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.230\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.81]\n", "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.560\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.580\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 34/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.560\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.320\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.65]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.620\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.570\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.490\n", + " Likelihood parameter acceptance fractions: [0.64]\n", "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.63]\n", + " Model parameter acceptance fraction: 0.470\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.81]\n", "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Model parameter acceptance fraction: 0.450\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.480\n", + " Likelihood parameter acceptance fractions: [0.78]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.73]\n", "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.360\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 52/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 52/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.77]\n", "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.450\n", + " Likelihood parameter acceptance fractions: [0.78]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.550\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.77]\n", "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.65]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.6]\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", + " Model parameter acceptance fraction: 0.340\n", " Likelihood parameter acceptance fractions: [0.71]\n", + "Batch: 62/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.290\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 65/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 67/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 67/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.440\n", " Likelihood parameter acceptance fractions: [0.72]\n", + "Batch: 68/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.560\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.540\n", + " Likelihood parameter acceptance fractions: [0.8]\n", "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.420\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Model parameter acceptance fraction: 0.360\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.74]\n", "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.82]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.72]\n", "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.410\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.420\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Model parameter acceptance fraction: 0.440\n", + " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.470\n", + " Likelihood parameter acceptance fractions: [0.78]\n", "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.530\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.460\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.580\n", + " Likelihood parameter acceptance fractions: [0.66]\n", "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.370\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.510\n", + " Likelihood parameter acceptance fractions: [0.73]\n", "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.540\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.500\n", + " Likelihood parameter acceptance fractions: [0.72]\n", "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 93/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch: 93/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.390\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.400\n", + " Likelihood parameter acceptance fractions: [0.73]\n", "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + " Model parameter acceptance fraction: 0.380\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.550\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.430\n", + " Likelihood parameter acceptance fractions: [0.72]\n", "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.350\n", + " Likelihood parameter acceptance fractions: [0.61]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 99/100 completed, 100 steps. \n", " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "CPU times: user 8.81 s, sys: 15.8 ms, total: 8.82 s\n", - "Wall time: 8.82 s\n" + " Model parameter acceptance fraction: 0.610\n", + " Likelihood parameter acceptance fractions: [0.73]\n", + "CPU times: user 9.78 s, sys: 10.8 ms, total: 9.79 s\n", + "Wall time: 9.77 s\n" ] } ], @@ -2140,9 +4746,16 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 59, "id": "e05be7bb-9dbf-4b3e-989e-4e585d6af958", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:54.297672Z", + "iopub.status.busy": "2026-08-11T03:09:54.297537Z", + "iopub.status.idle": "2026-08-11T03:09:54.351090Z", + "shell.execute_reply": "2026-08-11T03:09:54.350419Z" + } + }, "outputs": [], "source": [ "upper2, med2, lower2 = np.percentile(\n", @@ -2154,9 +4767,16 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 60, "id": "46043bca-0a01-45b3-b404-33be8cf82dbf", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:54.352464Z", + "iopub.status.busy": "2026-08-11T03:09:54.352340Z", + "iopub.status.idle": "2026-08-11T03:09:54.355183Z", + "shell.execute_reply": "2026-08-11T03:09:54.354366Z" + } + }, "outputs": [], "source": [ "walker3 = rxmc.walker.Walker(\n", @@ -2173,19 +4793,32 @@ }, { "cell_type": "code", - "execution_count": 53, + "execution_count": 61, "id": "4d0484c6-2cac-4205-9e7a-524dc2c0df26", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:54.356461Z", + "iopub.status.busy": "2026-08-11T03:09:54.356343Z", + "iopub.status.idle": "2026-08-11T03:09:59.757763Z", + "shell.execute_reply": "2026-08-11T03:09:59.757135Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.590\n", - "CPU times: user 4.21 s, sys: 7.66 ms, total: 4.21 s\n", - "Wall time: 4.22 s\n" + " Model parameter acceptance fraction: 0.592\n", + "CPU times: user 5.4 s, sys: 841 μs, total: 5.4 s\n", + "Wall time: 5.4 s\n" ] } ], @@ -2196,9 +4829,16 @@ }, { "cell_type": "code", - "execution_count": 54, + "execution_count": 62, "id": "4ecd35ac-5852-4a02-91a3-d149b9f5dea6", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:59.759151Z", + "iopub.status.busy": "2026-08-11T03:09:59.758999Z", + "iopub.status.idle": "2026-08-11T03:09:59.810849Z", + "shell.execute_reply": "2026-08-11T03:09:59.809999Z" + } + }, "outputs": [], "source": [ "upper3, med3, lower3 = np.percentile(\n", @@ -2210,9 +4850,16 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 63, "id": "dbf399dd-c2b7-49fb-898e-ee5994b6f086", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:59.812312Z", + "iopub.status.busy": "2026-08-11T03:09:59.812170Z", + "iopub.status.idle": "2026-08-11T03:09:59.814898Z", + "shell.execute_reply": "2026-08-11T03:09:59.814223Z" + } + }, "outputs": [], "source": [ "walker4 = rxmc.walker.Walker(\n", @@ -2229,19 +4876,32 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 64, "id": "ced1d78c-42b4-474c-84ca-e5d54d2c0f15", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:09:59.816292Z", + "iopub.status.busy": "2026-08-11T03:09:59.816155Z", + "iopub.status.idle": "2026-08-11T03:10:03.452356Z", + "shell.execute_reply": "2026-08-11T03:10:03.451766Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", " Model parameter acceptance fraction: 0.578\n", - "CPU times: user 2.72 s, sys: 40.3 ms, total: 2.76 s\n", - "Wall time: 2.74 s\n" + "CPU times: user 3.63 s, sys: 30.1 ms, total: 3.66 s\n", + "Wall time: 3.63 s\n" ] } ], @@ -2252,9 +4912,16 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 65, "id": "8670fc09-6a92-4231-ae5f-2710836d736d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.453827Z", + "iopub.status.busy": "2026-08-11T03:10:03.453695Z", + "iopub.status.idle": "2026-08-11T03:10:03.505158Z", + "shell.execute_reply": "2026-08-11T03:10:03.504394Z" + } + }, "outputs": [], "source": [ "upper4, med4, lower4 = np.percentile(\n", @@ -2266,9 +4933,16 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 66, "id": "92988fb9-05bc-4223-8ae0-e7f620047ca7", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.506585Z", + "iopub.status.busy": "2026-08-11T03:10:03.506407Z", + "iopub.status.idle": "2026-08-11T03:10:03.709366Z", + "shell.execute_reply": "2026-08-11T03:10:03.708598Z" + } + }, "outputs": [ { "data": { @@ -2276,13 +4950,13 @@ "Text(0.5, 1.0, 'multiple constraints with systematic normalization error')" ] }, - "execution_count": 58, + "execution_count": 66, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2345,9 +5019,16 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 67, "id": "48e2d2b2-6199-49e3-a312-df82a796a3c0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.710718Z", + "iopub.status.busy": "2026-08-11T03:10:03.710576Z", + "iopub.status.idle": "2026-08-11T03:10:03.714021Z", + "shell.execute_reply": "2026-08-11T03:10:03.713230Z" + } + }, "outputs": [], "source": [ "x2 = np.linspace(0.6, 1.4, 27, dtype=float)\n", @@ -2358,9 +5039,16 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 68, "id": "55153cf1-0153-443f-8e94-7b0cbf9fbab0", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.715216Z", + "iopub.status.busy": "2026-08-11T03:10:03.715094Z", + "iopub.status.idle": "2026-08-11T03:10:03.891635Z", + "shell.execute_reply": "2026-08-11T03:10:03.891086Z" + } + }, "outputs": [ { "data": { @@ -2368,13 +5056,13 @@ "Text(0.5, 1.0, '$x$-offset experimental constraint with opposite bias')" ] }, - "execution_count": 60, + "execution_count": 68, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2412,32 +5100,31 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 69, "id": "bb633a19-afb3-413e-b57b-2c489ca0c382", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.893160Z", + "iopub.status.busy": "2026-08-11T03:10:03.893032Z", + "iopub.status.idle": "2026-08-11T03:10:03.896205Z", + "shell.execute_reply": "2026-08-11T03:10:03.895687Z" + } + }, "outputs": [], "source": [ "# 1 and 2\n", - "obs_stat_only2 = rxmc.observation.Observation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " y_stat_err=y_stat_err2,\n", - ")\n", + "obs_stat_only2 = rxmc.observation.Observation(x=x2, y=y_exp2, y_stat_err=y_stat_err2)\n", + "obs_unknown_stat2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", "\n", "# 3\n", "obs_sys_norm_correct2 = rxmc.observation.Observation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " y_stat_err=y_stat_err2,\n", - " y_sys_err_normalization=systematic_fractional_err2,\n", + " x=x2, y=y_exp2, y_stat_err=y_stat_err2\n", ")\n", "\n", "# 4\n", - "obs_sys_norm_wrong2 = rxmc.observation.FixedCovarianceObservation(\n", - " x=x2,\n", - " y=y_exp2,\n", - " covariance=np.diag(y_stat_err2**2)\n", - " + systematic_fractional_err2**2 * np.outer(y_exp2, y_exp2),\n", + "obs_sys_norm_wrong2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", + "wrong_cov2 = np.diag(y_stat_err2**2) + systematic_fractional_err2**2 * np.outer(\n", + " y_exp2, y_exp2\n", ")" ] }, @@ -2451,32 +5138,40 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 70, "id": "38796171-1781-4044-82b1-1592abeaed4f", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.897627Z", + "iopub.status.busy": "2026-08-11T03:10:03.897509Z", + "iopub.status.idle": "2026-08-11T03:10:03.902733Z", + "shell.execute_reply": "2026-08-11T03:10:03.902059Z" + } + }, "outputs": [], "source": [ + "N1 = obs_stat_only.n_data_pts\n", + "N2 = obs_stat_only2.n_data_pts\n", + "s1 = np.arange(N1)\n", + "s2 = np.arange(N1, N1 + N2)\n", + "\n", "# 1\n", "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_stat_only, obs_stat_only2],\n", - " my_model,\n", - " likelihood,\n", - " )\n", - " ]\n", + " [rxmc.constraint.Constraint([obs_stat_only, obs_stat_only2], my_model, likelihood)]\n", ")\n", "\n", - "# 2\n", + "# 2 (shared noise-fraction parameter across both datasets -> case B)\n", "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " constraints=[],\n", - " parametric_constraints=[\n", + " [\n", " rxmc.constraint.Constraint(\n", - " [obs_stat_only, obs_stat_only2],\n", + " [obs_unknown_stat, obs_unknown_stat2],\n", " my_model,\n", - " likelihood_unknown_stat,\n", + " extra_terms=[\n", + " rxmc.covariance.noise_fraction_term(s1, log_noise_fraction),\n", + " rxmc.covariance.noise_fraction_term(s2, log_noise_fraction),\n", + " ],\n", " )\n", - " ],\n", + " ]\n", ")\n", "\n", "# 3\n", @@ -2485,7 +5180,14 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_correct, obs_sys_norm_correct2],\n", " my_model,\n", - " likelihood,\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(\n", + " s1, magnitude=systematic_fractional_err\n", + " ),\n", + " rxmc.covariance.normalization_term(\n", + " s2, magnitude=systematic_fractional_err2\n", + " ),\n", + " ],\n", " )\n", " ]\n", ")\n", @@ -2496,7 +5198,10 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", " my_model,\n", - " likelihood_fixed_cov,\n", + " extra_terms=[\n", + " rxmc.covariance.DenseTerm(s1, wrong_cov),\n", + " rxmc.covariance.DenseTerm(s2, wrong_cov2),\n", + " ],\n", " )\n", " ]\n", ")" @@ -2504,9 +5209,16 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 71, "id": "a1ea1e11-1b1f-44c2-9218-dce25f613a18", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.904075Z", + "iopub.status.busy": "2026-08-11T03:10:03.903959Z", + "iopub.status.idle": "2026-08-11T03:10:03.906384Z", + "shell.execute_reply": "2026-08-11T03:10:03.905825Z" + } + }, "outputs": [], "source": [ "walker1 = rxmc.walker.Walker(\n", @@ -2523,19 +5235,32 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 72, "id": "e2cd9f71-2395-4ee8-84ed-a0ad4b6abc37", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:03.907639Z", + "iopub.status.busy": "2026-08-11T03:10:03.907525Z", + "iopub.status.idle": "2026-08-11T03:10:07.489591Z", + "shell.execute_reply": "2026-08-11T03:10:07.488800Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.144\n", - "CPU times: user 4.18 s, sys: 3.95 ms, total: 4.19 s\n", - "Wall time: 4.19 s\n" + " Model parameter acceptance fraction: 0.331\n", + "CPU times: user 3.58 s, sys: 16 ms, total: 3.6 s\n", + "Wall time: 3.58 s\n" ] } ], @@ -2546,9 +5271,16 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 73, "id": "a939e980-1479-4619-b7d1-507a5c1ce3f9", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:07.490910Z", + "iopub.status.busy": "2026-08-11T03:10:07.490749Z", + "iopub.status.idle": "2026-08-11T03:10:07.540105Z", + "shell.execute_reply": "2026-08-11T03:10:07.539346Z" + } + }, "outputs": [], "source": [ "upper1, med1, lower1 = np.percentile(\n", @@ -2560,9 +5292,16 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 74, "id": "309bae03-b150-454b-86cb-a1c3e42fb1ad", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:07.541679Z", + "iopub.status.busy": "2026-08-11T03:10:07.541511Z", + "iopub.status.idle": "2026-08-11T03:10:07.544922Z", + "shell.execute_reply": "2026-08-11T03:10:07.544100Z" + } + }, "outputs": [], "source": [ "walker2 = rxmc.walker.Walker(\n", @@ -2575,7 +5314,7 @@ " evidence=evidence_unknown_stat,\n", " likelihood_samplers=[\n", " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=likelihood_unknown_stat.params,\n", + " params=[log_noise_fraction],\n", " starting_location=noise_prior.mean(),\n", " proposal=proposal_distribution_noise,\n", " prior=noise_prior,\n", @@ -2587,326 +5326,771 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 75, "id": "3ab21666-0ffb-4692-a3ac-ef8e588bd2b7", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:07.546286Z", + "iopub.status.busy": "2026-08-11T03:10:07.546127Z", + "iopub.status.idle": "2026-08-11T03:10:17.201635Z", + "shell.execute_reply": "2026-08-11T03:10:17.201079Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", + "Burn-in batch 1/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", - "Burn-in batch 4/10 completed, 100 steps.\n", + "Burn-in batch 3/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 4/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", - "Burn-in batch 7/10 completed, 100 steps.\n", + "Burn-in batch 6/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 7/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n", + "Burn-in batch 9/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Burn-in batch 10/10 completed, 100 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.83]\n", "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.940\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.79]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.8]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.75]\n", "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.910\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.67]\n", "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.66]\n", "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.930\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.66]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.75]\n", "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.940\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.940\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.62]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.68]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.76]\n", "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.67]\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.200\n", + " Model parameter acceptance fraction: 0.980\n", " Likelihood parameter acceptance fractions: [0.69]\n", + "Batch: 32/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.74]\n", "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.66]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.66]\n", "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.6]\n", "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.920\n", + " Likelihood parameter acceptance fractions: [0.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.910\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.72]\n", "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", + " Model parameter acceptance fraction: 0.980\n", " Likelihood parameter acceptance fractions: [0.71]\n", + "Batch: 47/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.63]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", + " Model parameter acceptance fraction: 0.920\n", " Likelihood parameter acceptance fractions: [0.73]\n", + "Batch: 50/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.66]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.67]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.72]\n", "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.66]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Model parameter acceptance fraction: 0.940\n", + " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.76]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.71]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.67]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", + " Model parameter acceptance fraction: 0.990\n", " Likelihood parameter acceptance fractions: [0.75]\n", "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.75]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.73]\n", + "Batch: 68/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.71]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.7]\n", "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.65]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.75]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.66]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.65]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.69]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.7]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", + " Model parameter acceptance fraction: 1.000\n", " Likelihood parameter acceptance fractions: [0.69]\n", + "Batch: 77/100 completed, 100 steps. \n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.68]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.77]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.78]\n", "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.84]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.66]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.65]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.82]\n", "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.63]\n", + " Model parameter acceptance fraction: 0.950\n", + " Likelihood parameter acceptance fractions: [0.69]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.74]\n", + " Model parameter acceptance fraction: 1.000\n", + " Likelihood parameter acceptance fractions: [0.57]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.66]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.66]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", + " Model parameter acceptance fraction: 0.960\n", " Likelihood parameter acceptance fractions: [0.76]\n", "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.72]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.69]\n", "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.940\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.73]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.7]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.71]\n", "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.81]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.74]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.990\n", + " Likelihood parameter acceptance fractions: [0.73]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.78]\n", + " Model parameter acceptance fraction: 0.980\n", + " Likelihood parameter acceptance fractions: [0.73]\n", "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.76]\n", + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.72]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.79]\n", + " Model parameter acceptance fraction: 0.970\n", + " Likelihood parameter acceptance fractions: [0.77]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "CPU times: user 8.96 s, sys: 223 ms, total: 9.19 s\n", - "Wall time: 8.92 s\n" + " Model parameter acceptance fraction: 0.960\n", + " Likelihood parameter acceptance fractions: [0.76]\n", + "CPU times: user 9.66 s, sys: 10.9 ms, total: 9.67 s\n", + "Wall time: 9.65 s\n" ] } ], @@ -2921,9 +6105,16 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 76, "id": "e78a780b-1336-41dd-a222-ea4333149f6d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:17.203038Z", + "iopub.status.busy": "2026-08-11T03:10:17.202905Z", + "iopub.status.idle": "2026-08-11T03:10:17.251148Z", + "shell.execute_reply": "2026-08-11T03:10:17.250464Z" + } + }, "outputs": [], "source": [ "upper2, med2, lower2 = np.percentile(\n", @@ -2935,9 +6126,16 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 77, "id": "d0f0d0cc-7f17-4d49-b60f-fe6330a1c10d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:17.252455Z", + "iopub.status.busy": "2026-08-11T03:10:17.252324Z", + "iopub.status.idle": "2026-08-11T03:10:17.254981Z", + "shell.execute_reply": "2026-08-11T03:10:17.254383Z" + } + }, "outputs": [], "source": [ "walker3 = rxmc.walker.Walker(\n", @@ -2954,19 +6152,32 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 78, "id": "c6e0ea79-3fbe-4105-8e34-a1e1db699c77", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:17.256193Z", + "iopub.status.busy": "2026-08-11T03:10:17.256076Z", + "iopub.status.idle": "2026-08-11T03:10:22.676338Z", + "shell.execute_reply": "2026-08-11T03:10:22.675665Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.626\n", - "CPU times: user 4.17 s, sys: 3.99 ms, total: 4.17 s\n", - "Wall time: 4.17 s\n" + " Model parameter acceptance fraction: 0.748\n", + "CPU times: user 5.42 s, sys: 897 μs, total: 5.42 s\n", + "Wall time: 5.42 s\n" ] } ], @@ -2977,9 +6188,16 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 79, "id": "60262bab-1c58-4a71-9227-43983c7af67d", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:22.677794Z", + "iopub.status.busy": "2026-08-11T03:10:22.677622Z", + "iopub.status.idle": "2026-08-11T03:10:22.729234Z", + "shell.execute_reply": "2026-08-11T03:10:22.728390Z" + } + }, "outputs": [], "source": [ "upper3, med3, lower3 = np.percentile(\n", @@ -2991,9 +6209,16 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 80, "id": "d9c5010e-8f5b-461a-8941-2b967fbfb8f7", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:22.730597Z", + "iopub.status.busy": "2026-08-11T03:10:22.730459Z", + "iopub.status.idle": "2026-08-11T03:10:22.733413Z", + "shell.execute_reply": "2026-08-11T03:10:22.732750Z" + } + }, "outputs": [], "source": [ "walker4 = rxmc.walker.Walker(\n", @@ -3010,19 +6235,32 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 81, "id": "b02c82e3-0cb0-4d5d-9d55-2b1ceacdf244", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:22.734633Z", + "iopub.status.busy": "2026-08-11T03:10:22.734464Z", + "iopub.status.idle": "2026-08-11T03:10:26.390364Z", + "shell.execute_reply": "2026-08-11T03:10:26.389705Z" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", + "Burn-in batch 1/1 completed, 1000 steps.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.618\n", - "CPU times: user 2.77 s, sys: 113 ms, total: 2.88 s\n", - "Wall time: 2.78 s\n" + " Model parameter acceptance fraction: 0.735\n", + "CPU times: user 3.65 s, sys: 10.9 ms, total: 3.66 s\n", + "Wall time: 3.65 s\n" ] } ], @@ -3033,9 +6271,16 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 82, "id": "d24a326a-093b-4e20-80d3-9d267a4c14e7", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:26.391784Z", + "iopub.status.busy": "2026-08-11T03:10:26.391652Z", + "iopub.status.idle": "2026-08-11T03:10:26.443882Z", + "shell.execute_reply": "2026-08-11T03:10:26.443172Z" + } + }, "outputs": [], "source": [ "upper4, med4, lower4 = np.percentile(\n", @@ -3047,13 +6292,30 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 83, "id": "78d9fee2-1f50-460b-b579-62f649785e00", - "metadata": {}, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-11T03:10:26.445207Z", + "iopub.status.busy": "2026-08-11T03:10:26.445078Z", + "iopub.status.idle": "2026-08-11T03:10:26.648495Z", + "shell.execute_reply": "2026-08-11T03:10:26.647882Z" + } + }, "outputs": [ { "data": { - "image/png": "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", + "text/plain": [ + "Text(0.5, 1.0, '$x$-offset constraints with systematic normalization error')" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjwAAAHFCAYAAAD2eiPWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAm25JREFUeJzs3XdYFMf/B/D33nHc0XsHaWJFxS4WRLE3RMVuYoux5KtGTdT4S080MUWTWGKMGpOgRpOIKHbsvcWKWFCxodJ7Oe7m98dyyx13SJF6fl7Pcw/s7uzs7LX93MzsDMcYYyCEEEII0WOimi4AIYQQQkhVo4CHEEIIIXqPAh5CCCGE6D0KeAghhBCi9yjgIYQQQojeo4CHEEIIIXqPAh5CCCGE6D0KeOqwrKwsnD59Gjt27MC1a9eE9SkpKTh27BjCw8MRGxtbgyV8fcXFxSE8PBzZ2dk1XZQKUygUCA8Px507d8qUPjIyEleuXKniUhF1ERERiI6Oruli1GpHjx7F6dOnheWMjAyEh4fjyZMn1VoOpVKJ8PBw3L59u1qPS4pQwFNHXbp0CfXr18fUqVOxYcMGnDt3DgCwd+9eeHh4YP78+fjtt98q/cvw9u3bCA8Ph0KhqNR8q5vqyycmJqZK8j9w4ABCQkLw4sWLcu+bnJyM8PBwPH/+vApKVnY5OTkICQnBP//8I6yLjY1FeHg48vLytNKPGTMGq1evrs4iVtjRo0dx6tSpmi5Gmdy4cQMRERE6tw0ZMgS///57NZeobpk7dy4+/fRTYTkuLg4hISE4fvx4lRzv8uXL2LNnj9b6/Px8hISEYOvWrVVyXFI6CnjqqE8++QQODg64fPkywsPDMWnSJADA+++/j8DAQJw+fRrh4eEYOHBgpR5369atCAkJQU5OTqXmW91UXz5btmypkvw9PDwQHBwMY2Pjcu8bHR2NkJAQnD9/vgpKVnYGBgYIDg5GgwYNhHU7d+5ESEgIUlJSarBkr27u3Ln46KOParoYZbJhwwYMGTJE57bg4GA0bdq0mktUt5mbmyM4OBiurq5Vkv+KFSswbtw4rfVisRjBwcFo2LBhlRyXlM6gpgtAKiY6Ohpt2rQBx3HCOqVSiZiYGPTr168GS0YAoEePHujRo0dNF+OVyGQyhIeH13QxyEuo176RsqlXr16NvK8lEgl9nmoYBTyVSKFQYNeuXXBwcECHDh00tl26dAkPHz5E165dYWVl9dJ8srKycOnSJWRlZcHb2xs+Pj7CtsePH+PChQtISkrCs2fPhA+Qu7s77t69C7lcjnv37gnrBw0aBJFIBLlcjmvXriEhIQH16tVDgwYNIBaLtY6dkpKCy5cvIz8/H02bNtX4FXT58mXcvHkTALBr1y7IZDIAQGBgICwtLUs9p//++w85OTnw9fWFk5OTVpq0tDRcunQJ+fn5aNSoEdzd3TW2x8fH4+zZs8JzeOnSJbx48QJ+fn5wdHTUyi81NRXR0dHIyclBgwYN4ObmBgDIzMwUqpxjYmKE58rV1RVt2rRBdHQ0bt++jcGDB0Mul+PcuXPIyMhAnz59cPPmTdy6dQsAIBKJYG5ujhYtWmi9pnFxcfjvv//Qq1cvoZbn0KFDMDY2RocOHZCYmIhLly7B0tISbdq0gUjEV7Y+fvxYqGo/c+YMCgoKAAC+vr6oX7++8DxFR0cjKysLDRo0QL169V763N+8eRN37tzBoEGDhHUvXrzAqVOn4O7ujpYtWwrrz58/j9TUVPTs2RMKhQI7d+5E06ZN4ePjg2vXrgl9xfbu3Su85p07d4atra3GMZ8+fYpr167BwcEBfn5+Ly1f8eft7t27MDY2RpMmTWBhYSE8LxcuXECnTp1gZ2ensY/qc+fl5YVmzZoB4Gvwrl27hsTERHh4eMDHx0d4jvfs2YPU1FTI5XLhtTcyMkLv3r2FPBljuHbtGh4/fgwbGxu0atUKEolE2K5UKhEREYFGjRqhUaNGiI2NRWxsLJo2bQoXFxch3b1793D79m34+PjA29tbo9wXL17Eo0ePAPDvJWtra/j5+cHU1FTj9bh79y4YYxoXy549e8LExAQRERGoX78+mjRpovWcXLt2Dc+ePYOHhwcaNmyo8eNIl8jISLi6uqJFixZlev2ys7Nx6dIlZGRkwMvLS6vmIiMjA1FRUWjTpg1cXV0RExODu3fvon379sLnKjAwEBYWFjh//jyysrLQrl07mJiYCK/BxYsXkZycjHbt2ml9x+zZs0doWpVIJHB2dkbz5s11fq/pKlfbtm3h4uKClJQUHD16tMT0qu/Qs2fPIj4+HgBfW2NjYwM/Pz+NWtxTp04hLi4O+fn5Gq9Xv379YGBggIiICDRp0kSj1lRVposXLyI3NxcNGzaEp6enxvaEhAScPHlSeP9fuXIF8fHxaNasmcb7rTQFBQW4fPkyXrx4AUdHR/j5+QmfC4D/nj5w4ABatmwJd3d33L59G3fu3BF+XJ86dUr4vF+5cgUPHz5Et27dhPdsZmYmLl26hOzsbJ3v+eTkZBw7dgz+/v5wcHDA9evXcf/+fXTp0qXUa0ilYKRShYaGMiMjI/b48WNh3e7du5mhoSGbPn16qfv/9NNPzMzMjPn4+LCAgABmbGzMunbtyp48ecIYY+zIkSMsODiYSaVS5urqyoKDg1lwcDD7+eef2cCBAxkA1qBBA2F9fn4+O3LkCHNxcWEeHh6sT58+rFmzZqxp06bsxIkTwnHz8vLY//73P2ZoaMhatmzJAgICmJGREZswYQLLzc1ljDG2YsUK1rhxYwaADRgwQDjG3bt3SzwfhULBPvzwQ2ZsbMzq16/PgoKCmKurKxs3bhzLz89njDGmVCrZRx99xKRSKfP19WUdO3ZkUqmUDR48mKWkpAh5bd++nQFge/bsYb169WKdOnViTZo0YRKJhP38888ax126dCkzNjZmrVq1Yr169WIeHh6sb9++7Pnz5+zx48fCc9WwYUPhPL799lvGGGPz589nANjly5dZs2bNWEBAAPP29maMMRYWFiakHzBgAPP19WWGhobsww8/1Dj+2rVrGQB2//59YV3Tpk1Z//792caNG1njxo1Zt27dmKmpKWvdurVwnkeOHGFdunRhAFiHDh2EY4WHhzPGGFu+fDkzNTVlfn5+rHfv3szLy4v17NlTeH/osnnzZgaAXbt2TVj3zTffMACsdevWGmkbNmzIBg8ezBhjLCMjgwFgS5YsYYwx9uuvvzJfX18GgPXp00comypfCwsL9vbbb7OlS5cyX19fFhAQwKRSKevZsyfLy8srsXyMMZadnc0GDhzIjI2NWWBgIAsICGBOTk5s0aJFjDHGnjx5wgwMDNj777+vte8///zDAAjP0Z49e5ijoyPz9vZmffr0YU2bNmUtWrRg58+fZ4wxNm7cOGZpacns7OyEc5g0aZKQ3/Hjx5mPjw+zs7NjQUFBzNPTk7m5ubGjR48KaXJychgA9vHHH7MZM2awVq1asbZt2zJDQ0O2bt06plAo2LRp01jLli1Z+/btGcdxbPHixRrlXrZsmXD8fv36sfr16zNjY2ON9/LXX3/N6tevzziOE9IGBwez+Ph4xhhjYrGYzZ8/XyPf7du3M1dXV2ZnZ8e6d+/OGjduzDp06MDu3Lnz0tegPK/fmjVrmLm5OfP29mZdu3ZlJiYmrGPHjiwuLk5Ic+3aNQaArV27loWGhrLWrVszb29vduDAAbZt2zYGgO3evZt17dqVBQQEMHd3d+bk5MSio6PZs2fPWOfOnVlAQADz8PBgFhYWGt9XqtdR9Xz06NGD2draMnd3d+F1VmndujXr3bu3Vrk2b97MGGPs1q1bGs+t6mFubs4AsJycHMYYY4sXLxa29e3bl3l6ejIzMzO2ceNGIe+PPvqIubu7M0NDQ4280tPThffM559/rlG+JUuWMCMjI9a4cWPWuXNnJpPJWN++fVlCQoKQ5sCBAwwA2759Oxs4cCDz9/dnzZo1Y2KxmH3//fcvfV1VduzYwVxcXJiLiwsLCgpizs7OrFGjRuzq1atCmjt37jAAbOXKlWz06NGsZcuWzMfHh+3cuZPt2bOHAWD//vsv69mzJ/P392fOzs7s5s2bjDHGvvvuO2ZiYsIaNmzIunTpwoyMjFiPHj3Ys2fPhPyPHz8uPPf9+/dn7dq1Y/Xq1dN6zaoKBTyV7P79+0wmk7EJEyYwxhg7dOgQMzIyYhMnTmRKpfKl+/77778MAPu///s/Yd3du3eZq6sra926tcb+Dg4ObMyYMRr7qz5QqouEipeXFxsyZIjGutu3b7O9e/cKy1OmTGEymYwdPnxYWHfjxg1mZWXF3n33XWHd559/zgCwjIyMUp4J3gcffMA4jmN//vmnsE6pVLLff/+dZWVlMcYY++GHHxgAtmbNGiHNxYsXmYWFBRs4cKCwThXwdOnShV2/fl1Y/8YbbzATExPhC+L27dta+THG2N69e9nt27c1nquPP/5Yq8yqgGf48OFCnrdu3SrxHFWvm/rzWVLA4+3tzebNmye8ltevX2cSiUTjNVN9KezcuVPjOHFxcYzjOPbDDz9orD948CCLjo4usXwvXrxgHMcJAR1jTAgCRSIRS0xMZIwx9vDhQ+HLjjHtgIcx/iINQLjgqrOwsGCNGjViX3/9tbAuKiqKAWCrV68usXyM8QGqVCrVuGDm5uayX375RVgeNmwYs7W1FQJwlaCgIObg4MDkcjljjP9sjBs3TiPNjRs32MGDB4Xl1q1bs6CgIK1y3Lx5kxkbG7Phw4cL70+FQsGmTJnCLCws2NOnTxljRe+fBg0aCBdOxhh77733mEwmYx988AH7448/hPULFy5kEolE4/x0WbZsGTMwMNB4f8+dO5eJxWKd6YsHPIcPH2ZisZi99dZbGs/TuXPn2IULF1567LK+fpGRkQwAe++994R1Dx48YJ6enszX15cVFBQwxooCiyZNmrADBw4wxvjX9MGDB0LAExAQIARiOTk5wo+tMWPGsJiYGGGfNm3aaAXnxeXk5LBBgwYxb29vplAohPWlBTy6qD6/o0aNKjGNUqlkX3zxBZNKpRo/+iZNmsRsbGx0lq94wLNu3ToGgH333XfCuuvXrzM7OzvWrVs3YZ0q4Gnfvj27dOmSsH769OlMKpVq/MDW5fjx40wsFrN33nlH+Jzk5uayQYMGMVdXV5aZmckYKwp4GjVqxCIjIxljjOXn57N79+4JAU+bNm3YxYsXGWOMpaSksOfPn7OwsDAGgH3xxRfCMWNiYpijoyPr2LGjRjkAsBYtWrBTp04xxvjvmZf9YKtMFPBUgQ8++ICJRCL2yy+/MFNTUzZmzBjhA5iZmcm2b9+u8VC92B07dmT16tUT3pAqq1evZgA0vrDLGvAolUomlUrZjBkzSizvo0ePmEgkYvPmzdPatmjRImZkZCR8eZYn4ElPT2dSqfSlXxqMMebu7s7atm2r89gAhC8+VcCj/qFijP8yB8D+/vtvxljRl3TxgEFdWQKeiIgInfsqlUp2/fp1tnv3buE1NDc3Z3PnzhXSlBTwWFlZsezsbI38evXqxfz8/ITlkgKekydPMgBs27ZtJZ5XSVq2bMl69erFGOO/6IyMjNi6deuYVCplW7ZsYYwVffmqgsKKBDw+Pj5agX2TJk3YgAEDXlq+//3vf8zCwuKl76tDhw4xABqBxK1btxjHcULNT25uLuM4TqvWo7iSAp6JEycyqVTKUlNTNdanpaUxQ0ND9uWXXzLGit4/Xbp00UinCrb9/f011sfGxgq1Herkcjm7ePEii4yMZNu3b2dbtmxhANhPP/0kpClPwNO9e3fm5OQk1EqUR1lfv+7duzNHR0etWp8NGzYwAGzXrl2MsaLAYvjw4VrHUgU86sEVY4x9//33DIDwPKuofhQVf9+lp6ezEydOsIiICLZ9+3b2/vvvMwAatVnlDXj27dvHDAwMWJcuXbSC6/z8fHbhwgW2a9cutn37dvbbb78xAGzDhg1CmvIEPE2aNGFNmjTRes6XLFnCAAhBqirgWbBggUa66OhoBoD99ttvOs9FpVevXszJyUmoVVdRBTiqWirV8qBBg7TyUAU8c+bM0drWqlUrVr9+fY1Ak7Gi7wtV7Zzqu23KlCkvLW9VoT48VWDhwoXYsGEDpkyZgmHDhmHjxo1CO2l8fDxCQkI00m/btg3Dhg3Df//9h759+8LAQPNl6dixIwC+H1BQUFC5ysJxHEaNGoWVK1fizp07GDBgALp27YrmzZsLac6ePQulUgmJRIJdu3aB8YEwAP7W5JycHNy5cwe+vr7lOvbly5eRl5eHrl27lpgmKSkJcXFxCA4O1tqmft7q/QNat26tkU7V10fVH6J9+/bw9vbGiBEjMHz4cAQFBaF79+5wdnYuV/nbtWunte7EiRN48803kZycjBYtWsDCwgIcx0Eul5dpXI8mTZrAyMhIq/wXL14sdd9WrVqhcePGGDduHCIiItCjRw907969THeb9OzZEz/99BNyc3Nx8uRJ5ObmYuDAgdi0aRMOHDiAESNG4MCBA3B3d9foM1ZerVq10uor4u7uLrw2JRk+fDh+/vln+Pr6YuTIkQgMDESXLl2E/hwA0K1bNzRp0gSrVq3C2LFjAQCrV68GYwwTJ04EAEilUgwdOhRLly7F9evX0a9fPwQGBmr1cSnJqVOn4OLiIvSjUn0WGGOwsrLC1atXtc5Xnao/RfH1qtfo8ePHwrrt27dj2rRpYIzB19cXpqamwnNX0TFizpw5g169egn968qrLK/fpUuX0LFjRxgaGmqkU/+89u/fX1iv63Okfjx1ZXn+HB0dwRjDBx98gGXLlsHd3R1eXl6QSqXCMBBPnjwR+ryVx7Vr1xAaGgovLy+Eh4dDKpUK2zZv3oyZM2dCIpGgSZMmMDExgVKpFI5XXnl5eYiOjsbEiRO1nnP151L9+660776SnDp1Ck2aNMG+ffuE73bV+1oikWi9r1/2mhXfplQqceXKFYwYMUKjP1Dx8+jUqVOZ8q9KFPBUAVXHTwAYOnSoRic6U1NTrYu76kOel5en8QWvolqXm5tbofKsX78effr0QXh4OJYuXYqZM2fCx8cH69evR+fOnYXB8U6cOKFz3J7g4GCtL7eyUJVXvRNmcapOh+U57+Kd21RlU6UzMTHBpUuX8Ouvv2Lfvn2YMWMG0tPT0bt3b/z++++wt7cvU/mLp5PL5Rg2bBiaNGmC6OhojS9DS0tL4YvkZXR1zDM0NCzTayuTyXDu3DmsW7cOe/fuxcyZM5GWlobu3bvjzz//1NkRXKVHjx5YunQpjh8/jqioKPj5+cHOzg49e/bEypUrwRhDVFSURsfmiqjo+XXu3BlXrlzB+vXrERUVhe+++w5isRhz5szB4sWLhXTTp0/HO++8gytXrqBBgwbYuHEjOnfurBEQ//XXX9i8eTN27NiBL7/8EjNmzECTJk2wceNGtGnT5qXlyM7ORm5uLn799VetbR06dBA6RZd0vqr3Ymnv0efPn2P06NEIDQ3Fhg0bhO+I1NRUWFlZlem9pEteXt5LP2+lKcvrV97vqZd93ir6/G3btg1fffUVNm7ciDfeeENIt3nzZpw+fbpCz9/Tp0/Rv39/SKVS7N69G9bW1sK2uLg4vPnmm5g4cSJWrVolXNgfPXok/Egsr6r47itJdnY2nj9/rvN93a9fP63g8GWvWfFtCoUCCoWi0t4TVYkCnkp26tQpDBw4EKGhobh58yYWLlyIwYMHC7+4HB0dS7w1UXWnVXGqdcV77pcVx3EYMWIERowYAQC4cuUKhgwZgjfeeAP37t2Dl5cXAGDChAmYMGFCqXmVlepDpLqzSxd7e3sYGxtX+nmbm5tjzpw5mDNnDhQKBbZv346RI0fik08+wapVq8p0HsXT3L59G8+fP8fixYs1gp3Hjx8jLS2t3GUs63HVmZqaYtasWZg1a5Zwd1JoaCgWLVqE9evXl7hfly5dIJPJsH//fhw6dAi9evUCwNf8LFiwAFu2bEFCQgJ69uxZ4bK9qsaNG+Obb74BwN+J9sEHH2DJkiUIDAwUyvvGG29gwYIFWLVqFdq3b4+UlBRhDCoVkUiEMWPGYMyYMQCACxcuYPDgwZg4caLwS7ak8/Dy8sLDhw+r/PbhCxcuIDc3F+PHj9f4QXT9+nWttOV5zr29vV/6easMHh4e5fq8VsV75vjx45DJZEJNn8qNGzcqlF9mZiYGDBiAhIQEHDp0SOvuojNnzkAul2PixIkatRi6jlfW8zU3N4e1tXWVfOcX5+XlBWdn5zK/r192DsW3SSQSODk51fh7oixo4MFKdP78efTt2xf9+vXD+vXr8e233+LBgwdYtmxZmfYPDQ3FmTNncOHCBWEdYww//vgjTE1NKzS+Tn5+PhITEzXWtWjRAp07dxZG8vX390eTJk2wfPlynSPoqlfX2tjYAADS09NLPbanpye6du2KNWvWICEhQWNbamoqCgoKYGBggMGDByMiIgJxcXHCdrlcjlWrVsHFxUWoFi2rhIQEyOVyYVksFmPYsGGwsbERzlkqlcLU1LRM56Hi4OAAQLv6+KuvvqpQDVhJSnqOExMTkZ+fLyyrBjJzcnIqdVRmmUyGzp074++//8Z///0nBDYtW7aEnZ0d/u///g8cx5XaZFqe1788ijcJWFhYCBcz9XMzMzPDuHHjEBYWhuXLl8PMzAyhoaHC9uzsbK1BEdu0aYP27dtr5GNjY6PzHCZNmoR79+5h27ZtWtvy8/O13scVpeu9pFQq8cMPP2iltbGxgUKhKNM0JRMmTMDFixexd+9ejfVKpRLJycmvWGpeaGgo/vvvP5w8eVJj/Y8//giZTFbpg53q4uDggLy8PI2RzJOSkio06rRCocDIkSNx+fJl/PHHH/D399d5PEDz9VIoFPjpp5+00trY2CAzM7NMtT7Dhg3DgQMHhKEuVPmuWLECtra26N69e7nPR5dJkybh5MmTOHHihNa27OxsoUWiokJDQ3H06FGNKY6USiV++uknWFhYCD9YahrV8FSSK1euoHfv3ggICEBYWBjEYjECAgIQHByMJUuWYMKECTrHilH34Ycf4siRI+jVqxfmzZsHJycn/P333zhw4AD++OMPjSrWssrKykLr1q0RFBSENm3awMbGBv/99x82b96MDz74AAD/i/iff/5B37590axZM0yePBlubm548uQJjh8/jtTUVGGcisDAQBgYGGD+/PkYNGgQJBLJS8fh2bhxI3r06AE/Pz/MmDED7u7uiI6OxrZt2/Dff//BwMAA3333nTDGypw5c2Bubo6NGzfi1q1b2LlzZ7mDifPnz+Odd94Rmp/EYjG2b9+O9PR0vPPOO0K6oKAg/PXXX2jatClsbGyEcXhKYmtri3HjxmHp0qXgOA4eHh7YvXs3XFxcXtqcVF7e3t7w9PTE8uXLAQDGxsbw9fVFXFwcJk+ejKFDh6Jp06aQSCTYuXMnnj17hl9++aXUfHv27ImDBw/CyMgInTt3BgAhyNmyZQtatWqlNZ5OcV26dIFUKsWiRYswfPhwSCQSnePwlNdXX32FixcvYsCAAfDy8kJSUhJWrlyJBg0aaDWzTZ8+HatXr8a1a9fw1ltvaVSlp6WloUOHDujduzdatmwJKysrnD9/Hjt27MCSJUuEdD169MCCBQvw7bffwtvbG8bGxujduzfGjh2Ly5cvY/To0di7dy86deoEjuNw8+ZN/P333/j5558r5cu7VatWCAwMxNy5c5GYmAgrKyv89ddfGDBgAP7++2+NtEFBQeA4Du+++y569eoFsVgsjMNT3Lx583D+/HkMGjQI06ZNQ5s2bfDs2TNs2bIFX331Vak1eGWxYMECREVFoV+/fnjvvffg6uqK7du3Y/fu3Vi/fr0QHFSl8ePH4/vvv0f//v3xzjvvIC0tDRs3bsTUqVOxaNGicuX1+++/IzIyEr1794aBgYFWLcigQYPQuXNntGvXDjNmzMDjx49hYmKCTZs2YfDgwdi9e7dG+h49euDrr7/GnDlz0LlzZ4jF4hJ/rC5ZsgSnTp1C165dMXfuXNjY2CAsLAwXLlzAP//8U6GR2nV57733cP36dfTs2RNvvfUW2rRpg9zcXNy4cQPh4eGIiIh4pXFwPvvsMxw/fhzdunXDe++9B3t7e2zZsgXHjx/HX3/9BXNz80o5j1dFAU8lyMnJwcqVKzF8+HD88MMPGgOUff3115g/fz4OHjyoVf1anKmpKY4fP47Nmzfj6NGjuHLlCpo3b47vvvsOjRo10kjbt29ftGjRQmOd6he/egdNKysr3Lp1C1u3bsXZs2eRkpICV1dXHD9+HO3btxfSNWrUCDdu3MCWLVtw6tQpXLp0Ce7u7pgyZYrGh7VRo0bYt28ftm7dis2bN0OpVKJZs2Ylfljc3d1x9epV/Pnnnzh16hSio6PRrFkznDlzRvjCdnR0xKVLl7Bx40acOXMG+fn56NGjB8LCwjQG1XNyckJwcLBW4CeRSDSmQOjXrx9OnjyJTZs24ejRo2CMoU2bNvjhhx+EwQcBvm/TypUrceDAAeTm5qJLly5o06YNmjZtqrMTNcAP8x8YGIhjx47hwYMHGDp0KEJDQ5GRkaHRj0TX1BJBQUE6265btGih8atYIpFg3759+OWXX7B9+3bI5XJMmDABwcHBOHv2LMLCwnD8+HEoFAr4+vpi6dKlWoM06jJw4ECh86J6k9y4ceOQk5Oj0dEU0D21hLu7Ow4ePIhNmzZhy5YtUCgUqF+/PmxtbdG/f3+dg9S1b9++1I7VP/30E86dO4eIiAjs2LEDlpaWeO+99zBy5EitTt6+vr5o3749zp49q9Wc5eTkhJs3b2LLli24cOEC0tLS4ObmhnPnzml0hJ09ezZMTU1x8uRJnDx5EjY2NsLAg99++y1GjRqFf/75B/v374eZmRkaN26MU6dOCT9aVJ+14p9LkUik9RlUUZ8GQiQSYc+ePVizZg0uXLgAY2NjzJs3Dz179kRUVJTGdBFt27bFrl27EB4ejrCwMCiVSnTo0AEmJiZaU0sYGBjgn3/+wZ49exAZGSkMyPjbb79p9T8qrqyvn5GREY4cOYItW7bg0KFDuHr1Kho3bozFixdrlEU1hYP6Z07FxcUFwcHBWgN2lvQZd3R0RHBwsFDD6OrqiqtXr2LVqlXYv38/XF1dsXXrVmRmZuLcuXMaAXhgYKDGBbf41BIODg7C5/23337T+bxIJBIcPnwYq1atwvnz52FqaoqPP/4Y7du3x6FDhzQ++z169MA///yDyMhI4fUKCgqCTCbTmlrC2toa58+fxx9//IETJ04gNzcXHTt2xNq1a4WuBgDf9B8cHKz1/fGy95s6sViMP//8E2+99RZ27tyJyMhIWFtbw9fXF5cvXxZeB1UfUw8PD608VM+Trh83FhYWOH36NMLCwnDs2DFcunQJbdq0wYoVKzRugrCxsUFwcHCpP/6rCscq2juOEEJqQEFBARwdHeHo6KizzwshhOhCfXgIIXXK/v37kZSUhKlTp9Z0UQghdQjV8BBC6oSrV6/i2rVr+Oyzz6BUKnHt2rUKjzdDCHn9UA0PIaROOHv2LP755x8MHDgQhw4domCHEFIuVMNDCCGEEL1HNTyEEEII0XsU8BBCCCFE79E4POBHhHz69CnMzMxqbMhrQgghhJQPYwwZGRlwdnbWmry0OAp4wE8ap2twLEIIIYTUfo8ePSp1gFMKeMDPzwPwT1htGQKbEEIIIS+Xnp4ONzc34Tr+MhTwoGjmVnNzcwp4CCGEkDqmLN1RqNMyIYQQQvQeBTyEEEII0XsU8BBCCCFE71EfnnJQKBSQy+U1XQxCaj2JRAKxWFzTxSCEEAEFPGXAGMOzZ8+Qmppa00UhpM6wtLSEo6MjjW1FCKkVKOApA1WwY29vD2NjY/oCJ+QlGGPIzs7GixcvAABOTk41XCJCCKGAp1QKhUIIdmxsbGq6OITUCUZGRgCAFy9ewN7enpq3CCE1jjotl0LVZ8fY2LiGS0JI3aL6zFC/N0JIbUABTxlRMxYh5UOfGUJIbUIBD6mV5HI5YmJiqHaAEEJIpaCA5zVU0WCiOoOQJ0+eoHHjxoiLi6vyYxFCCNF/1Gn5FSw7cLvajvVuzwaVlldcXBwaN26M+/fvw8PDo8r3I4QQQmoa1fDoufT0dDx9+lRYViqVuHfvHgAgNjYWMTExePz4MRhjiImJQUxMDO7evYu8vDyNfEraryRKpRJxcXFISEjQ2pafn4+YmBgoFAoolUo8fvy41FqjW7duISMjQ2v9nTt3aHwkQgghpaKAR0+lpaWhd+/ecHJyQocOHeDm5oYdO3YgKysL06ZNAwBMmTIFgwcPxqeffgq5XI7Bgwdj8ODB6N27NywtLTFu3DhkZ2cDQIn76RIREQE3Nze0bt0a9erVQ+fOnTWapm7fvo3GjRvjww8/hIODA9q3bw9LS0v8/vvvJZ7PW2+9hQ8//FBjXUxMDBo0aEDNXoQQQkpFAY+eWrZsGZKSkpCQkICHDx/iwoULiI2NhZmZGfbt2wcAiIqKQkxMDNauXQtDQ0Ohhic2NhYPHjzA9evX8e233wJAifsV9/TpU4waNQrvvvsuEhMTkZiYCJlMhvHjx2ulvXr1Kh48eIAnT57g66+/xvTp03XW4gDA5MmTERYWhvz8fGHdunXr0KpVK7Ro0eJVny5CSC2UpVDA8fBlOB6+jCyFoqaLQ+o4Cnj0VHp6OiwsLCCVSgEADg4OmDNnTqn7FRQU4NGjR0hJSUHfvn1x4MCBch33t99+g4ODA+bOnQsAMDExwTfffIMjR47g5s2bGmk//fRTmJiYAADGjh2LrKws3L6tu19UaGgo5HI5IiIihHL++eefmDhxYrnKRwgh5PVEAY+emjFjBh49egQvLy+8/fbb+Oeff1BQUFBieqVSiXfeeQdmZmZo164dgoODsWHDBjx58qRcx7179y58fX01xmBRLd+5c0cjrYuLi/C/qakpAJRYw2NkZIQxY8Zgw4YNAIDdu3cjNTUVo0ePLlf5CCGEvJ4o4NFT3t7eiImJwV9//QUPDw8sWLAA3bp1g1Kp1Jl+w4YN+Pfff3H9+nXEx8fj1q1beP/990tMXxIjIyPk5ORorMvLywNj7JVHq37rrbewb98+PH36FOvXr0dISAisrKxeKU9CCCGvB7otXU/J5XJIJBJ06NABHTp0QJ8+fdCqVSs8fvwYMplMSKNy8+ZNtGrVCt7e3sK6qKgojTx17Vdcy5YtERYWhszMTKHWJioqCgYGBvD19X2lc/Lz80OLFi3wzTffIDIyEnv27Hml/AghhLw+qIZHT02fPh0LFizA4cOHceHCBfz4449wc3ODi4sLHB0dYWFhgc2bNyM6OhqPHz+Gv78/Dh06hE2bNuH8+fOYO3cu9u7dq5Gnrv2Ke+ONN2Bvb4/hw4fjxIkT2L59O6ZPn44ZM2bA0dHxlc/rrbfewvLly+Hi4oKgoKBXzo8QUjOqskMydXYmulDAo6d++OEHWFtb47PPPsP06dMhkUhw5MgRiMViGBgYYNOmTTh27BhCQ0Px6aefYujQofj666+xcuVKvP3228jJycGPP/6oUeOja7/iDA0NceTIEdSrVw//+9//8O2332L27Nn47rvvhDRSqRQNGzaEgUFRBSPHcWjYsKHQ7CWRSNCwYUMYGhpq5D969GiIxWJMmDCB5moihACgAIeUDccYYzVdiJqmuqMpLS0N5ubmGttyc3Nx//59eHp6Ck06pOacOnUKAQEBiI2Nhbu7e00Xh7wEfXbIy2QpFPA+dg0AEBvQDCZicYXS6EoHoEz7kbrvZdfv4qgPD6kTMjIycO/ePSxcuBChoaEU7BBCCCkXatIidcLp06cxatQo2Nvb48cff6zp4hBCCKljqIaH1Am9evVCdHR0TReDEEJIHUU1PIQQQl471NH59UMBDyGEEEL0HgU8hBBCKhXVnpDaiAIeQgghhOg96rRMCCGkVtA1ng4hlaVW1PCkpKQgKSnppWlKmkW7eJrc3NzKKhYhhBBC9ESNBjw7duxAnz59YG9vj969e2ttf/bsGWbPng07Ozs4OzvD0tIS7733ntbkldHR0WjXrh1sbW1hbm6OIUOGIDU1tZrOghR37949hISEwMfHB6Ghobh27Ro8PDyQnp5e00UjhBDymqqxJq28vDysX78eM2fORIMGDXDq1CmtNPv27YOnpydiYmJgY2ODy5cvo1evXhCLxfjqq6+EfAYMGAB/f38cOXIEGRkZ6NmzJyZOnIh///23ak/i8JKqzV9dt4WVllVcXBy6du2KEydOwNXVtdL3mzlzJszMzLB7926YmZnh8ePHiIuLg1KpfKXjE/K6K+tUC3X1eIRUpRoLeKRSKXbs2AEA2L9/v840b775psayn58fxowZg8jISCHg2bVrFx48eICTJ0/C2NgYxsbG+PjjjxEaGoonT57AxcWlak+kDpLL5YiLi0NBQUGV7Hf16lV88cUX8PHxAQBYW1vj/v37wjwnFT0+IYQQUlG1og9Pedy/fx8ODg7C8rlz5+Dt7Q0nJydhXUBAABhjOH/+fE0UsVZgjGHZsmXo2LEjmjdvjkmTJuHJkydIT09HYGAgAKBz587w8PDAm2++iby8PHh4eMDDwwP169dHjx49EBYWJuRX0n7qnj17Bg8PDzx58gRz584V8mvQoAECAwORmZlZpnwIIXUH3YJO6oo6dZfWzp07ERERIdQMAUBCQgJsbW010tnY2EAkEuHFixc688nLy0NeXp6wrI99S3799Vd88803WL9+PerVq4cLFy5g/vz5+P333xEWFobAwEBs2bIFrq6uMDIygqGhIY4cOQKAr4G5cOEC3nnnHRgYGGDEiBEwNTXVuZ86Ozs7HDlyBG3btsWiRYswePBgAMC1a9cwaNAgKJVKmJubl5oPIYQQUtnqTMBz+vRpjB49Gv/3f/+HgQMHCus5jtNqGlEqlVAqlRCX0N68ZMkSfPrpp1Va3pp25coVBAQEoE+fPgCAJk2aYMyYMRCJREIzn6urKzw8PIR91P/38fHBvXv3sH79eowYMeKl+6mIxWJ4eHhALBbD1tZWSJOYmCikKUs+hJCyqwv9bCqzjBXNi255J3WiSevs2bPo06cPZsyYgc8++0xjm4uLC54/f66xTrXs7OysM7+FCxciLS1NeDx69KhqCl6DBg0ahB07dmDy5MnYvn07UlNTSwwAVXbu3In+/fujadOm8PDwwLJly/DgwYPqKTAhpE6gJixSV9X6gOf8+fPo3bs3pk6dKnRUVhcQEIBHjx7h1q1bwrp9+/ZBIpGgQ4cOOvOUSqUwNzfXeOibXr164dKlS3B1dcXy5cvh6Oj40lqtqKgojBgxAv369cOmTZtw+PBhzJo1S6PpjxCivyiQIfquRpu0kpKSIJfLkZ2djYKCAjx79gwA4ODgAI7j8N9//6FXr14YMmQI3n33XWG7SCSCvb09ACAoKAj+/v6YMGECfvrpJyQnJ+ODDz7AjBkzYGVlVWPnVhs0btwYn3zyCT755BNERkZiwIABePvtt4WaHsaYkHbfvn3o1q0bZsyYIax7+vSpRn669quIysqHEEIIKasareEZOnQo/Pz8EBERgWfPnsHPzw9+fn7IyckBAOzevRtSqRS7d+8Wtvn5+aFLly5CHhzHYefOnWjatCmGDx+OWbNmYdq0afjmm29q6rRqhaVLl+LIkSNQFP5Se/bsGQwNDWFqagpHR0eIRCLcuXNHSO/i4oKrV68KzYEHDhzAb7/9ppGnrv0qorLyIYQQQsqqRmt4VHcFlWTRokVYtGhRqfnY2Nhg7dq1lVQq/dC9e3e8//77uHDhAgwNDWFiYoJNmzbB1NQUADB//nwMGjQI9vb26NatG37++Wfs378f9erVg6mpKSwtLREaGopjx44JeRoZGWntt3HjxnKXrbLyIYQQQsqqztylVStV4ujHla1NmzY4dOgQsrOzkZubC2tra43tixcvxscff4wXL17A0NAQRkZGiIyMREZGBnJycmBvb4/MzEytKTqK76fL+fPnNY7XvHlzjYEHy5oPIYQQUlko4NFzqtGndZFKpXBzc9NYZ2ZmBjMzMwCAqampUCNU2n7qim8zNDTUeft5afkQQgghlaXW36VFCCGEEPKqKOAhhBBCiN6jgIcQQipRTY9nU9PHJ6S2ooCHEEIIIXqPOi0TQkgtRfM/EVJ5qIaHEEL0HDVzEUIBDyGEEEJeAxTwEEIIIUTvUcCjx/Ly8rBmzRrMnDkT3377bZn2SUpKwtSpU5GQkKBzua6p6+Un+oGalAipeRTw6LFZs2Zh1apV8PHxgY+PT5n2ycjIwJo1a5CWlqZzua6p6+UnhBBSOegurVew6vKqajvWdL/p5d4nKioKCxYswKRJk6qgRHWDjY0NVq9eDXt7+5ouCiGEkBpEAY8eSk1NxYIFC/DkyRNs2rQJ58+fx8iRI+Hs7Izvv/8eq1atgkjEV+6lp6fj/fffx0cffQRnZ+cKH/PQoUM4ePAgRCIRQkJC0Lp1a2GbQqHAtm3bcPbsWRgbGyM4OBjt2rUTtr///vvo378/unbtKqyTy+V49913MXHiRDRv3hzvvPMOAMDAwAAeHh4IDQ2Fu7u7kP7p06f47LPP8PHHH2Pr1q24e/cuJk+eDFdXV1y+fBlDhw4FABQUFJQ5r08++QQ7d+7ErVu34OnpiUmTJkEmk5X5vAHg4MGDwvZOnTqhf//+FX6OiX4rfgu6iVhcrccjRN9Rk5Yekkgk8PPzg0Qigbu7O/z8/GBnZ4enT59izZo1UCqVQtrs7GysWbMGycnJFT7elClTEBISgvz8fBgZGWHGjBnYu3evsH3o0KF4//33YW1tjfT0dHTu3BkbNmwQtr948UKrj9G+ffuwdu1aeHp6guM4+Pn5wc/PDw0bNsS1a9fQrFkzXL58WUifnJyMNWvWoFOnTrh16xYaN24MCwsLrSat8uTVpUsXXL16FQ4ODli5ciUGDRpUrvOeNm0apkyZAmNjY5iZmWHWrFmYMmVKhZ9nQgghFUc1PHrIxMQEU6dOxSeffILu3btj7NixAIAjR45U+rF2796NdevW4fz582jVqhUAYMGCBXj27BkAIDIyEpGRkYiJiYG3tzcAwNPTE/PmzcOwYcNgZmaGMWPGoH///khKSoKNjQ0AICwsDP369YOVlRUAYOrUqVrnuGTJEvz1118a66dPn4558+YJyw8ePNDYLhaLy5zXvHnz8PbbbwMAevbsiZYtW+LBgwfw8PAo9bz379+Pv/76C7dv34atrS0A4I033oCXlxemTp0q7EMIIaR6UMBDXklkZCTatWuncQEXi8VwcXEBABw+fBjt27cXgh0AGDduHObOnYurV6+iU6dOCAoKgq2tLbZu3Ypp06YhMzMTERER+P3334V9EhISsGXLFjx48ABZWVm4efMmUlJStMpTliajsubVq1cv4f/GjRsDAB49egQPD49Sz3vnzp0wNjbGJ598AsYYGGMAAKlUiv/++48CntdcdTdfEUIo4CGvKDk5GQ4ODiVuf/HiBezs7DTW2djYQCQS4fnz5wAAkUiEkSNHIiwsDNOmTcP27dthaGiIAQMGAADu3r2Ltm3bonPnzujcuTPMzc2RmZmJuLg4reOpaoRKUp68jIyMhP/FhRckReEtxaWdd2JiImxsbODr66uxfunSpRr9lwghhFQPCnheI4aGhgCA/Px8GBjwL31qauor5eni4oL9+/eXuN3NzU2jXwvA15IolUrUq1dPWDd27FgsX74cDx48QFhYGIYNGwapVAoA+PPPP9G0aVPs3LlTSP/06VOcOHGi3OWtrLxKO29nZ2dcvHhRq/mMEEJIzaBOy68Rb29vcByHM2fOCOs2btz4SnmOGDEC169fx7///iusS0pKwrVrfHX94MGD8d9//+H48ePC9mXLlsHLywvNmzcX1rVq1QqNGjXCsmXLcPDgQaHfEQAolUrk5OQIzUIJCQkanZ7Lo7LyKu28R40ahdjYWKxdu1Zjv+PHjyMpKalCZSeEEFJxVMPzGnFwcMD06dMxZMgQDBgwAHFxcUJNT0W1bdsWy5Ytw+jRoxEQEABLS0tcvXpV6H/Ttm1bLFy4EH379kWfPn2QkJCAy5cvC81W6saMGYMPP/wQbm5uCAgIENZPnDgRq1evhr+/P7y9vXHo0CE4OTlV6M6yysqrtPNu06YNVq1ahZkzZ+KPP/6Au7s7oqOjYWZmhvDw8HKXmxBCyKuhgOcVVGQwwOq0dOlStG/fXmPdihUrMGrUKNy7dw8NGzaEr68vfv/9d6GzbfGB+soycN+sWbMwbNgwHD16FDKZDD///DOsra2F7V9++SXGjh2Lc+fOwdjYGN27dxfuxlI3efJk2NjYoEGDBuA4Tljv4eGBW7duISoqCjk5Ofjoo4/AGMPFixeFNC4uLli9ejUsLCw08ixe/ormJRaLsXr1ajRo0KDM5/32229jyJAhOHbsGHJycjB37lz4+fmV+DwSQgipOhTw6LE33nhD5/pOnTqhU6dOwrJ6PxMzM7OXLpfExcUFo0ePLnF748aNhTudSuLg4FDisaytrREaGqqxrlGjRsL/VlZWOvfVVf6K5MVxnM78SztvOzs7YdBDQgghNYf68BBCSAXRpKCE1B1Uw0MIIWVE0zEQUndRDQ8hhBBC9B4FPIQQQgjRexTwEEIIIUTvUcBDCCGEEL1HAQ8hhBBC9B4FPIQQQgjRexTw6Ln79+9j9+7dGnNZvUx2djbCw8ORlZWlc7muqevlJ4QQUjko4NFja9asQcuWLbFy5Urs2bOnTPu8ePECISEhiI+P17lc19T18hNCCKkcNPDgK8g6e67ajmXSvl2591m5ciU+/fRTzJo1qwpKVDcYGxsjODgYpqamNV0UUscUH2TQRCyu4RIRQl4F1fDoodzcXISHh+PRo0d48OABwsPDcf/+fSQmJiI8PByMMSFtXl4ewsPDkZGR8UrHzM7OxrFjx3DixAnk5uZqbX/x4gX27duH48ePIy8vT2Pbrl278OjRI619du3ahYcPH0KpVCI8PBzh4eHYtWsXrl+/DqVSqZE2IyMD4eHhyMvLQ0xMDCIjIxEfHw9TU1OMHz8eZmZmAFDuvB49eoSDBw/i7t27FTrvzMxMHDlyBMeOHUNqaupLn8Pijhw5gtjYWGH51q1bCA8Ph1wuF9YdOHAADx8+LPH8VaKjo7F7925cvXpV6zi3b9/GsWPHoFAocO3aNRw6dAhJSUla6ZRKJc6ePYujR48iOTkZcXFxOHjwYLnOiRBCagrV8OihrKws/Pbbb8jJycHx48dx//59TJkyBcbGxggJCYFcLoeBAf/Sp6SkICQkBNeuXYOvr2+FjvfXX39h6tSpcHFxgZWVFRITE7Ft2zYhvx9++AELFy5Ey5YtkZiYiMzMTERERKB169YAgB9//BGenp5Ys2aNkOelS5cwcOBA3L59GwqFAr/99hsAQC6X48qVK3BxcUFkZCRsbW0BAHFxcQgJCcHQoUNx5coVNG7cGIsWLYKDgwNCQkJw584d1K9fv1x5hYaG4sqVK3B1dcWpU6ewYMECfPzxx2U+761bt2Lq1Klo1KgRJBIJrl69ihUrVmDMmDFlel7Xrl0LIyMj/PrrrwCAjz76CFu3bsXx48fRuXNnZGZmol+/fjhx4gTS09N1nr+1tTWGDx+OY8eOoWXLlrh69Sr8/PwQHh4u1Hpt3boVGzZsgK2tLSQSCXJycnD37l3s2rULXbp0AcAHbn379sXNmzfRvHlzxMTEoHnz5rh7926JwSAhhNQmVMOjh2xsbBAeHg5LS0vMnj0b4eHh6NevX5UcKzo6GuPGjcOXX36J69ev4/jx49izZ4/QSTg6Ohpz585FWFgYTp48iZiYGHTv3h3jx4+HonCyxbFjx2Lbtm3Iz88X8g0LC0O7du3g4+MDiUQi1MpERkbi/v37MDc3x5dffqlVHplMhlu3biEiIgLt27fX2l6evKytrRETE4OoqChs3rwZX3zxhVDzUdp537p1CxMnTsSOHTtw6tQpHD16FH///TemTJmiszZLl8DAQBw5ckRYPnbsGPz8/IR1x48fh0wmEwJHXee/fPlynD9/HtevX8ehQ4cQHR2N2NhYLF68WONY9+7dw0cffYQTJ07g4sWLCAkJwUcffSRsX7ZsGR49eoSbN2/i0KFDOHfuHC5dulSm8yCEkNqAAh7ySv744w94enpi+vTpwjoPDw8h2Pjrr7/QuHFjhISEAAA4jsOHH36I69evC80rISEhyMvLEzpWK5VKbNmyBWPHjtU41p07d3DgwAFERkbCw8MDp0+f1irP7NmzIRKV/rYuS17/+9//wHEcAKBHjx4oKCgQajNKO+8//vgDrq6uSEtLw86dOxEREYGsrCzIZDKcPHmy1PIBfMATGxsrBBo5OTmYPXs2Dh8+DIBv8urcubNQW6fr/Ddt2oRJkybBxcUFAGBvb49p06YhLCxM41j169dH//79heUePXogJiZGWN66dSsmTZoEOzs7AICrqyvGjRtXpvMghJDagJq0yCt58OABGjVqVOL2+/fvw9vbW2Odt7c3RCIRHjx4gJYtW8LMzAyDBg1CWFgYgoODcfjwYbx48QIjR44EwPeTGTRoEC5cuICWLVvC3NwcDx8+1NknRnVhL0l58rKxsRH+l8lkAICcnJwynfe9e/eQkZEhNEepdOnSpcwdqH18fODi4oLDhw8jKysLAQEBCAoKwrRp05CXl4cjR45gyJAhGvsUP39dz7+Pjw8eP34MhUIBcWFHXPVzVZ2v6lwBvpnPy8tLI42np2eZzoMQQmoDCnheI6pf/sU7Lb8Kc3NzPH78uMTtNjY2ePjwoca69PR0KJVKjYvsmDFjEBoaivT0dISFhaFXr15CbcIvv/yCuLg4PHnyBCYmJgCAr7/+GqtXr9Y6nqpGpiTlyetlSjtvMzMzuLq6Ijw8vFz5Fte1a1ccOXIEWVlZ6NatG1xdXeHk5ISDBw/i0qVL+PHHHzXSFz9/GxsbrWAuNTUVFhYWQrBTFlZWVkhLS9NYV3yZEEJqsxpt0rpy5QqmTp0KKysrdOrUSWeap0+fYvjw4bCxsYGLiwvmzJmjdZEuSxoCODs7A4DGnT/Hjh17pTx79uyJs2fPauQJ8J2hAaBjx444e/Ysnj9/Lmzbvn07TE1N0axZM2Fdnz59YGpqik2bNuGff/7RaM56+vQpvL29hQAFAHbs2FGh8lZWXqWdd8+ePXHhwgVcvnxZY3tmZqZGzcnRo0dx8eLFEo8TGBiIw4cP49ixYwgMDBTWffHFF1r9d3Tp2LGj1vlt374dHTt2LO0UNfj7+2PXrl0a6yIjI8uVByGE1KQaq+HJy8vDm2++iSlTpgh3yxSnUCjQv39/2NjY4OzZs0hJScHQoUORlZUl3NFTljSE5+3tjXbt2mHChAmYMWMG4uLitJpcymvIkCHo06cPAgICMHfuXFhaWuLvv//G5MmTMWTIEAwbNgw//fQTevTogVmzZiEhIQFffPEFPvvsM1hZWQn5GBgYYPjw4ViwYAGUSiWCg4OFbf369cP333+Pjz76CD4+Pvjrr79w/fp1WFtbl7u8lZVXaec9dOhQDBkyBD169MCcOXPg7u6O6OhobN26FUePHoWRkREA4N1334Wfnx/Wr1+v8ziBgYGYMmUKrKys0KJFC2Hd+vXr0adPH43+O7p89tlnaN26NUaOHIn+/fsjKioKUVFROvssvcyHH36Itm3bYsKECejevTt27dqFmzdvCne2EUJIbVdjAY9UKhV+/c6ePVtnmv379+Py5cuIjY0V+g8sXrwY48ePx5dffglbW9sypXld9e3bF25ubsIyx3HYu3cvvv/+e+zZswcNGzbEwYMHMXfuXJibmwPQHqivtIH7RCIRtm/fjrCwMBw8eBAymQyzZs1C7969hWPu27cPa9asQVRUFIyNjbFlyxYMHDhQK6/JkyfjyZMn6NChA4yNjYX1gYGB2L17N/766y/cvXsXvXr1wtSpUxERESGkMTc3R3BwsNDXRqV4+Sual0gkQnBwsPB+Kst5b926Ff/88w/27duH6Oho+Pr64tSpU0JTXVZWFm7evPnSwNzHxwdjx45F/fr1hSbJoKAgBAcHY8SIEaWev7e3N/777z+sXr0aO3fuhKurKy5evKjR/6hhw4Za4zC5uLhodGJu2rQpTp06hZ9//hlRUVEIDAyEn58ftm7dWmLZCSGkNqnVfXhOnDgBd3d3jc6SQUFBUCgUOHPmDAYMGFCmNFWlIqMfV6cNGzZorbOyssLnn3+usU69n4m9vf1Ll3URi8V444038MYbb+jcbmRkVGJQq65ly5YlHqtXr17o1auXxjr117ZevXo699VV/orkJRKJtNaVdt4cx2HYsGEYNmyYzu2xsbFYsGAB2rZtq3O7yh9//KGx7OzsrFWWks4f4DsXL126tMT8Q0NDERoaqrHO398f/v7+wrJCoYCPjw9+/vlnYV2PHj3QsmXLl5adEEJqi1od8MTHx8Pe3l5jnZ2dHTiOw7Nnz8qcpri8vDyNPj7p6emVXHJCSte8eXM0b968potRJnK5HF27dsXo0aNhY2ODiIgInD9/HsuXL6/pohFCSJnU+nF4io+poroLRf1Oo7KkUbdkyRJYWFgID/VmH0KINplMhs2bNyMhIQH79+9H06ZNcePGjQqPzk0IIdWtVtfwODg44OjRoxrrEhMTwRiDg4NDmdMUt3DhQsyZM0dYTk9Pp6CHkFL4+PhgyZIlNV0MQgipkFpdw+Pv74979+5pDMV/+PBhiEQitGvXrsxpipNKpTA3N9d4EEIIIUR/1eqAp2/fvmjUqBHeeecdJCYm4s6dO/j4448xatQoODo6ljkNIYQQQl5vNRrwtG7dGjKZDCtWrMClS5cgk8kgk8mECRglEgkiIyORnZ0NZ2dn+Pn5oWPHjhp3ipQlDSGEEEJebzXah+f06dNQKpVa69XHEvHy8sKBAwegVCpLnBSyLGkIIYQQ8vqq0YDH0NCwzGnLEshQsEMIIYQQXShCIBXGGENubm5NF4MQQggpFQU8ekoVjJQ0FlFl5Hfjxg0YGRmVOMAjIYQQUltQwKOnYmNjYWRkhLi4uFqZHyGEEFKdKODRU/n5+QD4aTRyc3Mhl8u1mqAKCgqgVCqhVCp1Nk2p1+joyq+4yqpNIoQQQiobBTx6KC0tTZjUsXnz5rC0tMTQoUOFJqiVK1fC09MTJiYmiIyMxLFjx2BkZISCggIhj2fPnsHIyAg3btwoMT+V7du3o2nTppDJZPDx8cG+ffuq94QJIYSQUlDA8wqysrJKfBSvMXlZ2pycnFLTloeFhQVu3LgBALh16xZyc3MREREhbF+3bh327duHvLw8DBw48JXz+/333xEREYGMjAwMGzYMY8aM0TonQgghpCZRwPMKTE1NS3yo14AAgL29fYlp+/btq5HWw8NDK01l+uqrr9CgQYNKy+/bb7+Ft7c3DA0NMXfuXCQlJeHWrVuVlj8hhBDyqijgeQ01bty4UvPz8vIS/re0tAQApKamVuoxCCGEkFdRq2dLr+0yMzNL3CYWizWWX7x4UWLa4gMmPnjw4JXKVRqJRKKxzHGcVhpdI2CXRNf+hBBCSG1CAc8rMDExqfG0JVEFNQqFotS0VlZWAICkpCQ4ODgAgFaTVHnyI4QQQmobatLSU05OTpDJZDhy5Aiys7N13kau0rBhQzg6OuKLL75AYmIiLl68iHfffbfC+RFCCCG1DQU8esrQ0BArVqzAkiVLYGdnh6FDh0IkEkEqlWo1QUmlUmzbtg1nzpxBw4YN8b///Q/vv/8+pFKp0NxW1vw4jtPYjxBCCKkNqElLj02aNAmTJk3SWFfS3FedO3fG+fPnNdaNHj263PmJxWKaX4sQQkitQz/DCSGEEKL3KOAhhBBCiN6jgIcQQggheo8CHkIIIYToPQp4CCGEEKL3KOAhhBBCiN6jgIcQQggheo8CHkIIIYToPRp4sBrJ8xT4ZdZRAMCUH7pCIhWXsgchhBBCKgPV8JAas3fvXoSGhtZ0MQghhLwGKOAhNebZs2c4ffp0TRdDEBkZiZEjR5aaLi0tDT/99BN69uyJjz/+uBpKRggh5FVRwENqTJ8+fbBt27aaLoYgPj4eZ86ceWmauLg4NG7cGDExMUhPT8eNGzeqqXSEEEJeBQU8NSQzNa/Kj5Gfn48VK1Zg8ODBGDJkCL777jvk5+cL21WzoqubPXs25s2bBwDYvn073njjDRw9ehSTJ09G3759sXTpUsjlco19Xrx4gUWLFqFv374YO3asVhCjyufEiRMYM2YMunfvjszMTFy+fBnff/+9Vrr9+/fjrbfeQr9+/bB48WLI5XLs27cPo0aNwqBBg/Drr79qnWtZy3D69GlMmTIFAwcOxJdffom8PP51OHHiBL755hs8e/YMgYGBCAwMxKZNm7SO4+DggLt372LlypVwcnIqy8tACCGkFqBOy9Uo5nS88P/mT84gcGwjNOnkXCXHUiqVGDhwIHJzczFjxgxIJBIsX74ce/bswcGDBwEAb7/9Ntq2bYvWrVtjxIgR2LBhA9auXYtLly4BAJ48eYKtW7fi1KlT+OSTT6BUKvHBBx/g7t27+OWXXwDwtSLt2rVDnz59MH36dCQmJmLevHm4desW/u///k8jnytXrmD+/PlwdnaGTCbTatJSpbt58ybef/99ZGZm4t1330VkZCSUSiXmzZuH5ORkzJ49G8bGxsJs7uUpQ3R0tBDQLViwAPHx8VixYgUaNWqEQYMG4Y8//sAnn3wCAPDy8tJ6XmUyWRW8WoQQQqoaBTzVJDMlF8f/ui0sMwYcCYtBvSbWMLWq/Ivo33//jWvXriE2NhZGRkYAgKCgIDg5OeHYsWMICAiAr68vli5diqlTp8LOzg4zZ87EsmXL0LBhQyGfvLw8bNmyBW3atAEAuLu7o3v37liwYAG8vLzw+eefo02bNli7dq2wT7169dC/f3/Mnz8fEokEAF/btH37dp1BhDqFQoGdO3fC0dERAHDlyhWsWbMGjx49gq2tLQDg7NmzCA8PFwKespZBlbeqZiYrKwsffvghVqxYAVtbWzRs2BAymQyBgYEVft4JIYTUThTwVJPUFzlgTHMdUwJpL3KqJOCJiopCXl4eBg4cCMYYWOHBGWO4efMmAgICAPDNWnv27EGPHj0waNAgTJkyRSMfa2trIdgBgK5du0IqleLixYvw8vJCVFQUFAoFevToIRwnNzcXeXl5uHfvnhA8OTs7lxrsAHygogp2AMDFxQVeXl5CsKNad/t2UfBY1jLUq1dPoxmqXr16ePbsWZmfU0IIIXUXBTzVxNLeCBwHjaCHEwEW9kZVcryMjAw0aNBAaNJRV79+fY1le3t7MMbg5+enldbMzEznutTUVOE4wcHBGDFihFY6FxcX4X9TU9MylVtVG6PCcZzOdUqlUlguaxl05cOKR6GEEEL0EgU81cTUSoYuIxrg2Ba+ZoLjgMAxjaqkdgfg+58cO3YMnTt3hoFByS/z33//jS1btmDJkiX46KOP0K9fP7Rr107Y/vTpU2RlZcHExAQAkJKSgoSEBHh6egrHSUlJqdFmoMoqg0hEffgJIURf0Td8NWrkX9ScMuqTDlXWYRkAxo8fj+TkZCxatEioDVEoFFi7di3i4/nO048fP8aUKVPw1VdfYcGCBZg0aRLGjh2LrKwsIR+5XI4vvvhCWP74449Rr149dO3aFQAwbdo0bNu2DREREUKatLQ0jbuvqlpllcHe3h6JiYkad7IRQgjRDxTw1BBTS2mV5l+/fn2Eh4dj8+bNcHZ2Rtu2bWFvb48LFy7AwsICjDG88cYbaNOmDWbNmgUA+P777yEWizF79mwhHxcXF5w/fx7169eHt7c3wsLC8NtvvwnNQ2PGjMFXX32FMWPGwMfHBy1atEDDhg0hFlfftBmVVYZu3brB1dUVjRo1KvG2dADo27cvAgMDceLECRw9ehSBgYEIDg6ujFMhhBBSRahJS4/16tULDx48wM2bN5GTk4NGjRoJfWkyMzPx0UcfoXnz5uA4DgBgZGSEgwcP4u7du1AoFAD4vjcHDx7Eo0eP8PTpUzRr1gzGxsYax3nvvffwzjvv4MaNG5DJZGjYsKFGf5mQkBCNZjKVPn36aNwRpivdiBEjtJqqxo8frxVgVKQMrVu3xuHDh4VlExMTXL9+HTdv3kRycrLQbFfcBx98IDw/KsX7BxFCCKldKODRcyKRCE2bNtVab2pqqrPPi4uLi0ZHXxU3Nze4ubmVeBwjIyONu7nKkqejo6PWHVnF0+k6roeHBzw8PF65DFZWVlrPgYGBAZo1a6YzD5UuXbq8dDshhJDahwKeaiSRijHj5+41XQxCCCHktUMBDylRSU1RhBBCSF1DAQ8pUUlNUYQQQkhdQ3dpEUIIIUTv1fqA59q1a3jzzTfRtm1bdOrUCXPmzMHz58810mRkZOD9999H69at0alTJ/z4448aI/ESQggh5PVWq5u0njx5gi5dumDQoEFYtWoVMjMz8cEHH6BHjx64du2akG7IkCFISEjAt99+i5SUFLz99ttISEjA559/XoOlJ4QQQkhtUasDnjNnziAtLQ0rV64U5nT69NNP0bt3bzx9+hTOzs44duwYDh48iKtXrwq3EycmJmLOnDl47733YG5uXpOnQAghhJBaoFY3abVp0wZGRkbYvXs3AECpVGLPnj1o1KgRHBwcAACHDx+Gs7Ozxtgp/fv3R25uLs6cOVMj5SaEEEJI7VKrAx53d3dERUVh9uzZcHV1hZ2dHY4dO4ZDhw4J0wY8evQITk5OGvupBrN7/Pixznzz8vKQnp6u8agOWQoFHA9fhuPhy8gqNlLv6+jatWtYtWpVTReDEELIa6BWBzzx8fEYPXo0evbsiX/++Qfbtm2DVCrFm2++qTEhpqGhocZ+EokEIpEIBQUFOvNdsmQJLCwshMfLRhAmVefixYtYvHhxTRdDcPXqVaxevbrUdGlpadi+fTtWrFiBPXv2aE0zQQghpPap1QHPL7/8gtzcXGzYsAHt27dH9+7d8eeff+LAgQM4ePAgAMDGxgaJiYka+yUnJ0OpVMLGxkZnvgsXLkRaWprwePToUZWfC9HWrFkzzJgxo6aLITh37hy+/vrrl6b5888/0aJFC/zxxx+4desWZs2aBT8/P633ICGEkNqlVndazszMhKWlpcas16ogJjMzEwDQtm1bLF++HAkJCbCzswMAnDp1CgBKnFdJKpVCKq3a2cpri9u3b+PQoUMQiUTw9/fX6Ou0Zs0auLm5oV+/fsK6iIgIvHjxApMnT8alS5dw8eJFDBs2DFFRUXjy5Am6du0KPz8/reMcP34cly5dgo2NDbp37w5nZ2dhmyqf0NBQ7Ny5E/Hx8Zg1axYMDQ1hYWGhlW7o0KE4fPgwnjx5gk6dOqF169ZISkrCrl27kJWVhR49eqBBgwYVKsOIESNw8OBBxMfHo127dmjbti0A4M6dO9izZw/S0tLw1VdfAQACAwPRoUMHjWN4eXnhypUrQrmzs7PRrFkzfPbZZ/jxxx/L89IQQgipRrW6hicoKAi3bt3Ctm3bAPCdlr/88ksYGxsLF6KBAwfCwcEB//d//weFQoGMjAx88cUX6NOnD9zd3Wuy+C8Vnyev8mN89dVX8Pf3x7lz53Dx4kV069ZN41Z9S0tLDB06FNevXwcAISixtbUFwAeOCxYsQJs2bRAeHo6zZ8+iXbt2WLt2rZCHXC5HcHAwJkyYgNu3b2Pnzp1o2rQp9u7dK6RR5dO+fXscOHAAycnJYIxpNWmpH2/37t04efIk2rVrhw8//BDt2rXDiRMnEBUVBT8/P1y8eLHcZVi4cCH8/f0RERGB8+fPo3Pnzli3bp2QR05ODpRKJVJTU5Gamoq8vDyt57Rjx44aQZqxsTFatWqF2NjYCr9OhBBCql6truHp06cPvv32W0yZMgUzZ85Ebm4urKyssHXrVuHXu7GxMXbs2IHRo0fDxsYGubm58Pf3x2+//Vazhddha3yy8H/A2Rh829ANo511N7u9qrNnz+LLL7/ElStX4OXlBQCYPXs2WrRogdDQUDRq1AgjRozA7t27MWrUKBw5cgRjxozB+PHjMXjwYCGf5ORkLF++HOPGjQPAzxT+3nvvITQ0FJaWlli2bBkePnyIGzduCLVma9euxeTJk/Ho0SNwHCfks2nTJvTu3ful5U5OTsauXbvg7+8PABgzZgwWL16M8+fPo1WrVgCA4OBgrFy5EuvXrweAMpchKSkJO3bsQKdOnQAAPj4++PrrrzFp0iQ0adIEQ4YMQXR0tFDDUxbJyck4dOgQZs6cWeZ9CCGEVL9aHfAAwJw5c/Duu+8iPj4ehoaGQu2DujZt2uD27dt49OgRpFIp7O3ta6CkL/c0Nx+L7jwRlpUA3rv1CIHWZnCWGZa8YwVt3boVdnZ2+Pfff8EYA2MMAGBiYoJz586hUaNGAIAVK1bAz88PzZo1g7m5OZYtW6aRj7GxMUaPHi0sT5o0CTNnzsSJEycwYMAA/PXXX7C1tcVPP/0kHCcpKQlPnjzBo0ePUK9ePQCAtbV1qcEOADg7OwvBDsD38zlz5owQ7KjWnTx5UlguaxmcnZ2FYAcAWrVqhU8++aSsT6mWgoICjB07FtbW1nj33XcrnA8hpHTxeXLUNxaXnpCQEtTqJi0VjuPg7OysM9hR5+bmViuDHQC4l5OH4pNdKADcz9FuNqkMT58+hUQiQWJiIpKSkpCcnIzk5GS8/fbb8Pb2FtKZmZlhzJgxiI+Px8yZM2FsbKyRj729vUYfKlXQ+fTpU+E4ADSOw3Ec5s+fD4lEIuyn6l9VGtUAkyoGBgY618nlRU2CZS1D8XwkEkmJd/KVRqFQYNy4cbh27Rr27dtHA1wSUgWK14pveppUg6UhdV2tr+HRF15GUogAjaBHDMDTqGo6T9va2kIqlZbaPBMdHY1vvvkGQUFB+OyzzxAaGqoRnCQmJoIxJjQLFRQUICkpSRjryNbWFo0bNy5XM1Blq+4yKJVKvPnmmzh+/DiOHDkiNBkSQipPfJ5cZ614O0uTmisUqdPqRA2PPnCWGeJLHxdhWQTgm4ZuVdKcBQAhISG4du2aMEq1SmxsLNLS0gAA+fn5GD16NEJDQ7Fv3z54eXlh4sSJGukzMzPx77//CsthYWEwNDQUmp1CQkLwxx9/CLUsKuqdiqtaZZXBwsICWVlZL02jCnaOHDmCw4cPo379+uUuLyGkdA9KqBWPK2eteHXcIELqBqrhqUbDnayxsPAXy7H2jVDfWFZlx+revTs++OADDB48GCNHjoS7uzuio6MRExODo0ePAigaj2jFihUQi8UICwtDixYt8PPPP2Pq1KkA+Du55syZg8OHD0OpVGL9+vX44osvhFqghQsX4vTp02jRogVGjhwJY2NjnD17FlZWVti+fXuVnZ+6yipDhw4dkJ6ejsmTJ6N+/fo6b0v/6KOP8Oeff2LSpEn4559/hPUODg6YMGFCpZ0TIa8TXf1zPEqoFXcvpVY8Pk+O48kZwrLqBpFgB8tKKy+pmyjgqSFOUknpiV7Rl19+iZEjR2L//v3IycnBuHHj0L9/f0gkEqSnp0MqlWLr1q1C/xNPT09s3boV58+fF0YPdnBwwOHDh7Fr1y48ffoUe/fuRWBgoHAMIyMj7N+/HwcPHsTZs2chk8nwxRdfoHPnzkKa1q1bY8qUKVrlKz7woK507du31xpJu3PnzkKT2quUwcPDA/PnzxeW3dzccPHiRezZswfJyck6b0tv2rSpsE9qaqqwvnjfJ0LIy+m6a1U9KHGSSvClj4vwI1FVK67ru1M9ry5nYzS2UVMYUaGAR881a9ZMY7BBFXNzc53TOvTp0wd9+vTRWOfk5IS33nqrxGNwHIeePXuiZ8+eOrf7+/tr3Hml0rp1a7Ru3fql6bp06YIuXbporOvRowd69OjxymWoX7++Vr8fX19f+Pr66swDAEaNGoVRo0aVuJ0QUrqS7lotHpToqhUvPg9h8byYjuNVpCmM6B/qw0MIIaRalXTX6suCkpJqxXXlVVxpTWHUz+f1QAFPNTIRi/Gsmx+edfODibj2jydRUlMUIYSUla5gQnXXqrqy9M/RRVdenNr/JTWF0S3vrx8KeEiJ/P39MWfOnJouBiGkjikeTKgvAyXftaoelJS11kVXXovVlo+1b6Q1on1Jt7w/zc0v0zFJ3UQBDyGEkEqjq3+O+rLKcCdr4X9VUFJaoFSS4nmpL+tqCivplveqGgiW1A4U8BBCSB1U3f1Oyno8XX1qSutj4ySVlDlQKk1Z7oD1KKFJraoGgiW1AwU8ZaRUlvaRJYSoo89M5avufiflPV58nlxnn5qyXGgqEihVlOqWd5WqHgiW1A50W3opDA0NIRKJ8PTpU9jZ2cHQ0FCYZoEQoo0xhvz8fCQkJEAkEmmNo0QqpixTLcTnySttjK+y3jquazyd4uPnqC+XNAmorul3ii9XpuocCJbUDhTwlEIkEsHT0xPx8fFaUxcQQkpmbGyMevXqQSSiiuTKUFK/k41PEoXlgLMxGjUXr6Ist45fSc/WGRQdbd9IWHesfaMyjXys6nxcUqCkS0VnUC8eGFbHQLCk5lHAUwaGhoaoV68eCgoKhBGICSElE4vFMDAwoNrQSqRrqgURgHWPiwKeivZ7KU69aar41A7XMnKE5aGXY7UG+tM1nk5ZJwEtXuviJJVoBTyljdBckuL7VVZgSOoOCnjKiOM4SCQSSCT0S4AQUv10TbXwtpsdVj9K0EhX0SagsjRNLfJywhf34oV0ukY1Lj6eTkUnAdVV61LWZray7FcZgSGpW6iumRBC6ojit1+/5WpXoQ7CxZXUP6iLtZnG8ZqbG780oNI1nk5Jd0RVZJDBiozQXNJ+1KX+9UMBDyGE1EFOUonOQfcq0lRTlloYJ6mk1DuwdA3yV9IdURXpN1PREZoreucY0S/0mhNCSBWpjrFyXjboXlmPX9ZamNICrJKCGF2DDFZEWUZoLut+1Ifn9UMBDyGEVKKqGiunLMGLk1RSoeOXpxbmZQFWWbzqHVEVDZ5etdyk7qOAhxBCKklJnWorWtNT3qkWSuqLo378kspSkUCipm/nrujxa7rcpGZQwEMIIZWkop1qdanInUVlHauntFofCgiIPqKAhxBCKklZOtVW5ZxUuvri6Bqr51VqnQipqyjgIYSQSlJSp9riIw2XZRbwitxZpKsvzttudpVW60RIXUYBDyGEVKLifWECrc3K3TQVnyev8J1FZRmrp6K1ToTUZRTwEEJIFXGSSkptmlIFG7rurqqMO6Iqs9aJkLqMAh5CCKlCupqm1GcYCzgbg1Vxz0u9u+pVOhJXRq0TIXUdBTyEEFKFitewFJ9OVQngi3vx1dbPpiy1ToToIwp4CCGkiqnXsPzQyE1r0k0ltAOhis43VRY01QJ5HdF7nBBCKkFZO/62sjDR2Yl4vqejsPwq802VBU21QF5HFPAQQkgFxOfJK3Uah7fc7IR1rzLfVFnRVAvkdWNQ0wUghJC6Qj3A6XI2RmObqqNxO0uTUvMZ7mSNhYWdhI+1b4T6xjJkKRTC9uoe6ZhGViavAwp4CCGkDIpP9VC8Hw5QsY7GFGwQUj2oSYsQQspA151NxVVlR2NCyKspd8Cze/du/P7778jOzq6K8hBCSK1U2ng6Vd3RmBDyasod8OTn52PmzJlwcnLC22+/jbNnz1ZFuQghpNYoaaqHxWrL1dHRmBBSceUOeAYPHoz4+HisXLkSd+7cgb+/P5o2bYrvvvsOL168qIoyEkJItSvvVA9Us0NI7VahPjxGRkYYO3YsDh06hNjYWAwbNgw//fQTXF1dMWTIEOzbt6+yy0kIIdWmeAflyp7qgRBS/V650zLHceA4viVbJpMhKysLwcHB6NSpE5KTaTI6Qkjdo6uDclVN9UAIqR4VCnhycnIQFhaGoKAgeHl5Yd++ffjwww8RHx+Pffv24dGjRxCJRFi/fn1ll5cQQqqcrg7KdAcWIXVbucfhCQ8Px/jx42FgYICxY8fixx9/RNOmTTXS2NnZYdCgQXj+/HmlFPLGjRv45ZdfcP/+fbRs2RLz5s2DmZmZsF0ul2P16tWIioqCTCbDiBEjMGTIkEo5NiHk9aPqoKwaHJDuwCKk7it3DY9UKsXq1avx5MkTLF++XCvYUZkzZw6WLFnyygXcuXMnWrduDQCYMmUKzMzM8Oabb2qkGTduHJYtW4aQkBB06NABY8aMwQ8//PDKxyaEvL6Kd1CmO7AIqdvKXcPTt2/fMqUTi8XlLkxxmZmZGD9+PObMmYPFixcDAAYMGIDMzEwhzYULF/DXX3/h5MmT6NixIwCgoKAAH330EaZMmQIjI6NXLgch5PVGNTuE1H21eqTliIgIJCcn43//+5/GelNTU+H//fv3w97eXgh2ACAkJATp6ek4c+ZMtZWVEEIIIbVXrZ5L6/r163Bzc8Pjx4/x/vvvIzs7Gy1btsTMmTNhbm4OAHjw4AFcXFw09nNzcxO26ZKXl4e8vKK7LdLT06vmBAghhBBSK9TqGp7s7GykpqZi4sSJ6NmzJ0aMGIGIiAj4+/sjJycHAD/yc/FmK0NDQ4hEIuTn5+vMd8mSJbCwsBAeqgCJEEIIIfqpVgc81tbWyMjIwK+//oo33ngDw4cPR0REBKKjoxEZGQkAsLKy0hrvJzU1FUqlElZWVjrzXbhwIdLS0oTHo0ePqvxcCCGEEFJzanXA06pVKwCAu7u7sM7BwQEymQwJCQkAAD8/P9y7dw9paWlCmkuXLgnbdJFKpTA3N9d4EEIIIUR/1eqAp2fPnqhXr57GAIabN2+GXC5H586dAQDBwcEwMTHBt99+CwBQKBRYunQp/P390aBBgxopNyGEEEJql1rdaVkqleLvv//GkCFD8Oeff0ImkyE2NharV69Gs2bNAACWlpbYvHkzRo8ejb///hvp6ekwMzMTmrwIIYQQQmp1wAMAbdu2xf379/Hff/9BJBKhUaNGMDEx0UjTu3dvPH78GJcvX4ZUKoWfnx9EolpdeUUIIYSQalTrAx4AMDAwQNu2bV+axsjICP7+/tVUIkIIIYTUJVQNQgghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsU8BBCCCFE71HAQwghhBC9RwEPIYQQQvQeBTyEEEII0XsGNV2A8vjwww8RHx+Pb775BlZWVhrbIiIiEBUVBZlMhmHDhqFt27Y1VEpCCCGE1DZ1poZn2bJlWLduHdatW4esrCyNbXPmzMGECRNgZWWF3NxcdOzYEVu2bKmhkhJCCCGktqkTNTyXLl3C999/j2+++QZjx47V2BYTE4Ply5dj165d6NevHwDA1NQUs2bNwrBhw2BgUCdOkRBCCCFVqNbX8GRmZmLkyJFYvXo1HBwctLbv2rULlpaW6N27t7Bu9OjRePHiBc6ePVudRSWEEEJILVXrA55p06ahR48eGDBggM7td+/ehZubG8RisbDOy8tL2KZLXl4e0tPTNR6EEEII0V+1ur1n48aNuHDhAi5dulRimpycHJiZmWmsMzIyglgsRk5Ojs59lixZgk8//bRSy0oIIYSQ2qtWBzyff/45nJ2d8b///Q8A8PTpUwDA+++/j+DgYIwYMQLm5uZISUnR2C8tLQ0KhQLm5uY68124cCHmzJkjLKenp8PNza2KzoIQQgghNa1WBzxffvklMjIyhOWbN29iz549aNmyJdzd3QEAvr6+WLduHXJycmBkZAQAuHHjhrBNF6lUCqlUWsWlJ4QQQkhtUav78IwYMQKTJ08WHn379gUAjBo1Ch06dAAABAcHAwDWrVsn7PfTTz+hSZMmaN68efUXmhBCCCG1Tq2u4SkLR0dHrF69GtOmTUNkZCRSUlIQGxuL3bt313TRCCGEEFJL1KmAp0mTJli7di2sra011r/55pvo3r07Tpw4AalUiqCgIFhYWNRQKQkhhBBS29SpgMfZ2RmTJ0/Wuc3NzQ2jRo2q5hIRQgghpC6o1X14CCGEEEIqAwU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0HgU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0HgU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0HgU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0HgU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0HgU8hBBCCNF7FPAQQgghRO9RwEMIIYQQvUcBDyGEEEL0nkFNF4AQQggheoYxIC8dyErkHxIjwKl5jRaJAh5CCCGEVAxjQH4WkJUAZCfxf7MS+CCnIK8onWMzCngIIYQQUgfIczUDGtX/8pyaLlmZUMBDCCGEkCIF+dq1NVkJQF5GTZfslVDAQwghhLyOFAVATnKxwCYRyE3lm6r0DAU8hBBCiD5TKvkgRghsCoOb7GSAKWu6dNWGAh5CCCFEHzAG5KYVBjNqfWyykgBlQU2XrsZRwEMIIaRWMhGL8aybX00Xo/ZRvzNKvfNwdiLf/4boRAEPIYSQaleZwYyuvPQmUJLn6LgzKrHO3BlVm1DAQwghpFIVD0CyFIqaK0wJal3tUUF+sWYo1Z1RmTVdMr1BAQ8hhNQR1X2R1vfj1QhFQdEt39mJRYFNTmpNl0zvUcBDCCF1WGXVppQ12KhI81FVN19V5X4VprozKvOFZq1NTsprdWdUbUIBDyGEEFJRGnNGJdCdUbUYBTyEEFKJaro2Q9c+r0VTUXXQdWdUVgLdGVVH1PqAJzs7GwcOHMC9e/fg5uaG/v37w8jISCvd5cuXcfjwYchkMgwYMABubm41UFpCCNFWFzrxEjUFebrnjMrPrumSkVdQqwOeffv2YerUqWjRogU8PT2xefNmzJo1C4cOHULDhg2FdN9//z0+/PBDhIaGIiUlBfPmzUNERASCgoJqsPSEEKJbbaiFoVofqHUgfqEZ3OSm13TJSBWo1QGPg4MDzp07Bzs7OwAAYwwBAQGYN28edu7cCQB4+PAhFixYgPXr12Ps2LEAgKlTp+Ktt95CbGwsOI6rsfITQvQbBQ11hFLJdxYuPrVCTrJezhlV6yjkQOrDmi5F7Q54/Pz8NJY5jkOHDh2we/duYd2OHTsgk8kwfPhwYd1bb72FNWvW4OLFi2jTpk11FZcQoucowKnl1KdWUA9uspMAJTUjViplAZB8n+/XlJ/J/5VnFS3b+AD1e/BpmQK4sx/wn16jRa7VAU9x+fn52LFjB7p06SKsi4mJgbu7OwwNDYV1DRo0ELbpCnjy8vKQl5cnLKenU/UlIUQTBTe1GE2tUDWYkr+NPj+Tf+Sp/mbwz7eVJ+DVlU+rLABu/FNyXrlpRf+LpYCRVdWWvQzqVMAzdepUpKSk4NNPPxXWZWZmwsLCQiOdmZkZxGIxMjN1j1C5ZMkSjTwIIYTUUvJcPpDJfKEZ3NDUCmXDGFCQqxnAqAc05s6AW3s+rSIfuPRbyXlJTYv+F0sBcxdAYgQYmgKGJmp/TQCpeVFajgN8h1bJ6ZVHnQl45s6di+3bt+PgwYNwdXUV1puYmGjV0GRmZkKhUMDExERnXgsXLsScOXOE5fT0dLqrixBCapI8V8cIxIl87QLRTVnABy15GWo1MZmAsQ3g1IJPo8gHTv1Qch5MURTwiKWAzAIwkPHBi9SsMHgx45fVa2k4Dmg5rurOrQrUiYDnvffew7p163DgwAG0bt1aY1vDhg0RFhYGuVwOiUQCALhz546wTRepVAqpVFq1hSaEEKKtIE9zEsxsCmx0Ksjjn5O8DCA/A5CYADbe/DaFHDi7quRaLmvvooBHbMg/ODFfQ2Oo9pCaAsa2RftxHNB+WtWeVw2q9QHP/Pnz8euvv+LAgQNo27at1vZBgwZh3rx5+PfffzFixAgAwPr161GvXj3qsEwIITVFIVcLaApHHs5K0Ozb8TpirDCYSecDDBP+LmQoFcD1v4uCHEWe5n7W3kUBj1hS1AlbZFBUG6OqiTF1KNqP44COM/l0r7la/QysWbMGS5cuRUhICPbt24d9+/YBAGQyGebNmwcA8PT0xKeffopJkybhyJEjSE5Oxo4dOxAeHg6RSFSTxSeEEP2nGssmO7HYWDZpr98t34wBSjlfowLwnYAfnOCDG1Ugk5fBpwH4IKZZKP+/SAykP+GboFQMpIBhYSBj5qR5rFZvAhJjvvmptOFXKNgBUMsDHk9PTyxatAgAkJubK6wvPrbOBx98gKCgIBw6dAg+Pj5YsmQJvLy8qrWshBCi13TO8p3IT5D5OgU2jAEJMZrNTcL/mfydTKoghhMBTy5oBjEqEiO+pkZdw/58sCQz54McsaH2firGNpV3Tq8JjrHX6Z2qW3p6OiwsLJCWlgZzc/PSdyCEEH1VkF9YY5NUFNhkJxXO8q3Hl4vctMLARb02pvB/Yxug0YCitCe+1x3EAICpPdB6YtHygxN87Y2qyUlqzjc7FQ929J1jM6DxgNLTlVN5rt+1uoaHEEJIFcnPVgtokosCHH2bVkG4k6lYIGNoArh3Kkp3Yb12vxn1PNTZ+vCjNwtBjFlh01NhZ2B1Hp0r93xIhVHAQwgh+iw/q6jGRtVxOCuBX1/XKeSaNTEiMWDfpGj7uTV8zZQuJnaaAY+RJT9ejaFZUZOS6iGz1Ny30cDKPhNSDSjgIYSQuk6p5PvSCDU1ao+6OkCfUsH3j1EUACZqt07f3MnXROWla5+biZ1mwMOJi/7KzAuDGTPA0BwwLjbyb6vxpXf+JXUaBTyEEFJXKOR8jUV2slpzVCKQnaLd7FJbMcY3HRnIitY9Osufl2r037wMfl4mgA9i2kwqSpv5nD9nFZGkqEameEde36H8nU4GRqUHMxTs6D0KeAghpDZRr63JSdb8W5sH52NMM2hIiOGDGGEUYLUpDYxtNIOY59f5ZrbiODF/p5M6r0D+r9QMkFrwAU1JwUotmL+J1B4U8BBCSHVTKvi7gnJStB+5abV3Zu+0x3wwpj6VgSqQkcg0706KO6k7iAH4fdQ5Ni/qP2NoUtT8JNFRM2NTv1JPibw+KOAhhJCqoJADOam6g5q89Npzi3deBn9nVvHxZPIz+eYi1ZgyAHBnX8lBTPHbtK3r8yP+qkb/Ff6a8tMkqHPVHkWfkMpGAQ8hhFQEY3xQkJPK13oU/1u8FqO6KRWFtTDpmkENANTvWZTu2taSgxiDYnMOmrvwo/tKTdVuwzYrmmRSnVfXyjsXQioBBTyEEKILY/yt26rbnnNS+eamXLW/ihrqKMyUhZ170/hARiEHnP2Ktl/ZDKTG6d5XLNUMeGSW/NxO6nMxqf4ammr2zWnQp6rOiJAqRwEPIeT1o1RoNt8IY7lkaq6vqb40inw+2FLvdHv/KJD2qLCmJpMPelTEUs2AR6R2O7b6CL+q/9WDGN+hVX46hNQGFPAQQvSPokCtNiZVs3YmL4MfZbg2SL4HZL4oDLYKH7npfAdesRTo/G5R2swXfKdhFU5UdKeSzJwPzlSBjk8f/n+JMd1uTSqOEwFiA35OL5GEnw5DLClcNlD7X1IsnUHhX8OifaRmNX02FPAQQuogVXOTrr4zOamFNSA11ClYnl04L1Nh8KI+EnBBHtB2clHaJxeB5Fjd+XDga3pUE0i6tAEcfPmaGllhk1PxW7ZVZDQn4GuB44oFHi8LQnQEK+rrhQBFbR+RWK8CZgp4CCG1C2N8YKBqalL9zU1XCyRSq7//DGN8MJOXofmQZwEN+hZdGGIiSw5iAL72RjXonpU7/7/UvHDwvMJmJ5mFdodha8+qOS9StUTiokBDK9gw4Gvy1GtCXhqQSAq3GRb9r0cBSVWjgIcQUj2UCr5WRp7N/83PLPybpTYwXVbRdALVXTahJiadL4dru6KLya3d/OB46v1m1Hl3LwpiZBZFHX+l5kU1Mqr/RWqzZLu2q9rzImWjXjOiq8ZDI9goHnRItAMW1XoDaVEzI6lxFPAQQipGqeRrK+Q5fBCjeuRnFwU1QnCTVXNzOqnXzJg5Fq1/eBpIvF0U4BTn1KIoiOHERcGOaiwZVW2MoRn49qdC9XsCPr2q7HRea5wIMDAsqi1RPTTWSTT/19VUUzyoEZXQNEj0CgU8hJDCZqTC4EUVnKgHMfIcQJ7L/69KV5BbewbPU0l5wHfszUvX7EfDCu+26jS7KIjJSwcy4ov2FRmo1cqY8gGdintHoJ4/P9ZMab/YqYmBp2rKKR5wiKX8egPpS4IT1Xb1AEaqd31KSPWigIcQfaMoAApy1IKW3MLlXLX1OWq1M4WPkppralp+VtHoxLlqdzOpmqDavV0UxCTeAp7+pzsfQ1P+PFVpHZsDVp5FTU26pjFQqQV3mFQ59WYdA6lawGGo439Jsb4nxWtXJNSUQ2odCngIqa0Y4weU0whW1GtZstUCluyivwX5pedd01Qdk+VZRXMx5WUUTm+QCTTsWxSYxJ0oOYgB+CDItDCtRT0+cFMFMVJzvk+N1Ez7AmzmxD/qKo4rIQiRaAYpQvAi1V2rInSmpQCF6DcKeAipSgo5H5wU5BX7q2tdvnaa2jqJpC6MFTaJqc2KrerPI88GvIP4WhQAiI0CnlwoOS/3TkVBjMyyMGgx19EJ2Awwti7az74x/6jNRAaFQYissO+JVO2vWuAi9Espvl0tWKHmHULKjAIeQkqiKODHQVHk8cGIxt9iAYoiryhQkasFNMoamnqgMjHG1y7lqQcyhVMueAYU1cTEHuTHlSmJa7uigEdizP8VS/l+MRpzMpkChsZF+7m15x+1gSpYkRhp16KoAhIDWVGtisb6wv/F9LVLSE2gTx7RP6qmIEU+/xBqTYrVqKhvE/7PL9pWl2pXyosxPkjLz1a7Pbzwr1sHQFIYxNw/Bjw6U3L/Hie/opoYQ1P+r8SYD2JUgYvEhF8nUQtiXNsCbu34AKK6iQz485MYAQZGRQGMgbRwWVYUuEhkastGFKwQUofRp5fUDkpFUYCikBcFIeqPguLLeTr+5vH717a7h6oLY0X9YvLSi4IYl7ZFQcyDE3wQU1Ltk33jorRiSVGwIzEqmlDS0ISvkVEfHM+lDV+LU5a+IGJJ6WlKzcOAD0Ikag/1ZQNZsUBGVTNTCccmhNQ5FPCQ8lMPTjSCEHkJ/78krVLO/6/PtSmVhSkLm5Iy+c69Vh4Qph14fA54fEF7UkkV2wZFQYxIXBTsiKV8LYwQxJjw61Sc/PjpDCTGpQcyFQ0kOK4oONEIWmSFNUMlBDIUuBBCyoECHn3GGB9ICEFFQeFfebEARBWcqPVR0VWjokpLwUnlUxbwgYzUtKiZJ/EW8Dxac/ZuqNVctZ4AmDoU7q/ka3RUVCP9qmpkVIERADi2AOwaFwY3pQQNqj435WVQ2DdHaN5S/a9q4jIqWmcgo4HfCCFVjgKe2qCk5hxlgdr6ArXARa62rKtmRS1NbR1b5XWhalpT3U2T/hRIua8WxKjmYyochbjV+KLRgHNS+aBHA1c00q/6a2vfGLBw5e9cKm1wPENjAMYlby+JyKCwc7FpUSdjVTCjEdSUYXA+QgipZhTwVLXMF/wQ9rqCElV/E6oxqdty04DM58WCmMyiZb8xRUFM2iPgwXHd+YgM+A7TKlYeQP0eRdMXSAsDDF0zZMss+MerUE2XILMonMjSomhCS5k5XxNDt0ETQuooCniqWl4G3yxB6p6CvGJTFKhNLunTGzCx5dMlxAD3Dpecj/ocTmaOfJOS1FQzkJGaaQcUpg5FTVavSiRWC2aKBTKqsW3oDiRCiB6jbzjyelINkpeXDuSl8UGNXSP+wg8Aj8/zg+OVJCelKOAxsuZH7FUFLkIQU9jsIzMv2s/SnX9UNk7EH1NmARhZqgU2FvzAfYam1E+GEPJao4CH6B/VRJh56fwFXzUwXlIsfzeTah6m4rdly6yKAh7VmDIGMs1aENXovuqzbtv68I+qZmhSLKCxLFqWmlO/GUIIeQkKeEjdoRosT2RQdCdTxjPgxc3C8WYyivrNqIKZpkP4W7IBvv9UapxmnoYmRU09qtu2AcCmPtDpXc1xZqqD2AAwsgKMbQoftvxfIyt+egFCCCEVQgEPqVmqSSRF4qJbpDOfAy9i+AH08rP4eZhUf5UFQNMQwLYhnzYnBXh8VnfeEmPNWhxzF6DRALWaGtOSR/qt6jFeZOaFgYx1YWBTGORIzaljMCGEVAEKeEjlY4yvTRGJiwIKIYhRTWOgCmSyAaYAmgzm+9AAfBDz6HTJ+efnFP1vYseP8Ku6g0mqNqlk8WBGZg7IfCv1VF9KbFBUUyMENlRbQwghNYECHlI2uoKYrER+nJj8zMLRfwvnY1LVxJQniJGr3Y5tbAu4tOYHqDMsnINJojbWi3rti4ktf+t2TZLIipqeTGyLAhuZBdXWEEJILUEBz+tOIecvykJNzAvgRXRR4JKfXdSkxBRA42B+kDsAyE4seUwZoGgwPaBYEKMapE4toNEKYnpW/rm+KplFYVBjo9nHxrACg/gRQgipVhTw6CPVQIaqu3ayEoHE20V9YvLVmpUU+TpqYs6UnHdBsSDGsXnR9AVSE0Bi+pKamFoYxBQnMijqT6PRcdia5m4ihOg9xhgYGJRMCQamuaz2v7JwpHfV/6q0OvcDg7GBMWyMbGr03CjgqSuK18SompOEWpisor/yHM2amJwk4MGxkvPOzyr638SOr4kxNC2aJkBiXDQPkvqcTCa2QMN+lX+u1UFqxgcxQt8aa2qGInorMyUXqS9yYGlvBFMr2Sunq2mlXZQBCNuKX6iLp1dPy5jmtgJFARRKBRQFChQUFIBxDDIjmbA9MSERBfICKBQKPq1CAYWSTyuWiOHi7sIHAVDiTvQd5GbnQsH4/JRKJZ9eoYCB1AC+bX2FY188cREZaRl8mgI+T1V6iaEEnQd0Fsp7cs9JJD1LgkKhmaeSKSEyEGHQ5EFghXPw7d+yH/EP4vntCj5QURYooVQqAQ4Y//F4IW3k+kjE3YiDUqkEU7Kivwr+7+xVsyE24H9Ub/tpG26fvV20nRWlY4xhwR8L0Mq9FYLqBdXAu6UIBTw1iSn5vjGqmpjsJCDhlmYNjFytJqbxIMC+CZ82J/nlzUn5mUX/G9kAjs342hepiVqzUmFtjHoQY2xdN2piykLVabh4UGNkTZ2GX6IqLo5VkbYuHF/1izc9JQfpL3JgZieFsaWh1oVWtZyVkofUFzkwtjaAoRmHAkUBxGIxxAZiMMaQJ89DWmoaCgoKkJtWgMykfBiYMYiN+QudhbUFzC3NwRhDVlYW7t+5j4y7YmRdMgPAAWAw8E2EyDkdzvWc4eTmBCVTIiM9A/+F34fhPXdw4MDAkO58CxkWj1BQUACvRl5o0rwJlEyJlNQU7PlnDwoKCqBUKlGgLBAu4AWKAjRo3gAdu3UEYwxp6Wn486c/NS7GSgV/gVUoFWjQsgH6DOsDxhgyMzKx8sOVRRfiwnSqi6hXKy8Me3sYGGOQ58vx9VtfCxdXpmRFF2UFQ72WHnjrw0nC67Cg/wdQyBWAkkGpZABTpWdwbuaK91fNEdK+23Uu8jNyNebpVbFp6IjPtnwoLM/p9h7yUrN1vvZm9Wzw1Y7PhOV5oz9Azos0nWll9hb4bt9iYfnzBd8h+3GizrQG5ibw7uateoNh7Y9bkHkvXmdakUyKoDFdAQZwjGHXtpNIvxWnMy1EIoydMxqMf3pw6nAsUq8Xn8uvSNqTbBjJ+Pf91f9SkHzjaYlp4+/mIFWWDdQrMUm1oICnqqXEAQ/PaAYv8uzCPjI5mkFMdmk1MWofLGObwuYkEx01Maaas1yb2AIN+1fN+dUGMnPNu6CMrfnHa3CLd2VcnFW/KhVKBW6ejMeJzXfBGP/UdRzlBefmxsjJzUFBQdEv2ceXM3HnQCZ/UeCA1qHO8GhviUePHuFFwgsUKAsgl8tRoCxAdqwhcq5Y8Ak5wHeINZzbmODq9au4G3uX/2VcoIBcKYc0wQGWTxuDK0xbf5AJ7Fsb4uSZk7h86bJwfJscb9TP6QwOIjAoYdo5E16B1mCM4dDhQzh15JRwkXUXt0Bb6UBwnIi/kLZ6Cu+efNr9+6NwaPshKBQKMCVDY7MOCHIaDVFh2pQGMWjQ3xYMDHt3HcK+jXuhVDL42XfBwAaThHThN36B6zBLdOreBowxHIg8gT0/7gRTMrR1D8KwVtOFtFvP/gSLgTL0G9oVAHAg8hR2fLIFHXx6Y1Tn2RCJxFAqFdh8bBlO39qDLu/0x8hJfE3q4f3n8ff83+DfsC9GBbyrlbbV+B6YNCsEAHDi2BXs+eBffDZ6E0Qi1eeAQ95Va3y84B049W2MdxaNBABcOf4Avnd7gitMx4GD6WMffLP0Y6RmJcKzrz/e+3w0wBiu34jDr5/9WuJ7zaVrW3g0cwIY8ODBMxz47UCJaR88UcA/oBUYgITEdFw/cL3EtCk5FugfnAMODHl5cjy9WvIFVm7ogsyHeWBK/g2a8TyLn0xZh4RnEqTczuPn+WVAQb6BzmAHALIyTfDsWj6/wBgKlMYAlwtwInAiET/iOceB40SQMxs8vJgPxvjnlMlcILaQgeO4wnQicJwIEInAmVvj7ukC/rAMEFs3gRRJfF4iEcCJhXxFRsa4cUwpTEwscekAY2my2vFFwjE4QwmunuDAwJfByLs7YJmulQ4ivvwxl0RQvVPMmvQB5xgolLEovRgQifA41gAyCR9G2/oNgNhzoFBGVf4Q8eeYnWyA9Od5Jb5e1YUCnqqWch+4f6Tk7eo1MUIQY8o3HwnNSoXLYqlm2rranFSM6lewSCQCY/yFNyk7B3KmQEEBg1xZADlEkEtMkW9gAiMLO3h4NgUzsoRSZoljV85AniaHPDkZBQVqF1tFASwtLBHQNoD/Bc2Azbs2Izs3m6+iVvC/UOUFcigUClhaW2PUoBFCALB87U/IyMhEQYECBUoFlAWF1cVKJcytLPDejP8J1b+ffrUUSYkpwq9YpmRQKPhfqSbmJvhq8f8JVdALFy1GwpMEKBUMSoWCP//CX6hSYyl+XPeFUIb5s5fgxb34wl+wSuGXLFMq0c49CCGNJwCMAziGvfFbcfD0NuEXL5QMjCnR3qMHhrebAREnAjgGcdcX+HT553h+6Y7wSxeMwdLYpvDiKC58XYCTm2OxfNHHuHvipPB6WZrYaqQDAy5ue4KLhseweOFqPD1xWUdaTkh7/d8k3DA8ja8+24hHh85qpeXU0t6NyMQ9wxh8v2or7u87XiwdP1UGBxEyT5jipt0VwFiOzdtO4c6ug0LaoaMX8V/CAEScCNx/zohzigYzLkDUgTu4eeCakPad0aP456kwrdWdRnh+PRrMSI4rFxLx/PpjWJrYYmCniRrpgpu8hR1XtyDDPR0cgEcxech+ngZLE1sMazlNI21ou3ewNfYP5NzhP/tJ9xkspFZCsAMAIpEYIwPexc3H55H8SIScmxkAA9LuK2FpYisEO+ppY55fQ2aCDNlX0sDAIScOcHBsUvQ6FRKLxHB0awl5jjEyL6aCARA/NNOZzqVBIHJT70EkcUPmZb7/njLeEMYNO2lc0NQvoDIbR2Td4D8XihQTmLUJBifiL9jCRb5wX0sXMyjuS8BxHKTZprDqPrkonWof8Bd9e1sxzBOMIeIAZYEStsEL1C7Gmhdaews53HLMIOL3hvPoxVByBmpBBscH1SIODkbZaC6yBsfxwZH35KUoYBJwIhE4EQeO4x8ijoO9JBOB5hb8OnCIemcpspSG4ACIwKAKLURgsBHnIMTJCiJwAMchZtw7SFNINdJwYBABsBTJMam+Mx9scBxygochQW4AEeMDCjEYRIVpTUVKvN/ME1zh8+2QCsTncBAzBjEAMVB43gwyjsOM1oX9M8GhXSaH+PSCwuOqygEh7zfbthDS9sqV4GlyFsTgIOJPAap3iIgDBrRtC4mhIThwGMZu4PmLVHAcgwgc/xIWphNxQPs2bWDi5oKapjcBz/Pnz3Hq1CnIZDIEBATAxMSkposEADifLsfpeDdkcwbI5STI4cTI4wyQAzFyOBF62Bqjn00iGBjOPUvFqnMiKFg2lMosKJQvoGAMTMGgUDL0ae6EiS2cAQaceZqKz3fdglKphJJBuGAqlQxKxtC9pRMWduHnbDoTn473fr8qtKeq0qn+79DaGd8N8AYDw+VnWZjyw7nCiyCKqn8Zf5H1bVUP68fUBwPD7aQ8jP74qNoFVln4K4m/MHu09MS26Q3BGMOzzAIMmLGbb18vzEuoO2UMds0bIvy9pigwMEQaJ8Ogkb+V+JyaN2qIz36dwX9clQxzus8FK5DrTGvi6YPP1v2PPyaAhZM/hzInU2dambMnzJwshV9k65dsgyI9SWdaiZ0LWrZrCTCAgcP+P09BnqT7F6eBhR2Oh/wHrvBX4+Wou8iLf6AzrcjYHFcu3BF+vcVdTUbOQ+0qaEsTWwT3HM8HOwDAOPRyGIYTWf8iNStRI93wttOFCy4Yh4Ij9pDk2oHJb2rkaWfhqnXRA+Ngzql/UXGws3DTmU56lQHMEmITK+GC5uDgqzOtabQhpFJ7GDr5AOB/XTrbNtCZ1irWBBbmrjBu0BHgOLhZeWml4yCCzUMrGFnnwcnOE89aDwI4Dh7m9XSm9Ux2gDmXj0ZuPogPnAhOJIKnsaNWWhFEaJbjDEtTOW7Vb4r4QZ7wlNrqDA4C3ZpjgLkbOHDIbpKPxHGNUU9sqTPtoIb+GGLnBgCwaGWEHYadIVJqp+s5eQm6eORiqGtDcACa+DviL5NuEGVqpx0++XP4e8gxwKcBAA5dTXywQdISLJXxF3fVUwqG/sEh6FDPCH2aNwVEHB5YJePIfu1043v1ACeWo0U9a3Rq0xQAkJGWhRb5rhBz/IWNv7iqLm4cPF2s0bodnzY3Jxftc235i6WQnoNIxO/n6GSDxm35tAX5cvjn8n3oxAA4joOBSHV+HCzsrFDPrwk4joNSqUT73DMQi0TgOAaOAwxEfO2ESMRBam0J66aNhVe8K7sADgxiEX+GqkAGHAexuTmkPoVTw3AczhvfABSKwsCr6MFxHDgjT0i9vFRJsc8yFqygoChNYfAFcOCkhjCsV0+oZd5k/xgoUAjHEaIIcBBJDCBxchK2LXdtqJGvkDcAiEQwsLUVXqf5Ho3BFAqIhGNDCAIhEkFsairkO65xC2E/9WASXOHzIjEQtvVv0Up4jjT3KfY/x8G/pV/hM42S09aC2na9CHi2bNmCyZMno02bNkhNTcXz58+xZ88e+Pn51XTRsDTyMv7+5UaJ2y/274/MICswcNh9Ixe7N5TcpPUsuQ/MZCIwAEfvinF51/kS0+YW2MPbwRgMwKVHBXh0uuQynDd2xd8NLAEAdxIMkXrrQYlp79l7YW+sLTgAj9Nzkfs8ocS0ySlSnHrgBA5AWm4+lHklV2nmyU1wPCcInMigsBr6N+1EhRdRppTBMNaY/4ByHETGlmAFco3qWdUvOQMTGzg8N+d/xXAcDO3d+XIIvzbFwheDka0tGmfZQVz488TEsznk2Tlavx45EQcjc1MEcC7gxBxEAH70bY/sjFy+DCKR8KsQHAcjYymGWXjztQsA/mzbBSkZHQqLIAIHDpyIg4gTQWooxgS3FoVNOhz2B/ZAfHrXwl+YRfm6GtrxX3BqRJwYAaGzkcBSIC5M6yi20XHB5zCx70hcCwiCqPCXq4FIBCNIwbI1L3ocB0wL6Y9b3TrDQCSGWMTBQGEA9kw73ZBO3eFqaofbT5NhAP55ESkNIH9Y2O6llnZAQDf4OtXD/bjnwsVQWSDG01vaaXsHdEMb7/qIf/AEHCdCQb4INy5rpwvq2g2mlhK0dvVD0oMnEIs55OeJcPy4dtqOXbvC1MIQG+u3Q87DhxCLRMjNAcJ3F3vLcUDLgK4wtZJieeOO+Db+GbKylfh7W44qJhXSzRg9BJau1gCA+U07Ym7CC2RlMWzdmKiV9q2xwbBw5e9YGd8yF0MevMCWnx9ppfv57R6wcLaCqPAHXO82Bejgn4TN39/SSvvVO/1h7mQBkSHfP81aoUCbfnm4efYFjm69JzRTBo70QZOOAfz7VMy/N5q2YhA5xONIWAyYkn+rdxvTGE06aXcyNQIwNaCj1npdjAAMa9u6TGkBILB5szKn9W3YsMxpHbw8y5zWsF7ZO5pIXMpeayFxcChzWvWAptS0VlZlTis2MytzWn1U5wOehIQETJ48GZ9//jneffddMMYQGhqKN998E1euXKnp4sHR1BISO/fCC6ZaNF1YrepuIUU7Y/6XzxNLMY56t+AvgsIFGXzVpYhDcycT9LPhqyGNMoATLbtAxHFF1a6iovSBPhaY4KIExzG0EAMXAvsI1bKciINYxAkXu65exphTny/DXRsD3AgeApGIg5jjiv5yHERiDh2cpZjVUApwQGImh7jx4yAuvGCJxBwkHJ+3mOPQzE6Mt/2cwYyskMOZITnLCiKRIUQGhpCIpRCLRJCIxBCJRPB2tkVwv278eQNwyDWGRCyGRCSGRCyGSMQJaW1szNGyU9EvlaZSJ0DJPy9iAz6AEHEAJ+ZgZm6K+u2aF6bk4GftCSgUEIkK28NFfCAkFokgMTGCfbPGQr736jUGV8CnBcfBgON/mXIGBuAMDYVfeuA4PGjcGixfDohFwqzkqkAGBhIYuhZ9MV71bQuo/3orzAPgwIk1f70datIKTKEoTFL0ay8zTY6wxVe0Lnp/LJ7B99EpTJeVkoc/PjmvmU4EzH1vPMys1fp5FYo++VTjohc4phGadOpepnTWLZzRp4UP+pQlbVNnWDf1QqsypLVq5AyrRu6or5bOXle6Bs4AAEd7ezi2L7rIGnhop7X05Cd/NbO2hlnjogtnNxvttBbudgDA1wS4u8MEQKBUxzk1dBbyEZmYQOLoACMAgQodZfVWSyuVwrqFBQLHmmjn2bgoHcC/96x8XBA4ltM+p8JyCmnFYnDGxmjazQPufo5Ie5EDixL6enEchyadnFGvifVL0xFSl3GMqX8V1j1r167FzJkzkZSUBGNjfgC4EydOoEuXLrh27Rp8fUufSiA9PR0WFhZIS0uDubl5pZZP+TQa7MIfQGEnTOGXZuGFTmRoCE7Cj+/ClAqw/Hy1vdX24QBObCD8ImNMyVe7Fs9XlbeqhqE6qE+hoBpxWDWFgrjOx9S1lu7gxLnC6VQyU3LLdNEra7qqSquPx6+qcyJEX5Xn+l3nA56ZM2ciKioKN24UNdmkpaXB0tISmzZtwqhRo7T2ycvLQ55a80p6ejrc3NyqJOBBUixwdWvl5llTJDLtwMbEBpBZ1or22ddRVVxICSGkrihPwFPnf36npaXBqlgbpoWFBcRiMdLS0nTus2TJEnz66afVUby6STWTt2qEYVWQY2hCgU0tY2olK1MAU9Z0hBCir+p8wGNkZITMTM27bnJycqBQKGBkpN1HAQAWLlyIOXOKBppS1fC8VjgRYGRZFMyoT3ppIC11d0IIIaQuqfMBj5eXF7Zt2walUinctfLgwQNhmy5SqRRS6WtyURcZFNXSCEGNLfWvIYQQ8lqp81e8/v37Y/78+YiKikLPnvyUCFu2bIGNjQ3at29fw6WrRuodh03s+KDGxJbvX1Ps9mVCCCHkdVPnA56mTZti+vTpGDt2LObMmYPk5GQsW7YMv/76KwwN9XC+JImsKJhRn9GbJr0khBBCSlTnAx4AWLFiBQICAnDo0CFIpVIcOnQInTt3rulivRpDY7WaGrWaG4kxBTaEEEJIOelFwMNxHEaMGIERI0bUdFHKT2auGdSoam8kujtcE0IIIaT89CLgqfU4ju8krN4EZWJXeEeUHja7EUIIIbUMBTxVzbIe0GUe3RFFCCGE1CC6Clc1saSmS0AIIYS89uh+ZUIIIeT/27v3oKjKNw7gXxZkQy7iGoWgsSkyQjghRKuYCcZIKYl5SyPFSzZdbHSsMXR0MG2aSQPLdJzJaWq6OBWTTjpZjXFR04YoFTQNjLwhooioiFzW3ef3h8OZNm4LP3YXXr+fGf4473nf5TnPnD377HsuS8pjwUNERETKY8FDREREymPBQ0RERMpjwUNERETKY8FDREREymPBQ0RERMpjwUNERETKY8FDREREymPBQ0RERMpjwUNERETKY8FDREREymPBQ0RERMpjwUNERETK83B1AD2BiAAAbty44eJIiIiIyF7Nn9vNn+PtYcEDoLa2FgAwePBgF0dCREREnVVbW4t+/fq128dN7CmLFGe1WlFRUQFfX1+4ubl162vfuHEDgwcPxvnz5+Hn59etr60a5sp+zJX9mCv7MVf2Y646x1H5EhHU1tYiKCgIOl37V+lwhgeATqfDoEGDHPo//Pz8+KawE3NlP+bKfsyV/Zgr+zFXneOIfHU0s9OMFy0TERGR8ljwEBERkfJY8DiYXq9HRkYG9Hq9q0Pp8Zgr+zFX9mOu7Mdc2Y+56pyekC9etExERETK4wwPERERKY8FDxERESmPBQ8REREpjwWPA1itVuzZswdTp07FqFGjcP36dbvGffPNN5g8eTLGjx+PjIwM1NXVOTjSniE3NxczZ85EfHw8li5disuXL7fbf926dRg1apTN3/z5850UrXMUFxcjLS0N48aNw8KFC1FaWuqQMSooLy/HK6+8gvj4eMyePRuHDh1qt//+/ftb7D+jRo1CVVWVkyJ2nStXrmDDhg0YO3YsVq5cadeYa9euIT09HQkJCXjmmWewe/duB0fZM9TV1WHbtm144oknkJqa2mF/i8XS6n61c+dOJ0TrWidOnMDSpUuRmJiIWbNmITs7u8OfehARfPzxx5g4cSISExOxfv16NDU1OTROPnjQAaZPn476+npERkZi586dMJvNHY7ZunUrli1bhg0bNiA4OBgZGRnYv38/cnNzu/3pzz3JTz/9hOTkZKxatQppaWnIysrCY489hqNHj6Jv376tjikrK4O/vz/WrFmjtfn4+DgpYsc7efIkxowZg9TUVKSnp+PLL7/E6NGjceTIETzwwAPdNkYFNTU1GD16NEaOHInly5cjPz8f8fHxyM/PR1xcXKtjrl69iuLiYuTm5tq02/vwst7qzJkzGDNmDGbNmgWLxWJXQXz79m0kJiaiT58+WLFiBUpKSjB16lR8/vnnmDVrlhOidp1hw4bhqaeegr+/P4qKijrsLyIoKCjAli1bEB0drbUPGTLEkWG63IEDB/Dqq69i4cKFSE5ORklJCV544QUUFRXh7bffbnPcmjVr8MEHHyArKwu+vr5Yvnw5Dh8+jK+++spxwQp1u2vXromIyA8//CAApKqqqt3+ZrNZBgwYIOvWrdPaTp48KQDkxx9/dGisrhYdHS1paWna8vXr16Vv376yefPmNsekpaVJamqqE6Jzjeeee05MJpO2bLFYJCwsTBYvXtytY1Swdu1aCQgIkMbGRq1t0qRJkpiY2OaYnTt3ire3tzPC61EaGhqkoaFBRERSUlJk2rRpHY7Zvn27uLu7y8WLF7W2JUuWiNFodFicPUXzcfzNN9+Uhx56qMP+ZrNZAEheXp6DI+tZ6urqxGq12rRlZmaKj4+PWCyWVsfU1NSIXq+Xbdu2aW15eXkCQI4ePeqwWHlKywE6+03x6NGjqK6uxtNPP621DR8+HGFhYfj555+7O7weo6amBocPH7bZbj8/P8THx3e43QcPHkRCQgKmTZuGTZs22TWL1lvk5OTY5ESn0yE5ObndnHRljApycnKQlJQET09PrS0lJQX79u1rd59obGzEpEmTkJSUhDfeeAMXL150RrgupdfrO/0MlJycHMTGxiIwMFBrS0lJwZkzZ1BWVtbdIfYoXZ3xW716NRISErBgwYIOT6+qoG/fvi3OQvj4+MBsNsNqtbY65pdffkFjY6PNMevxxx+Hv7+/Q49ZLHh6gLNnzwIAgoKCbNqDgoK0dSo6d+4cgM5vt4+PD+bMmYOVK1di4sSJyMrKwoQJE9p8c/UmjY2NuHTpUqdy0pUxqjh79myr2202m9ssYtzc3DB9+nQsWrQIL7/8Mo4fP46IiAicPn3aGSH3Km3lt3kd2YqKisKCBQuwYsUKGAwGjBs3Dp999pmrw3KqW7duYePGjUhOToaHR+tXzZw9exbu7u647777tDadTofAwECH7le8hscO8+fPx8mTJ9tcr9frsW/fvi6/fvM30f9++/Ly8up1MxerV6/G3r172+2ze/duBAQEdHm7MzMzbcbExcUhIiICu3btwpQpU7oefA/QlZyotP90ltlsbnW7m9e15sknn0RKSoq2nJycjKioKLz11lv49NNPHRZrb9SV/N6tPDw8UFBQoM02TpgwAQCwbNkyzJ0715WhOY3FYsHzzz+PW7duYcuWLW32M5vN8PT0bDEz5OhjFgseO7z++uu4efNmm+s7+kn6jhgMBgB3Lqb896/IVldXY8SIEf/XaztbWloaJk2a1G6f5qnif2/3v1VXV2PAgAFtjv/vATg8PBzBwcEoKirq9QWPt7c39Hp9p3LSlTGqMBgMrW5387rW/Hf/8fDwQHx8PA4ePOiYIHux9vKr+r7VFf8+tQoAiYmJyMzMxIULFxAcHOyiqJzDYrFg7ty5KCwsRH5+Pu6///42+xoMBtTX16OhoQH33HOP1u7oYxYLHjtERkY69PWjoqKg0+lQWFgIo9EI4M604PHjx3vdN4PQ0FCEhoba1ddoNMJgMKCwsBCJiYla+2+//Ybk5GS7/2dTUxOuXr0Kb2/vTsfb07i5uSEqKgqFhYU27QUFBRg5cmS3jVFFdHR0q9ttNBrRv39/u1+nsrJSif2nu0VHR2PTpk2wWq3aF7uCggLo9XqEh4e7OLqer7KyEm5ubm3ecaoKq9WKtLQ07Nu3D/n5+Rg6dGi7/ZvvYissLMTYsWMBABcvXkR5ebljj1kOuxya2r1La+HChbJq1SptefLkyRIbGyt1dXUiIrJmzRrx9fWVy5cvOy1eV1i2bJmEhIRIZWWliIh88cUXotPppKioSOuTkZEh8+bNExGR2tpayczMlKamJhERaWpqksWLF4ter5e///7b+RvgAB999JH4+PhIcXGxiIgcOnRIPD09JTs7W+vzySefSEJCQqfGqGj//v3i5uYme/bsERGR06dPS0BAgM0dj7m5uWIymbT30ubNm23uOtq1a5e4u7vLhx9+6NzgXaitu7RKS0vFZDLJH3/8ISJ38qnX67Xc1NTUyPDhw23urFRdW3dpNTY2islkkh07doiIyPfffy+HDh3S1v/zzz8SGhoqSUlJTovVFSwWi8yZM0eCg4Pl1KlTbfabMmWKbNy4UVs2mUySlJQkZrNZREReeuklGThwoPYZ6AgseBxg06ZNYjKZZPjw4QJAYmJixGQySW5urtbHZDLJs88+qy1funRJRo8eLX5+fhISEiL33nuvdhBX2a1btyQlJUW8vLwkNDRUvL29bW5VFBFJTU2VmJgYERG5ffu2pKeni8FgkMjISOnfv7+EhYXJ3r17XRG+Q1itVnnttdfE09NTwsLCRK/Xy8qVK236rFu3zubWanvGqCorK0u8vLy07U5NTdUKYhGR7OxsASDnz58XEZEdO3bI0KFDZdiwYWI0GsXX11feeeedFrfWqighIUFMJpP0799fDAaD9qHT7MiRIy1urc7OzpZ+/frJkCFDxNvbW8aPH6/dsq2yefPmiclkkqCgIPHy8hKTySQmk0nb9vr6egEgW7duFRGRv/76S8aPHy+BgYESEREhnp6eMnv27A4fS9LbffvttwJAjEajlqPmv4qKCq1fSEiILFmyRFsuKyuTyMhIMRgMEhQUJIMGDbIpGB2Bv5buAOfOnUNFRUWL9rCwMO26gj///BN6vb7F6Z+ysjLcvHkT4eHhLc4Hq6y8vBxVVVUICwtrcWqhrKxMe5Bjs6amJpSWlmLAgAEYOHCgs8N1iqqqKpSXlyMkJKTF9SgXLlxARUUFYmNj7R6jshs3bqCsrAyBgYEt9oerV6+itLQU0dHR2ntKRHD69GlYrVYYjcY27yZRTWFhISwWi01bnz59EBMTA+DOqfTi4mJERETYXE9YX1+PkpIS+Pv7a6fdVXf8+PFWr9185JFH4OHhoT1ocMiQITZ3G125cgWVlZV48MEH74rTpNXV1Th16lSr60aOHKldM3fkyBEYDAaEhITY9CkpKUFTUxPCw8Md/j5kwUNERETK43N4iIiISHkseIiIiEh5LHiIiIhIeSx4iIiISHkseIiIiEh5LHiIiIhIeSx4iIiISHkseIiIiEh5LHiIiIhIeSx4iEg5ZrMZX3/9NUpLS23a8/LykJ+f75qgiMilWPAQkXL69OmDgwcPYuLEiaitrQUAHDhwABMmTMDt27ddHB0RuQJ/S4uIlNTQ0IDY2FjExMTg/fffx8MPP4wZM2bgvffec3VoROQCLHiISFnHjh3Do48+imHDhsHd3R0FBQXaL6YT0d2Fp7SISFkjRozAzJkzcezYMaxfv57FDtFdjDM8RKSs33//HXFxcQgNDUVAQADy8vKg0/F7HtHdiO98IlJSXV0dUlNTsWjRIuTk5ODEiRN49913XR0WEbkIZ3iISEkvvvgiDhw4gMOHD8PLywvfffcdZsyYgV9//RUxMTGuDo+InIwzPESknDNnzqC2thbbt2+Hl5cXACAlJQVr167F7t27XRwdEbkCZ3iIiIhIeZzhISIiIuWx4CEiIiLlseAhIiIi5bHgISIiIuWx4CEiIiLlseAhIiIi5bHgISIiIuWx4CEiIiLlseAhIiIi5bHgISIiIuWx4CEiIiLlseAhIiIi5f0PohNJN2RF5gUAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -3102,8 +6364,7 @@ "plt.xlabel(\"x\")\n", "plt.ylabel(\"y\")\n", "plt.legend()\n", - "plt.title(\"$x$-offset constraints with systematic normalization error\")\n", - "plt.savefig(\"systematic_err.pdf\")" + "plt.title(\"$x$-offset constraints with systematic normalization error\")" ] }, { @@ -3131,9 +6392,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.5" + "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From ec94284162328583b1b8ed20c1012f9a4cf2d697 Mon Sep 17 00:00:00 2001 From: beykyle Date: Mon, 10 Aug 2026 23:21:13 -0400 Subject: [PATCH 03/24] Update docs, CI, and packaging for the covariance refactor Rewrite the API reference around the covariance/predictive modules, replace the design spec with an accurate architecture page (docs/design.md), refresh README to the Term API with the behavior change called out, drop the broken environment.yml install path, run notebooks in CI with pytest-xdist under a raised timeout, test 3.11, scope bare pytest to the unit suite, and ignore local tooling artifacts. Co-Authored-By: Claude Fable 5 --- .github/workflows/ci.yml | 8 +- .gitignore | 6 +- README.md | 120 ++++++++++----- docs/api.rst | 71 +++++++-- docs/conf.py | 2 +- docs/design.md | 143 ++++++++++++++++++ docs/examples.rst | 4 + .../rxmc.config.CalibrationConfig.rst | 1 + docs/generated/rxmc.constraint.Constraint.rst | 2 +- ..._model.SklearnKernelGPDiscrepancyModel.rst | 26 ---- .../rxmc.covariance.ConstraintCovariance.rst | 33 ++++ docs/generated/rxmc.covariance.DenseTerm.rst | 32 ++++ .../rxmc.covariance.DiagonalTerm.rst | 32 ++++ docs/generated/rxmc.covariance.KernelTerm.rst | 32 ++++ .../generated/rxmc.covariance.RankOneTerm.rst | 32 ++++ docs/generated/rxmc.covariance.Term.rst | 32 ++++ .../rxmc.covariance.discrepancy_term.rst | 6 + .../rxmc.covariance.model_error_term.rst | 6 + .../rxmc.covariance.noise_fraction_term.rst | 6 + docs/generated/rxmc.covariance.noise_term.rst | 6 + .../rxmc.covariance.normalization_term.rst | 6 + .../generated/rxmc.covariance.offset_term.rst | 6 + .../rxmc.covariance.stacked_supports.rst | 6 + .../rxmc.covariance.statistical_term.rst | 6 + ...ation.ElasticDifferentialXSObservation.rst | 4 +- docs/generated/rxmc.evidence.Evidence.rst | 1 + ...bservation.IsobaricAnalogPNObservation.rst | 4 +- docs/generated/rxmc.likelihood_model.Chi2.rst | 31 ++++ ...c.likelihood_model.Chi2LikelihoodModel.rst | 26 ---- ...lihood_model.FixedCovarianceLikelihood.rst | 26 ---- ...mc.likelihood_model.GaussianLikelihood.rst | 31 ++++ .../rxmc.likelihood_model.Likelihood.rst | 31 ++++ .../rxmc.likelihood_model.LikelihoodModel.rst | 26 ---- ...lihood_model.ParametricLikelihoodModel.rst | 26 ---- .../rxmc.likelihood_model.StudentT.rst | 31 ++++ ...kelihood_model.StudentTLikelihoodModel.rst | 26 ---- ...xmc.likelihood_model.UnknownModelError.rst | 26 ---- ...ikelihood_model.UnknownNoiseErrorModel.rst | 26 ---- ...d_model.UnknownNoiseFractionErrorModel.rst | 26 ---- ...d_model.UnknownNormalizationErrorModel.rst | 26 ---- ...lihood_model.UnknownNormalizationModel.rst | 26 ---- .../rxmc.likelihood_model.log_likelihood.rst | 6 + ...odel.mahalanobis_distance_sqr_cholesky.rst | 6 + ...observation.FixedCovarianceObservation.rst | 25 --- .../rxmc.observation.Observation.rst | 4 +- ...ysical_model.PerObservationScaledModel.rst | 23 +++ .../rxmc.physical_model.ScaledModel.rst | 23 +++ ...xmc.predictive.gp_posterior_predictive.rst | 6 + .../rxmc.predictive.predictive_band.rst | 6 + .../rxmc.predictive.total_predictive_band.rst | 6 + docs/index.rst | 12 +- docs/installation.rst | 9 -- environment.yml | 18 --- 53 files changed, 757 insertions(+), 404 deletions(-) create mode 100644 docs/design.md delete mode 100644 docs/generated/rxmc.correlated_discrepancy_likelihood_model.SklearnKernelGPDiscrepancyModel.rst create mode 100644 docs/generated/rxmc.covariance.ConstraintCovariance.rst create mode 100644 docs/generated/rxmc.covariance.DenseTerm.rst create mode 100644 docs/generated/rxmc.covariance.DiagonalTerm.rst create mode 100644 docs/generated/rxmc.covariance.KernelTerm.rst create mode 100644 docs/generated/rxmc.covariance.RankOneTerm.rst create mode 100644 docs/generated/rxmc.covariance.Term.rst create mode 100644 docs/generated/rxmc.covariance.discrepancy_term.rst create mode 100644 docs/generated/rxmc.covariance.model_error_term.rst create mode 100644 docs/generated/rxmc.covariance.noise_fraction_term.rst create mode 100644 docs/generated/rxmc.covariance.noise_term.rst create mode 100644 docs/generated/rxmc.covariance.normalization_term.rst create mode 100644 docs/generated/rxmc.covariance.offset_term.rst create mode 100644 docs/generated/rxmc.covariance.stacked_supports.rst create mode 100644 docs/generated/rxmc.covariance.statistical_term.rst create mode 100644 docs/generated/rxmc.likelihood_model.Chi2.rst delete mode 100644 docs/generated/rxmc.likelihood_model.Chi2LikelihoodModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.FixedCovarianceLikelihood.rst create mode 100644 docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst create mode 100644 docs/generated/rxmc.likelihood_model.Likelihood.rst delete mode 100644 docs/generated/rxmc.likelihood_model.LikelihoodModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.ParametricLikelihoodModel.rst create mode 100644 docs/generated/rxmc.likelihood_model.StudentT.rst delete mode 100644 docs/generated/rxmc.likelihood_model.StudentTLikelihoodModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.UnknownModelError.rst delete mode 100644 docs/generated/rxmc.likelihood_model.UnknownNoiseErrorModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.UnknownNoiseFractionErrorModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.UnknownNormalizationErrorModel.rst delete mode 100644 docs/generated/rxmc.likelihood_model.UnknownNormalizationModel.rst create mode 100644 docs/generated/rxmc.likelihood_model.log_likelihood.rst create mode 100644 docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst delete mode 100644 docs/generated/rxmc.observation.FixedCovarianceObservation.rst create mode 100644 docs/generated/rxmc.physical_model.PerObservationScaledModel.rst create mode 100644 docs/generated/rxmc.physical_model.ScaledModel.rst create mode 100644 docs/generated/rxmc.predictive.gp_posterior_predictive.rst create mode 100644 docs/generated/rxmc.predictive.predictive_band.rst create mode 100644 docs/generated/rxmc.predictive.total_predictive_band.rst delete mode 100644 environment.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7309c18..dfd05c1 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,7 +46,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.10", "3.12"] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v4 @@ -66,7 +66,7 @@ jobs: notebooks: runs-on: ubuntu-latest - timeout-minutes: 45 + timeout-minutes: 60 steps: - uses: actions/checkout@v4 @@ -79,10 +79,10 @@ jobs: - name: Install validation dependencies run: | python -m pip install --upgrade pip setuptools wheel - python -m pip install -e '.[validation]' + python -m pip install -e '.[validation]' pytest-xdist - name: Run notebooks with pytest - run: python -m pytest examples + run: python -m pytest -n 4 --nbmake --nbmake-timeout=1200 examples docs: runs-on: ubuntu-latest diff --git a/.gitignore b/.gitignore index 3c8dc04..b682064 100644 --- a/.gitignore +++ b/.gitignore @@ -118,7 +118,10 @@ ipython_config.py # Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. -#uv.lock +uv.lock + +# agent/session config +.claude/ # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. @@ -212,3 +215,4 @@ cython_debug/ # refer to https://docs.cursor.com/context/ignore-files .cursorignore .cursorindexingignore +docs/jupyter_execute/ diff --git a/README.md b/README.md index 44ad28a..3fe0e2c 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # rxmc `rxmc` is an orchestration layer for Bayesian calibration of reaction models to -large data sets with flexible likelihood modeling. +large data sets with flexible, composable covariance modeling. It is built around two complementary workflows: @@ -15,10 +15,55 @@ The package composes: - curated experimental data as `Observation` objects, - model predictions via `PhysicalModel`, -- statistical assumptions via `LikelihoodModel`, -- independent data-model pairings via `Constraint`, +- uncertainty declared as additive covariance `Term`s (statistical, + systematic, unknown-noise, and Gaussian-process discrepancy modes) via + `rxmc.covariance`, +- maximal blocks of mutually-correlated data via `Constraint`, - and full calibration problems via `Evidence`. +## Quickstart + +```python +import numpy as np +from scipy import stats +import rxmc + +# measured data: pure data plus (optional) reported systematics as metadata +obs = rxmc.observation.Observation( + x=x, y=y, y_stat_err=y_err, y_sys_err_normalization=0.04 +) + +# a constraint owns one multivariate likelihood over its stacked observations; +# every correlated mode is an explicit covariance term - nothing is folded in +# silently +(support,) = rxmc.covariance.stacked_supports([obs]) +constraint = rxmc.constraint.Constraint( + [obs], model, extra_terms=obs.systematic_terms(support) +) +evidence = rxmc.evidence.Evidence([constraint]) + +# calibrate with the in-package Gibbs walker (or wrap in CalibrationConfig +# for emcee / dynesty) +prior = stats.multivariate_normal(mean=prior_mean, cov=prior_cov) +walker = rxmc.walker.Walker( + rxmc.param_sampling.BatchedAdaptiveMetropolisSampler( + params=model.params, + starting_location=prior.mean, + prior=prior, + initial_proposal_cov=prior.cov / 100, + ), + evidence, + rng=np.random.default_rng(1), +) +walker.walk(n_steps=10_000, burnin=1_000, batch_size=1_000) +``` + +> **Note — behavior change from pre-0.1 versions:** an `Observation`'s +> reported systematic errors are never folded into the covariance +> automatically. The default constraint covariance is the statistical diagonal +> only; systematics enter explicitly, e.g. via +> `obs.systematic_terms(support)` passed to `Constraint(extra_terms=...)`. + ## Installation @@ -32,20 +77,6 @@ pip install -ve . It is strongly recommended to use an isolated environment. -### `conda` / `mamba` - -```bash -conda env create -f environment.yml -conda activate rxmc -pip install -ve . --no-deps -``` - -```bash -mamba env create -f environment.yml -mamba activate rxmc -pip install -ve . --no-deps -``` - ### `venv` ```bash @@ -95,7 +126,8 @@ Typical flow: 1. Build `Observation` objects from your measurements. 2. Define a `PhysicalModel`. -3. Choose a `LikelihoodModel`. +3. Declare correlated uncertainty as covariance `Term`s (and pick a + likelihood functional: Gaussian, Student-t, or chi-squared). 4. Combine them into `Constraint` objects and then `Evidence`. 5. Wrap the problem in `ParameterConfig` and `CalibrationConfig`. 6. Hand the resulting object to an external sampler. @@ -121,31 +153,45 @@ for: ### `Observation` -Represents measured data and its covariance structure, including: - -- statistical errors, -- systematic normalization errors, -- systematic offset errors, -- or fixed covariance matrices. +Pure measured data — `x`, `y`, and the statistical error on `y` — plus the +measurement's reported systematic magnitudes retained as inert metadata +(`y_sys_err_normalization`, `y_sys_err_offset`). It contributes only its +statistical diagonal by default; `obs.systematic_terms(support)` turns the +metadata into explicit covariance terms when you ask. ### `PhysicalModel` Maps model parameters to predicted observables for a given `Observation`. +`ScaledModel` / `PerObservationScaledModel` wrap any model with latent +normalization parameters (Kennedy–O'Hagan style). + +### Covariance `Term`s (`rxmc.covariance`) + +Every uncertainty beyond the statistical diagonal is an explicit additive +contribution to the constraint's stacked covariance. Factory helpers cover the +common modes: + +- `normalization_term` / `offset_term` — correlated systematics, fixed + magnitude or free nuisance, +- `noise_term` / `noise_fraction_term` — unknown statistical noise, +- `model_error_term` — uncorrelated model error, +- `discrepancy_term` — Gaussian-process model discrepancy using sklearn + kernels. -### `LikelihoodModel` +A term whose support spans several observations *couples* them (correlated +datasets); referencing the same `Parameter` object in two terms *shares* one +sampled value between them. -Encodes how predictions are compared to observations. Built-in options include: +### Likelihood functionals -- Gaussian covariance-based likelihoods, -- unknown noise models, -- unknown normalization / normalization-error models, -- unknown model-error terms, -- Student-t likelihoods, -- and a Gaussian-process discrepancy model using sklearn kernels. +`GaussianLikelihood` (default), `StudentT` (heavy-tailed, with a +degrees-of-freedom parameter), and `Chi2` are thin functionals over the same +stacked covariance. ### `Constraint` -Pairs observations, a physical model, and a likelihood model. +The maximal block of mutually-correlated data: observations, a physical model, +a covariance assembled from terms, and a likelihood functional. ### `Evidence` @@ -158,10 +204,16 @@ The `examples/` directory contains richer notebooks and demos. The most useful entry points are: - `examples/linear_calibration_demo.ipynb` for the basic workflow, -- `examples/systematic_err_demo.ipynb` for likelihood comparisons and +- `examples/systematic_err_demo.ipynb` for the error-model catalog and systematic-error handling, +- `examples/measurement_to_calibration.ipynb` for the EXFOR-measurement → + calibration path (units, retained systematics, guardrails), - `examples/30s_optical_potential_calibration.ipynb` for a realistic optical potential calibration example, +- `examples/correlated_observations.ipynb` for correlated datasets and shared + systematics (including across cross-section experiments), +- `examples/gp_discrepancy.ipynb` for Gaussian-process model discrepancy, +- `examples/robust_likelihoods.ipynb` for Student-t vs Gaussian likelihoods, - `examples/normalization_inference.ipynb` for normalization-focused modeling, - `examples/sampling_algos.ipynb` for sampling comparisons. diff --git a/docs/api.rst b/docs/api.rst index 5651f6c..0940a4d 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -38,29 +38,72 @@ Core building blocks rxmc.constraint.Constraint rxmc.evidence.Evidence rxmc.observation.Observation - rxmc.observation.FixedCovarianceObservation rxmc.params.Parameter rxmc.physical_model.PhysicalModel rxmc.physical_model.Polynomial + rxmc.physical_model.ScaledModel + rxmc.physical_model.PerObservationScaledModel -Likelihood models ------------------ +Covariance terms +---------------- + +The stacked covariance of a :class:`~rxmc.constraint.Constraint` is assembled +additively from :class:`~rxmc.covariance.Term` objects. The factory helpers +are the primary authoring API; the term primitives underneath are available for +custom modes. Context-dependent terms and basis callables receive a +``StackContext`` bundling the stacked ``x``/``y``/``ym`` arrays and block +supports (see the :mod:`rxmc.covariance` module docstring). + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + rxmc.covariance.statistical_term + rxmc.covariance.normalization_term + rxmc.covariance.offset_term + rxmc.covariance.noise_term + rxmc.covariance.noise_fraction_term + rxmc.covariance.model_error_term + rxmc.covariance.discrepancy_term + rxmc.covariance.stacked_supports + rxmc.covariance.Term + rxmc.covariance.DenseTerm + rxmc.covariance.DiagonalTerm + rxmc.covariance.RankOneTerm + rxmc.covariance.KernelTerm + rxmc.covariance.ConstraintCovariance + +Likelihood functionals +---------------------- + +Thin functionals of the pre-computed Mahalanobis statistics +``(d2, logdet, n)``; all covariance modeling lives on the +:class:`~rxmc.covariance.ConstraintCovariance`. + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + rxmc.likelihood_model.Likelihood + rxmc.likelihood_model.GaussianLikelihood + rxmc.likelihood_model.StudentT + rxmc.likelihood_model.Chi2 + rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky + rxmc.likelihood_model.log_likelihood + +Predictive utilities +-------------------- + +Posterior-predictive helpers, including Gaussian-process discrepancy +propagation. .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.likelihood_model.LikelihoodModel - rxmc.likelihood_model.FixedCovarianceLikelihood - rxmc.likelihood_model.Chi2LikelihoodModel - rxmc.likelihood_model.ParametricLikelihoodModel - rxmc.likelihood_model.UnknownNoiseErrorModel - rxmc.likelihood_model.UnknownNoiseFractionErrorModel - rxmc.likelihood_model.UnknownNormalizationModel - rxmc.likelihood_model.UnknownNormalizationErrorModel - rxmc.likelihood_model.UnknownModelError - rxmc.likelihood_model.StudentTLikelihoodModel - rxmc.correlated_discrepancy_likelihood_model.SklearnKernelGPDiscrepancyModel + rxmc.predictive.predictive_band + rxmc.predictive.gp_posterior_predictive + rxmc.predictive.total_predictive_band Sampling -------- diff --git a/docs/conf.py b/docs/conf.py index 5376c16..22f4d51 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -62,4 +62,4 @@ "scipy": ("https://docs.scipy.org/doc/scipy", None), } -exclude_patterns = ["_build", "**.ipynb_checkpoints"] +exclude_patterns = ["_build", "jupyter_execute", "**.ipynb_checkpoints"] diff --git a/docs/design.md b/docs/design.md new file mode 100644 index 0000000..ba360d4 --- /dev/null +++ b/docs/design.md @@ -0,0 +1,143 @@ +# Design: the stacked covariance model + +This page records the architecture of `rxmc`'s covariance layer — the design +that replaced the pre-0.1 "likelihood model zoo" — and the decisions locked in +during that refactor. + +## The two mechanisms + +Two different things hide under "share a covariance," and they live on +different axes: + +- **(A) Correlating observations** is a statement about **covariance + structure** — off-diagonal blocks coupling observation *i* and *j*. +- **(B) Two covariance terms sharing a parameter** is a statement about + **parameter wiring** — the observations stay independent; one θ component + feeds two different terms. + +**A couples the data; B couples the parameters.** They get distinct +mechanisms: + +- **A — the covariance owns the stacked block.** A + {class}`~rxmc.constraint.Constraint` is the maximal block of + mutually-correlated data: it owns one multivariate likelihood over the + stacked vector `y = [y1; y2; ...]` of its observations. A *coupling* term is + simply one whose `support` spans more than one observation block. +- **B — parameter routing by identity.** + {class}`~rxmc.covariance.ConstraintCovariance` deduplicates the + {class}`~rxmc.params.Parameter` objects its terms reference **by identity** + (gather, not slice): referencing the *same* object in two terms yields one + entry in the sampled vector, gathered into both. + +The normalization example shows why both are needed: two datasets with +*independent* flux measurements of the same *magnitude* are case B (two +block-local `normalization_term`s sharing one `Parameter`); two datasets +normalized by the *same* uncertain flux are case A (one `normalization_term` +whose support spans both blocks). This is the D'Agostini / Barlow +correlated-systematics distinction. + +## Terms and the assembled covariance + +A {class}`~rxmc.covariance.Term` is one additive contribution to the stacked +covariance: it carries a `support` (indices into the stacked vector), the +`Parameter`s it consumes, and writes its block via `add_to(Sigma, ctx, theta)`. +Context-dependent terms receive a `StackContext` bundling the stacked +`x`/`y`/`ym` and the block supports, so modes can be prediction-scaled +(`ctx.ym[support]`) or coordinate-dependent (kernels). + +The primitives — {class}`~rxmc.covariance.DenseTerm` (fixed block, validated +for shape and symmetry), {class}`~rxmc.covariance.DiagonalTerm`, +{class}`~rxmc.covariance.RankOneTerm`, and +{class}`~rxmc.covariance.KernelTerm` (sklearn kernels; one parameter per free +hyperparameter *element*, so anisotropic kernels contribute +`len(kernel.theta)` parameters) — are wrapped by the factory helpers that form +the primary authoring API: `statistical_term`, `normalization_term`, +`offset_term`, `noise_term`, `noise_fraction_term`, `model_error_term`, and +`discrepancy_term`. + +{class}`~rxmc.covariance.ConstraintCovariance` assembles the terms. It is +constructed with the true observation block boundaries +(`blocks=stacked_supports(observations)`), from which two structural facts are +decided **once, conservatively**: + +- `block_diagonal` — true only if every off-diagonal-capable term + (`couples_offdiagonal`) provably sits inside a single block. With no blocks + supplied, any coupling-capable term forces the dense path; there is no + guessing from support shape. +- `is_constant` — true when no term depends on parameters or context; the + Cholesky factors (dense and per-block) are then computed once and cached + read-only. + +`ConstraintCovariance.stacked_distance(ctx, params)` owns the dispatch between +the block-diagonal fast path (factor each block separately, `O(Σ nᵢ³)`) and a +single dense Cholesky — and is the seam where a future low-rank (Woodbury) +path would slot in. + +## Observations are leaves + +An {class}`~rxmc.observation.Observation` is pure data — `x`, `y`, +`y_stat_err` — plus the measurement's reported systematic magnitudes retained +as **inert metadata** (`y_sys_err_normalization` fractional, +`y_sys_err_offset` absolute in internal units). It emits only its statistical +diagonal automatically. Every correlated mode is an explicit term: +`obs.systematic_terms(support)` converts the metadata on request, and +**nothing is ever folded into a covariance silently** — a deliberate behavior +change from pre-0.1 versions, pinned by regression tests. + +The reaction observation classes' `from_measurement` constructors keep this +contract across unit conversion: dimensionful errors (statistical, offset) are +divided by the unit normalization (retained as `obs.norm`; a per-angle array +in the Rutherford-conversion cases), the fractional normalization error passes +through untouched. + +## Constraints, likelihood functionals, and parameters + +`Constraint(observations, physical_model, likelihood=GaussianLikelihood(), +extra_terms=(), include_statistical_term=True)` builds the stacked covariance +from each observation's statistical term plus the explicit `extra_terms` +(`include_statistical_term=False` composes the entire covariance from +`extra_terms`, e.g. to let a `noise_term` *replace* reported statistics). + +A likelihood ({class}`~rxmc.likelihood_model.Likelihood`: +`GaussianLikelihood`, `StudentT`, `Chi2`) is a thin functional of the +pre-computed `(d2, logdet, n)` statistics. The constraint's parameter vector +is the **full tuple** — covariance parameters followed by likelihood +parameters (e.g. Student-t `nu`) — and every method (`log_likelihood`, `chi2`, +`covariance_matrix`, `marginal_log_likelihood`) takes it in that order, +validating the count. + +Mean renormalization (a Kennedy–O'Hagan latent scale ρ) is **not** a +covariance term: it changes the mean, so it lives on the model side as +{class}`~rxmc.physical_model.ScaledModel` / +{class}`~rxmc.physical_model.PerObservationScaledModel`, flowing through the +ordinary model-parameter machinery. + +## Scope decisions (locked) + +- **Constraint = maximal correlated block.** {class}`~rxmc.evidence.Evidence` + stays a weighted sum over *independent* constraints, so factorization cost + is bounded at the block level. +- **Covariance/likelihood parameters are constraint-scoped.** Case-A and + case-B sharing both happen *within* a constraint. Sharing a `Parameter` + object across constraints, or duplicating a parameter name anywhere in an + `Evidence`, is a hard error — the sanctioned model for a systematic shared + between datasets is one constraint with a cross-block coupling term. +- **Tempering is consistent**: `Evidence` weights and + `CalibrationConfig.likelihood_scaling` apply to the likelihood only (never + the prior), including inside the Gibbs conditionals. +- **Fail fast**: constant covariances are factored eagerly at `Constraint` + construction, so a singular covariance (e.g. an EXFOR subentry with no + statistical error and no covering term) raises a named, actionable error + instead of a `LinAlgError` mid-chain. + +## Known limitations + +- **No low-rank fast path yet.** Cross-block couplings are typically low rank, + and the design anticipates a Woodbury / matrix-determinant-lemma update on + top of the block-diagonal base; today they take the dense `O(N³)` path. + `ConstraintCovariance.stacked_distance` is the seam. +- **Non-constant block-diagonal covariances still assemble the dense `N×N` + matrix** before factoring its blocks (per-term `add_to` writes into the full + matrix by design). +- Masked/multi-mode systematics on `Observation` are deferred; the factory + helpers accept a `mask=` argument directly for masked terms. diff --git a/docs/examples.rst b/docs/examples.rst index 266fee1..abeccd8 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -18,6 +18,7 @@ Basic calibration examples/linear_calibration_demo.ipynb examples/systematic_err_demo.ipynb + examples/robust_likelihoods.ipynb Realistic nuclear physics calibration -------------------------------------- @@ -26,6 +27,7 @@ Realistic nuclear physics calibration :maxdepth: 1 examples/30s_optical_potential_calibration.ipynb + examples/measurement_to_calibration.ipynb examples/calibration_config_emcee_dynesty.ipynb Advanced topics @@ -34,6 +36,8 @@ Advanced topics .. toctree:: :maxdepth: 1 + examples/correlated_observations.ipynb + examples/gp_discrepancy.ipynb examples/normalization_inference.ipynb examples/sampling_algos.ipynb examples/overconfidence.ipynb diff --git a/docs/generated/rxmc.config.CalibrationConfig.rst b/docs/generated/rxmc.config.CalibrationConfig.rst index 67aff7c..2d16ffb 100644 --- a/docs/generated/rxmc.config.CalibrationConfig.rst +++ b/docs/generated/rxmc.config.CalibrationConfig.rst @@ -20,6 +20,7 @@ ~CalibrationConfig.log_posterior_batch ~CalibrationConfig.log_prior ~CalibrationConfig.predict + ~CalibrationConfig.predict_parametric ~CalibrationConfig.prior_transform ~CalibrationConfig.split_parameters ~CalibrationConfig.starting_location diff --git a/docs/generated/rxmc.constraint.Constraint.rst b/docs/generated/rxmc.constraint.Constraint.rst index 0f96af2..cca1447 100644 --- a/docs/generated/rxmc.constraint.Constraint.rst +++ b/docs/generated/rxmc.constraint.Constraint.rst @@ -15,10 +15,10 @@ ~Constraint.__init__ ~Constraint.chi2 + ~Constraint.covariance_matrix ~Constraint.empirical_coverage ~Constraint.log_likelihood ~Constraint.marginal_log_likelihood - ~Constraint.model ~Constraint.num_pts_within_interval ~Constraint.predict diff --git a/docs/generated/rxmc.correlated_discrepancy_likelihood_model.SklearnKernelGPDiscrepancyModel.rst b/docs/generated/rxmc.correlated_discrepancy_likelihood_model.SklearnKernelGPDiscrepancyModel.rst deleted file mode 100644 index 02d8331..0000000 --- a/docs/generated/rxmc.correlated_discrepancy_likelihood_model.SklearnKernelGPDiscrepancyModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.correlated\_discrepancy\_likelihood\_model.SklearnKernelGPDiscrepancyModel -=============================================================================== - -.. currentmodule:: rxmc.correlated_discrepancy_likelihood_model - -.. autoclass:: SklearnKernelGPDiscrepancyModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~SklearnKernelGPDiscrepancyModel.__init__ - ~SklearnKernelGPDiscrepancyModel.chi2 - ~SklearnKernelGPDiscrepancyModel.covariance - ~SklearnKernelGPDiscrepancyModel.log_likelihood - ~SklearnKernelGPDiscrepancyModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.ConstraintCovariance.rst b/docs/generated/rxmc.covariance.ConstraintCovariance.rst new file mode 100644 index 0000000..e8fe693 --- /dev/null +++ b/docs/generated/rxmc.covariance.ConstraintCovariance.rst @@ -0,0 +1,33 @@ +rxmc.covariance.ConstraintCovariance +==================================== + +.. currentmodule:: rxmc.covariance + +.. autoclass:: ConstraintCovariance + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~ConstraintCovariance.__init__ + ~ConstraintCovariance.block_cholesky + ~ConstraintCovariance.cholesky + ~ConstraintCovariance.matrix + ~ConstraintCovariance.stacked_distance + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~ConstraintCovariance.blocks + ~ConstraintCovariance.n_params + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.DenseTerm.rst b/docs/generated/rxmc.covariance.DenseTerm.rst new file mode 100644 index 0000000..6e94a9e --- /dev/null +++ b/docs/generated/rxmc.covariance.DenseTerm.rst @@ -0,0 +1,32 @@ +rxmc.covariance.DenseTerm +========================= + +.. currentmodule:: rxmc.covariance + +.. autoclass:: DenseTerm + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~DenseTerm.__init__ + ~DenseTerm.add_to + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~DenseTerm.couples_offdiagonal + ~DenseTerm.is_constant + ~DenseTerm.params + ~DenseTerm.support + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.DiagonalTerm.rst b/docs/generated/rxmc.covariance.DiagonalTerm.rst new file mode 100644 index 0000000..48dac86 --- /dev/null +++ b/docs/generated/rxmc.covariance.DiagonalTerm.rst @@ -0,0 +1,32 @@ +rxmc.covariance.DiagonalTerm +============================ + +.. currentmodule:: rxmc.covariance + +.. autoclass:: DiagonalTerm + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~DiagonalTerm.__init__ + ~DiagonalTerm.add_to + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~DiagonalTerm.couples_offdiagonal + ~DiagonalTerm.is_constant + ~DiagonalTerm.params + ~DiagonalTerm.support + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.KernelTerm.rst b/docs/generated/rxmc.covariance.KernelTerm.rst new file mode 100644 index 0000000..13b5b0d --- /dev/null +++ b/docs/generated/rxmc.covariance.KernelTerm.rst @@ -0,0 +1,32 @@ +rxmc.covariance.KernelTerm +========================== + +.. currentmodule:: rxmc.covariance + +.. autoclass:: KernelTerm + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~KernelTerm.__init__ + ~KernelTerm.add_to + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~KernelTerm.couples_offdiagonal + ~KernelTerm.is_constant + ~KernelTerm.params + ~KernelTerm.support + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.RankOneTerm.rst b/docs/generated/rxmc.covariance.RankOneTerm.rst new file mode 100644 index 0000000..6bb9526 --- /dev/null +++ b/docs/generated/rxmc.covariance.RankOneTerm.rst @@ -0,0 +1,32 @@ +rxmc.covariance.RankOneTerm +=========================== + +.. currentmodule:: rxmc.covariance + +.. autoclass:: RankOneTerm + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~RankOneTerm.__init__ + ~RankOneTerm.add_to + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~RankOneTerm.couples_offdiagonal + ~RankOneTerm.is_constant + ~RankOneTerm.params + ~RankOneTerm.support + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.Term.rst b/docs/generated/rxmc.covariance.Term.rst new file mode 100644 index 0000000..3074349 --- /dev/null +++ b/docs/generated/rxmc.covariance.Term.rst @@ -0,0 +1,32 @@ +rxmc.covariance.Term +==================== + +.. currentmodule:: rxmc.covariance + +.. autoclass:: Term + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~Term.__init__ + ~Term.add_to + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~Term.couples_offdiagonal + ~Term.is_constant + ~Term.params + ~Term.support + + \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.discrepancy_term.rst b/docs/generated/rxmc.covariance.discrepancy_term.rst new file mode 100644 index 0000000..d0fc059 --- /dev/null +++ b/docs/generated/rxmc.covariance.discrepancy_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.discrepancy\_term +================================= + +.. currentmodule:: rxmc.covariance + +.. autofunction:: discrepancy_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.model_error_term.rst b/docs/generated/rxmc.covariance.model_error_term.rst new file mode 100644 index 0000000..5e16b63 --- /dev/null +++ b/docs/generated/rxmc.covariance.model_error_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.model\_error\_term +================================== + +.. currentmodule:: rxmc.covariance + +.. autofunction:: model_error_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.noise_fraction_term.rst b/docs/generated/rxmc.covariance.noise_fraction_term.rst new file mode 100644 index 0000000..0da615a --- /dev/null +++ b/docs/generated/rxmc.covariance.noise_fraction_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.noise\_fraction\_term +===================================== + +.. currentmodule:: rxmc.covariance + +.. autofunction:: noise_fraction_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.noise_term.rst b/docs/generated/rxmc.covariance.noise_term.rst new file mode 100644 index 0000000..d209843 --- /dev/null +++ b/docs/generated/rxmc.covariance.noise_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.noise\_term +=========================== + +.. currentmodule:: rxmc.covariance + +.. autofunction:: noise_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.normalization_term.rst b/docs/generated/rxmc.covariance.normalization_term.rst new file mode 100644 index 0000000..feca611 --- /dev/null +++ b/docs/generated/rxmc.covariance.normalization_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.normalization\_term +=================================== + +.. currentmodule:: rxmc.covariance + +.. autofunction:: normalization_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.offset_term.rst b/docs/generated/rxmc.covariance.offset_term.rst new file mode 100644 index 0000000..4aa2980 --- /dev/null +++ b/docs/generated/rxmc.covariance.offset_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.offset\_term +============================ + +.. currentmodule:: rxmc.covariance + +.. autofunction:: offset_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.stacked_supports.rst b/docs/generated/rxmc.covariance.stacked_supports.rst new file mode 100644 index 0000000..5d367db --- /dev/null +++ b/docs/generated/rxmc.covariance.stacked_supports.rst @@ -0,0 +1,6 @@ +rxmc.covariance.stacked\_supports +================================= + +.. currentmodule:: rxmc.covariance + +.. autofunction:: stacked_supports \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.statistical_term.rst b/docs/generated/rxmc.covariance.statistical_term.rst new file mode 100644 index 0000000..baec23c --- /dev/null +++ b/docs/generated/rxmc.covariance.statistical_term.rst @@ -0,0 +1,6 @@ +rxmc.covariance.statistical\_term +================================= + +.. currentmodule:: rxmc.covariance + +.. autofunction:: statistical_term \ No newline at end of file diff --git a/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst b/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst index 8650ae5..d702f26 100644 --- a/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst +++ b/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst @@ -15,10 +15,10 @@ ~ElasticDifferentialXSObservation.__init__ ~ElasticDifferentialXSObservation.calculate_normalization - ~ElasticDifferentialXSObservation.covariance ~ElasticDifferentialXSObservation.from_measurement ~ElasticDifferentialXSObservation.num_pts_within_interval - ~ElasticDifferentialXSObservation.residual + ~ElasticDifferentialXSObservation.statistical_term + ~ElasticDifferentialXSObservation.systematic_terms diff --git a/docs/generated/rxmc.evidence.Evidence.rst b/docs/generated/rxmc.evidence.Evidence.rst index 154fd14..acc1e90 100644 --- a/docs/generated/rxmc.evidence.Evidence.rst +++ b/docs/generated/rxmc.evidence.Evidence.rst @@ -15,6 +15,7 @@ ~Evidence.__init__ ~Evidence.log_likelihood + ~Evidence.weighted_marginal_log_likelihood diff --git a/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst b/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst index 431afa4..3710cb4 100644 --- a/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst +++ b/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst @@ -14,10 +14,10 @@ .. autosummary:: ~IsobaricAnalogPNObservation.__init__ - ~IsobaricAnalogPNObservation.covariance ~IsobaricAnalogPNObservation.from_measurement ~IsobaricAnalogPNObservation.num_pts_within_interval - ~IsobaricAnalogPNObservation.residual + ~IsobaricAnalogPNObservation.statistical_term + ~IsobaricAnalogPNObservation.systematic_terms diff --git a/docs/generated/rxmc.likelihood_model.Chi2.rst b/docs/generated/rxmc.likelihood_model.Chi2.rst new file mode 100644 index 0000000..5dbb7bd --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.Chi2.rst @@ -0,0 +1,31 @@ +rxmc.likelihood\_model.Chi2 +=========================== + +.. currentmodule:: rxmc.likelihood_model + +.. autoclass:: Chi2 + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~Chi2.__init__ + ~Chi2.chi2 + ~Chi2.log_likelihood + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~Chi2.n_params + ~Chi2.params + + \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.Chi2LikelihoodModel.rst b/docs/generated/rxmc.likelihood_model.Chi2LikelihoodModel.rst deleted file mode 100644 index 1493dff..0000000 --- a/docs/generated/rxmc.likelihood_model.Chi2LikelihoodModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.Chi2LikelihoodModel -========================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: Chi2LikelihoodModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Chi2LikelihoodModel.__init__ - ~Chi2LikelihoodModel.chi2 - ~Chi2LikelihoodModel.covariance - ~Chi2LikelihoodModel.log_likelihood - ~Chi2LikelihoodModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.FixedCovarianceLikelihood.rst b/docs/generated/rxmc.likelihood_model.FixedCovarianceLikelihood.rst deleted file mode 100644 index 31d98d3..0000000 --- a/docs/generated/rxmc.likelihood_model.FixedCovarianceLikelihood.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.FixedCovarianceLikelihood -================================================ - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: FixedCovarianceLikelihood - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~FixedCovarianceLikelihood.__init__ - ~FixedCovarianceLikelihood.chi2 - ~FixedCovarianceLikelihood.covariance - ~FixedCovarianceLikelihood.log_likelihood - ~FixedCovarianceLikelihood.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst b/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst new file mode 100644 index 0000000..16c84cc --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst @@ -0,0 +1,31 @@ +rxmc.likelihood\_model.GaussianLikelihood +========================================= + +.. currentmodule:: rxmc.likelihood_model + +.. autoclass:: GaussianLikelihood + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~GaussianLikelihood.__init__ + ~GaussianLikelihood.chi2 + ~GaussianLikelihood.log_likelihood + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~GaussianLikelihood.n_params + ~GaussianLikelihood.params + + \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.Likelihood.rst b/docs/generated/rxmc.likelihood_model.Likelihood.rst new file mode 100644 index 0000000..794d1e3 --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.Likelihood.rst @@ -0,0 +1,31 @@ +rxmc.likelihood\_model.Likelihood +================================= + +.. currentmodule:: rxmc.likelihood_model + +.. autoclass:: Likelihood + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~Likelihood.__init__ + ~Likelihood.chi2 + ~Likelihood.log_likelihood + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~Likelihood.n_params + ~Likelihood.params + + \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.LikelihoodModel.rst b/docs/generated/rxmc.likelihood_model.LikelihoodModel.rst deleted file mode 100644 index 36efd72..0000000 --- a/docs/generated/rxmc.likelihood_model.LikelihoodModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.LikelihoodModel -====================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: LikelihoodModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~LikelihoodModel.__init__ - ~LikelihoodModel.chi2 - ~LikelihoodModel.covariance - ~LikelihoodModel.log_likelihood - ~LikelihoodModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.ParametricLikelihoodModel.rst b/docs/generated/rxmc.likelihood_model.ParametricLikelihoodModel.rst deleted file mode 100644 index f3fec3e..0000000 --- a/docs/generated/rxmc.likelihood_model.ParametricLikelihoodModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.ParametricLikelihoodModel -================================================ - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: ParametricLikelihoodModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ParametricLikelihoodModel.__init__ - ~ParametricLikelihoodModel.chi2 - ~ParametricLikelihoodModel.covariance - ~ParametricLikelihoodModel.log_likelihood - ~ParametricLikelihoodModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.StudentT.rst b/docs/generated/rxmc.likelihood_model.StudentT.rst new file mode 100644 index 0000000..c7ab508 --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.StudentT.rst @@ -0,0 +1,31 @@ +rxmc.likelihood\_model.StudentT +=============================== + +.. currentmodule:: rxmc.likelihood_model + +.. autoclass:: StudentT + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~StudentT.__init__ + ~StudentT.chi2 + ~StudentT.log_likelihood + + + + + + .. rubric:: Attributes + + .. autosummary:: + + ~StudentT.n_params + ~StudentT.params + + \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.StudentTLikelihoodModel.rst b/docs/generated/rxmc.likelihood_model.StudentTLikelihoodModel.rst deleted file mode 100644 index 72d2a8e..0000000 --- a/docs/generated/rxmc.likelihood_model.StudentTLikelihoodModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.StudentTLikelihoodModel -============================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: StudentTLikelihoodModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~StudentTLikelihoodModel.__init__ - ~StudentTLikelihoodModel.chi2 - ~StudentTLikelihoodModel.covariance - ~StudentTLikelihoodModel.log_likelihood - ~StudentTLikelihoodModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.UnknownModelError.rst b/docs/generated/rxmc.likelihood_model.UnknownModelError.rst deleted file mode 100644 index 97a9d8b..0000000 --- a/docs/generated/rxmc.likelihood_model.UnknownModelError.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.UnknownModelError -======================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: UnknownModelError - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~UnknownModelError.__init__ - ~UnknownModelError.chi2 - ~UnknownModelError.covariance - ~UnknownModelError.log_likelihood - ~UnknownModelError.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.UnknownNoiseErrorModel.rst b/docs/generated/rxmc.likelihood_model.UnknownNoiseErrorModel.rst deleted file mode 100644 index e0059e3..0000000 --- a/docs/generated/rxmc.likelihood_model.UnknownNoiseErrorModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.UnknownNoiseErrorModel -============================================= - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: UnknownNoiseErrorModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~UnknownNoiseErrorModel.__init__ - ~UnknownNoiseErrorModel.chi2 - ~UnknownNoiseErrorModel.covariance - ~UnknownNoiseErrorModel.log_likelihood - ~UnknownNoiseErrorModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.UnknownNoiseFractionErrorModel.rst b/docs/generated/rxmc.likelihood_model.UnknownNoiseFractionErrorModel.rst deleted file mode 100644 index 63093fd..0000000 --- a/docs/generated/rxmc.likelihood_model.UnknownNoiseFractionErrorModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.UnknownNoiseFractionErrorModel -===================================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: UnknownNoiseFractionErrorModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~UnknownNoiseFractionErrorModel.__init__ - ~UnknownNoiseFractionErrorModel.chi2 - ~UnknownNoiseFractionErrorModel.covariance - ~UnknownNoiseFractionErrorModel.log_likelihood - ~UnknownNoiseFractionErrorModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.UnknownNormalizationErrorModel.rst b/docs/generated/rxmc.likelihood_model.UnknownNormalizationErrorModel.rst deleted file mode 100644 index a0c6615..0000000 --- a/docs/generated/rxmc.likelihood_model.UnknownNormalizationErrorModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.UnknownNormalizationErrorModel -===================================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: UnknownNormalizationErrorModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~UnknownNormalizationErrorModel.__init__ - ~UnknownNormalizationErrorModel.chi2 - ~UnknownNormalizationErrorModel.covariance - ~UnknownNormalizationErrorModel.log_likelihood - ~UnknownNormalizationErrorModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.UnknownNormalizationModel.rst b/docs/generated/rxmc.likelihood_model.UnknownNormalizationModel.rst deleted file mode 100644 index f9ea13e..0000000 --- a/docs/generated/rxmc.likelihood_model.UnknownNormalizationModel.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.likelihood\_model.UnknownNormalizationModel -================================================ - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: UnknownNormalizationModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~UnknownNormalizationModel.__init__ - ~UnknownNormalizationModel.chi2 - ~UnknownNormalizationModel.covariance - ~UnknownNormalizationModel.log_likelihood - ~UnknownNormalizationModel.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.log_likelihood.rst b/docs/generated/rxmc.likelihood_model.log_likelihood.rst new file mode 100644 index 0000000..1b66b0a --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.log_likelihood.rst @@ -0,0 +1,6 @@ +rxmc.likelihood\_model.log\_likelihood +====================================== + +.. currentmodule:: rxmc.likelihood_model + +.. autofunction:: log_likelihood \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst b/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst new file mode 100644 index 0000000..0a1e57a --- /dev/null +++ b/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst @@ -0,0 +1,6 @@ +rxmc.likelihood\_model.mahalanobis\_distance\_sqr\_cholesky +=========================================================== + +.. currentmodule:: rxmc.likelihood_model + +.. autofunction:: mahalanobis_distance_sqr_cholesky \ No newline at end of file diff --git a/docs/generated/rxmc.observation.FixedCovarianceObservation.rst b/docs/generated/rxmc.observation.FixedCovarianceObservation.rst deleted file mode 100644 index a4576c5..0000000 --- a/docs/generated/rxmc.observation.FixedCovarianceObservation.rst +++ /dev/null @@ -1,25 +0,0 @@ -rxmc.observation.FixedCovarianceObservation -=========================================== - -.. currentmodule:: rxmc.observation - -.. autoclass:: FixedCovarianceObservation - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~FixedCovarianceObservation.__init__ - ~FixedCovarianceObservation.covariance - ~FixedCovarianceObservation.num_pts_within_interval - ~FixedCovarianceObservation.residual - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.observation.Observation.rst b/docs/generated/rxmc.observation.Observation.rst index 3265a08..c804feb 100644 --- a/docs/generated/rxmc.observation.Observation.rst +++ b/docs/generated/rxmc.observation.Observation.rst @@ -14,9 +14,9 @@ .. autosummary:: ~Observation.__init__ - ~Observation.covariance ~Observation.num_pts_within_interval - ~Observation.residual + ~Observation.statistical_term + ~Observation.systematic_terms diff --git a/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst b/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst new file mode 100644 index 0000000..687fdb1 --- /dev/null +++ b/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst @@ -0,0 +1,23 @@ +rxmc.physical\_model.PerObservationScaledModel +============================================== + +.. currentmodule:: rxmc.physical_model + +.. autoclass:: PerObservationScaledModel + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~PerObservationScaledModel.__init__ + ~PerObservationScaledModel.evaluate + + + + + + \ No newline at end of file diff --git a/docs/generated/rxmc.physical_model.ScaledModel.rst b/docs/generated/rxmc.physical_model.ScaledModel.rst new file mode 100644 index 0000000..d08afd3 --- /dev/null +++ b/docs/generated/rxmc.physical_model.ScaledModel.rst @@ -0,0 +1,23 @@ +rxmc.physical\_model.ScaledModel +================================ + +.. currentmodule:: rxmc.physical_model + +.. autoclass:: ScaledModel + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + ~ScaledModel.__init__ + ~ScaledModel.evaluate + + + + + + \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.gp_posterior_predictive.rst b/docs/generated/rxmc.predictive.gp_posterior_predictive.rst new file mode 100644 index 0000000..ec996fc --- /dev/null +++ b/docs/generated/rxmc.predictive.gp_posterior_predictive.rst @@ -0,0 +1,6 @@ +rxmc.predictive.gp\_posterior\_predictive +========================================= + +.. currentmodule:: rxmc.predictive + +.. autofunction:: gp_posterior_predictive \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.predictive_band.rst b/docs/generated/rxmc.predictive.predictive_band.rst new file mode 100644 index 0000000..024c18e --- /dev/null +++ b/docs/generated/rxmc.predictive.predictive_band.rst @@ -0,0 +1,6 @@ +rxmc.predictive.predictive\_band +================================ + +.. currentmodule:: rxmc.predictive + +.. autofunction:: predictive_band \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.total_predictive_band.rst b/docs/generated/rxmc.predictive.total_predictive_band.rst new file mode 100644 index 0000000..d5624f8 --- /dev/null +++ b/docs/generated/rxmc.predictive.total_predictive_band.rst @@ -0,0 +1,6 @@ +rxmc.predictive.total\_predictive\_band +======================================= + +.. currentmodule:: rxmc.predictive + +.. autofunction:: total_predictive_band \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst index e675159..72385d2 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -2,7 +2,7 @@ rxmc ==== ``rxmc`` is an orchestration layer for Bayesian calibration of reaction models -to large data sets with flexible likelihood modeling. +to large data sets with flexible, composable covariance modeling. It is built around two complementary workflows: @@ -12,15 +12,17 @@ It is built around two complementary workflows: for smaller problems where you want to run the full MCMC workflow locally. The package composes curated experimental data (:class:`~rxmc.observation.Observation`), -model predictions (:class:`~rxmc.physical_model.PhysicalModel`), statistical assumptions -(:class:`~rxmc.likelihood_model.LikelihoodModel`), independent data-model pairings -(:class:`~rxmc.constraint.Constraint`), and full calibration problems -(:class:`~rxmc.evidence.Evidence`). +model predictions (:class:`~rxmc.physical_model.PhysicalModel`), uncertainty +declared as additive covariance :class:`~rxmc.covariance.Term` s (statistical, +systematic, unknown-noise, and Gaussian-process discrepancy modes), maximal +blocks of mutually-correlated data (:class:`~rxmc.constraint.Constraint`), and +full calibration problems (:class:`~rxmc.evidence.Evidence`). .. toctree:: :maxdepth: 1 :caption: Contents installation + design api examples diff --git a/docs/installation.rst b/docs/installation.rst index 28c1b7c..54b6fa0 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -18,15 +18,6 @@ Development / local use It is strongly recommended to use an isolated environment. -``conda`` / ``mamba`` ---------------------- - -.. code-block:: bash - - conda env create -f environment.yml - conda activate rxmc - pip install -ve . --no-deps - ``venv`` -------- diff --git a/environment.yml b/environment.yml deleted file mode 100644 index 8240778..0000000 --- a/environment.yml +++ /dev/null @@ -1,18 +0,0 @@ -name: rxmc -channels: - - conda-forge -dependencies: - - git=2.34.1 - - ipython - - jupyter - - matplotlib - - mpi4py - - openssh - - openssl - - pip - - pipreqs - - python - - setuptools - - pip: - - build==1.2.2.post1 - - pipreq==0.4 From 3b93979792e254566dfe9bba46efc985eb521387 Mon Sep 17 00:00:00 2001 From: beykyle Date: Mon, 10 Aug 2026 23:59:06 -0400 Subject: [PATCH 04/24] Fix EXFOR-database download race in the parallel notebooks job x4i3 downloads its database at import time when missing from site-packages, and each nbmake notebook runs in its own kernel process: under pytest-xdist, concurrent kernels raced the same download/unpack and failed mid-extraction. Warm the database with a single serial import before the parallel run, and cache the data directory across runs (one key shared by all jobs, keyed on the dependency pins) so tests, docs, and the wheel smoke test stop re-downloading it every run. Co-Authored-By: Claude Fable 5 --- .github/workflows/ci.yml | 57 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 53 insertions(+), 4 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index dfd05c1..1597850 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -61,6 +61,18 @@ jobs: python -m pip install --upgrade pip setuptools wheel python -m pip install -e '.[validation]' + - name: Locate x4i3 database directory + run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" + + - name: Restore EXFOR database cache + uses: actions/cache@v4 + with: + path: ${{ env.X4I3_DATA_DIR }} + key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} + + - name: Warm EXFOR database + run: python -c "import x4i3" + - name: Run unit tests run: python -m pytest test @@ -81,6 +93,21 @@ jobs: python -m pip install --upgrade pip setuptools wheel python -m pip install -e '.[validation]' pytest-xdist + - name: Locate x4i3 database directory + run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" + + - name: Restore EXFOR database cache + uses: actions/cache@v4 + with: + path: ${{ env.X4I3_DATA_DIR }} + key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} + + # single serial download; the concurrent notebook kernels spawned by + # xdist must find the database already in place (x4i3 downloads at + # import time outside pytest, so parallel kernels would race it) + - name: Warm EXFOR database + run: python -c "import x4i3" + - name: Run notebooks with pytest run: python -m pytest -n 4 --nbmake --nbmake-timeout=1200 examples @@ -100,6 +127,18 @@ jobs: python -m pip install --upgrade pip setuptools wheel python -m pip install -e '.[docs]' + - name: Locate x4i3 database directory + run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" + + - name: Restore EXFOR database cache + uses: actions/cache@v4 + with: + path: ${{ env.X4I3_DATA_DIR }} + key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} + + - name: Warm EXFOR database + run: python -c "import x4i3" + - name: Build HTML docs run: | test -L docs/examples || ln -sf ../examples docs/examples @@ -121,7 +160,17 @@ jobs: python -m pip install --upgrade pip build python -m build - - name: Install wheel smoke test - run: | - python -m pip install "$(ls -t dist/*.whl | head -n 1)" - python -c "import rxmc; import rxmc.config; import rxmc.walker" + - name: Install wheel + run: python -m pip install "$(ls -t dist/*.whl | head -n 1)" + + - name: Locate x4i3 database directory + run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" + + - name: Restore EXFOR database cache + uses: actions/cache@v4 + with: + path: ${{ env.X4I3_DATA_DIR }} + key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} + + - name: Wheel smoke test + run: python -c "import rxmc; import rxmc.config; import rxmc.walker" From eda0b1c2bdff04f2e7dd55983ae42c15a74ce577 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:42:17 -0400 Subject: [PATCH 05/24] Port reaction models to the jitr 3.0 array-based workspace API jitr 3.0 changed DifferentialWorkspace.xs and the (p,n) Workspace.xs to take potential arrays evaluated on ws.radial_grid() instead of callables plus argument tuples. Move the potential evaluation into a private _xs helper on each reaction model so evaluate and visualizable_model_prediction share it, accept an optional separate Coulomb interaction (calculate_interaction_from_params may return two or three argument tuples), and fail loudly on an unknown elastic quantity instead of leaving the extractor unset. Require jitr>=3.0 from PyPI, and raise the Python floor to 3.12 (the only version jitr 3.0 is built for), trimming the CI matrix to match. Co-Authored-By: Claude Fable 5 --- .github/workflows/ci.yml | 2 +- pyproject.toml | 4 +- requirements.txt | 2 +- src/rxmc/elastic_diffxs_model.py | 76 ++++++++++++++++++++---------- src/rxmc/ias_pn_model.py | 81 +++++++++++--------------------- 5 files changed, 81 insertions(+), 84 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1597850..3e1b655 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -46,7 +46,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.12"] steps: - uses: actions/checkout@v4 diff --git a/pyproject.toml b/pyproject.toml index 731bee7..254beb5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -10,12 +10,10 @@ authors = [ description = "Uncertainty quantification and calibration of reaction models with Markov-Chain Monte Carlo, with flexible and composable models for the likelihood and corpus of constraints" readme = "README.md" license = "BSD-3-Clause" -requires-python = ">=3.10" +requires-python = ">=3.12" dynamic = ["dependencies", "version"] classifiers = [ "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", - "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", "Intended Audience :: Science/Research", "Topic :: Scientific/Engineering :: Physics", diff --git a/requirements.txt b/requirements.txt index 6bc134a..9987df3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,5 +3,5 @@ numpy>=2.2.6 pandas>=2.2 scipy>=1.15 pint>=0.2 -jitr>=2.6 +jitr>=3.0 exfor-tools>=0.4 diff --git a/src/rxmc/elastic_diffxs_model.py b/src/rxmc/elastic_diffxs_model.py index 397123f..5becc16 100644 --- a/src/rxmc/elastic_diffxs_model.py +++ b/src/rxmc/elastic_diffxs_model.py @@ -23,13 +23,14 @@ class ElasticDifferentialXSModel(PhysicalModel): def __init__( self, quantity: str, - interaction_central: Callable[[float, tuple], complex], - interaction_spin_orbit: Callable[[float, tuple], complex], + interaction_central: Callable[..., np.ndarray], + interaction_spin_orbit: Callable[..., np.ndarray] | None, calculate_interaction_from_params: Callable[ [jitr.xs.elastic.DifferentialWorkspace, tuple], tuple ], params: list = [], model_name: str = None, + interaction_coulomb: Callable[..., np.ndarray] | None = None, ): """ Parameters @@ -37,23 +38,31 @@ def __init__( quantity : str Observable to compute: ``"dXS/dA"``, ``"dXS/dRuth"``, or ``"Ay"``. interaction_central : callable - ``f(r, args) -> complex`` returning the central interaction potential. - interaction_spin_orbit : callable - ``f(r, args) -> complex`` returning the spin-orbit potential. + ``f(r, *args) -> np.ndarray`` returning the central interaction + potential on the radial grid ``r`` (fm), in MeV. + interaction_spin_orbit : callable or None + ``f(r, *args) -> np.ndarray`` returning the spin-orbit potential on + ``r``. ``None`` for a spin-orbit-free model. calculate_interaction_from_params : callable - ``f(workspace, *params) -> (central_args, spin_orbit_args)`` - mapping model parameters to the argument tuples expected by the - interaction callables. + ``f(workspace, *params) -> (central_args, spin_orbit_args)`` or + ``-> (central_args, spin_orbit_args, coulomb_args)`` mapping model + parameters to the argument tuples expected by the interaction + callables. params : list of Parameter, optional Parameters of the model. Defaults to ``[]``. model_name : str, optional Human-readable model name. Defaults to ``"ElasticDifferentialXSModel"``. + interaction_coulomb : callable, optional + ``f(r, *args) -> np.ndarray`` returning the Coulomb potential on + ``r``. When ``None`` the Coulomb interaction inside the channel + radius must be folded into ``interaction_central``. """ self.model_name = model_name or "ElasticDifferentialXSModel" self.quantity = quantity self.interaction_central = interaction_central self.interaction_spin_orbit = interaction_spin_orbit + self.interaction_coulomb = interaction_coulomb self.calculate_interaction_from_params = calculate_interaction_from_params if self.quantity == "dXS/dA": @@ -62,9 +71,40 @@ def __init__( self.extractor = extract_dXS_dRuth elif self.quantity == "Ay": self.extractor = extract_Ay + else: + raise ValueError( + f"Unknown quantity {quantity!r}; expected 'dXS/dA', 'dXS/dRuth' " + "or 'Ay'." + ) super().__init__(params) + def _xs(self, ws, params): + """Evaluate the potentials on ``ws.radial_grid()`` and solve.""" + args = self.calculate_interaction_from_params(ws, *params) + if len(args) == 2: + (central_args, spin_orbit_args), coulomb_args = args, () + elif len(args) == 3: + central_args, spin_orbit_args, coulomb_args = args + else: + raise ValueError( + "calculate_interaction_from_params must return 2 or 3 argument " + f"tuples, got {len(args)}" + ) + r = ws.radial_grid() + central = self.interaction_central(r, *central_args) + spin_orbit = ( + None + if self.interaction_spin_orbit is None + else self.interaction_spin_orbit(r, *spin_orbit_args) + ) + coulomb = ( + None + if self.interaction_coulomb is None + else self.interaction_coulomb(r, *coulomb_args) + ) + return ws.xs(central, spin_orbit, coulomb) + def evaluate( self, observation: ElasticDifferentialXSObservation, @@ -91,15 +131,7 @@ def evaluate( f"model quantity {self.quantity}." ) ws = observation.constraint_workspace - central_params, spin_orbit_params = self.calculate_interaction_from_params( - ws, *params - ) - xs = ws.xs( - self.interaction_central, - self.interaction_spin_orbit, - args_central=central_params, - args_spin_orbit=spin_orbit_params, - ) + xs = self._xs(ws, params) if observation.compound_correction is not None: if observation.quantity not in ["dXS/dA", "dXS/dRuth"]: raise ValueError( @@ -135,15 +167,7 @@ def visualizable_model_prediction( f"model quantity {self.quantity}." ) ws = observation.visualization_workspace - central_params, spin_orbit_params = self.calculate_interaction_from_params( - ws, *params - ) - xs = ws.xs( - self.interaction_central, - self.interaction_spin_orbit, - args_central=central_params, - args_spin_orbit=spin_orbit_params, - ) + xs = self._xs(ws, params) if observation.compound_correction is not None: cn = np.interp( ws.angles, diff --git a/src/rxmc/ias_pn_model.py b/src/rxmc/ias_pn_model.py index 43daeea..7019242 100644 --- a/src/rxmc/ias_pn_model.py +++ b/src/rxmc/ias_pn_model.py @@ -50,15 +50,15 @@ def __init__( Parameters ---------- U_p_coulomb : callable - ``f(r, args) -> complex`` — proton Coulomb potential. + ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton Coulomb potential. U_p_central : callable - ``f(r, args) -> complex`` — proton central potential. + ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton central potential. U_p_spin_orbit : callable - ``f(r, args) -> complex`` — proton spin-orbit potential. + ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton spin-orbit potential. U_n_central : callable - ``f(r, args) -> complex`` — neutron central potential. + ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — neutron central potential. U_n_spin_orbit : callable - ``f(r, args) -> complex`` — neutron spin-orbit potential. + ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — neutron spin-orbit potential. calculate_params : callable ``f(workspace, *params) -> (args_p_coulomb, args_p_central, args_p_spin_orbit, args_n_central, args_n_spin_orbit)`` @@ -79,6 +79,27 @@ def __init__( super().__init__(params) + def _xs(self, ws, params) -> np.ndarray: + """Evaluate the five potentials on ``ws.radial_grid()`` and solve (b/sr).""" + ( + args_p_coulomb, + args_p_central, + args_p_spin_orbit, + args_n_central, + args_n_spin_orbit, + ) = self.calculate_params(ws, *params) + r = ws.radial_grid() + return ( + ws.xs( + self.U_p_coulomb(r, *args_p_coulomb), + self.U_p_central(r, *args_p_central), + self.U_p_spin_orbit(r, *args_p_spin_orbit), + self.U_n_central(r, *args_n_central), + self.U_n_spin_orbit(r, *args_n_spin_orbit), + ) + / 1000 + ) + def evaluate( self, observation: IsobaricAnalogPNObservation, @@ -100,30 +121,7 @@ def evaluate( Predicted (p,n) IAS differential cross section in b/sr on ``observation.constraint_workspace.angles``. """ - ws = observation.constraint_workspace - ( - args_p_coulomb, - args_p_central, - args_p_spin_orbit, - args_n_central, - args_n_spin_orbit, - ) = self.calculate_params(ws, *params) - xs = ( - ws.xs( - self.U_p_coulomb, - self.U_p_central, - self.U_p_spin_orbit, - self.U_n_central, - self.U_n_spin_orbit, - args_p_coulomb=args_p_coulomb, - args_p_central=args_p_central, - args_p_spin_orbit=args_p_spin_orbit, - args_n_central=args_n_central, - args_n_spin_orbit=args_n_spin_orbit, - ) - / 1000 - ) - return xs + return self._xs(observation.constraint_workspace, params) def visualizable_model_prediction( self, @@ -146,27 +144,4 @@ def visualizable_model_prediction( Predicted (p,n) IAS differential cross section in b/sr on ``observation.visualization_workspace.angles``. """ - ws = observation.visualization_workspace - ( - args_p_coulomb, - args_p_central, - args_p_spin_orbit, - args_n_central, - args_n_spin_orbit, - ) = self.calculate_params(ws, *params) - xs = ( - ws.xs( - self.U_p_coulomb, - self.U_p_central, - self.U_p_spin_orbit, - self.U_n_central, - self.U_n_spin_orbit, - args_p_coulomb=args_p_coulomb, - args_p_central=args_p_central, - args_p_spin_orbit=args_p_spin_orbit, - args_n_central=args_n_central, - args_n_spin_orbit=args_n_spin_orbit, - ) - / 1000 - ) - return xs + return self._xs(observation.visualization_workspace, params) From 2621085108c72d516f746e1ee1667420b55c6954 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:43:26 -0400 Subject: [PATCH 06/24] Add rxmc.transforms: one Transform type with derivative and composition Introduce a single low-level transform type shared by the observation (comparison space), model (parametric latent scale) and covariance (term coordinates) layers that follow. A Transform is a numpy-style callable fn(a, *values) with an optional tuple of Parameters, an optional analytic derivative (central finite difference otherwise), an optional inverse, and composition via `|` with parameters concatenated. Plain callables are accepted anywhere a Transform is and wrapped as parameter-free. Ship the parameter-free `identity`, `log` (-inf where the argument is not positive, no warnings) and `exp`, plus the parametric `scale()` and `per_observation_scaling()` latent normalisations that will replace the ScaledModel classes. Co-Authored-By: Claude Fable 5 --- src/rxmc/__init__.py | 1 + src/rxmc/transforms.py | 323 ++++++++++++++++++++++++++++++++++++++++ test/test_transforms.py | 113 ++++++++++++++ 3 files changed, 437 insertions(+) create mode 100644 src/rxmc/transforms.py create mode 100644 test/test_transforms.py diff --git a/src/rxmc/__init__.py b/src/rxmc/__init__.py index 9a76a0e..4f7edc5 100644 --- a/src/rxmc/__init__.py +++ b/src/rxmc/__init__.py @@ -15,6 +15,7 @@ from . import physical_model as physical_model from . import predictive as predictive from . import priors as priors +from . import transforms as transforms from . import walker as walker from .__version__ import __version__ as __version__ diff --git a/src/rxmc/transforms.py b/src/rxmc/transforms.py new file mode 100644 index 0000000..6e430b4 --- /dev/null +++ b/src/rxmc/transforms.py @@ -0,0 +1,323 @@ +""" +Low-level transforms shared across rxmc. + +A :class:`Transform` is a numpy-style callable ``fn(a, *values) -> array`` with an +optional tuple of :class:`~rxmc.params.Parameter` s (``values`` are their sampled +values) and optional analytic ``derivative``/``inverse``. The same type serves +three roles: + +* the comparison-space transform of an :class:`~rxmc.observation.Observation` + (e.g. ``transform=log`` to compare in log space; parameter-free), +* a parametric model-side transform on a + :class:`~rxmc.physical_model.PhysicalModel` (e.g. :func:`scale` for a latent + normalisation, :func:`per_observation_scaling` for one per dataset), +* the coordinate transform of a covariance :class:`~rxmc.covariance.Term` + (e.g. angle to momentum transfer). + +Anything callable is accepted wherever a ``Transform`` is expected and is wrapped +as a parameter-free transform. Transforms compose with ``|``: ``(f | g)(a)`` is +``g(f(a))``, parameters concatenated in that order. +""" + +from __future__ import annotations + +from typing import Callable, Sequence + +import numpy as np + +from .params import Parameter + + +class Transform: + """A numpy-style transform with optional parameters. + + Parameters + ---------- + fn : callable + ``fn(a, *values) -> np.ndarray``; when ``contextual`` is ``True``, + ``fn(context, a, *values)`` where ``context`` is whatever the owner + passes (the :class:`~rxmc.observation.Observation` for model transforms). + params : sequence of Parameter, optional + Parameters whose sampled values are passed as ``*values``. + contextual : bool, optional + Whether ``fn`` takes the owner's context as its first argument. + derivative : callable, optional + ``derivative(a, *values) -> np.ndarray``, :math:`\\partial fn/\\partial a` + elementwise. Used for delta-method error propagation and Jacobians. + inverse : Transform or callable, optional + The inverse transform (parameter-free transforms only). + name : str, optional + Human-readable name. + """ + + def __init__( + self, + fn: Callable, + params: Sequence[Parameter] = (), + *, + contextual: bool = False, + derivative: Callable | None = None, + inverse=None, + name: str | None = None, + ): + if not callable(fn): + raise TypeError("fn must be callable") + self.fn = fn + self.params = tuple(params) + for p in self.params: + if not isinstance(p, Parameter): + raise TypeError(f"params must be Parameter objects, got {p!r}") + self.contextual = bool(contextual) + self.derivative_fn = derivative + self._inverse = inverse + self._inverse_factory = None + self.name = name or getattr(fn, "__name__", "transform") + + @property + def n_params(self) -> int: + return len(self.params) + + @property + def is_identity(self) -> bool: + return self is identity + + @property + def inverse(self) -> "Transform | None": + """The inverse transform, or ``None`` if unknown.""" + if self._inverse is None and self._inverse_factory is not None: + self._inverse = self._inverse_factory() + if self._inverse is None: + return None + return as_transform(self._inverse) + + def __call__(self, a, *values, context=None): + if len(values) != self.n_params: + raise ValueError( + f"transform {self.name!r} expects {self.n_params} value(s), " + f"got {len(values)}" + ) + a = np.asarray(a, dtype=float) + if self.contextual: + return np.asarray(self.fn(context, a, *values), dtype=float) + return np.asarray(self.fn(a, *values), dtype=float) + + def derivative(self, a, *values, context=None): + """Elementwise derivative :math:`\\partial fn/\\partial a` at ``a``. + + Falls back to a central finite difference when no analytic derivative + was supplied. + """ + a = np.asarray(a, dtype=float) + if self.derivative_fn is not None: + if self.contextual: + return np.asarray(self.derivative_fn(context, a, *values), dtype=float) + return np.asarray(self.derivative_fn(a, *values), dtype=float) + h = 1e-6 * np.maximum(np.abs(a), 1.0) + fp = self(a + h, *values, context=context) + fm = self(a - h, *values, context=context) + return (fp - fm) / (2 * h) + + def __or__(self, other) -> "Transform": + """``(f | g)(a) = g(f(a))`` with parameters ``f.params + g.params``.""" + f, g = self, as_transform(other) + nf = f.n_params + contextual = f.contextual or g.contextual + + def fn(*args): + if contextual: + context, a, *values = args + else: + context, (a, *values) = None, args + b = f(a, *values[:nf], context=context) + return g(b, *values[nf:], context=context) + + def derivative(*args): + if contextual: + context, a, *values = args + else: + context, (a, *values) = None, args + b = f(a, *values[:nf], context=context) + return g.derivative(b, *values[nf:], context=context) * f.derivative( + a, *values[:nf], context=context + ) + + out = Transform( + fn, + f.params + g.params, + contextual=contextual, + derivative=derivative, + name=f"{f.name}|{g.name}", + ) + if not (f.params or g.params): + # lazy: composing eagerly would recurse for mutually inverse pairs + def _inverse(): + if f.inverse is None or g.inverse is None: + return None + return g.inverse | f.inverse + + out._inverse_factory = _inverse + return out + + def __repr__(self): + names = ", ".join(p.name for p in self.params) + return f"Transform({self.name}{', params=(' + names + ')' if names else ''})" + + +def as_transform(t) -> Transform: + """Coerce ``None`` (identity), a callable, or a :class:`Transform`.""" + if t is None: + return identity + if isinstance(t, Transform): + return t + if callable(t): + return Transform(t) + raise TypeError(f"expected a Transform or callable, got {type(t).__name__}") + + +# ---------------------------------------------------------------------------- +# Parameter-free transforms +# ---------------------------------------------------------------------------- + + +def _identity(a): + return a + + +def _safe_log(a): + out = np.full(np.shape(a), -np.inf, dtype=float) + pos = a > 0 + out[pos] = np.log(a[pos]) + return out + + +def _reciprocal(a): + with np.errstate(divide="ignore"): + return 1.0 / a + + +identity = Transform(_identity, derivative=np.ones_like, name="identity") +identity._inverse = identity + +exp = Transform(np.exp, derivative=np.exp, name="exp") +log = Transform(_safe_log, derivative=_reciprocal, inverse=exp, name="log") +"""Natural log; ``-inf`` (no warnings) where the argument is not positive.""" +exp._inverse = log + + +# ---------------------------------------------------------------------------- +# Parametric transforms +# ---------------------------------------------------------------------------- + + +def scale(parameter: Parameter | None = None, log: bool = True, name=None) -> Transform: + r"""A latent multiplicative normalisation :math:`\rho\, y`. + + The Kennedy & O'Hagan forward-model scale: it changes the *mean*, not the + covariance, so it belongs on the model + (``PhysicalModel(params, transform=scale())``). + + Parameters + ---------- + parameter : Parameter, optional + The scale parameter. Defaults to ``log_rho`` (or ``rho`` when + ``log=False``). + log : bool, optional + If ``True`` (default) the sampled value is :math:`\log\rho` and the + prediction is scaled by ``exp(value)``; otherwise by ``value``. + name : str, optional + Name for the default parameter. + """ + if parameter is None: + name = name or ("log_rho" if log else "rho") + parameter = Parameter( + name, + float, + unit="dimensionless", + latex_name=r"\log{\rho}" if log else r"\rho", + ) + if log: + return Transform( + lambda a, v: np.exp(v) * a, + (parameter,), + derivative=lambda a, v: np.full_like(a, np.exp(v)), + name="scale", + ) + return Transform( + lambda a, v: v * a, + (parameter,), + derivative=lambda a, v: np.full_like(a, v), + name="scale", + ) + + +def _root(observation): + """The identity key of an observation (its root; itself for other objects).""" + return getattr(observation, "identity", observation) + + +def per_observation_scaling( + observations, parameters=None, log: bool = True, prefix: str | None = None +) -> Transform: + r"""One latent normalisation :math:`\rho_i` per dataset, routed by identity. + + Contextual: when the owning model is evaluated on observation :math:`i` + (matched by identity of ``obs.identity``, so masked views made with + :meth:`~rxmc.observation.Observation.masked` route to their root's scale), + the prediction is scaled by :math:`\rho_i`. Parameters are ordered as + ``observations``. + + Parameters + ---------- + observations : sequence of Observation + The datasets, each assigned one scale parameter. + parameters : sequence of Parameter, optional + One per observation. Defaults to ``{prefix}_{i}``. + log : bool, optional + Sample :math:`\log\rho_i` (default) or :math:`\rho_i`. + prefix : str, optional + Default-parameter name prefix; ``log_rho``/``rho`` by ``log``. + """ + observations = list(observations) + index = {id(_root(o)): i for i, o in enumerate(observations)} + if len(index) != len(observations): + raise ValueError("observations must be distinct objects (routing by identity)") + if prefix is None: + prefix = "log_rho" if log else "rho" + if parameters is None: + parameters = [ + Parameter( + f"{prefix}_{i}", + float, + unit="dimensionless", + latex_name=(rf"\log{{\rho_{{{i}}}}}" if log else rf"\rho_{{{i}}}"), + ) + for i in range(len(observations)) + ] + parameters = tuple(parameters) + if len(parameters) != len(observations): + raise ValueError("need exactly one parameter per observation") + + def _value(context, values): + i = index.get(id(_root(context))) + if i is None: + raise KeyError( + "observation was not registered with this per_observation_scaling" + ) + v = values[i] + return np.exp(v) if log else v + + def fn(context, a, *values): + return _value(context, values) * a + + def derivative(context, a, *values): + return np.full_like(a, _value(context, values)) + + t = Transform( + fn, + parameters, + contextual=True, + derivative=derivative, + name="per_observation_scaling", + ) + t.observations = observations # keep ids alive + return t diff --git a/test/test_transforms.py b/test/test_transforms.py new file mode 100644 index 0000000..e643cdd --- /dev/null +++ b/test/test_transforms.py @@ -0,0 +1,113 @@ +"""Tests for the low-level ``rxmc.transforms`` type.""" + +import unittest + +import numpy as np + +from rxmc.observation import Observation +from rxmc.params import Parameter +from rxmc.transforms import ( + Transform, + as_transform, + exp, + identity, + log, + per_observation_scaling, + scale, +) + + +class TestTransform(unittest.TestCase): + def test_callable_is_wrapped_parameter_free(self): + t = as_transform(np.sqrt) + self.assertIsInstance(t, Transform) + self.assertEqual(t.params, ()) + np.testing.assert_allclose(t([4.0, 9.0]), [2.0, 3.0]) + self.assertIs(as_transform(None), identity) + self.assertIs(as_transform(t), t) + + def test_log_is_safe_and_invertible(self): + y = np.array([1.0, 0.0, -2.0, np.e]) + out = log(y) + self.assertEqual(out[0], 0.0) + self.assertEqual(out[1], -np.inf) + self.assertEqual(out[2], -np.inf) + self.assertAlmostEqual(out[3], 1.0) + np.testing.assert_allclose(log.derivative(np.array([2.0, 4.0])), [0.5, 0.25]) + self.assertIs(log.inverse, exp) + self.assertIs(exp.inverse, log) + np.testing.assert_allclose(exp(log(np.array([3.0, 7.0]))), [3.0, 7.0]) + + def test_finite_difference_derivative_fallback(self): + t = Transform(lambda a: a**3) + np.testing.assert_allclose( + t.derivative(np.array([1.0, 2.0])), [3.0, 12.0], rtol=1e-5 + ) + + def test_compose_order_and_params(self): + p = Parameter("c") + shift = Transform( + lambda a, c: a + c, (p,), derivative=lambda a, c: np.ones_like(a) + ) + t = shift | log # log(a + c) + self.assertEqual(t.params, (p,)) + np.testing.assert_allclose(t(np.array([1.0]), 1.0), [np.log(2.0)]) + np.testing.assert_allclose(t.derivative(np.array([1.0]), 1.0), [0.5]) + self.assertIsNone(t.inverse) # parametric -> no inverse + u = log | exp + np.testing.assert_allclose(u(np.array([2.0])), [2.0]) + self.assertIsNotNone(u.inverse) + + def test_wrong_value_count_raises(self): + with self.assertRaises(ValueError): + scale()(np.ones(2)) + + +class TestScale(unittest.TestCase): + def test_log_scale(self): + t = scale() + self.assertEqual(t.params[0].name, "log_rho") + np.testing.assert_allclose(t(np.array([1.0, 2.0]), np.log(3.0)), [3.0, 6.0]) + np.testing.assert_allclose( + t.derivative(np.array([1.0, 2.0]), np.log(3.0)), [3.0, 3.0] + ) + + def test_linear_scale_names(self): + t = scale(log=False) + self.assertEqual(t.params[0].name, "rho") + np.testing.assert_allclose(t(np.array([1.0, 2.0]), 3.0), [3.0, 6.0]) + t2 = scale(Parameter("eta"), log=False) + self.assertEqual(t2.params[0].name, "eta") + + +class TestPerObservationScaling(unittest.TestCase): + def setUp(self): + self.o1 = Observation(np.array([1.0]), np.array([1.0])) + self.o2 = Observation(np.array([1.0]), np.array([1.0])) + + def test_routes_by_identity(self): + t = per_observation_scaling([self.o1, self.o2]) + self.assertEqual([p.name for p in t.params], ["log_rho_0", "log_rho_1"]) + a = np.array([1.0, 2.0]) + np.testing.assert_allclose( + t(a, np.log(2.0), np.log(5.0), context=self.o2), [5.0, 10.0] + ) + np.testing.assert_allclose( + t(a, np.log(2.0), np.log(5.0), context=self.o1), [2.0, 4.0] + ) + with self.assertRaises(KeyError): + t(a, 0.0, 0.0, context=Observation(np.array([1.0]), np.array([1.0]))) + + def test_linear_and_custom_parameters(self): + t = per_observation_scaling([self.o1], log=False) + self.assertEqual(t.params[0].name, "rho_0") + t2 = per_observation_scaling([self.o1], parameters=[Parameter("n")]) + self.assertEqual(t2.params[0].name, "n") + with self.assertRaises(ValueError): + per_observation_scaling([self.o1, self.o2], parameters=[Parameter("n")]) + with self.assertRaises(ValueError): + per_observation_scaling([self.o1, self.o1]) + + +if __name__ == "__main__": + unittest.main() From 0025ccde61195f8c94b660ac21041564c9cea724 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:45:09 -0400 Subject: [PATCH 07/24] Deduplicate measurement kwargs in the reaction observations Both reaction observations' from_measurement classmethods copied the same eight fields out of an exfor_tools Distribution and re-listed every constructor option by hand, so each new constructor keyword had to be threaded through twice. Collect the Distribution fields in one measurement_kwargs helper and forward the remaining keywords with **kwargs, so from_measurement accepts everything the constructor does (solver settings, compound_correction, and the observation-level options added in the following commits). Tests get a make_measurement stub factory in place of four hand-built SimpleNamespaces. Co-Authored-By: Claude Fable 5 --- src/rxmc/elastic_diffxs_observation.py | 32 ++++++++------------ src/rxmc/ias_pn_observation.py | 31 ++++++++----------- src/rxmc/observation_from_measurement.py | 20 +++++++++++++ test/test_reaction_observation.py | 38 +++++++++++++----------- 4 files changed, 65 insertions(+), 56 deletions(-) diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index 1d51f86..08dee71 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -14,7 +14,11 @@ from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import check_angle_grid, normalized_error_kwargs +from .observation_from_measurement import ( + check_angle_grid, + measurement_kwargs, + normalized_error_kwargs, +) # Create a unit registry ureg = UnitRegistry() @@ -164,29 +168,19 @@ def from_measurement( measurement: Distribution, reaction: jitr.reactions.Reaction, quantity: str, - lmax: int = DEFAULT_LMAX, - wavelengths_beyond_range=2.0, - zeros_per_node=5, - angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - compound_correction: np.ndarray = None, + **kwargs, ): + """Construct from an ``exfor_tools`` ``Distribution``. + + ``**kwargs`` (solver settings, ``compound_correction``, ``transform``, + ``mask``, ...) are forwarded to the constructor. + """ return cls( - x=measurement.x, - y=measurement.y, - Elab=measurement.Einc, reaction=reaction, quantity=quantity, measurement_quantity=measurement.quantity, - y_units=measurement.y_units, - y_stat_err=measurement.statistical_err, - y_sys_err_normalization=measurement.systematic_norm_err, - y_sys_err_offset=measurement.systematic_offset_err, - dataset_label=getattr(measurement, "subentry", None), - lmax=lmax, - wavelengths_beyond_range=wavelengths_beyond_range, - zeros_per_node=zeros_per_node, - angles_vis=angles_vis, - compound_correction=compound_correction, + **measurement_kwargs(measurement), + **kwargs, ) def calculate_normalization( diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py index b37e8df..12db563 100644 --- a/src/rxmc/ias_pn_observation.py +++ b/src/rxmc/ias_pn_observation.py @@ -4,7 +4,11 @@ from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import check_angle_grid, normalized_error_kwargs +from .observation_from_measurement import ( + check_angle_grid, + measurement_kwargs, + normalized_error_kwargs, +) # Create a unit registry ureg = UnitRegistry() @@ -142,26 +146,15 @@ def from_measurement( measurement: Distribution, reaction: jitr.reactions.Reaction, ExIAS: float, - lmax: int = DEFAULT_LMAX, - angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - wavelengths_beyond_range: float = 2.0, - zeros_per_node: int = 5, + **kwargs, ): + """Construct from an ``exfor_tools`` ``Distribution``. + + ``**kwargs`` (solver settings, ``transform``, ``mask``, ...) are + forwarded to the constructor. + """ return cls( - x=measurement.x, - y=measurement.y, - Elab=measurement.Einc, - reaction=reaction, - ExIAS=ExIAS, - y_units=measurement.y_units, - y_stat_err=measurement.statistical_err, - y_sys_err_normalization=measurement.systematic_norm_err, - y_sys_err_offset=measurement.systematic_offset_err, - dataset_label=getattr(measurement, "subentry", None), - lmax=lmax, - angles_vis=angles_vis, - wavelengths_beyond_range=wavelengths_beyond_range, - zeros_per_node=zeros_per_node, + reaction=reaction, ExIAS=ExIAS, **measurement_kwargs(measurement), **kwargs ) diff --git a/src/rxmc/observation_from_measurement.py b/src/rxmc/observation_from_measurement.py index cb97a11..5ac83d4 100644 --- a/src/rxmc/observation_from_measurement.py +++ b/src/rxmc/observation_from_measurement.py @@ -35,6 +35,26 @@ def normalized_error_kwargs( } +def measurement_kwargs(measurement) -> dict: + """The ``Observation``-side constructor keywords carried by an + ``exfor_tools`` :class:`~exfor_tools.distribution.Distribution`. + + Shared by the reaction observations' ``from_measurement`` classmethods; the + reaction-specific arguments (``reaction``, ``quantity``/``ExIAS``, solver + settings, ``transform``, ``mask``) are passed alongside. + """ + return { + "x": measurement.x, + "y": measurement.y, + "Elab": measurement.Einc, + "y_units": measurement.y_units, + "y_stat_err": measurement.statistical_err, + "y_sys_err_normalization": measurement.systematic_norm_err, + "y_sys_err_offset": measurement.systematic_offset_err, + "dataset_label": getattr(measurement, "subentry", None), + } + + def check_angle_grid(angles_rad: np.ndarray, name: str): if len(angles_rad.shape) > 1: raise ValueError(f"{name} must be 1D, is {len(angles_rad.shape)}D") diff --git a/test/test_reaction_observation.py b/test/test_reaction_observation.py index 5c90e6e..10ddb00 100644 --- a/test/test_reaction_observation.py +++ b/test/test_reaction_observation.py @@ -9,6 +9,23 @@ from rxmc.observation import Observation +def make_measurement(**overrides): + """A minimal ``exfor_tools``-like Distribution stub.""" + fields = dict( + x=np.array([20.0, 40.0]), + y=np.array([2.0, 1.0]), + Einc=8.0, + quantity="dXS/dA", + y_units="barn / steradian", + statistical_err=np.array([0.2, 0.1]), + systematic_norm_err=0.03, + systematic_offset_err=0.02, + subentry="subentry", + ) + fields.update(overrides) + return SimpleNamespace(**fields) + + class DummyElasticWorkspace: def __init__(self, rutherford=1.0): self.rutherford = rutherford @@ -56,17 +73,7 @@ def test_from_measurement_construction(self, mock_set_up_solver): object(), ) - measurement = SimpleNamespace( - x=np.array([20.0, 40.0]), - y=np.array([2.0, 1.0]), - Einc=8.0, - quantity="dXS/dA", - y_units="barn / steradian", - statistical_err=np.array([0.2, 0.1]), - systematic_norm_err=0.03, - systematic_offset_err=0.02, - subentry="elastic-subentry", - ) + measurement = make_measurement(subentry="elastic-subentry") obs = ElasticDifferentialXSObservation.from_measurement( measurement=measurement, @@ -97,14 +104,10 @@ def test_from_measurement_rutherford_array_norm(self, mock_set_up_solver): object(), ) - measurement = SimpleNamespace( - x=np.array([20.0, 40.0]), + measurement = make_measurement( y=np.array([1800.0, 300.0]), - Einc=8.0, - quantity="dXS/dA", y_units="mb/sr", statistical_err=np.array([20.0, 10.0]), - systematic_norm_err=np.array(0.03), # 0-d, as exfor_tools stores it systematic_offset_err=5.0, # mb/sr subentry="ruth-subentry", ) @@ -247,11 +250,10 @@ def test_direct_construction_from_explicit_data(self, mock_set_up_solver): def test_from_measurement_construction(self, mock_set_up_solver): mock_set_up_solver.return_value = (object(), object(), object(), object()) - measurement = SimpleNamespace( + measurement = make_measurement( x=np.array([5.0, 15.0]), y=np.array([0.9, 0.7]), Einc=18.0, - y_units="barn / steradian", statistical_err=np.array([0.08, 0.07]), systematic_norm_err=0.02, systematic_offset_err=0.01, From 74ec43b059de7a037c9cdbd6df646610045b2e6a Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:49:11 -0400 Subject: [PATCH 08/24] Collapse covariance terms into one generic Term Replace the DenseTerm / DiagonalTerm / RankOneTerm / KernelTerm class hierarchy with a single Term: a numpy-style callable fn(c, *values) of a TermContext (the term's local view of the stacked x, y and ym on its support) plus a `kind` saying how the result enters the covariance ("diag" adds v**2 to the diagonal, "mode" adds the outer product v v^T, "matrix" adds a symmetric block). A plain array instead of fn is a fixed contribution; `constant=True` lets an x-dependent callable be evaluated once and cached, and the Constraint's eager singular-covariance check now passes a real StackContext so such terms can read x. Terms default to support=None, meaning "the whole constraint", and are bound when added to a ConstraintCovariance, so the factory helpers take support as a trailing keyword instead of a leading positional. An optional `coords` transform (rxmc.transforms) is applied to x before fn sees it, so a kernel can live in momentum transfer without knowing. The factory helpers become one-liners over Term: statistical_term, offset_term, normalization_term, noise_term (now with an optional parametric basis), noise_fraction_term, model_error_term, the new systematic_term (a mode with a user basis) and kernel_term (replacing KernelTerm and discrepancy_term, with an optional parametric amplitude so that Sigma += a a^T o K). Bases are ordinary callables of the TermContext: ones, ym, averaging, x_basis(scale), exp_growth(scale), constant_amplitude and exp_growth_amplitude(scale). Port Observation.statistical_term / systematic_terms, the predictive docstrings, the unit tests and five example notebooks to the new signatures. Co-Authored-By: Claude Fable 5 --- examples/correlated_observations.ipynb | 22 +- examples/gp_discrepancy.ipynb | 22 +- examples/measurement_to_calibration.ipynb | 9 +- examples/sampling_algos.ipynb | 5 +- examples/systematic_err_demo.ipynb | 48 +- src/rxmc/constraint.py | 19 +- src/rxmc/covariance.py | 732 +++++++++++------ src/rxmc/elastic_diffxs_observation.py | 5 +- src/rxmc/evidence.py | 2 +- src/rxmc/observation.py | 28 +- src/rxmc/predictive.py | 8 +- test/test_config.py | 2 +- test/test_constraint.py | 105 ++- test/test_covariance.py | 957 +++++++++++++--------- test/test_evidence.py | 8 +- test/test_likelihood_model.py | 18 +- test/test_observation.py | 14 +- test/test_regression.py | 6 +- test/test_sampler.py | 26 +- 19 files changed, 1282 insertions(+), 754 deletions(-) diff --git a/examples/correlated_observations.ipynb b/examples/correlated_observations.ipynb index 5aecd33..193b69e 100644 --- a/examples/correlated_observations.ipynb +++ b/examples/correlated_observations.ipynb @@ -187,14 +187,14 @@ "constraint_corr = rxmc.constraint.Constraint(\n", " [obs1, obs2],\n", " model,\n", - " extra_terms=[rxmc.covariance.normalization_term(full, magnitude=sigma_c)],\n", + " extra_terms=[rxmc.covariance.normalization_term(magnitude=sigma_c, support=full)],\n", ")\n", "constraint_indep = rxmc.constraint.Constraint(\n", " [obs1, obs2],\n", " model,\n", " extra_terms=[\n", - " rxmc.covariance.normalization_term(s1, magnitude=sigma_c),\n", - " rxmc.covariance.normalization_term(s2, magnitude=sigma_c),\n", + " rxmc.covariance.normalization_term(magnitude=sigma_c, support=s1),\n", + " rxmc.covariance.normalization_term(magnitude=sigma_c, support=s2),\n", " ],\n", ")\n", "\n", @@ -373,14 +373,14 @@ "case_A = rxmc.constraint.Constraint(\n", " [obs1, obs2],\n", " model,\n", - " extra_terms=[rxmc.covariance.normalization_term(full, parameter=eta)],\n", + " extra_terms=[rxmc.covariance.normalization_term(parameter=eta, support=full)],\n", ")\n", "case_B = rxmc.constraint.Constraint(\n", " [obs1, obs2],\n", " model,\n", " extra_terms=[\n", - " rxmc.covariance.normalization_term(s1, parameter=eta),\n", - " rxmc.covariance.normalization_term(s2, parameter=eta),\n", + " rxmc.covariance.normalization_term(parameter=eta, support=s1),\n", + " rxmc.covariance.normalization_term(parameter=eta, support=s2),\n", " ],\n", ")\n", "\n", @@ -407,7 +407,7 @@ "\n", "- **Correlated observations are just a covariance `Term` whose `support` spans\n", " blocks.** No special machinery — a cross-block `normalization_term` (or any\n", - " `RankOneTerm`/`KernelTerm`) writes the off-diagonal $\\Sigma$ blocks.\n", + " a mode or kernel `Term`) writes the off-diagonal $\\Sigma$ blocks.\n", "- Treating shared-systematic datasets **independently is overconfident**: the\n", " common mode cannot average down.\n", "- **A couples the data** (cross-block, off-diagonal $\\Sigma$); **B couples the\n", @@ -615,14 +615,16 @@ "xs_coupled = rxmc.constraint.Constraint(\n", " [obs_fwd, obs_bwd],\n", " omp,\n", - " extra_terms=[rxmc.covariance.normalization_term(s_all, magnitude=sigma_flux)],\n", + " extra_terms=[\n", + " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_all)\n", + " ],\n", ")\n", "xs_indep = rxmc.constraint.Constraint(\n", " [obs_fwd, obs_bwd],\n", " omp,\n", " extra_terms=[\n", - " rxmc.covariance.normalization_term(s_fwd, magnitude=sigma_flux),\n", - " rxmc.covariance.normalization_term(s_bwd, magnitude=sigma_flux),\n", + " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_fwd),\n", + " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_bwd),\n", " ],\n", ")\n", "print(\"coupled block-diagonal?\", xs_coupled.covariance.block_diagonal)\n", diff --git a/examples/gp_discrepancy.ipynb b/examples/gp_discrepancy.ipynb index 2846daa..38406b5 100644 --- a/examples/gp_discrepancy.ipynb +++ b/examples/gp_discrepancy.ipynb @@ -10,13 +10,13 @@ "A linear model is fit to data drawn from a *mildly non-linear* truth. The model\n", "is structurally wrong, so a plain fit leaves **correlated** residuals. We absorb\n", "that structure with a Gaussian-process (GP) **discrepancy** term added to the\n", - "constraint covariance — a `rxmc.covariance.KernelTerm` built from a scikit-learn\n", + "constraint covariance — a `rxmc.covariance.kernel_term` built from a scikit-learn\n", "kernel — and then **propagate the total uncertainty** (model parameters + GP\n", "discrepancy + observation noise) to a fine prediction grid using\n", "`rxmc.predictive.total_predictive_band`.\n", "\n", "This is the Kennedy & O'Hagan picture: the discrepancy is a latent correlated\n", - "function, marginalised over its GP prior. The `KernelTerm` only inflates the\n", + "function, marginalised over its GP prior. The kernel term only inflates the\n", "covariance **at the data points**; predicting the discrepancy at *new* points is\n", "the GP posterior-predictive provided by `rxmc.predictive.gp_posterior_predictive`." ] @@ -151,8 +151,8 @@ "source": [ "## Building the constraint with a GP discrepancy term\n", "\n", - "`rxmc.covariance.discrepancy_term(support, kernel)` wraps a scikit-learn kernel as\n", - "a `KernelTerm`. It **auto-derives one `Parameter` per free kernel hyperparameter**\n", + "`rxmc.covariance.kernel_term(kernel)` wraps a scikit-learn kernel as\n", + "a kernel `Term`. It **auto-derives one `Parameter` per free kernel hyperparameter**\n", "(sampled in sklearn's log-theta space). The constraint then carries those\n", "hyperparameters as its covariance parameters (`constraint.params`), so it is\n", "auto-detected as a parametric constraint." @@ -184,12 +184,11 @@ ], "source": [ "kernel = ConstantKernel(1.0) * Matern(length_scale=2.0, nu=2.5) + WhiteKernel(1e-6)\n", - "(support,) = rxmc.covariance.stacked_supports([observation])\n", "\n", "constraint_gp = rxmc.constraint.Constraint(\n", " [observation],\n", " model,\n", - " extra_terms=[rxmc.covariance.discrepancy_term(support, kernel)],\n", + " extra_terms=[rxmc.covariance.kernel_term(kernel)],\n", ")\n", "evidence_gp = rxmc.evidence.Evidence([constraint_gp])\n", "\n", @@ -232,7 +231,7 @@ "constraint_me = rxmc.constraint.Constraint(\n", " [observation],\n", " model,\n", - " extra_terms=[rxmc.covariance.model_error_term(support, gamma, averaging=True)],\n", + " extra_terms=[rxmc.covariance.model_error_term(gamma, averaging=True)],\n", ")\n", "evidence_me = rxmc.evidence.Evidence([constraint_me])" ] @@ -540,9 +539,9 @@ "## Takeaways\n", "\n", "- A GP discrepancy is **just another covariance `Term`** — `discrepancy_term`\n", - " (a `KernelTerm`) added to the constraint. Its hyperparameters become\n", + " (a `kernel_term`) added to the constraint. Its hyperparameters become\n", " constraint parameters and are sampled like any other nuisance.\n", - "- The `KernelTerm` only inflates the covariance at the data points. To predict the\n", + "- The kernel term only inflates the covariance at the data points. To predict the\n", " discrepancy at new $x$, use `rxmc.predictive.gp_posterior_predictive`; to get a\n", " full data-space band that propagates model, discrepancy, and noise uncertainty,\n", " use `rxmc.predictive.total_predictive_band`.\n", @@ -719,13 +718,12 @@ ], "source": [ "kernel_xs = ConstantKernel(1.0) * Matern(length_scale=0.5, nu=2.5) + WhiteKernel(1e-6)\n", - "(support_xs,) = rxmc.covariance.stacked_supports([obs_xs])\n", "\n", "c_vol_plain = rxmc.constraint.Constraint([obs_xs], omp_vol)\n", "c_vol_gp = rxmc.constraint.Constraint(\n", " [obs_xs],\n", " omp_vol,\n", - " extra_terms=[rxmc.covariance.discrepancy_term(support_xs, kernel_xs)],\n", + " extra_terms=[rxmc.covariance.kernel_term(kernel_xs)],\n", ")\n", "print(\"GP hyperparameters:\", [p.name for p in c_vol_gp.params])" ] @@ -934,7 +932,7 @@ "source": [ "## Takeaways, continued\n", "\n", - "- **Same API, real physics**: `discrepancy_term(support, kernel)` on a\n", + "- **Same API, real physics**: `kernel_term(kernel)` on a\n", " differential cross section works exactly as in the toy — the kernel just\n", " acts on the angle grid (radians), so its length scale is angular.\n", "- Without the discrepancy term the deficient potential's parameters must\n", diff --git a/examples/measurement_to_calibration.ipynb b/examples/measurement_to_calibration.ipynb index ffb80dd..81a3dde 100644 --- a/examples/measurement_to_calibration.ipynb +++ b/examples/measurement_to_calibration.ipynb @@ -277,7 +277,7 @@ "\n", "By design there is **no compatibility path that re-folds systematics into the\n", "covariance automatically**: the default constraint covariance is the statistical\n", - "diagonal only. `obs.systematic_terms(support)` turns the retained metadata into\n", + "diagonal only. `obs.systematic_terms()` turns the retained metadata into\n", "fixed rank-one terms — the absolute offset mode\n", "$\\Sigma \\mathrel{+}= \\omega\\omega^T$ and the prediction-scaled normalization mode\n", "$\\Sigma \\mathrel{+}= \\eta^2\\, y_m y_m^T$ — which you pass in as `extra_terms`.\n" @@ -315,8 +315,7 @@ } ], "source": [ - "(support,) = rxmc.covariance.stacked_supports([obs])\n", - "terms = obs.systematic_terms(support)\n", + "terms = obs.systematic_terms()\n", "print([type(t).__name__ for t in terms])\n", "\n", "constraint_stat = rxmc.constraint.Constraint([obs], omp)\n", @@ -366,7 +365,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Constraint covariance over [toy-subentry-nostat] is singular (Cholesky factorization failed). The covariance diagonal is zero on rows belonging to ['toy-subentry-nostat']: these datasets report zero statistical error and no other covariance term covers their points. Remedies: pass the dataset's reported systematics as terms (extra_terms=[*obs.systematic_terms(support)], with supports from rxmc.covariance.stacked_supports(observations)), add a noise_term or DenseTerm covering those points, or compose the full covariance explicitly with include_statistical_term=False.\n" + "Constraint covariance over [toy-subentry-nostat] is singular (Cholesky factorization failed). The covariance diagonal is zero on rows belonging to ['toy-subentry-nostat']: these datasets report zero statistical error and no other covariance term covers their points. Remedies: pass the dataset's reported systematics as terms (extra_terms=[*obs.systematic_terms()]; for a multi-observation constraint place them with support= from rxmc.covariance.stacked_supports(observations)), add a noise_term or a fixed Term covering those points, or compose the full covariance explicitly with include_statistical_term=False.\n" ] } ], @@ -586,7 +585,7 @@ " fractional normalization error through untouched. `obs.norm` is retained, so\n", " you can always convert back.\n", "- **Systematics are opt-in**: they ride along as metadata and become covariance\n", - " terms only via `obs.systematic_terms(support)` passed to\n", + " terms only via `obs.systematic_terms()` passed to\n", " `Constraint(extra_terms=...)` — nothing correlated is hidden in a default.\n", "- **The guardrail**: a dataset contributing zero variance fails at construction\n", " with a message naming the subentry, not with an opaque `LinAlgError` mid-chain.\n", diff --git a/examples/sampling_algos.ipynb b/examples/sampling_algos.ipynb index d47e2a5..1ba8e58 100644 --- a/examples/sampling_algos.ipynb +++ b/examples/sampling_algos.ipynb @@ -259,7 +259,8 @@ " my_model,\n", " extra_terms=[\n", " rxmc.covariance.noise_fraction_term(\n", - " np.arange(observation.n_data_pts), log_noise\n", + " log_noise,\n", + " support=np.arange(observation.n_data_pts),\n", " )\n", " ],\n", ")\n", @@ -887,4 +888,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/examples/systematic_err_demo.ipynb b/examples/systematic_err_demo.ipynb index 811b5ac..7c09426 100644 --- a/examples/systematic_err_demo.ipynb +++ b/examples/systematic_err_demo.ipynb @@ -693,8 +693,6 @@ }, "outputs": [], "source": [ - "(support,) = rxmc.covariance.stacked_supports([obs_stat_only])\n", - "\n", "# 1\n", "evidence_stat_only = rxmc.evidence.Evidence(\n", " [rxmc.constraint.Constraint([obs_stat_only], my_model, likelihood)]\n", @@ -706,9 +704,7 @@ " rxmc.constraint.Constraint(\n", " [obs_unknown_stat],\n", " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(support, log_noise_fraction)\n", - " ],\n", + " extra_terms=[rxmc.covariance.noise_fraction_term(log_noise_fraction)],\n", " )\n", " ]\n", ")\n", @@ -721,7 +717,7 @@ " my_model,\n", " extra_terms=[\n", " rxmc.covariance.normalization_term(\n", - " support, magnitude=systematic_fractional_err\n", + " magnitude=systematic_fractional_err,\n", " )\n", " ],\n", " )\n", @@ -734,7 +730,7 @@ " rxmc.constraint.Constraint(\n", " [obs_sys_norm_wrong],\n", " my_model,\n", - " extra_terms=[rxmc.covariance.DenseTerm(support, wrong_cov)],\n", + " extra_terms=[rxmc.covariance.Term(wrong_cov)],\n", " )\n", " ]\n", ")" @@ -1760,7 +1756,7 @@ " rxmc.constraint.Constraint(\n", " [obs_unknown_stat],\n", " my_model,\n", - " extra_terms=[rxmc.covariance.noise_term(support, log_noise)],\n", + " extra_terms=[rxmc.covariance.noise_term(log_noise)],\n", " )\n", " ]\n", ")\n", @@ -2748,7 +2744,7 @@ "\\begin{equation}\n", "\\Sigma_{ij} = \\delta_{ij}\\,\\sigma_{stat,i}^2 + \\omega^2 ,\n", "\\end{equation}\n", - "via `offset_term(support, magnitude=...)`. With `parameter=` instead of\n", + "via `offset_term(magnitude=...)`. With `parameter=` instead of\n", "`magnitude=`, the magnitude becomes a free nuisance ($\\omega = e^{\\theta}$),\n", "exactly parallel to options 2 and 2b. As with the normalization bias above, we\n", "shift the data by one standard deviation of the reported offset error, and\n", @@ -2793,9 +2789,7 @@ " rxmc.constraint.Constraint(\n", " [obs_offset],\n", " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.offset_term(support, magnitude=offset_syst_err)\n", - " ],\n", + " extra_terms=[rxmc.covariance.offset_term(magnitude=offset_syst_err)],\n", " )\n", " ]\n", ")\n", @@ -2808,7 +2802,7 @@ "free_offset = rxmc.constraint.Constraint(\n", " [rxmc.observation.Observation(x=x, y=y_exp_off, y_stat_err=y_stat_err_off)],\n", " my_model,\n", - " extra_terms=[rxmc.covariance.offset_term(support, parameter=log_omega)],\n", + " extra_terms=[rxmc.covariance.offset_term(parameter=log_omega)],\n", ")\n", "print(f\"free-offset constraint has {free_offset.n_params} nuisance parameter(s)\")" ] @@ -3808,8 +3802,8 @@ " [obs_unknown_stat, obs_unknown_stat2],\n", " my_model,\n", " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(s1, log_noise_fraction),\n", - " rxmc.covariance.noise_fraction_term(s2, log_noise_fraction),\n", + " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s1),\n", + " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s2),\n", " ],\n", " )\n", " ]\n", @@ -3823,10 +3817,12 @@ " my_model,\n", " extra_terms=[\n", " rxmc.covariance.normalization_term(\n", - " s1, magnitude=systematic_fractional_err\n", + " magnitude=systematic_fractional_err,\n", + " support=s1,\n", " ),\n", " rxmc.covariance.normalization_term(\n", - " s2, magnitude=systematic_fractional_err2\n", + " magnitude=systematic_fractional_err2,\n", + " support=s2,\n", " ),\n", " ],\n", " )\n", @@ -3840,8 +3836,8 @@ " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", " my_model,\n", " extra_terms=[\n", - " rxmc.covariance.DenseTerm(s1, wrong_cov),\n", - " rxmc.covariance.DenseTerm(s2, wrong_cov2),\n", + " rxmc.covariance.Term(wrong_cov, support=s1),\n", + " rxmc.covariance.Term(wrong_cov2, support=s2),\n", " ],\n", " )\n", " ]\n", @@ -5167,8 +5163,8 @@ " [obs_unknown_stat, obs_unknown_stat2],\n", " my_model,\n", " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(s1, log_noise_fraction),\n", - " rxmc.covariance.noise_fraction_term(s2, log_noise_fraction),\n", + " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s1),\n", + " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s2),\n", " ],\n", " )\n", " ]\n", @@ -5182,10 +5178,12 @@ " my_model,\n", " extra_terms=[\n", " rxmc.covariance.normalization_term(\n", - " s1, magnitude=systematic_fractional_err\n", + " magnitude=systematic_fractional_err,\n", + " support=s1,\n", " ),\n", " rxmc.covariance.normalization_term(\n", - " s2, magnitude=systematic_fractional_err2\n", + " magnitude=systematic_fractional_err2,\n", + " support=s2,\n", " ),\n", " ],\n", " )\n", @@ -5199,8 +5197,8 @@ " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", " my_model,\n", " extra_terms=[\n", - " rxmc.covariance.DenseTerm(s1, wrong_cov),\n", - " rxmc.covariance.DenseTerm(s2, wrong_cov2),\n", + " rxmc.covariance.Term(wrong_cov, support=s1),\n", + " rxmc.covariance.Term(wrong_cov2, support=s2),\n", " ],\n", " )\n", " ]\n", diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index dde8a3d..aed4b9e 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -131,13 +131,19 @@ def _validate_constant_covariance(self): Catching it here names the offending dataset instead of surfacing an opaque ``LinAlgError`` deep inside a sampler. """ + ctx = StackContext.constant(self._x_stacked, self._y_stacked, self._supports) + cov = self.covariance try: - self.covariance.cholesky(None) + # warm whichever factorisation the likelihood path will use + if cov.uses_block_path: + cov.block_cholesky(ctx) + else: + cov.cholesky(ctx) except np.linalg.LinAlgError as err: labels = [ o.label or f"observation {i}" for i, o in enumerate(self.observations) ] - Sigma = self.covariance.matrix(None) + Sigma = self.covariance.matrix(ctx) zero_rows = np.flatnonzero(np.diag(Sigma) == 0.0) offenders = [ label @@ -156,10 +162,11 @@ def _validate_constant_covariance(self): ) msg += ( " Remedies: pass the dataset's reported systematics as terms " - "(extra_terms=[*obs.systematic_terms(support)], with supports " - "from rxmc.covariance.stacked_supports(observations)), add a " - "noise_term or DenseTerm covering those points, or compose the " - "full covariance explicitly with include_statistical_term=False." + "(extra_terms=[*obs.systematic_terms()]; for a multi-observation " + "constraint place them with support= from " + "rxmc.covariance.stacked_supports(observations)), add a " + "noise_term or a fixed Term covering those points, or compose " + "the full covariance explicitly with include_statistical_term=False." ) raise ValueError(msg) from err diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index 08ca08b..086b612 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -5,9 +5,9 @@ of all its observations, ``y = [y1; y2; ...]``. The covariance of that MVN is built additively from :class:`Term` objects, each of which writes its contribution into a sub-block of the stacked covariance matrix selected by an -index array ``support``. +index array ``support`` (``None`` = the whole constraint). -Two mechanisms are expressed here (see ``covariance_refactor.md``): +Two mechanisms are expressed here (see ``docs/design.md``): * **Correlating observations (A)** — a term whose ``support`` spans more than one observation block writes off-diagonal blocks, coupling the data. A @@ -18,21 +18,24 @@ them (gather, not slice): two terms referencing the *same* ``Parameter`` object share one entry in the sampled vector. -Term primitives ---------------- -:class:`DenseTerm` - A fixed sub-block (statistical diagonal, fixed offset, fixed full covariance). -:class:`DiagonalTerm` - ``diag((c * basis)**2)`` — an uncorrelated (rank-zero) contribution. -:class:`RankOneTerm` - ``outer(v, v)`` with ``v = c * basis`` — one correlated mode. -:class:`KernelTerm` - A Gaussian-process kernel ``K(x, x; theta)`` over ``support``. - -Factory helpers (:func:`statistical_term`, :func:`normalization_term`, +There is exactly **one** term type. A :class:`Term` is a numpy-style callable +``fn(c, *values) -> array`` of a :class:`TermContext` ``c`` (the term's local view +of ``x``, ``y`` and ``ym`` on its support, with ``x`` passed through an optional +coordinate :class:`~rxmc.transforms.Transform`) and its parameter values, plus a +``kind`` that says how the returned array enters the covariance: + +``"diag"`` + ``fn`` returns a standard-deviation vector ``v``; ``Sigma_ii += v_i**2``. +``"mode"`` + ``fn`` returns a vector ``v``; ``Sigma += outer(v, v)`` (one correlated mode). +``"matrix"`` + ``fn`` returns a full block ``M``; ``Sigma_block += M``. + +The factory helpers (:func:`statistical_term`, :func:`normalization_term`, :func:`offset_term`, :func:`noise_term`, :func:`noise_fraction_term`, -:func:`model_error_term`, :func:`discrepancy_term`) map each capability of the old -``LikelihoodModel`` zoo to a single ``Term``. +:func:`model_error_term`, :func:`systematic_term`, :func:`kernel_term`) are +one-line conveniences that build the common terms; anything they cannot express +is a direct ``Term(fn, params, kind=...)``. """ from dataclasses import dataclass @@ -41,29 +44,36 @@ import scipy as sc from .params import Parameter +from .transforms import as_transform __all__ = [ "StackContext", + "TermContext", "Term", - "DenseTerm", - "DiagonalTerm", - "RankOneTerm", - "KernelTerm", "ConstraintCovariance", "stacked_supports", "chol_logdet", - "ym_basis", - "ones_basis", - "averaging_basis", + "as_2d", + "ones", + "ym", + "averaging", + "x_basis", + "exp_growth", + "constant_amplitude", + "exp_growth_amplitude", "statistical_term", "offset_term", "normalization_term", "noise_term", "noise_fraction_term", "model_error_term", + "systematic_term", + "kernel_term", "discrepancy_term", ] +KINDS = ("diag", "mode", "matrix") + @dataclass(frozen=True) class StackContext: @@ -74,25 +84,53 @@ class StackContext: x : np.ndarray Stacked independent variable, ``np.concatenate`` over observations. y : np.ndarray - Stacked observed data. - ym : np.ndarray - Stacked model prediction. + Stacked observed data (in each observation's comparison space). + ym : np.ndarray or None + Stacked model prediction (same space as ``y``). ``None`` when a + *constant* covariance is assembled before any model evaluation (see + :meth:`constant`); constant terms never read it. supports : tuple of np.ndarray One contiguous index array per observation block, in stacking order. """ x: np.ndarray y: np.ndarray - ym: np.ndarray + ym: np.ndarray | None supports: tuple + @classmethod + def constant(cls, x, y, supports) -> "StackContext": + """A stack with no model prediction, for assembling constant terms.""" + return cls(x=x, y=y, ym=None, supports=tuple(supports)) + + +@dataclass(frozen=True) +class TermContext: + """A term's local view of the stack on its own support. + + ``x`` are the coordinates on the support — ``ctx.x[support]`` passed + through the term's ``coords`` transform (so ``x`` may be 2-D); ``y`` and + ``ym`` are the observed data and model prediction on the support (``ym`` is + ``None`` when a constant covariance is assembled without a model + prediction), and ``support`` the stacked indices this view corresponds to. + ``len(c)`` is the number of points. + """ + + x: np.ndarray + y: np.ndarray + ym: np.ndarray | None + support: np.ndarray + + def __len__(self): + return len(self.support) + def stacked_supports(observations) -> tuple: """One contiguous index array per observation, in stacking order. The block layout of the stacked vector ``y = [y1; y2; ...]``: - ``Constraint`` uses this internally, and callers building ``extra_terms`` - use it to place a term on the right rows. + ``Constraint`` uses this internally; callers only need it to place a term on + a *subset* of a constraint's observations (``support=None`` covers all). """ supports, b = [], 0 for obs in observations: @@ -101,26 +139,6 @@ def stacked_supports(observations) -> tuple: return tuple(supports) -# ---------------------------------------------------------------------------- -# Standard basis callables (shared modes / diagonal scalings) -# ---------------------------------------------------------------------------- - - -def ym_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: - """Model prediction on ``support`` — the prediction-scaled basis.""" - return ctx.ym[support] - - -def ones_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: - """Constant unit basis on ``support``.""" - return np.ones(len(support)) - - -def averaging_basis(ctx: StackContext, support: np.ndarray) -> np.ndarray: - """``0.5 * (y + ym)`` on ``support`` — the averaging model-error basis.""" - return 0.5 * (ctx.y[support] + ctx.ym[support]) - - def chol_logdet(Sigma): """Lower Cholesky factor and log-determinant of a positive-definite matrix.""" L = sc.linalg.cholesky(Sigma, lower=True) @@ -134,166 +152,193 @@ def as_2d(X) -> np.ndarray: # ---------------------------------------------------------------------------- -# Term primitives +# The term # ---------------------------------------------------------------------------- class Term: """One additive contribution to the stacked covariance. - Subclasses set ``support`` (indices into the stacked vector) and ``params`` - (the :class:`~rxmc.params.Parameter` objects they consume, by identity) and - implement :meth:`add_to`. - - ``couples_offdiagonal`` declares whether the term can write off-diagonal - entries of its sub-block: terms that write only the diagonal (e.g. - :class:`DiagonalTerm`) can never couple observation blocks, whatever their - support. - - ``is_constant`` declares that the contribution depends on neither ``theta`` - nor ``ctx`` — a covariance whose every term is constant is factored once and - cached by :class:`ConstraintCovariance`. + Parameters + ---------- + fn : callable or array_like + ``fn(c, *values) -> np.ndarray`` with ``c`` a :class:`TermContext` and + ``values`` the sampled values of ``params`` (in order). A plain array is a + fixed contribution (``constant=True`` implied): a standard-deviation + vector for ``kind="diag"``, a mode vector for ``"mode"``, or a symmetric + block for ``"matrix"``. + params : sequence of Parameter, optional + Parameters consumed by ``fn``, matched *by identity* across terms + (pass the same object to two terms to share one sampled value). + kind : {"diag", "mode", "matrix"} + How the returned array enters the covariance (see module docstring). + support : array_like of int, optional + Indices into the stacked vector. ``None`` (default) means the whole + constraint; it is resolved when the term is added to a + :class:`ConstraintCovariance`. + coords : Transform or callable, optional + Coordinate transform applied to ``x[support]`` before ``fn`` sees it + (e.g. angle to momentum transfer). Its parameters, if any, are appended + to :attr:`params`. + constant : bool, optional + Declare that a *callable* ``fn`` does not read ``c.ym`` (the model + prediction) and has no parameters, so the contribution can be evaluated + once and cached. ``c.x`` and ``c.y`` are invariant per constraint and + may be read freely (e.g. a fixed-hyperparameter kernel over ``x``). A + constant term is first evaluated with ``c.ym is None``, so a + mis-declared term fails loudly. Ignored (``True``) for array ``fn``. """ - params: tuple = () - support: np.ndarray - couples_offdiagonal: bool = True - is_constant: bool = False + def __init__( + self, + fn, + params=(), + *, + kind="matrix", + support=None, + coords=None, + constant=False, + ): + if kind not in KINDS: + raise ValueError(f"kind must be one of {KINDS}, got {kind!r}") + self.kind = kind + self.coords = as_transform(coords) + fn_params = tuple(params) + for p in fn_params + self.coords.params: + if not isinstance(p, Parameter): + raise TypeError(f"params must be Parameter objects, got {p!r}") + self._n_fn_params = len(fn_params) + self.params = fn_params + self.coords.params + self.support = None + self._cache = None + self._x_cache = None + + if callable(fn): + self.fn = fn + self._array = None + self.is_constant = bool(constant) and not self.params + else: + self.fn = None + self._array = np.asarray(fn, dtype=float) + if self.params: + raise ValueError("an array-valued term cannot have parameters") + self.is_constant = True + if support is not None: + self._set_support(np.asarray(support, dtype=int)) - def add_to(self, Sigma: np.ndarray, ctx: StackContext, theta: np.ndarray) -> None: - raise NotImplementedError + # -- structure ---------------------------------------------------------- + @property + def couples_offdiagonal(self) -> bool: + """Whether the term can write off-diagonal entries (``kind != "diag"``).""" + return self.kind != "diag" -class DenseTerm(Term): - """A fixed sub-block written into ``Sigma[support, support]``. + @property + def bound(self) -> bool: + return self.support is not None - A 1-D ``matrix`` is treated as a diagonal (variance vector); a 2-D ``matrix`` - is used as-is. - """ + def bind(self, N: int) -> None: + """Resolve ``support=None`` to the whole stack of length ``N``. - is_constant = True + Idempotent; a term constructed with an explicit support is untouched. + """ + if self.support is None: + self._set_support(np.arange(int(N))) + + def _set_support(self, ix: np.ndarray) -> None: + self.support = ix + n = len(ix) + # supports from ``stacked_supports`` (and the whole stack) are + # contiguous: index the block with slices instead of a gather/scatter + if n and np.array_equal(ix, np.arange(ix[0], ix[0] + n)): + sl = slice(int(ix[0]), int(ix[0]) + n) + self._block = (sl, sl) + else: + self._block = np.ix_(ix, ix) + if self._array is not None: + self._validate_bound() - def __init__(self, support, matrix): - self.support = np.asarray(support, dtype=int) - m = np.asarray(matrix, dtype=float) + @property + def _expected_shape(self) -> tuple: n = len(self.support) - if m.shape not in ((n,), (n, n)): + return (n, n) if self.kind == "matrix" else (n,) + + def _validate_bound(self): + a = self._array + if a.shape != self._expected_shape: raise ValueError( - f"DenseTerm matrix shape {m.shape} does not match support " - f"length {n}: expected ({n},) or ({n}, {n})" + f"{self.kind} term expects shape {self._expected_shape}, got {a.shape}" ) - if m.ndim == 2 and not np.allclose(m, m.T): - raise ValueError("DenseTerm 2-D matrix must be symmetric") - self.couples_offdiagonal = m.ndim != 1 - self._m = m - - def add_to(self, Sigma, ctx, theta): - ix = self.support - if self._m.ndim == 1: - Sigma[ix, ix] += self._m - else: - Sigma[np.ix_(ix, ix)] += self._m - - -class _ScaledBasisTerm(Term): - """Shared ``v = c * basis`` machinery for scaled-basis terms. - - ``c = exp(theta)`` when ``log`` else ``theta`` (``c = 1`` when there is no - parameter). ``basis`` is an array, a callable ``basis(ctx, support)``, or - ``None`` (ones). - """ - - def __init__(self, support, basis=None, parameter=None, log=True): - self.support = np.asarray(support, dtype=int) - self.basis = basis - self.log = log - self.params = (parameter,) if parameter is not None else () - # a callable basis reads ctx (e.g. ym); a parameter reads theta - self.is_constant = not self.params and not callable(basis) - - def _vec(self, ctx, theta): - if self.params: - c = np.exp(theta[0]) if self.log else theta[0] - else: - c = 1.0 - if callable(self.basis): - b = self.basis(ctx, self.support) - elif self.basis is not None: - b = np.asarray(self.basis, dtype=float) - else: - b = np.ones(len(self.support)) - return c * b - - -class DiagonalTerm(_ScaledBasisTerm): - """``diag((c * basis)**2)`` on ``support`` — an uncorrelated contribution. + if self.kind == "matrix" and not np.allclose(a, a.T): + raise ValueError("matrix term must be symmetric") - See :class:`_ScaledBasisTerm` for the ``basis``/``parameter``/``log`` - semantics. - """ - - couples_offdiagonal = False - - def add_to(self, Sigma, ctx, theta): - v = self._vec(ctx, theta) - ix = self.support - Sigma[ix, ix] += v**2 + # -- evaluation ----------------------------------------------------------- + def _check_bound(self): + if self.support is None: + raise ValueError( + "term support is unresolved; add it to a Constraint / " + "ConstraintCovariance (which binds support=None to the whole " + "stack) or pass support= explicitly" + ) -class RankOneTerm(_ScaledBasisTerm): - """``outer(v, v)`` with ``v = c * basis`` — one correlated mode. - - A local systematic when ``support`` lies in a single observation block; a - cross-block *coupling* (case A) when ``support`` spans blocks. See - :class:`_ScaledBasisTerm` for the ``basis``/``parameter``/``log`` semantics. - """ - - def add_to(self, Sigma, ctx, theta): - v = self._vec(ctx, theta) + def local_context(self, ctx: StackContext, theta=()) -> TermContext: + """The :class:`TermContext` this term sees at ``theta``.""" + self._check_bound() ix = self.support - Sigma[np.ix_(ix, ix)] += np.outer(v, v) - - -class KernelTerm(Term): - """A Gaussian-process kernel ``K(x, x; theta)`` over ``support``. - - Subsumes the old ``SklearnKernelGPDiscrepancyModel``. Auto-derives one - :class:`~rxmc.params.Parameter` per *free* kernel hyperparameter **element** - (sampled in sklearn's log-theta space): an anisotropic hyperparameter (one - with ``n_elements > 1``, e.g. a vector ``length_scale``) contributes that many - parameters, so ``len(self.params) == len(kernel.theta)``. Local on one block, - or a correlated discrepancy across blocks when ``support`` spans them. - """ - - def __init__(self, support, kernel, jitter=1e-10, prefix="discrepancy"): - self.support = np.asarray(support, dtype=int) - self.kernel = kernel - self.jitter = float(jitter) - params = [] - for hp in kernel.hyperparameters: - if hp.fixed: - continue - if hp.n_elements == 1: - params.append( - Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name) - ) - else: - params.extend( - Parameter( - f"{prefix}_{hp.name}_{i}", - float, - latex_name=f"{hp.name}[{i}]", - ) - for i in range(hp.n_elements) - ) - self.params = tuple(params) + x = self._coords_x(ctx, np.asarray(theta, dtype=float)) + ym = None if ctx.ym is None else ctx.ym[ix] + return TermContext(x=x, y=ctx.y[ix], ym=ym, support=ix) + + def _coords_x(self, ctx, theta): + """``coords(x[support])``; cached when the transform is parameter-free + (``x`` is invariant per constraint).""" + if self.coords.is_identity: + return ctx.x[self.support] + if self.coords.params: + return self.coords(ctx.x[self.support], *theta[self._n_fn_params :]) + if self._x_cache is None: + self._x_cache = self.coords(ctx.x[self.support]) + self._x_cache.setflags(write=False) + return self._x_cache + + def value(self, ctx: StackContext, theta=()) -> np.ndarray: + """The raw array ``fn`` returns (std vector, mode vector, or block).""" + self._check_bound() + if self._array is not None: + return self._array + if self.is_constant and self._cache is not None: + return self._cache + theta = np.asarray(theta, dtype=float) + if len(theta) != len(self.params): + raise ValueError(f"expected {len(self.params)} params, got {len(theta)}") + c = self.local_context(ctx, theta) + v = np.asarray(self.fn(c, *theta[: self._n_fn_params]), dtype=float) + if v.shape != self._expected_shape: + raise ValueError( + f"{self.kind} term fn returned shape {v.shape}, " + f"expected {self._expected_shape}" + ) + if self.is_constant: + v.setflags(write=False) + self._cache = v + return v + + def add_to(self, Sigma: np.ndarray, ctx: StackContext, theta) -> None: + """Add this term's contribution to the stacked ``Sigma`` in place.""" + v = self.value(ctx, theta) + if self.kind == "diag": + ix = self.support + Sigma[ix, ix] += v**2 + elif self.kind == "mode": + Sigma[self._block] += np.outer(v, v) + else: + Sigma[self._block] += v - def add_to(self, Sigma, ctx, theta): - ix = self.support - X = as_2d(np.asarray(ctx.x)[ix]) - K = self.kernel.clone_with_theta(np.asarray(theta, dtype=float))(X) - K[np.diag_indices_from(K)] += self.jitter - Sigma[np.ix_(ix, ix)] += K + def __repr__(self): + names = ", ".join(p.name for p in self.params) + sup = "all" if self.support is None else f"{len(self.support)} pts" + return f"Term(kind={self.kind!r}, params=({names}), support={sup})" # ---------------------------------------------------------------------------- @@ -312,7 +357,8 @@ class ConstraintCovariance: Parameters ---------- terms : sequence of Term - Additive covariance contributions. + Additive covariance contributions. Terms with ``support=None`` are + bound to the whole stack here. N : int Dimension of the stacked vector. blocks : sequence of np.ndarray, optional @@ -330,6 +376,10 @@ class ConstraintCovariance: def __init__(self, terms, N, blocks=None): self.terms = list(terms) self.N = int(N) + for t in self.terms: + if not isinstance(t, Term): + raise TypeError(f"terms must be Term objects, got {type(t).__name__}") + t.bind(self.N) self._blocks = ( None if blocks is None else [np.asarray(b, dtype=int) for b in blocks] ) @@ -370,13 +420,24 @@ def blocks(self): """Observation block index arrays, or ``None`` if unknown.""" return self._blocks + @property + def uses_block_path(self) -> bool: + """Whether :meth:`stacked_distance` factors block by block + (:meth:`block_cholesky`) rather than the whole stack + (:meth:`cholesky`).""" + return ( + self.block_diagonal and self._blocks is not None and len(self._blocks) > 1 + ) + def matrix(self, ctx, *theta) -> np.ndarray: """Assemble the stacked covariance matrix. Parameters ---------- ctx : StackContext - Stacked arrays; may be ``None`` only when :attr:`is_constant`. + Stacked arrays. When :attr:`is_constant`, ``ctx.ym`` is never read + (it may be ``None``, see :meth:`StackContext.constant`) and the + result is cached. *theta : float One value per unique parameter, in :attr:`params` order. """ @@ -398,8 +459,7 @@ def matrix(self, ctx, *theta) -> np.ndarray: def cholesky(self, ctx, *theta): """Lower Cholesky factor and log-determinant of the full stacked covariance. - Cached when :attr:`is_constant` (the old ``FixedCovarianceLikelihood`` fast - path). + Cached when :attr:`is_constant`, so a fixed covariance is factored once. Returns ------- @@ -457,120 +517,314 @@ def stacked_distance(self, ctx, params=()): ``(d2, logdet)``. """ params = tuple(params) - if self.block_diagonal and self._blocks is not None and len(self._blocks) > 1: + r = ctx.y - ctx.ym + if self.uses_block_path: factors = self.block_cholesky(ctx, *params) d2 = 0.0 logdet = 0.0 for ix, (L, ld) in zip(self._blocks, factors): - z = sc.linalg.solve_triangular(L, ctx.y[ix] - ctx.ym[ix], lower=True) + z = sc.linalg.solve_triangular(L, r[ix], lower=True) d2 += float(np.dot(z, z)) logdet += ld return d2, logdet L, logdet = self.cholesky(ctx, *params) - z = sc.linalg.solve_triangular(L, ctx.y - ctx.ym, lower=True) + z = sc.linalg.solve_triangular(L, r, lower=True) return float(np.dot(z, z)), logdet +# ---------------------------------------------------------------------------- +# Standard bases and amplitudes (numpy-style callables over a TermContext) +# ---------------------------------------------------------------------------- + + +def ones(c: TermContext) -> np.ndarray: + """Constant unit basis.""" + return np.ones(len(c)) + + +def ym(c: TermContext) -> np.ndarray: + """The model prediction — the prediction-scaled basis.""" + return c.ym + + +def averaging(c: TermContext) -> np.ndarray: + """``0.5 * (y + ym)`` — the averaging model-error basis.""" + return 0.5 * (c.y + c.ym) + + +_AVERAGING = averaging # factories take an ``averaging`` flag that shadows the name + + +def x_basis(scale: float = 1.0): + """Basis ``x / scale`` (e.g. ``x_basis(np.pi)`` for ``theta/180`` on radians).""" + + def basis(c: TermContext) -> np.ndarray: + return np.asarray(c.x, dtype=float) / scale + + return basis + + +def exp_growth(scale: float = 1.0, base=ones): + """Parametric basis ``base(c) * exp(slope * x / scale)``. + + Takes one basis parameter, ``slope``; use with + ``noise_term(..., basis=exp_growth(np.pi), basis_params=(slope,))``. + """ + + def basis(c: TermContext, slope: float) -> np.ndarray: + return base(c) * np.exp(slope * np.asarray(c.x, dtype=float) / scale) + + return basis + + +def constant_amplitude(c: TermContext, log_amplitude: float) -> np.ndarray: + """Kernel amplitude ``exp(log_amplitude)``, constant over the support.""" + return np.full(len(c), np.exp(log_amplitude)) + + +def exp_growth_amplitude(scale: float = 1.0): + """Kernel amplitude ``exp(log_amplitude) * exp(slope * x / scale)`` (two params).""" + + def amplitude(c: TermContext, log_amplitude: float, slope: float) -> np.ndarray: + return np.exp(log_amplitude) * np.exp( + slope * np.asarray(c.x, dtype=float) / scale + ) + + return amplitude + + # ---------------------------------------------------------------------------- # Term factory helpers (the assembly-time builders) # ---------------------------------------------------------------------------- -def _masked(magnitude, support, mask=None) -> np.ndarray: - """Broadcast a scalar/array magnitude over ``support`` with an optional mask. +def _masked(magnitude, mask=None): + """A scalar/array magnitude with an optional mask. Scalar-like values include 0-d ndarrays (e.g. ``np.array(0.05)`` as stored by - ``exfor_tools`` distributions), not just Python scalars. + ``exfor_tools`` distributions), not just Python scalars. An array magnitude + is checked against the support length when the term is evaluated + (``np.broadcast_to`` in the basis). """ - n = len(support) - if np.ndim(magnitude) == 0: - v = np.full(n, float(magnitude), dtype=float) - else: - v = np.asarray(magnitude, dtype=float) - if v.shape != (n,): - raise ValueError( - f"magnitude shape {v.shape} does not match support length {n}" - ) + v = float(magnitude) if np.ndim(magnitude) == 0 else np.asarray(magnitude, float) if mask is not None: v = v * np.asarray(mask, dtype=float) return v -def statistical_term(support, stat_err) -> DenseTerm: +def _coefficient(parameter, log): + """Parameter -> multiplicative coefficient ``exp(theta)`` (``log``) or ``theta``.""" + if parameter is None: + return (), (lambda values: 1.0) + if log: + return (parameter,), (lambda values: np.exp(values[0])) + return (parameter,), (lambda values: values[0]) + + +def _scaled_term( + kind, parameter, log, basis, basis_params=(), *, support=None, coords=None +): + """``c * basis(ctx, *basis_values)`` as a term of the given kind.""" + cparams, coef = _coefficient(parameter, log) + basis_params = tuple(basis_params) + nc = len(cparams) + + def fn(c, *values): + b = basis(c, *values[nc:]) if callable(basis) else basis + return coef(values[:nc]) * np.broadcast_to(b, (len(c),)) + + return Term(fn, cparams + basis_params, kind=kind, support=support, coords=coords) + + +def statistical_term(stat_err, support=None) -> Term: """Always-on, genuinely uncorrelated statistical diagonal ``diag(stat_err**2)``.""" - return DenseTerm(support, np.asarray(stat_err, dtype=float) ** 2) + return Term(np.asarray(stat_err, dtype=float), kind="diag", support=support) def offset_term( - support, magnitude=None, parameter=None, mask=None, log=True -) -> RankOneTerm: - """A correlated absolute-offset systematic ``outer(omega, omega)`` on ``support``. + magnitude=None, parameter=None, mask=None, log=True, support=None +) -> Term: + """A correlated absolute-offset systematic ``outer(omega, omega)``. With ``magnitude`` it is a fixed (data-given) rank-one mode; with ``parameter`` it is a free nuisance magnitude (``c = exp(theta)`` when ``log``). """ if magnitude is None and parameter is None: raise ValueError("offset_term requires a magnitude and/or a parameter") - basis = _masked(1.0 if magnitude is None else magnitude, support, mask) - return RankOneTerm(support, basis=basis, parameter=parameter, log=log) + mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) + + def basis(c): + return np.broadcast_to(mag, (len(c),)) + + if parameter is None: + return Term(basis, kind="mode", support=support, constant=True) + return _scaled_term("mode", parameter, log, basis, support=support) def normalization_term( - support, magnitude=None, parameter=None, mask=None, log=True -) -> RankOneTerm: + magnitude=None, parameter=None, mask=None, log=True, support=None +) -> Term: """A correlated normalisation systematic ``outer(eta * ym, eta * ym)``. With ``magnitude`` it is a fixed fractional normalisation uncertainty; with - ``parameter`` the magnitude eta is a free nuisance (``UnknownNormalizationError``, - ``c = exp(theta)`` when ``log``). In both cases the mode scales with the model - prediction ``ym`` on ``support``. + ``parameter`` the magnitude eta is a free nuisance (``c = exp(theta)`` when + ``log``). In both cases the mode scales with the model prediction ``ym``. """ if magnitude is None and parameter is None: raise ValueError("normalization_term requires a magnitude and/or a parameter") - if magnitude is None and mask is None: - basis = ym_basis - else: - scale = _masked(1.0 if magnitude is None else magnitude, support, mask) + mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) - def basis(ctx, support): - return scale * ctx.ym[support] + def basis(c): + return np.broadcast_to(mag, (len(c),)) * c.ym - return RankOneTerm(support, basis=basis, parameter=parameter, log=log) + return _scaled_term("mode", parameter, log, basis, support=support) -def noise_term(support, parameter, log=True) -> DiagonalTerm: - """Unknown constant statistical noise ``diag(epsilon**2)`` (``UnknownNoise``). +def noise_term( + parameter, log=True, basis=None, basis_params=(), support=None, coords=None +) -> Term: + """Unknown statistical noise ``diag((epsilon * basis)**2)``. + + ``basis`` defaults to ones (constant noise); pass any + ``basis(c, *basis_values)`` — e.g. :func:`exp_growth` with + ``basis_params=(slope,)`` for noise growing along ``x``. This term is **additive**: a :class:`~rxmc.constraint.Constraint` already adds each observation's reported statistical diagonal, so the assembled covariance is ``diag(y_stat_err**2 + epsilon**2)``. To make the inferred noise *replace* - the reported statistics (the old ``UnknownNoise`` semantics), build the + the reported statistics, build the ``Observation`` with zero ``y_stat_err`` or pass ``include_statistical_term=False`` to the ``Constraint``. """ - return DiagonalTerm(support, basis=ones_basis, parameter=parameter, log=log) + return _scaled_term( + "diag", + parameter, + log, + ones if basis is None else basis, + basis_params, + support=support, + coords=coords, + ) -def noise_fraction_term(support, parameter, log=True) -> DiagonalTerm: - """Unknown fractional noise ``diag((epsilon * ym)**2)`` (``UnknownNoiseFraction``). +def noise_fraction_term(parameter, log=True, support=None) -> Term: + """Unknown fractional noise ``diag((epsilon * ym)**2)``. **Additive** on top of the reported statistical diagonal (see :func:`noise_term` for how to get replace-semantics instead). """ - return DiagonalTerm(support, basis=ym_basis, parameter=parameter, log=log) + return _scaled_term("diag", parameter, log, ym, support=support) -def model_error_term(support, parameter, averaging=True, log=True) -> DiagonalTerm: - """Unknown uncorrelated model error ``diag((gamma * z)**2)`` (``UnknownModelError``). +def model_error_term(parameter, averaging=True, log=True, support=None) -> Term: + """Unknown uncorrelated model error ``diag((gamma * z)**2)``. ``z = 0.5 * (y + ym)`` when ``averaging`` (stabilises when ``ym`` is near zero), else ``z = ym``. """ - basis = averaging_basis if averaging else ym_basis - return DiagonalTerm(support, basis=basis, parameter=parameter, log=log) + basis = _AVERAGING if averaging else ym + return _scaled_term("diag", parameter, log, basis, support=support) + +def systematic_term( + parameter, basis, log=True, basis_params=(), support=None, coords=None +) -> Term: + """A correlated mode ``outer(s * u, s * u)`` with a user basis ``u = basis(c, ...)``. -def discrepancy_term(support, kernel, jitter=1e-10, prefix="discrepancy") -> KernelTerm: - """A Gaussian-process discrepancy ``K(x, x; theta)`` over ``support``.""" - return KernelTerm(support, kernel, jitter=jitter, prefix=prefix) + :func:`offset_term` and :func:`normalization_term` are its ``ones``/``ym`` + special cases; use e.g. ``basis=x_basis(np.pi)`` for a mode growing with + angle. + """ + return _scaled_term( + "mode", parameter, log, basis, basis_params, support=support, coords=coords + ) + + +def kernel_term( + kernel, + coords=None, + amplitude=None, + amplitude_params=(), + jitter=1e-10, + prefix="discrepancy", + support=None, +) -> Term: + """A Gaussian-process kernel ``a a^T * K(x, x; theta)`` over the support. + + One :class:`~rxmc.params.Parameter` is auto-derived per *free* kernel + hyperparameter **element** (sampled in sklearn's log-theta space): an + anisotropic hyperparameter (``n_elements > 1``) contributes that many + parameters. ``amplitude_params`` follow the kernel parameters. + + Parameters + ---------- + kernel : sklearn-style kernel + Duck-typed on ``hyperparameters``, ``theta``, ``clone_with_theta`` and + ``__call__``. + coords : Transform or callable, optional + Coordinate transform of ``x`` the kernel is evaluated in (e.g. angle to + momentum transfer). Default: ``x`` itself. + amplitude : callable or array, optional + ``amplitude(c, *amplitude_values) -> vector a``; the block becomes + ``outer(a, a) * K``. See :func:`constant_amplitude`, + :func:`exp_growth_amplitude`. + amplitude_params : sequence of Parameter, optional + Parameters consumed by ``amplitude``. + jitter : float, optional + Added to the diagonal after scaling, for numerical stability. + prefix : str, optional + Name prefix of the auto-derived kernel parameters. + support : array_like of int, optional + See :class:`Term`. + """ + kparams = [] + for hp in kernel.hyperparameters: + if hp.fixed: + continue + if hp.n_elements == 1: + kparams.append(Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name)) + else: + kparams.extend( + Parameter( + f"{prefix}_{hp.name}_{i}", float, latex_name=f"{hp.name}[{i}]" + ) + for i in range(hp.n_elements) + ) + nk = len(kparams) + amplitude_params = tuple(amplitude_params) + # with no free kernel hyperparameters and parameter-free coordinates, + # K(x, x) is invariant per constraint: build it once + fixed_K = nk == 0 and not as_transform(coords).params + K_cache = [] + + def fn(c, *values): + if fixed_K: + if not K_cache: + K_cache.append(np.asarray(kernel(as_2d(c.x)), dtype=float)) + K = K_cache[0] + else: + K = kernel.clone_with_theta(np.asarray(values[:nk], dtype=float))( + as_2d(c.x) + ) + if amplitude is not None: + a = amplitude(c, *values[nk:]) if callable(amplitude) else amplitude + a = np.broadcast_to(np.asarray(a, dtype=float), (len(c),)) + K = np.outer(a, a) * K + else: + K = np.array(K, dtype=float) + K[np.diag_indices_from(K)] += jitter + return K + + return Term( + fn, + tuple(kparams) + amplitude_params, + kind="matrix", + support=support, + coords=coords, + constant=nk == 0 and not amplitude_params and not callable(amplitude), + ) + + +discrepancy_term = kernel_term +"""Alias of :func:`kernel_term` (a GP model-discrepancy term).""" diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index 08dee71..a378520 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -33,8 +33,9 @@ class ElasticDifferentialXSObservation(Observation): This is an :class:`~rxmc.observation.Observation` (statistical error only): it inherits ``statistical_term`` and ``num_pts_within_interval``. Any correlated - systematic — the dataset's reported normalisation/offset, or a fixed covariance - (:class:`~rxmc.covariance.DenseTerm`) — is composed explicitly as an + systematic — the dataset's reported normalisation/offset, or a fixed + covariance block (an array-valued :class:`~rxmc.covariance.Term`) — is + composed explicitly as an ``extra_terms`` entry in the :class:`~rxmc.constraint.Constraint`. It is designed to handle elastic differential cross section diff --git a/src/rxmc/evidence.py b/src/rxmc/evidence.py index d315ae9..2940486 100644 --- a/src/rxmc/evidence.py +++ b/src/rxmc/evidence.py @@ -90,7 +90,7 @@ def _validate_constraint_params(self): """Reject cross-constraint parameter sharing and duplicate names. Covariance/likelihood parameters are constraint-scoped (see - ``covariance_refactor.md`` §8): the same ``Parameter`` object in two + ``docs/design.md`` §8): the same ``Parameter`` object in two constraints would silently be sampled as two independent values. Names must also be unique across the whole Evidence — they label sampler columns, priors, and corner-plot axes. diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index 8d98be4..7573773 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -22,7 +22,7 @@ import numpy as np -from .covariance import DenseTerm, normalization_term, offset_term, statistical_term +from .covariance import normalization_term, offset_term, statistical_term def _store_error_spec(value, n, name): @@ -110,33 +110,35 @@ def __init__( y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" ) - def statistical_term(self, support) -> DenseTerm: + def statistical_term(self, support=None): """The always-on, genuinely uncorrelated statistical diagonal. Parameters ---------- - support : np.ndarray - Indices of this observation's block in the stacked vector. + support : np.ndarray, optional + Indices of this observation's block in the stacked vector + (``None`` for a single-observation constraint). Returns ------- - DenseTerm + Term ``diag(y_stat_err**2)`` on ``support``. """ - return statistical_term(support, self.y_stat_err) + return statistical_term(self.y_stat_err, support=support) - def systematic_terms(self, support) -> list: + def systematic_terms(self, support=None) -> list: """This dataset's reported correlated systematics as fixed rank-one terms. Opt-in — **not** added to any covariance automatically. Pass the result - via ``Constraint(extra_terms=[*obs.systematic_terms(support), ...])``. + via ``Constraint(extra_terms=[*obs.systematic_terms(), ...])``. Zero magnitudes are skipped, so an observation without reported systematics yields an empty list. Parameters ---------- - support : np.ndarray - Indices of this observation's block in the stacked vector. + support : np.ndarray, optional + Indices of this observation's block in the stacked vector + (``None`` for a single-observation constraint). Returns ------- @@ -149,12 +151,14 @@ def systematic_terms(self, support) -> list: if self.y_sys_err_offset is not None and np.any( np.asarray(self.y_sys_err_offset) != 0.0 ): - terms.append(offset_term(support, magnitude=self.y_sys_err_offset)) + terms.append(offset_term(magnitude=self.y_sys_err_offset, support=support)) if self.y_sys_err_normalization is not None and np.any( np.asarray(self.y_sys_err_normalization) != 0.0 ): terms.append( - normalization_term(support, magnitude=self.y_sys_err_normalization) + normalization_term( + magnitude=self.y_sys_err_normalization, support=support + ) ) return terms diff --git a/src/rxmc/predictive.py b/src/rxmc/predictive.py index 45087cf..a7fc92d 100644 --- a/src/rxmc/predictive.py +++ b/src/rxmc/predictive.py @@ -1,7 +1,7 @@ """ Predictive-uncertainty helpers. -A :class:`~rxmc.covariance.KernelTerm` (like the GP discrepancy model it replaced) +A :func:`~rxmc.covariance.kernel_term` only inflates the covariance *at the data points* with ``K(X, X)`` — it does not propagate the discrepancy to new ``x``. :func:`gp_posterior_predictive` performs the standard Gaussian-process conditioning needed to predict the discrepancy (mean @@ -9,7 +9,7 @@ sample of ``[model params | kernel log-theta]`` into a data-space predictive band that propagates model-parameter, discrepancy, and observation-noise uncertainty. -The kernel is duck-typed exactly as in :class:`~rxmc.covariance.KernelTerm`: a +The kernel is duck-typed exactly as in :func:`~rxmc.covariance.kernel_term`: a scikit-learn-style object exposing ``clone_with_theta`` and ``__call__``, with ``theta`` in sklearn **log-theta** space. """ @@ -64,7 +64,7 @@ def gp_posterior_predictive( ---------- kernel : sklearn-style kernel Object with ``clone_with_theta`` and ``__call__`` (as for - :class:`~rxmc.covariance.KernelTerm`). + :func:`~rxmc.covariance.kernel_term`). theta : array-like Kernel hyperparameters in sklearn **log-theta** space. X_train, X_pred : array-like @@ -189,7 +189,7 @@ def total_predictive_band( ``mean_fn(x, *model_params) -> y`` on a raw ``x`` array (e.g. a model's ``.y`` plotting helper). kernel : sklearn-style kernel - The discrepancy kernel (as passed to :class:`~rxmc.covariance.KernelTerm`). + The discrepancy kernel (as passed to :func:`~rxmc.covariance.kernel_term`). x_train, y_train, x_pred : array-like Training inputs/outputs and the prediction grid. draws : array-like, shape (n_samples, n_draw_cols) diff --git a/test/test_config.py b/test/test_config.py index d8758cb..e5bf117 100644 --- a/test/test_config.py +++ b/test/test_config.py @@ -26,7 +26,7 @@ def model_error_constraint(observation, model, gamma): return Constraint( observations=[observation], physical_model=model, - extra_terms=[model_error_term(support, gamma, averaging=True)], + extra_terms=[model_error_term(gamma, averaging=True, support=support)], ) diff --git a/test/test_constraint.py b/test/test_constraint.py index 0c6091a..47c3124 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -3,11 +3,19 @@ import unittest import numpy as np +from sklearn.gaussian_process.kernels import RBF from helpers import manual_mvn_loglike from rxmc.constraint import Constraint -from rxmc.covariance import RankOneTerm, normalization_term +from rxmc.covariance import ( + Term, + kernel_term, + noise_term, + normalization_term, + systematic_term, +) from rxmc.evidence import Evidence +from rxmc.likelihood_model import GaussianLikelihood, StudentT from rxmc.observation import Observation from rxmc.params import Parameter from rxmc.physical_model import PerObservationScaledModel, Polynomial @@ -72,7 +80,7 @@ def test_case_A_cross_block_coupling(self): eta = 0.1 p = Parameter("log eta") support = np.arange(5) - coupling = RankOneTerm(support, basis=lambda ctx, s: ctx.ym[s], parameter=p) + coupling = systematic_term(p, basis=lambda c: c.ym, support=support) c = Constraint([self.obs1, self.obs2], self.pm, extra_terms=[coupling]) self.assertFalse(c.covariance.block_diagonal) @@ -93,7 +101,7 @@ def test_case_A_differs_from_independent(self): [self.obs1, self.obs2], self.pm, extra_terms=[ - RankOneTerm(np.arange(5), basis=lambda c, s: c.ym[s], parameter=p) + systematic_term(p, basis=lambda c: c.ym, support=np.arange(5)) ], ) # independent: two per-block normalization modes (no cross coupling) @@ -102,8 +110,8 @@ def test_case_A_differs_from_independent(self): [self.obs1, self.obs2], self.pm, extra_terms=[ - normalization_term(np.arange(2), parameter=p1), - normalization_term(np.arange(2, 5), parameter=p2), + normalization_term(parameter=p1, support=np.arange(2)), + normalization_term(parameter=p2, support=np.arange(2, 5)), ], ) ll_coupled = coupled.log_likelihood(self.model_params, (np.log(eta),)) @@ -178,8 +186,8 @@ def test_shared_eta_one_param(self): [obs1, obs2], pm, extra_terms=[ - normalization_term(np.arange(2), parameter=eta), - normalization_term(np.arange(2, 4), parameter=eta), + normalization_term(parameter=eta, support=np.arange(2)), + normalization_term(parameter=eta, support=np.arange(2, 4)), ], ) # one shared parameter, covariance stays block-diagonal @@ -210,7 +218,7 @@ def test_missing_params_raise(self): c = Constraint( [self.obs], self.pm, - extra_terms=[normalization_term(np.arange(2), parameter=eta)], + extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], ) with self.assertRaises(ValueError) as cm: c.log_likelihood(self.mp) @@ -221,20 +229,18 @@ def test_correct_count_unchanged(self): c = Constraint( [self.obs], self.pm, - extra_terms=[normalization_term(np.arange(2), parameter=eta)], + extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], ) self.assertTrue(np.isfinite(c.log_likelihood(self.mp, (np.log(0.1),)))) def test_studentt_chi2_full_tuple(self): - from rxmc.covariance import noise_term - from rxmc.likelihood_model import GaussianLikelihood, StudentT eps = Parameter("log eps") student = Constraint( [self.obs], self.pm, likelihood=StudentT(), - extra_terms=[noise_term(np.arange(2), eps)], + extra_terms=[noise_term(eps, support=np.arange(2))], ) # covariance-only tuple is a deficit now with self.assertRaises(ValueError): @@ -244,7 +250,7 @@ def test_studentt_chi2_full_tuple(self): [self.obs], self.pm, likelihood=GaussianLikelihood(), - extra_terms=[noise_term(np.arange(2), Parameter("log eps g"))], + extra_terms=[noise_term(Parameter("log eps g"), support=np.arange(2))], ) self.assertAlmostEqual( student.chi2(self.mp, (np.log(0.1), 4.0)), @@ -252,14 +258,13 @@ def test_studentt_chi2_full_tuple(self): ) def test_covariance_matrix_full_tuple_convention(self): - from rxmc.likelihood_model import StudentT eta = Parameter("log eta") c = Constraint( [self.obs], self.pm, likelihood=StudentT(), - extra_terms=[normalization_term(np.arange(2), parameter=eta)], + extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], ) # reviewer repro: forwarding the full sampled tuple used to crash S = c.covariance_matrix(self.mp, (np.log(0.1), 4.0)) @@ -267,7 +272,7 @@ def test_covariance_matrix_full_tuple_convention(self): [self.obs], self.pm, extra_terms=[ - normalization_term(np.arange(2), parameter=Parameter("log eta")) + normalization_term(parameter=Parameter("log eta"), support=np.arange(2)) ], ) np.testing.assert_allclose(S, gauss.covariance_matrix(self.mp, (np.log(0.1),))) @@ -291,8 +296,12 @@ def test_two_distinct_same_name_params_raise(self): [self.obs], self.pm, extra_terms=[ - normalization_term(np.arange(2), parameter=Parameter("log eta")), - normalization_term(np.arange(2), parameter=Parameter("log eta")), + normalization_term( + parameter=Parameter("log eta"), support=np.arange(2) + ), + normalization_term( + parameter=Parameter("log eta"), support=np.arange(2) + ), ], ) self.assertIn("SAME Parameter object", str(cm.exception)) @@ -304,13 +313,12 @@ def test_collision_with_model_param_name_raises(self): [self.obs], self.pm, extra_terms=[ - normalization_term(np.arange(2), parameter=Parameter("a0")) + normalization_term(parameter=Parameter("a0"), support=np.arange(2)) ], ) self.assertIn("physical-model parameter", str(cm.exception)) def test_likelihood_param_collision_raises(self): - from rxmc.likelihood_model import StudentT nu_clone = Parameter("nu") with self.assertRaises(ValueError): @@ -318,7 +326,9 @@ def test_likelihood_param_collision_raises(self): [self.obs], self.pm, likelihood=StudentT(nu_parameter=Parameter("nu")), - extra_terms=[normalization_term(np.arange(2), parameter=nu_clone)], + extra_terms=[ + normalization_term(parameter=nu_clone, support=np.arange(2)) + ], ) @@ -347,13 +357,11 @@ def test_offending_dataset_named_by_label(self): self.assertNotIn("observation 0'", msg) def test_zero_stat_err_with_covering_term_ok(self): - from rxmc.covariance import DenseTerm - obs = Observation(self.x, self.y) c = Constraint( [obs], self.pm, - extra_terms=[DenseTerm(np.arange(2), np.array([0.04, 0.04]))], + extra_terms=[Term(np.array([0.2, 0.2]), kind="diag", support=np.arange(2))], ) self.assertTrue(np.isfinite(c.log_likelihood((0.5, 1.2)))) @@ -366,11 +374,12 @@ def test_zero_stat_err_with_systematic_terms_ok(self): def test_parametric_covariance_not_checked_eagerly(self): # replace-semantics: zero stat err + a free noise term must construct - from rxmc.covariance import noise_term obs = Observation(self.x, self.y) p = Parameter("log eps") - c = Constraint([obs], self.pm, extra_terms=[noise_term(np.arange(2), p)]) + c = Constraint( + [obs], self.pm, extra_terms=[noise_term(p, support=np.arange(2))] + ) self.assertEqual(c.n_params, 1) @@ -398,17 +407,15 @@ def test_stack_shape_guard(self): c.marginal_log_likelihood([np.array([1.0, 2.0])]) # wrong length def test_include_statistical_term_false_omits_diagonal(self): - from rxmc.covariance import DenseTerm - sup = np.arange(self.obs.n_data_pts) cov = np.diag([0.04, 0.04, 0.04]) c = Constraint( [self.obs], self.pm, - extra_terms=[DenseTerm(sup, cov)], + extra_terms=[Term(cov, support=sup)], include_statistical_term=False, ) - # only the supplied DenseTerm survives (no statistical diagonal added) + # only the supplied fixed Term survives (no statistical diagonal added) S = c.covariance_matrix(self.params) np.testing.assert_allclose(S, cov) @@ -443,5 +450,43 @@ def test_linear_scale(self): ) +class TestConstantTermsReadX(unittest.TestCase): + """Constant terms (fixed kernels, x-dependent fixed diagonals) are evaluated + once with the invariant x/y at Constraint construction.""" + + def setUp(self): + self.pm = Polynomial(order=1) + self.mp = (0.1, 1.0) + self.x = np.linspace(0.0, 1.0, 5) + self.err = np.full(5, 0.1) + self.obs = Observation(self.x, self.x + 0.1, y_stat_err=self.err) + + def test_fixed_kernel_term_in_constraint(self): + kernel = RBF(length_scale=0.3, length_scale_bounds="fixed") + c = Constraint( + [self.obs], self.pm, extra_terms=[kernel_term(kernel, jitter=0.0)] + ) + self.assertTrue(c.covariance.is_constant) + self.assertEqual(c.n_params, 0) + ym = self.pm(self.obs, *self.mp) + cov = np.diag(self.err**2) + kernel(self.x[:, None]) + expected = manual_mvn_loglike(self.obs.y, ym, cov) + self.assertAlmostEqual(c.log_likelihood(self.mp), expected) + + def test_x_dependent_constant_term_in_constraint(self): + t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) + c = Constraint([self.obs], self.pm, extra_terms=[t]) + self.assertTrue(c.covariance.is_constant) + ym = self.pm(self.obs, *self.mp) + cov = np.diag(self.err**2 + (0.1 * self.x) ** 2) + self.assertAlmostEqual( + c.log_likelihood(self.mp), manual_mvn_loglike(self.obs.y, ym, cov) + ) + # the eager validation warmed the cache; a fresh copy is returned to callers + S = c.covariance_matrix(self.mp) + self.assertTrue(S.flags.writeable) + np.testing.assert_allclose(S, cov) + + if __name__ == "__main__": unittest.main() diff --git a/test/test_covariance.py b/test/test_covariance.py index 4a0571d..647906b 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -2,22 +2,32 @@ import numpy as np import pytest +from sklearn.gaussian_process.kernels import RBF, ConstantKernel, Matern, WhiteKernel from helpers import make_ctx from rxmc.covariance import ( ConstraintCovariance, - DenseTerm, - DiagonalTerm, - RankOneTerm, + StackContext, + Term, + averaging, + constant_amplitude, + exp_growth, + exp_growth_amplitude, + kernel_term, model_error_term, noise_fraction_term, noise_term, normalization_term, offset_term, + ones, statistical_term, - ym_basis, + systematic_term, + x_basis, + ym, ) +from rxmc.likelihood_model import mahalanobis_distance_sqr_cholesky from rxmc.params import Parameter +from rxmc.transforms import Transform def single_block_ctx(x, y, ym): @@ -25,473 +35,682 @@ def single_block_ctx(x, y, ym): return make_ctx(x, y, ym, [np.arange(n)]) -class TestDenseTerm: - def test_vector_is_diagonal(self): - t = DenseTerm([0, 1, 2], np.array([1.0, 2.0, 3.0])) - S = np.zeros((3, 3)) - t.add_to(S, None, np.array([])) - assert np.allclose(S, np.diag([1.0, 2.0, 3.0])) +def assemble(terms, ctx, theta=()): + cov = ConstraintCovariance(terms, len(ctx.x), blocks=ctx.supports) + return cov.matrix(ctx, *theta) - def test_full_matrix_passthrough(self): - m = np.array([[2.0, 0.5], [0.5, 3.0]]) - t = DenseTerm([0, 1], m) + +# ---------------------------------------------------------------------------- +# Term +# ---------------------------------------------------------------------------- + + +class TestTermKinds: + def test_diag_array_squares_std(self): + t = Term(np.array([1.0, 2.0, 3.0]), kind="diag", support=[0, 1, 2]) + S = np.zeros((3, 3)) + t.add_to(S, None, ()) + assert np.allclose(S, np.diag([1.0, 4.0, 9.0])) + assert t.is_constant + assert not t.couples_offdiagonal + + def test_mode_array_outer(self): + v = np.array([1.0, 2.0]) + t = Term(v, kind="mode", support=[0, 1]) S = np.zeros((2, 2)) - t.add_to(S, None, np.array([])) - assert np.allclose(S, m) + t.add_to(S, None, ()) + assert np.allclose(S, np.outer(v, v)) + assert t.couples_offdiagonal - def test_writes_into_subblock(self): - t = DenseTerm([2, 3], np.array([1.0, 1.0])) + def test_matrix_array_passthrough_into_subblock(self): + m = np.array([[2.0, 0.5], [0.5, 3.0]]) + t = Term(m, support=[2, 3]) S = np.zeros((4, 4)) - t.add_to(S, None, np.array([])) + t.add_to(S, None, ()) expected = np.zeros((4, 4)) - expected[2, 2] = expected[3, 3] = 1.0 + expected[2:, 2:] = m assert np.allclose(S, expected) + def test_bad_kind_raises(self): + with pytest.raises(ValueError, match="kind"): + Term(np.ones(2), kind="rank1", support=[0, 1]) + def test_scalar_broadcast_raises(self): # a (1, 1) matrix on a length-3 support used to broadcast silently - # into the whole block - with pytest.raises(ValueError, match="does not match support"): - DenseTerm(np.arange(3), [[0.04]]) + with pytest.raises(ValueError, match="expects shape"): + Term([[0.04]], support=np.arange(3)) def test_wrong_length_vector_raises(self): - with pytest.raises(ValueError, match="does not match support"): - DenseTerm(np.arange(3), np.ones(2)) + with pytest.raises(ValueError, match="expects shape"): + Term(np.ones(2), kind="diag", support=np.arange(3)) def test_asymmetric_matrix_raises(self): with pytest.raises(ValueError, match="symmetric"): - DenseTerm(np.arange(2), [[1.0, 0.5], [0.0, 1.0]]) + Term(np.array([[1.0, 0.2], [0.0, 1.0]]), support=[0, 1]) - def test_couples_offdiagonal(self): - # only terms that can write off-diagonal entries can couple blocks - assert not DenseTerm([0, 1, 2], np.ones(3)).couples_offdiagonal - assert DenseTerm([0, 1], np.array([[2.0, 0.5], [0.5, 3.0]])).couples_offdiagonal - assert not DiagonalTerm([0, 1]).couples_offdiagonal - assert RankOneTerm([0, 1], basis=np.ones(2)).couples_offdiagonal + def test_array_with_params_raises(self): + with pytest.raises(ValueError, match="array-valued"): + Term(np.ones(2), (Parameter("p"),), kind="diag", support=[0, 1]) + def test_callable_sees_local_context_and_values(self): + seen = {} -class TestDiagonalTerm: - def test_ones_basis_with_param(self): - p = Parameter("log eps") - t = DiagonalTerm([0, 1], basis=None, parameter=p, log=True) - ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) - S = np.zeros((2, 2)) - t.add_to(S, ctx, np.array([np.log(0.5)])) - assert np.allclose(S, np.diag([0.25, 0.25])) + def fn(c, a, b): + seen["c"] = c + return a * c.ym + b * c.y - def test_basis_array_no_param(self): - t = DiagonalTerm([0, 1], basis=np.array([2.0, 3.0])) + pa, pb = Parameter("a"), Parameter("b") + t = Term(fn, (pa, pb), kind="diag", support=[1, 2]) + ctx = single_block_ctx([0.0, 1.0, 2.0], [1.0, 2.0, 3.0], [1.5, 2.5, 3.5]) + S = np.zeros((3, 3)) + t.add_to(S, ctx, (2.0, 1.0)) + c = seen["c"] + assert np.allclose(c.x, [1.0, 2.0]) + assert np.allclose(c.ym, [2.5, 3.5]) + assert len(c) == 2 + v = 2.0 * np.array([2.5, 3.5]) + np.array([2.0, 3.0]) + assert np.allclose(np.diag(S), [0.0, *(v**2)]) + + def test_callable_wrong_shape_raises(self): + t = Term(lambda c: np.ones(len(c) + 1), kind="diag", support=[0, 1]) + ctx = single_block_ctx([0.0, 1.0], [0.0, 0.0], [0.0, 0.0]) + with pytest.raises(ValueError, match="returned shape"): + t.add_to(np.zeros((2, 2)), ctx, ()) + + def test_wrong_param_count_raises(self): + t = Term(lambda c, a: a * ones(c), (Parameter("a"),), kind="diag", support=[0]) + ctx = single_block_ctx([0.0], [0.0], [0.0]) + with pytest.raises(ValueError, match="expected 1 params"): + t.add_to(np.zeros((1, 1)), ctx, ()) + + def test_constant_callable_cached(self): + calls = [] + + def fn(c): + calls.append(1) + return np.ones(len(c)) + + t = Term(fn, kind="diag", support=[0, 1], constant=True) + assert t.is_constant + ctx = single_block_ctx([0.0, 1.0], [0.0, 0.0], [0.0, 0.0]) + t.add_to(np.zeros((2, 2)), ctx, ()) + t.add_to(np.zeros((2, 2)), ctx, ()) + assert len(calls) == 1 + + def test_constant_flag_ignored_with_params(self): + t = Term(lambda c, a: ones(c), (Parameter("a"),), kind="diag", constant=True) + assert not t.is_constant + + +class TestTermCoords: + def test_coords_callable_applied_to_x(self): + t = Term(lambda c: c.x, kind="diag", support=[0, 1], coords=lambda x: 2 * x) + ctx = single_block_ctx([1.0, 3.0], [0.0, 0.0], [0.0, 0.0]) + assert np.allclose(t.local_context(ctx).x, [2.0, 6.0]) + + def test_parametric_coords_params_appended(self): + pk = Parameter("k") + coords = Transform(lambda x, k: k * x, (pk,)) + pa = Parameter("a") + t = Term( + lambda c, a: a * c.x, (pa,), kind="diag", support=[0, 1], coords=coords + ) + assert t.params == (pa, pk) + ctx = single_block_ctx([1.0, 2.0], [0.0, 0.0], [0.0, 0.0]) S = np.zeros((2, 2)) - t.add_to(S, None, np.array([])) - assert np.allclose(S, np.diag([4.0, 9.0])) + t.add_to(S, ctx, (3.0, 2.0)) # a=3, k=2 -> v = 3 * 2 * x + assert np.allclose(np.diag(S), (6.0 * np.array([1.0, 2.0])) ** 2) + + def test_coords_array_2d_reaches_kernel(self): + kernel = RBF(length_scale=1.0) + X = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 0.0]]) + t = kernel_term(kernel, coords=lambda x: X, jitter=0.0, support=np.arange(3)) + ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.zeros(3)) + S = np.zeros((3, 3)) + t.add_to(S, ctx, kernel.theta) + assert np.allclose(S, kernel(X)) - def test_ym_basis_callable(self): + +class TestSupportNone: + def test_bound_by_constraint_covariance(self): p = Parameter("log eps") - t = DiagonalTerm([0, 1], basis=ym_basis, parameter=p) - ym = np.array([2.0, 4.0]) - ctx = single_block_ctx(np.zeros(2), np.zeros(2), ym) - S = np.zeros((2, 2)) - t.add_to(S, ctx, np.array([np.log(0.1)])) - assert np.allclose(S, np.diag((0.1 * ym) ** 2)) + t = noise_term(p) + assert not t.bound + cov = ConstraintCovariance([t], 3) + assert t.bound and np.array_equal(t.support, np.arange(3)) + ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.zeros(3)) + assert np.allclose(cov.matrix(ctx, np.log(2.0)), 4.0 * np.eye(3)) + + def test_unbound_add_to_raises(self): + t = noise_term(Parameter("p")) + with pytest.raises(ValueError, match="unresolved"): + t.add_to(np.zeros((2, 2)), None, (0.0,)) + + def test_bind_idempotent_and_explicit_support_untouched(self): + t = Term(np.ones(2), kind="diag", support=[1, 2]) + t.bind(5) + assert np.array_equal(t.support, [1, 2]) + u = Term(np.ones(3), kind="diag") + u.bind(3) + u.bind(3) + assert np.array_equal(u.support, np.arange(3)) + + def test_array_length_checked_at_bind(self): + t = Term(np.ones(2), kind="diag") + with pytest.raises(ValueError, match="expects shape"): + ConstraintCovariance([t], 3) + + def test_whole_stack_mode_block_diagonality(self): + one = ConstraintCovariance( + [offset_term(parameter=Parameter("w"))], 3, blocks=[np.arange(3)] + ) + assert one.block_diagonal + two = ConstraintCovariance( + [offset_term(parameter=Parameter("w"))], + 4, + blocks=[np.arange(2), np.arange(2, 4)], + ) + assert not two.block_diagonal + diag = ConstraintCovariance( + [noise_term(Parameter("e"))], 4, blocks=[np.arange(2), np.arange(2, 4)] + ) + assert diag.block_diagonal + def test_non_term_raises(self): + with pytest.raises(TypeError): + ConstraintCovariance([np.eye(2)], 2) -class TestRankOneTerm: - def test_outer_product(self): - v = np.array([1.0, 2.0, 3.0]) - t = RankOneTerm([0, 1, 2], basis=v) - S = np.zeros((3, 3)) - t.add_to(S, None, np.array([])) - assert np.allclose(S, np.outer(v, v)) - def test_normalization_mode_scales_with_ym(self): - p = Parameter("log eta") - t = RankOneTerm([0, 1], basis=ym_basis, parameter=p) - ym = np.array([3.0, 5.0]) - ctx = single_block_ctx(np.zeros(2), np.zeros(2), ym) - S = np.zeros((2, 2)) - eta = 0.07 - t.add_to(S, ctx, np.array([np.log(eta)])) - assert np.allclose(S, np.outer(eta * ym, eta * ym)) - - def test_cross_block_coupling_writes_offdiagonal(self): - # support spans two blocks [0,1] and [2,3] - v = np.array([1.0, 1.0, 1.0, 1.0]) - t = RankOneTerm([0, 1, 2, 3], basis=v) - S = np.zeros((4, 4)) - t.add_to(S, None, np.array([])) - # off-diagonal blocks coupling block 0 and block 1 are non-zero - assert S[0, 2] != 0.0 and S[1, 3] != 0.0 +# ---------------------------------------------------------------------------- +# Gather-by-identity and structural properties +# ---------------------------------------------------------------------------- class TestGatherByIdentity: def test_shared_parameter_dedup(self): - # Case B: two block-local terms share ONE Parameter object - eta = Parameter("log eta") - t1 = normalization_term([0, 1], parameter=eta) - t2 = normalization_term([2, 3], parameter=eta) - cov = ConstraintCovariance([t1, t2], N=4) + p = Parameter("log eps") + cov = ConstraintCovariance( + [noise_term(p, support=[0, 1]), noise_term(p, support=[2, 3])], 4 + ) assert cov.n_params == 1 - assert cov.params == (eta,) def test_distinct_parameters_not_shared(self): - e1 = Parameter("log eta 1") - e2 = Parameter("log eta 2") - t1 = normalization_term([0, 1], parameter=e1) - t2 = normalization_term([2, 3], parameter=e2) - cov = ConstraintCovariance([t1, t2], N=4) - assert cov.n_params == 2 - assert cov.params == (e1, e2) - - def test_shared_value_fed_to_both(self): - eta = Parameter("log eta") - t1 = normalization_term([0, 1], parameter=eta) - t2 = normalization_term([2, 3], parameter=eta) - cov = ConstraintCovariance([t1, t2], N=4) - ym = np.array([1.0, 1.0, 2.0, 2.0]) - ctx = make_ctx(np.zeros(4), np.zeros(4), ym, [np.arange(2), np.arange(2, 4)]) - e = 0.1 - S = cov.matrix(ctx, np.log(e)) - # both blocks scaled by the same eta - assert np.allclose(S[:2, :2], np.outer(e * ym[:2], e * ym[:2])) - assert np.allclose(S[2:, 2:], np.outer(e * ym[2:], e * ym[2:])) - # block-local -> no cross coupling - assert np.allclose(S[:2, 2:], 0.0) - - def test_first_seen_order_deterministic(self): - a = Parameter("a") - b = Parameter("b") - t1 = DiagonalTerm([0], parameter=b) - t2 = DiagonalTerm([1], parameter=a) - cov = ConstraintCovariance([t1, t2], N=2) - assert cov.params == (b, a) - - def test_wrong_param_count_raises(self): - p = Parameter("p") - cov = ConstraintCovariance([DiagonalTerm([0], parameter=p)], N=1) - with pytest.raises(ValueError): - cov.matrix(single_block_ctx(np.zeros(1), np.zeros(1), np.zeros(1))) - - -class TestProperties: - def test_block_diagonal_true_for_local_terms(self): cov = ConstraintCovariance( [ - statistical_term([0, 1], np.ones(2)), - statistical_term([2, 3], np.ones(2)), + noise_term(Parameter("a"), support=[0, 1]), + noise_term(Parameter("b"), support=[2, 3]), ], - N=4, - blocks=[np.arange(2), np.arange(2, 4)], + 4, ) - assert cov.block_diagonal + assert cov.n_params == 2 - def test_block_diagonal_false_for_coupling(self): + def test_shared_value_fed_to_both(self): + p = Parameter("log eps") cov = ConstraintCovariance( - [RankOneTerm([0, 1, 2, 3], basis=np.ones(4))], - N=4, - blocks=[np.arange(2), np.arange(2, 4)], + [noise_term(p, support=[0, 1]), noise_term(p, support=[2, 3])], 4 ) - assert not cov.block_diagonal + ctx = single_block_ctx(np.zeros(4), np.zeros(4), np.zeros(4)) + S = cov.matrix(ctx, np.log(3.0)) + assert np.allclose(S, 9.0 * np.eye(4)) - def test_contiguous_cross_block_term_without_blocks_not_block_diagonal(self): - # the old contiguity heuristic classified a coupling term with a - # contiguous support as block-local; without explicit blocks the - # classification must now be conservative (dense path) + def test_first_seen_order_deterministic(self): + a, b = Parameter("a"), Parameter("b") cov = ConstraintCovariance( [ - statistical_term([0, 1], np.ones(2)), - statistical_term([2, 3], np.ones(2)), - RankOneTerm(np.arange(4), basis=np.ones(4)), + noise_term(b, support=[0]), + noise_term(a, support=[1]), + noise_term(b, support=[2]), ], - N=4, - ) - assert not cov.block_diagonal - - def test_diagonal_only_terms_block_diagonal_without_blocks(self): - # strictly-diagonal terms are block-diagonal under ANY partition - cov = ConstraintCovariance( - [statistical_term([0, 1], np.ones(2)), DiagonalTerm([2, 3])], N=4 + 3, ) - assert cov.block_diagonal + assert cov.params == (b, a) - def test_diagonal_term_spanning_blocks_stays_block_diagonal(self): - cov = ConstraintCovariance( - [DiagonalTerm(np.arange(4))], - N=4, - blocks=[np.arange(2), np.arange(2, 4)], - ) - assert cov.block_diagonal + def test_wrong_param_count_raises(self): + cov = ConstraintCovariance([noise_term(Parameter("a"))], 2) + with pytest.raises(ValueError, match="expected 1 params"): + cov.matrix(None) - def test_is_constant(self): - cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) - assert cov.is_constant - p = Parameter("p") - cov2 = ConstraintCovariance([DiagonalTerm([0, 1], parameter=p)], N=2) - assert not cov2.is_constant - def test_constant_matrix_cached(self): +class TestProperties: + def test_is_constant_and_caching(self): cov = ConstraintCovariance( - [statistical_term([0, 1], np.array([2.0, 3.0]))], N=2 + [statistical_term(np.array([1.0, 2.0]))], 2, blocks=[np.arange(2)] ) - m1 = cov.matrix(None) - m2 = cov.matrix(None) - assert m1 is m2 - assert np.allclose(m1, np.diag([4.0, 9.0])) - - def test_cached_matrix_readonly(self): - # the cached matrix is shared state: mutation must fail loudly - cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) - m = cov.matrix(None) - with pytest.raises(ValueError): - m[0, 0] = 99.0 - - def test_cached_cholesky_readonly(self): - cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) + assert cov.is_constant + S1 = cov.matrix(None) + S2 = cov.matrix(None) + assert S1 is S2 + assert not S1.flags.writeable L, _ = cov.cholesky(None) - with pytest.raises(ValueError): - L[0, 0] = 99.0 + assert not L.flags.writeable - def test_block_cholesky_cached_and_readonly(self): + def test_nonconstant_matrix_writable(self): + cov = ConstraintCovariance([noise_term(Parameter("a"))], 2) + ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) + S = cov.matrix(ctx, 0.0) + assert S.flags.writeable + + def test_block_cholesky_cached_and_requires_blocks(self): cov = ConstraintCovariance( - [ - statistical_term([0, 1], np.ones(2)), - statistical_term([2, 3], np.ones(2)), - ], - N=4, - blocks=[np.arange(2), np.arange(2, 4)], + [statistical_term(np.ones(4))], 4, blocks=[np.arange(2), np.arange(2, 4)] ) f1 = cov.block_cholesky(None) f2 = cov.block_cholesky(None) assert f1 is f2 with pytest.raises(ValueError): - f1[0][0][0, 0] = 99.0 - - def test_block_cholesky_requires_blocks(self): - cov = ConstraintCovariance([statistical_term([0, 1], np.ones(2))], N=2) - with pytest.raises(ValueError, match="blocks"): - cov.block_cholesky(None) - - def test_block_cholesky_nonconstant_not_cached(self): - p = Parameter("log eps") - cov = ConstraintCovariance( - [ - statistical_term([0, 1], np.ones(2)), - DiagonalTerm([2, 3], parameter=p), - ], - N=4, - blocks=[np.arange(2), np.arange(2, 4)], - ) - ctx = make_ctx( - np.zeros(4), np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)] - ) - f1 = cov.block_cholesky(ctx, 0.0) - f2 = cov.block_cholesky(ctx, 0.0) - assert f1 is not f2 - for (L1, d1), (L2, d2) in zip(f1, f2): - assert np.allclose(L1, L2) - assert d1 == d2 - - def test_nonconstant_matrix_writable(self): - p = Parameter("p") - cov = ConstraintCovariance([DiagonalTerm([0, 1], parameter=p)], N=2) - ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) - S = cov.matrix(ctx, 0.0) - S[0, 0] = 99.0 # fresh array, caller-owned - - -class TestNoSilentFastPathWithoutBlocks: - """A cross-block coupling built without explicit blocks must take the dense path. + ConstraintCovariance([statistical_term(np.ones(2))], 2).block_cholesky(None) - This pins the fix for the contiguity-heuristic bug: a RankOneTerm whose - support is one contiguous run over two observation blocks used to be - misclassified as block-local, and the fast path silently dropped the - off-diagonal coupling. - """ + def test_cross_block_term_without_blocks_not_block_diagonal(self): + cov = ConstraintCovariance([offset_term(parameter=Parameter("w"))], 4) + assert not cov.block_diagonal + diag = ConstraintCovariance([noise_term(Parameter("e"))], 4) + assert diag.block_diagonal def test_stacked_distance_matches_dense(self): - from rxmc.likelihood_model import mahalanobis_distance_sqr_cholesky - - rng = np.random.default_rng(7) - y = rng.normal(size=4) - ym = y + 0.1 * rng.normal(size=4) - cov = ConstraintCovariance( - [ - statistical_term(np.arange(4), np.full(4, 0.5)), - RankOneTerm(np.arange(4), basis=np.ones(4)), - ], - N=4, - ) - ctx = make_ctx(np.arange(4.0), y, ym, [np.arange(2), np.arange(2, 4)]) - - d2, logdet = cov.stacked_distance(ctx) - Sigma = np.diag(np.full(4, 0.25)) + np.ones((4, 4)) - d2_dense, logdet_dense = mahalanobis_distance_sqr_cholesky(y, ym, Sigma) - assert np.isclose(d2, d2_dense) - assert np.isclose(logdet, logdet_dense) - - -class TestScalarLikeMagnitudes: - """0-d ndarrays (as stored by exfor_tools distributions) count as scalars.""" - - def test_zero_dim_offset_magnitude(self): - support = np.arange(3) - a = offset_term(support, magnitude=np.array(0.2)) - b = offset_term(support, magnitude=0.2) - S1, S2 = np.zeros((3, 3)), np.zeros((3, 3)) - a.add_to(S1, None, np.array([])) - b.add_to(S2, None, np.array([])) - assert np.allclose(S1, S2) - - def test_zero_dim_normalization_magnitude(self): - support = np.arange(3) - ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.array([1.0, 2.0, 3.0])) - a = normalization_term(support, magnitude=np.array(0.05)) - b = normalization_term(support, magnitude=0.05) - S1, S2 = np.zeros((3, 3)), np.zeros((3, 3)) - a.add_to(S1, ctx, np.array([])) - b.add_to(S2, ctx, np.array([])) - assert np.allclose(S1, S2) - - -class TestFactoryHelpersReproduceOldCovariance: - """Each helper reproduces the matrix the old LikelihoodModel zoo built.""" - + x = np.arange(4.0) + y = np.array([1.0, 2.0, 3.0, 4.0]) + ymod = np.array([1.1, 1.9, 3.2, 3.8]) + ctx = make_ctx(x, y, ymod, [np.arange(2), np.arange(2, 4)]) + terms = [statistical_term(0.5 * np.ones(4)), noise_term(Parameter("e"))] + block = ConstraintCovariance(terms, 4, blocks=ctx.supports) + dense = ConstraintCovariance(terms, 4) + assert block.block_diagonal + d_b = block.stacked_distance(ctx, (np.log(0.3),)) + d_d = dense.stacked_distance(ctx, (np.log(0.3),)) + S = block.matrix(ctx, np.log(0.3)) + assert np.allclose(d_b, mahalanobis_distance_sqr_cholesky(y, ymod, S)) + assert np.allclose(d_d, d_b) + + +# ---------------------------------------------------------------------------- +# Factories +# ---------------------------------------------------------------------------- + + +class TestFactories: def setup_method(self): + self.x = np.array([0.5, 1.0, 1.5]) self.y = np.array([1.0, 2.0, 3.0]) self.ym = np.array([1.1, 1.9, 3.2]) self.stat = np.array([0.1, 0.2, 0.3]) - self.support = np.arange(3) - self.ctx = single_block_ctx(np.arange(3.0), self.y, self.ym) + self.ctx = single_block_ctx(self.x, self.y, self.ym) def test_statistical_only(self): - S = ConstraintCovariance( - [statistical_term(self.support, self.stat)], N=3 - ).matrix(self.ctx) + S = assemble([statistical_term(self.stat)], self.ctx) assert np.allclose(S, np.diag(self.stat**2)) def test_unknown_noise(self): - eps = 0.05 - p = Parameter("log eps") - cov = ConstraintCovariance( - [statistical_term(self.support, np.zeros(3)), noise_term(self.support, p)], - N=3, - ) - S = cov.matrix(self.ctx, np.log(eps)) - assert np.allclose(S, np.diag(np.full(3, eps**2))) + S = assemble([noise_term(Parameter("e"))], self.ctx, (np.log(0.4),)) + assert np.allclose(S, 0.16 * np.eye(3)) + S = assemble([noise_term(Parameter("e"), log=False)], self.ctx, (0.4,)) + assert np.allclose(S, 0.16 * np.eye(3)) def test_unknown_noise_fraction(self): - eps = 0.05 - p = Parameter("log eps") - cov = ConstraintCovariance([noise_fraction_term(self.support, p)], N=3) - S = cov.matrix(self.ctx, np.log(eps)) - assert np.allclose(S, np.diag((eps * self.ym) ** 2)) + S = assemble([noise_fraction_term(Parameter("e"))], self.ctx, (np.log(0.4),)) + assert np.allclose(S, np.diag((0.4 * self.ym) ** 2)) def test_unknown_normalization_error(self): - eta = 0.07 - p = Parameter("log eta") - cov = ConstraintCovariance([normalization_term(self.support, parameter=p)], N=3) - S = cov.matrix(self.ctx, np.log(eta)) - assert np.allclose(S, eta**2 * np.outer(self.ym, self.ym)) + S = assemble( + [normalization_term(parameter=Parameter("n"))], self.ctx, (np.log(0.05),) + ) + assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) def test_unknown_model_error_averaging(self): - gamma = 0.1 - p = Parameter("log gamma") - cov = ConstraintCovariance( - [model_error_term(self.support, p, averaging=True)], N=3 + S = assemble( + [model_error_term(Parameter("g"), averaging=True)], self.ctx, (np.log(0.1),) ) - S = cov.matrix(self.ctx, np.log(gamma)) z = 0.5 * (self.y + self.ym) - assert np.allclose(S, np.diag((gamma * z) ** 2)) + assert np.allclose(S, np.diag((0.1 * z) ** 2)) + S = assemble( + [model_error_term(Parameter("g"), averaging=False)], + self.ctx, + (np.log(0.1),), + ) + assert np.allclose(S, np.diag((0.1 * self.ym) ** 2)) def test_fixed_normalization_systematic(self): - # data-given fractional normalisation (no free parameter) - frac = 0.03 - cov = ConstraintCovariance( - [normalization_term(self.support, magnitude=frac)], N=3 - ) - S = cov.matrix(self.ctx) - expected = (frac**2) * np.outer(self.ym, self.ym) - assert np.allclose(S, expected) + S = assemble([normalization_term(magnitude=0.05)], self.ctx) + assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) + S = assemble([normalization_term(magnitude=np.array(0.05))], self.ctx) + assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) def test_fixed_offset_systematic(self): - off = 0.2 - cov = ConstraintCovariance([offset_term(self.support, magnitude=off)], N=3) - S = cov.matrix(self.ctx) - omega = off * np.ones(3) - assert np.allclose(S, np.outer(omega, omega)) + t = offset_term(magnitude=0.2) + assert t.is_constant + S = assemble([t], self.ctx) + assert np.allclose(S, 0.04 * np.ones((3, 3))) + S = assemble([offset_term(magnitude=np.array([0.1, 0.2, 0.3]))], self.ctx) + v = np.array([0.1, 0.2, 0.3]) + assert np.allclose(S, np.outer(v, v)) + + def test_fixed_offset_in_constant_covariance_ignores_ym(self): + # a constant covariance never reads ym: it can be factored (eagerly, at + # Constraint construction) with a placeholder ym and the cached factor + # is reused afterwards + cov = ConstraintCovariance( + [statistical_term(self.stat), offset_term(magnitude=0.2)], 3 + ) + assert cov.is_constant + L, logdet = cov.cholesky( + StackContext.constant(self.ctx.x, self.ctx.y, [np.arange(3)]) + ) + assert np.all(np.isfinite(L)) + L2, logdet2 = cov.cholesky(self.ctx) + assert L2 is L and logdet2 == logdet + + def test_masked_magnitudes(self): + m = np.array([1.0, 0.0, 1.0]) + S = assemble([offset_term(magnitude=0.2, mask=m)], self.ctx) + v = 0.2 * m + assert np.allclose(S, np.outer(v, v)) + S = assemble( + [normalization_term(parameter=Parameter("n"), mask=m)], + self.ctx, + (np.log(0.5),), + ) + v = 0.5 * m * self.ym + assert np.allclose(S, np.outer(v, v)) + def test_magnitude_length_mismatch_raises(self): + with pytest.raises(ValueError): + assemble([offset_term(magnitude=np.ones(2))], self.ctx) -class TestOldObservationCovarianceEquivalence: - """A stat+offset+normalization stack matches the old Observation.covariance(ym).""" + def test_requires_magnitude_or_parameter(self): + with pytest.raises(ValueError): + offset_term() + with pytest.raises(ValueError): + normalization_term() - def test_full_covariance(self): - y = np.array([1.0, 2.0, 4.0]) - ym = np.array([1.2, 2.1, 3.5]) - stat = np.array([0.1, 0.2, 0.3]) - norm = 0.05 - offset = 0.2 - support = np.arange(3) - ctx = make_ctx(np.arange(3.0), y, ym, [support]) + def test_systematic_term_with_basis(self): + s = Parameter("log s") + S = assemble([systematic_term(s, basis=x_basis(2.0))], self.ctx, (np.log(3.0),)) + v = 3.0 * self.x / 2.0 + assert np.allclose(S, np.outer(v, v)) + def test_parametric_basis(self): + e, l = Parameter("log e"), Parameter("slope") + t = noise_term(e, basis=exp_growth(np.pi), basis_params=(l,)) + assert t.params == (e, l) + S = assemble([t], self.ctx, (np.log(0.3), 0.0)) + assert np.allclose(S, 0.09 * np.eye(3)) # slope 0 == plain noise_term + S = assemble([t], self.ctx, (np.log(0.3), 2.0)) + assert np.allclose(S, np.diag((0.3 * np.exp(2.0 * self.x / np.pi)) ** 2)) + # basis growing with ym in linear space + t = noise_term(e, basis=exp_growth(np.pi, base=ym), basis_params=(l,)) + S = assemble([t], self.ctx, (np.log(0.3), 1.0)) + assert np.allclose(S, np.diag((0.3 * self.ym * np.exp(self.x / np.pi)) ** 2)) + + def test_old_observation_covariance_equivalence(self): + offset, norm = 0.2, 0.05 terms = [ - statistical_term(support, stat), - offset_term(support, magnitude=offset), - normalization_term(support, magnitude=norm), + statistical_term(self.stat), + offset_term(magnitude=offset), + normalization_term(magnitude=norm), ] - S = ConstraintCovariance(terms, N=3).matrix(ctx) - - # old Observation.covariance(ym): + S = assemble(terms, self.ctx) old = ( - np.diag(stat**2) + np.diag(self.stat**2) + np.outer(offset * np.ones(3), offset * np.ones(3)) - + np.outer(norm * np.ones(3), norm * np.ones(3)) * np.outer(ym, ym) + + norm**2 * np.outer(self.ym, self.ym) ) assert np.allclose(S, old) + def test_bases(self): + c = Term(lambda c: c.ym, kind="diag", support=np.arange(3)).local_context( + self.ctx + ) + assert np.allclose(ones(c), 1.0) + assert np.allclose(ym(c), self.ym) + assert np.allclose(averaging(c), 0.5 * (self.y + self.ym)) + + +class TestKernelTerm: + def test_params_match_theta_length_isotropic(self): + kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) + term = kernel_term(kernel) + assert len(term.params) == len(kernel.theta) + assert not term.is_constant + + def test_params_anisotropic(self): + kernel = ConstantKernel(1.0) * RBF(length_scale=[1.0, 1.0]) + term = kernel_term(kernel, support=np.arange(3)) + assert len(term.params) == len(kernel.theta) + x2d = np.array([[0.0, 0.0], [1.0, 0.5], [2.0, 1.0]]) + ctx = make_ctx(x2d, np.zeros(3), np.zeros(3), [np.arange(3)]) + Sigma = np.zeros((3, 3)) + term.add_to(Sigma, ctx, kernel.theta) + assert np.all(np.isfinite(Sigma)) + + def test_cross_block_values(self): + kernel = RBF(length_scale=1.0) + term = kernel_term(kernel, jitter=0.0, support=np.arange(4)) + x = np.array([0.0, 1.0, 2.0, 3.0]) + ctx = make_ctx(x, np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)]) + S = np.zeros((4, 4)) + term.add_to(S, ctx, kernel.theta) + np.testing.assert_allclose(S, kernel(x[:, None])) + assert np.any(S[:2, 2:] != 0.0) + cov = ConstraintCovariance([term], N=4, blocks=[np.arange(2), np.arange(2, 4)]) + assert not cov.block_diagonal -def test_kernel_term_params_match_theta_length_isotropic(): - from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel + def test_fixed_kernel_is_constant(self): + kernel = RBF(length_scale=1.0, length_scale_bounds="fixed") + term = kernel_term(kernel) + assert term.params == () and term.is_constant - from rxmc.covariance import KernelTerm + def test_constant_term_may_read_x(self): + # constant means "independent of ym"; x is invariant and readable + x = np.linspace(0.0, 2.0, 4) + t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) + cov = ConstraintCovariance([t], 4) + assert cov.is_constant + ctx = StackContext.constant(x, np.zeros(4), [np.arange(4)]) + np.testing.assert_allclose(cov.matrix(ctx), np.diag((0.1 * x) ** 2)) + # a mis-declared constant term (reads ym) fails loudly, not silently + bad = ConstraintCovariance( + [Term(lambda c: 0.1 * c.ym, kind="diag", constant=True)], 4 + ) + with pytest.raises(TypeError): + bad.matrix(ctx) + assert cov.matrix(single_block_ctx(x, np.zeros(4), np.ones(4))) is cov.matrix( + ctx + ) - kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) - term = KernelTerm(np.arange(4), kernel) - # one free Parameter per non-fixed hyperparameter element - assert len(term.params) == len(kernel.theta) + def test_constant_amplitude_reproduces_constant_kernel(self): + x = np.linspace(0.0, 2.0, 5) + ctx = single_block_ctx(x, np.zeros(5), np.zeros(5)) + A = 0.7 + la = Parameter("log A") + term = kernel_term( + RBF(1.0), amplitude=constant_amplitude, amplitude_params=(la,), jitter=0.0 + ) + assert [p.name for p in term.params] == ["discrepancy_length_scale", "log A"] + S = assemble([term], ctx, (0.0, np.log(A))) + ref = ConstantKernel(A**2, constant_value_bounds="fixed") * RBF(1.0) + np.testing.assert_allclose(S, ref(x[:, None])) + + def test_exp_growth_amplitude_and_coords(self): + x = np.linspace(0.1, 3.0, 4) + ctx = single_block_ctx(x, np.zeros(4), np.zeros(4)) + la, sl = Parameter("log A"), Parameter("slope") + q = lambda x: 2.0 * np.sin(x / 2) # noqa: E731 + term = kernel_term( + Matern(1.0, nu=2.5), + coords=q, + amplitude=exp_growth_amplitude(np.pi), + amplitude_params=(la, sl), + jitter=0.0, + ) + S = assemble([term], ctx, (np.log(0.5), np.log(0.3), 1.5)) + # note: amplitude sees the *transformed* coordinate + a = 0.3 * np.exp(1.5 * q(x) / np.pi) + ref = np.outer(a, a) * Matern(0.5, nu=2.5)(q(x)[:, None]) + np.testing.assert_allclose(S, ref) + def test_duplicate_coords_factorizable_with_jitter(self): + x = np.array([0.0, 0.0, 1.0]) + ctx = single_block_ctx(x, np.zeros(3), np.zeros(3)) + term = kernel_term(RBF(1.0), jitter=1e-8) + cov = ConstraintCovariance([term, statistical_term(1e-3 * np.ones(3))], 3) + L, _ = cov.cholesky(ctx, 0.0) + assert np.all(np.isfinite(L)) -def test_kernel_term_params_anisotropic(): - from sklearn.gaussian_process.kernels import RBF, ConstantKernel - from rxmc.covariance import KernelTerm +# ---------------------------------------------------------------------------- +# The alpha+Ca error-model ladder as one-line term lists (study self-checks) +# ---------------------------------------------------------------------------- - # anisotropic: a vector length_scale is ONE hyperparameter with n_elements == 2 - kernel = ConstantKernel(1.0) * RBF(length_scale=[1.0, 1.0]) - term = KernelTerm(np.arange(3), kernel) - assert len(term.params) == len(kernel.theta) # would be 1 vs 2 before the fix - # the gathered theta has the right length for clone_with_theta in add_to - x2d = np.array([[0.0, 0.0], [1.0, 0.5], [2.0, 1.0]]) - ctx = make_ctx(x2d, np.zeros(3), np.zeros(3), [np.arange(3)]) - Sigma = np.zeros((3, 3)) - term.add_to(Sigma, ctx, kernel.theta) # must not raise - assert np.all(np.isfinite(Sigma)) +class TestStudyForms: + """Each error model of the alpha+Ca study is one term list; compare to the + hand-rolled dense covariance from that study's ``error_covariance``.""" + def setup_method(self): + rng = np.random.default_rng(1) + n = 12 + self.x = np.sort(rng.uniform(0.2, 3.0, n)) # radians + self.y = rng.uniform(0.1, 1.5, n) # log-space "data" (any values) + self.ym = self.y + rng.normal(0.0, 0.1, n) + self.ctx = single_block_ctx(self.x, self.y, self.ym) + self.X = np.pi + self.log_err, self.log_slope = Parameter("log_err"), Parameter("log_err_slope") + self.log_sys, self.log_amp = Parameter("log_sys"), Parameter("log_amp") + self.err, self.slope, self.sys, self.amp = 0.05, 1.3, 0.04, 0.2 + self.k = 2.7 + + def xdeg(self): + return self.x / self.X # theta / 180 + + def test_L0(self): + S = assemble([noise_term(self.log_err)], self.ctx, (np.log(self.err),)) + assert np.allclose(S, self.err**2 * np.eye(len(self.x))) + + def test_E0_linear_space(self): + S = assemble([noise_fraction_term(self.log_err)], self.ctx, (np.log(self.err),)) + assert np.allclose(S, np.diag((self.err * self.ym) ** 2)) + + def test_L1(self): + terms = [ + noise_term( + self.log_err, basis=exp_growth(self.X), basis_params=(self.log_slope,) + ) + ] + S = assemble(terms, self.ctx, (np.log(self.err), self.slope)) + sigma = self.err * np.exp(self.slope * self.xdeg()) + assert np.allclose(S, np.diag(sigma**2)) -def test_kernel_term_cross_block_values(): - # a kernel spanning two observation blocks writes the correct - # off-diagonal coupling block (case A with a GP) - from sklearn.gaussian_process.kernels import RBF + def test_L2_rank_one_over_theta(self): + terms = [ + noise_term(self.log_err), + systematic_term(self.log_sys, basis=x_basis(self.X)), + ] + S = assemble(terms, self.ctx, (np.log(self.err), np.log(self.sys))) + u = self.xdeg() + assert np.allclose( + S, self.err**2 * np.eye(len(u)) + self.sys**2 * np.outer(u, u) + ) - from rxmc.covariance import KernelTerm + def test_L2n_and_L2y(self): + S = assemble( + [noise_term(self.log_err), offset_term(parameter=self.log_sys)], + self.ctx, + (np.log(self.err), np.log(self.sys)), + ) + assert np.allclose(S, self.err**2 * np.eye(len(self.x)) + self.sys**2) + S = assemble( + [noise_term(self.log_err), normalization_term(parameter=self.log_sys)], + self.ctx, + (np.log(self.err), np.log(self.sys)), + ) + assert np.allclose( + S, + self.err**2 * np.eye(len(self.x)) + + self.sys**2 * np.outer(self.ym, self.ym), + ) - kernel = RBF(length_scale=1.0) - term = KernelTerm(np.arange(4), kernel, jitter=0.0) - x = np.array([0.0, 1.0, 2.0, 3.0]) - ctx = make_ctx(x, np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)]) + def test_L12(self): + terms = [ + noise_term( + self.log_err, basis=exp_growth(self.X), basis_params=(self.log_slope,) + ), + systematic_term(self.log_sys, basis=x_basis(self.X)), + ] + S = assemble(terms, self.ctx, (np.log(self.err), self.slope, np.log(self.sys))) + sigma = self.err * np.exp(self.slope * self.xdeg()) + u = self.xdeg() + assert np.allclose(S, np.diag(sigma**2) + self.sys**2 * np.outer(u, u)) - S = np.zeros((4, 4)) - term.add_to(S, ctx, kernel.theta) - np.testing.assert_allclose(S, kernel(x[:, None])) - assert np.any(S[:2, 2:] != 0.0) + def test_Lgp_matern_in_theta(self): + ell = 0.3 + terms = [ + noise_term(self.log_err), + kernel_term( + Matern(1.0, nu=2.5), + coords=lambda x: x / self.X, + amplitude=constant_amplitude, + amplitude_params=(self.log_amp,), + jitter=0.0, + prefix="gp", + ), + ] + S = assemble(terms, self.ctx, (np.log(self.err), np.log(ell), np.log(self.amp))) + u = self.xdeg() + K = self.amp**2 * Matern(ell, nu=2.5)(u[:, None]) + assert np.allclose(S, self.err**2 * np.eye(len(u)) + K) - cov = ConstraintCovariance([term], N=4, blocks=[np.arange(2), np.arange(2, 4)]) - assert not cov.block_diagonal + def test_Lgpn_angle_growing_amplitude(self): + ell = 0.3 + terms = [ + noise_term(self.log_err), + kernel_term( + Matern(1.0, nu=2.5), + coords=lambda x: x / self.X, + amplitude=exp_growth_amplitude(1.0), + amplitude_params=(self.log_amp, self.log_slope), + jitter=0.0, + ), + ] + S = assemble( + terms, + self.ctx, + (np.log(self.err), np.log(ell), np.log(self.amp), self.slope), + ) + u = self.xdeg() + a = self.amp * np.exp(self.slope * u) + K = np.outer(a, a) * Matern(ell, nu=2.5)(u[:, None]) + assert np.allclose(S, self.err**2 * np.eye(len(u)) + K) + + def test_LKp_kernel_in_momentum_transfer(self): + # b^2 I + s^2 11^T + a(q) a(q') RBF(|q - q'| / l_q), a = A q^(r/2) + log_b, log_s, r_pow = Parameter("log_b"), Parameter("log_s"), Parameter("r") + b, s, lq, r = 0.05, 0.05, 1.2, 0.8 + q = 2.0 * self.k * np.sin(self.x / 2) + terms = [ + noise_term(log_b), + offset_term(parameter=log_s), + kernel_term( + RBF(1.0), + coords=lambda x: 2.0 * self.k * np.sin(x / 2), + amplitude=lambda c, lA, r: np.exp(lA) * c.x ** (r / 2), + amplitude_params=(self.log_amp, r_pow), + jitter=0.0, + prefix="gpq", + ), + ] + S = assemble( + terms, self.ctx, (np.log(b), np.log(s), np.log(lq), np.log(self.amp), r) + ) + a = self.amp * q ** (r / 2) + K = np.outer(a, a) * RBF(lq)(q[:, None]) + ref = b**2 * np.eye(len(q)) + s**2 * np.ones((len(q), len(q))) + K + assert np.allclose(S, ref) + + def test_custom_term_direct(self): + # anything the factories cannot say is a one-line Term + e, l = Parameter("e"), Parameter("l") + t = Term( + lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (e, l), kind="diag" + ) + S = assemble([t], self.ctx, (np.log(self.err), self.slope)) + sigma = self.err * np.exp(self.slope * self.xdeg()) + assert np.allclose(S, np.diag(sigma**2)) diff --git a/test/test_evidence.py b/test/test_evidence.py index f5204df..989c50a 100644 --- a/test/test_evidence.py +++ b/test/test_evidence.py @@ -49,7 +49,7 @@ def test_parametric_constraint_auto_detected(self): parametric = Constraint( observations=self.observations, physical_model=self.pm, - extra_terms=[model_error_term(np.arange(3), gamma)], + extra_terms=[model_error_term(gamma, support=np.arange(3))], ) evidence = Evidence(constraints=[self.constraints[0], parametric]) self.assertEqual(len(evidence.parametric_constraints), 1) @@ -61,7 +61,7 @@ def test_parametric_constraint_receives_its_params(self): parametric = Constraint( observations=self.observations, physical_model=self.pm, - extra_terms=[model_error_term(np.arange(3), gamma)], + extra_terms=[model_error_term(gamma, support=np.arange(3))], ) evidence = Evidence(constraints=[parametric]) # one tuple per parametric constraint @@ -75,7 +75,7 @@ def test_wrong_cov_params_length_raises(self): parametric = Constraint( observations=self.observations, physical_model=self.pm, - extra_terms=[model_error_term(np.arange(3), gamma)], + extra_terms=[model_error_term(gamma, support=np.arange(3))], ) evidence = Evidence(constraints=[parametric]) with self.assertRaises(ValueError): @@ -99,7 +99,7 @@ def _constraint(self, param): return Constraint( observations=self.obs, physical_model=self.pm, - extra_terms=[model_error_term(np.arange(3), param)], + extra_terms=[model_error_term(param, support=np.arange(3))], ) def test_same_parameter_object_in_two_constraints_raises(self): diff --git a/test/test_likelihood_model.py b/test/test_likelihood_model.py index db5af74..2e1aa48 100644 --- a/test/test_likelihood_model.py +++ b/test/test_likelihood_model.py @@ -8,7 +8,7 @@ from helpers import manual_mvn_loglike from rxmc.constraint import Constraint from rxmc.covariance import ( - DenseTerm, + Term, model_error_term, noise_fraction_term, noise_term, @@ -52,7 +52,9 @@ class TestUnknownNoise(LikelihoodTestBase): def test_constant_noise(self): eps = 0.05 p = Parameter("log eps") - c = Constraint([self.obs], self.pm, extra_terms=[noise_term(np.arange(3), p)]) + c = Constraint( + [self.obs], self.pm, extra_terms=[noise_term(p, support=np.arange(3))] + ) cov = np.diag(self.stat**2) + np.diag(np.full(3, eps**2)) expected = manual_mvn_loglike(self.y, self.ym, cov) self.assertEqual(c.n_params, 1) @@ -64,7 +66,9 @@ def test_noise_fraction(self): eps = 0.05 p = Parameter("log eps") c = Constraint( - [self.obs], self.pm, extra_terms=[noise_fraction_term(np.arange(3), p)] + [self.obs], + self.pm, + extra_terms=[noise_fraction_term(p, support=np.arange(3))], ) cov = np.diag(self.stat**2) + np.diag((eps * self.ym) ** 2) expected = manual_mvn_loglike(self.y, self.ym, cov) @@ -80,7 +84,7 @@ def test_eta(self): c = Constraint( [self.obs], self.pm, - extra_terms=[normalization_term(np.arange(3), parameter=p)], + extra_terms=[normalization_term(parameter=p, support=np.arange(3))], ) cov = np.diag(self.stat**2) + eta**2 * np.outer(self.ym, self.ym) expected = manual_mvn_loglike(self.y, self.ym, cov) @@ -96,7 +100,7 @@ def test_averaging(self): c = Constraint( [self.obs], self.pm, - extra_terms=[model_error_term(np.arange(3), p, averaging=True)], + extra_terms=[model_error_term(p, averaging=True, support=np.arange(3))], ) z = 0.5 * (self.y + self.ym) cov = np.diag(self.stat**2) + np.diag((gamma * z) ** 2) @@ -110,7 +114,7 @@ class TestFixedCovariance(LikelihoodTestBase): def test_dense_term_fixed_full_covariance(self): cov = np.array([[0.04, 0.01, 0.0], [0.01, 0.09, 0.02], [0.0, 0.02, 0.16]]) obs = Observation(self.x, self.y) # no stat err -> zeros - c = Constraint([obs], self.pm, extra_terms=[DenseTerm(np.arange(3), cov)]) + c = Constraint([obs], self.pm, extra_terms=[Term(cov, support=np.arange(3))]) self.assertTrue(c.covariance.is_constant) expected = manual_mvn_loglike(self.y, self.ym, cov) self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) @@ -118,7 +122,7 @@ def test_dense_term_fixed_full_covariance(self): def test_cholesky_cached(self): cov = np.diag([0.04, 0.09, 0.16]) obs = Observation(self.x, self.y) - c = Constraint([obs], self.pm, extra_terms=[DenseTerm(np.arange(3), cov)]) + c = Constraint([obs], self.pm, extra_terms=[Term(cov, support=np.arange(3))]) L1, _ = c.covariance.cholesky(None) L2, _ = c.covariance.cholesky(None) self.assertIs(L1, L2) diff --git a/test/test_observation.py b/test/test_observation.py index 8e92515..343b459 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -3,7 +3,7 @@ import numpy as np from helpers import make_ctx -from rxmc.covariance import ConstraintCovariance, RankOneTerm +from rxmc.covariance import ConstraintCovariance, Term from rxmc.observation import Observation @@ -36,7 +36,7 @@ def test_statistical_term_is_diagonal_variance(self): y_stat_err = np.array([0.1, 0.2]) observation = Observation(x, y, y_stat_err=y_stat_err) support = np.arange(2) - term = observation.statistical_term(support) + term = observation.statistical_term(support=support) Sigma = np.zeros((2, 2)) term.add_to(Sigma, None, np.array([])) np.testing.assert_array_almost_equal(Sigma, np.diag(y_stat_err**2)) @@ -48,7 +48,7 @@ def test_statistical_term_writes_into_support_block(self): y_stat_err = np.array([0.3, 0.4]) observation = Observation(x, y, y_stat_err=y_stat_err) support = np.array([2, 3]) - cov = ConstraintCovariance([observation.statistical_term(support)], N=4) + cov = ConstraintCovariance([observation.statistical_term(support=support)], N=4) Sigma = cov.matrix(None) expected = np.zeros((4, 4)) expected[2, 2] = 0.3**2 @@ -59,7 +59,9 @@ def test_default_statistical_term_is_constant(self): observation = Observation( np.array([1.0, 2.0]), np.array([2.0, 4.0]), y_stat_err=np.array([0.1, 0.2]) ) - cov = ConstraintCovariance([observation.statistical_term(np.arange(2))], N=2) + cov = ConstraintCovariance( + [observation.statistical_term(support=np.arange(2))], N=2 + ) self.assertTrue(cov.is_constant) self.assertTrue(cov.block_diagonal) self.assertEqual(cov.n_params, 0) @@ -113,7 +115,7 @@ def test_systematic_terms_offset_then_normalization(self): ) terms = obs.systematic_terms(np.arange(2)) self.assertEqual(len(terms), 2) - self.assertTrue(all(isinstance(t, RankOneTerm) for t in terms)) + self.assertTrue(all(isinstance(t, Term) and t.kind == "mode" for t in terms)) def test_systematic_terms_recover_old_covariance(self): # statistical_term + systematic_terms matches the old auto-folded @@ -132,7 +134,7 @@ def test_systematic_terms_recover_old_covariance(self): ) support = np.arange(3) cov = ConstraintCovariance( - [obs.statistical_term(support), *obs.systematic_terms(support)], N=3 + [obs.statistical_term(support=support), *obs.systematic_terms(support)], N=3 ) S = cov.matrix(make_ctx(np.arange(3.0), y, ym, [support])) old = ( diff --git a/test/test_regression.py b/test/test_regression.py index b7b5548..2cd8de0 100644 --- a/test/test_regression.py +++ b/test/test_regression.py @@ -66,8 +66,8 @@ def test_explicit_terms_recover_old_value(self): [self.obs], self.pm, extra_terms=[ - offset_term(support, magnitude=self.offset), - normalization_term(support, magnitude=self.norm), + offset_term(magnitude=self.offset, support=support), + normalization_term(magnitude=self.norm, support=support), ], ) recovered = c.log_likelihood(self.model_params) @@ -121,7 +121,7 @@ def test_off_diagonal_blocks_present_and_changes_likelihood(self): from rxmc.params import Parameter eta = Parameter("log eta") - coupling = normalization_term(np.arange(4), parameter=eta) + coupling = normalization_term(parameter=eta, support=np.arange(4)) c = Constraint([obs1, obs2], pm, extra_terms=[coupling]) # the assembled Sigma has non-zero cross-block (off-diagonal) entries diff --git a/test/test_sampler.py b/test/test_sampler.py index c42add4..461c1c9 100644 --- a/test/test_sampler.py +++ b/test/test_sampler.py @@ -15,20 +15,14 @@ from rxmc.walker import Walker -class FloorSlopeNoiseTerm(Term): +def floor_slope_noise_term(support=None): """diag((exp(floor) + exp(slope)*|ym|)**2) — a two-parameter noise term.""" - - def __init__(self, support): - self.support = np.asarray(support, dtype=int) - self.params = ( - Parameter("log noise floor", float), - Parameter("log noise slope", float), - ) - - def add_to(self, Sigma, ctx, theta): - ym = ctx.ym[self.support] - sigma = np.exp(theta[0]) + np.exp(theta[1]) * np.abs(ym) - Sigma[self.support, self.support] += sigma**2 + return Term( + lambda c, floor, slope: np.exp(floor) + np.exp(slope) * np.abs(c.ym), + (Parameter("log noise floor", float), Parameter("log noise slope", float)), + kind="diag", + support=support, + ) class TestAdaptiveMetropolisSampler(unittest.TestCase): @@ -93,7 +87,7 @@ def test_walk_runs_end_to_end_with_multi_parameter_likelihood(self): y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), ) - noise_term = FloorSlopeNoiseTerm(np.arange(observation.n_data_pts)) + noise_term = floor_slope_noise_term(np.arange(observation.n_data_pts)) constraint = Constraint( observations=[observation], physical_model=model, @@ -139,7 +133,7 @@ def test_gibbs_conditional_applies_evidence_weight(self): constraint = Constraint( observations=[observation], physical_model=model, - extra_terms=[FloorSlopeNoiseTerm(np.arange(observation.n_data_pts))], + extra_terms=[floor_slope_noise_term(np.arange(observation.n_data_pts))], ) weight = 2.5 evidence = Evidence(constraints=[constraint], weights=np.array([weight])) @@ -187,7 +181,7 @@ def setUp(self): self.parametric = Constraint( observations=[obs], physical_model=self.model, - extra_terms=[FloorSlopeNoiseTerm(np.arange(obs.n_data_pts))], + extra_terms=[floor_slope_noise_term(np.arange(obs.n_data_pts))], ) self.evidence = Evidence(constraints=[self.parametric]) self.prior = scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)) From 739be7dcf1595ea0b596642eaa84088bd2fde5e1 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:52:50 -0400 Subject: [PATCH 09/24] Add comparison-space transforms to Observation Let an Observation compare in a transformed space without the model knowing: Observation(x, y, transform=rxmc.transforms.log) takes raw y, keeps it as y_raw, stores y = log(y_raw) and the delta-method statistical error |t'(y_raw)| sigma, and fails loudly at construction if the transform is not finite at a data point. The Constraint applies the same transform to every prediction when stacking, so the model is written once in physical space and can never be double-transformed; predict(raw=True) returns the untransformed prediction, and a non-finite prediction (a non-positive cross section under log) yields -inf log likelihood and +inf chi-squared instead of a LinAlgError. Reported systematics are propagated to the comparison space the same way: the offset mode is |t'(y_raw)| omega and the normalisation mode becomes a systematic_term whose basis is eta ym_raw |t'(ym_raw)|, evaluated at the prediction. obs.log_jacobian and constraint.log_jacobian expose the constant needed to compare evidences across comparison spaces. Parametric transforms are rejected here; they belong on the model. The reaction observations forward transform= to the base class. Co-Authored-By: Claude Fable 5 --- src/rxmc/constraint.py | 37 +++++-- src/rxmc/elastic_diffxs_observation.py | 5 + src/rxmc/ias_pn_observation.py | 2 + src/rxmc/observation.py | 135 ++++++++++++++++++++----- test/test_constraint.py | 41 ++++++++ test/test_observation.py | 56 ++++++++++ 6 files changed, 244 insertions(+), 32 deletions(-) diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index aed4b9e..dc1f9a4 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -15,6 +15,9 @@ likelihoods). Correlated modes — a dataset's own normalisation/offset systematic, an unknown-noise term, or a cross-dataset coupling — are supplied as ``extra_terms``. + +Each observation's comparison-space ``transform`` is applied to the model +prediction here, so the residual ``y - ym`` is formed in that space. """ import numpy as np @@ -185,13 +188,13 @@ def _stack_from_predictions(self, ym: list): ) ym_arrays = [] for o, y in zip(self.observations, ym): - y = np.asarray(y) + y = np.asarray(y, dtype=float) if y.shape != o.y.shape: raise ValueError( f"prediction shape {y.shape} does not match observation shape " f"{o.y.shape}" ) - ym_arrays.append(y) + ym_arrays.append(o.transform(y)) return StackContext( x=self._x_stacked, y=self._y_stacked, @@ -213,8 +216,16 @@ def _split(self, params): # Likelihood # ------------------------------------------------------------------ - def _evaluate(self, ctx, cov_params, statistic): + def _evaluate(self, ctx, cov_params, statistic, *, invalid=-np.inf): + """Evaluate ``statistic(d2, logdet, n, *like_params)`` on the stack. + + ``invalid`` is returned when the prediction is not finite (e.g. a + non-positive prediction under a log comparison space): ``-inf`` for a + log likelihood (default), ``+inf`` for a chi-squared. + """ cov_part, like_part = self._split(cov_params) + if not np.all(np.isfinite(ctx.ym)): + return invalid d2, logdet = self.covariance.stacked_distance(ctx, cov_part) return statistic(d2, logdet, self.n_data_pts, *like_part) @@ -253,11 +264,23 @@ def chi2(self, model_params, cov_params=()): chi-squared statistic ignores them. """ ctx = self._stack(model_params) - return self._evaluate(ctx, cov_params, self.likelihood.chi2) + return self._evaluate(ctx, cov_params, self.likelihood.chi2, invalid=np.inf) - def predict(self, *model_params): - """Generate predictions for each observation.""" - return [self.physical_model(obs, *model_params) for obs in self.observations] + def predict(self, *model_params, raw=False): + """Predictions for each observation (comparison space). + + With ``raw=True`` the predictions are returned in physical space (the + model's own output, before each observation's ``transform``). + """ + ym = [self.physical_model(obs, *model_params) for obs in self.observations] + if raw: + return ym + return [o.transform(y) for o, y in zip(self.observations, ym)] + + @property + def log_jacobian(self) -> float: + """Sum of the observations' comparison-space log-Jacobians.""" + return float(sum(o.log_jacobian for o in self.observations)) def covariance_matrix(self, model_params, cov_params=()): """Assemble the stacked covariance matrix Σ at a parameter point. diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index a378520..da920b6 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -67,6 +67,7 @@ def __init__( zeros_per_node=5, angles_vis: np.ndarray = np.linspace(0.01, 180, 100), compound_correction: np.ndarray = None, + transform=None, ): """ Parameters @@ -112,6 +113,9 @@ def __init__( compound_correction : np.ndarray, optional Compound-nuclear contribution to dXS/dΩ in mb/sr, added to the calculated cross section before comparing to data. + transform : Transform or callable, optional + Comparison-space transform; see + :class:`~rxmc.observation.Observation`. """ self.reaction = reaction self.quantity = quantity @@ -158,6 +162,7 @@ def __init__( angles_rad_constraint, np.asarray(y) / norm, label=dataset_label, + transform=transform, **normalized_error_kwargs( norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset ), diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py index 12db563..bf4df63 100644 --- a/src/rxmc/ias_pn_observation.py +++ b/src/rxmc/ias_pn_observation.py @@ -49,6 +49,7 @@ def __init__( angles_vis: np.ndarray = np.linspace(0.01, 180, 100), wavelengths_beyond_range: float = 2.0, zeros_per_node: int = 5, + transform=None, ): """ Initialize a Observation instance for the (p,n) IAS reaction. @@ -135,6 +136,7 @@ def __init__( angles_rad_constraint, np.asarray(y) / norm, label=dataset_label, + transform=transform, **normalized_error_kwargs( norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset ), diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index 7573773..d3f0900 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -22,7 +22,8 @@ import numpy as np -from .covariance import normalization_term, offset_term, statistical_term +from .covariance import offset_term, statistical_term, systematic_term +from .transforms import as_transform def _store_error_spec(value, n, name): @@ -58,13 +59,24 @@ class Observation: inert metadata; see :meth:`systematic_terms`. label : str, optional Human-readable dataset identifier used in error messages. + transform : Transform or callable, optional + Parameter-free *comparison-space* transform (see :mod:`rxmc.transforms`). + Pass **raw** ``y``: the observation stores ``y = transform(y_raw)`` and + propagates ``y_stat_err`` by the delta method, and the + :class:`~rxmc.constraint.Constraint` applies the same transform to the + model prediction — so ``transform=rxmc.transforms.log`` compares in log + space with the model written once, in physical space. Attributes ---------- x, y : np.ndarray - The data. + The data, ``y`` in comparison space. + y_raw, y_stat_err_raw : np.ndarray + ``y`` and its statistical error as given (physical space). y_stat_err : np.ndarray - Statistical error on ``y`` (raw, not squared). + Statistical error on ``y`` in comparison space (raw, not squared). + transform : Transform + The comparison-space transform (identity by default). y_sys_err_normalization : float or np.ndarray or None Fractional normalisation uncertainty (dimensionless). y_sys_err_offset : float or np.ndarray or None @@ -83,25 +95,51 @@ def __init__( y_sys_err_normalization=None, y_sys_err_offset=None, label=None, + transform=None, ): self.label = label self.x = np.asarray(x) - self.y = np.asarray(y) - if self.x.shape != self.y.shape: + y_raw = np.asarray(y, dtype=float) + if self.x.shape != y_raw.shape: raise ValueError( "x and y must have the same shape, they have shapes " - f"{self.x.shape} and {self.y.shape}" + f"{self.x.shape} and {y_raw.shape}" ) self.n_data_pts = self.x.shape[0] - y_stat_err = y_stat_err if y_stat_err is not None else np.zeros_like(self.y) + y_stat_err = y_stat_err if y_stat_err is not None else np.zeros_like(y_raw) y_stat_err = np.asarray(y_stat_err, dtype=float) - if y_stat_err.shape != self.y.shape: + if y_stat_err.shape != y_raw.shape: raise ValueError( "y_stat_err must have the same shape as y, " - f"it has shape {y_stat_err.shape} and y has shape {self.y.shape}" + f"it has shape {y_stat_err.shape} and y has shape {y_raw.shape}" ) - self.y_stat_err = y_stat_err + + self.transform = as_transform(transform) + if self.transform.params: + raise ValueError( + "an Observation's comparison-space transform must be parameter-free" + ) + self.y_raw = y_raw + self.y_stat_err_raw = y_stat_err + if self.transform.is_identity: + self.y = y_raw + self.y_stat_err = y_stat_err + self._abs_jacobian = None + else: + # |t'(y_raw)|: the delta-method factor, reused by log_jacobian and + # systematic_terms + self._abs_jacobian = np.abs(self.transform.derivative(y_raw)) + self.y = self.transform(y_raw) + self.y_stat_err = self._abs_jacobian * y_stat_err + bad = ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) + if np.any(bad): + raise ValueError( + f"transform {self.transform.name!r} is not finite at " + f"{int(bad.sum())} data point(s) of dataset " + f"{label or 'observation'!r} (e.g. non-positive y under a " + "log transform); drop those points" + ) self.y_sys_err_normalization = _store_error_spec( y_sys_err_normalization, self.n_data_pts, "y_sys_err_normalization" @@ -110,6 +148,39 @@ def __init__( y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" ) + # ------------------------------------------------------------------ + # Comparison-space bookkeeping + # ------------------------------------------------------------------ + + @property + def log_jacobian(self) -> float: + r"""``sum(log |t'(y_raw)|)`` over all points. + + The log-Jacobian of the comparison-space transform: a constant in the + parameters, needed only to compare marginal likelihoods (log Z) across + different comparison spaces (``log Z_raw = log Z_transformed + + log_jacobian``). Zero for the identity. + """ + if self.transform.is_identity: + return 0.0 + return float(np.sum(np.log(self._abs_jacobian))) + + def _raw_prediction(self, ym): + """Invert the comparison-space transform on a prediction.""" + if self.transform.is_identity: + return np.asarray(ym, dtype=float) + inv = self.transform.inverse + if inv is None: + raise ValueError( + f"transform {self.transform.name!r} has no inverse; cannot map " + "predictions back to physical space" + ) + return inv(ym) + + # ------------------------------------------------------------------ + # Covariance terms + # ------------------------------------------------------------------ + def statistical_term(self, support=None): """The always-on, genuinely uncorrelated statistical diagonal. @@ -122,7 +193,7 @@ def statistical_term(self, support=None): Returns ------- Term - ``diag(y_stat_err**2)`` on ``support``. + ``diag(y_stat_err**2)`` on ``support`` (comparison space). """ return statistical_term(self.y_stat_err, support=support) @@ -132,7 +203,10 @@ def systematic_terms(self, support=None) -> list: Opt-in — **not** added to any covariance automatically. Pass the result via ``Constraint(extra_terms=[*obs.systematic_terms(), ...])``. Zero magnitudes are skipped, so an observation without reported - systematics yields an empty list. + systematics yields an empty list. Magnitudes are reported in physical + space and propagated to the comparison space by the delta method + (``|t'| * omega`` for an offset, ``|t'(ym_raw)| * eta * ym_raw`` for a + normalisation). Parameters ---------- @@ -147,19 +221,29 @@ def systematic_terms(self, support=None) -> list: fractional, prediction-scaled normalisation mode (``eta**2 * outer(ym, ym)``). """ + + def reported(spec): + if spec is None or not np.any(np.asarray(spec) != 0.0): + return None + return np.broadcast_to(np.asarray(spec, dtype=float), (self.n_data_pts,)) + + # the identity transform has unit Jacobian and trivial inverse, so the + # delta-method expressions below reduce to the plain magnitudes + t = self.transform terms = [] - if self.y_sys_err_offset is not None and np.any( - np.asarray(self.y_sys_err_offset) != 0.0 - ): - terms.append(offset_term(magnitude=self.y_sys_err_offset, support=support)) - if self.y_sys_err_normalization is not None and np.any( - np.asarray(self.y_sys_err_normalization) != 0.0 - ): - terms.append( - normalization_term( - magnitude=self.y_sys_err_normalization, support=support - ) - ) + omega = reported(self.y_sys_err_offset) + if omega is not None: + if not t.is_identity: + omega = self._abs_jacobian * omega + terms.append(offset_term(magnitude=omega, support=support)) + eta = reported(self.y_sys_err_normalization) + if eta is not None: + + def basis(c): + ym_raw = self._raw_prediction(c.ym) + return eta * ym_raw * np.abs(t.derivative(ym_raw)) + + terms.append(systematic_term(None, basis, support=support)) return terms def num_pts_within_interval( @@ -170,7 +254,8 @@ def num_pts_within_interval( ): """Number of points of ``y`` that fall within ``[ylow, yhigh)``. - Useful for empirical-coverage diagnostics. + Useful for empirical-coverage diagnostics. ``ylow``/``yhigh`` are in + comparison space. Parameters ---------- diff --git a/test/test_constraint.py b/test/test_constraint.py index 47c3124..efcfe2e 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -19,6 +19,7 @@ from rxmc.observation import Observation from rxmc.params import Parameter from rxmc.physical_model import PerObservationScaledModel, Polynomial +from rxmc.transforms import log class TestStackedConstraint(unittest.TestCase): @@ -450,6 +451,46 @@ def test_linear_scale(self): ) +class TestComparisonSpaceTransform(unittest.TestCase): + def setUp(self): + + self.pm = Polynomial(order=1) + self.mp = (1.0, 2.0) + self.x = np.array([1.0, 2.0, 3.0]) + self.y = np.array([3.2, 4.9, 7.3]) + self.err = np.array([0.3, 0.5, 0.7]) + + def test_log_space_equals_hand_built(self): + obs = Observation(self.x, self.y, y_stat_err=self.err, transform=log) + eps = Parameter("log eps") + c = Constraint([obs], self.pm, extra_terms=[noise_term(eps)]) + ym = self.pm(obs, *self.mp) + cov = np.diag((self.err / self.y) ** 2) + 0.04 * np.eye(3) + expected = manual_mvn_loglike(np.log(self.y), np.log(ym), cov) + self.assertAlmostEqual(c.log_likelihood(self.mp, (np.log(0.2),)), expected) + self.assertAlmostEqual(c.log_jacobian, -np.sum(np.log(self.y))) + + def test_predict_spaces(self): + obs = Observation(self.x, self.y, transform=log) + c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) + ym = self.pm(obs, *self.mp) + np.testing.assert_allclose(c.predict(*self.mp)[0], np.log(ym)) + np.testing.assert_allclose(c.predict(*self.mp, raw=True)[0], ym) + + def test_nonpositive_prediction_is_minus_inf(self): + obs = Observation(self.x, self.y, transform=log) + c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) + ll = c.log_likelihood((-10.0, 0.0), (0.0,)) + self.assertEqual(ll, -np.inf) + self.assertEqual(c.marginal_log_likelihood([np.full(3, -1.0)], 0.0), -np.inf) + + def test_nonpositive_prediction_chi2_is_plus_inf(self): + # chi2 is a distance: an invalid prediction must be +inf, not -inf + obs = Observation(self.x, self.y, transform=log) + c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) + self.assertEqual(c.chi2((-10.0, 0.0), (0.0,)), np.inf) + + class TestConstantTermsReadX(unittest.TestCase): """Constant terms (fixed kernels, x-dependent fixed diagonals) are evaluated once with the invariant x/y at Constraint construction.""" diff --git a/test/test_observation.py b/test/test_observation.py index 343b459..5978c84 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -5,6 +5,7 @@ from helpers import make_ctx from rxmc.covariance import ConstraintCovariance, Term from rxmc.observation import Observation +from rxmc.transforms import log class TestObservation(unittest.TestCase): @@ -163,5 +164,60 @@ def test_num_pts_within_interval_out(self): self.assertEqual(num_pts, 2) +class TestObservationTransform(unittest.TestCase): + def setUp(self): + self.x = np.array([1.0, 2.0, 3.0]) + self.y = np.array([2.0, 4.0, 8.0]) + self.err = np.array([0.2, 0.4, 0.8]) + + def test_raw_kept_and_y_transformed(self): + obs = Observation(self.x, self.y, y_stat_err=self.err, transform=log) + np.testing.assert_allclose(obs.y_raw, self.y) + np.testing.assert_allclose(obs.y, np.log(self.y)) + np.testing.assert_allclose(obs.y_stat_err_raw, self.err) + # delta method: sigma_log = sigma / y + np.testing.assert_allclose(obs.y_stat_err, self.err / self.y) + self.assertIs(obs.transform, log) + + def test_identity_by_default(self): + obs = Observation(self.x, self.y, y_stat_err=self.err) + self.assertTrue(obs.transform.is_identity) + self.assertIs(obs.y, obs.y_raw) + self.assertEqual(obs.log_jacobian, 0.0) + + def test_log_jacobian(self): + obs = Observation(self.x, self.y, transform=log) + self.assertAlmostEqual(obs.log_jacobian, -np.sum(np.log(self.y))) + + def test_parametric_transform_rejected(self): + from rxmc.transforms import scale + + with self.assertRaises(ValueError): + Observation(self.x, self.y, transform=scale()) + + def test_plain_callable_accepted(self): + obs = Observation(self.x, self.y, transform=np.sqrt) + np.testing.assert_allclose(obs.y, np.sqrt(self.y)) + + def test_systematic_terms_propagated_by_delta_method(self): + obs = Observation( + self.x, + self.y, + y_sys_err_offset=0.5, + y_sys_err_normalization=0.1, + transform=log, + ) + terms = obs.systematic_terms() + self.assertEqual(len(terms), 2) + ym_raw = np.array([2.5, 3.5, 9.0]) + ctx = make_ctx(self.x, obs.y, np.log(ym_raw), [np.arange(3)]) + cov = ConstraintCovariance(terms, 3, blocks=ctx.supports) + S = cov.matrix(ctx) + omega = 0.5 / self.y # |t'(y)| * offset + # fractional normalisation in log space is a constant offset eta + eta = 0.1 * ym_raw * (1.0 / ym_raw) + np.testing.assert_allclose(S, np.outer(omega, omega) + np.outer(eta, eta)) + + if __name__ == "__main__": unittest.main() From 57e4f04eddee36147891a85c6c597fcaf79c2ea4 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:53:51 -0400 Subject: [PATCH 10/24] Add point masks and held-out complements Make hold-out part of a constraint's support instead of a data surgery. Observation(mask=) marks which points are active; masked() and masked_where(predicate) derive views that share the data and any precomputed solver workspaces and only change which points enter the likelihood. Constraint(mask=) additionally switches whole observations off, and Constraint.masked() / complement() build the fit / held-out counterpart over the same Term and Parameter objects, so both views have an identical parameter vector and their log likelihoods add up to the unmasked one. Terms are still authored over the full stack: ConstraintCovariance gains active= and always assembles the full N x N matrix, restricting the Cholesky factorisation and the Mahalanobis distance to the active rows (fully masked blocks are skipped on the block path). The non-finite-transform guard, log_jacobian and the coverage counts are scoped to active points, and masked views keep an `identity` pointing at their root so identity-routed transforms treat them as one dataset. predict_and_covariance, x, y and covariance_matrix(active_only=) give the active-point views that model comparison needs. The reaction observations forward mask= to the base class. Co-Authored-By: Claude Fable 5 --- src/rxmc/constraint.py | 170 ++++++++++++++++++++++--- src/rxmc/covariance.py | 48 +++++-- src/rxmc/elastic_diffxs_observation.py | 6 +- src/rxmc/ias_pn_observation.py | 2 + src/rxmc/observation.py | 72 +++++++++-- test/test_constraint.py | 113 ++++++++++++++++ test/test_covariance.py | 47 +++++++ test/test_observation.py | 53 ++++++++ test/test_reaction_observation.py | 49 +++++++ test/test_transforms.py | 10 ++ 10 files changed, 533 insertions(+), 37 deletions(-) diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index dc1f9a4..1441a4a 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -17,7 +17,9 @@ ``extra_terms``. Each observation's comparison-space ``transform`` is applied to the model -prediction here, so the residual ``y - ym`` is formed in that space. +prediction here, so the residual ``y - ym`` is formed in that space. Masks — +point-level on the observations, observation-level via ``mask=`` — select the +*active* rows; terms are always authored over the full stack. """ import numpy as np @@ -50,6 +52,10 @@ class Constraint: it and compose the *entire* covariance from ``extra_terms`` — e.g. to let an unknown-noise term (:func:`~rxmc.covariance.noise_term`) *replace* the reported statistics rather than add to them. + mask : sequence of bool or of int, optional + Which *observations* are active (all by default): a boolean per + observation, or the indices of the active ones. Combined with each + observation's own point ``mask`` to give :attr:`active`. Attributes ---------- @@ -60,6 +66,12 @@ class Constraint: likelihood params (e.g. Student-t ``nu``). n_params : int ``len(params)``. + active : np.ndarray + Stacked indices of the active points. + n_data_pts : int + Number of *active* points (the ``n`` of the likelihood). + n_data_pts_total : int + Length of the full stack. """ def __init__( @@ -69,14 +81,24 @@ def __init__( likelihood=None, extra_terms=(), include_statistical_term: bool = True, + mask=None, ): - self.observations = observations + self.observations = list(observations) self.physical_model = physical_model self.likelihood = likelihood if likelihood is not None else GaussianLikelihood() supports = stacked_supports(observations) self._supports = supports - self.n_data_pts = sum(o.n_data_pts for o in observations) + self.n_data_pts_total = sum(o.n_data_pts for o in observations) + + self.observation_mask = self._observation_mask(mask) + self.active = np.concatenate( + [ + s[o.mask] if keep else np.zeros(0, dtype=int) + for o, s, keep in zip(observations, supports, self.observation_mask) + ] + ).astype(int) + self.n_data_pts = int(self.active.size) # x and y are invariant per constraint; stack them once. Frozen # because they are shared across every likelihood evaluation. @@ -90,7 +112,9 @@ def __init__( else: terms = [] terms += list(extra_terms) - self.covariance = ConstraintCovariance(terms, self.n_data_pts, blocks=supports) + self.covariance = ConstraintCovariance( + terms, self.n_data_pts_total, blocks=supports, active=self.active + ) self.params = tuple(self.covariance.params) + tuple(self.likelihood.params) self.n_params = len(self.params) @@ -100,6 +124,82 @@ def __init__( if self.covariance.is_constant: self._validate_constant_covariance() + def _observation_mask(self, mask): + n = len(self.observations) + if mask is None: + return np.ones(n, dtype=bool) + m = np.asarray(mask) + if m.dtype == bool: + if m.shape != (n,): + raise ValueError(f"mask must have one entry per observation ({n})") + return m + out = np.zeros(n, dtype=bool) + out[np.asarray(m, dtype=int)] = True + return out + + # ------------------------------------------------------------------ + # Masked views + # ------------------------------------------------------------------ + + def masked(self, mask=None, point_masks=None): + """A new constraint over the same observations/model/terms with new masks. + + Parameters + ---------- + mask : sequence of bool or of int, optional + Observation-level mask (see the constructor); ``None`` keeps this + constraint's. + point_masks : sequence of array_like of bool, optional + One point mask per observation (``None`` entries keep that + observation's current mask). + + Notes + ----- + The new constraint shares the ``Term``/``Parameter`` objects with this + one, so its parameter vector is identical — it is a *view* for + evaluating the same likelihood on a different subset (e.g. held-out + scoring), not an independent constraint to place in the same + :class:`~rxmc.evidence.Evidence`. + """ + observations = list(self.observations) + if point_masks is not None: + if len(point_masks) != len(observations): + raise ValueError("point_masks must have one entry per observation") + observations = [ + o if pm is None else o.masked(pm) + for o, pm in zip(observations, point_masks) + ] + # hand over the already-built term list (statistical diagonals included) + # so the view shares the exact same Term/Parameter objects + return Constraint( + observations, + self.physical_model, + likelihood=self.likelihood, + extra_terms=self.covariance.terms, + include_statistical_term=False, + mask=self.observation_mask if mask is None else mask, + ) + + def complement(self): + """The held-out counterpart: every currently inactive point becomes active + and every active point inactive. + + An observation excluded wholesale at the constraint level is therefore + restored in full; an active observation whose point mask keeps every + point is dropped wholesale. See :meth:`masked` for the sharing caveat. + """ + # an observation dropped wholesale at the constraint level is restored + # in full; an active one has its point mask flipped + point_masks = [ + ~o.mask if keep else np.ones(o.n_data_pts, dtype=bool) + for o, keep in zip(self.observations, self.observation_mask) + ] + obs_mask = [ + not keep or o.n_active < o.n_data_pts + for o, keep in zip(self.observations, self.observation_mask) + ] + return self.masked(mask=np.array(obs_mask), point_masks=point_masks) + def _validate_parameter_names(self): """Reject ambiguous parameter names within this constraint. @@ -147,7 +247,7 @@ def _validate_constant_covariance(self): o.label or f"observation {i}" for i, o in enumerate(self.observations) ] Sigma = self.covariance.matrix(ctx) - zero_rows = np.flatnonzero(np.diag(Sigma) == 0.0) + zero_rows = self.active[np.diag(Sigma)[self.active] == 0.0] offenders = [ label for label, s in zip(labels, self._supports) @@ -219,12 +319,12 @@ def _split(self, params): def _evaluate(self, ctx, cov_params, statistic, *, invalid=-np.inf): """Evaluate ``statistic(d2, logdet, n, *like_params)`` on the stack. - ``invalid`` is returned when the prediction is not finite (e.g. a - non-positive prediction under a log comparison space): ``-inf`` for a - log likelihood (default), ``+inf`` for a chi-squared. + ``invalid`` is returned when the prediction is not finite on the active + points (e.g. a non-positive prediction under a log comparison space): + ``-inf`` for a log likelihood (default), ``+inf`` for a chi-squared. """ cov_part, like_part = self._split(cov_params) - if not np.all(np.isfinite(ctx.ym)): + if not np.all(np.isfinite(ctx.ym[self.active])): return invalid d2, logdet = self.covariance.stacked_distance(ctx, cov_part) return statistic(d2, logdet, self.n_data_pts, *like_part) @@ -267,7 +367,7 @@ def chi2(self, model_params, cov_params=()): return self._evaluate(ctx, cov_params, self.likelihood.chi2, invalid=np.inf) def predict(self, *model_params, raw=False): - """Predictions for each observation (comparison space). + """Predictions for each observation (all points, comparison space). With ``raw=True`` the predictions are returned in physical space (the model's own output, before each observation's ``transform``). @@ -277,16 +377,53 @@ def predict(self, *model_params, raw=False): return ym return [o.transform(y) for o, y in zip(self.observations, ym)] + def _stack_and_covariance(self, model_params, cov_params, active_only): + """``(ctx, Sigma)`` at a parameter point; ``Sigma`` is a fresh copy.""" + ctx = self._stack(model_params) + cov_part, _ = self._split(cov_params) + if active_only: + return ctx, np.array(self.covariance.active_matrix(ctx, *cov_part)) + return ctx, np.array(self.covariance.matrix(ctx, *cov_part)) + + def predict_and_covariance(self, model_params, cov_params=()): + """Stacked prediction and covariance on the active points, one model call. + + Returns + ------- + (np.ndarray, np.ndarray) + ``(ym, Sigma)`` with ``ym`` of length ``n_data_pts`` (comparison + space) and ``Sigma`` a fresh ``(n_data_pts, n_data_pts)`` array. + """ + ctx, Sigma = self._stack_and_covariance(model_params, cov_params, True) + return ctx.ym[self.active], Sigma + + @property + def y(self) -> np.ndarray: + """Stacked observed data on the active points (comparison space).""" + return self._y_stacked[self.active] + + @property + def x(self) -> np.ndarray: + """Stacked independent variable on the active points.""" + return self._x_stacked[self.active] + @property def log_jacobian(self) -> float: - """Sum of the observations' comparison-space log-Jacobians.""" - return float(sum(o.log_jacobian for o in self.observations)) + """Sum of the observations' comparison-space log-Jacobians (active points).""" + return float( + sum( + o.log_jacobian + for o, keep in zip(self.observations, self.observation_mask) + if keep + ) + ) - def covariance_matrix(self, model_params, cov_params=()): + def covariance_matrix(self, model_params, cov_params=(), active_only=True): """Assemble the stacked covariance matrix Σ at a parameter point. Convenience accessor (e.g. for visualising the off-diagonal block - structure of correlated observations). + structure of correlated observations). Restricted to the active points + unless ``active_only=False``. Parameters ---------- @@ -301,9 +438,7 @@ def covariance_matrix(self, model_params, cov_params=()): np.ndarray, shape (n_data_pts, n_data_pts) A fresh copy (safe to mutate; never aliases the internal cache). """ - ctx = self._stack(model_params) - cov_part, _ = self._split(cov_params) - return np.array(self.covariance.matrix(ctx, *cov_part)) + return self._stack_and_covariance(model_params, cov_params, active_only)[1] # ------------------------------------------------------------------ # Coverage diagnostics @@ -316,6 +451,7 @@ def num_pts_within_interval( return sum( obs.num_pts_within_interval(ylow[i], yhigh[i], xlim) for i, obs in enumerate(self.observations) + if self.observation_mask[i] ) def empirical_coverage( diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index 086b612..16e2b0a 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -368,12 +368,17 @@ class ConstraintCovariance: (``couples_offdiagonal == False``) is classified block-diagonal; any coupling-capable term conservatively forces the dense path — there is no guessing of block structure from support shape. + active : array_like of int, optional + Indices of the *active* (unmasked) rows of the stack. The full + ``N x N`` matrix is always assembled (terms are authored in the full + space); factorisation and the Mahalanobis distance are restricted to + ``active``. ``None`` means all rows. ``terms`` and ``blocks`` are treated as immutable after construction: :attr:`block_diagonal` and :attr:`is_constant` are decided once, here. """ - def __init__(self, terms, N, blocks=None): + def __init__(self, terms, N, blocks=None, active=None): self.terms = list(terms) self.N = int(N) for t in self.terms: @@ -383,6 +388,16 @@ def __init__(self, terms, N, blocks=None): self._blocks = ( None if blocks is None else [np.asarray(b, dtype=int) for b in blocks] ) + if active is None: + self.active = None + else: + active = np.asarray(active, dtype=int) + self.active = None if active.size == self.N else active + self.n_active = self.N if self.active is None else int(self.active.size) + if self._blocks is not None and self.active is not None: + self._active_blocks = [b[np.isin(b, self.active)] for b in self._blocks] + else: + self._active_blocks = self._blocks params, index_of = [], {} for t in self.terms: @@ -423,14 +438,14 @@ def blocks(self): @property def uses_block_path(self) -> bool: """Whether :meth:`stacked_distance` factors block by block - (:meth:`block_cholesky`) rather than the whole stack + (:meth:`block_cholesky`) rather than the whole active stack (:meth:`cholesky`).""" return ( self.block_diagonal and self._blocks is not None and len(self._blocks) > 1 ) def matrix(self, ctx, *theta) -> np.ndarray: - """Assemble the stacked covariance matrix. + """Assemble the full stacked covariance matrix (all ``N`` rows). Parameters ---------- @@ -456,8 +471,15 @@ def matrix(self, ctx, *theta) -> np.ndarray: self._const_cache = Sigma return Sigma + def active_matrix(self, ctx, *theta) -> np.ndarray: + """The covariance restricted to the active rows/columns.""" + Sigma = self.matrix(ctx, *theta) + if self.active is None: + return Sigma + return Sigma[np.ix_(self.active, self.active)] + def cholesky(self, ctx, *theta): - """Lower Cholesky factor and log-determinant of the full stacked covariance. + """Lower Cholesky factor and log-determinant of the active stacked covariance. Cached when :attr:`is_constant`, so a fixed covariance is factored once. @@ -469,7 +491,7 @@ def cholesky(self, ctx, *theta): """ if self.is_constant and self._chol_cache is not None: return self._chol_cache - L, logdet = chol_logdet(self.matrix(ctx, *theta)) + L, logdet = chol_logdet(self.active_matrix(ctx, *theta)) result = (L, logdet) if self.is_constant: L.setflags(write=False) @@ -481,7 +503,8 @@ def block_cholesky(self, ctx, *theta): Only meaningful when :attr:`block_diagonal`; cached when :attr:`is_constant` so a constant block-diagonal covariance is factored - once instead of on every likelihood evaluation. + once instead of on every likelihood evaluation. Blocks are restricted to + the active rows; a fully-masked block yields ``(empty, 0.0)``. Returns ------- @@ -494,7 +517,10 @@ def block_cholesky(self, ctx, *theta): return self._block_chol_cache Sigma = self.matrix(ctx, *theta) factors = [] - for ix in self._blocks: + for ix in self._active_blocks: + if ix.size == 0: + factors.append((np.zeros((0, 0)), 0.0)) + continue L, logdet = chol_logdet(Sigma[np.ix_(ix, ix)]) L.setflags(write=False) factors.append((L, logdet)) @@ -504,7 +530,7 @@ def block_cholesky(self, ctx, *theta): return factors def stacked_distance(self, ctx, params=()): - r"""Squared Mahalanobis distance and log-determinant over the stacked residual. + r"""Squared Mahalanobis distance and log-determinant over the active residual. Owns the dispatch between the block-diagonal fast path (factor each block separately, :math:`O(\sum n_i^3)`, cached per block via @@ -522,13 +548,17 @@ def stacked_distance(self, ctx, params=()): factors = self.block_cholesky(ctx, *params) d2 = 0.0 logdet = 0.0 - for ix, (L, ld) in zip(self._blocks, factors): + for ix, (L, ld) in zip(self._active_blocks, factors): + if ix.size == 0: + continue z = sc.linalg.solve_triangular(L, r[ix], lower=True) d2 += float(np.dot(z, z)) logdet += ld return d2, logdet L, logdet = self.cholesky(ctx, *params) + if self.active is not None: + r = r[self.active] z = sc.linalg.solve_triangular(L, r, lower=True) return float(np.dot(z, z)), logdet diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index da920b6..2c53672 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -68,6 +68,7 @@ def __init__( angles_vis: np.ndarray = np.linspace(0.01, 180, 100), compound_correction: np.ndarray = None, transform=None, + mask=None, ): """ Parameters @@ -113,8 +114,8 @@ def __init__( compound_correction : np.ndarray, optional Compound-nuclear contribution to dXS/dΩ in mb/sr, added to the calculated cross section before comparing to data. - transform : Transform or callable, optional - Comparison-space transform; see + transform, mask : optional + Comparison-space transform and active-point mask; see :class:`~rxmc.observation.Observation`. """ self.reaction = reaction @@ -163,6 +164,7 @@ def __init__( np.asarray(y) / norm, label=dataset_label, transform=transform, + mask=mask, **normalized_error_kwargs( norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset ), diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py index bf4df63..545392a 100644 --- a/src/rxmc/ias_pn_observation.py +++ b/src/rxmc/ias_pn_observation.py @@ -50,6 +50,7 @@ def __init__( wavelengths_beyond_range: float = 2.0, zeros_per_node: int = 5, transform=None, + mask=None, ): """ Initialize a Observation instance for the (p,n) IAS reaction. @@ -137,6 +138,7 @@ def __init__( np.asarray(y) / norm, label=dataset_label, transform=transform, + mask=mask, **normalized_error_kwargs( norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset ), diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index d3f0900..6c0ae08 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -20,12 +20,22 @@ result via ``Constraint(extra_terms=...)``. """ +import copy + import numpy as np from .covariance import offset_term, statistical_term, systematic_term from .transforms import as_transform +def _as_point_mask(mask, n) -> np.ndarray: + """Coerce a point mask to a boolean array of shape ``(n,)``.""" + mask = np.asarray(mask, dtype=bool) + if mask.shape != (n,): + raise ValueError(f"mask must have shape ({n},), got {mask.shape}") + return mask + + def _store_error_spec(value, n, name): """Validate/normalize a systematic-error spec: None, scalar, or shape (n,).""" if value is None: @@ -66,6 +76,11 @@ class Observation: :class:`~rxmc.constraint.Constraint` applies the same transform to the model prediction — so ``transform=rxmc.transforms.log`` compares in log space with the model written once, in physical space. + mask : array_like of bool, optional + Which points are *active* in a likelihood (default all). Inactive + points stay in the block (supports/terms are authored over all points) + but are excluded from the residual; use :meth:`masked` / + :meth:`masked_where` to derive fit/held-out views. Attributes ---------- @@ -77,6 +92,13 @@ class Observation: Statistical error on ``y`` in comparison space (raw, not squared). transform : Transform The comparison-space transform (identity by default). + mask : np.ndarray of bool + Active points. + identity : Observation + The root observation this one is a view of. Views made by + :meth:`masked` share it, so anything routing by observation (e.g. + :func:`rxmc.transforms.per_observation_scaling`) treats a masked view + and its root as the same dataset. y_sys_err_normalization : float or np.ndarray or None Fractional normalisation uncertainty (dimensionless). y_sys_err_offset : float or np.ndarray or None @@ -96,8 +118,10 @@ def __init__( y_sys_err_offset=None, label=None, transform=None, + mask=None, ): self.label = label + self.identity = self self.x = np.asarray(x) y_raw = np.asarray(y, dtype=float) if self.x.shape != y_raw.shape: @@ -122,6 +146,11 @@ def __init__( ) self.y_raw = y_raw self.y_stat_err_raw = y_stat_err + self.mask = ( + np.ones(self.n_data_pts, dtype=bool) + if mask is None + else _as_point_mask(mask, self.n_data_pts) + ) if self.transform.is_identity: self.y = y_raw self.y_stat_err = y_stat_err @@ -132,13 +161,13 @@ def __init__( self._abs_jacobian = np.abs(self.transform.derivative(y_raw)) self.y = self.transform(y_raw) self.y_stat_err = self._abs_jacobian * y_stat_err - bad = ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) + bad = self.mask & ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) if np.any(bad): raise ValueError( f"transform {self.transform.name!r} is not finite at " - f"{int(bad.sum())} data point(s) of dataset " + f"{int(bad.sum())} active data point(s) of dataset " f"{label or 'observation'!r} (e.g. non-positive y under a " - "log transform); drop those points" + "log transform); mask or drop those points" ) self.y_sys_err_normalization = _store_error_spec( @@ -148,13 +177,38 @@ def __init__( y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" ) + # ------------------------------------------------------------------ + # Masks (active points) + # ------------------------------------------------------------------ + + @property + def n_active(self) -> int: + """Number of active (unmasked) points.""" + return int(self.mask.sum()) + + def masked(self, mask, label=None): + """A shallow copy of this observation with a new point mask. + + No data or pre-computed workspaces are rebuilt: the copy shares them and + only changes which points enter a likelihood. + """ + new = copy.copy(self) + new.mask = _as_point_mask(mask, self.n_data_pts) + if label is not None: + new.label = label + return new + + def masked_where(self, predicate, label=None): + """:meth:`masked` with ``mask = predicate(x)`` (points where it is True).""" + return self.masked(np.asarray(predicate(self.x), dtype=bool), label=label) + # ------------------------------------------------------------------ # Comparison-space bookkeeping # ------------------------------------------------------------------ @property def log_jacobian(self) -> float: - r"""``sum(log |t'(y_raw)|)`` over all points. + r"""``sum(log |t'(y_raw)|)`` over the active points. The log-Jacobian of the comparison-space transform: a constant in the parameters, needed only to compare marginal likelihoods (log Z) across @@ -163,7 +217,7 @@ def log_jacobian(self) -> float: """ if self.transform.is_identity: return 0.0 - return float(np.sum(np.log(self._abs_jacobian))) + return float(np.sum(np.log(self._abs_jacobian[self.mask]))) def _raw_prediction(self, ym): """Invert the comparison-space transform on a prediction.""" @@ -252,10 +306,10 @@ def num_pts_within_interval( yhigh: np.ndarray, xlim=None, ): - """Number of points of ``y`` that fall within ``[ylow, yhigh)``. + """Number of active points of ``y`` that fall within ``[ylow, yhigh)``. Useful for empirical-coverage diagnostics. ``ylow``/``yhigh`` are in - comparison space. + comparison space and indexed over *all* points of the block. Parameters ---------- @@ -264,10 +318,10 @@ def num_pts_within_interval( xlim : tuple, optional ``(x_min, x_max)`` range to restrict the count. """ - mask = np.ones_like(self.y, dtype=bool) + mask = self.mask.copy() if xlim is not None: xlow, xhigh = xlim - mask = np.logical_and(self.x >= xlow, self.x < xhigh) + mask &= np.logical_and(self.x >= xlow, self.x < xhigh) return int( np.sum( np.logical_and( diff --git a/test/test_constraint.py b/test/test_constraint.py index efcfe2e..22b706b 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -451,6 +451,119 @@ def test_linear_scale(self): ) +class TestMask(unittest.TestCase): + """Masks select the active rows; terms are authored over the full stack.""" + + def setUp(self): + self.pm = Polynomial(order=1) + self.mp = (0.5, 1.5) + self.obs1 = Observation( + np.array([1.0, 2.0, 3.0]), + np.array([2.1, 3.4, 5.2]), + y_stat_err=np.array([0.1, 0.2, 0.3]), + ) + self.obs2 = Observation( + np.array([4.0, 5.0]), + np.array([6.7, 8.1]), + y_stat_err=np.array([0.2, 0.2]), + ) + + def test_point_mask_equals_hand_subset(self): + eta = Parameter("log eta") + masked = Constraint( + [self.obs1.masked([True, False, True]), self.obs2], + self.pm, + extra_terms=[normalization_term(parameter=eta)], + ) + sub = Observation( + self.obs1.x[[0, 2]], + self.obs1.y[[0, 2]], + y_stat_err=self.obs1.y_stat_err[[0, 2]], + ) + ref = Constraint( + [sub, self.obs2], self.pm, extra_terms=[normalization_term(parameter=eta)] + ) + self.assertEqual(masked.n_data_pts, 4) + self.assertEqual(masked.n_data_pts_total, 5) + self.assertEqual(masked.covariance.N, 5) + self.assertAlmostEqual( + masked.log_likelihood(self.mp, (np.log(0.1),)), + ref.log_likelihood(self.mp, (np.log(0.1),)), + ) + # block-diagonal path too + eps = Parameter("log eps") + masked = Constraint( + [self.obs1.masked([True, False, True]), self.obs2], + self.pm, + extra_terms=[noise_term(eps)], + ) + ref = Constraint([sub, self.obs2], self.pm, extra_terms=[noise_term(eps)]) + self.assertTrue(masked.covariance.block_diagonal) + self.assertAlmostEqual( + masked.log_likelihood(self.mp, (np.log(0.3),)), + ref.log_likelihood(self.mp, (np.log(0.3),)), + ) + + def test_observation_mask_drops_block(self): + c = Constraint([self.obs1, self.obs2], self.pm, mask=[True, False]) + ref = Constraint([self.obs1], self.pm) + self.assertEqual(c.n_data_pts, 3) + self.assertAlmostEqual(c.log_likelihood(self.mp), ref.log_likelihood(self.mp)) + c2 = Constraint([self.obs1, self.obs2], self.pm, mask=[1]) + self.assertEqual(c2.n_data_pts, 2) + ev = Evidence([c2]) + self.assertEqual(ev.n_dof, 2 - 2) + + def test_complement_partitions(self): + c = Constraint( + [self.obs1.masked_where(lambda x: x < 2.5), self.obs2], + self.pm, + mask=[True, False], + ) + h = c.complement() + self.assertEqual(c.n_data_pts, 2) + self.assertEqual(h.n_data_pts, 3) # obs1's third point + all of obs2 + both = set(c.active) | set(h.active) + self.assertEqual(both, set(range(5))) + self.assertEqual(set(c.active) & set(h.active), set()) + full = Constraint([self.obs1, self.obs2], self.pm) + self.assertAlmostEqual( + c.log_likelihood(self.mp) + h.log_likelihood(self.mp), + full.log_likelihood(self.mp), + ) + + def test_masked_shares_params(self): + eta = Parameter("log eta") + c = Constraint( + [self.obs1, self.obs2], + self.pm, + extra_terms=[normalization_term(parameter=eta)], + ) + h = c.masked(point_masks=[[False, True, False], None]) + self.assertEqual(h.params, c.params) + self.assertEqual(h.n_data_pts, 3) + + def test_predict_and_covariance_active(self): + c = Constraint([self.obs1.masked([True, False, True]), self.obs2], self.pm) + ym, S = c.predict_and_covariance(self.mp) + self.assertEqual(ym.shape, (4,)) + self.assertEqual(S.shape, (4, 4)) + full = c.covariance_matrix(self.mp, active_only=False) + self.assertEqual(full.shape, (5, 5)) + np.testing.assert_allclose( + c.y, np.concatenate([self.obs1.y[[0, 2]], self.obs2.y]) + ) + preds = c.predict(*self.mp) + self.assertEqual(len(preds[0]), 3) # all points, per observation + + def test_coverage_uses_active_points(self): + c = Constraint([self.obs1.masked([True, False, True]), self.obs2], self.pm) + lo = [o.y - 1.0 for o in c.observations] + hi = [o.y + 1.0 for o in c.observations] + self.assertEqual(c.empirical_coverage(lo, hi), 1.0) + self.assertEqual(c.num_pts_within_interval(lo, hi), 4) + + class TestComparisonSpaceTransform(unittest.TestCase): def setUp(self): diff --git a/test/test_covariance.py b/test/test_covariance.py index 647906b..f776110 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -322,6 +322,53 @@ def test_stacked_distance_matches_dense(self): assert np.allclose(d_d, d_b) +class TestActive: + def setup_method(self): + self.x = np.arange(6.0) + self.y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) + self.ym = self.y + 0.1 * np.array([1, -1, 1, -1, 1, -1]) + self.blocks = [np.arange(3), np.arange(3, 6)] + self.ctx = make_ctx(self.x, self.y, self.ym, self.blocks) + self.eta = Parameter("log eta") + self.terms = [ + statistical_term(0.3 * np.ones(6)), + normalization_term(parameter=self.eta), # whole stack -> dense + ] + self.active = np.array([0, 2, 3, 5]) + + def _reference(self, cov, active): + """Dense (d2, logdet) on the active subset of ``cov``'s full matrix.""" + S = cov.matrix(self.ctx, np.log(0.2))[np.ix_(active, active)] + return mahalanobis_distance_sqr_cholesky(self.y[active], self.ym[active], S) + + def test_dense_path_restricts_to_active(self): + cov = ConstraintCovariance(self.terms, 6, active=self.active) + assert cov.n_active == 4 + d2, ld = cov.stacked_distance(self.ctx, (np.log(0.2),)) + assert np.allclose((d2, ld), self._reference(cov, self.active)) + assert cov.active_matrix(self.ctx, np.log(0.2)).shape == (4, 4) + assert cov.matrix(self.ctx, np.log(0.2)).shape == (6, 6) + + def test_block_path_restricts_to_active(self): + terms = [statistical_term(0.3 * np.ones(6)), noise_term(Parameter("e"))] + cov = ConstraintCovariance(terms, 6, blocks=self.blocks, active=self.active) + assert cov.block_diagonal and cov.uses_block_path + d2, ld = cov.stacked_distance(self.ctx, (np.log(0.2),)) + assert np.allclose((d2, ld), self._reference(cov, self.active)) + + def test_fully_masked_block_skipped(self): + terms = [statistical_term(0.3 * np.ones(6))] + active = np.arange(3) + cov = ConstraintCovariance(terms, 6, blocks=self.blocks, active=active) + d2, ld = cov.stacked_distance(self.ctx) + r = (self.y - self.ym)[:3] + assert np.allclose((d2, ld), (r @ r / 0.09, 3 * np.log(0.09))) + + def test_all_active_is_none(self): + cov = ConstraintCovariance(self.terms, 6, active=np.arange(6)) + assert cov.active is None + + # ---------------------------------------------------------------------------- # Factories # ---------------------------------------------------------------------------- diff --git a/test/test_observation.py b/test/test_observation.py index 5978c84..0746efa 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -170,6 +170,20 @@ def setUp(self): self.y = np.array([2.0, 4.0, 8.0]) self.err = np.array([0.2, 0.4, 0.8]) + def test_nonpositive_data_under_log_raises(self): + y = np.array([2.0, 0.0, -1.0]) + with self.assertRaises(ValueError) as cm: + Observation(self.x, y, y_stat_err=self.err, transform=log, label="bad") + msg = str(cm.exception) + self.assertIn("'log'", msg) + self.assertIn("'bad'", msg) + self.assertIn("2 active data point(s)", msg) + # inactive points may be non-positive: the guard is active-point scoped + obs = Observation( + self.x, y, y_stat_err=self.err, transform=log, mask=[True, False, False] + ) + self.assertEqual(obs.n_active, 1) + def test_raw_kept_and_y_transformed(self): obs = Observation(self.x, self.y, y_stat_err=self.err, transform=log) np.testing.assert_allclose(obs.y_raw, self.y) @@ -188,6 +202,9 @@ def test_identity_by_default(self): def test_log_jacobian(self): obs = Observation(self.x, self.y, transform=log) self.assertAlmostEqual(obs.log_jacobian, -np.sum(np.log(self.y))) + # respects the mask + obs2 = obs.masked([True, False, True]) + self.assertAlmostEqual(obs2.log_jacobian, -np.log(2.0) - np.log(8.0)) def test_parametric_transform_rejected(self): from rxmc.transforms import scale @@ -219,5 +236,41 @@ def test_systematic_terms_propagated_by_delta_method(self): np.testing.assert_allclose(S, np.outer(omega, omega) + np.outer(eta, eta)) +class TestObservationMask(unittest.TestCase): + def setUp(self): + self.x = np.array([1.0, 2.0, 3.0, 4.0]) + self.y = np.array([1.0, 2.0, 3.0, 4.0]) + + def test_default_all_active(self): + obs = Observation(self.x, self.y) + self.assertEqual(obs.n_active, 4) + self.assertTrue(obs.mask.all()) + + def test_masked_is_shallow_copy(self): + obs = Observation(self.x, self.y, label="a") + m = obs.masked([True, True, False, False], label="a-fwd") + self.assertEqual(m.n_active, 2) + self.assertEqual(m.n_data_pts, 4) + self.assertEqual(m.label, "a-fwd") + self.assertIs(m.y, obs.y) + self.assertEqual(obs.n_active, 4) # original untouched + + def test_masked_where(self): + obs = Observation(self.x, self.y) + m = obs.masked_where(lambda x: x < 2.5) + np.testing.assert_array_equal(m.mask, [True, True, False, False]) + + def test_bad_mask_shape_raises(self): + with self.assertRaises(ValueError): + Observation(self.x, self.y, mask=[True, False]) + with self.assertRaises(ValueError): + Observation(self.x, self.y).masked([True]) + + def test_num_pts_within_interval_respects_mask(self): + obs = Observation(self.x, self.y, mask=[True, False, True, False]) + n = obs.num_pts_within_interval(self.y - 0.1, self.y + 0.1) + self.assertEqual(n, 2) + + if __name__ == "__main__": unittest.main() diff --git a/test/test_reaction_observation.py b/test/test_reaction_observation.py index 10ddb00..aaebf7a 100644 --- a/test/test_reaction_observation.py +++ b/test/test_reaction_observation.py @@ -7,6 +7,7 @@ from rxmc.elastic_diffxs_observation import ElasticDifferentialXSObservation from rxmc.ias_pn_observation import IsobaricAnalogPNObservation from rxmc.observation import Observation +from rxmc.transforms import log def make_measurement(**overrides): @@ -91,6 +92,30 @@ def test_from_measurement_construction(self, mock_set_up_solver): self.assertEqual(obs.y_sys_err_offset, 0.02) self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_from_measurement_forwards_transform_and_mask(self, mock_set_up_solver): + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(), + DummyElasticWorkspace(), + object(), + ) + measurement = make_measurement( + systematic_norm_err=None, + systematic_offset_err=None, + subentry="elastic-subentry", + ) + mask = np.array([True, False]) + obs = ElasticDifferentialXSObservation.from_measurement( + measurement=measurement, + reaction=object(), + quantity="dXS/dA", + transform=log, + mask=mask, + ) + self.assertIs(obs.transform, log) + np.testing.assert_allclose(obs.y, np.log(measurement.y)) + np.testing.assert_array_equal(obs.mask, mask) + @patch("rxmc.elastic_diffxs_observation.set_up_solver") def test_from_measurement_rutherford_array_norm(self, mock_set_up_solver): # dXS/dRuth requested from a dXS/dA measurement: norm is the per-angle @@ -276,6 +301,30 @@ def test_from_measurement_construction(self, mock_set_up_solver): self.assertEqual(obs.y_sys_err_offset, 0.01) self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) + @patch("rxmc.ias_pn_observation.set_up_solver") + def test_from_measurement_forwards_transform_and_mask(self, mock_set_up_solver): + mock_set_up_solver.return_value = (object(), object(), object(), object()) + measurement = make_measurement( + x=np.array([5.0, 15.0]), + y=np.array([0.9, 0.7]), + Einc=18.0, + statistical_err=np.array([0.08, 0.07]), + systematic_norm_err=None, + systematic_offset_err=None, + subentry="ias-subentry", + ) + mask = np.array([False, True]) + obs = IsobaricAnalogPNObservation.from_measurement( + measurement=measurement, + reaction=object(), + ExIAS=4.5, + transform=log, + mask=mask, + ) + self.assertIs(obs.transform, log) + np.testing.assert_allclose(obs.y, np.log(measurement.y)) + np.testing.assert_array_equal(obs.mask, mask) + @patch("rxmc.ias_pn_observation.set_up_solver") def test_unit_conversion_divides_offset_not_normalization(self, mock_set_up_solver): mock_set_up_solver.return_value = (object(), object(), object(), object()) diff --git a/test/test_transforms.py b/test/test_transforms.py index e643cdd..7bb3c44 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -98,6 +98,16 @@ def test_routes_by_identity(self): with self.assertRaises(KeyError): t(a, 0.0, 0.0, context=Observation(np.array([1.0]), np.array([1.0]))) + def test_masked_view_routes_to_root(self): + t = per_observation_scaling([self.o1, self.o2]) + view = self.o2.masked(np.array([False])) + self.assertIs(view.identity, self.o2) + a = np.array([1.0]) + np.testing.assert_allclose(t(a, 0.0, np.log(5.0), context=view), [5.0]) + # registering a view and its root is still a duplicate + with self.assertRaises(ValueError): + per_observation_scaling([self.o2, view]) + def test_linear_and_custom_parameters(self): t = per_observation_scaling([self.o1], log=False) self.assertEqual(t.params[0].name, "rho_0") From b8fe476e7c97b5a119cb4f90d76b51748a587090 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:54:28 -0400 Subject: [PATCH 11/24] Replace ScaledModel classes with parametric model transforms Drop ScaledModel and PerObservationScaledModel in favour of one mechanism: PhysicalModel(params, transform=...) appends the transform's Parameters to the model's and applies it to the output of evaluate, so evaluate stays physical-space only and split_params / apply_transform give subclasses the same hook for their visualisation predictions. rxmc.transforms.scale() is the Kennedy-O'Hagan latent scale rho (it changes the mean, so it is a model transform, not a covariance term) and per_observation_scaling(observations) is one rho_i per dataset, routed by observation identity so masked views scale like their root. The reaction models accept transform= and route their visualisation path through split_params / apply_transform; the normalization inference notebook is ported to Polynomial(transform=...). Co-Authored-By: Claude Fable 5 --- examples/normalization_inference.ipynb | 48 +++---- src/rxmc/elastic_diffxs_model.py | 14 +- src/rxmc/ias_pn_model.py | 10 +- src/rxmc/physical_model.py | 175 +++++++------------------ test/test_constraint.py | 109 ++++++++++----- 5 files changed, 167 insertions(+), 189 deletions(-) diff --git a/examples/normalization_inference.ipynb b/examples/normalization_inference.ipynb index ad0cf37..6b89d43 100644 --- a/examples/normalization_inference.ipynb +++ b/examples/normalization_inference.ipynb @@ -352,11 +352,14 @@ "# Unknown per-dataset normalization: a latent scale rho_i for each dataset, routed\n", "# to it by identity and sampled as ordinary *model* parameters. This is the v2\n", "# form of the old per-dataset UnknownNormalizationModel -- rho moves onto the\n", - "# PhysicalModel (rxmc.physical_model.PerObservationScaledModel) and is sampled in\n", + "# PhysicalModel (via rxmc.transforms.per_observation_scaling) and is sampled in\n", "# the model block (jointly with the physics) rather than as a per-constraint\n", "# covariance nuisance. All constraints share the one model instance, so they\n", "# still share a single model-parameter vector.\n", - "norm_model = rxmc.physical_model.PerObservationScaledModel(correct_model, observations)\n", + "norm_model = rxmc.physical_model.Polynomial(\n", + " order=correct_model.order,\n", + " transform=rxmc.transforms.per_observation_scaling(observations),\n", + ")\n", "evidence_models[\"unknown_norm\"] = rxmc.evidence.Evidence(\n", " [rxmc.constraint.Constraint([obs], norm_model) for obs in observations]\n", ")\n", @@ -368,7 +371,9 @@ " observations,\n", " correct_model,\n", " extra_terms=[\n", - " rxmc.covariance.normalization_term(sup, magnitude=o.sys_norm_err)\n", + " rxmc.covariance.normalization_term(\n", + " magnitude=o.sys_norm_err, support=sup\n", + " )\n", " for o, sup in zip(observations, _block_supports(observations))\n", " ],\n", " )\n", @@ -392,7 +397,9 @@ " correct_model,\n", " extra_terms=[\n", " rxmc.covariance.model_error_term(\n", - " np.arange(_N_unreported), gamma, averaging=True\n", + " gamma,\n", + " averaging=True,\n", + " support=np.arange(_N_unreported),\n", " )\n", " ],\n", " )\n", @@ -1815,7 +1822,7 @@ "A flat `normalization_term` is a *rank-one* mode: every point is **100 %**\n", "correlated (correlation matrix all ones off-diagonal). A systematic that varies\n", "smoothly with $x$ — e.g. an energy-dependent efficiency — instead has correlation\n", - "that **decays** with separation. That is a `KernelTerm` (a GP prior on the\n", + "that **decays** with separation. That is a `kernel_term` (a GP prior on the\n", "systematic). Same API, richer structure." ] }, @@ -1845,21 +1852,20 @@ ], "source": [ "o0 = observations[0]\n", - "(sup0,) = rxmc.covariance.stacked_supports([o0])\n", "xspan = o0.x.max() - o0.x.min()\n", "\n", "# (a) flat normalization: rank-one, uniform correlation\n", "c_flat = rxmc.constraint.Constraint(\n", " [o0],\n", " correct_model,\n", - " extra_terms=[rxmc.covariance.normalization_term(sup0, magnitude=0.05)],\n", + " extra_terms=[rxmc.covariance.normalization_term(magnitude=0.05)],\n", ")\n", - "# (b) smooth correlated systematic: a GP (KernelTerm) over x\n", + "# (b) smooth correlated systematic: a GP (kernel_term) over x\n", "sys_kernel = ConstantKernel(0.05**2) * RBF(length_scale=xspan / 4)\n", "c_smooth = rxmc.constraint.Constraint(\n", " [o0],\n", " correct_model,\n", - " extra_terms=[rxmc.covariance.discrepancy_term(sup0, sys_kernel)],\n", + " extra_terms=[rxmc.covariance.kernel_term(sys_kernel)],\n", ")\n", "\n", "S_flat = c_flat.covariance_matrix(true_params)\n", @@ -1868,7 +1874,7 @@ "fig, ax = plt.subplots(1, 2, figsize=(9, 4))\n", "for a, S, t in [\n", " (ax[0], S_flat, \"flat normalization (rank-one)\"),\n", - " (ax[1], S_smooth, \"smooth systematic (KernelTerm)\"),\n", + " (ax[1], S_smooth, \"smooth systematic (kernel_term)\"),\n", "]:\n", " im = a.imshow(correlation(S), vmin=-1, vmax=1, cmap=\"RdBu_r\")\n", " a.set_title(t)\n", @@ -1887,7 +1893,7 @@ "they are **not** — shared backgrounds, unfolding, detector resolution — ignoring\n", "the correlation makes the posterior **overconfident**. We draw line data with\n", "exponentially-correlated noise and fit it two ways: a naive diagonal, and the\n", - "correct correlated covariance supplied as a `DenseTerm`." + "correct correlated covariance supplied as a fixed `Term`." ] }, { @@ -1922,17 +1928,16 @@ "y_corr = line(rxmc.observation.Observation(x=xs, y=np.zeros_like(xs)), *a_true)\n", "y_corr = y_corr + rng.multivariate_normal(np.zeros(xs.size), C)\n", "obs_corr = rxmc.observation.Observation(x=xs, y=y_corr)\n", - "sup = np.arange(obs_corr.n_data_pts)\n", "\n", "c_naive = rxmc.constraint.Constraint(\n", " [obs_corr],\n", " line,\n", - " extra_terms=[rxmc.covariance.DenseTerm(sup, sig**2 * np.ones(xs.size))],\n", + " extra_terms=[rxmc.covariance.Term(sig * np.ones(xs.size), kind=\"diag\")],\n", ")\n", "c_correlated = rxmc.constraint.Constraint(\n", " [obs_corr],\n", " line,\n", - " extra_terms=[rxmc.covariance.DenseTerm(sup, C)],\n", + " extra_terms=[rxmc.covariance.Term(C)],\n", ")\n", "\n", "\n", @@ -1989,7 +1994,7 @@ ")\n", "corner.corner(chain_correlated, fig=fig, color=\"tab:blue\")\n", "plt.plot([], [], color=\"tab:red\", label=\"naive diagonal (overconfident)\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"correlated DenseTerm\")\n", + "plt.plot([], [], color=\"tab:blue\", label=\"correlated fixed Term\")\n", "fig.legend(loc=\"upper right\");" ] }, @@ -2000,7 +2005,7 @@ "source": [ "The naive-diagonal posterior is visibly **tighter** than the correct one:\n", "treating correlated noise as independent over-counts the information. The\n", - "`DenseTerm` with the true correlation restores honest uncertainty." + "a fixed `Term` with the true correlation restores honest uncertainty." ] }, { @@ -2057,12 +2062,11 @@ ], "source": [ "o = observations[0]\n", - "(sup,) = rxmc.covariance.stacked_supports([o])\n", "gamma = rxmc.params.Parameter(\"log gamma\", float)\n", "c_me = rxmc.constraint.Constraint(\n", " [o],\n", " correct_model,\n", - " extra_terms=[rxmc.covariance.model_error_term(sup, gamma, averaging=True)],\n", + " extra_terms=[rxmc.covariance.model_error_term(gamma, averaging=True)],\n", ")\n", "plt.figure(figsize=(7, 4))\n", "for g in [0.02, 0.05, 0.10]:\n", @@ -2121,13 +2125,13 @@ "c_shared = rxmc.constraint.Constraint(\n", " pair,\n", " correct_model,\n", - " extra_terms=[rxmc.covariance.normalization_term(full, magnitude=0.06)],\n", + " extra_terms=[rxmc.covariance.normalization_term(magnitude=0.06, support=full)],\n", ")\n", "c_separate = rxmc.constraint.Constraint(\n", " pair,\n", " correct_model,\n", " extra_terms=[\n", - " rxmc.covariance.normalization_term(s, magnitude=0.06) for s in supports\n", + " rxmc.covariance.normalization_term(magnitude=0.06, support=s) for s in supports\n", " ],\n", ")\n", "n1 = pair[0].n_data_pts\n", @@ -2158,8 +2162,8 @@ "| case | `Term` | structure |\n", "|------|--------|-----------|\n", "| flat normalisation | `normalization_term` | rank-one, uniform |\n", - "| correlated-across-$x$ systematic | `KernelTerm` (`discrepancy_term`) | smooth/banded |\n", - "| correlated statistical errors | `DenseTerm` | arbitrary off-diagonal |\n", + "| correlated-across-$x$ systematic | `kernel_term` | smooth/banded |\n", + "| correlated statistical errors | fixed `Term` | arbitrary off-diagonal |\n", "| unknown magnitude | `model_error_term` (free $\\gamma$) | sampled diagonal |\n", "| shared across datasets | cross-block `normalization_term` | off-diagonal blocks |\n", "\n", diff --git a/src/rxmc/elastic_diffxs_model.py b/src/rxmc/elastic_diffxs_model.py index 5becc16..1b45fe2 100644 --- a/src/rxmc/elastic_diffxs_model.py +++ b/src/rxmc/elastic_diffxs_model.py @@ -31,6 +31,7 @@ def __init__( params: list = [], model_name: str = None, interaction_coulomb: Callable[..., np.ndarray] | None = None, + transform=None, ): """ Parameters @@ -56,6 +57,9 @@ def __init__( ``f(r, *args) -> np.ndarray`` returning the Coulomb potential on ``r``. When ``None`` the Coulomb interaction inside the channel radius must be folded into ``interaction_central``. + transform : Transform or callable, optional + Parametric model-side transform applied to the prediction; see + :class:`~rxmc.physical_model.PhysicalModel`. """ self.model_name = model_name or "ElasticDifferentialXSModel" @@ -77,7 +81,7 @@ def __init__( "or 'Ay'." ) - super().__init__(params) + super().__init__(params, transform=transform) def _xs(self, ws, params): """Evaluate the potentials on ``ws.radial_grid()`` and solve.""" @@ -154,7 +158,8 @@ def visualizable_model_prediction( observation : ElasticDifferentialXSObservation Observation containing the reaction data and pre-built workspace. *params : float - Physical-model parameter values. + Full model parameter values (physical parameters followed by any + transform parameters). Returns ------- @@ -166,8 +171,9 @@ def visualizable_model_prediction( f"Observation quantity {observation.quantity} does not match " f"model quantity {self.quantity}." ) + base, values = self.split_params(params) ws = observation.visualization_workspace - xs = self._xs(ws, params) + xs = self._xs(ws, base) if observation.compound_correction is not None: cn = np.interp( ws.angles, @@ -180,7 +186,7 @@ def visualizable_model_prediction( ) xs.dsdo += cn xs.t += 2 * np.pi * np.trapz(cn, ws.angles) - return self.extractor(xs, ws) + return self.apply_transform(observation, self.extractor(xs, ws), values) def extract_dXS_dA( diff --git a/src/rxmc/ias_pn_model.py b/src/rxmc/ias_pn_model.py index 7019242..4dae85f 100644 --- a/src/rxmc/ias_pn_model.py +++ b/src/rxmc/ias_pn_model.py @@ -45,6 +45,7 @@ def __init__( calculate_params: Callable[[jitr.xs.quasielastic_pn.Workspace, tuple], tuple], params: list = [], model_name: str = None, + transform=None, ): """ Parameters @@ -68,6 +69,9 @@ def __init__( Parameters of the model. Defaults to ``[]``. model_name : str, optional Human-readable model name. Defaults to ``"IsobaricAnalogPNXSModel"``. + transform : Transform or callable, optional + Parametric model-side transform applied to the prediction; see + :class:`~rxmc.physical_model.PhysicalModel`. """ self.model_name = model_name or "IsobaricAnalogPNXSModel" self.U_p_coulomb = U_p_coulomb @@ -77,7 +81,7 @@ def __init__( self.U_n_spin_orbit = U_n_spin_orbit self.calculate_params = calculate_params - super().__init__(params) + super().__init__(params, transform=transform) def _xs(self, ws, params) -> np.ndarray: """Evaluate the five potentials on ``ws.radial_grid()`` and solve (b/sr).""" @@ -144,4 +148,6 @@ def visualizable_model_prediction( Predicted (p,n) IAS differential cross section in b/sr on ``observation.visualization_workspace.angles``. """ - return self._xs(observation.visualization_workspace, params) + base, values = self.split_params(params) + xs = self._xs(observation.visualization_workspace, base) + return self.apply_transform(observation, xs, values) diff --git a/src/rxmc/physical_model.py b/src/rxmc/physical_model.py index 5ef3a0d..ccd6a8f 100644 --- a/src/rxmc/physical_model.py +++ b/src/rxmc/physical_model.py @@ -13,6 +13,7 @@ from .observation import Observation from .params import Parameter +from .transforms import as_transform class PhysicalModel: @@ -23,17 +24,48 @@ class PhysicalModel: measurement $\\{x_i,\\, y(x_i)\\}$ encapsulated in an :class:`~rxmc.observation.Observation`. + Subclasses implement :meth:`evaluate` in physical space. An optional + *parametric* ``transform`` (see :mod:`rxmc.transforms`) is applied on top by + :meth:`__call__`; its parameters are appended to :attr:`params` so they flow + through the ordinary model-parameter machinery (priors, ``split_parameters``). + Typical uses are a latent normalisation :func:`rxmc.transforms.scale` or one + per dataset via :func:`rxmc.transforms.per_observation_scaling`. Comparison- + space transforms (e.g. comparing in log space) are *not* the model's + business: declare them on the :class:`~rxmc.observation.Observation`. + Parameters ---------- params : list of Parameter - Parameters that define the model. Each entry should carry a name + Physical parameters of the model. Each entry should carry a name and a data type. + transform : Transform or callable, optional + Model-side transform ``y -> transform(y, *values)`` applied after + :meth:`evaluate`. Its parameters (if any) are appended to ``params``. """ - def __init__(self, params: list[Parameter]): - self.params = params + def __init__(self, params: list[Parameter], transform=None): + self.base_params = list(params) + self.transform = as_transform(transform) + self.params = self.base_params + list(self.transform.params) + self.n_base_params = len(self.base_params) self.n_params = len(self.params) + def split_params(self, params): + """Split a full parameter tuple into ``(base_params, transform_values)``.""" + params = tuple(params) + if len(params) != self.n_params: + raise ValueError( + f"{type(self).__name__} expects {self.n_params} parameter(s), " + f"got {len(params)}" + ) + return params[: self.n_base_params], params[self.n_base_params :] + + def apply_transform(self, observation, y, transform_values=()): + """Apply the model-side transform to a physical-space prediction.""" + if self.transform.is_identity: + return np.asarray(y, dtype=float) + return self.transform(y, *transform_values, context=observation) + def evaluate(self, observation: Observation, *params) -> np.ndarray: """Evaluate the model at the given parameter values. @@ -59,7 +91,11 @@ def evaluate(self, observation: Observation, *params) -> np.ndarray: raise NotImplementedError("Subclasses must implement the evaluate method.") def __call__(self, observation: Observation, *params) -> np.ndarray: - return self.evaluate(observation, *params) + """Physical-space :meth:`evaluate` followed by the model transform.""" + base, values = self.split_params(params) + return self.apply_transform( + observation, self.evaluate(observation, *base), values + ) class Polynomial(PhysicalModel): @@ -75,14 +111,16 @@ class Polynomial(PhysicalModel): ---------- order : int Polynomial order $n$. The model has $n+1$ free coefficients. + transform : Transform or callable, optional + See :class:`PhysicalModel`. """ - def __init__(self, order: int): + def __init__(self, order: int, transform=None): params = [] for i in range(order + 1): params.append(Parameter(f"a{i}", latex_name=f"a_{i}", dtype=float)) self.order = order - super().__init__(params) + super().__init__(params, transform=transform) def evaluate(self, observation: Observation, *params) -> np.ndarray: """Evaluate the polynomial at the observation grid. @@ -113,128 +151,3 @@ def evaluate(self, observation: Observation, *params) -> np.ndarray: x_powers = np.vander(observation.x, self.order + 1, increasing=True) y = np.dot(x_powers, np.asarray(params)) return y - - -class ScaledModel(PhysicalModel): - r"""A physical model with a latent multiplicative normalisation. - - Wraps a base :class:`PhysicalModel` and prepends a scale parameter - :math:`\rho`, returning - - .. math:: - - y_{\mathrm{model}}(x;\, \rho, \alpha) = \rho \, y_{\mathrm{base}}(x;\, \alpha) - - This is the Kennedy & O'Hagan latent forward-model scale that the old - ``UnknownNormalizationModel`` expressed on the likelihood side. It changes the - *mean*, not the covariance, so it lives on the model and flows through the - ordinary model-parameter machinery (priors, ``split_parameters``). - - Parameters - ---------- - base_model : PhysicalModel - The model whose prediction is rescaled. - scale_parameter : Parameter, optional - The scale parameter. Defaults to a log-scale ``log rho``; set - ``log=False`` for a linear scale. - log : bool, optional - If ``True`` (default), the sampled value is ``log(rho)`` and the model - scales by ``exp(value)``; otherwise it scales by ``value`` directly. - """ - - def __init__( - self, base_model: PhysicalModel, scale_parameter: Parameter = None, log=True - ): - self.base_model = base_model - self.log = log - if scale_parameter is None: - scale_parameter = Parameter( - "log normalization", - float, - unit="dimensionless", - latex_name=r"\log{\rho}" if log else r"\rho", - ) - self.scale_parameter = scale_parameter - super().__init__([scale_parameter] + list(base_model.params)) - - def evaluate(self, observation: Observation, *params) -> np.ndarray: - if len(params) != self.n_params: - raise ValueError(f"Expected {self.n_params} parameters, got {len(params)}") - scale = np.exp(params[0]) if self.log else params[0] - return scale * self.base_model.evaluate(observation, *params[1:]) - - -class PerObservationScaledModel(PhysicalModel): - r"""A physical model with an independent latent normalisation per dataset. - - Wraps a base :class:`PhysicalModel` and assigns one scale parameter - :math:`\rho_i` to each :class:`~rxmc.observation.Observation` in - ``observations``, routing **by identity**: when evaluated on observation - :math:`i` it returns :math:`\rho_i\, y_{\mathrm{base}}`. The base parameters - come first, followed by the per-observation scales in ``observations`` order. - - Because every constraint shares one such model instance, the per-dataset - scales are ordinary *model* parameters (sampled in the model block jointly - with the physics) rather than per-constraint covariance nuisances — this is - how the old per-dataset ``UnknownNormalizationModel`` is expressed in v2. The - routing reuses the same gather-by-identity idea as - :class:`~rxmc.covariance.ConstraintCovariance`. - - Parameters - ---------- - base_model : PhysicalModel - The model whose prediction is rescaled. - observations : sequence of Observation - The datasets, each assigned its own scale parameter (matched by identity - when :meth:`evaluate` is called). - scale_parameters : sequence of Parameter, optional - One scale parameter per observation. Defaults to ``log_rho_{i}``. - log : bool, optional - If ``True`` (default), the sampled value is ``log(rho_i)`` and the model - scales by ``exp(value)``; otherwise it scales by ``value`` directly. - prefix : str, optional - Name prefix for the default scale parameters. - """ - - def __init__( - self, - base_model: PhysicalModel, - observations, - scale_parameters=None, - log=True, - prefix="log_rho", - ): - self.base_model = base_model - self.log = log - self._n_base = len(base_model.params) - # hold references so id()-keyed routing can never see a recycled id - self.observations = list(observations) - self._index = {id(o): i for i, o in enumerate(self.observations)} - if len(self._index) != len(self.observations): - raise ValueError( - "observations must be distinct objects (routing by identity)" - ) - if scale_parameters is None: - scale_parameters = [ - Parameter( - f"{prefix}_{i}", - float, - unit="dimensionless", - latex_name=(rf"\log{{\rho_{{{i}}}}}" if log else rf"\rho_{{{i}}}"), - ) - for i in range(len(self._index)) - ] - self.scale_parameters = list(scale_parameters) - super().__init__(list(base_model.params) + self.scale_parameters) - - def evaluate(self, observation: Observation, *params) -> np.ndarray: - if len(params) != self.n_params: - raise ValueError(f"Expected {self.n_params} parameters, got {len(params)}") - if id(observation) not in self._index: - raise KeyError( - "observation was not registered with this PerObservationScaledModel" - ) - base_params = params[: self._n_base] - value = params[self._n_base + self._index[id(observation)]] - scale = np.exp(value) if self.log else value - return scale * self.base_model.evaluate(observation, *base_params) diff --git a/test/test_constraint.py b/test/test_constraint.py index 22b706b..3a57183 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -18,8 +18,8 @@ from rxmc.likelihood_model import GaussianLikelihood, StudentT from rxmc.observation import Observation from rxmc.params import Parameter -from rxmc.physical_model import PerObservationScaledModel, Polynomial -from rxmc.transforms import log +from rxmc.physical_model import Polynomial +from rxmc.transforms import log, per_observation_scaling, scale class TestStackedConstraint(unittest.TestCase): @@ -122,11 +122,10 @@ def test_case_A_differs_from_independent(self): self.assertNotAlmostEqual(ll_coupled, ll_indep) -class TestPerDatasetScaledModel(unittest.TestCase): - """Per-dataset latent rho expressed as identity-routed model parameters.""" +class TestPerObservationScaling(unittest.TestCase): + """Per-dataset latent rho as an identity-routed model transform.""" def setUp(self): - self.base = Polynomial(order=1) self.obs1 = Observation( np.array([1.0, 2.0, 3.0]), np.array([2.0, 4.0, 6.0]), @@ -138,16 +137,30 @@ def setUp(self): y_stat_err=np.array([0.1, 0.1, 0.1]), ) + def make_model(self, observations): + return Polynomial(order=1, transform=per_observation_scaling(observations)) + def test_routes_rho_by_identity(self): - model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + model = self.make_model([self.obs1, self.obs2]) # params = [a0, a1, log_rho_0, log_rho_1] self.assertEqual(model.n_params, 4) + self.assertEqual( + [p.name for p in model.params], ["a0", "a1", "log_rho_0", "log_rho_1"] + ) mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) - np.testing.assert_allclose(model.evaluate(self.obs1, *mp), [2.0, 4.0, 6.0]) - np.testing.assert_allclose(model.evaluate(self.obs2, *mp), [4.0, 8.0, 12.0]) + np.testing.assert_allclose(model(self.obs1, *mp), [2.0, 4.0, 6.0]) + np.testing.assert_allclose(model(self.obs2, *mp), [4.0, 8.0, 12.0]) + + def test_linear_prefix(self): + t = per_observation_scaling([self.obs1, self.obs2], log=False) + self.assertEqual([p.name for p in t.params], ["rho_0", "rho_1"]) + model = Polynomial(order=1, transform=t) + np.testing.assert_allclose( + model(self.obs2, 0.0, 2.0, 1.0, 3.0), [6.0, 12.0, 18.0] + ) def test_shared_across_constraints_in_evidence(self): - model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + model = self.make_model([self.obs1, self.obs2]) c1 = Constraint([self.obs1], model) c2 = Constraint([self.obs2], model) ev = Evidence([c1, c2]) # all constraints share one model instance @@ -162,19 +175,18 @@ def test_holds_observation_references(self): # garbage-collected observation's id can never be recycled import gc - model = PerObservationScaledModel(self.base, [self.obs1, self.obs2]) + model = self.make_model([self.obs1, self.obs2]) gc.collect() - self.assertIs(model.observations[0], self.obs1) - self.assertIs(model.observations[1], self.obs2) + self.assertIs(model.transform.observations[0], self.obs1) mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) np.testing.assert_allclose( - model.evaluate(model.observations[0], *mp), [2.0, 4.0, 6.0] + model(model.transform.observations[0], *mp), [2.0, 4.0, 6.0] ) def test_unregistered_observation_raises(self): - model = PerObservationScaledModel(self.base, [self.obs1]) + model = self.make_model([self.obs1]) with self.assertRaises(KeyError): - model.evaluate(self.obs2, 0.0, 1.0, 0.0) + model(self.obs2, 0.0, 1.0, 0.0) class TestSharedParameterCaseB(unittest.TestCase): @@ -421,34 +433,35 @@ def test_include_statistical_term_false_omits_diagonal(self): np.testing.assert_allclose(S, cov) -class TestScaledModel(unittest.TestCase): - def test_scale_applied_and_params_prepended(self): - from rxmc.physical_model import ScaledModel - +class TestScaleTransform(unittest.TestCase): + def test_scale_applied_and_params_appended(self): base = Polynomial(order=1) obs = Observation( np.array([1.0, 2.0, 3.0]), np.array([2.0, 4.0, 6.0]), y_stat_err=np.array([0.1, 0.1, 0.1]), ) - model = ScaledModel(base) + model = Polynomial(order=1, transform=scale()) self.assertEqual(model.n_params, 3) - self.assertEqual(model.params[0].name, "log normalization") + self.assertEqual(model.params[-1].name, "log_rho") np.testing.assert_allclose( - model.evaluate(obs, np.log(2.0), 0.0, 2.0), - 2.0 * base.evaluate(obs, 0.0, 2.0), + model(obs, 0.0, 2.0, np.log(2.0)), + 2.0 * base(obs, 0.0, 2.0), ) + # evaluate() is physical space only + np.testing.assert_allclose(model.evaluate(obs, 0.0, 2.0), base(obs, 0.0, 2.0)) def test_linear_scale(self): - from rxmc.params import Parameter - from rxmc.physical_model import ScaledModel - base = Polynomial(order=0) obs = Observation(np.array([1.0, 2.0]), np.array([3.0, 3.0])) - model = ScaledModel(base, scale_parameter=Parameter("rho"), log=False) - np.testing.assert_allclose( - model.evaluate(obs, 1.5, 4.0), 1.5 * base.evaluate(obs, 4.0) - ) + model = Polynomial(order=0, transform=scale(Parameter("rho"), log=False)) + np.testing.assert_allclose(model(obs, 4.0, 1.5), 1.5 * base(obs, 4.0)) + + def test_wrong_param_count_raises(self): + model = Polynomial(order=0, transform=scale()) + obs = Observation(np.array([1.0]), np.array([1.0])) + with self.assertRaises(ValueError): + model(obs, 1.0) class TestMask(unittest.TestCase): @@ -642,5 +655,41 @@ def test_x_dependent_constant_term_in_constraint(self): np.testing.assert_allclose(S, cov) +class TestMaskWithPerObservationScaling(unittest.TestCase): + """Masked views keep routing to their root observation's rho.""" + + def setUp(self): + self.x = np.array([1.0, 2.0, 3.0, 4.0]) + self.err = np.full(4, 0.1) + self.obs1 = Observation(self.x, 2.0 * self.x, y_stat_err=self.err) + self.obs2 = Observation(self.x, 6.0 * self.x, y_stat_err=self.err) + self.pm = Polynomial( + order=1, transform=per_observation_scaling([self.obs1, self.obs2]) + ) + self.mp = (0.0, 2.0, 0.0, np.log(3.0)) + + def _reference(self, obs_list, keep): + # a constraint built directly on the same active points; masked views + # share their root's identity so the same transform routes them + return Constraint(obs_list, self.pm, mask=keep).log_likelihood(self.mp) + + def test_masked_view_routes_to_root(self): + c = Constraint([self.obs1, self.obs2], self.pm) + held = c.masked(point_masks=[self.x < 2.5, None]) + ref = self._reference([self.obs1.masked(self.x < 2.5), self.obs2], [True, True]) + self.assertAlmostEqual(held.log_likelihood(self.mp), ref) + + def test_complement_routes_to_root(self): + c = Constraint([self.obs1, self.obs2], self.pm, mask=[True, False]) + comp = c.complement() + self.assertEqual(comp.n_data_pts, 4) + ref = self._reference([self.obs1, self.obs2], [False, True]) + self.assertAlmostEqual(comp.log_likelihood(self.mp), ref) + self.assertAlmostEqual( + c.log_likelihood(self.mp) + comp.log_likelihood(self.mp), + Constraint([self.obs1, self.obs2], self.pm).log_likelihood(self.mp), + ) + + if __name__ == "__main__": unittest.main() From 6e2c3ef05dca0ecbf08fe4035c8603de8fbf412e Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:55:25 -0400 Subject: [PATCH 12/24] Add momentum_transfer and the k property to the elastic observation Expose the entrance-channel wavenumber of an ElasticDifferentialXSObservation and a momentum_transfer helper q = 2 k sin(theta/2) on its data angles, so a kernel_term can be placed in momentum-transfer space (coords=) for the error-model study forms instead of every caller reaching into the jitr workspace. Co-Authored-By: Claude Fable 5 --- src/rxmc/elastic_diffxs_observation.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index 2c53672..87d0d48 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -170,6 +170,11 @@ def __init__( ), ) + @property + def k(self) -> float: + """Entrance-channel wavenumber in fm^-1.""" + return float(self.constraint_workspace.kinematics.k) + @classmethod def from_measurement( cls, @@ -312,3 +317,13 @@ def set_up_solver( ) return constraint_ws, visualization_ws, kinematics + + +def momentum_transfer(observation: ElasticDifferentialXSObservation) -> np.ndarray: + r"""Momentum transfer :math:`q = 2k\sin(\theta/2)` (fm^-1) on the data angles. + + Handy as a fixed coordinate array for a + :func:`~rxmc.covariance.kernel_term` in :math:`q`-space: + ``kernel_term(kernel, coords=lambda x: 2 * obs.k * np.sin(x / 2))``. + """ + return 2.0 * observation.k * np.sin(np.asarray(observation.x, dtype=float) / 2.0) From 8c2d878829cb1ca9920966efdc435dd189aaafd3 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:55:48 -0400 Subject: [PATCH 13/24] Add rxmc.model_comparison for sample-based predictive checks and evidence Provide the model-comparison bookkeeping the error-model study needs without touching a sampler: everything consumes a Constraint plus rows of posterior samples. predictive_draws draws from N(ym(theta), Sigma(theta)) on the active points (or the model-only predictive), coverage_curve / coverage_error / sharpness score calibration and width of those draws, heldout_log_predictive and elpd score a held-out constraint (typically fit.complement()), logz_summary and compare_logz summarise replicate nested-sampling evidences with a conservative tie verdict, log_jacobian supplies the comparison-space constant, and split_samples cuts flat sampler rows into model and per-constraint parameter blocks. Co-Authored-By: Claude Fable 5 --- src/rxmc/__init__.py | 1 + src/rxmc/model_comparison.py | 294 ++++++++++++++++++++++++++++++++++ test/test_model_comparison.py | 177 ++++++++++++++++++++ 3 files changed, 472 insertions(+) create mode 100644 src/rxmc/model_comparison.py create mode 100644 test/test_model_comparison.py diff --git a/src/rxmc/__init__.py b/src/rxmc/__init__.py index 4f7edc5..46b2256 100644 --- a/src/rxmc/__init__.py +++ b/src/rxmc/__init__.py @@ -9,6 +9,7 @@ from . import ias_pn_observation as ias_pn_observation from . import likelihood_model as likelihood_model from . import metropolis_hastings as metropolis_hastings +from . import model_comparison as model_comparison from . import observation as observation from . import param_sampling as param_sampling from . import params as params diff --git a/src/rxmc/model_comparison.py b/src/rxmc/model_comparison.py new file mode 100644 index 0000000..1d371af --- /dev/null +++ b/src/rxmc/model_comparison.py @@ -0,0 +1,294 @@ +""" +Sampler-agnostic model-comparison and predictive-checking utilities. + +Everything here consumes a :class:`~rxmc.constraint.Constraint` plus posterior +*samples* (rows of model parameters and, optionally, of the constraint's +covariance/likelihood parameters) and never touches a sampler: + +* :func:`predictive_draws` — draws from the posterior predictive + ``N(ym(theta), Sigma(theta))`` on the constraint's active points (or the + model-only predictive ``ym(theta)``). +* :func:`coverage_curve`, :func:`coverage_error`, :func:`sharpness` — empirical + calibration and width of those draws against the data. +* :func:`heldout_log_predictive`, :func:`elpd` — out-of-sample scoring on a + held-out constraint (e.g. ``constraint.complement()``). +* :func:`logz_summary`, :func:`compare_logz` — nested-sampling evidence + bookkeeping with replicate-based errors and a conservative tie verdict. +* :func:`log_jacobian` — the comparison-space Jacobian needed to compare + evidences across residual spaces (e.g. log-y versus linear-y fits). + +Notes +----- +Drawing from ``N(ym, Sigma)`` in a *transformed* comparison space (an +observation with ``transform=log``) yields draws in that space; map them back +with the transform's inverse (``np.exp``) before comparing to raw data. +""" + +from __future__ import annotations + +import numpy as np +import scipy as sc +from scipy.special import logsumexp + +__all__ = [ + "log_jacobian", + "predictive_draws", + "coverage_curve", + "coverage_error", + "sharpness", + "heldout_log_predictive", + "elpd", + "logz_summary", + "compare_logz", + "split_samples", +] + + +def log_jacobian(constraint) -> float: + """Comparison-space log-Jacobian of a constraint (sum over active points). + + ``log Z_raw = log Z_transformed + log_jacobian``: add it to the evidence of a + fit performed in a transformed comparison space (e.g. ``transform=log``) + before comparing with a fit in raw space. Zero for identity transforms. + """ + return float(constraint.log_jacobian) + + +def _psd_factor(Sigma, jitter=1e-10): + """Lower factor ``L`` with ``L L^T = Sigma`` (Cholesky, eigen fallback).""" + try: + return sc.linalg.cholesky(Sigma + jitter * np.eye(len(Sigma)), lower=True) + except np.linalg.LinAlgError: + w, V = np.linalg.eigh(Sigma) + return V * np.sqrt(np.clip(w, 0.0, None)) + + +def _rows(samples, n): + samples = np.asarray(samples, dtype=float) + if samples.ndim == 1: + samples = samples[:, None] + if samples.shape[0] != n: + raise ValueError(f"expected {n} sample rows, got {samples.shape[0]}") + return samples + + +def predictive_draws( + constraint, + model_samples, + cov_samples=None, + *, + n_rep: int = 1, + rng=None, + model_only: bool = False, +) -> np.ndarray: + """Posterior-predictive draws on the constraint's active points. + + For each posterior row ``theta_i`` the constraint gives ``ym_i`` and + ``Sigma_i``; ``n_rep`` draws ``ym_i + L_i z`` (``z ~ N(0, I)``) are taken. + With ``model_only=True`` the rows are ``ym_i`` (the model-only predictive, + no error-model noise). + + Parameters + ---------- + constraint : Constraint + The constraint whose predictive is wanted (its active points). + model_samples : array_like, shape (n, n_model_params) + Posterior samples of the physical-model parameters. + cov_samples : array_like, shape (n, constraint.n_params), optional + Matching samples of the constraint's parameters (required when the + constraint has any). + n_rep : int, optional + Draws per posterior row (ignored when ``model_only``). + rng : numpy.random.Generator, optional + model_only : bool, optional + + Returns + ------- + np.ndarray, shape (n * n_rep, n_data_pts) + Draws in the observations' comparison space. + """ + rng = np.random.default_rng() if rng is None else rng + model_samples = _rows(model_samples, len(np.asarray(model_samples))) + n = model_samples.shape[0] + if constraint.n_params: + if cov_samples is None: + raise ValueError("constraint has parameters; pass cov_samples") + cov_samples = _rows(cov_samples, n) + else: + cov_samples = np.zeros((n, 0)) + + N = constraint.n_data_pts + if model_only: + out = np.empty((n, N)) + for i in range(n): + ym, _ = constraint.predict_and_covariance( + tuple(model_samples[i]), tuple(cov_samples[i]) + ) + out[i] = ym + return out + + out = np.empty((n * n_rep, N)) + for i in range(n): + ym, Sigma = constraint.predict_and_covariance( + tuple(model_samples[i]), tuple(cov_samples[i]) + ) + L = _psd_factor(Sigma) + z = rng.standard_normal((n_rep, N)) + out[i * n_rep : (i + 1) * n_rep] = ym + z @ L.T + return out + + +def coverage_curve(draws, y, levels=None) -> np.ndarray: + """Empirical coverage of central predictive intervals at each nominal level. + + Parameters + ---------- + draws : array_like, shape (n_draws, n_pts) + y : array_like, shape (n_pts,) + The data the draws are checked against (same space as ``draws``). + levels : array_like, optional + Nominal central-interval probabilities in (0, 1). Defaults to + ``np.linspace(0.02, 0.98, 49)``. + + Returns + ------- + np.ndarray + Fraction of points inside the central ``level`` interval, per level. + """ + draws = np.asarray(draws, dtype=float) + y = np.asarray(y, dtype=float) + levels = np.linspace(0.02, 0.98, 49) if levels is None else np.asarray(levels) + out = np.empty(len(levels)) + for i, lv in enumerate(levels): + lo, hi = np.percentile(draws, [50 * (1 - lv), 50 * (1 + lv)], axis=0) + out[i] = np.mean((y >= lo) & (y <= hi)) + return out + + +def coverage_error(draws, y, levels=None) -> float: + """``max |coverage(level) - level|`` — a single calibration score.""" + levels = np.linspace(0.02, 0.98, 49) if levels is None else np.asarray(levels) + return float(np.max(np.abs(coverage_curve(draws, y, levels) - levels))) + + +def sharpness(draws, levels=(16, 84), transform=None) -> np.ndarray: + """Per-point width of the central predictive interval. + + Parameters + ---------- + draws : array_like, shape (n_draws, n_pts) + levels : (float, float), optional + Percentiles of the interval; default the central 68 %. + transform : callable, optional + Applied to the draws first (e.g. ``np.exp`` to report widths in raw + space for a log comparison space, or ``np.log10``). + """ + draws = np.asarray(draws, dtype=float) + if transform is not None: + draws = transform(draws) + lo, hi = np.percentile(draws, levels, axis=0) + return hi - lo + + +def heldout_log_predictive(heldout_constraint, model_samples, cov_samples=None): + """``log p(y_held | theta_i)`` for each posterior row. + + ``heldout_constraint`` is typically ``fit_constraint.complement()``: the same + observations, terms and parameters, with the held-out points active. The + score is the constraint's own (marginal-block) log likelihood at each + sample. + + Returns + ------- + np.ndarray, shape (n,) + """ + model_samples = _rows(model_samples, len(np.asarray(model_samples))) + n = model_samples.shape[0] + if heldout_constraint.n_params: + if cov_samples is None: + raise ValueError("constraint has parameters; pass cov_samples") + cov_samples = _rows(cov_samples, n) + else: + cov_samples = np.zeros((n, 0)) + return np.array( + [ + heldout_constraint.log_likelihood( + tuple(model_samples[i]), tuple(cov_samples[i]) + ) + for i in range(n) + ] + ) + + +def elpd(logp_samples, logw=None) -> float: + """Expected log predictive density ``log E_post[p(y_held | theta)]``. + + A log-mean-exp over posterior samples; pass ``logw`` (unnormalised log + importance weights, e.g. nested-sampling ``logwt``) for weighted samples. + """ + logp = np.asarray(logp_samples, dtype=float) + if logw is None: + return float(logsumexp(logp) - np.log(len(logp))) + logw = np.asarray(logw, dtype=float) + return float(logsumexp(logp + logw) - logsumexp(logw)) + + +def logz_summary(logz, logzerr): + """Replicate-aware evidence summary. + + Parameters + ---------- + logz, logzerr : array_like + ``log Z`` and its sampler-reported error for each replicate run (one + value each is fine). + + Returns + ------- + (float, float, int) + ``(mean, err, n)`` with ``err = max(half-range across replicates, mean + reported error)`` — the sampler's own error is a lower bound. + """ + logz = np.atleast_1d(np.asarray(logz, dtype=float)) + logzerr = np.atleast_1d(np.asarray(logzerr, dtype=float)) + half_range = 0.5 * (logz.max() - logz.min()) if logz.size > 1 else 0.0 + return float(logz.mean()), float(max(half_range, logzerr.mean())), int(logz.size) + + +def compare_logz(a, b, sigma: float = 2.0) -> dict: + """``Delta log Z = a - b`` with a conservative tie verdict. + + Parameters + ---------- + a, b : (mean, err) or (mean, err, n) + As returned by :func:`logz_summary`. + sigma : float, optional + A difference smaller than ``sigma * hypot(err_a, err_b)`` is a ``"tie"``. + + Returns + ------- + dict + ``{"dlogZ": ..., "err": ..., "verdict": "a" | "b" | "tie"}``. + """ + ma, ea = a[0], a[1] + mb, eb = b[0], b[1] + d = float(ma - mb) + err = float(np.hypot(ea, eb)) + if abs(d) < sigma * err: + verdict = "tie" + else: + verdict = "a" if d > 0 else "b" + return {"dlogZ": d, "err": err, "verdict": verdict} + + +def split_samples(config, samples): + """Split flat sampler rows into ``(model_samples, [cov_samples, ...])``. + + Row-wise :meth:`~rxmc.config.CalibrationConfig.split_parameters`: one + covariance-sample block per parametric constraint, in + ``config.evidence.parametric_constraints`` order. + """ + samples = np.asarray(samples, dtype=float) + if samples.ndim == 1: + samples = samples[None, :] + parts = np.split(samples, config.indices[:-1], axis=1) + return parts[0], parts[1:] diff --git a/test/test_model_comparison.py b/test/test_model_comparison.py new file mode 100644 index 0000000..f6ecfa8 --- /dev/null +++ b/test/test_model_comparison.py @@ -0,0 +1,177 @@ +"""Tests for the sampler-agnostic ``rxmc.model_comparison`` utilities.""" + +import unittest + +import numpy as np +from scipy.special import logsumexp + +from helpers import manual_mvn_loglike +from rxmc.constraint import Constraint +from rxmc.covariance import Term, noise_term +from rxmc.model_comparison import ( + compare_logz, + coverage_curve, + coverage_error, + elpd, + heldout_log_predictive, + log_jacobian, + logz_summary, + predictive_draws, + sharpness, + split_samples, +) +from rxmc.observation import Observation +from rxmc.params import Parameter +from rxmc.physical_model import Polynomial +from rxmc.transforms import log + + +class TestPredictiveDraws(unittest.TestCase): + def setUp(self): + self.pm = Polynomial(order=1) + self.x = np.linspace(0.0, 4.0, 5) + self.y = 1.0 + 2.0 * self.x + self.err = np.full(5, 0.3) + self.obs = Observation(self.x, self.y, y_stat_err=self.err) + + def test_draw_covariance_recovers_sigma(self): + eps = Parameter("log eps") + c = Constraint([self.obs], self.pm, extra_terms=[noise_term(eps)]) + theta = np.array([[1.0, 2.0]]) + cov = np.array([[np.log(0.4)]]) + draws = predictive_draws( + c, theta, cov, n_rep=40000, rng=np.random.default_rng(0) + ) + self.assertEqual(draws.shape, (40000, 5)) + np.testing.assert_allclose(draws.mean(axis=0), self.y, atol=0.02) + S = np.cov(draws.T) + np.testing.assert_allclose(S, np.diag(self.err**2 + 0.16), atol=0.02) + + def test_model_only_returns_ym(self): + c = Constraint([self.obs], self.pm) + theta = np.array([[1.0, 2.0], [0.0, 1.0]]) + d = predictive_draws(c, theta, model_only=True) + np.testing.assert_allclose(d[0], self.y) + np.testing.assert_allclose(d[1], self.x) + + def test_requires_cov_samples_when_parametric(self): + c = Constraint([self.obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) + with self.assertRaises(ValueError): + predictive_draws(c, np.array([[1.0, 2.0]])) + + def test_respects_mask(self): + c = Constraint([self.obs.masked([True, False, True, False, True])], self.pm) + d = predictive_draws( + c, np.array([[1.0, 2.0]]), n_rep=3, rng=np.random.default_rng(1) + ) + self.assertEqual(d.shape, (3, 3)) + + +class TestCoverageSharpness(unittest.TestCase): + def test_coverage_near_nominal_for_matching_draws(self): + rng = np.random.default_rng(0) + n_pts = 2000 + draws = rng.normal(0.0, 1.0, (4000, n_pts)) + y = rng.normal(0.0, 1.0, n_pts) + levels = np.array([0.5, 0.9]) + cov = coverage_curve(draws, y, levels) + np.testing.assert_allclose(cov, levels, atol=0.03) + self.assertLess(coverage_error(draws, y, levels), 0.03) + # overconfident draws under-cover + cov_narrow = coverage_curve(0.3 * draws, y, levels) + self.assertTrue(np.all(cov_narrow < levels - 0.2)) + + def test_sharpness_width(self): + rng = np.random.default_rng(0) + draws = rng.normal(0.0, 1.0, (20000, 3)) + w = sharpness(draws) + np.testing.assert_allclose(w, 2 * 0.9945, atol=0.05) + w_exp = sharpness(np.zeros((10, 2)), transform=np.exp) + np.testing.assert_allclose(w_exp, 0.0) + + +class TestHeldout(unittest.TestCase): + def test_heldout_log_predictive_matches_manual(self): + pm = Polynomial(order=1) + x = np.array([1.0, 2.0, 3.0, 4.0]) + y = np.array([3.1, 4.8, 7.2, 9.1]) + err = np.array([0.2, 0.2, 0.3, 0.3]) + obs = Observation(x, y, y_stat_err=err).masked_where(lambda x: x < 2.5) + fit = Constraint( + [obs], pm, extra_terms=[Term(np.array(0.1 * np.ones(4)), kind="diag")] + ) + held = fit.complement() + samples = np.array([[1.0, 2.0], [1.2, 1.9]]) + lp = heldout_log_predictive(held, samples) + for i, (a0, a1) in enumerate(samples): + ym = a0 + a1 * x[2:] + cov = np.diag(err[2:] ** 2 + 0.01) + self.assertAlmostEqual(lp[i], manual_mvn_loglike(y[2:], ym, cov)) + + def test_elpd(self): + lp = np.array([-1.0, -2.0, -0.5]) + self.assertAlmostEqual(elpd(lp), logsumexp(lp) - np.log(3)) + logw = np.array([0.0, -np.inf, 0.0]) + self.assertAlmostEqual(elpd(lp, logw), logsumexp(lp[[0, 2]]) - np.log(2)) + + +class TestLogZ(unittest.TestCase): + def test_summary_single_and_replicates(self): + m, e, n = logz_summary([-10.0], [0.3]) + self.assertEqual((m, e, n), (-10.0, 0.3, 1)) + m, e, n = logz_summary([-10.0, -12.0], [0.3, 0.3]) + self.assertEqual((m, e, n), (-11.0, 1.0, 2)) # half-range dominates + m, e, n = logz_summary([-10.0, -10.2], [0.5, 0.5]) + self.assertAlmostEqual(e, 0.5) # reported error dominates + + def test_compare(self): + r = compare_logz((-10.0, 0.5), (-15.0, 0.5)) + self.assertEqual(r["verdict"], "a") + self.assertAlmostEqual(r["dlogZ"], 5.0) + self.assertAlmostEqual(r["err"], np.hypot(0.5, 0.5)) + self.assertEqual(compare_logz((-15.0, 0.5), (-10.0, 0.5))["verdict"], "b") + self.assertEqual(compare_logz((-10.0, 1.0), (-11.0, 1.0))["verdict"], "tie") + + def test_log_jacobian(self): + y = np.array([2.0, 3.0]) + obs = Observation(np.array([0.0, 1.0]), y, transform=log) + c = Constraint( + [obs], Polynomial(order=0), extra_terms=[noise_term(Parameter("e"))] + ) + self.assertAlmostEqual(log_jacobian(c), -np.sum(np.log(y))) + + +class TestSplitSamples(unittest.TestCase): + def test_split_rows(self): + from scipy import stats + + from rxmc.config import CalibrationConfig, ParameterConfig + from rxmc.evidence import Evidence + from rxmc.priors import IndependentPrior + + pm = Polynomial(order=1) + obs = Observation( + np.arange(4.0), 1.0 + 2.0 * np.arange(4.0), y_stat_err=np.full(4, 0.1) + ) + eps = Parameter("log eps") + c = Constraint([obs], pm, extra_terms=[noise_term(eps)]) + ev = Evidence([c]) + mprior = IndependentPrior([stats.norm(0, 1), stats.norm(0, 1)]) + lprior = IndependentPrior([stats.norm(-2, 1)]) + config = CalibrationConfig( + ev, + ParameterConfig(pm.params, mprior, mprior), + [ParameterConfig(list(c.params), lprior, lprior)], + ) + samples = np.array([[1.0, 2.0, -1.0], [0.5, 1.5, -2.0]]) + m, covs = split_samples(config, samples) + np.testing.assert_allclose(m, samples[:, :2]) + self.assertEqual(len(covs), 1) + np.testing.assert_allclose(covs[0], samples[:, 2:]) + # single row + m1, _ = split_samples(config, samples[0]) + self.assertEqual(m1.shape, (1, 2)) + + +if __name__ == "__main__": + unittest.main() From 4a123bff48be92711616e02a16b17801c93c144b Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:57:10 -0400 Subject: [PATCH 14/24] Update README, design doc and API reference for the transform/mask/Term API Rewrite the covariance section of the README and docs/design.md around the single generic Term (kind table, support=None, coords, the factory helpers and bases), add sections on comparison-space and model transforms, point masks and held-out complements, and the sampler-free model-comparison module, and record the error-model recipes the API was generalised for. The API reference gains the transforms and model_comparison modules and the new covariance helpers, and drops the removed term classes, ScaledModel classes and discrepancy_term. The README notes the jitr>=3.0 / Python 3.12 requirement. Co-Authored-By: Claude Fable 5 --- README.md | 61 +++++++++++++++----- docs/api.rst | 67 ++++++++++++++++----- docs/design.md | 154 ++++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 226 insertions(+), 56 deletions(-) diff --git a/README.md b/README.md index 3fe0e2c..5205b82 100644 --- a/README.md +++ b/README.md @@ -35,10 +35,13 @@ obs = rxmc.observation.Observation( # a constraint owns one multivariate likelihood over its stacked observations; # every correlated mode is an explicit covariance term - nothing is folded in -# silently -(support,) = rxmc.covariance.stacked_supports([obs]) +# silently. Here: the reported normalisation systematic plus an unknown +# constant noise inferred alongside the model +log_eps = rxmc.params.Parameter("log_eps") constraint = rxmc.constraint.Constraint( - [obs], model, extra_terms=obs.systematic_terms(support) + [obs], + model, + extra_terms=[*obs.systematic_terms(), rxmc.covariance.noise_term(log_eps)], ) evidence = rxmc.evidence.Evidence([constraint]) @@ -62,7 +65,12 @@ walker.walk(n_steps=10_000, burnin=1_000, batch_size=1_000) > reported systematic errors are never folded into the covariance > automatically. The default constraint covariance is the statistical diagonal > only; systematics enter explicitly, e.g. via -> `obs.systematic_terms(support)` passed to `Constraint(extra_terms=...)`. +> `obs.systematic_terms()` passed to `Constraint(extra_terms=...)`. + +> **Note — jitr:** this version requires +> [jitr](https://github.com/beykyle/lagrange-rmatrix) ≥ 3.0 (workspaces take +> potential *arrays* on `ws.radial_grid()`); `requirements.txt` pins +> `jitr>=3.0` from PyPI. Python ≥ 3.12. ## Installation @@ -156,31 +164,45 @@ for: Pure measured data — `x`, `y`, and the statistical error on `y` — plus the measurement's reported systematic magnitudes retained as inert metadata (`y_sys_err_normalization`, `y_sys_err_offset`). It contributes only its -statistical diagonal by default; `obs.systematic_terms(support)` turns the +statistical diagonal by default; `obs.systematic_terms()` turns the metadata into explicit covariance terms when you ask. +An observation also owns its **comparison space**: `Observation(x, y, +transform=rxmc.transforms.log)` takes raw `y`, compares in log space (errors +propagated by the delta method) and the constraint transforms the model +prediction to match. A point-level `mask` (or `obs.masked_where(...)`) selects +which points enter a likelihood — fit/held-out splits without rebuilding +anything. + ### `PhysicalModel` Maps model parameters to predicted observables for a given `Observation`. -`ScaledModel` / `PerObservationScaledModel` wrap any model with latent -normalization parameters (Kennedy–O'Hagan style). +A parametric `transform=` (e.g. `rxmc.transforms.scale()` or +`per_observation_scaling(observations)`) adds latent normalization parameters +(Kennedy–O'Hagan style) to any model. ### Covariance `Term`s (`rxmc.covariance`) Every uncertainty beyond the statistical diagonal is an explicit additive -contribution to the constraint's stacked covariance. Factory helpers cover the -common modes: - -- `normalization_term` / `offset_term` — correlated systematics, fixed - magnitude or free nuisance, -- `noise_term` / `noise_fraction_term` — unknown statistical noise, +contribution to the constraint's stacked covariance. There is one generic +`Term(fn, params, kind=...)` — `fn` is a numpy-style callable of the term's +local `x`/`y`/`ym` and its parameters, `kind` is `"diag"`, `"mode"` or +`"matrix"`, and an optional `coords` transform changes the coordinate the term +lives in. Factory helpers cover the common modes in one line: + +- `normalization_term` / `offset_term` / `systematic_term` — correlated + modes, fixed magnitude or free nuisance, prediction-, unit- or user-basis + scaled, +- `noise_term` / `noise_fraction_term` — unknown statistical noise (with an + optional parametric basis, e.g. noise growing with angle), - `model_error_term` — uncorrelated model error, -- `discrepancy_term` — Gaussian-process model discrepancy using sklearn - kernels. +- `kernel_term` — Gaussian-process model discrepancy using sklearn kernels, + optionally in transformed coordinates and with a parametric amplitude. A term whose support spans several observations *couples* them (correlated datasets); referencing the same `Parameter` object in two terms *shares* one -sampled value between them. +sampled value between them. `support=None` (the default) means the whole +constraint. ### Likelihood functionals @@ -198,6 +220,13 @@ a covariance assembled from terms, and a likelihood functional. Aggregates multiple independent constraints that share the same physical-model parameterization. +### Model comparison (`rxmc.model_comparison`) + +Sampler-agnostic posterior-predictive draws, coverage/sharpness checks, +held-out scoring on `constraint.complement()`, and log-evidence bookkeeping +(`logz_summary`, `compare_logz`, `log_jacobian` for comparing fits done in +different comparison spaces). + ## Examples and tutorials The `examples/` directory contains richer notebooks and demos. The most useful diff --git a/docs/api.rst b/docs/api.rst index 0940a4d..dcfb8b3 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -41,36 +41,55 @@ Core building blocks rxmc.params.Parameter rxmc.physical_model.PhysicalModel rxmc.physical_model.Polynomial - rxmc.physical_model.ScaledModel - rxmc.physical_model.PerObservationScaledModel + +Transforms +---------- + +One low-level, numpy-style transform type shared by observations (the +comparison space, e.g. ``transform=log``), models (parametric transforms such +as a latent normalisation) and covariance terms (coordinate transforms). + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + rxmc.transforms.Transform + rxmc.transforms.as_transform + rxmc.transforms.scale + rxmc.transforms.per_observation_scaling Covariance terms ---------------- The stacked covariance of a :class:`~rxmc.constraint.Constraint` is assembled -additively from :class:`~rxmc.covariance.Term` objects. The factory helpers -are the primary authoring API; the term primitives underneath are available for -custom modes. Context-dependent terms and basis callables receive a -``StackContext`` bundling the stacked ``x``/``y``/``ym`` arrays and block -supports (see the :mod:`rxmc.covariance` module docstring). +additively from :class:`~rxmc.covariance.Term` objects — a single generic type: +a numpy-style callable of a :class:`~rxmc.covariance.TermContext` (the term's +local ``x``/``y``/``ym``) and its parameters, plus a ``kind`` +(``"diag"``/``"mode"``/``"matrix"``). The factory helpers build the common +terms in one line; anything else is a direct ``Term(fn, params, kind=...)``. .. autosummary:: :toctree: generated/ :nosignatures: + rxmc.covariance.Term + rxmc.covariance.TermContext rxmc.covariance.statistical_term rxmc.covariance.normalization_term rxmc.covariance.offset_term rxmc.covariance.noise_term rxmc.covariance.noise_fraction_term rxmc.covariance.model_error_term - rxmc.covariance.discrepancy_term + rxmc.covariance.systematic_term + rxmc.covariance.kernel_term + rxmc.covariance.ones + rxmc.covariance.ym + rxmc.covariance.averaging + rxmc.covariance.x_basis + rxmc.covariance.exp_growth + rxmc.covariance.constant_amplitude + rxmc.covariance.exp_growth_amplitude rxmc.covariance.stacked_supports - rxmc.covariance.Term - rxmc.covariance.DenseTerm - rxmc.covariance.DiagonalTerm - rxmc.covariance.RankOneTerm - rxmc.covariance.KernelTerm rxmc.covariance.ConstraintCovariance Likelihood functionals @@ -105,6 +124,27 @@ propagation. rxmc.predictive.gp_posterior_predictive rxmc.predictive.total_predictive_band +Model comparison +---------------- + +Sampler-agnostic posterior-predictive checks, held-out scoring, and +nested-sampling evidence bookkeeping. + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + rxmc.model_comparison.predictive_draws + rxmc.model_comparison.coverage_curve + rxmc.model_comparison.coverage_error + rxmc.model_comparison.sharpness + rxmc.model_comparison.heldout_log_predictive + rxmc.model_comparison.elpd + rxmc.model_comparison.logz_summary + rxmc.model_comparison.compare_logz + rxmc.model_comparison.log_jacobian + rxmc.model_comparison.split_samples + Sampling -------- @@ -145,6 +185,7 @@ cross sections and isobaric-analog (p,n) cross sections. :nosignatures: rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation + rxmc.elastic_diffxs_observation.momentum_transfer rxmc.elastic_diffxs_model.ElasticDifferentialXSModel rxmc.ias_pn_observation.IsobaricAnalogPNObservation rxmc.ias_pn_model.IsobaricAnalogPNXSModel diff --git a/docs/design.md b/docs/design.md index ba360d4..7439c55 100644 --- a/docs/design.md +++ b/docs/design.md @@ -38,22 +38,43 @@ correlated-systematics distinction. ## Terms and the assembled covariance -A {class}`~rxmc.covariance.Term` is one additive contribution to the stacked -covariance: it carries a `support` (indices into the stacked vector), the -`Parameter`s it consumes, and writes its block via `add_to(Sigma, ctx, theta)`. -Context-dependent terms receive a `StackContext` bundling the stacked -`x`/`y`/`ym` and the block supports, so modes can be prediction-scaled -(`ctx.ym[support]`) or coordinate-dependent (kernels). - -The primitives — {class}`~rxmc.covariance.DenseTerm` (fixed block, validated -for shape and symmetry), {class}`~rxmc.covariance.DiagonalTerm`, -{class}`~rxmc.covariance.RankOneTerm`, and -{class}`~rxmc.covariance.KernelTerm` (sklearn kernels; one parameter per free -hyperparameter *element*, so anisotropic kernels contribute -`len(kernel.theta)` parameters) — are wrapped by the factory helpers that form -the primary authoring API: `statistical_term`, `normalization_term`, -`offset_term`, `noise_term`, `noise_fraction_term`, `model_error_term`, and -`discrepancy_term`. +There is exactly one term type. A {class}`~rxmc.covariance.Term` is a +numpy-style callable `fn(c, *values) -> array` of a +{class}`~rxmc.covariance.TermContext` `c` — the term's local view of the +stacked `x`, `y` and `ym` on its `support` — and the sampled values of the +`Parameter`s it declares, plus a `kind` saying how the array enters the +covariance: + +| `kind` | `fn` returns | contribution | +|------------|-------------------------------|---------------------------------| +| `"diag"` | standard-deviation vector `v` | `Σ_ii += v_i²` | +| `"mode"` | mode vector `v` | `Σ += v vᵀ` (one correlated mode) | +| `"matrix"` | symmetric block `M` | `Σ_block += M` | + +A plain array instead of `fn` is a fixed contribution (factored once and +cached). `support=None` (the default) means *the whole constraint* and is +bound when the term is added to a `ConstraintCovariance`; an explicit support +places a term on a subset of a multi-observation constraint. A `coords` +transform (see below) is applied to `x[support]` before `fn` sees it, so a +kernel can live in momentum transfer rather than angle without the term +knowing. + +The factory helpers are one-line conveniences over this single type: +`statistical_term`, `normalization_term`, `offset_term`, `noise_term`, +`noise_fraction_term`, `model_error_term`, `systematic_term` (a mode with a +user basis), and `kernel_term` (sklearn kernels; one parameter per free +hyperparameter *element*, plus an optional parametric `amplitude` so that +`Σ += a aᵀ ∘ K`). Bases are ordinary callables of the `TermContext` +(`ones`, `ym`, `averaging`, `x_basis(scale)`, or parametric ones like +`exp_growth(scale)` whose extra parameters are passed as `basis_params`). +Anything the helpers cannot say is a direct `Term`: + +```python +# noise growing with angle: sigma(theta) = eps * exp(l * theta / pi) +Term(lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (log_eps, slope), kind="diag") +# the same thing through the helper +noise_term(log_eps, basis=exp_growth(np.pi), basis_params=(slope,)) +``` {class}`~rxmc.covariance.ConstraintCovariance` assembles the terms. It is constructed with the true observation block boundaries @@ -61,9 +82,9 @@ constructed with the true observation block boundaries decided **once, conservatively**: - `block_diagonal` — true only if every off-diagonal-capable term - (`couples_offdiagonal`) provably sits inside a single block. With no blocks - supplied, any coupling-capable term forces the dense path; there is no - guessing from support shape. + (`couples_offdiagonal`, i.e. `kind != "diag"`) provably sits inside a single + block. With no blocks supplied, any coupling-capable term forces the dense + path; there is no guessing from support shape. - `is_constant` — true when no term depends on parameters or context; the Cholesky factors (dense and per-block) are then computed once and cached read-only. @@ -73,6 +94,46 @@ the block-diagonal fast path (factor each block separately, `O(Σ nᵢ³)`) and single dense Cholesky — and is the seam where a future low-rank (Woodbury) path would slot in. +## Transforms are one low-level type + +{class}`~rxmc.transforms.Transform` is a numpy-style callable +`fn(a, *values)` with an optional tuple of `Parameter`s, an optional analytic +derivative and inverse, and composition via `|`. Anything callable is accepted +wherever a transform is expected. The same type serves three roles, so there +is no wrapper class per use: + +- **Comparison space, on the observation.** `Observation(x, y, + transform=log)` takes *raw* `y`, stores `y_raw`, `y = log(y_raw)`, and the + delta-method statistical error `|t′(y_raw)|·σ`; the `Constraint` applies the + same transform to the model prediction, so the model is written once, in + physical space, and can never be double-transformed. `obs.log_jacobian` + (`Σ log|t′|`) is the constant needed to compare evidences across comparison + spaces. Parametric transforms are rejected here. +- **Parametric model transforms, on the model.** `PhysicalModel(params, + transform=scale())` appends the transform's parameters to the model's and + applies it after `evaluate`. This is the Kennedy–O'Hagan latent scale ρ (it + changes the *mean*, so it is not a covariance term); + `per_observation_scaling(observations)` gives one ρᵢ per dataset, routed by + observation identity. +- **Coordinates, on a term.** `Term(..., coords=q)` / `kernel_term(kernel, + coords=q)` evaluate the term in transformed coordinates; a parametric + `coords` contributes its parameters to the term. + +## Masks: hold-out as part of support + +Which points *enter* a likelihood is a property of the support machinery, not +of the data: `Observation(..., mask=)` (or `obs.masked(mask)`, +`obs.masked_where(lambda x: x < cut)`) marks points active at the point level +without rebuilding anything — a reaction observation keeps its solver +workspace — and `Constraint(..., mask=)` selects observations at the +constraint level. The two combine into `constraint.active`, the stacked +indices the residual and the factorisation are restricted to; `n_data_pts` is +the active count. Terms are always authored over the full stack, so the same +term list describes the fit and the held-out views: `constraint.complement()` +is the held-out counterpart (every inactive point becomes active), sharing the +`Term`/`Parameter` objects so a posterior sample of the fit scores it directly +(see {mod}`rxmc.model_comparison`). + ## Observations are leaves An {class}`~rxmc.observation.Observation` is pure data — `x`, `y`, @@ -80,7 +141,8 @@ An {class}`~rxmc.observation.Observation` is pure data — `x`, `y`, as **inert metadata** (`y_sys_err_normalization` fractional, `y_sys_err_offset` absolute in internal units). It emits only its statistical diagonal automatically. Every correlated mode is an explicit term: -`obs.systematic_terms(support)` converts the metadata on request, and +`obs.systematic_terms()` converts the metadata on request (propagated to the +comparison space by the delta method when the observation has a transform), and **nothing is ever folded into a covariance silently** — a deliberate behavior change from pre-0.1 versions, pinned by regression tests. @@ -93,7 +155,7 @@ through untouched. ## Constraints, likelihood functionals, and parameters `Constraint(observations, physical_model, likelihood=GaussianLikelihood(), -extra_terms=(), include_statistical_term=True)` builds the stacked covariance +extra_terms=(), include_statistical_term=True, mask=None)` builds the stacked covariance from each observation's statistical term plus the explicit `extra_terms` (`include_statistical_term=False` composes the entire covariance from `extra_terms`, e.g. to let a `noise_term` *replace* reported statistics). @@ -107,10 +169,44 @@ parameters (e.g. Student-t `nu`) — and every method (`log_likelihood`, `chi2`, validating the count. Mean renormalization (a Kennedy–O'Hagan latent scale ρ) is **not** a -covariance term: it changes the mean, so it lives on the model side as -{class}`~rxmc.physical_model.ScaledModel` / -{class}`~rxmc.physical_model.PerObservationScaledModel`, flowing through the -ordinary model-parameter machinery. +covariance term: it changes the mean, so it lives on the model side as a +parametric transform (`PhysicalModel(..., transform=rxmc.transforms.scale())` +or `per_observation_scaling(observations)`), flowing through the ordinary +model-parameter machinery. + +## Model comparison lives outside the sampler + +{mod}`rxmc.model_comparison` consumes a constraint plus posterior *samples* and +never touches a sampler: posterior-predictive draws from `N(ym(θ), Σ(θ))` on +the active points (or the model-only predictive), empirical coverage curves and +sharpness, held-out log predictive scores on `constraint.complement()`, and +nested-sampling evidence bookkeeping (`logz_summary` with replicate-based +errors — the sampler's own error is a lower bound — and `compare_logz` with a +conservative tie verdict). `log_jacobian` supplies the comparison-space +constant for comparing evidences of, say, a log-space and a linear-space fit +of the same data. + +## Error-model recipes + +The motivating study — comparing error models for α+Ca elastic scattering data +without reported uncertainties — becomes one term list per model: + +| error model | `extra_terms` | +|----------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------| +| constant noise (log space) | `[noise_term(log_err)]` with `Observation(..., transform=log)` | +| fractional noise (linear space) | `[noise_fraction_term(log_err)]` | +| noise growing with angle | `[noise_term(log_err, basis=exp_growth(np.pi), basis_params=(slope,))]` | +| + rank-one mode ∝ θ | `[..., systematic_term(log_sys, basis=x_basis(np.pi))]` | +| + rank-one offset / normalisation | `[..., offset_term(parameter=log_sys)]` / `[..., normalization_term(parameter=log_sys)]` | +| GP discrepancy in angle, constant amplitude | `[..., kernel_term(Matern(1.0, nu=2.5), coords=lambda x: x/np.pi, amplitude=constant_amplitude, amplitude_params=(log_A,))]` | +| GP with angle-growing amplitude | `[..., kernel_term(..., amplitude=exp_growth_amplitude(1.0), amplitude_params=(log_A, slope))]` | +| GP in momentum transfer with amplitude `A q^{r/2}` | `[..., kernel_term(RBF(1.0), coords=lambda x: 2*k*np.sin(x/2), amplitude=lambda c, lA, r: np.exp(lA)*c.x**(r/2), amplitude_params=(log_A, r))]` | +| heavy tails | any of the above with `likelihood=StudentT()` | + +Fit/held-out splits are `obs.masked_where(lambda x: x < cut)` and +`constraint.complement()`; evidences are compared with +`compare_logz(logz_summary(...), logz_summary(...))` after adding +`log_jacobian` to the log-space fits. ## Scope decisions (locked) @@ -139,5 +235,9 @@ ordinary model-parameter machinery. - **Non-constant block-diagonal covariances still assemble the dense `N×N` matrix** before factoring its blocks (per-term `add_to` writes into the full matrix by design). -- Masked/multi-mode systematics on `Observation` are deferred; the factory - helpers accept a `mask=` argument directly for masked terms. +- **Masked rows are still assembled.** The full `N×N` covariance is built and + then restricted to the active rows; a held-out view pays for the inactive + rows' terms (cheap next to the forward model, but not free for large dense + kernels). +- Multi-mode systematics on `Observation` are deferred; the factory helpers + accept a `mask=` argument directly for masked (partial-support) terms. From d7e0bd122396f1b3c15c38296f43cd45db37c99d Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 13:57:10 -0400 Subject: [PATCH 15/24] Stop tracking Sphinx autosummary stubs docs/generated/ is pure build output: docs/conf.py sets autosummary_generate = True, so Sphinx rewrites every stub on each build and `make clean` deletes the directory. Keeping them under version control meant every API change churned dozens of generated files (this refactor alone added 24, deleted 7 and modified 12). Ignore the directory and drop the tracked copies. Co-Authored-By: Claude Fable 5 --- .gitignore | 1 + ...daptive_metropolis.adaptive_metropolis.rst | 6 --- .../rxmc.config.CalibrationConfig.rst | 41 ------------------- .../generated/rxmc.config.ParameterConfig.rst | 25 ----------- docs/generated/rxmc.constraint.Constraint.rst | 29 ------------- .../rxmc.covariance.ConstraintCovariance.rst | 33 --------------- docs/generated/rxmc.covariance.DenseTerm.rst | 32 --------------- .../rxmc.covariance.DiagonalTerm.rst | 32 --------------- docs/generated/rxmc.covariance.KernelTerm.rst | 32 --------------- .../generated/rxmc.covariance.RankOneTerm.rst | 32 --------------- docs/generated/rxmc.covariance.Term.rst | 32 --------------- .../rxmc.covariance.discrepancy_term.rst | 6 --- .../rxmc.covariance.model_error_term.rst | 6 --- .../rxmc.covariance.noise_fraction_term.rst | 6 --- docs/generated/rxmc.covariance.noise_term.rst | 6 --- .../rxmc.covariance.normalization_term.rst | 6 --- .../generated/rxmc.covariance.offset_term.rst | 6 --- .../rxmc.covariance.stacked_supports.rst | 6 --- .../rxmc.covariance.statistical_term.rst | 6 --- ...iffxs_model.ElasticDifferentialXSModel.rst | 24 ----------- ...ation.ElasticDifferentialXSObservation.rst | 27 ------------ docs/generated/rxmc.evidence.Evidence.rst | 24 ----------- ...c.ias_pn_model.IsobaricAnalogPNXSModel.rst | 24 ----------- ...bservation.IsobaricAnalogPNObservation.rst | 26 ------------ docs/generated/rxmc.likelihood_model.Chi2.rst | 31 -------------- ...mc.likelihood_model.GaussianLikelihood.rst | 31 -------------- .../rxmc.likelihood_model.Likelihood.rst | 31 -------------- .../rxmc.likelihood_model.StudentT.rst | 31 -------------- .../rxmc.likelihood_model.log_likelihood.rst | 6 --- ...odel.mahalanobis_distance_sqr_cholesky.rst | 6 --- ...etropolis_hastings.metropolis_hastings.rst | 6 --- .../rxmc.observation.Observation.rst | 25 ----------- ...ram_sampling.AdaptiveMetropolisSampler.rst | 27 ------------ ...pling.BatchedAdaptiveMetropolisSampler.rst | 27 ------------ ...ram_sampling.MetropolisHastingsSampler.rst | 27 ------------ .../generated/rxmc.param_sampling.Sampler.rst | 27 ------------ docs/generated/rxmc.params.Parameter.rst | 22 ---------- ...ysical_model.PerObservationScaledModel.rst | 23 ----------- .../rxmc.physical_model.PhysicalModel.rst | 23 ----------- .../rxmc.physical_model.Polynomial.rst | 23 ----------- .../rxmc.physical_model.ScaledModel.rst | 23 ----------- ...xmc.predictive.gp_posterior_predictive.rst | 6 --- .../rxmc.predictive.predictive_band.rst | 6 --- .../rxmc.predictive.total_predictive_band.rst | 6 --- .../rxmc.priors.IndependentPrior.rst | 25 ----------- .../rxmc.priors.TruncatedNormalPrior.rst | 25 ----------- ...roposal.HalfNormalProposalDistribution.rst | 22 ---------- ...sal.LogspaceNormalProposalDistribution.rst | 22 ---------- ...mc.proposal.NormalProposalDistribution.rst | 22 ---------- .../rxmc.proposal.ProposalDistribution.rst | 22 ---------- docs/generated/rxmc.walker.Walker.rst | 28 ------------- 51 files changed, 1 insertion(+), 1040 deletions(-) delete mode 100644 docs/generated/rxmc.adaptive_metropolis.adaptive_metropolis.rst delete mode 100644 docs/generated/rxmc.config.CalibrationConfig.rst delete mode 100644 docs/generated/rxmc.config.ParameterConfig.rst delete mode 100644 docs/generated/rxmc.constraint.Constraint.rst delete mode 100644 docs/generated/rxmc.covariance.ConstraintCovariance.rst delete mode 100644 docs/generated/rxmc.covariance.DenseTerm.rst delete mode 100644 docs/generated/rxmc.covariance.DiagonalTerm.rst delete mode 100644 docs/generated/rxmc.covariance.KernelTerm.rst delete mode 100644 docs/generated/rxmc.covariance.RankOneTerm.rst delete mode 100644 docs/generated/rxmc.covariance.Term.rst delete mode 100644 docs/generated/rxmc.covariance.discrepancy_term.rst delete mode 100644 docs/generated/rxmc.covariance.model_error_term.rst delete mode 100644 docs/generated/rxmc.covariance.noise_fraction_term.rst delete mode 100644 docs/generated/rxmc.covariance.noise_term.rst delete mode 100644 docs/generated/rxmc.covariance.normalization_term.rst delete mode 100644 docs/generated/rxmc.covariance.offset_term.rst delete mode 100644 docs/generated/rxmc.covariance.stacked_supports.rst delete mode 100644 docs/generated/rxmc.covariance.statistical_term.rst delete mode 100644 docs/generated/rxmc.elastic_diffxs_model.ElasticDifferentialXSModel.rst delete mode 100644 docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst delete mode 100644 docs/generated/rxmc.evidence.Evidence.rst delete mode 100644 docs/generated/rxmc.ias_pn_model.IsobaricAnalogPNXSModel.rst delete mode 100644 docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst delete mode 100644 docs/generated/rxmc.likelihood_model.Chi2.rst delete mode 100644 docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst delete mode 100644 docs/generated/rxmc.likelihood_model.Likelihood.rst delete mode 100644 docs/generated/rxmc.likelihood_model.StudentT.rst delete mode 100644 docs/generated/rxmc.likelihood_model.log_likelihood.rst delete mode 100644 docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst delete mode 100644 docs/generated/rxmc.metropolis_hastings.metropolis_hastings.rst delete mode 100644 docs/generated/rxmc.observation.Observation.rst delete mode 100644 docs/generated/rxmc.param_sampling.AdaptiveMetropolisSampler.rst delete mode 100644 docs/generated/rxmc.param_sampling.BatchedAdaptiveMetropolisSampler.rst delete mode 100644 docs/generated/rxmc.param_sampling.MetropolisHastingsSampler.rst delete mode 100644 docs/generated/rxmc.param_sampling.Sampler.rst delete mode 100644 docs/generated/rxmc.params.Parameter.rst delete mode 100644 docs/generated/rxmc.physical_model.PerObservationScaledModel.rst delete mode 100644 docs/generated/rxmc.physical_model.PhysicalModel.rst delete mode 100644 docs/generated/rxmc.physical_model.Polynomial.rst delete mode 100644 docs/generated/rxmc.physical_model.ScaledModel.rst delete mode 100644 docs/generated/rxmc.predictive.gp_posterior_predictive.rst delete mode 100644 docs/generated/rxmc.predictive.predictive_band.rst delete mode 100644 docs/generated/rxmc.predictive.total_predictive_band.rst delete mode 100644 docs/generated/rxmc.priors.IndependentPrior.rst delete mode 100644 docs/generated/rxmc.priors.TruncatedNormalPrior.rst delete mode 100644 docs/generated/rxmc.proposal.HalfNormalProposalDistribution.rst delete mode 100644 docs/generated/rxmc.proposal.LogspaceNormalProposalDistribution.rst delete mode 100644 docs/generated/rxmc.proposal.NormalProposalDistribution.rst delete mode 100644 docs/generated/rxmc.proposal.ProposalDistribution.rst delete mode 100644 docs/generated/rxmc.walker.Walker.rst diff --git a/.gitignore b/.gitignore index b682064..48ef535 100644 --- a/.gitignore +++ b/.gitignore @@ -3,6 +3,7 @@ examples/*.pdf # docs docs/_build/ +docs/generated/ #slurm *.out diff --git a/docs/generated/rxmc.adaptive_metropolis.adaptive_metropolis.rst b/docs/generated/rxmc.adaptive_metropolis.adaptive_metropolis.rst deleted file mode 100644 index ef48425..0000000 --- a/docs/generated/rxmc.adaptive_metropolis.adaptive_metropolis.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.adaptive\_metropolis.adaptive\_metropolis -============================================== - -.. currentmodule:: rxmc.adaptive_metropolis - -.. autofunction:: adaptive_metropolis \ No newline at end of file diff --git a/docs/generated/rxmc.config.CalibrationConfig.rst b/docs/generated/rxmc.config.CalibrationConfig.rst deleted file mode 100644 index 2d16ffb..0000000 --- a/docs/generated/rxmc.config.CalibrationConfig.rst +++ /dev/null @@ -1,41 +0,0 @@ -rxmc.config.CalibrationConfig -============================= - -.. currentmodule:: rxmc.config - -.. autoclass:: CalibrationConfig - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~CalibrationConfig.__init__ - ~CalibrationConfig.conditional_posterior - ~CalibrationConfig.log_likelihood - ~CalibrationConfig.log_posterior - ~CalibrationConfig.log_posterior_batch - ~CalibrationConfig.log_prior - ~CalibrationConfig.predict - ~CalibrationConfig.predict_parametric - ~CalibrationConfig.prior_transform - ~CalibrationConfig.split_parameters - ~CalibrationConfig.starting_location - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~CalibrationConfig.parameter_configs - ~CalibrationConfig.parameter_names - ~CalibrationConfig.parameters - ~CalibrationConfig.prior - - \ No newline at end of file diff --git a/docs/generated/rxmc.config.ParameterConfig.rst b/docs/generated/rxmc.config.ParameterConfig.rst deleted file mode 100644 index 7ac6157..0000000 --- a/docs/generated/rxmc.config.ParameterConfig.rst +++ /dev/null @@ -1,25 +0,0 @@ -rxmc.config.ParameterConfig -=========================== - -.. currentmodule:: rxmc.config - -.. autoclass:: ParameterConfig - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ParameterConfig.__init__ - ~ParameterConfig.prior_logpdf - ~ParameterConfig.prior_transform - ~ParameterConfig.x0 - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.constraint.Constraint.rst b/docs/generated/rxmc.constraint.Constraint.rst deleted file mode 100644 index cca1447..0000000 --- a/docs/generated/rxmc.constraint.Constraint.rst +++ /dev/null @@ -1,29 +0,0 @@ -rxmc.constraint.Constraint -========================== - -.. currentmodule:: rxmc.constraint - -.. autoclass:: Constraint - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Constraint.__init__ - ~Constraint.chi2 - ~Constraint.covariance_matrix - ~Constraint.empirical_coverage - ~Constraint.log_likelihood - ~Constraint.marginal_log_likelihood - ~Constraint.num_pts_within_interval - ~Constraint.predict - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.ConstraintCovariance.rst b/docs/generated/rxmc.covariance.ConstraintCovariance.rst deleted file mode 100644 index e8fe693..0000000 --- a/docs/generated/rxmc.covariance.ConstraintCovariance.rst +++ /dev/null @@ -1,33 +0,0 @@ -rxmc.covariance.ConstraintCovariance -==================================== - -.. currentmodule:: rxmc.covariance - -.. autoclass:: ConstraintCovariance - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ConstraintCovariance.__init__ - ~ConstraintCovariance.block_cholesky - ~ConstraintCovariance.cholesky - ~ConstraintCovariance.matrix - ~ConstraintCovariance.stacked_distance - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~ConstraintCovariance.blocks - ~ConstraintCovariance.n_params - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.DenseTerm.rst b/docs/generated/rxmc.covariance.DenseTerm.rst deleted file mode 100644 index 6e94a9e..0000000 --- a/docs/generated/rxmc.covariance.DenseTerm.rst +++ /dev/null @@ -1,32 +0,0 @@ -rxmc.covariance.DenseTerm -========================= - -.. currentmodule:: rxmc.covariance - -.. autoclass:: DenseTerm - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~DenseTerm.__init__ - ~DenseTerm.add_to - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~DenseTerm.couples_offdiagonal - ~DenseTerm.is_constant - ~DenseTerm.params - ~DenseTerm.support - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.DiagonalTerm.rst b/docs/generated/rxmc.covariance.DiagonalTerm.rst deleted file mode 100644 index 48dac86..0000000 --- a/docs/generated/rxmc.covariance.DiagonalTerm.rst +++ /dev/null @@ -1,32 +0,0 @@ -rxmc.covariance.DiagonalTerm -============================ - -.. currentmodule:: rxmc.covariance - -.. autoclass:: DiagonalTerm - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~DiagonalTerm.__init__ - ~DiagonalTerm.add_to - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~DiagonalTerm.couples_offdiagonal - ~DiagonalTerm.is_constant - ~DiagonalTerm.params - ~DiagonalTerm.support - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.KernelTerm.rst b/docs/generated/rxmc.covariance.KernelTerm.rst deleted file mode 100644 index 13b5b0d..0000000 --- a/docs/generated/rxmc.covariance.KernelTerm.rst +++ /dev/null @@ -1,32 +0,0 @@ -rxmc.covariance.KernelTerm -========================== - -.. currentmodule:: rxmc.covariance - -.. autoclass:: KernelTerm - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~KernelTerm.__init__ - ~KernelTerm.add_to - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~KernelTerm.couples_offdiagonal - ~KernelTerm.is_constant - ~KernelTerm.params - ~KernelTerm.support - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.RankOneTerm.rst b/docs/generated/rxmc.covariance.RankOneTerm.rst deleted file mode 100644 index 6bb9526..0000000 --- a/docs/generated/rxmc.covariance.RankOneTerm.rst +++ /dev/null @@ -1,32 +0,0 @@ -rxmc.covariance.RankOneTerm -=========================== - -.. currentmodule:: rxmc.covariance - -.. autoclass:: RankOneTerm - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~RankOneTerm.__init__ - ~RankOneTerm.add_to - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~RankOneTerm.couples_offdiagonal - ~RankOneTerm.is_constant - ~RankOneTerm.params - ~RankOneTerm.support - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.Term.rst b/docs/generated/rxmc.covariance.Term.rst deleted file mode 100644 index 3074349..0000000 --- a/docs/generated/rxmc.covariance.Term.rst +++ /dev/null @@ -1,32 +0,0 @@ -rxmc.covariance.Term -==================== - -.. currentmodule:: rxmc.covariance - -.. autoclass:: Term - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Term.__init__ - ~Term.add_to - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~Term.couples_offdiagonal - ~Term.is_constant - ~Term.params - ~Term.support - - \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.discrepancy_term.rst b/docs/generated/rxmc.covariance.discrepancy_term.rst deleted file mode 100644 index d0fc059..0000000 --- a/docs/generated/rxmc.covariance.discrepancy_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.discrepancy\_term -================================= - -.. currentmodule:: rxmc.covariance - -.. autofunction:: discrepancy_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.model_error_term.rst b/docs/generated/rxmc.covariance.model_error_term.rst deleted file mode 100644 index 5e16b63..0000000 --- a/docs/generated/rxmc.covariance.model_error_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.model\_error\_term -================================== - -.. currentmodule:: rxmc.covariance - -.. autofunction:: model_error_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.noise_fraction_term.rst b/docs/generated/rxmc.covariance.noise_fraction_term.rst deleted file mode 100644 index 0da615a..0000000 --- a/docs/generated/rxmc.covariance.noise_fraction_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.noise\_fraction\_term -===================================== - -.. currentmodule:: rxmc.covariance - -.. autofunction:: noise_fraction_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.noise_term.rst b/docs/generated/rxmc.covariance.noise_term.rst deleted file mode 100644 index d209843..0000000 --- a/docs/generated/rxmc.covariance.noise_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.noise\_term -=========================== - -.. currentmodule:: rxmc.covariance - -.. autofunction:: noise_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.normalization_term.rst b/docs/generated/rxmc.covariance.normalization_term.rst deleted file mode 100644 index feca611..0000000 --- a/docs/generated/rxmc.covariance.normalization_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.normalization\_term -=================================== - -.. currentmodule:: rxmc.covariance - -.. autofunction:: normalization_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.offset_term.rst b/docs/generated/rxmc.covariance.offset_term.rst deleted file mode 100644 index 4aa2980..0000000 --- a/docs/generated/rxmc.covariance.offset_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.offset\_term -============================ - -.. currentmodule:: rxmc.covariance - -.. autofunction:: offset_term \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.stacked_supports.rst b/docs/generated/rxmc.covariance.stacked_supports.rst deleted file mode 100644 index 5d367db..0000000 --- a/docs/generated/rxmc.covariance.stacked_supports.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.stacked\_supports -================================= - -.. currentmodule:: rxmc.covariance - -.. autofunction:: stacked_supports \ No newline at end of file diff --git a/docs/generated/rxmc.covariance.statistical_term.rst b/docs/generated/rxmc.covariance.statistical_term.rst deleted file mode 100644 index baec23c..0000000 --- a/docs/generated/rxmc.covariance.statistical_term.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.covariance.statistical\_term -================================= - -.. currentmodule:: rxmc.covariance - -.. autofunction:: statistical_term \ No newline at end of file diff --git a/docs/generated/rxmc.elastic_diffxs_model.ElasticDifferentialXSModel.rst b/docs/generated/rxmc.elastic_diffxs_model.ElasticDifferentialXSModel.rst deleted file mode 100644 index 61e6cd3..0000000 --- a/docs/generated/rxmc.elastic_diffxs_model.ElasticDifferentialXSModel.rst +++ /dev/null @@ -1,24 +0,0 @@ -rxmc.elastic\_diffxs\_model.ElasticDifferentialXSModel -====================================================== - -.. currentmodule:: rxmc.elastic_diffxs_model - -.. autoclass:: ElasticDifferentialXSModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ElasticDifferentialXSModel.__init__ - ~ElasticDifferentialXSModel.evaluate - ~ElasticDifferentialXSModel.visualizable_model_prediction - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst b/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst deleted file mode 100644 index d702f26..0000000 --- a/docs/generated/rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.rst +++ /dev/null @@ -1,27 +0,0 @@ -rxmc.elastic\_diffxs\_observation.ElasticDifferentialXSObservation -================================================================== - -.. currentmodule:: rxmc.elastic_diffxs_observation - -.. autoclass:: ElasticDifferentialXSObservation - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ElasticDifferentialXSObservation.__init__ - ~ElasticDifferentialXSObservation.calculate_normalization - ~ElasticDifferentialXSObservation.from_measurement - ~ElasticDifferentialXSObservation.num_pts_within_interval - ~ElasticDifferentialXSObservation.statistical_term - ~ElasticDifferentialXSObservation.systematic_terms - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.evidence.Evidence.rst b/docs/generated/rxmc.evidence.Evidence.rst deleted file mode 100644 index acc1e90..0000000 --- a/docs/generated/rxmc.evidence.Evidence.rst +++ /dev/null @@ -1,24 +0,0 @@ -rxmc.evidence.Evidence -====================== - -.. currentmodule:: rxmc.evidence - -.. autoclass:: Evidence - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Evidence.__init__ - ~Evidence.log_likelihood - ~Evidence.weighted_marginal_log_likelihood - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.ias_pn_model.IsobaricAnalogPNXSModel.rst b/docs/generated/rxmc.ias_pn_model.IsobaricAnalogPNXSModel.rst deleted file mode 100644 index b8f4b92..0000000 --- a/docs/generated/rxmc.ias_pn_model.IsobaricAnalogPNXSModel.rst +++ /dev/null @@ -1,24 +0,0 @@ -rxmc.ias\_pn\_model.IsobaricAnalogPNXSModel -=========================================== - -.. currentmodule:: rxmc.ias_pn_model - -.. autoclass:: IsobaricAnalogPNXSModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~IsobaricAnalogPNXSModel.__init__ - ~IsobaricAnalogPNXSModel.evaluate - ~IsobaricAnalogPNXSModel.visualizable_model_prediction - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst b/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst deleted file mode 100644 index 3710cb4..0000000 --- a/docs/generated/rxmc.ias_pn_observation.IsobaricAnalogPNObservation.rst +++ /dev/null @@ -1,26 +0,0 @@ -rxmc.ias\_pn\_observation.IsobaricAnalogPNObservation -===================================================== - -.. currentmodule:: rxmc.ias_pn_observation - -.. autoclass:: IsobaricAnalogPNObservation - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~IsobaricAnalogPNObservation.__init__ - ~IsobaricAnalogPNObservation.from_measurement - ~IsobaricAnalogPNObservation.num_pts_within_interval - ~IsobaricAnalogPNObservation.statistical_term - ~IsobaricAnalogPNObservation.systematic_terms - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.Chi2.rst b/docs/generated/rxmc.likelihood_model.Chi2.rst deleted file mode 100644 index 5dbb7bd..0000000 --- a/docs/generated/rxmc.likelihood_model.Chi2.rst +++ /dev/null @@ -1,31 +0,0 @@ -rxmc.likelihood\_model.Chi2 -=========================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: Chi2 - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Chi2.__init__ - ~Chi2.chi2 - ~Chi2.log_likelihood - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~Chi2.n_params - ~Chi2.params - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst b/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst deleted file mode 100644 index 16c84cc..0000000 --- a/docs/generated/rxmc.likelihood_model.GaussianLikelihood.rst +++ /dev/null @@ -1,31 +0,0 @@ -rxmc.likelihood\_model.GaussianLikelihood -========================================= - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: GaussianLikelihood - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~GaussianLikelihood.__init__ - ~GaussianLikelihood.chi2 - ~GaussianLikelihood.log_likelihood - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~GaussianLikelihood.n_params - ~GaussianLikelihood.params - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.Likelihood.rst b/docs/generated/rxmc.likelihood_model.Likelihood.rst deleted file mode 100644 index 794d1e3..0000000 --- a/docs/generated/rxmc.likelihood_model.Likelihood.rst +++ /dev/null @@ -1,31 +0,0 @@ -rxmc.likelihood\_model.Likelihood -================================= - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: Likelihood - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Likelihood.__init__ - ~Likelihood.chi2 - ~Likelihood.log_likelihood - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~Likelihood.n_params - ~Likelihood.params - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.StudentT.rst b/docs/generated/rxmc.likelihood_model.StudentT.rst deleted file mode 100644 index c7ab508..0000000 --- a/docs/generated/rxmc.likelihood_model.StudentT.rst +++ /dev/null @@ -1,31 +0,0 @@ -rxmc.likelihood\_model.StudentT -=============================== - -.. currentmodule:: rxmc.likelihood_model - -.. autoclass:: StudentT - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~StudentT.__init__ - ~StudentT.chi2 - ~StudentT.log_likelihood - - - - - - .. rubric:: Attributes - - .. autosummary:: - - ~StudentT.n_params - ~StudentT.params - - \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.log_likelihood.rst b/docs/generated/rxmc.likelihood_model.log_likelihood.rst deleted file mode 100644 index 1b66b0a..0000000 --- a/docs/generated/rxmc.likelihood_model.log_likelihood.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.likelihood\_model.log\_likelihood -====================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autofunction:: log_likelihood \ No newline at end of file diff --git a/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst b/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst deleted file mode 100644 index 0a1e57a..0000000 --- a/docs/generated/rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.likelihood\_model.mahalanobis\_distance\_sqr\_cholesky -=========================================================== - -.. currentmodule:: rxmc.likelihood_model - -.. autofunction:: mahalanobis_distance_sqr_cholesky \ No newline at end of file diff --git a/docs/generated/rxmc.metropolis_hastings.metropolis_hastings.rst b/docs/generated/rxmc.metropolis_hastings.metropolis_hastings.rst deleted file mode 100644 index 223b626..0000000 --- a/docs/generated/rxmc.metropolis_hastings.metropolis_hastings.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.metropolis\_hastings.metropolis\_hastings -============================================== - -.. currentmodule:: rxmc.metropolis_hastings - -.. autofunction:: metropolis_hastings \ No newline at end of file diff --git a/docs/generated/rxmc.observation.Observation.rst b/docs/generated/rxmc.observation.Observation.rst deleted file mode 100644 index c804feb..0000000 --- a/docs/generated/rxmc.observation.Observation.rst +++ /dev/null @@ -1,25 +0,0 @@ -rxmc.observation.Observation -============================ - -.. currentmodule:: rxmc.observation - -.. autoclass:: Observation - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Observation.__init__ - ~Observation.num_pts_within_interval - ~Observation.statistical_term - ~Observation.systematic_terms - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.param_sampling.AdaptiveMetropolisSampler.rst b/docs/generated/rxmc.param_sampling.AdaptiveMetropolisSampler.rst deleted file mode 100644 index ca66606..0000000 --- a/docs/generated/rxmc.param_sampling.AdaptiveMetropolisSampler.rst +++ /dev/null @@ -1,27 +0,0 @@ -rxmc.param\_sampling.AdaptiveMetropolisSampler -============================================== - -.. currentmodule:: rxmc.param_sampling - -.. autoclass:: AdaptiveMetropolisSampler - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~AdaptiveMetropolisSampler.__init__ - ~AdaptiveMetropolisSampler.batch_acceptance_fractions - ~AdaptiveMetropolisSampler.most_recent_batch_acceptance_fraction - ~AdaptiveMetropolisSampler.overall_acceptance_fraction - ~AdaptiveMetropolisSampler.record_batch - ~AdaptiveMetropolisSampler.sample - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.param_sampling.BatchedAdaptiveMetropolisSampler.rst b/docs/generated/rxmc.param_sampling.BatchedAdaptiveMetropolisSampler.rst deleted file mode 100644 index 476dc93..0000000 --- a/docs/generated/rxmc.param_sampling.BatchedAdaptiveMetropolisSampler.rst +++ /dev/null @@ -1,27 +0,0 @@ -rxmc.param\_sampling.BatchedAdaptiveMetropolisSampler -===================================================== - -.. currentmodule:: rxmc.param_sampling - -.. autoclass:: BatchedAdaptiveMetropolisSampler - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~BatchedAdaptiveMetropolisSampler.__init__ - ~BatchedAdaptiveMetropolisSampler.batch_acceptance_fractions - ~BatchedAdaptiveMetropolisSampler.most_recent_batch_acceptance_fraction - ~BatchedAdaptiveMetropolisSampler.overall_acceptance_fraction - ~BatchedAdaptiveMetropolisSampler.record_batch - ~BatchedAdaptiveMetropolisSampler.sample - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.param_sampling.MetropolisHastingsSampler.rst b/docs/generated/rxmc.param_sampling.MetropolisHastingsSampler.rst deleted file mode 100644 index 10d4d9f..0000000 --- a/docs/generated/rxmc.param_sampling.MetropolisHastingsSampler.rst +++ /dev/null @@ -1,27 +0,0 @@ -rxmc.param\_sampling.MetropolisHastingsSampler -============================================== - -.. currentmodule:: rxmc.param_sampling - -.. autoclass:: MetropolisHastingsSampler - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~MetropolisHastingsSampler.__init__ - ~MetropolisHastingsSampler.batch_acceptance_fractions - ~MetropolisHastingsSampler.most_recent_batch_acceptance_fraction - ~MetropolisHastingsSampler.overall_acceptance_fraction - ~MetropolisHastingsSampler.record_batch - ~MetropolisHastingsSampler.sample - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.param_sampling.Sampler.rst b/docs/generated/rxmc.param_sampling.Sampler.rst deleted file mode 100644 index 9ead0d8..0000000 --- a/docs/generated/rxmc.param_sampling.Sampler.rst +++ /dev/null @@ -1,27 +0,0 @@ -rxmc.param\_sampling.Sampler -============================ - -.. currentmodule:: rxmc.param_sampling - -.. autoclass:: Sampler - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Sampler.__init__ - ~Sampler.batch_acceptance_fractions - ~Sampler.most_recent_batch_acceptance_fraction - ~Sampler.overall_acceptance_fraction - ~Sampler.record_batch - ~Sampler.sample - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.params.Parameter.rst b/docs/generated/rxmc.params.Parameter.rst deleted file mode 100644 index 9292cef..0000000 --- a/docs/generated/rxmc.params.Parameter.rst +++ /dev/null @@ -1,22 +0,0 @@ -rxmc.params.Parameter -===================== - -.. currentmodule:: rxmc.params - -.. autoclass:: Parameter - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Parameter.__init__ - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst b/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst deleted file mode 100644 index 687fdb1..0000000 --- a/docs/generated/rxmc.physical_model.PerObservationScaledModel.rst +++ /dev/null @@ -1,23 +0,0 @@ -rxmc.physical\_model.PerObservationScaledModel -============================================== - -.. currentmodule:: rxmc.physical_model - -.. autoclass:: PerObservationScaledModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~PerObservationScaledModel.__init__ - ~PerObservationScaledModel.evaluate - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.physical_model.PhysicalModel.rst b/docs/generated/rxmc.physical_model.PhysicalModel.rst deleted file mode 100644 index 48f7915..0000000 --- a/docs/generated/rxmc.physical_model.PhysicalModel.rst +++ /dev/null @@ -1,23 +0,0 @@ -rxmc.physical\_model.PhysicalModel -================================== - -.. currentmodule:: rxmc.physical_model - -.. autoclass:: PhysicalModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~PhysicalModel.__init__ - ~PhysicalModel.evaluate - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.physical_model.Polynomial.rst b/docs/generated/rxmc.physical_model.Polynomial.rst deleted file mode 100644 index d683066..0000000 --- a/docs/generated/rxmc.physical_model.Polynomial.rst +++ /dev/null @@ -1,23 +0,0 @@ -rxmc.physical\_model.Polynomial -=============================== - -.. currentmodule:: rxmc.physical_model - -.. autoclass:: Polynomial - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Polynomial.__init__ - ~Polynomial.evaluate - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.physical_model.ScaledModel.rst b/docs/generated/rxmc.physical_model.ScaledModel.rst deleted file mode 100644 index d08afd3..0000000 --- a/docs/generated/rxmc.physical_model.ScaledModel.rst +++ /dev/null @@ -1,23 +0,0 @@ -rxmc.physical\_model.ScaledModel -================================ - -.. currentmodule:: rxmc.physical_model - -.. autoclass:: ScaledModel - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ScaledModel.__init__ - ~ScaledModel.evaluate - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.gp_posterior_predictive.rst b/docs/generated/rxmc.predictive.gp_posterior_predictive.rst deleted file mode 100644 index ec996fc..0000000 --- a/docs/generated/rxmc.predictive.gp_posterior_predictive.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.predictive.gp\_posterior\_predictive -========================================= - -.. currentmodule:: rxmc.predictive - -.. autofunction:: gp_posterior_predictive \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.predictive_band.rst b/docs/generated/rxmc.predictive.predictive_band.rst deleted file mode 100644 index 024c18e..0000000 --- a/docs/generated/rxmc.predictive.predictive_band.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.predictive.predictive\_band -================================ - -.. currentmodule:: rxmc.predictive - -.. autofunction:: predictive_band \ No newline at end of file diff --git a/docs/generated/rxmc.predictive.total_predictive_band.rst b/docs/generated/rxmc.predictive.total_predictive_band.rst deleted file mode 100644 index d5624f8..0000000 --- a/docs/generated/rxmc.predictive.total_predictive_band.rst +++ /dev/null @@ -1,6 +0,0 @@ -rxmc.predictive.total\_predictive\_band -======================================= - -.. currentmodule:: rxmc.predictive - -.. autofunction:: total_predictive_band \ No newline at end of file diff --git a/docs/generated/rxmc.priors.IndependentPrior.rst b/docs/generated/rxmc.priors.IndependentPrior.rst deleted file mode 100644 index e3b7a97..0000000 --- a/docs/generated/rxmc.priors.IndependentPrior.rst +++ /dev/null @@ -1,25 +0,0 @@ -rxmc.priors.IndependentPrior -============================ - -.. currentmodule:: rxmc.priors - -.. autoclass:: IndependentPrior - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~IndependentPrior.__init__ - ~IndependentPrior.logpdf - ~IndependentPrior.prior_transform - ~IndependentPrior.rvs - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.priors.TruncatedNormalPrior.rst b/docs/generated/rxmc.priors.TruncatedNormalPrior.rst deleted file mode 100644 index ff6d210..0000000 --- a/docs/generated/rxmc.priors.TruncatedNormalPrior.rst +++ /dev/null @@ -1,25 +0,0 @@ -rxmc.priors.TruncatedNormalPrior -================================ - -.. currentmodule:: rxmc.priors - -.. autoclass:: TruncatedNormalPrior - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~TruncatedNormalPrior.__init__ - ~TruncatedNormalPrior.logpdf - ~TruncatedNormalPrior.prior_transform - ~TruncatedNormalPrior.rvs - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.proposal.HalfNormalProposalDistribution.rst b/docs/generated/rxmc.proposal.HalfNormalProposalDistribution.rst deleted file mode 100644 index 63d5baa..0000000 --- a/docs/generated/rxmc.proposal.HalfNormalProposalDistribution.rst +++ /dev/null @@ -1,22 +0,0 @@ -rxmc.proposal.HalfNormalProposalDistribution -============================================ - -.. currentmodule:: rxmc.proposal - -.. autoclass:: HalfNormalProposalDistribution - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~HalfNormalProposalDistribution.__init__ - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.proposal.LogspaceNormalProposalDistribution.rst b/docs/generated/rxmc.proposal.LogspaceNormalProposalDistribution.rst deleted file mode 100644 index db24068..0000000 --- a/docs/generated/rxmc.proposal.LogspaceNormalProposalDistribution.rst +++ /dev/null @@ -1,22 +0,0 @@ -rxmc.proposal.LogspaceNormalProposalDistribution -================================================ - -.. currentmodule:: rxmc.proposal - -.. autoclass:: LogspaceNormalProposalDistribution - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~LogspaceNormalProposalDistribution.__init__ - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.proposal.NormalProposalDistribution.rst b/docs/generated/rxmc.proposal.NormalProposalDistribution.rst deleted file mode 100644 index 284fa43..0000000 --- a/docs/generated/rxmc.proposal.NormalProposalDistribution.rst +++ /dev/null @@ -1,22 +0,0 @@ -rxmc.proposal.NormalProposalDistribution -======================================== - -.. currentmodule:: rxmc.proposal - -.. autoclass:: NormalProposalDistribution - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~NormalProposalDistribution.__init__ - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.proposal.ProposalDistribution.rst b/docs/generated/rxmc.proposal.ProposalDistribution.rst deleted file mode 100644 index 9439d8e..0000000 --- a/docs/generated/rxmc.proposal.ProposalDistribution.rst +++ /dev/null @@ -1,22 +0,0 @@ -rxmc.proposal.ProposalDistribution -================================== - -.. currentmodule:: rxmc.proposal - -.. autoclass:: ProposalDistribution - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~ProposalDistribution.__init__ - - - - - - \ No newline at end of file diff --git a/docs/generated/rxmc.walker.Walker.rst b/docs/generated/rxmc.walker.Walker.rst deleted file mode 100644 index 4ccfc9f..0000000 --- a/docs/generated/rxmc.walker.Walker.rst +++ /dev/null @@ -1,28 +0,0 @@ -rxmc.walker.Walker -================== - -.. currentmodule:: rxmc.walker - -.. autoclass:: Walker - - - .. automethod:: __init__ - - - .. rubric:: Methods - - .. autosummary:: - - ~Walker.__init__ - ~Walker.log_likelihood - ~Walker.log_posterior - ~Walker.log_prior - ~Walker.run_likelihood_batches - ~Walker.run_model_batch - ~Walker.walk - - - - - - \ No newline at end of file From 2bc0771d3b760f6239aa7c9af215e29ccc61dd25 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:17:50 -0400 Subject: [PATCH 16/24] Fix Constraint consuming its observations argument; harden masks Constraint.__init__ copied the observations into a list and then kept iterating the original argument, so a generator (or any one-shot iterable) was exhausted on the first line and produced an empty constraint without complaint. Iterate the stored list throughout. Also from the review of the masks commit: empirical_coverage returns nan instead of dividing by zero when no point is active; an integer observation mask of length n holding only 0/1 is rejected as ambiguous (bool mask or index list?) instead of being read as indices; masked() re-runs the non-finite comparison-space guard so a view cannot re-activate a point that is -inf under log (and the guard no longer warns about inf*0 at inactive points); ConstraintCovariance keeps an active index array that merely has size N unless it is exactly arange(N); covariance_matrix documents active_only and its two possible shapes; masked() explains why sharing Terms between the view and its parent is safe; stray blank lines left by hoisted test imports are removed. Co-Authored-By: Claude Fable 5 --- src/rxmc/constraint.py | 38 ++++++++++++++++++++++++++++++-------- src/rxmc/covariance.py | 2 +- src/rxmc/observation.py | 32 +++++++++++++++++++++----------- test/test_constraint.py | 26 ++++++++++++++++++++++---- test/test_covariance.py | 9 +++++++++ test/test_observation.py | 7 +++++++ 6 files changed, 90 insertions(+), 24 deletions(-) diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index 1441a4a..73ef398 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -54,7 +54,9 @@ class Constraint: reported statistics rather than add to them. mask : sequence of bool or of int, optional Which *observations* are active (all by default): a boolean per - observation, or the indices of the active ones. Combined with each + observation, or the indices of the active ones. An integer array of + length ``len(observations)`` holding only 0/1 is ambiguous and + rejected; pass a bool array or explicit indices. Combined with each observation's own point ``mask`` to give :attr:`active`. Attributes @@ -87,6 +89,7 @@ def __init__( self.physical_model = physical_model self.likelihood = likelihood if likelihood is not None else GaussianLikelihood() + observations = self.observations supports = stacked_supports(observations) self._supports = supports self.n_data_pts_total = sum(o.n_data_pts for o in observations) @@ -133,8 +136,15 @@ def _observation_mask(self, mask): if m.shape != (n,): raise ValueError(f"mask must have one entry per observation ({n})") return m + idx = np.asarray(m, dtype=int) + if n > 1 and idx.shape == (n,) and np.isin(idx, (0, 1)).all(): + raise ValueError( + f"ambiguous observation mask: an integer array of length {n} with " + "only 0/1 entries could be a boolean mask or a list of indices; " + "pass a bool array or integer indices" + ) out = np.zeros(n, dtype=bool) - out[np.asarray(m, dtype=int)] = True + out[idx] = True return out # ------------------------------------------------------------------ @@ -159,7 +169,9 @@ def masked(self, mask=None, point_masks=None): one, so its parameter vector is identical — it is a *view* for evaluating the same likelihood on a different subset (e.g. held-out scoring), not an independent constraint to place in the same - :class:`~rxmc.evidence.Evidence`. + :class:`~rxmc.evidence.Evidence`. Sharing the terms is safe because + both constraints stack the same observations in the same order, so the + terms' bound supports and cached ``x``-dependent values stay valid. """ observations = list(self.observations) if point_masks is not None: @@ -422,8 +434,7 @@ def covariance_matrix(self, model_params, cov_params=(), active_only=True): """Assemble the stacked covariance matrix Σ at a parameter point. Convenience accessor (e.g. for visualising the off-diagonal block - structure of correlated observations). Restricted to the active points - unless ``active_only=False``. + structure of correlated observations). Parameters ---------- @@ -432,13 +443,19 @@ def covariance_matrix(self, model_params, cov_params=(), active_only=True): cov_params : tuple, optional Constraint parameters: covariance params followed by likelihood params, in :attr:`params` order (matching :meth:`log_likelihood`). + active_only : bool, optional + Restrict to the active points (default); ``False`` returns the + full stacked matrix. Returns ------- - np.ndarray, shape (n_data_pts, n_data_pts) + np.ndarray + Shape ``(n_data_pts, n_data_pts)`` (active points) or + ``(n_data_pts_total, n_data_pts_total)`` when ``active_only=False``. A fresh copy (safe to mutate; never aliases the internal cache). """ - return self._stack_and_covariance(model_params, cov_params, active_only)[1] + _, Sigma = self._stack_and_covariance(model_params, cov_params, active_only) + return Sigma # ------------------------------------------------------------------ # Coverage diagnostics @@ -457,5 +474,10 @@ def num_pts_within_interval( def empirical_coverage( self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None ): - """Fraction of data points within a predictive interval.""" + """Fraction of active data points within a predictive interval. + + ``nan`` when the constraint has no active points. + """ + if self.n_data_pts == 0: + return float("nan") return self.num_pts_within_interval(ylow, yhigh, xlim) / self.n_data_pts diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index 16e2b0a..f0e6cf1 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -392,7 +392,7 @@ def __init__(self, terms, N, blocks=None, active=None): self.active = None else: active = np.asarray(active, dtype=int) - self.active = None if active.size == self.N else active + self.active = None if np.array_equal(active, np.arange(self.N)) else active self.n_active = self.N if self.active is None else int(self.active.size) if self._blocks is not None and self.active is not None: self._active_blocks = [b[np.isin(b, self.active)] for b in self._blocks] diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index 6c0ae08..9281008 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -158,17 +158,13 @@ def __init__( else: # |t'(y_raw)|: the delta-method factor, reused by log_jacobian and # systematic_terms - self._abs_jacobian = np.abs(self.transform.derivative(y_raw)) - self.y = self.transform(y_raw) - self.y_stat_err = self._abs_jacobian * y_stat_err - bad = self.mask & ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) - if np.any(bad): - raise ValueError( - f"transform {self.transform.name!r} is not finite at " - f"{int(bad.sum())} active data point(s) of dataset " - f"{label or 'observation'!r} (e.g. non-positive y under a " - "log transform); mask or drop those points" - ) + # inactive points may be non-finite (inf * 0 -> nan); the guard + # below only inspects the active ones + with np.errstate(invalid="ignore", divide="ignore"): + self._abs_jacobian = np.abs(self.transform.derivative(y_raw)) + self.y = self.transform(y_raw) + self.y_stat_err = self._abs_jacobian * y_stat_err + self._check_finite() self.y_sys_err_normalization = _store_error_spec( y_sys_err_normalization, self.n_data_pts, "y_sys_err_normalization" @@ -177,6 +173,19 @@ def __init__( y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" ) + def _check_finite(self): + """Reject non-finite comparison-space values at the active points.""" + if self.transform.is_identity: + return + bad = self.mask & ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) + if np.any(bad): + raise ValueError( + f"transform {self.transform.name!r} is not finite at " + f"{int(bad.sum())} active data point(s) of dataset " + f"{self.label or 'observation'!r} (e.g. non-positive y under a " + "log transform); mask or drop those points" + ) + # ------------------------------------------------------------------ # Masks (active points) # ------------------------------------------------------------------ @@ -196,6 +205,7 @@ def masked(self, mask, label=None): new.mask = _as_point_mask(mask, self.n_data_pts) if label is not None: new.label = label + new._check_finite() return new def masked_where(self, predicate, label=None): diff --git a/test/test_constraint.py b/test/test_constraint.py index 3a57183..57e6623 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -247,7 +247,6 @@ def test_correct_count_unchanged(self): self.assertTrue(np.isfinite(c.log_likelihood(self.mp, (np.log(0.1),)))) def test_studentt_chi2_full_tuple(self): - eps = Parameter("log eps") student = Constraint( [self.obs], @@ -271,7 +270,6 @@ def test_studentt_chi2_full_tuple(self): ) def test_covariance_matrix_full_tuple_convention(self): - eta = Parameter("log eta") c = Constraint( [self.obs], @@ -332,7 +330,6 @@ def test_collision_with_model_param_name_raises(self): self.assertIn("physical-model parameter", str(cm.exception)) def test_likelihood_param_collision_raises(self): - nu_clone = Parameter("nu") with self.assertRaises(ValueError): Constraint( @@ -576,10 +573,31 @@ def test_coverage_uses_active_points(self): self.assertEqual(c.empirical_coverage(lo, hi), 1.0) self.assertEqual(c.num_pts_within_interval(lo, hi), 4) + def test_no_active_points_coverage_is_nan(self): + c = Constraint([self.obs1, self.obs2], self.pm, mask=[]) + self.assertEqual(c.n_data_pts, 0) + lo = [o.y - 1.0 for o in c.observations] + hi = [o.y + 1.0 for o in c.observations] + self.assertTrue(np.isnan(c.empirical_coverage(lo, hi))) + + def test_generator_argument(self): + ref = Constraint([self.obs1, self.obs2], self.pm) + gen = Constraint((o for o in [self.obs1, self.obs2]), self.pm) + self.assertEqual(len(gen.observations), 2) + self.assertEqual(gen.n_data_pts, ref.n_data_pts) + self.assertAlmostEqual(gen.log_likelihood(self.mp), ref.log_likelihood(self.mp)) + + def test_ambiguous_observation_mask_raises(self): + with self.assertRaises(ValueError): + Constraint([self.obs1, self.obs2], self.pm, mask=[1, 0]) + by_index = Constraint([self.obs1, self.obs2], self.pm, mask=[0]) + self.assertEqual(by_index.n_data_pts, 3) + by_bool = Constraint([self.obs1, self.obs2], self.pm, mask=[False, True]) + self.assertEqual(by_bool.n_data_pts, 2) + class TestComparisonSpaceTransform(unittest.TestCase): def setUp(self): - self.pm = Polynomial(order=1) self.mp = (1.0, 2.0) self.x = np.array([1.0, 2.0, 3.0]) diff --git a/test/test_covariance.py b/test/test_covariance.py index f776110..cc707d9 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -368,6 +368,15 @@ def test_all_active_is_none(self): cov = ConstraintCovariance(self.terms, 6, active=np.arange(6)) assert cov.active is None + def test_permuted_active_is_kept(self): + perm = np.array([5, 4, 3, 2, 1, 0]) + cov = ConstraintCovariance(self.terms, 6, active=perm) + assert cov.active is not None and cov.n_active == 6 + ref = ConstraintCovariance(self.terms, 6) + d_perm = cov.stacked_distance(self.ctx, (np.log(0.2),)) + d_ref = ref.stacked_distance(self.ctx, (np.log(0.2),)) + assert np.allclose(d_perm, d_ref) + # ---------------------------------------------------------------------------- # Factories diff --git a/test/test_observation.py b/test/test_observation.py index 0746efa..2e67864 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -266,6 +266,13 @@ def test_bad_mask_shape_raises(self): with self.assertRaises(ValueError): Observation(self.x, self.y).masked([True]) + def test_masked_rechecks_transform_finiteness(self): + y = np.array([1.0, 0.0, 3.0, 4.0]) + obs = Observation(self.x, y, transform=log, mask=[True, False, True, True]) + self.assertEqual(obs.n_active, 3) + with self.assertRaises(ValueError): + obs.masked([True, True, True, True]) + def test_num_pts_within_interval_respects_mask(self): obs = Observation(self.x, self.y, mask=[True, False, True, False]) n = obs.num_pts_within_interval(self.y - 0.1, self.y + 0.1) From 53680349cd556c47df1db8e3a57e97c4b92d00c5 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:21:06 -0400 Subject: [PATCH 17/24] Validate term magnitudes, guard Term reuse, drop discrepancy_term The generic-Term rewrite lost the eager shape check the old offset_term / normalization_term had: a magnitude or mask array of the wrong length was run through np.broadcast_to in the basis, which silently spreads a length-1 array over the support. Route every magnitude and basis value through _full(), which broadcasts scalars (0-d arrays included) and rejects any array whose shape is not (n,). A Term binds its support once and caches x-dependent values, so it cannot be shared between constraints of different length without returning stale or misplaced blocks; bind() now raises when asked to re-bind to a different N, and the Term docstring states the one-Term-one-constraint rule (masked views of one constraint share its stack and may share Terms). local_context() checks the parameter count before handing values to a parametric coords transform, so the error comes from the covariance layer rather than the Transform. Drop the discrepancy_term alias: nothing used it, the module docstring and API reference already omitted it, and kernel_term is the one name. Document StackContext in the API reference (it is the context a ConstraintCovariance is evaluated on), extract the kernel hyperparameter-to-Parameter loop into _kernel_params, and state that a kernel_term amplitude sees the transformed coordinate. Tests: length-1 magnitude/mask, 0-d magnitude, re-binding, local_context parameter check; the constant-term test moves out of the kernel class and the noqa'd lambda becomes a def. Not changed: the _AVERAGING alias stays, because removing it means renaming model_error_term's averaging= keyword for no behavioural gain. Co-Authored-By: Claude Fable 5 --- docs/api.rst | 3 ++ src/rxmc/covariance.py | 100 +++++++++++++++++++++++++++++----------- test/test_covariance.py | 74 +++++++++++++++++++++-------- 3 files changed, 130 insertions(+), 47 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index dcfb8b3..29f54ee 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -67,6 +67,8 @@ a numpy-style callable of a :class:`~rxmc.covariance.TermContext` (the term's local ``x``/``y``/``ym``) and its parameters, plus a ``kind`` (``"diag"``/``"mode"``/``"matrix"``). The factory helpers build the common terms in one line; anything else is a direct ``Term(fn, params, kind=...)``. +A :class:`~rxmc.covariance.StackContext` bundles the stacked ``x``/``y``/``ym`` +that a :class:`~rxmc.covariance.ConstraintCovariance` is evaluated on. .. autosummary:: :toctree: generated/ @@ -91,6 +93,7 @@ terms in one line; anything else is a direct ``Term(fn, params, kind=...)``. rxmc.covariance.exp_growth_amplitude rxmc.covariance.stacked_supports rxmc.covariance.ConstraintCovariance + rxmc.covariance.StackContext Likelihood functionals ---------------------- diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index f0e6cf1..861fc36 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -69,7 +69,6 @@ "model_error_term", "systematic_term", "kernel_term", - "discrepancy_term", ] KINDS = ("diag", "mode", "matrix") @@ -187,6 +186,14 @@ class Term: may be read freely (e.g. a fixed-hyperparameter kernel over ``x``). A constant term is first evaluated with ``c.ym is None``, so a mis-declared term fails loudly. Ignored (``True``) for array ``fn``. + + Notes + ----- + A Term is stateful: its support is bound once (see :meth:`bind`) and + constant or coordinate-transformed values are cached on the assumption that + the constraint's ``x`` never changes. Build a fresh Term per constraint; + only masked views of one constraint (which stack the same observations) + may share Terms. """ def __init__( @@ -210,6 +217,7 @@ def __init__( self._n_fn_params = len(fn_params) self.params = fn_params + self.coords.params self.support = None + self._bound_N = None self._cache = None self._x_cache = None @@ -240,10 +248,21 @@ def bound(self) -> bool: def bind(self, N: int) -> None: """Resolve ``support=None`` to the whole stack of length ``N``. - Idempotent; a term constructed with an explicit support is untouched. + Idempotent for the same ``N``; a term constructed with an explicit + support is untouched. Re-binding to a *different* ``N`` raises: one + Term belongs to one constraint (masked views of that constraint share + its stack, see :meth:`rxmc.constraint.Constraint.masked`). """ + N = int(N) if self.support is None: - self._set_support(np.arange(int(N))) + self._set_support(np.arange(N)) + self._bound_N = N + elif self._bound_N is not None and self._bound_N != N: + raise ValueError( + f"Term already bound to a stack of length {self._bound_N}; cannot " + f"re-bind it to length {N}. One Term belongs to one constraint " + "(masked views of the same constraint share its stack)" + ) def _set_support(self, ix: np.ndarray) -> None: self.support = ix @@ -285,8 +304,11 @@ def _check_bound(self): def local_context(self, ctx: StackContext, theta=()) -> TermContext: """The :class:`TermContext` this term sees at ``theta``.""" self._check_bound() + theta = np.asarray(theta, dtype=float) + if len(theta) != len(self.params): + raise ValueError(f"expected {len(self.params)} params, got {len(theta)}") ix = self.support - x = self._coords_x(ctx, np.asarray(theta, dtype=float)) + x = self._coords_x(ctx, theta) ym = None if ctx.ym is None else ctx.ym[ix] return TermContext(x=x, y=ctx.y[ix], ym=ym, support=ix) @@ -450,7 +472,8 @@ def matrix(self, ctx, *theta) -> np.ndarray: Parameters ---------- ctx : StackContext - Stacked arrays. When :attr:`is_constant`, ``ctx.ym`` is never read + Stacked arrays. ``ctx`` itself may be ``None`` only when every term + is array-valued. When :attr:`is_constant`, ``ctx.ym`` is never read (it may be ``None``, see :meth:`StackContext.constant`) and the result is cached. *theta : float @@ -634,8 +657,8 @@ def _masked(magnitude, mask=None): Scalar-like values include 0-d ndarrays (e.g. ``np.array(0.05)`` as stored by ``exfor_tools`` distributions), not just Python scalars. An array magnitude - is checked against the support length when the term is evaluated - (``np.broadcast_to`` in the basis). + must have exactly the support's length; this is checked by :func:`_full` + when the term is evaluated. """ v = float(magnitude) if np.ndim(magnitude) == 0 else np.asarray(magnitude, float) if mask is not None: @@ -643,6 +666,24 @@ def _masked(magnitude, mask=None): return v +def _full(v, n): + """``v`` as a length-``n`` vector. + + Scalars are broadcast; arrays must already have shape ``(n,)`` — a length-1 + array is *not* treated as a scalar, so a magnitude or mask of the wrong + length fails loudly instead of being spread over the support. + """ + v = np.asarray(v, dtype=float) + if v.ndim == 0: + return np.full(n, float(v)) + if v.shape != (n,): + raise ValueError( + f"magnitude/basis has shape {v.shape} but the term's support has " + f"length {n}" + ) + return v + + def _coefficient(parameter, log): """Parameter -> multiplicative coefficient ``exp(theta)`` (``log``) or ``theta``.""" if parameter is None: @@ -662,7 +703,7 @@ def _scaled_term( def fn(c, *values): b = basis(c, *values[nc:]) if callable(basis) else basis - return coef(values[:nc]) * np.broadcast_to(b, (len(c),)) + return coef(values[:nc]) * _full(b, len(c)) return Term(fn, cparams + basis_params, kind=kind, support=support, coords=coords) @@ -685,7 +726,7 @@ def offset_term( mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) def basis(c): - return np.broadcast_to(mag, (len(c),)) + return _full(mag, len(c)) if parameter is None: return Term(basis, kind="mode", support=support, constant=True) @@ -706,7 +747,7 @@ def normalization_term( mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) def basis(c): - return np.broadcast_to(mag, (len(c),)) * c.ym + return _full(mag, len(c)) * c.ym return _scaled_term("mode", parameter, log, basis, support=support) @@ -771,6 +812,24 @@ def systematic_term( ) +def _kernel_params(kernel, prefix) -> list: + """One :class:`~rxmc.params.Parameter` per free kernel hyperparameter element.""" + params = [] + for hp in kernel.hyperparameters: + if hp.fixed: + continue + if hp.n_elements == 1: + params.append(Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name)) + else: + params.extend( + Parameter( + f"{prefix}_{hp.name}_{i}", float, latex_name=f"{hp.name}[{i}]" + ) + for i in range(hp.n_elements) + ) + return params + + def kernel_term( kernel, coords=None, @@ -797,7 +856,8 @@ def kernel_term( momentum transfer). Default: ``x`` itself. amplitude : callable or array, optional ``amplitude(c, *amplitude_values) -> vector a``; the block becomes - ``outer(a, a) * K``. See :func:`constant_amplitude`, + ``outer(a, a) * K``. Like the kernel, it sees the *transformed* + coordinate: ``c.x`` is ``coords(x)``. See :func:`constant_amplitude`, :func:`exp_growth_amplitude`. amplitude_params : sequence of Parameter, optional Parameters consumed by ``amplitude``. @@ -808,19 +868,7 @@ def kernel_term( support : array_like of int, optional See :class:`Term`. """ - kparams = [] - for hp in kernel.hyperparameters: - if hp.fixed: - continue - if hp.n_elements == 1: - kparams.append(Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name)) - else: - kparams.extend( - Parameter( - f"{prefix}_{hp.name}_{i}", float, latex_name=f"{hp.name}[{i}]" - ) - for i in range(hp.n_elements) - ) + kparams = _kernel_params(kernel, prefix) nk = len(kparams) amplitude_params = tuple(amplitude_params) # with no free kernel hyperparameters and parameter-free coordinates, @@ -854,7 +902,3 @@ def fn(c, *values): coords=coords, constant=nk == 0 and not amplitude_params and not callable(amplitude), ) - - -discrepancy_term = kernel_term -"""Alias of :func:`kernel_term` (a GP model-discrepancy term).""" diff --git a/test/test_covariance.py b/test/test_covariance.py index cc707d9..481c8d0 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -141,6 +141,24 @@ def test_constant_flag_ignored_with_params(self): t = Term(lambda c, a: ones(c), (Parameter("a"),), kind="diag", constant=True) assert not t.is_constant + def test_constant_term_may_read_x(self): + # constant means "independent of ym"; x is invariant and readable + x = np.linspace(0.0, 2.0, 4) + t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) + cov = ConstraintCovariance([t], 4) + assert cov.is_constant + ctx = StackContext.constant(x, np.zeros(4), [np.arange(4)]) + np.testing.assert_allclose(cov.matrix(ctx), np.diag((0.1 * x) ** 2)) + # a mis-declared constant term (reads ym) fails loudly, not silently + bad = ConstraintCovariance( + [Term(lambda c: 0.1 * c.ym, kind="diag", constant=True)], 4 + ) + with pytest.raises(TypeError): + bad.matrix(ctx) + assert cov.matrix(single_block_ctx(x, np.zeros(4), np.ones(4))) is cov.matrix( + ctx + ) + class TestTermCoords: def test_coords_callable_applied_to_x(self): @@ -220,6 +238,21 @@ def test_non_term_raises(self): with pytest.raises(TypeError): ConstraintCovariance([np.eye(2)], 2) + def test_rebinding_to_a_different_stack_raises(self): + t = noise_term(Parameter("p")) + ConstraintCovariance([t], 4) + ConstraintCovariance([t], 4) # same stack (a masked view): fine + with pytest.raises(ValueError, match="already bound"): + ConstraintCovariance([t], 6) + + def test_local_context_checks_param_count(self): + s = Parameter("s") + t = Term(lambda c: c.x, kind="diag", coords=Transform(lambda a, s: s * a, (s,))) + t.bind(2) + ctx = single_block_ctx(np.ones(2), np.zeros(2), np.zeros(2)) + with pytest.raises(ValueError, match="expected 1 params"): + t.local_context(ctx) + # ---------------------------------------------------------------------------- # Gather-by-identity and structural properties @@ -467,6 +500,24 @@ def test_masked_magnitudes(self): v = 0.5 * m * self.ym assert np.allclose(S, np.outer(v, v)) + def test_length_one_magnitude_or_mask_raises(self): + # a length-1 array is not a scalar: it must not broadcast silently + with pytest.raises(ValueError, match="shape"): + assemble([offset_term(magnitude=np.array([0.2]))], self.ctx) + with pytest.raises(ValueError, match="shape"): + assemble([offset_term(magnitude=0.2, mask=np.array([1.0]))], self.ctx) + with pytest.raises(ValueError, match="shape"): + assemble( + [normalization_term(parameter=Parameter("n"), mask=np.array([1.0]))], + self.ctx, + (0.0,), + ) + + def test_zero_d_magnitude_is_scalar(self): + # exfor_tools stores scalar systematics as 0-d arrays + S = assemble([offset_term(magnitude=np.array(0.2))], self.ctx) + assert np.allclose(S, 0.04 * np.ones((3, 3))) + def test_magnitude_length_mismatch_raises(self): with pytest.raises(ValueError): assemble([offset_term(magnitude=np.ones(2))], self.ctx) @@ -554,24 +605,6 @@ def test_fixed_kernel_is_constant(self): term = kernel_term(kernel) assert term.params == () and term.is_constant - def test_constant_term_may_read_x(self): - # constant means "independent of ym"; x is invariant and readable - x = np.linspace(0.0, 2.0, 4) - t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) - cov = ConstraintCovariance([t], 4) - assert cov.is_constant - ctx = StackContext.constant(x, np.zeros(4), [np.arange(4)]) - np.testing.assert_allclose(cov.matrix(ctx), np.diag((0.1 * x) ** 2)) - # a mis-declared constant term (reads ym) fails loudly, not silently - bad = ConstraintCovariance( - [Term(lambda c: 0.1 * c.ym, kind="diag", constant=True)], 4 - ) - with pytest.raises(TypeError): - bad.matrix(ctx) - assert cov.matrix(single_block_ctx(x, np.zeros(4), np.ones(4))) is cov.matrix( - ctx - ) - def test_constant_amplitude_reproduces_constant_kernel(self): x = np.linspace(0.0, 2.0, 5) ctx = single_block_ctx(x, np.zeros(5), np.zeros(5)) @@ -589,7 +622,10 @@ def test_exp_growth_amplitude_and_coords(self): x = np.linspace(0.1, 3.0, 4) ctx = single_block_ctx(x, np.zeros(4), np.zeros(4)) la, sl = Parameter("log A"), Parameter("slope") - q = lambda x: 2.0 * np.sin(x / 2) # noqa: E731 + + def q(x): + return 2.0 * np.sin(x / 2) + term = kernel_term( Matern(1.0, nu=2.5), coords=q, From ff448c2407cec355bb764be8c22d7112170b8c43 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:22:09 -0400 Subject: [PATCH 18/24] Fix model_comparison sample handling, jitter and model-only draws predictive_draws and heldout_log_predictive validated model_samples against its own length, so the row check could never fire and a single 1-D posterior row [a0, a1] was reshaped to (2, 1) - two samples of a one-parameter model - before failing deep in Constraint._split. _rows now treats a 1-D input as one sample (as split_samples already did) and checks the row count only against an explicit n. _psd_factor added an absolute 1e-10 jitter to Sigma on every call, including the successful Cholesky path; in a log comparison space with 1e-8 variances that inflated every draw by ~1 %. Factor Sigma as-is first, retry with a jitter relative to the mean variance only when the plain Cholesky fails, and fall back to the eigen square root last. The model-only predictive no longer assembles the covariance at all: it stacks Constraint.predict and takes the active points. Rename elpd to log_posterior_predictive: it is the log-mean-exp of the joint held-out log likelihood over posterior samples, i.e. the joint log posterior predictive of the block, not the pointwise-summed elpd of Vehtari et al., and the old name invited comparison with ArviZ/LOO numbers that are not comparable. sharpness(levels=) becomes sharpness(percentiles=) so the two interval conventions in the module (probabilities in (0, 1) for coverage, percentiles in 0-100 here) no longer share a name. The default coverage levels are one module constant; scipy.linalg is dropped for numpy.linalg; docstrings gain the missing Returns and parameter descriptions; test imports are hoisted. Not changed: compare_logz still ignores the replicate count (it is informational; now said so in the docstring), and the log_jacobian wrapper stays because the design doc and API reference point to it. Co-Authored-By: Claude Fable 5 --- docs/api.rst | 2 +- src/rxmc/model_comparison.py | 107 +++++++++++++++++++++++----------- test/test_model_comparison.py | 58 ++++++++++++++---- 3 files changed, 121 insertions(+), 46 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index 29f54ee..52e98e0 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -142,7 +142,7 @@ nested-sampling evidence bookkeeping. rxmc.model_comparison.coverage_error rxmc.model_comparison.sharpness rxmc.model_comparison.heldout_log_predictive - rxmc.model_comparison.elpd + rxmc.model_comparison.log_posterior_predictive rxmc.model_comparison.logz_summary rxmc.model_comparison.compare_logz rxmc.model_comparison.log_jacobian diff --git a/src/rxmc/model_comparison.py b/src/rxmc/model_comparison.py index 1d371af..162c679 100644 --- a/src/rxmc/model_comparison.py +++ b/src/rxmc/model_comparison.py @@ -10,8 +10,9 @@ model-only predictive ``ym(theta)``). * :func:`coverage_curve`, :func:`coverage_error`, :func:`sharpness` — empirical calibration and width of those draws against the data. -* :func:`heldout_log_predictive`, :func:`elpd` — out-of-sample scoring on a - held-out constraint (e.g. ``constraint.complement()``). +* :func:`heldout_log_predictive`, :func:`log_posterior_predictive` — + out-of-sample scoring on a held-out constraint (e.g. + ``constraint.complement()``). * :func:`logz_summary`, :func:`compare_logz` — nested-sampling evidence bookkeeping with replicate-based errors and a conservative tie verdict. * :func:`log_jacobian` — the comparison-space Jacobian needed to compare @@ -27,7 +28,6 @@ from __future__ import annotations import numpy as np -import scipy as sc from scipy.special import logsumexp __all__ = [ @@ -37,7 +37,7 @@ "coverage_error", "sharpness", "heldout_log_predictive", - "elpd", + "log_posterior_predictive", "logz_summary", "compare_logz", "split_samples", @@ -54,20 +54,41 @@ def log_jacobian(constraint) -> float: return float(constraint.log_jacobian) +_DEFAULT_LEVELS = np.linspace(0.02, 0.98, 49) + + def _psd_factor(Sigma, jitter=1e-10): - """Lower factor ``L`` with ``L L^T = Sigma`` (Cholesky, eigen fallback).""" + """A factor ``L`` with ``L L^T = Sigma``. + + The lower Cholesky factor when ``Sigma`` is positive definite; otherwise + the Cholesky factor of ``Sigma`` plus a jitter *relative* to its mean + variance, and failing that a symmetric square root from the eigen + decomposition (negative eigenvalues clipped to zero). No jitter is added + on the successful path, so draws are never inflated. + """ + Sigma = np.asarray(Sigma, dtype=float) try: - return sc.linalg.cholesky(Sigma + jitter * np.eye(len(Sigma)), lower=True) + return np.linalg.cholesky(Sigma) + except np.linalg.LinAlgError: + pass + scale = max(float(np.mean(np.diag(Sigma))), np.finfo(float).tiny) + try: + return np.linalg.cholesky(Sigma + jitter * scale * np.eye(len(Sigma))) except np.linalg.LinAlgError: w, V = np.linalg.eigh(Sigma) return V * np.sqrt(np.clip(w, 0.0, None)) -def _rows(samples, n): +def _rows(samples, n=None): + """Posterior samples as a 2-D ``(n_samples, n_params)`` array. + + A 1-D input is one sample row (as in :func:`split_samples`). When ``n`` is + given the number of rows must match it. + """ samples = np.asarray(samples, dtype=float) if samples.ndim == 1: - samples = samples[:, None] - if samples.shape[0] != n: + samples = samples[None, :] + if n is not None and samples.shape[0] != n: raise ValueError(f"expected {n} sample rows, got {samples.shape[0]}") return samples @@ -93,22 +114,28 @@ def predictive_draws( constraint : Constraint The constraint whose predictive is wanted (its active points). model_samples : array_like, shape (n, n_model_params) - Posterior samples of the physical-model parameters. + Posterior samples of the physical-model parameters (a 1-D array is + one sample). cov_samples : array_like, shape (n, constraint.n_params), optional Matching samples of the constraint's parameters (required when the constraint has any). n_rep : int, optional Draws per posterior row (ignored when ``model_only``). rng : numpy.random.Generator, optional + Source of the standard-normal draws; a fresh default generator when + omitted. model_only : bool, optional + Return the predictions ``ym_i`` themselves instead of draws around + them (no covariance is assembled). Returns ------- - np.ndarray, shape (n * n_rep, n_data_pts) - Draws in the observations' comparison space. + np.ndarray + Draws in the observations' comparison space: shape + ``(n * n_rep, n_data_pts)``, or ``(n, n_data_pts)`` when ``model_only``. """ rng = np.random.default_rng() if rng is None else rng - model_samples = _rows(model_samples, len(np.asarray(model_samples))) + model_samples = _rows(model_samples) n = model_samples.shape[0] if constraint.n_params: if cov_samples is None: @@ -121,10 +148,8 @@ def predictive_draws( if model_only: out = np.empty((n, N)) for i in range(n): - ym, _ = constraint.predict_and_covariance( - tuple(model_samples[i]), tuple(cov_samples[i]) - ) - out[i] = ym + ym = np.concatenate(constraint.predict(*model_samples[i])) + out[i] = ym[constraint.active] return out out = np.empty((n * n_rep, N)) @@ -147,8 +172,8 @@ def coverage_curve(draws, y, levels=None) -> np.ndarray: y : array_like, shape (n_pts,) The data the draws are checked against (same space as ``draws``). levels : array_like, optional - Nominal central-interval probabilities in (0, 1). Defaults to - ``np.linspace(0.02, 0.98, 49)``. + Nominal central-interval probabilities in (0, 1). Defaults to 49 + levels from 0.02 to 0.98 (``_DEFAULT_LEVELS``). Returns ------- @@ -157,7 +182,7 @@ def coverage_curve(draws, y, levels=None) -> np.ndarray: """ draws = np.asarray(draws, dtype=float) y = np.asarray(y, dtype=float) - levels = np.linspace(0.02, 0.98, 49) if levels is None else np.asarray(levels) + levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels) out = np.empty(len(levels)) for i, lv in enumerate(levels): lo, hi = np.percentile(draws, [50 * (1 - lv), 50 * (1 + lv)], axis=0) @@ -167,18 +192,20 @@ def coverage_curve(draws, y, levels=None) -> np.ndarray: def coverage_error(draws, y, levels=None) -> float: """``max |coverage(level) - level|`` — a single calibration score.""" - levels = np.linspace(0.02, 0.98, 49) if levels is None else np.asarray(levels) + levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels) return float(np.max(np.abs(coverage_curve(draws, y, levels) - levels))) -def sharpness(draws, levels=(16, 84), transform=None) -> np.ndarray: - """Per-point width of the central predictive interval. +def sharpness(draws, percentiles=(16, 84), transform=None) -> np.ndarray: + """Per-point width of a central predictive interval. Parameters ---------- draws : array_like, shape (n_draws, n_pts) - levels : (float, float), optional - Percentiles of the interval; default the central 68 %. + percentiles : (float, float), optional + Lower and upper percentiles (in 0-100) bounding the interval; the + default is the central 68 %. Note :func:`coverage_curve` takes + interval *probabilities* in (0, 1) instead. transform : callable, optional Applied to the draws first (e.g. ``np.exp`` to report widths in raw space for a log comparison space, or ``np.log10``). @@ -186,7 +213,7 @@ def sharpness(draws, levels=(16, 84), transform=None) -> np.ndarray: draws = np.asarray(draws, dtype=float) if transform is not None: draws = transform(draws) - lo, hi = np.percentile(draws, levels, axis=0) + lo, hi = np.percentile(draws, percentiles, axis=0) return hi - lo @@ -195,14 +222,14 @@ def heldout_log_predictive(heldout_constraint, model_samples, cov_samples=None): ``heldout_constraint`` is typically ``fit_constraint.complement()``: the same observations, terms and parameters, with the held-out points active. The - score is the constraint's own (marginal-block) log likelihood at each - sample. + score is that constraint's log likelihood at each sample (a 1-D + ``model_samples`` is one sample). Returns ------- np.ndarray, shape (n,) """ - model_samples = _rows(model_samples, len(np.asarray(model_samples))) + model_samples = _rows(model_samples) n = model_samples.shape[0] if heldout_constraint.n_params: if cov_samples is None: @@ -220,11 +247,16 @@ def heldout_log_predictive(heldout_constraint, model_samples, cov_samples=None): ) -def elpd(logp_samples, logw=None) -> float: - """Expected log predictive density ``log E_post[p(y_held | theta)]``. +def log_posterior_predictive(logp_samples, logw=None) -> float: + """``log E_post[p(y_held | theta)]``: the joint log posterior predictive + density of the held-out block. - A log-mean-exp over posterior samples; pass ``logw`` (unnormalised log - importance weights, e.g. nested-sampling ``logwt``) for weighted samples. + A log-mean-exp over posterior samples of :func:`heldout_log_predictive` + values; pass ``logw`` (unnormalised log importance weights, e.g. + nested-sampling ``logwt``) for weighted samples. This is the joint + predictive of the whole held-out block, not the pointwise-summed ``elpd`` + of Vehtari et al.; divide by the number of held-out points for a + per-point score. """ logp = np.asarray(logp_samples, dtype=float) if logw is None: @@ -260,7 +292,8 @@ def compare_logz(a, b, sigma: float = 2.0) -> dict: Parameters ---------- a, b : (mean, err) or (mean, err, n) - As returned by :func:`logz_summary`. + As returned by :func:`logz_summary`; a trailing replicate count is + accepted and ignored (it is informational only). sigma : float, optional A difference smaller than ``sigma * hypot(err_a, err_b)`` is a ``"tie"``. @@ -286,6 +319,12 @@ def split_samples(config, samples): Row-wise :meth:`~rxmc.config.CalibrationConfig.split_parameters`: one covariance-sample block per parametric constraint, in ``config.evidence.parametric_constraints`` order. + + Returns + ------- + (np.ndarray, list of np.ndarray) + ``model_samples`` of shape ``(n, n_model_params)`` and one + ``(n, constraint.n_params)`` array per parametric constraint. """ samples = np.asarray(samples, dtype=float) if samples.ndim == 1: diff --git a/test/test_model_comparison.py b/test/test_model_comparison.py index f6ecfa8..a214528 100644 --- a/test/test_model_comparison.py +++ b/test/test_model_comparison.py @@ -1,20 +1,25 @@ """Tests for the sampler-agnostic ``rxmc.model_comparison`` utilities.""" import unittest +from unittest.mock import patch import numpy as np +from scipy import stats from scipy.special import logsumexp +from sklearn.gaussian_process.kernels import RBF from helpers import manual_mvn_loglike +from rxmc.config import CalibrationConfig, ParameterConfig from rxmc.constraint import Constraint -from rxmc.covariance import Term, noise_term +from rxmc.covariance import ConstraintCovariance, Term, kernel_term, noise_term +from rxmc.evidence import Evidence from rxmc.model_comparison import ( compare_logz, coverage_curve, coverage_error, - elpd, heldout_log_predictive, log_jacobian, + log_posterior_predictive, logz_summary, predictive_draws, sharpness, @@ -23,6 +28,7 @@ from rxmc.observation import Observation from rxmc.params import Parameter from rxmc.physical_model import Polynomial +from rxmc.priors import IndependentPrior from rxmc.transforms import log @@ -54,6 +60,38 @@ def test_model_only_returns_ym(self): np.testing.assert_allclose(d[0], self.y) np.testing.assert_allclose(d[1], self.x) + def test_model_only_skips_covariance_assembly(self): + kernel = RBF(length_scale=1.0) + c = Constraint( + [self.obs.masked([True, True, False, True, True])], + self.pm, + extra_terms=[kernel_term(kernel)], + ) + ym, _ = c.predict_and_covariance((1.0, 2.0), (0.0,)) + with patch.object(ConstraintCovariance, "matrix") as m: + d = predictive_draws(c, [1.0, 2.0], [0.0], model_only=True) + m.assert_not_called() + self.assertEqual(d.shape, (1, 4)) + np.testing.assert_allclose(d[0], ym) + + def test_one_dimensional_row_is_one_sample(self): + c = Constraint([self.obs], self.pm) + d = predictive_draws(c, [1.0, 2.0], n_rep=3, rng=np.random.default_rng(2)) + self.assertEqual(d.shape, (3, 5)) + eps = Parameter("log eps") + cp = Constraint([self.obs], self.pm, extra_terms=[noise_term(eps)]) + with self.assertRaises(ValueError): + predictive_draws(cp, [[1.0, 2.0], [1.0, 2.0]], [[0.0]]) + + def test_tiny_variances_not_inflated(self): + obs = Observation(self.x, self.y, y_stat_err=np.full(5, 1e-4)) + c = Constraint([obs], self.pm) + draws = predictive_draws( + c, [1.0, 2.0], n_rep=40000, rng=np.random.default_rng(3) + ) + var = draws.var(axis=0) + np.testing.assert_allclose(var, 1e-8, rtol=0.03) + def test_requires_cov_samples_when_parametric(self): c = Constraint([self.obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) with self.assertRaises(ValueError): @@ -88,6 +126,8 @@ def test_sharpness_width(self): np.testing.assert_allclose(w, 2 * 0.9945, atol=0.05) w_exp = sharpness(np.zeros((10, 2)), transform=np.exp) np.testing.assert_allclose(w_exp, 0.0) + w95 = sharpness(draws, percentiles=(2.5, 97.5)) + np.testing.assert_allclose(w95, 2 * 1.96, atol=0.15) class TestHeldout(unittest.TestCase): @@ -108,11 +148,13 @@ def test_heldout_log_predictive_matches_manual(self): cov = np.diag(err[2:] ** 2 + 0.01) self.assertAlmostEqual(lp[i], manual_mvn_loglike(y[2:], ym, cov)) - def test_elpd(self): + def test_log_posterior_predictive(self): lp = np.array([-1.0, -2.0, -0.5]) - self.assertAlmostEqual(elpd(lp), logsumexp(lp) - np.log(3)) + self.assertAlmostEqual(log_posterior_predictive(lp), logsumexp(lp) - np.log(3)) logw = np.array([0.0, -np.inf, 0.0]) - self.assertAlmostEqual(elpd(lp, logw), logsumexp(lp[[0, 2]]) - np.log(2)) + self.assertAlmostEqual( + log_posterior_predictive(lp, logw), logsumexp(lp[[0, 2]]) - np.log(2) + ) class TestLogZ(unittest.TestCase): @@ -143,12 +185,6 @@ def test_log_jacobian(self): class TestSplitSamples(unittest.TestCase): def test_split_rows(self): - from scipy import stats - - from rxmc.config import CalibrationConfig, ParameterConfig - from rxmc.evidence import Evidence - from rxmc.priors import IndependentPrior - pm = Polynomial(order=1) obs = Observation( np.arange(4.0), 1.0 + 2.0 * np.arange(4.0), y_stat_err=np.full(4, 0.1) From 75fb2818ac06fa1b4acc41ad2aa1dcdf58ce6ceb Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:25:31 -0400 Subject: [PATCH 19/24] Polish transforms, model and observation edges from the review Polynomial.evaluate reported len(self.params) in its parameter-count error, which counts the transform's parameters too; report order + 1. A contextual per_observation_scaling evaluated without a context now says so instead of raising a misleading "observation was not registered" KeyError, and it keeps its registered observations under a private attribute (the test checks the id-routing behaviour instead of reaching in). Transform.is_identity and inverse document that they are an object-identity test and parameter-free only, the composition closures share one argument unpacker, and _safe_log says it expects an ndarray. Observation.systematic_terms checks eagerly that the transform has an inverse when a normalisation systematic is reported (the failure used to surface at the first likelihood evaluation), explains why the offset and normalisation modes are linearised at y_raw and ym_raw respectively, and says what support=None means inside a multi-observation constraint. The elastic observation keeps the kinematics it already unpacks and reads k from them; the momentum_transfer docstring no longer suggests passing its array as a kernel coordinate transform, and the momentum-transfer study form checks the helper against the inline map. The base evaluate docstrings say they receive base parameters only, the ias potential docstrings are wrapped to the line length, and _xs states the two-or-three-tuple contract. The design doc notes that the latent scale parameters now come last and are named log_rho, unlike ScaledModel. Co-Authored-By: Claude Fable 5 --- docs/design.md | 4 ++- src/rxmc/elastic_diffxs_model.py | 7 ++++- src/rxmc/elastic_diffxs_observation.py | 8 ++++-- src/rxmc/ias_pn_model.py | 19 +++++++++---- src/rxmc/observation.py | 18 ++++++++++-- src/rxmc/physical_model.py | 10 +++---- src/rxmc/transforms.py | 38 +++++++++++++++++++------- test/test_constraint.py | 17 ++++++++---- test/test_covariance.py | 6 +++- test/test_observation.py | 10 +++++++ test/test_transforms.py | 5 ++++ 11 files changed, 107 insertions(+), 35 deletions(-) diff --git a/docs/design.md b/docs/design.md index 7439c55..fe892ce 100644 --- a/docs/design.md +++ b/docs/design.md @@ -111,7 +111,9 @@ is no wrapper class per use: spaces. Parametric transforms are rejected here. - **Parametric model transforms, on the model.** `PhysicalModel(params, transform=scale())` appends the transform's parameters to the model's and - applies it after `evaluate`. This is the Kennedy–O'Hagan latent scale ρ (it + applies it after `evaluate` (unlike the former `ScaledModel`, which prepended a + `log normalization` parameter, the scale parameters come *last* and default to + `log_rho` / `log_rho_i`). This is the Kennedy–O'Hagan latent scale ρ (it changes the *mean*, so it is not a covariance term); `per_observation_scaling(observations)` gives one ρᵢ per dataset, routed by observation identity. diff --git a/src/rxmc/elastic_diffxs_model.py b/src/rxmc/elastic_diffxs_model.py index 1b45fe2..4dd817f 100644 --- a/src/rxmc/elastic_diffxs_model.py +++ b/src/rxmc/elastic_diffxs_model.py @@ -84,7 +84,12 @@ def __init__( super().__init__(params, transform=transform) def _xs(self, ws, params): - """Evaluate the potentials on ``ws.radial_grid()`` and solve.""" + """Evaluate the potentials on ``ws.radial_grid()`` and solve. + + ``calculate_interaction_from_params`` returns either two argument + tuples ``(central, spin_orbit)`` or three ``(central, spin_orbit, + coulomb)``; anything else is an error. + """ args = self.calculate_interaction_from_params(ws, *params) if len(args) == 2: (central_args, spin_orbit_args), coulomb_args = args, () diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index 87d0d48..ea865c3 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -149,6 +149,7 @@ def __init__( ) self.constraint_workspace = constraint_ws self.visualization_workspace = vis_ws + self.kinematics = kinematics # Convert measurement to correct quantity and normalize to `b/sr` norm, normalized_y_units = self.calculate_normalization( @@ -173,7 +174,7 @@ def __init__( @property def k(self) -> float: """Entrance-channel wavenumber in fm^-1.""" - return float(self.constraint_workspace.kinematics.k) + return float(self.kinematics.k) @classmethod def from_measurement( @@ -322,8 +323,9 @@ def set_up_solver( def momentum_transfer(observation: ElasticDifferentialXSObservation) -> np.ndarray: r"""Momentum transfer :math:`q = 2k\sin(\theta/2)` (fm^-1) on the data angles. - Handy as a fixed coordinate array for a - :func:`~rxmc.covariance.kernel_term` in :math:`q`-space: + Returns the array of :math:`q` values, e.g. for plotting. For a + :func:`~rxmc.covariance.kernel_term` in :math:`q`-space pass the same map + as the term's coordinate transform of the angle instead: ``kernel_term(kernel, coords=lambda x: 2 * obs.k * np.sin(x / 2))``. """ return 2.0 * observation.k * np.sin(np.asarray(observation.x, dtype=float) / 2.0) diff --git a/src/rxmc/ias_pn_model.py b/src/rxmc/ias_pn_model.py index 4dae85f..3c5c719 100644 --- a/src/rxmc/ias_pn_model.py +++ b/src/rxmc/ias_pn_model.py @@ -51,15 +51,20 @@ def __init__( Parameters ---------- U_p_coulomb : callable - ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton Coulomb potential. + ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton Coulomb + potential. U_p_central : callable - ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton central potential. + ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton central + potential. U_p_spin_orbit : callable - ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — proton spin-orbit potential. + ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton spin-orbit + potential. U_n_central : callable - ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — neutron central potential. + ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the neutron central + potential. U_n_spin_orbit : callable - ``f(r, *args) -> np.ndarray`` (on the radial grid ``r``) — neutron spin-orbit potential. + ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the neutron spin-orbit + potential. calculate_params : callable ``f(workspace, *params) -> (args_p_coulomb, args_p_central, args_p_spin_orbit, args_n_central, args_n_spin_orbit)`` @@ -117,7 +122,9 @@ def evaluate( observation : IsobaricAnalogPNObservation Observation containing the pre-built workspace. *params : float - Physical-model parameter values, consumed by *calculate_params*. + Physical-model (base) parameter values, consumed by + *calculate_params*; transform parameters are split off by + ``__call__``. Returns ------- diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py index 9281008..95a177a 100644 --- a/src/rxmc/observation.py +++ b/src/rxmc/observation.py @@ -275,8 +275,11 @@ def systematic_terms(self, support=None) -> list: Parameters ---------- support : np.ndarray, optional - Indices of this observation's block in the stacked vector - (``None`` for a single-observation constraint). + Indices of this observation's block in the stacked vector. ``None`` + binds the terms to the whole constraint, which is right only for a + single-observation constraint; in a multi-observation constraint + they then fail loudly with a shape error, so pass the block's + support there (see :func:`rxmc.covariance.stacked_supports`). Returns ------- @@ -292,7 +295,11 @@ def reported(spec): return np.broadcast_to(np.asarray(spec, dtype=float), (self.n_data_pts,)) # the identity transform has unit Jacobian and trivial inverse, so the - # delta-method expressions below reduce to the plain magnitudes + # delta-method expressions below reduce to the plain magnitudes. The + # two modes are linearised at different points on purpose: the offset + # is an error on the *data*, so it is propagated at y_raw; the + # normalisation multiplies the *prediction*, so its mode eta * ym_raw is + # propagated at ym_raw. t = self.transform terms = [] omega = reported(self.y_sys_err_offset) @@ -302,6 +309,11 @@ def reported(spec): terms.append(offset_term(magnitude=omega, support=support)) eta = reported(self.y_sys_err_normalization) if eta is not None: + if not t.is_identity and t.inverse is None: + raise ValueError( + f"transform {t.name!r} has no inverse; the normalisation " + "systematic needs the physical-space prediction" + ) def basis(c): ym_raw = self._raw_prediction(c.ym) diff --git a/src/rxmc/physical_model.py b/src/rxmc/physical_model.py index ccd6a8f..b47ea22 100644 --- a/src/rxmc/physical_model.py +++ b/src/rxmc/physical_model.py @@ -76,12 +76,14 @@ def evaluate(self, observation: Observation, *params) -> np.ndarray: observation : Observation Observation containing the independent-variable grid. *params : float - Model parameter values. + Physical-model (base) parameter values only; any transform + parameters are split off by :meth:`__call__` before this is called. Returns ------- np.ndarray - Predicted observable values on the observation grid. + Predicted observable values on the observation grid (physical + space, before the model transform). Raises ------ @@ -144,9 +146,7 @@ def evaluate(self, observation: Observation, *params) -> np.ndarray: ``self.order + 1``. """ if len(params) != self.order + 1: - raise ValueError( - f"Expected {len(self.params)} parameters, got {len(params)}" - ) + raise ValueError(f"Expected {self.order + 1} parameters, got {len(params)}") x_powers = np.vander(observation.x, self.order + 1, increasing=True) y = np.dot(x_powers, np.asarray(params)) diff --git a/src/rxmc/transforms.py b/src/rxmc/transforms.py index 6e430b4..9b8483b 100644 --- a/src/rxmc/transforms.py +++ b/src/rxmc/transforms.py @@ -28,6 +28,15 @@ from .params import Parameter +def _unpack(contextual, args): + """Split a composed transform's positional ``args`` into ``(context, a, values)``.""" + if contextual: + context, a, *values = args + return context, a, values + a, *values = args + return None, a, values + + class Transform: """A numpy-style transform with optional parameters. @@ -79,11 +88,20 @@ def n_params(self) -> int: @property def is_identity(self) -> bool: + """Whether this is the module-level :data:`identity` singleton. + + An object-identity test, not a semantic one: ``Transform(lambda a: a)`` + or ``log | exp`` are not recognised and take no identity fast path. + """ return self is identity @property def inverse(self) -> "Transform | None": - """The inverse transform, or ``None`` if unknown.""" + """The inverse transform, or ``None`` if unknown. + + Only meaningful for parameter-free transforms (a parametric inverse + would need the same values, which are not carried along). + """ if self._inverse is None and self._inverse_factory is not None: self._inverse = self._inverse_factory() if self._inverse is None: @@ -124,18 +142,12 @@ def __or__(self, other) -> "Transform": contextual = f.contextual or g.contextual def fn(*args): - if contextual: - context, a, *values = args - else: - context, (a, *values) = None, args + context, a, values = _unpack(contextual, args) b = f(a, *values[:nf], context=context) return g(b, *values[nf:], context=context) def derivative(*args): - if contextual: - context, a, *values = args - else: - context, (a, *values) = None, args + context, a, values = _unpack(contextual, args) b = f(a, *values[:nf], context=context) return g.derivative(b, *values[nf:], context=context) * f.derivative( a, *values[:nf], context=context @@ -184,6 +196,7 @@ def _identity(a): def _safe_log(a): + """``log(a)`` for an ndarray ``a``, ``-inf`` where ``a <= 0`` (no warnings).""" out = np.full(np.shape(a), -np.inf, dtype=float) pos = a > 0 out[pos] = np.log(a[pos]) @@ -298,6 +311,11 @@ def per_observation_scaling( raise ValueError("need exactly one parameter per observation") def _value(context, values): + if context is None: + raise ValueError( + "per_observation_scaling is contextual: evaluate it through a " + "PhysicalModel, or pass context=observation" + ) i = index.get(id(_root(context))) if i is None: raise KeyError( @@ -319,5 +337,5 @@ def derivative(context, a, *values): derivative=derivative, name="per_observation_scaling", ) - t.observations = observations # keep ids alive + t._keepalive = observations # routing is id()-keyed: keep the objects alive return t diff --git a/test/test_constraint.py b/test/test_constraint.py index 57e6623..9b9e632 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -175,13 +175,17 @@ def test_holds_observation_references(self): # garbage-collected observation's id can never be recycled import gc - model = self.make_model([self.obs1, self.obs2]) + model = self.make_model( + [Observation(np.array([1.0]), np.array([1.0])), self.obs2] + ) gc.collect() - self.assertIs(model.transform.observations[0], self.obs1) mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) - np.testing.assert_allclose( - model(model.transform.observations[0], *mp), [2.0, 4.0, 6.0] - ) + np.testing.assert_allclose(model(self.obs2, *mp), [4.0, 8.0, 12.0]) + # the first observation is still registered, so a new object can never + # inherit its id and be routed to its scale + stranger = Observation(np.array([1.0]), np.array([1.0])) + with self.assertRaises(KeyError): + model(stranger, *mp) def test_unregistered_observation_raises(self): model = self.make_model([self.obs1]) @@ -459,6 +463,9 @@ def test_wrong_param_count_raises(self): obs = Observation(np.array([1.0]), np.array([1.0])) with self.assertRaises(ValueError): model(obs, 1.0) + # evaluate() counts base parameters only, not the transform's + with self.assertRaisesRegex(ValueError, "Expected 1 parameters"): + model.evaluate(obs, 1.0, 2.0) class TestMask(unittest.TestCase): diff --git a/test/test_covariance.py b/test/test_covariance.py index 481c8d0..86d4840 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -1,5 +1,7 @@ """Unit tests for the stacked-covariance core (:mod:`rxmc.covariance`).""" +from types import SimpleNamespace + import numpy as np import pytest from sklearn.gaussian_process.kernels import RBF, ConstantKernel, Matern, WhiteKernel @@ -25,6 +27,7 @@ x_basis, ym, ) +from rxmc.elastic_diffxs_observation import momentum_transfer from rxmc.likelihood_model import mahalanobis_distance_sqr_cholesky from rxmc.params import Parameter from rxmc.transforms import Transform @@ -776,7 +779,8 @@ def test_LKp_kernel_in_momentum_transfer(self): # b^2 I + s^2 11^T + a(q) a(q') RBF(|q - q'| / l_q), a = A q^(r/2) log_b, log_s, r_pow = Parameter("log_b"), Parameter("log_s"), Parameter("r") b, s, lq, r = 0.05, 0.05, 1.2, 0.8 - q = 2.0 * self.k * np.sin(self.x / 2) + q = momentum_transfer(SimpleNamespace(k=self.k, x=self.x)) + assert np.allclose(q, 2.0 * self.k * np.sin(self.x / 2)) terms = [ noise_term(log_b), offset_term(parameter=log_s), diff --git a/test/test_observation.py b/test/test_observation.py index 2e67864..4a1e51c 100644 --- a/test/test_observation.py +++ b/test/test_observation.py @@ -212,6 +212,16 @@ def test_parametric_transform_rejected(self): with self.assertRaises(ValueError): Observation(self.x, self.y, transform=scale()) + def test_normalisation_systematic_needs_inverse(self): + obs = Observation( + self.x, self.y, y_sys_err_normalization=0.1, transform=np.sqrt + ) + with self.assertRaisesRegex(ValueError, "no inverse"): + obs.systematic_terms() + # an offset alone is propagated at the data and needs no inverse + obs2 = Observation(self.x, self.y, y_sys_err_offset=0.1, transform=np.sqrt) + self.assertEqual(len(obs2.systematic_terms()), 1) + def test_plain_callable_accepted(self): obs = Observation(self.x, self.y, transform=np.sqrt) np.testing.assert_allclose(obs.y, np.sqrt(self.y)) diff --git a/test/test_transforms.py b/test/test_transforms.py index 7bb3c44..f1e4edc 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -108,6 +108,11 @@ def test_masked_view_routes_to_root(self): with self.assertRaises(ValueError): per_observation_scaling([self.o2, view]) + def test_missing_context_raises(self): + t = per_observation_scaling([self.o1]) + with self.assertRaisesRegex(ValueError, "contextual"): + t(np.array([1.0]), 0.0) + def test_linear_and_custom_parameters(self): t = per_observation_scaling([self.o1], log=False) self.assertEqual(t.params[0].name, "rho_0") From b8bc7d800aa84f4ce109c8c6dec4e9b0e0c29a57 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:28:50 -0400 Subject: [PATCH 20/24] Sync docs and example notebooks with the reviewed API Add the module-level identity, log and exp transforms to the API reference (they are used throughout the README, design doc and tests but had no entry), and document StackContext's fields as constructor parameters so its autosummary page no longer duplicates the attribute descriptions under sphinx -W. Bring the example notebooks back in line with the code: the stored output in measurement_to_calibration that still printed the old RankOneTerm class names now shows Term, the gp_discrepancy prose refers to kernel_term rather than the dropped discrepancy_term alias, and linear_calibration_demo is re-executed so its help() output shows the current statistical_term signature instead of DenseTerm. Co-Authored-By: Claude Fable 5 --- docs/api.rst | 3 + examples/gp_discrepancy.ipynb | 4 +- examples/linear_calibration_demo.ipynb | 438 +++++++++++++--------- examples/measurement_to_calibration.ipynb | 2 +- src/rxmc/covariance.py | 2 +- 5 files changed, 261 insertions(+), 188 deletions(-) diff --git a/docs/api.rst b/docs/api.rst index 52e98e0..c1d869c 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -55,6 +55,9 @@ as a latent normalisation) and covariance terms (coordinate transforms). rxmc.transforms.Transform rxmc.transforms.as_transform + rxmc.transforms.identity + rxmc.transforms.log + rxmc.transforms.exp rxmc.transforms.scale rxmc.transforms.per_observation_scaling diff --git a/examples/gp_discrepancy.ipynb b/examples/gp_discrepancy.ipynb index 38406b5..236a733 100644 --- a/examples/gp_discrepancy.ipynb +++ b/examples/gp_discrepancy.ipynb @@ -538,7 +538,7 @@ "source": [ "## Takeaways\n", "\n", - "- A GP discrepancy is **just another covariance `Term`** — `discrepancy_term`\n", + "- A GP discrepancy is **just another covariance `Term`** — `kernel_term`\n", " (a `kernel_term`) added to the constraint. Its hyperparameters become\n", " constraint parameters and are sampled like any other nuisance.\n", "- The kernel term only inflates the covariance at the data points. To predict the\n", @@ -560,7 +560,7 @@ "$n + {}^{40}$Ca elastic scattering data from a **full** optical potential\n", "(volume + surface absorption), then fit it with a **deficient** potential that\n", "has no surface term. The missing physics leaves a smooth, *angle-correlated*\n", - "residual — exactly what a `discrepancy_term` over the angle grid absorbs.\n" + "residual — exactly what a `kernel_term` over the angle grid absorbs.\n" ] }, { diff --git a/examples/linear_calibration_demo.ipynb b/examples/linear_calibration_demo.ipynb index 93b6152..500f59f 100644 --- a/examples/linear_calibration_demo.ipynb +++ b/examples/linear_calibration_demo.ipynb @@ -16,10 +16,10 @@ "id": "69d96b52-427c-4345-8622-d2726544a77c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:02.712511Z", - "iopub.status.busy": "2026-08-11T03:09:02.712346Z", - "iopub.status.idle": "2026-08-11T03:09:05.354221Z", - "shell.execute_reply": "2026-08-11T03:09:05.353431Z" + "iopub.execute_input": "2026-09-09T18:23:07.173521Z", + "iopub.status.busy": "2026-09-09T18:23:07.173398Z", + "iopub.status.idle": "2026-09-09T18:23:09.655789Z", + "shell.execute_reply": "2026-09-09T18:23:09.655058Z" } }, "outputs": [ @@ -48,10 +48,10 @@ "id": "315006bb-c255-4555-b458-e00bfef26ef9", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.355925Z", - "iopub.status.busy": "2026-08-11T03:09:05.355653Z", - "iopub.status.idle": "2026-08-11T03:09:05.358653Z", - "shell.execute_reply": "2026-08-11T03:09:05.357898Z" + "iopub.execute_input": "2026-09-09T18:23:09.657738Z", + "iopub.status.busy": "2026-09-09T18:23:09.657494Z", + "iopub.status.idle": "2026-09-09T18:23:09.660733Z", + "shell.execute_reply": "2026-09-09T18:23:09.659881Z" } }, "outputs": [], @@ -73,10 +73,10 @@ "id": "ab500ce6-552f-4c9e-9b0f-648d456e4a53", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.360296Z", - "iopub.status.busy": "2026-08-11T03:09:05.360000Z", - "iopub.status.idle": "2026-08-11T03:09:05.363673Z", - "shell.execute_reply": "2026-08-11T03:09:05.362944Z" + "iopub.execute_input": "2026-09-09T18:23:09.662224Z", + "iopub.status.busy": "2026-09-09T18:23:09.661954Z", + "iopub.status.idle": "2026-09-09T18:23:09.665195Z", + "shell.execute_reply": "2026-09-09T18:23:09.664616Z" } }, "outputs": [ @@ -149,10 +149,10 @@ "id": "0669a9b0-3941-429b-887f-edcfeb909453", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.365347Z", - "iopub.status.busy": "2026-08-11T03:09:05.365169Z", - "iopub.status.idle": "2026-08-11T03:09:05.368679Z", - "shell.execute_reply": "2026-08-11T03:09:05.368006Z" + "iopub.execute_input": "2026-09-09T18:23:09.666500Z", + "iopub.status.busy": "2026-09-09T18:23:09.666383Z", + "iopub.status.idle": "2026-09-09T18:23:09.669683Z", + "shell.execute_reply": "2026-09-09T18:23:09.668842Z" } }, "outputs": [ @@ -163,7 +163,7 @@ "Help on class PhysicalModel in module rxmc.physical_model:\n", "\n", "class PhysicalModel(builtins.object)\n", - " | PhysicalModel(params: list[rxmc.params.Parameter])\n", + " | PhysicalModel(params: list[rxmc.params.Parameter], transform=None)\n", " |\n", " | Abstract base class for parametric physical models.\n", " |\n", @@ -172,20 +172,35 @@ " | measurement $\\{x_i,\\, y(x_i)\\}$ encapsulated in an\n", " | :class:`~rxmc.observation.Observation`.\n", " |\n", + " | Subclasses implement :meth:`evaluate` in physical space. An optional\n", + " | *parametric* ``transform`` (see :mod:`rxmc.transforms`) is applied on top by\n", + " | :meth:`__call__`; its parameters are appended to :attr:`params` so they flow\n", + " | through the ordinary model-parameter machinery (priors, ``split_parameters``).\n", + " | Typical uses are a latent normalisation :func:`rxmc.transforms.scale` or one\n", + " | per dataset via :func:`rxmc.transforms.per_observation_scaling`. Comparison-\n", + " | space transforms (e.g. comparing in log space) are *not* the model's\n", + " | business: declare them on the :class:`~rxmc.observation.Observation`.\n", + " |\n", " | Parameters\n", " | ----------\n", " | params : list of Parameter\n", - " | Parameters that define the model. Each entry should carry a name\n", + " | Physical parameters of the model. Each entry should carry a name\n", " | and a data type.\n", + " | transform : Transform or callable, optional\n", + " | Model-side transform ``y -> transform(y, *values)`` applied after\n", + " | :meth:`evaluate`. Its parameters (if any) are appended to ``params``.\n", " |\n", " | Methods defined here:\n", " |\n", " | __call__(self, observation: rxmc.observation.Observation, *params) -> numpy.ndarray\n", - " | Call self as a function.\n", + " | Physical-space :meth:`evaluate` followed by the model transform.\n", " |\n", - " | __init__(self, params: list[rxmc.params.Parameter])\n", + " | __init__(self, params: list[rxmc.params.Parameter], transform=None)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", + " | apply_transform(self, observation, y, transform_values=())\n", + " | Apply the model-side transform to a physical-space prediction.\n", + " |\n", " | evaluate(self, observation: rxmc.observation.Observation, *params) -> numpy.ndarray\n", " | Evaluate the model at the given parameter values.\n", " |\n", @@ -208,6 +223,9 @@ " | NotImplementedError\n", " | Always — subclasses must implement this method.\n", " |\n", + " | split_params(self, params)\n", + " | Split a full parameter tuple into ``(base_params, transform_values)``.\n", + " |\n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " |\n", @@ -240,10 +258,10 @@ "id": "3c64a7e3-c4a4-41e4-a7de-34eb7ab4728a", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.370349Z", - "iopub.status.busy": "2026-08-11T03:09:05.370147Z", - "iopub.status.idle": "2026-08-11T03:09:05.373852Z", - "shell.execute_reply": "2026-08-11T03:09:05.373217Z" + "iopub.execute_input": "2026-09-09T18:23:09.670969Z", + "iopub.status.busy": "2026-09-09T18:23:09.670850Z", + "iopub.status.idle": "2026-09-09T18:23:09.674074Z", + "shell.execute_reply": "2026-09-09T18:23:09.673577Z" } }, "outputs": [ @@ -254,7 +272,7 @@ "Help on class Observation in module rxmc.observation:\n", "\n", "class Observation(builtins.object)\n", - " | Observation(x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None)\n", + " | Observation(x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None, transform=None, mask=None)\n", " |\n", " | Experimental data: ``x``, ``y``, and the statistical error on ``y``.\n", " |\n", @@ -274,13 +292,36 @@ " | inert metadata; see :meth:`systematic_terms`.\n", " | label : str, optional\n", " | Human-readable dataset identifier used in error messages.\n", + " | transform : Transform or callable, optional\n", + " | Parameter-free *comparison-space* transform (see :mod:`rxmc.transforms`).\n", + " | Pass **raw** ``y``: the observation stores ``y = transform(y_raw)`` and\n", + " | propagates ``y_stat_err`` by the delta method, and the\n", + " | :class:`~rxmc.constraint.Constraint` applies the same transform to the\n", + " | model prediction — so ``transform=rxmc.transforms.log`` compares in log\n", + " | space with the model written once, in physical space.\n", + " | mask : array_like of bool, optional\n", + " | Which points are *active* in a likelihood (default all). Inactive\n", + " | points stay in the block (supports/terms are authored over all points)\n", + " | but are excluded from the residual; use :meth:`masked` /\n", + " | :meth:`masked_where` to derive fit/held-out views.\n", " |\n", " | Attributes\n", " | ----------\n", " | x, y : np.ndarray\n", - " | The data.\n", + " | The data, ``y`` in comparison space.\n", + " | y_raw, y_stat_err_raw : np.ndarray\n", + " | ``y`` and its statistical error as given (physical space).\n", " | y_stat_err : np.ndarray\n", - " | Statistical error on ``y`` (raw, not squared).\n", + " | Statistical error on ``y`` in comparison space (raw, not squared).\n", + " | transform : Transform\n", + " | The comparison-space transform (identity by default).\n", + " | mask : np.ndarray of bool\n", + " | Active points.\n", + " | identity : Observation\n", + " | The root observation this one is a view of. Views made by\n", + " | :meth:`masked` share it, so anything routing by observation (e.g.\n", + " | :func:`rxmc.transforms.per_observation_scaling`) treats a masked view\n", + " | and its root as the same dataset.\n", " | y_sys_err_normalization : float or np.ndarray or None\n", " | Fractional normalisation uncertainty (dimensionless).\n", " | y_sys_err_offset : float or np.ndarray or None\n", @@ -292,13 +333,23 @@ " |\n", " | Methods defined here:\n", " |\n", - " | __init__(self, x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None)\n", + " | __init__(self, x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None, transform=None, mask=None)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " |\n", + " | masked(self, mask, label=None)\n", + " | A shallow copy of this observation with a new point mask.\n", + " |\n", + " | No data or pre-computed workspaces are rebuilt: the copy shares them and\n", + " | only changes which points enter a likelihood.\n", + " |\n", + " | masked_where(self, predicate, label=None)\n", + " | :meth:`masked` with ``mask = predicate(x)`` (points where it is True).\n", + " |\n", " | num_pts_within_interval(self, ylow: numpy.ndarray, yhigh: numpy.ndarray, xlim=None)\n", - " | Number of points of ``y`` that fall within ``[ylow, yhigh)``.\n", + " | Number of active points of ``y`` that fall within ``[ylow, yhigh)``.\n", " |\n", - " | Useful for empirical-coverage diagnostics.\n", + " | Useful for empirical-coverage diagnostics. ``ylow``/``yhigh`` are in\n", + " | comparison space and indexed over *all* points of the block.\n", " |\n", " | Parameters\n", " | ----------\n", @@ -307,31 +358,36 @@ " | xlim : tuple, optional\n", " | ``(x_min, x_max)`` range to restrict the count.\n", " |\n", - " | statistical_term(self, support) -> rxmc.covariance.DenseTerm\n", + " | statistical_term(self, support=None)\n", " | The always-on, genuinely uncorrelated statistical diagonal.\n", " |\n", " | Parameters\n", " | ----------\n", - " | support : np.ndarray\n", - " | Indices of this observation's block in the stacked vector.\n", + " | support : np.ndarray, optional\n", + " | Indices of this observation's block in the stacked vector\n", + " | (``None`` for a single-observation constraint).\n", " |\n", " | Returns\n", " | -------\n", - " | DenseTerm\n", - " | ``diag(y_stat_err**2)`` on ``support``.\n", + " | Term\n", + " | ``diag(y_stat_err**2)`` on ``support`` (comparison space).\n", " |\n", - " | systematic_terms(self, support) -> list\n", + " | systematic_terms(self, support=None) -> list\n", " | This dataset's reported correlated systematics as fixed rank-one terms.\n", " |\n", " | Opt-in — **not** added to any covariance automatically. Pass the result\n", - " | via ``Constraint(extra_terms=[*obs.systematic_terms(support), ...])``.\n", + " | via ``Constraint(extra_terms=[*obs.systematic_terms(), ...])``.\n", " | Zero magnitudes are skipped, so an observation without reported\n", - " | systematics yields an empty list.\n", + " | systematics yields an empty list. Magnitudes are reported in physical\n", + " | space and propagated to the comparison space by the delta method\n", + " | (``|t'| * omega`` for an offset, ``|t'(ym_raw)| * eta * ym_raw`` for a\n", + " | normalisation).\n", " |\n", " | Parameters\n", " | ----------\n", - " | support : np.ndarray\n", - " | Indices of this observation's block in the stacked vector.\n", + " | support : np.ndarray, optional\n", + " | Indices of this observation's block in the stacked vector\n", + " | (``None`` for a single-observation constraint).\n", " |\n", " | Returns\n", " | -------\n", @@ -341,6 +397,20 @@ " | (``eta**2 * outer(ym, ym)``).\n", " |\n", " | ----------------------------------------------------------------------\n", + " | Readonly properties defined here:\n", + " |\n", + " | log_jacobian\n", + " | ``sum(log |t'(y_raw)|)`` over the active points.\n", + " |\n", + " | The log-Jacobian of the comparison-space transform: a constant in the\n", + " | parameters, needed only to compare marginal likelihoods (log Z) across\n", + " | different comparison spaces (``log Z_raw = log Z_transformed +\n", + " | log_jacobian``). Zero for the identity.\n", + " |\n", + " | n_active\n", + " | Number of active (unmasked) points.\n", + " |\n", + " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " |\n", " | __dict__\n", @@ -370,10 +440,10 @@ "id": "9f859e53-c6f9-4d88-b7bf-bbc5bc9ab686", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.375707Z", - "iopub.status.busy": "2026-08-11T03:09:05.375530Z", - "iopub.status.idle": "2026-08-11T03:09:05.379066Z", - "shell.execute_reply": "2026-08-11T03:09:05.378458Z" + "iopub.execute_input": "2026-09-09T18:23:09.675382Z", + "iopub.status.busy": "2026-09-09T18:23:09.675238Z", + "iopub.status.idle": "2026-09-09T18:23:09.679017Z", + "shell.execute_reply": "2026-09-09T18:23:09.678407Z" } }, "outputs": [], @@ -409,10 +479,10 @@ "id": "b83c6308-935b-4c8a-b1ef-0d65677ec809", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.380724Z", - "iopub.status.busy": "2026-08-11T03:09:05.380525Z", - "iopub.status.idle": "2026-08-11T03:09:05.383075Z", - "shell.execute_reply": "2026-08-11T03:09:05.382377Z" + "iopub.execute_input": "2026-09-09T18:23:09.680343Z", + "iopub.status.busy": "2026-09-09T18:23:09.680183Z", + "iopub.status.idle": "2026-09-09T18:23:09.682461Z", + "shell.execute_reply": "2026-09-09T18:23:09.681975Z" } }, "outputs": [], @@ -434,17 +504,17 @@ "id": "27f09315-06dc-44ee-8190-f5d393974b68", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.384860Z", - "iopub.status.busy": "2026-08-11T03:09:05.384688Z", - "iopub.status.idle": "2026-08-11T03:09:05.390726Z", - "shell.execute_reply": "2026-08-11T03:09:05.390004Z" + "iopub.execute_input": "2026-09-09T18:23:09.683764Z", + "iopub.status.busy": "2026-09-09T18:23:09.683648Z", + "iopub.status.idle": "2026-09-09T18:23:09.688346Z", + "shell.execute_reply": "2026-09-09T18:23:09.687910Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([1, 2, 3])" + "array([1., 2., 3.])" ] }, "execution_count": 8, @@ -464,10 +534,10 @@ "id": "f5de0b99-d85b-4acf-bfb4-eabdc4580688", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.392309Z", - "iopub.status.busy": "2026-08-11T03:09:05.392096Z", - "iopub.status.idle": "2026-08-11T03:09:05.395544Z", - "shell.execute_reply": "2026-08-11T03:09:05.395004Z" + "iopub.execute_input": "2026-09-09T18:23:09.689720Z", + "iopub.status.busy": "2026-09-09T18:23:09.689590Z", + "iopub.status.idle": "2026-09-09T18:23:09.692850Z", + "shell.execute_reply": "2026-09-09T18:23:09.692199Z" } }, "outputs": [ @@ -492,17 +562,17 @@ "id": "bf846a07-d5d2-4f34-838c-06b1deca0739", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.397370Z", - "iopub.status.busy": "2026-08-11T03:09:05.397069Z", - "iopub.status.idle": "2026-08-11T03:09:05.400664Z", - "shell.execute_reply": "2026-08-11T03:09:05.399966Z" + "iopub.execute_input": "2026-09-09T18:23:09.694092Z", + "iopub.status.busy": "2026-09-09T18:23:09.693952Z", + "iopub.status.idle": "2026-09-09T18:23:09.696803Z", + "shell.execute_reply": "2026-09-09T18:23:09.696336Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([3, 5, 7])" + "array([3., 5., 7.])" ] }, "execution_count": 10, @@ -521,10 +591,10 @@ "id": "fb8188e6-7e47-479f-8b72-a8825ae5dacd", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.402252Z", - "iopub.status.busy": "2026-08-11T03:09:05.402076Z", - "iopub.status.idle": "2026-08-11T03:09:05.405624Z", - "shell.execute_reply": "2026-08-11T03:09:05.405027Z" + "iopub.execute_input": "2026-09-09T18:23:09.698094Z", + "iopub.status.busy": "2026-09-09T18:23:09.697955Z", + "iopub.status.idle": "2026-09-09T18:23:09.700984Z", + "shell.execute_reply": "2026-09-09T18:23:09.700393Z" } }, "outputs": [ @@ -532,8 +602,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[3 5 7]\n", - "[3 5 7]\n" + "[3. 5. 7.]\n", + "[3. 5. 7.]\n" ] } ], @@ -564,10 +634,10 @@ "id": "d251f717-09be-4280-b59d-de137fd7cfc2", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.407376Z", - "iopub.status.busy": "2026-08-11T03:09:05.407202Z", - "iopub.status.idle": "2026-08-11T03:09:05.409979Z", - "shell.execute_reply": "2026-08-11T03:09:05.409330Z" + "iopub.execute_input": "2026-09-09T18:23:09.702304Z", + "iopub.status.busy": "2026-09-09T18:23:09.702188Z", + "iopub.status.idle": "2026-09-09T18:23:09.704818Z", + "shell.execute_reply": "2026-09-09T18:23:09.704037Z" } }, "outputs": [], @@ -592,10 +662,10 @@ "id": "016fc2de-c206-44c1-916a-a3b663a8fd25", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.411250Z", - "iopub.status.busy": "2026-08-11T03:09:05.411020Z", - "iopub.status.idle": "2026-08-11T03:09:05.413480Z", - "shell.execute_reply": "2026-08-11T03:09:05.412844Z" + "iopub.execute_input": "2026-09-09T18:23:09.706006Z", + "iopub.status.busy": "2026-09-09T18:23:09.705881Z", + "iopub.status.idle": "2026-09-09T18:23:09.708580Z", + "shell.execute_reply": "2026-09-09T18:23:09.707834Z" } }, "outputs": [], @@ -610,10 +680,10 @@ "id": "d28fcb22-9ca7-4846-9cba-24b7b4808e2c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.414714Z", - "iopub.status.busy": "2026-08-11T03:09:05.414573Z", - "iopub.status.idle": "2026-08-11T03:09:05.417834Z", - "shell.execute_reply": "2026-08-11T03:09:05.417232Z" + "iopub.execute_input": "2026-09-09T18:23:09.709810Z", + "iopub.status.busy": "2026-09-09T18:23:09.709694Z", + "iopub.status.idle": "2026-09-09T18:23:09.712937Z", + "shell.execute_reply": "2026-09-09T18:23:09.712205Z" } }, "outputs": [], @@ -637,10 +707,10 @@ "id": "70a97727-68ec-4eea-880f-203a3f0817cc", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.419363Z", - "iopub.status.busy": "2026-08-11T03:09:05.419191Z", - "iopub.status.idle": "2026-08-11T03:09:05.426888Z", - "shell.execute_reply": "2026-08-11T03:09:05.426199Z" + "iopub.execute_input": "2026-09-09T18:23:09.714160Z", + "iopub.status.busy": "2026-09-09T18:23:09.714001Z", + "iopub.status.idle": "2026-09-09T18:23:09.719998Z", + "shell.execute_reply": "2026-09-09T18:23:09.719429Z" } }, "outputs": [], @@ -665,10 +735,10 @@ "id": "e8476136-5ab0-42c7-a3fe-88539ee7a019", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.428500Z", - "iopub.status.busy": "2026-08-11T03:09:05.428328Z", - "iopub.status.idle": "2026-08-11T03:09:07.420058Z", - "shell.execute_reply": "2026-08-11T03:09:07.419311Z" + "iopub.execute_input": "2026-09-09T18:23:09.721383Z", + "iopub.status.busy": "2026-09-09T18:23:09.721216Z", + "iopub.status.idle": "2026-09-09T18:23:11.427947Z", + "shell.execute_reply": "2026-09-09T18:23:11.427321Z" } }, "outputs": [ @@ -684,7 +754,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -713,10 +783,10 @@ "id": "30ed8fc8-d5e9-4e58-85e8-aba6b8683d00", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.421881Z", - "iopub.status.busy": "2026-08-11T03:09:07.421708Z", - "iopub.status.idle": "2026-08-11T03:09:07.579757Z", - "shell.execute_reply": "2026-08-11T03:09:07.579177Z" + "iopub.execute_input": "2026-09-09T18:23:11.429402Z", + "iopub.status.busy": "2026-09-09T18:23:11.429243Z", + "iopub.status.idle": "2026-09-09T18:23:11.567585Z", + "shell.execute_reply": "2026-09-09T18:23:11.566891Z" } }, "outputs": [ @@ -768,10 +838,10 @@ "id": "d07c4b8c-fb40-4af3-9a76-7c798943a213", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.581645Z", - "iopub.status.busy": "2026-08-11T03:09:07.581477Z", - "iopub.status.idle": "2026-08-11T03:09:07.585234Z", - "shell.execute_reply": "2026-08-11T03:09:07.584428Z" + "iopub.execute_input": "2026-09-09T18:23:11.568951Z", + "iopub.status.busy": "2026-09-09T18:23:11.568808Z", + "iopub.status.idle": "2026-09-09T18:23:11.572069Z", + "shell.execute_reply": "2026-09-09T18:23:11.571523Z" } }, "outputs": [], @@ -798,10 +868,10 @@ "id": "664d9b5e-d7d2-4d08-91f6-763e75b40ab4", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.586896Z", - "iopub.status.busy": "2026-08-11T03:09:07.586730Z", - "iopub.status.idle": "2026-08-11T03:09:07.736211Z", - "shell.execute_reply": "2026-08-11T03:09:07.735557Z" + "iopub.execute_input": "2026-09-09T18:23:11.573283Z", + "iopub.status.busy": "2026-09-09T18:23:11.573166Z", + "iopub.status.idle": "2026-09-09T18:23:11.702710Z", + "shell.execute_reply": "2026-09-09T18:23:11.701937Z" } }, "outputs": [ @@ -879,10 +949,10 @@ "id": "1ca25e05-9b9d-4c22-94bf-0caf31854835", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.737939Z", - "iopub.status.busy": "2026-08-11T03:09:07.737759Z", - "iopub.status.idle": "2026-08-11T03:09:07.741990Z", - "shell.execute_reply": "2026-08-11T03:09:07.741374Z" + "iopub.execute_input": "2026-09-09T18:23:11.704213Z", + "iopub.status.busy": "2026-09-09T18:23:11.704025Z", + "iopub.status.idle": "2026-09-09T18:23:11.708161Z", + "shell.execute_reply": "2026-09-09T18:23:11.707585Z" } }, "outputs": [ @@ -965,10 +1035,10 @@ "id": "8b698c69-7a23-4955-ab7a-15107774bec9", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.743560Z", - "iopub.status.busy": "2026-08-11T03:09:07.743395Z", - "iopub.status.idle": "2026-08-11T03:09:07.745930Z", - "shell.execute_reply": "2026-08-11T03:09:07.745391Z" + "iopub.execute_input": "2026-09-09T18:23:11.709520Z", + "iopub.status.busy": "2026-09-09T18:23:11.709400Z", + "iopub.status.idle": "2026-09-09T18:23:11.711656Z", + "shell.execute_reply": "2026-09-09T18:23:11.711076Z" } }, "outputs": [], @@ -982,10 +1052,10 @@ "id": "211990b6-85ba-47b1-89c4-796c5b396168", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.747662Z", - "iopub.status.busy": "2026-08-11T03:09:07.747493Z", - "iopub.status.idle": "2026-08-11T03:09:07.750438Z", - "shell.execute_reply": "2026-08-11T03:09:07.749818Z" + "iopub.execute_input": "2026-09-09T18:23:11.713223Z", + "iopub.status.busy": "2026-09-09T18:23:11.713084Z", + "iopub.status.idle": "2026-09-09T18:23:11.715482Z", + "shell.execute_reply": "2026-09-09T18:23:11.714951Z" } }, "outputs": [], @@ -1011,10 +1081,10 @@ "id": "51b72666-3986-42f1-8262-8de23eb87ee3", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.752100Z", - "iopub.status.busy": "2026-08-11T03:09:07.751936Z", - "iopub.status.idle": "2026-08-11T03:09:07.755357Z", - "shell.execute_reply": "2026-08-11T03:09:07.754829Z" + "iopub.execute_input": "2026-09-09T18:23:11.716786Z", + "iopub.status.busy": "2026-09-09T18:23:11.716668Z", + "iopub.status.idle": "2026-09-09T18:23:11.720105Z", + "shell.execute_reply": "2026-09-09T18:23:11.719481Z" } }, "outputs": [ @@ -1047,10 +1117,10 @@ "id": "a845e4ff-1d51-455b-97c8-e7ad561a89ce", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.757071Z", - "iopub.status.busy": "2026-08-11T03:09:07.756908Z", - "iopub.status.idle": "2026-08-11T03:09:07.760621Z", - "shell.execute_reply": "2026-08-11T03:09:07.759942Z" + "iopub.execute_input": "2026-09-09T18:23:11.721495Z", + "iopub.status.busy": "2026-09-09T18:23:11.721360Z", + "iopub.status.idle": "2026-09-09T18:23:11.724730Z", + "shell.execute_reply": "2026-09-09T18:23:11.724208Z" } }, "outputs": [ @@ -1084,10 +1154,10 @@ "id": "dd9fa5b9-10ab-4649-96c0-58f9cb6896f6", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.762137Z", - "iopub.status.busy": "2026-08-11T03:09:07.761976Z", - "iopub.status.idle": "2026-08-11T03:09:07.766123Z", - "shell.execute_reply": "2026-08-11T03:09:07.765448Z" + "iopub.execute_input": "2026-09-09T18:23:11.725920Z", + "iopub.status.busy": "2026-09-09T18:23:11.725804Z", + "iopub.status.idle": "2026-09-09T18:23:11.728856Z", + "shell.execute_reply": "2026-09-09T18:23:11.728456Z" } }, "outputs": [ @@ -1233,10 +1303,10 @@ "id": "1ff7c728-b0ac-4c48-8779-19da58277cc9", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.767747Z", - "iopub.status.busy": "2026-08-11T03:09:07.767554Z", - "iopub.status.idle": "2026-08-11T03:09:07.770332Z", - "shell.execute_reply": "2026-08-11T03:09:07.769632Z" + "iopub.execute_input": "2026-09-09T18:23:11.730328Z", + "iopub.status.busy": "2026-09-09T18:23:11.730196Z", + "iopub.status.idle": "2026-09-09T18:23:11.732694Z", + "shell.execute_reply": "2026-09-09T18:23:11.731967Z" } }, "outputs": [], @@ -1258,10 +1328,10 @@ "id": "5470a662-4880-418d-85aa-deadeca0cfe7", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.771869Z", - "iopub.status.busy": "2026-08-11T03:09:07.771708Z", - "iopub.status.idle": "2026-08-11T03:09:07.775298Z", - "shell.execute_reply": "2026-08-11T03:09:07.774722Z" + "iopub.execute_input": "2026-09-09T18:23:11.734066Z", + "iopub.status.busy": "2026-09-09T18:23:11.733940Z", + "iopub.status.idle": "2026-09-09T18:23:11.736842Z", + "shell.execute_reply": "2026-09-09T18:23:11.736379Z" } }, "outputs": [ @@ -1390,10 +1460,10 @@ "id": "9c0ac067-047a-4357-a462-415e32d0481c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.776959Z", - "iopub.status.busy": "2026-08-11T03:09:07.776787Z", - "iopub.status.idle": "2026-08-11T03:09:07.779534Z", - "shell.execute_reply": "2026-08-11T03:09:07.778858Z" + "iopub.execute_input": "2026-09-09T18:23:11.738159Z", + "iopub.status.busy": "2026-09-09T18:23:11.737999Z", + "iopub.status.idle": "2026-09-09T18:23:11.740430Z", + "shell.execute_reply": "2026-09-09T18:23:11.739854Z" } }, "outputs": [], @@ -1410,10 +1480,10 @@ "id": "5362bf0b-76d4-419b-af34-2ee94e3b2dda", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.781050Z", - "iopub.status.busy": "2026-08-11T03:09:07.780883Z", - "iopub.status.idle": "2026-08-11T03:09:07.783689Z", - "shell.execute_reply": "2026-08-11T03:09:07.783104Z" + "iopub.execute_input": "2026-09-09T18:23:11.741585Z", + "iopub.status.busy": "2026-09-09T18:23:11.741426Z", + "iopub.status.idle": "2026-09-09T18:23:11.743814Z", + "shell.execute_reply": "2026-09-09T18:23:11.743184Z" } }, "outputs": [], @@ -1432,10 +1502,10 @@ "id": "784ebdb9-b5f2-4a2f-9882-a65d2f107c05", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.785440Z", - "iopub.status.busy": "2026-08-11T03:09:07.785276Z", - "iopub.status.idle": "2026-08-11T03:09:07.788142Z", - "shell.execute_reply": "2026-08-11T03:09:07.787286Z" + "iopub.execute_input": "2026-09-09T18:23:11.744999Z", + "iopub.status.busy": "2026-09-09T18:23:11.744868Z", + "iopub.status.idle": "2026-09-09T18:23:11.747235Z", + "shell.execute_reply": "2026-09-09T18:23:11.746588Z" } }, "outputs": [], @@ -1452,10 +1522,10 @@ "id": "194af035-fafd-4c64-8b58-0f7af34bb685", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:07.789652Z", - "iopub.status.busy": "2026-08-11T03:09:07.789496Z", - "iopub.status.idle": "2026-08-11T03:09:15.058935Z", - "shell.execute_reply": "2026-08-11T03:09:15.057935Z" + "iopub.execute_input": "2026-09-09T18:23:11.748479Z", + "iopub.status.busy": "2026-09-09T18:23:11.748344Z", + "iopub.status.idle": "2026-09-09T18:23:17.635768Z", + "shell.execute_reply": "2026-09-09T18:23:17.635315Z" } }, "outputs": [ @@ -1472,8 +1542,8 @@ "text": [ "Batch: 1/1 completed, 20000 steps. \n", " Model parameter acceptance fraction: 0.273\n", - "CPU times: user 7.28 s, sys: 23.3 ms, total: 7.31 s\n", - "Wall time: 7.27 s\n" + "CPU times: user 5.89 s, sys: 40.5 ms, total: 5.93 s\n", + "Wall time: 5.88 s\n" ] } ], @@ -1491,10 +1561,10 @@ "id": "b57ce430-2014-4999-9e4f-3f16f0c3c8fc", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.060564Z", - "iopub.status.busy": "2026-08-11T03:09:15.060387Z", - "iopub.status.idle": "2026-08-11T03:09:15.063241Z", - "shell.execute_reply": "2026-08-11T03:09:15.062413Z" + "iopub.execute_input": "2026-09-09T18:23:17.637295Z", + "iopub.status.busy": "2026-09-09T18:23:17.637172Z", + "iopub.status.idle": "2026-09-09T18:23:17.639377Z", + "shell.execute_reply": "2026-09-09T18:23:17.638835Z" } }, "outputs": [], @@ -1509,10 +1579,10 @@ "id": "8bd838cf-8ed2-43b9-a545-416b9f5b802c", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.064834Z", - "iopub.status.busy": "2026-08-11T03:09:15.064663Z", - "iopub.status.idle": "2026-08-11T03:09:15.068500Z", - "shell.execute_reply": "2026-08-11T03:09:15.067598Z" + "iopub.execute_input": "2026-09-09T18:23:17.640592Z", + "iopub.status.busy": "2026-09-09T18:23:17.640474Z", + "iopub.status.idle": "2026-09-09T18:23:17.643253Z", + "shell.execute_reply": "2026-09-09T18:23:17.642785Z" } }, "outputs": [ @@ -1537,10 +1607,10 @@ "id": "122e8c8e-4975-42b0-96ef-611cb9187c85", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.070108Z", - "iopub.status.busy": "2026-08-11T03:09:15.069926Z", - "iopub.status.idle": "2026-08-11T03:09:15.438422Z", - "shell.execute_reply": "2026-08-11T03:09:15.437498Z" + "iopub.execute_input": "2026-09-09T18:23:17.644574Z", + "iopub.status.busy": "2026-09-09T18:23:17.644455Z", + "iopub.status.idle": "2026-09-09T18:23:17.944915Z", + "shell.execute_reply": "2026-09-09T18:23:17.944215Z" } }, "outputs": [ @@ -1587,10 +1657,10 @@ "id": "6b20814a-1595-4881-9190-6f03ee4811e3", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.440066Z", - "iopub.status.busy": "2026-08-11T03:09:15.439884Z", - "iopub.status.idle": "2026-08-11T03:09:15.444340Z", - "shell.execute_reply": "2026-08-11T03:09:15.443554Z" + "iopub.execute_input": "2026-09-09T18:23:17.946425Z", + "iopub.status.busy": "2026-09-09T18:23:17.946297Z", + "iopub.status.idle": "2026-09-09T18:23:17.949919Z", + "shell.execute_reply": "2026-09-09T18:23:17.949142Z" } }, "outputs": [], @@ -1604,10 +1674,10 @@ "id": "21ca84ce-5d9a-44db-8651-f9c80e9b1f68", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.445989Z", - "iopub.status.busy": "2026-08-11T03:09:15.445814Z", - "iopub.status.idle": "2026-08-11T03:09:15.637095Z", - "shell.execute_reply": "2026-08-11T03:09:15.636320Z" + "iopub.execute_input": "2026-09-09T18:23:17.951275Z", + "iopub.status.busy": "2026-09-09T18:23:17.951157Z", + "iopub.status.idle": "2026-09-09T18:23:18.106585Z", + "shell.execute_reply": "2026-09-09T18:23:18.105865Z" } }, "outputs": [ @@ -1648,10 +1718,10 @@ "id": "4aaec946-4f48-47e0-ad46-f6d71e866341", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.638929Z", - "iopub.status.busy": "2026-08-11T03:09:15.638758Z", - "iopub.status.idle": "2026-08-11T03:09:15.641318Z", - "shell.execute_reply": "2026-08-11T03:09:15.640744Z" + "iopub.execute_input": "2026-09-09T18:23:18.107941Z", + "iopub.status.busy": "2026-09-09T18:23:18.107811Z", + "iopub.status.idle": "2026-09-09T18:23:18.110248Z", + "shell.execute_reply": "2026-09-09T18:23:18.109767Z" } }, "outputs": [], @@ -1665,10 +1735,10 @@ "id": "2aab97fb-db36-4a05-aef0-8774173188df", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.642802Z", - "iopub.status.busy": "2026-08-11T03:09:15.642643Z", - "iopub.status.idle": "2026-08-11T03:09:15.726232Z", - "shell.execute_reply": "2026-08-11T03:09:15.725497Z" + "iopub.execute_input": "2026-09-09T18:23:18.111547Z", + "iopub.status.busy": "2026-09-09T18:23:18.111429Z", + "iopub.status.idle": "2026-09-09T18:23:18.178487Z", + "shell.execute_reply": "2026-09-09T18:23:18.177824Z" } }, "outputs": [], @@ -1688,17 +1758,17 @@ "id": "92fc68f8-9be2-4e5f-9bf0-65eb796f5e0a", "metadata": { "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.728106Z", - "iopub.status.busy": "2026-08-11T03:09:15.727930Z", - "iopub.status.idle": "2026-08-11T03:09:15.874964Z", - "shell.execute_reply": "2026-08-11T03:09:15.874133Z" + "iopub.execute_input": "2026-09-09T18:23:18.180170Z", + "iopub.status.busy": "2026-09-09T18:23:18.180004Z", + "iopub.status.idle": "2026-09-09T18:23:18.301745Z", + "shell.execute_reply": "2026-09-09T18:23:18.300991Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 39, diff --git a/examples/measurement_to_calibration.ipynb b/examples/measurement_to_calibration.ipynb index 81a3dde..19f4055 100644 --- a/examples/measurement_to_calibration.ipynb +++ b/examples/measurement_to_calibration.ipynb @@ -300,7 +300,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "['RankOneTerm', 'RankOneTerm']\n" + "['Term', 'Term']\n" ] }, { diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index 861fc36..86e349e 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -78,7 +78,7 @@ class StackContext: """Bundle of stacked arrays passed to every :meth:`Term.add_to`. - Attributes + Parameters ---------- x : np.ndarray Stacked independent variable, ``np.concatenate`` over observations. From 78f00834b47b81816006f8162099cb73c2ed3c48 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 14:37:51 -0400 Subject: [PATCH 21/24] Add ground-up design proposal and review bug list to docs docs/groundup_design.md sketches a declare-then-compile architecture (hashable identity Parameters, Dataset/Block split, bind-time predictors, stateless Terms with block-reference supports, a single ParameterIndex, and a structured diag + modes + block covariance with a Woodbury path) and compares it with the current api_generalisation design, ending with an incremental adoption path. docs/bugs_found.md enumerates the bugs and driver inconsistencies found while reading the branch for that comparison, with file:line references. Both pages are added to the Sphinx toctree. --- docs/bugs_found.md | 158 ++++++++++++ docs/groundup_design.md | 536 ++++++++++++++++++++++++++++++++++++++++ docs/index.rst | 2 + 3 files changed, 696 insertions(+) create mode 100644 docs/bugs_found.md create mode 100644 docs/groundup_design.md diff --git a/docs/bugs_found.md b/docs/bugs_found.md new file mode 100644 index 0000000..7681e04 --- /dev/null +++ b/docs/bugs_found.md @@ -0,0 +1,158 @@ +# Bugs and inconsistencies found during the architecture review + +Found while reading the `api_generalisation` branch (head `b8bc7d8`) for the +ground-up design comparison in `groundup_design.md`. Nothing here has been +fixed; every item was verified by reading the code at the cited lines. Items +are grouped by how sure I am that they are wrong rather than merely fragile. + +## Confirmed bugs + +### 1. `IsobaricAnalogPNObservation` silently drops two solver arguments + +- **Where:** `src/rxmc/ias_pn_observation.py:52-53` (constructor signature) + and `:113-120` (the `set_up_solver` call). +- **What:** the constructor accepts `wavelengths_beyond_range` and + `zeros_per_node`, documents them (`:92-94`), and `set_up_solver` takes them + (`:209-210`), but the call inside `__init__` never forwards them. The + defaults are always used. The elastic observation forwards both + (`src/rxmc/elastic_diffxs_observation.py:149-150`). +- **Why it matters:** a user tuning the Lagrange basis size for the (p,n) IAS + channel gets no effect and no error. +- **Fix:** add the two keyword arguments to the `set_up_solver` call. + +### 2. `BatchedAdaptiveMetropolisSampler` adapts its proposal during burn-in + +- **Where:** `src/rxmc/param_sampling.py:376-388`. +- **What:** the class docstring (`:304`), the `sample` docstring (`:354`) and + the `burn` parameter docstring (`:366-368`) all say the proposal covariance + is replaced only after *non-burn* batches. The code recomputes + `self.proposal_cov` and `self.args` unconditionally; only `record_batch` is + guarded by `if not burn`. +- **Why it matters:** burn-in batches feed the adaptation, so the behaviour + differs from what the docstring promises and from `AdaptiveMetropolisSampler`. + Either the doc or the code is wrong. Adapting during burn-in is arguably + the *better* behaviour, so the likely fix is to the docstrings. +- **Fix:** decide, then make the docstrings and the `if not burn:` guard agree. + +### 3. `Parameter` defines `__eq__` without `__hash__` + +- **Where:** `src/rxmc/params.py:39-48`. +- **What:** defining `__eq__` sets `__hash__ = None`, so `Parameter` objects + are unhashable. Every uniqueness check in the package keys on `id(p)` or + `p.name` for this reason (`covariance.py`, `constraint.py`, `evidence.py`), + and nothing documents it. +- **Why it matters:** `set(model.params)` or `{p: value}` raises `TypeError` + at runtime. It is a trap for anyone extending the package, and it is the + root reason the by-identity routing needs `id()` bookkeeping. +- **Fix:** either drop `__eq__` (identity is the sharing semantics anyway) or + add `__hash__ = object.__hash__`. See `groundup_design.md` §2.1. + +### 4. Two independent pint `UnitRegistry` instances + +- **Where:** `src/rxmc/elastic_diffxs_observation.py:24` and + `src/rxmc/ias_pn_observation.py:12`. +- **What:** each module builds its own registry. pint refuses to combine + quantities from different registries. +- **Why it matters:** latent today because no code path mixes the two, but any + helper that takes a quantity from one module into the other will raise. + `DEFAULT_LMAX = 20` is likewise duplicated (`:27` and `:14`). +- **Fix:** one `ureg` in a shared module (`observation_from_measurement.py` + is the natural home; its docstring already says it holds what the two share). + +## Inconsistencies between the two sampler front ends + +`CalibrationConfig` and `Walker` are meant to be two drivers over the same +posterior. They are not. + +### 5. `Walker.log_posterior` evaluates the likelihood when the prior is `-inf` + +- **Where:** `src/rxmc/walker.py:140-143` versus + `src/rxmc/config.py:405-411`. +- **What:** the config path short-circuits on a non-finite prior and skips + the forward model. The walker path always calls `Evidence.log_likelihood` + first. The Gibbs conditional has the same split: + `config.conditional_posterior` (`config.py:579-583`) short-circuits, + the inline closure at `walker.py:130-132` does not. +- **Why it matters:** out-of-bounds proposals cost a full reaction-model + solve in the walker. With bounds also enforced inside the kernels this is + a performance bug, not a correctness bug, but it is a silent divergence. + +### 6. Tempering exists only on the config path + +- **Where:** `config.py:245-252, 384, 583`; no counterpart in `walker.py`. +- **What:** `likelihood_scaling` scales the likelihood (and the Gibbs + conditionals) in `CalibrationConfig`. `Walker` has no such knob; the only + way to temper is `Evidence(weights=...)`. `examples/overconfidence.ipynb` + demonstrates both and prints a check that they agree. +- **Why it matters:** two names for one concept, with one of them reachable + from only one driver. + +### 7. List-of-scipy priors are accepted by one driver and rejected by the other + +- **Where:** `config.py:133-135, 153-155, 184-185` (list branches in + `ParameterConfig`) versus `param_sampling.py:66-70` (`_validate_object` + requires `prior.logpdf`) and `walker.py:131, 160` (calls + `sampler.prior.logpdf` directly). +- **What:** `ParameterConfig` special-cases a plain list of frozen scipy + distributions in three places. A `Sampler` built with the same list fails + at construction because a list has no `logpdf`. +- **Why it matters:** the prior protocol is documented as one thing and + implemented as two. `IndependentPrior` already exists to wrap a list; + `ParameterConfig` could wrap in `__init__` and delete all three branches. + +### 8. `ParameterConfig._infer_dim` misreads priors whose `mean` is a method + +- **Where:** `src/rxmc/config.py:92-98`. +- **What:** if the prior has no integer `dim`, the fallback is + `int(np.size(dist.mean))`. For any object whose `mean` is a *method* this + is `1`, regardless of the true dimension. +- **Why it matters:** a custom multi-dimensional prior exposing `mean()` is + reported as one-dimensional and rejected at `config.py:109-113` with a + misleading message. Frozen scipy multivariate distributions happen to + expose `mean` as an array, which is why the tests pass. +- **Fix:** call `mean` if callable, or require `dim` and drop the guess. + +## Fragile, not wrong + +These are not bugs today but each is one refactor away from becoming one. + +### 9. Unit conventions split across model and observation with no shared constant + +- `elastic_diffxs_model.py:166` and `ias_pn_model.py:124, 170` divide by a + bare `1000` (mb/sr to b/sr). The matching assumption lives in the + observation as `ureg.millibarn / ureg.steradian` + (`elastic_diffxs_observation.py:204`). Nothing ties them together. + +### 10. Model and observation compatibility is checked by string, or not at all + +- `elastic_diffxs_model.py:137, 174` compare `observation.quantity` to + `self.quantity`. `ias_pn_model.py:135, 159` reach straight for + `observation.constraint_workspace` with no check. Pairing an elastic model + with an IAS observation fails inside jitr with a shape error. + +### 11. Masked views share solver workspaces by reference, routed by `id()` + +- `observation.py:204` uses `copy.copy`, so a masked view of a reaction + observation shares both jitr workspaces and every array with its root. + `transforms.py:281, 301` route `per_observation_scaling` by + `id(obs.identity)`, and `test_holds_observation_references` exists only to + stop id recycling. Any deep copy, pickle, or reconstruction of an + observation breaks the routing with a `KeyError` at evaluation time. + +### 12. The burn-in loop in `Walker.walk` duplicates the main loop + +- `walker.py:207-221` versus `:229-241`: identical bodies apart from + `burn=True` and the progress string. Any change to one must be mirrored. + +### 13. `prior_transform` clips the unit cube only at the top level + +- `config.py:492-506` clips `u` to `[eps, 1-eps]`; `ParameterConfig.prior_transform` + and `IndependentPrior.prior_transform` (`priors.py:273-277`) do not. + Calling either directly with an exact `0.0` or `1.0` returns `±inf`. + +## Already fixed on this branch + +- The `_rows` row-count check in `model_comparison.py` was reported by an + earlier read as unable to fire. At `b8bc7d8` it is called without `n` for + the model samples and with `n` for the covariance samples (`:138, 143`), + which is correct. diff --git a/docs/groundup_design.md b/docs/groundup_design.md new file mode 100644 index 0000000..c5c8d7a --- /dev/null +++ b/docs/groundup_design.md @@ -0,0 +1,536 @@ +# A ground-up rxmc: declare, then compile + +This document sketches what `rxmc` would look like if rewritten from scratch +around one principle, compares it with the current `api_generalisation` +design (`design.md`), and lays out an incremental path from one to the other. +It is a design proposal, not a plan of record. + +The conclusion first: the *concepts* in `design.md` survive intact. Evidence +over independent constraints, constraint as the maximal correlated block, one +`Term` with three kinds, likelihood as a functional of `(d2, logdet, n)`, +comparison space owned by the data side, masks as part of support, and the +case A / case B distinction are all things this design keeps. What changes +is the *mechanics*: how parameters are routed, how the covariance is +represented, where solver state lives, and when validation happens. + +## 1. The principle + +**Everything the user constructs is an immutable declaration. One compile +step turns the declaration into evaluators.** + +Today the same objects do both jobs. A `Term` is authored by the user and +then binds its support, caches coordinate transforms, and refuses to be reused +in a second constraint. An `Observation` is "pure data" and also carries a +jitr workspace, a comparison transform, a mask, and an identity key that +`per_observation_scaling` routes on. `Constraint.__init__` is the compile +step for one constraint, `Evidence.__init__` re-validates across constraints, +and `CalibrationConfig` / `Walker` each compile the flat parameter vector +again. Every lifecycle rule in the current docs ("one Term belongs to one +constraint", "masked views share terms", "parameters are constraint-scoped", +"the same Parameter object across constraints is an error") is a consequence +of declaration and evaluation being fused. + +Separating them gives: + +- one place where parameters get slots, names get checked, supports get + resolved, constant pieces get factored, and singular covariances get + reported; +- specs that are reusable, comparable, and serialisable because they hold no + caches; +- a single flat parameter vector that both samplers, model comparison, and + plotting read from through one index instead of ten positional splits. + +## 2. Components + +The declarative layer, bottom up. + +### 2.1 `Parameter` + +```python +@dataclass(eq=False, frozen=True) +class Parameter: + name: str + bounds: tuple[float, float] = (-inf, inf) + unit: str = "" + latex: str | None = None + prior: Distribution | None = None # optional 1-D marginal +``` + +- Identity **is** the object. `eq=False` keeps the default identity hash, so + parameters are hashable and can key dicts and sets. This replaces the + current `__eq__`-without-`__hash__` and every `id(p)` table. +- Sharing a parameter anywhere in the graph means passing the same object. + There is one rule and it holds across constraints too. (Today: identity + inside a constraint, value-equality for model parameters across + constraints, and a hard error for covariance parameters across + constraints.) +- A parameter may carry its own marginal prior. Joint priors over several + parameters (e.g. a multivariate normal over the optical-potential set) are + attached at the `Problem` level (§2.8). + +### 2.2 `Dataset` + +Pure data, nothing else. + +```python +@dataclass(frozen=True) +class Dataset: + x: ndarray + y: ndarray + y_err: ndarray # statistical, physical units + meta: Mapping = field(default_factory=dict) + # meta holds: label, units, kinematics (reaction, Elab, ...), + # reported systematics (norm fraction, offset), provenance (subentry) +``` + +- No comparison transform, no mask, no solver workspace, no identity key. +- `from_measurement` becomes a free function that reads an EXFOR-style + measurement, converts units once (one shared `UnitRegistry`), and returns a + `Dataset` with `meta` filled. The current `ElasticDifferentialXSObservation` + and `IsobaricAnalogPNObservation` classes disappear; what they store beyond + data moves into `meta`, and the solver they build moves into `bind` (§2.3). + +### 2.3 `Model` and `Predictor` + +A model is a spec of "how to compute observables from parameters". A +predictor is that model **bound to a grid**. + +```python +class Model: + params: tuple[Parameter, ...] + def bind(self, grid_or_dataset) -> Predictor: ... + +class Predictor: + params: tuple[Parameter, ...] # model params (+ transform params) + grid: ndarray + def __call__(self, *values) -> ndarray: ... # physical space, on grid + def __or__(self, transform) -> Predictor: ... # compose a mean transform +``` + +- `bind` is where expensive, grid-dependent state is built. For a plain + function model it closes over `x`. For a reaction model it builds the + jitr workspace from `dataset.meta["kinematics"]` and the grid, and caches + it keyed on `(reaction, Elab, lmax, grid)` so that two datasets at the same + energy solve the basis once. The model owns its solver; the data does not. +- Binding to a bare array gives the plotting predictor every notebook + currently hand-writes as `model.y(x, ...)`, and replaces + `visualization_workspace` / `visualizable_model_prediction`. +- A Kennedy–O'Hagan scale is a transform composed onto a predictor: + `model.bind(d) | scale(rho)`. Because a predictor is per block, per-dataset + scales are just distinct `rho_i` objects on distinct predictors. The + contextual transform, `_root`, and `per_observation_scaling`'s id table are + gone. +- The generic model is `Model(params, fn)` with `fn(grid, *values)`, matching + the "one class + callables" style of `Term` and `Transform`. Reaction + models subclass only to override `bind`. + +### 2.4 `Block` + +A block is the unit the residual is formed on: one dataset, one predictor, +one comparison space, one point mask. + +```python +@dataclass(frozen=True) +class Block: + data: Dataset + predictor: Predictor + space: Transform = identity # parameter-free comparison transform + mask: ndarray | None = None # active points + + n: int; n_active: int + y: ndarray # space(data.y) + y_err: ndarray # |space'(data.y)| * data.y_err + log_jacobian: float + def predict(self, *values) -> ndarray # space(predictor(*values)) + def masked(self, mask) / masked_where(pred) -> Block # shares data+predictor + def reported_terms(self) -> list[Term] # from data.meta, delta-method propagated +``` + +- The comparison transform lives here, not on `Dataset`, because it is a + modelling choice (a Gaussian in log space is a different distribution from + a Gaussian in linear space, not merely a different covariance). Terms are + still authored in comparison space, exactly as today. +- `masked` returns a new `Block` sharing the dataset and predictor. No + `identity` attribute is needed: anything that wants "the same dataset" + compares `block.data`. + +### 2.5 `Term` + +Unchanged in spirit; changed in what it holds. + +```python +@dataclass(frozen=True) +class Term: + fn: Callable | ndarray # fn(c, *values) -> vector or matrix + params: tuple[Parameter, ...] = () + kind: Literal["diag", "mode", "matrix"] = "matrix" + on: Block | Sequence[Block] | None = None # None = all blocks of the constraint + coords: Transform = identity + constant: bool = False +``` + +- **Support is a block reference, not stacked integer indices.** `on=obs1` + places the term on that block, `on=[obs1, obs2]` spans both (case A), and + `on=None` means the whole constraint. Compile resolves these to indices. + `stacked_supports` and the `support=np.arange(...)` ceremony in the + notebooks disappear. +- A term holds no state. No `bind`, no `_x_cache`, no `_bound_N`. The + same term object can be placed in two constraints; each compile resolves it + independently. +- The factory helpers (`noise_term`, `normalization_term`, `kernel_term`, …) + keep their signatures with `support=` renamed `on=`. + +### 2.6 `Constraint` + +A container of blocks and terms plus the likelihood functional and weight. + +```python +@dataclass(frozen=True) +class Constraint: + blocks: tuple[Block, ...] + terms: tuple[Term, ...] = () + likelihood: Likelihood = Gaussian() + weight: float = 1.0 + statistical: bool = True # add each block's y_err diagonal + def complement(self) -> Constraint +``` + +- Eager checks only on things that do not need the parameter graph: blocks + are distinct, every `on=` references a block in this constraint, an + array-valued term has the right shape. +- `weight` moves here from `Evidence(weights=)` and subsumes + `CalibrationConfig.likelihood_scaling`: one tempering knob, applied to the + likelihood only, honoured by every driver. + +### 2.7 `Evidence` + +A tuple of independent constraints. It no longer validates anything; it +exists so that "the calibration problem" has one name. (It could be a plain +list; keeping the class gives a place for the `compile` entry point.) + +### 2.8 `Problem` — the compile step + +```python +problem = Problem(evidence, priors=[(omp.params, mvn), (log_eps, halfnormal)]) +``` + +`Problem.__init__` is the only place in the package that walks the graph. +It produces: + +- `problem.index: ParameterIndex` — the unique `Parameter` objects in + first-seen order (blocks' predictors, then terms, then likelihoods, + constraint by constraint), each with a slot. `index.slot(p)`, + `index.slots(ps)`, `index.names`, `index.bounds`, `index.ndim`. Name + uniqueness is checked once, here. +- `problem.constraints: tuple[CompiledConstraint, ...]` (§3). +- `problem.prior` — assembled from per-parameter marginals and the joint + priors passed in; every slot must be covered exactly once, checked here. +- The flat interface external samplers want, which is what + `CalibrationConfig` exposes today: + `ndim`, `names`, `log_likelihood(theta)`, `log_prior(theta)`, + `log_posterior(theta)`, `prior_transform(u)`, `starting_location(n)`. +- `problem.groups` — named slot groups for Gibbs drivers: `"model"` (all + predictor slots) and one group per constraint's nuisance slots. Any other + partition is a list of slot arrays. +- `problem.predict(theta) -> list[ndarray]` per block, in comparison or + physical space. + +Nothing user-facing is mutated by compiling. Compile the same evidence twice +and you get two independent problems. + +### 2.9 Likelihood + +Unchanged. A `Likelihood` is a functional of `(d2, logdet, n, *values)` with +optional parameters (`StudentT.nu`). Those parameters are ordinary nodes in +the index like every other. + +## 3. The compiled constraint + +`CompiledConstraint` is what today's `Constraint` + `ConstraintCovariance` +are, minus the parameter splitting. + +```python +class CompiledConstraint: + x, y, y_err: ndarray # stacked, comparison space + offsets: tuple[slice, ...] # one per block + active: ndarray # stacked indices of active points + predictors: list[(slice, gather, Predictor)] + covariance: StructuredCovariance + likelihood: Likelihood; like_gather: ndarray + weight: float + + def ym(self, theta) -> ndarray # memoised on theta[predictor slots] + def log_likelihood(self, theta) -> float + def matrix(self, theta) -> ndarray # dense, for display only +``` + +Two things are worth spelling out. + +**Gather, never split.** Every callable node received a gather array at +compile time. Evaluation is `node(*theta[gather])`. The ten positional +splits in the current code (`PhysicalModel.split_params`, +`Constraint._split`, the term's fn/coords split, `_scaled_term`'s +coefficient/basis split, `kernel_term`'s kernel/amplitude split, +`Transform.__or__`, `CalibrationConfig.split_parameters` and its +`prior_transform` cursor, `model_comparison.split_samples`, and +`predictive.total_predictive_band`'s `n_model_params`) all become reads of +`problem.index`. Composite nodes (`f | g`, coefficient times basis) still +concatenate their children's parameters, but they do so once at construction +and the compile step assigns one gather for the composite. + +**Memoised forward model.** `ym(theta)` caches the last prediction keyed on +the values of the predictor slots. A Gibbs sweep over the nuisance group +changes no predictor slot, so it never re-solves the reaction model. This one +mechanism replaces `Constraint.marginal_log_likelihood`, +`Constraint.predict`-then-closure in `Walker.run_likelihood_batches`, +`Evidence.weighted_marginal_log_likelihood`, `CalibrationConfig.predict_parametric` +and `CalibrationConfig.conditional_posterior`. + +## 4. The structured covariance + +This is the one change that is a dramatic simplification *and* a speed-up, +and it needs no API change. + +The three term kinds already describe a decomposition: + +``` +Sigma = D + sum_b M_b + U U^T (+ dense fallback) +``` + +- `D` is a length-`N` vector: the sum of squares of every `"diag"` term. +- `M_b` is one dense block per observation block: the sum of `"matrix"` terms + whose support lies inside block `b`. +- `U` is `N x r`: one column per `"mode"` term, the mode vector scattered onto + its support and zero elsewhere. A mode spanning several blocks (case A) is + just a column with entries in several blocks. +- A `"matrix"` term that crosses block boundaries (a GP kernel over the union + of two datasets) forces the dense path for that constraint. Everything + else stays structured. + +With `B = blockdiag(M_b + diag(D_b))` and per-block Cholesky `L_b`: + +``` +z = L^{-1} r (block by block) +W = L^{-1} U (block by block, N x r) +S = I_r + W^T W (r x r) +d2 = z^T z - (W^T z)^T S^{-1} (W^T z) +logdet Sigma = sum_b logdet B_b + logdet S +``` + +Cost is `O(sum_b n_b^3 + N r^2 + r^3)` instead of `O(N^3)`. For the +motivating cases (two or three datasets sharing a normalisation mode, +`r = 1`) the cross-block coupling is essentially free. + +Consequences: + +- **All three "known limitations" in `design.md` go away.** There is no + dense `N x N` assembly for non-constant block-diagonal covariances, the + low-rank path exists, and masking is slicing rows out of `D`, `U`, and + `M_b` rather than assembling and then restricting. +- **The block path is the only path.** `uses_block_path`, `block_diagonal`, + `cholesky` versus `block_cholesky`, and the dispatch in `stacked_distance` + collapse into one routine. +- **Constant pieces are still cached.** Each of `D`, `U`, `M_b` is the sum of + a constant part (evaluated once) and a parametric part. When everything is + constant the factors are cached exactly as now. +- **Constraint boundaries carry less weight.** Today a constraint is the + unit of dense factorisation, so the design must forbid sharing across + constraints and push cross-dataset systematics into one constraint. With + Woodbury the cost of a coupling mode is independent of `N`, so the choice + of where to draw constraint boundaries becomes about the likelihood + functional and the weight, not about cost. +- `B` must be positive definite. A block covered by modes alone (no + statistical diagonal, no noise term) is singular in `B` even if `Sigma` is + not. Compile catches this as today's eager singular check does, and the + remedy list is the same; a dense fallback for that constraint is the + escape hatch. + +## 5. Drivers + +### 5.1 External samplers + +`Problem` *is* the interface `black-box-bayes`, `emcee`, and `dynesty` want. +`CalibrationConfig` and `ParameterConfig` are not needed. The prior list +form, `IndependentPrior`, and `TruncatedNormalPrior` collapse into +"a `Parameter` carries a marginal, or a group of parameters carries a joint". + +### 5.2 In-package Gibbs + +```python +walker = Walker(problem, groups=problem.groups, samplers={...}, rng=rng) +walker.walk(n_steps, burnin, batch_size) +walker.chain # (n, ndim), columns named by problem.index.names +``` + +- A sector is a slot group. The walker alternates over groups, holding the + others fixed, calling `problem.log_posterior` each time. The forward-model + memo makes the nuisance sweeps cheap without special methods. +- There is one chain. The two-sector `model_sampler.chain` / + `likelihood_samplers[i].chain` and the `np.hstack` in every notebook go + away, as does the duplicated validation between `Walker` and + `CalibrationConfig`. + +### 5.3 Model comparison and prediction + +`model_comparison` and `predictive` take `(problem, chain)` and select +columns through `problem.index`. `split_samples` is not needed; +`total_predictive_band` gets its kernel columns from +`index.slots(term.params)` instead of a caller-supplied integer. +`Constraint.complement()` works on blocks exactly as it does on observations +today, and the held-out problem shares `Parameter` objects with the fit, so a +posterior sample scores it directly. + +## 6. Worked example + +The α+Ca study shape: two datasets without reported errors, compared in log +space, a noise level shared between them (case B), a normalisation mode +coupling them (case A), one latent scale per dataset, one held out below a +cut, nested sampling. + +```python +import numpy as np, rxmc as rx +from rxmc import terms as T, transforms as tf + +d1 = rx.from_measurement(m1) # Dataset, meta filled, units converted +d2 = rx.from_measurement(m2) + +omp = MyOpticalModel(params=[...]) # Model; bind() builds jitr workspaces +rho1, rho2 = rx.Parameter("log_rho_1"), rx.Parameter("log_rho_2") +b1 = rx.Block(d1, omp.bind(d1) | tf.scale(rho1), space=tf.log) +b2 = rx.Block(d2, omp.bind(d2) | tf.scale(rho2), space=tf.log) + +log_eps = rx.Parameter("log_eps", prior=halfnormal) +log_eta = rx.Parameter("log_eta", prior=halfnormal) +c = rx.Constraint( + blocks=[b1, b2], + terms=[ + T.noise(log_eps, on=b1), # case B: one magnitude, two blocks + T.noise(log_eps, on=b2), + T.normalization(log_eta, on=[b1, b2]), # case A: one mode across both + ], + likelihood=rx.StudentT(), +) +fit = c.masked_where(lambda x: x < cut) +held = fit.complement() + +problem = rx.Problem([fit], priors=[(omp.params, mvn_prior)]) +sampler = dynesty.NestedSampler(problem.log_likelihood, problem.prior_transform, problem.ndim) +... +heldout = rx.Problem([held], priors=problem.prior) # same Parameter objects +lp = rx.model_comparison.heldout_log_predictive(heldout, chain) +``` + +Compare with the current version of the same study: `Observation(..., +transform=log)` per dataset, `stacked_supports` to place the terms, +`per_observation_scaling([obs1, obs2])` on the model with `obs` passed to +three places, `Constraint(...)`, `Evidence([...])`, `ParameterConfig` twice, +`CalibrationConfig`, and `split_samples` to read the chain back. + +## 7. Compile, in pseudo-code + +```python +def compile(evidence, priors): + index = ParameterIndex() # ordered dict Parameter -> slot + compiled = [] + for c in evidence: + offsets, x, y, err = stack(c.blocks) # comparison space + active = concatenate(offset[b.mask] for each block) + preds = [(offsets[i], index.add_all(b.predictor.params), b.predictor) + for i, b in enumerate(c.blocks)] + terms = list(c.terms) + if c.statistical: + terms = [T.statistical(b.y_err, on=b) for b in c.blocks] + terms + resolved = [(resolve(t.on, c.blocks, offsets), index.add_all(t.params), t) + for t in terms] + like_gather = index.add_all(c.likelihood.params) + cov = StructuredCovariance(resolved, N=len(y), offsets, active) + cov.factor_constant_parts() # eager; names the block on failure + compiled.append(CompiledConstraint(...)) + index.check_names_unique() + prior = assemble_prior(index, priors) # every slot covered exactly once + return Problem(index, compiled, prior) +``` + +`index.add_all(params)` returns the gather array for that node, adding new +parameters in first-seen order. That is the whole routing story. + +## 8. Mapping from the current code + +| today | ground-up | note | +|---|---|---| +| `Parameter` (`__eq__`, no hash) | `Parameter` (identity, hashable, optional prior) | one identity notion | +| `Observation` | `Dataset` + `Block` | data vs. modelling choices | +| `ElasticDifferentialXSObservation`, `IsobaricAnalogPNObservation` | `from_measurement` → `Dataset`; solver in `Model.bind` | classes removed | +| `PhysicalModel(params, transform)` | `Model.bind(grid) -> Predictor`; `predictor \| transform` | per-block mean transforms | +| `per_observation_scaling`, `_root`, `identity` | `omp.bind(d_i) \| scale(rho_i)` | no routing table | +| `Term(support=indices)` + `bind` + caches | `Term(on=blocks)`, stateless | resolved at compile | +| `stacked_supports` | not needed | | +| `Constraint.__init__` + `ConstraintCovariance` | `Constraint` (spec) + `CompiledConstraint` | | +| `ConstraintCovariance.matrix/cholesky/block_cholesky/stacked_distance` | `StructuredCovariance` | Woodbury, one path | +| `Evidence(weights=)` + `likelihood_scaling` | `Constraint.weight` | one knob | +| `Evidence._validate_constraint_params`, `Constraint._validate_parameter_names` | `ParameterIndex.check_names_unique` | once | +| `ParameterConfig`, `CalibrationConfig` | `Problem` | | +| `IndependentPrior`, `TruncatedNormalPrior`, list priors | `Parameter.prior` + joint priors on `Problem` | | +| `Walker(model_sampler, likelihood_samplers)` | `Walker(problem, groups)` | one chain | +| `marginal_log_likelihood`, `predict_parametric`, `conditional_posterior`, `weighted_marginal_log_likelihood` | `CompiledConstraint.ym` memo | | +| `split_samples`, `n_model_params`, `theta_cols` | `problem.index.slots(...)` | | + +## 9. What stays the same + +- The hierarchy: evidence → constraint → block → point. +- `Term` with `kind in {"diag", "mode", "matrix"}`, the factory helpers, bases + and amplitudes as callables of a local context. +- `Transform` as one type with derivative, inverse, and `|` composition, + serving comparison space, mean transforms, and term coordinates. +- Terms authored in comparison space; delta-method propagation of reported + errors; `log_jacobian` for cross-space evidence comparison. +- Likelihood as a functional of `(d2, logdet, n)`; `Gaussian`, `StudentT`, + `Chi2`. +- Masks as part of support; `complement()` sharing parameters with the fit. +- Fail fast on singular constant covariances with a named dataset. +- Tempering applies to the likelihood only. + +## 10. Incremental path + +None of this requires a rewrite. In order of payoff per unit of risk: + +1. **`StructuredCovariance` inside `ConstraintCovariance`.** Replace the + internals of `matrix`, `cholesky`, `block_cholesky`, and + `stacked_distance`; keep `matrix()` as the dense view. No public API + change. The existing dense-versus-block equivalence tests are the + acceptance tests. This alone removes every "known limitation". +2. **Make `Parameter` hashable** (drop `__eq__` or add `__hash__`). +3. **`support=` accepts observation objects** and is resolved in + `Constraint`. Keep integer supports working. +4. **`ParameterIndex` built by `Evidence`**, exposing + `log_likelihood(theta_flat)` alongside the nested form. Point + `CalibrationConfig.split_parameters`, `model_comparison.split_samples`, + `predictive`, and `Walker`'s validation at it. Lift the cross-constraint + sharing ban. This is the step that unifies the two drivers and fixes the + inconsistencies in `bugs_found.md` §5–7. +5. **`Problem`** as the single compile entry point; `CalibrationConfig` + becomes a thin alias, `Walker` takes a `Problem` and slot groups, one + chain. +6. **Bind-time predictors.** Move workspaces off the reaction observations + into `Model.bind`, fold the two observation subclasses into + `from_measurement`. Do this after the α+Ca study lands, since it + touches the classes that study uses. + +Steps 1–3 are local and safe. Step 4 is the structural one. Steps 5–6 are +cleanup that the earlier steps make small. + +## 11. Open questions + +- **Joint priors and `prior_transform`.** Nested sampling needs a + unit-cube map. Independent marginals have one; a multivariate normal + needs a whitening transform. Same situation as today; `Problem` should + reject `prior_transform` for joints without a `ppf`-like method rather + than guess. +- **Cross-constraint modes.** `U` is per constraint so that constraints + stay independent and weights stay meaningful. A mode that couples two + constraints is, as today, a reason to merge them. +- **`n_dof`.** With sharing across constraints allowed, count unique + slots, not the sum of per-constraint counts. +- **Term-level masks.** Today the factories accept `mask=` for partial + support. With `on=(block, point_mask)` that becomes a first-class support + form; whether it is worth the extra spelling is a matter of taste. diff --git a/docs/index.rst b/docs/index.rst index 72385d2..e72868d 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -24,5 +24,7 @@ full calibration problems (:class:`~rxmc.evidence.Evidence`). installation design + groundup_design + bugs_found api examples From 7380776b78e536e1cbec3f989361c8a95dd7dd97 Mon Sep 17 00:00:00 2001 From: beykyle Date: Wed, 9 Sep 2026 15:38:42 -0400 Subject: [PATCH 22/24] Fix the bugs and driver inconsistencies listed in docs/bugs_found.md Confirmed bugs - IsobaricAnalogPNObservation forwards wavelengths_beyond_range and zeros_per_node to set_up_solver instead of silently dropping them. - BatchedAdaptiveMetropolisSampler: docstrings now match the code (the proposal adapts after every batch, burn-in included) and the public proposal attribute is refreshed alongside args. - Parameter is hashable (value hash consistent with its value __eq__), coerces bounds to a float 2-tuple, and has a repr. - One pint UnitRegistry, DEFAULT_LMAX, XS_UNIT, RUTHERFORD_UNIT and MB_PER_B live in observation_from_measurement (now exported from rxmc); both reaction observations import them and both reaction models divide by MB_PER_B instead of a bare 1000. Driver parity between CalibrationConfig and Walker - Walker.log_posterior and the Gibbs conditional evaluate the prior first and return -inf without touching the likelihood. - Walker gains likelihood_scaling with the config's semantics. - A list of scipy marginals is wrapped in IndependentPrior by a shared priors.as_prior in both ParameterConfig and Sampler; the four list branches in ParameterConfig are gone. x0 for a list prior is now seeded. - ParameterConfig._infer_dim calls mean() when it is a method. Fragile spots - Reaction models reject an observation of the wrong class up front. - Walker.walk runs one _run_batch sweep for burn-in and active batches. - priors.clip_unit_cube is applied in every prior_transform. Tests added for each item (295 total, from 268); docs/bugs_found.md records the resolution of every item, with 11 deferred to groundup_design.md. --- docs/bugs_found.md | 57 ++++++- src/rxmc/__init__.py | 2 + src/rxmc/config.py | 104 ++++++------ src/rxmc/elastic_diffxs_model.py | 22 ++- src/rxmc/elastic_diffxs_observation.py | 17 +- src/rxmc/ias_pn_model.py | 19 ++- src/rxmc/ias_pn_observation.py | 15 +- src/rxmc/observation_from_measurement.py | 22 ++- src/rxmc/param_sampling.py | 29 ++-- src/rxmc/params.py | 30 +++- src/rxmc/priors.py | 33 +++- src/rxmc/walker.py | 111 +++++++------ test/test_config.py | 57 ++++++- test/test_params.py | 52 ++++++ test/test_priors.py | 38 ++++- test/test_reaction_models.py | 38 +++++ test/test_reaction_observation.py | 70 ++++++++ test/test_sampler.py | 195 ++++++++++++++++++++++- 18 files changed, 761 insertions(+), 150 deletions(-) create mode 100644 test/test_params.py diff --git a/docs/bugs_found.md b/docs/bugs_found.md index 7681e04..f9949fb 100644 --- a/docs/bugs_found.md +++ b/docs/bugs_found.md @@ -1,9 +1,14 @@ # Bugs and inconsistencies found during the architecture review Found while reading the `api_generalisation` branch (head `b8bc7d8`) for the -ground-up design comparison in `groundup_design.md`. Nothing here has been -fixed; every item was verified by reading the code at the cited lines. Items -are grouped by how sure I am that they are wrong rather than merely fragile. +ground-up design comparison in `groundup_design.md`. Every item was verified +by reading the code at the cited lines (line numbers refer to `b8bc7d8`). +Items are grouped by how sure I am that they are wrong rather than merely +fragile. + +**Status:** every item except 11 is fixed on this branch; each carries a +**Resolution** line. Item 11 is a design-level change and is deferred to +`groundup_design.md`. ## Confirmed bugs @@ -19,6 +24,8 @@ are grouped by how sure I am that they are wrong rather than merely fragile. - **Why it matters:** a user tuning the Lagrange basis size for the (p,n) IAS channel gets no effect and no error. - **Fix:** add the two keyword arguments to the `set_up_solver` call. +- **Resolution:** forwarded; `test_reaction_observation.py::TestSolverSettingsForwarding` + asserts the kwargs reach `set_up_solver` for both reaction observations. ### 2. `BatchedAdaptiveMetropolisSampler` adapts its proposal during burn-in @@ -33,6 +40,10 @@ are grouped by how sure I am that they are wrong rather than merely fragile. Either the doc or the code is wrong. Adapting during burn-in is arguably the *better* behaviour, so the likely fix is to the docstrings. - **Fix:** decide, then make the docstrings and the `if not burn:` guard agree. +- **Resolution:** kept the code behaviour (adapt after every batch, burn-in + included) and fixed the three docstrings. `sample` now also refreshes + `self.proposal` so it never goes stale; pinned by + `test_sampler.py::TestSamplerPriors::test_batched_adaptive_updates_proposal_after_burn_batch`. ### 3. `Parameter` defines `__eq__` without `__hash__` @@ -46,6 +57,10 @@ are grouped by how sure I am that they are wrong rather than merely fragile. root reason the by-identity routing needs `id()` bookkeeping. - **Fix:** either drop `__eq__` (identity is the sharing semantics anyway) or add `__hash__ = object.__hash__`. See `groundup_design.md` §2.1. +- **Resolution:** value-based `__hash__` consistent with the existing value + `__eq__`; `bounds` is coerced to a 2-tuple of floats so the hash is stable; + `__repr__` added. Identity routing in `covariance.py` / `evidence.py` is + untouched. New `test/test_params.py`. ### 4. Two independent pint `UnitRegistry` instances @@ -58,6 +73,10 @@ are grouped by how sure I am that they are wrong rather than merely fragile. `DEFAULT_LMAX = 20` is likewise duplicated (`:27` and `:14`). - **Fix:** one `ureg` in a shared module (`observation_from_measurement.py` is the natural home; its docstring already says it holds what the two share). +- **Resolution:** `ureg`, `DEFAULT_LMAX`, `XS_UNIT`, `RUTHERFORD_UNIT` and + `MB_PER_B` live in `observation_from_measurement.py` (now exported from + `rxmc`); both observation modules import and re-export them. + `test_reaction_observation.py::TestSharedUnits`. ## Inconsistencies between the two sampler front ends @@ -76,6 +95,9 @@ posterior. They are not. - **Why it matters:** out-of-bounds proposals cost a full reaction-model solve in the walker. With bounds also enforced inside the kernels this is a performance bug, not a correctness bug, but it is a silent divergence. +- **Resolution:** `Walker.log_posterior` and the Gibbs closure evaluate the + prior first and return `-inf` without touching the likelihood. + `test_sampler.py::TestWalkerPosterior::test_*_skips_likelihood_when_prior_neg_inf`. ### 6. Tempering exists only on the config path @@ -86,6 +108,10 @@ posterior. They are not. demonstrates both and prints a check that they agree. - **Why it matters:** two names for one concept, with one of them reachable from only one driver. +- **Resolution:** `Walker(..., likelihood_scaling=)` added with the same + semantics as the config (scales the likelihood in the model block and the + Gibbs conditionals, never the prior). + `test_sampler.py::TestWalkerPosterior::test_*_applies_likelihood_scaling*`. ### 7. List-of-scipy priors are accepted by one driver and rejected by the other @@ -99,6 +125,13 @@ posterior. They are not. - **Why it matters:** the prior protocol is documented as one thing and implemented as two. `IndependentPrior` already exists to wrap a list; `ParameterConfig` could wrap in `__init__` and delete all three branches. +- **Resolution:** `rxmc.priors.as_prior` wraps a list/tuple in + `IndependentPrior`; both `ParameterConfig.__init__` and `Sampler.__init__` + call it, and the four list branches in `ParameterConfig` are gone. + Behaviour change: `x0` for a list prior is now seeded (`IndependentPrior` + default seed) instead of drawing from numpy's global state, and + `config.prior` returns the wrapper. Tests in `test_config.py`, + `test_sampler.py`, `test_priors.py`. ### 8. `ParameterConfig._infer_dim` misreads priors whose `mean` is a method @@ -111,6 +144,8 @@ posterior. They are not. misleading message. Frozen scipy multivariate distributions happen to expose `mean` as an array, which is why the tests pass. - **Fix:** call `mean` if callable, or require `dim` and drop the guess. +- **Resolution:** an integer `dim` wins; otherwise `mean` is called when it + is a method. `test_config.py::test_infer_dim_calls_mean_method`. ## Fragile, not wrong @@ -122,6 +157,9 @@ These are not bugs today but each is one refactor away from becoming one. bare `1000` (mb/sr to b/sr). The matching assumption lives in the observation as `ureg.millibarn / ureg.steradian` (`elastic_diffxs_observation.py:204`). Nothing ties them together. +- **Resolution:** both models divide by `MB_PER_B`, derived from the shared + registry next to `XS_UNIT` / `RUTHERFORD_UNIT`, which the observations now + use. `test_reaction_observation.py::TestSharedUnits::test_unit_constants_agree`. ### 10. Model and observation compatibility is checked by string, or not at all @@ -129,6 +167,10 @@ These are not bugs today but each is one refactor away from becoming one. `self.quantity`. `ias_pn_model.py:135, 159` reach straight for `observation.constraint_workspace` with no check. Pairing an elastic model with an IAS observation fails inside jitr with a shape error. +- **Resolution:** each model checks `isinstance` against its observation class + first in `evaluate` and `visualizable_model_prediction` and raises a named + `ValueError` (a string check cannot work: both observations report + `quantity == "dXS/dA"`). `test_reaction_models.py::TestObservationTypeChecks`. ### 11. Masked views share solver workspaces by reference, routed by `id()` @@ -138,17 +180,26 @@ These are not bugs today but each is one refactor away from becoming one. `id(obs.identity)`, and `test_holds_observation_references` exists only to stop id recycling. Any deep copy, pickle, or reconstruction of an observation breaks the routing with a `KeyError` at evaluation time. +- **Deferred:** design-level; see `groundup_design.md` §2.3–2.4 (bind-time + predictors, blocks without identity keys). ### 12. The burn-in loop in `Walker.walk` duplicates the main loop - `walker.py:207-221` versus `:229-241`: identical bodies apart from `burn=True` and the progress string. Any change to one must be mirrored. +- **Resolution:** one `_run_batch(steps, burn)` sweep plus `_batch_message`; + the burn-in line prints no acceptance fraction because nothing is recorded + during burn-in. `test_sampler.py::TestWalkerPosterior::test_burn_message_has_no_acceptance_fraction`. ### 13. `prior_transform` clips the unit cube only at the top level - `config.py:492-506` clips `u` to `[eps, 1-eps]`; `ParameterConfig.prior_transform` and `IndependentPrior.prior_transform` (`priors.py:273-277`) do not. Calling either directly with an exact `0.0` or `1.0` returns `±inf`. + (`TruncatedNormalPrior` is finite at the boundary by construction.) +- **Resolution:** `rxmc.priors.clip_unit_cube` is applied in all four + transforms. `test_priors.py::TestUnitCubeClipping`, + `test_config.py::test_prior_transform_boundary_finite`. ## Already fixed on this branch diff --git a/src/rxmc/__init__.py b/src/rxmc/__init__.py index 46b2256..5685810 100644 --- a/src/rxmc/__init__.py +++ b/src/rxmc/__init__.py @@ -11,6 +11,7 @@ from . import metropolis_hastings as metropolis_hastings from . import model_comparison as model_comparison from . import observation as observation +from . import observation_from_measurement as observation_from_measurement from . import param_sampling as param_sampling from . import params as params from . import physical_model as physical_model @@ -34,6 +35,7 @@ "likelihood_model", "metropolis_hastings", "observation", + "observation_from_measurement", "param_sampling", "params", "physical_model", diff --git a/src/rxmc/config.py b/src/rxmc/config.py index 55e99de..79983fc 100644 --- a/src/rxmc/config.py +++ b/src/rxmc/config.py @@ -21,8 +21,10 @@ any user-supplied class that satisfies the same interface. Alternatively, a **list** of univariate ``scipy.stats`` frozen distributions -(one per parameter) may be passed. This form and any prior class that -implements ``prior_transform(u)`` both support the Dynesty-compatible +(one per parameter) may be passed; it is wrapped in an +:class:`~rxmc.priors.IndependentPrior` on construction (the same rule +:class:`~rxmc.param_sampling.Sampler` applies). That class and any prior +class that implements ``prior_transform(u)`` support the Dynesty-compatible :meth:`CalibrationConfig.prior_transform`. """ @@ -32,6 +34,7 @@ from rxmc.evidence import Evidence from rxmc.params import Parameter +from rxmc.priors import as_prior, clip_unit_cube class ParameterConfig: @@ -73,8 +76,10 @@ def __init__( ): self.params = params self.ndim = len(params) - self.prior = prior - self.initial_proposal_distribution = initial_proposal_distribution + # a list of marginals becomes an IndependentPrior here, so every + # method below sees one prior object (the rule Sampler applies too) + self.prior = as_prior(prior) + self.initial_proposal_distribution = as_prior(initial_proposal_distribution) if self.ndim == 0: raise ValueError("Parameter list cannot be empty") @@ -90,27 +95,33 @@ def __init__( @staticmethod def _infer_dim(dist) -> Optional[int]: - """Return the dimensionality of a prior object, or None if unknown.""" - if hasattr(dist, "dim") and isinstance(dist.dim, int): - return dist.dim - if hasattr(dist, "mean"): - return int(np.size(dist.mean)) - return None + """Return the dimensionality of a prior object, or None if unknown. + + An integer ``dim`` attribute wins; otherwise the size of ``mean`` is + used, *calling* it when it is a method (frozen ``scipy.stats`` + univariates and user classes expose ``mean()``; scipy multivariates + expose an array). + """ + dim = getattr(dist, "dim", None) + if isinstance(dim, int) and not isinstance(dim, bool): + return dim + mean = getattr(dist, "mean", None) + if mean is None: + return None + if callable(mean): + try: + mean = mean() + except Exception: + return None + return int(np.size(mean)) def _validate_prior_dim(self, dist, name: str) -> None: - if isinstance(dist, list): - if len(dist) != self.ndim: - raise ValueError( - f"{name} list length ({len(dist)}) does not match " - f"number of parameters ({self.ndim})" - ) - else: - dim = self._infer_dim(dist) - if dim is not None and dim != self.ndim: - raise ValueError( - f"{name} dimensionality ({dim}) does not match " - f"number of parameters ({self.ndim})" - ) + dim = self._infer_dim(dist) + if dim is not None and dim != self.ndim: + raise ValueError( + f"{name} dimensionality ({dim}) does not match " + f"number of parameters ({self.ndim})" + ) # ------------------------------------------------------------------ # Public API @@ -129,11 +140,7 @@ def x0(self, nwalkers: int) -> np.ndarray: ndarray, shape (nwalkers, ndim) One initial position per walker. """ - dist = self.initial_proposal_distribution - if isinstance(dist, list): - samples = [d.rvs(nwalkers) for d in dist] - return np.column_stack(samples) - samples = np.atleast_1d(dist.rvs(nwalkers)) + samples = np.atleast_1d(self.initial_proposal_distribution.rvs(nwalkers)) return samples.reshape(nwalkers, -1) def prior_logpdf(self, x: np.ndarray) -> float: @@ -149,22 +156,15 @@ def prior_logpdf(self, x: np.ndarray) -> float: float Log prior probability at ``x``. """ - x = np.atleast_1d(x) - if isinstance(self.prior, list): - logpdfs = [dist.logpdf(x[i]) for i, dist in enumerate(self.prior)] - return float(np.sum(logpdfs)) - return float(self.prior.logpdf(x)) + return float(self.prior.logpdf(np.atleast_1d(x))) def prior_transform(self, u: np.ndarray) -> np.ndarray: """Map unit-cube coordinates to physical parameters for this sector. - Supports two forms: - - * **List prior** — each element must expose a ``ppf`` method (all - frozen ``scipy.stats`` univariate distributions do). - * **Joint prior with ``prior_transform``** — the prior object must - implement ``prior_transform(u) -> ndarray`` itself (e.g. - :class:`~rxmc.priors.TruncatedNormalPrior`). + The prior object must implement ``prior_transform(u) -> ndarray`` + (:class:`~rxmc.priors.IndependentPrior`, which a list prior becomes, + and :class:`~rxmc.priors.TruncatedNormalPrior` do). ``u`` is clipped + into the open unit cube first, so an exact ``0`` or ``1`` stays finite. Parameters ---------- @@ -179,15 +179,15 @@ def prior_transform(self, u: np.ndarray) -> np.ndarray: Raises ------ NotImplementedError - If the prior is neither a list nor exposes ``prior_transform``. + If the prior does not expose ``prior_transform``. """ - if isinstance(self.prior, list): - return np.array([dist.ppf(u[i]) for i, dist in enumerate(self.prior)]) + u = clip_unit_cube(u) if hasattr(self.prior, "prior_transform"): return self.prior.prior_transform(u) raise NotImplementedError( - "Prior transform requires either a list of distributions with ppf " - "or a prior object that implements prior_transform(u)." + "Prior transform requires a prior object that implements " + "prior_transform(u) (a list of scipy marginals is wrapped in " + "IndependentPrior, which does)." ) @@ -314,10 +314,11 @@ def prior(self) -> list: """Prior distribution objects in parameter-sector order. Returns one entry per sector: the model prior first, followed by one - entry per likelihood sector. Each entry is whatever was passed as - ``prior`` to the corresponding :class:`ParameterConfig` — a list of - univariate distributions, a multivariate distribution, or a custom - prior object. + entry per likelihood sector. Each entry is the prior object held by + the corresponding :class:`ParameterConfig` — a multivariate + distribution, a custom prior object, or the + :class:`~rxmc.priors.IndependentPrior` a list of univariate + distributions was wrapped into. """ return [pc.prior for pc in self.parameter_configs] @@ -489,13 +490,10 @@ def prior_transform(self, u) -> np.ndarray: ValueError If ``u`` does not have length ``ndim``. """ - u = np.asarray(u, dtype=float) + u = clip_unit_cube(u) if u.shape[-1] != self.ndim: raise ValueError(f"Expected u with length {self.ndim}, got shape {u.shape}") - eps = np.finfo(float).eps - u = np.clip(u, eps, 1.0 - eps) - theta = np.empty_like(u) offset = 0 for pc in self.parameter_configs: diff --git a/src/rxmc/elastic_diffxs_model.py b/src/rxmc/elastic_diffxs_model.py index 4dd817f..6842a1f 100644 --- a/src/rxmc/elastic_diffxs_model.py +++ b/src/rxmc/elastic_diffxs_model.py @@ -12,9 +12,25 @@ import numpy as np from .elastic_diffxs_observation import ElasticDifferentialXSObservation +from .observation_from_measurement import MB_PER_B from .physical_model import PhysicalModel +def _require_observation(observation) -> None: + """Reject observations this model cannot evaluate on. + + Both reaction observations report ``quantity == "dXS/dA"``, so a string + check cannot tell them apart; the class carries the solver workspace the + model needs. + """ + if not isinstance(observation, ElasticDifferentialXSObservation): + raise ValueError( + "ElasticDifferentialXSModel requires an " + "ElasticDifferentialXSObservation, got " + f"{type(observation).__name__}" + ) + + class ElasticDifferentialXSModel(PhysicalModel): """ A model that predicts the elastic differential xs for a given reaction. @@ -134,6 +150,7 @@ def evaluate( np.ndarray Predicted observable on ``observation.constraint_workspace.angles``. """ + _require_observation(observation) if observation.quantity != self.quantity: raise ValueError( f"Observation quantity {observation.quantity} does not match " @@ -171,6 +188,7 @@ def visualizable_model_prediction( np.ndarray Predicted observable on ``observation.visualization_workspace.angles``. """ + _require_observation(observation) if observation.quantity != self.quantity: raise ValueError( f"Observation quantity {observation.quantity} does not match " @@ -197,8 +215,8 @@ def visualizable_model_prediction( def extract_dXS_dA( xs: jitr.xs.elastic.ElasticXS, ws: jitr.xs.elastic.DifferentialWorkspace ) -> np.ndarray: - """Extracts dXS/dA in b/Sr""" - return xs.dsdo / 1000 + """Extracts dXS/dA in b/Sr (``jitr`` reports mb/sr).""" + return xs.dsdo / MB_PER_B def extract_dXS_dRuth( diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py index ea865c3..d4cc6e5 100644 --- a/src/rxmc/elastic_diffxs_observation.py +++ b/src/rxmc/elastic_diffxs_observation.py @@ -11,21 +11,18 @@ import jitr import numpy as np from exfor_tools.distribution import Distribution -from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import ( +from .observation_from_measurement import ( # noqa: F401 (re-exported names) + DEFAULT_LMAX, + RUTHERFORD_UNIT, + XS_UNIT, check_angle_grid, measurement_kwargs, normalized_error_kwargs, + ureg, ) -# Create a unit registry -ureg = UnitRegistry() - - -DEFAULT_LMAX = 20 - class ElasticDifferentialXSObservation(Observation): """ @@ -201,8 +198,8 @@ def calculate_normalization( self, measurement_quantity: str, measurement_y_units: str ): # Determine the xs_unit based on self.quantity - xs_unit = ureg.barn / ureg.steradian - rutherford_unit = ureg.millibarn / ureg.steradian + xs_unit = XS_UNIT + rutherford_unit = RUTHERFORD_UNIT if self.quantity == "dXS/dA": y_unit = xs_unit elif self.quantity in {"dXS/dRuth", "Ay"}: diff --git a/src/rxmc/ias_pn_model.py b/src/rxmc/ias_pn_model.py index 3c5c719..a8cee77 100644 --- a/src/rxmc/ias_pn_model.py +++ b/src/rxmc/ias_pn_model.py @@ -13,9 +13,24 @@ import numpy as np from .ias_pn_observation import IsobaricAnalogPNObservation +from .observation_from_measurement import MB_PER_B from .physical_model import PhysicalModel +def _require_observation(observation) -> None: + """Reject observations this model cannot evaluate on. + + Both reaction observations report ``quantity == "dXS/dA"``, so a string + check cannot tell them apart; the class carries the solver workspace the + model needs. + """ + if not isinstance(observation, IsobaricAnalogPNObservation): + raise ValueError( + "IsobaricAnalogPNXSModel requires an IsobaricAnalogPNObservation, " + f"got {type(observation).__name__}" + ) + + class IsobaricAnalogPNXSModel(PhysicalModel): """ A model that predicts the (p,n) IAS differential xs for a given reaction. @@ -106,7 +121,7 @@ def _xs(self, ws, params) -> np.ndarray: self.U_n_central(r, *args_n_central), self.U_n_spin_orbit(r, *args_n_spin_orbit), ) - / 1000 + / MB_PER_B # jitr reports mb/sr; internal unit is b/sr ) def evaluate( @@ -132,6 +147,7 @@ def evaluate( Predicted (p,n) IAS differential cross section in b/sr on ``observation.constraint_workspace.angles``. """ + _require_observation(observation) return self._xs(observation.constraint_workspace, params) def visualizable_model_prediction( @@ -155,6 +171,7 @@ def visualizable_model_prediction( Predicted (p,n) IAS differential cross section in b/sr on ``observation.visualization_workspace.angles``. """ + _require_observation(observation) base, values = self.split_params(params) xs = self._xs(observation.visualization_workspace, base) return self.apply_transform(observation, xs, values) diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py index 545392a..c448fe2 100644 --- a/src/rxmc/ias_pn_observation.py +++ b/src/rxmc/ias_pn_observation.py @@ -1,20 +1,17 @@ import jitr import numpy as np from exfor_tools.distribution import Distribution -from pint import UnitRegistry from .observation import Observation -from .observation_from_measurement import ( +from .observation_from_measurement import ( # noqa: F401 (re-exported names) + DEFAULT_LMAX, + XS_UNIT, check_angle_grid, measurement_kwargs, normalized_error_kwargs, + ureg, ) -# Create a unit registry -ureg = UnitRegistry() - -DEFAULT_LMAX = 20 - class IsobaricAnalogPNObservation(Observation): """ @@ -117,11 +114,13 @@ def __init__( angle_rad_constraint=angles_rad_constraint, angle_rad_vis=angles_rad_vis, lmax=self.lmax, + wavelengths_beyond_range=wavelengths_beyond_range, + zeros_per_node=zeros_per_node, ) self.constraint_workspace = constraint_ws self.visualization_workspace = vis_ws - self.y_units = ureg.barn / ureg.steradian + self.y_units = XS_UNIT measurement_unit = 1 * ureg(y_units) if not measurement_unit.check(self.y_units): raise ValueError( diff --git a/src/rxmc/observation_from_measurement.py b/src/rxmc/observation_from_measurement.py index 5ac83d4..3dfc871 100644 --- a/src/rxmc/observation_from_measurement.py +++ b/src/rxmc/observation_from_measurement.py @@ -6,10 +6,30 @@ :class:`~rxmc.observation.Observation` subclasses carrying **statistical error only**; any correlated systematic is composed explicitly as a :class:`~rxmc.covariance.Term` in the :class:`~rxmc.constraint.Constraint`. This -module just holds the angle-grid validation they share. +module holds what the reaction observations *and* the reaction models share: +the angle-grid validation, the single ``pint`` unit registry, and the unit +convention (cross sections are stored internally in b/sr; ``jitr`` returns +mb/sr, so model outputs are divided by :data:`MB_PER_B`). """ import numpy as np +from pint import UnitRegistry + +#: The one unit registry for the package. ``pint`` refuses to combine +#: quantities from different registries, so every module must use this one. +ureg = UnitRegistry() + +#: Default maximum partial wave for the reaction solvers. +DEFAULT_LMAX = 20 + +#: Internal cross-section unit: every ``y`` in b/sr. +XS_UNIT = ureg.barn / ureg.steradian + +#: Unit ``jitr`` reports cross sections (and the Rutherford cross section) in. +RUTHERFORD_UNIT = ureg.millibarn / ureg.steradian + +#: Millibarn per barn; divides ``jitr`` output to land in :data:`XS_UNIT`. +MB_PER_B = float((1 * ureg.barn).to(ureg.millibarn).magnitude) def normalized_error_kwargs( diff --git a/src/rxmc/param_sampling.py b/src/rxmc/param_sampling.py index 65c7b8a..7064b41 100644 --- a/src/rxmc/param_sampling.py +++ b/src/rxmc/param_sampling.py @@ -17,6 +17,7 @@ from . import params, proposal from .adaptive_metropolis import adaptive_metropolis from .metropolis_hastings import metropolis_hastings +from .priors import as_prior class Sampler: @@ -51,7 +52,9 @@ def __init__( ): self.params = params self.starting_location = starting_location - self.prior = prior + # a list of scipy marginals becomes an IndependentPrior, as in + # ParameterConfig, so both drivers accept the same prior forms + self.prior = as_prior(prior) self.sampling_algorithm = sampling_algorithm self.args = args if args is not None else () self.kwargs = kwargs if kwargs is not None else {} @@ -64,7 +67,7 @@ def __init__( self.bounds = np.array([param.bounds for param in params]) _validate_object( - prior, + self.prior, "prior", required_methods=["logpdf"], ) @@ -301,8 +304,10 @@ def sample( class BatchedAdaptiveMetropolisSampler(Sampler): """Metropolis sampler that updates the proposal covariance after each batch. - After each completed (non-burn) batch the proposal covariance is replaced - by the empirical covariance of that batch, scaled by ``2.38² / ndim``. + After **every** completed batch — burn-in batches included — the proposal + covariance is replaced by the empirical covariance of that batch, scaled + by ``2.38² / ndim``. Burn-in only affects whether the samples are + recorded, so the proposal adapts during burn-in as is standard. Parameters ---------- @@ -348,10 +353,12 @@ def sample( log_posterior: Callable[[np.ndarray], float], burn: bool = False, ): - """Run the sampler for one batch, updating the proposal after recording. + """Run the sampler for one batch, then adapt the proposal. - Overrides :meth:`Sampler.sample` to adapt the proposal covariance from - the current batch's empirical covariance after each non-burn batch. + Overrides :meth:`Sampler.sample` to replace the proposal covariance + with the current batch's empirical covariance after every batch, + burn-in or not. :attr:`proposal` and :attr:`proposal_cov` always + reflect the proposal the *next* batch will use. Parameters ---------- @@ -364,8 +371,8 @@ def sample( log_posterior : callable Function ``f(x) -> float`` returning the log posterior. burn : bool, optional - If ``True``, discard samples and skip covariance update. - Defaults to ``False``. + If ``True``, discard the samples (they are not recorded); the + covariance update still happens. Defaults to ``False``. """ chain, logp_chain, accepted = self.sampling_algorithm( starting_location, @@ -382,8 +389,8 @@ def sample( self.proposal_cov = ( self.scale * empirical_cov + np.eye(empirical_cov.shape[0]) * epsilon ) - new_proposal = proposal.NormalProposalDistribution(self.proposal_cov) - self.args = [new_proposal] + self.proposal = proposal.NormalProposalDistribution(self.proposal_cov) + self.args = [self.proposal] if not burn: self.record_batch(n_steps, accepted, chain, logp_chain) diff --git a/src/rxmc/params.py b/src/rxmc/params.py index 122d40c..a5fc547 100644 --- a/src/rxmc/params.py +++ b/src/rxmc/params.py @@ -24,7 +24,15 @@ class Parameter: ``name`` when not supplied. bounds : tuple of float, optional ``(lower, upper)`` bounds for the parameter. Defaults to - ``(-np.inf, np.inf)``. + ``(-np.inf, np.inf)``. Stored as a tuple of floats. + + Notes + ----- + Equality and hashing are by *value* (all five fields), so equal + parameters are interchangeable as dict keys and set members. Sharing one + sampled value between covariance terms is by object *identity* (see + :mod:`rxmc.covariance`); two equal-but-distinct parameters are two + parameters. """ def __init__( @@ -33,16 +41,26 @@ def __init__( self.name = name self.dtype = dtype self.unit = unit + bounds = tuple(float(b) for b in bounds) + if len(bounds) != 2: + raise ValueError(f"bounds must be (lower, upper), got {bounds!r}") self.bounds = bounds self.latex_name = latex_name if latex_name else name + def _key(self): + return (self.name, self.dtype, self.unit, self.latex_name, self.bounds) + def __eq__(self, other): if not isinstance(other, Parameter): return False + return self._key() == other._key() + + def __hash__(self): + return hash(self._key()) + + def __repr__(self): return ( - self.name == other.name - and self.dtype == other.dtype - and self.unit == other.unit - and self.latex_name == other.latex_name - and self.bounds == other.bounds + f"Parameter({self.name!r}, dtype={self.dtype.__name__}, " + f"unit={self.unit!r}, latex_name={self.latex_name!r}, " + f"bounds={self.bounds!r})" ) diff --git a/src/rxmc/priors.py b/src/rxmc/priors.py index 0ca649e..d7dbb99 100644 --- a/src/rxmc/priors.py +++ b/src/rxmc/priors.py @@ -26,13 +26,40 @@ def prior_transform(self, u: ndarray) -> ndarray where ``u`` has shape ``(ndim,)`` with each element in ``[0, 1)`` and the return value is the corresponding physical parameter vector. Both :class:`IndependentPrior` and :class:`TruncatedNormalPrior` provide this -method via the ``ppf`` of each marginal distribution. +method via the ``ppf`` of each marginal distribution; they clip ``u`` into +the open unit cube first (:func:`clip_unit_cube`) so an exact ``0`` or ``1`` +never yields ``±inf``. """ import numpy as np from scipy import stats +def clip_unit_cube(u) -> np.ndarray: + """Coerce ``u`` to a float array clipped into the open unit cube. + + Exact ``0.0`` / ``1.0`` map to ``±inf`` under an unbounded marginal's + ``ppf``; clipping to ``[eps, 1 - eps]`` keeps every ``prior_transform`` + finite. Shared by every prior transform in the package. + """ + u = np.asarray(u, dtype=float) + eps = np.finfo(float).eps + return np.clip(u, eps, 1.0 - eps) + + +def as_prior(prior): + """Coerce a list/tuple of frozen univariate distributions to an + :class:`IndependentPrior`; any other prior object is returned unchanged. + + The single place where the "list of marginals" form is accepted, so + :class:`~rxmc.config.ParameterConfig` and + :class:`~rxmc.param_sampling.Sampler` agree on it. + """ + if isinstance(prior, (list, tuple)): + return IndependentPrior(list(prior)) + return prior + + class TruncatedNormalPrior: """Independent truncated-normal prior for a vector of parameters. @@ -149,7 +176,7 @@ def prior_transform(self, u): Physical parameter vector obtained by applying the component-wise percent-point function of each truncated normal. """ - u = np.asarray(u, dtype=float) + u = clip_unit_cube(u) theta = np.empty_like(u) for j in range(self.dim): theta[j] = stats.truncnorm.ppf( @@ -270,7 +297,7 @@ def prior_transform(self, u) -> np.ndarray: ndarray, shape (ndim,) Physical parameter vector. """ - u = np.asarray(u, dtype=float) + u = clip_unit_cube(u) theta = np.empty_like(u) for j, dist in enumerate(self.distributions): theta[j] = dist.ppf(u[j]) diff --git a/src/rxmc/walker.py b/src/rxmc/walker.py index 643bcba..2c76b52 100644 --- a/src/rxmc/walker.py +++ b/src/rxmc/walker.py @@ -34,6 +34,10 @@ class Walker: One sampler per entry in ``evidence.parametric_constraints``. rng : np.random.Generator, optional Random number generator. Defaults to ``default_rng(42)``. + likelihood_scaling : float, optional + Tempering factor applied to the log likelihood (never the prior) in + both the model block and the Gibbs conditionals, mirroring + :class:`~rxmc.config.CalibrationConfig`. Defaults to ``1.0``. Raises ------ @@ -54,10 +58,14 @@ def __init__( evidence: Evidence, likelihood_samplers: list[Sampler] | None = None, rng: np.random.Generator | None = None, + likelihood_scaling: float | None = None, ): self.model_sampler = model_sampler self.likelihood_samplers = likelihood_samplers or [] self.evidence = evidence + self.likelihood_scaling = ( + 1.0 if likelihood_scaling is None else float(likelihood_scaling) + ) self.rng = rng if rng is not None else np.random.default_rng(42) self.gibbs_sampling = len(self.likelihood_samplers) > 0 @@ -123,25 +131,37 @@ def run_likelihood_batches( If ``True``, treat as burn-in (samples are not recorded). """ wmll = self.evidence.weighted_marginal_log_likelihood + scaling = self.likelihood_scaling for i, sampler in enumerate(self.likelihood_samplers): constraint = self.evidence.parametric_constraints[i] ym = constraint.predict(*model_params) def log_posterior_lm(x, sampler=sampler, i=i, ym=ym): - lp = sampler.prior.logpdf(x) + wmll(i, ym, *np.atleast_1d(x)) - return float(np.squeeze(lp)) + # prior first: an out-of-support proposal never pays for the + # likelihood (matches CalibrationConfig.conditional_posterior) + lp = float(np.squeeze(sampler.prior.logpdf(x))) + if not np.isfinite(lp): + return -np.inf + ll = float(np.squeeze(wmll(i, ym, *np.atleast_1d(x)))) + return lp + scaling * ll x0 = starting_locations[i] sampler.sample(n_steps, x0, self.rng, log_posterior_lm, burn=burn) def log_likelihood(self, model_params, likelihood_params): - return self.evidence.log_likelihood(model_params, likelihood_params) - - def log_posterior(self, model_params, likelihood_params): - return self.log_likelihood(model_params, likelihood_params) + self.log_prior( + """``likelihood_scaling * evidence.log_likelihood(...)``.""" + return self.likelihood_scaling * self.evidence.log_likelihood( model_params, likelihood_params ) + def log_posterior(self, model_params, likelihood_params): + """Log posterior; ``-inf`` without evaluating the likelihood (and + hence the physical model) when the prior is not finite.""" + lp = self.log_prior(model_params, likelihood_params) + if not np.isfinite(lp): + return -np.inf + return lp + self.log_likelihood(model_params, likelihood_params) + def log_prior(self, model_params, likelihood_params): """Log prior probability of model and likelihood parameters. @@ -205,51 +225,48 @@ def walk( burn_batches = [] for i, steps_in_batch in enumerate(burn_batches): - self.run_model_batch( - steps_in_batch, - self.model_sampler.state, - [sampler.state for sampler in self.likelihood_samplers], - burn=True, - ) - - if self.gibbs_sampling: - self.run_likelihood_batches( - steps_in_batch, - [sampler.state for sampler in self.likelihood_samplers], - self.model_sampler.state, - burn=True, - ) - + self._run_batch(steps_in_batch, burn=True) if verbose: - print( - f"Burn-in batch {i + 1}/{len(burn_batches)}" - f" completed, {steps_in_batch} steps." - ) + print(self._batch_message(i, len(burn_batches), steps_in_batch, True)) for i, steps_in_batch in enumerate(batches): - self.run_model_batch( - steps_in_batch, - self.model_sampler.state, + self._run_batch(steps_in_batch, burn=False) + if verbose: + print(self._batch_message(i, len(batches), steps_in_batch, False)) + + def _run_batch(self, steps: int, burn: bool) -> None: + """One Gibbs sweep: the model block, then each likelihood block.""" + self.run_model_batch( + steps, + self.model_sampler.state, + [sampler.state for sampler in self.likelihood_samplers], + burn=burn, + ) + if self.gibbs_sampling: + self.run_likelihood_batches( + steps, [sampler.state for sampler in self.likelihood_samplers], + self.model_sampler.state, + burn=burn, ) - if self.gibbs_sampling: - self.run_likelihood_batches( - steps_in_batch, - [sampler.state for sampler in self.likelihood_samplers], - self.model_sampler.state, - ) + def _batch_message(self, index: int, n_batches: int, steps: int, burn: bool): + """Progress line for a batch. - if verbose: - msg = ( - f"Batch: {i + 1}/{len(batches)} completed, " - f"{steps_in_batch} steps. " - f"\n Model parameter acceptance fraction: " - f"{self.model_sampler.most_recent_batch_acceptance_fraction():.3f}" - ) - if self.gibbs_sampling: - msg += ( - f"\n Likelihood parameter acceptance fractions: " - f"{[sampler.most_recent_batch_acceptance_fraction() for sampler in self.likelihood_samplers]}" - ) - print(msg) + Burn-in batches are not recorded, so no acceptance fraction is + available for them and none is printed. + """ + if burn: + return f"Burn-in batch {index + 1}/{n_batches} completed, {steps} steps." + msg = ( + f"Batch: {index + 1}/{n_batches} completed, {steps} steps. " + f"\n Model parameter acceptance fraction: " + f"{self.model_sampler.most_recent_batch_acceptance_fraction():.3f}" + ) + if self.gibbs_sampling: + fractions = [ + sampler.most_recent_batch_acceptance_fraction() + for sampler in self.likelihood_samplers + ] + msg += f"\n Likelihood parameter acceptance fractions: {fractions}" + return msg diff --git a/test/test_config.py b/test/test_config.py index e5bf117..605661b 100644 --- a/test/test_config.py +++ b/test/test_config.py @@ -10,7 +10,7 @@ from rxmc.observation import Observation from rxmc.params import Parameter from rxmc.physical_model import Polynomial -from rxmc.priors import TruncatedNormalPrior +from rxmc.priors import IndependentPrior, TruncatedNormalPrior def gamma_parameter(): @@ -102,6 +102,61 @@ def test_prior_transform_list(self): theta = config.prior_transform(u) np.testing.assert_allclose(theta, [0.0, 0.0], atol=1e-10) + def test_list_prior_is_wrapped_in_independent_prior(self): + """A list of marginals becomes one IndependentPrior (as in Sampler).""" + prior_list = [scipy.stats.norm(0, 1), scipy.stats.uniform(0, 2)] + config = ParameterConfig( + params=[self.param1, self.param2], + prior=prior_list, + initial_proposal_distribution=prior_list, + ) + self.assertIsInstance(config.prior, IndependentPrior) + self.assertIsInstance(config.initial_proposal_distribution, IndependentPrior) + self.assertEqual(config.x0(3).shape, (3, 2)) + x = np.array([0.3, 1.0]) + expected = sum(d.logpdf(xi) for d, xi in zip(prior_list, x)) + self.assertAlmostEqual(config.prior_logpdf(x), expected) + with self.assertRaises(ValueError): + ParameterConfig( + params=[self.param1], + prior=prior_list, + initial_proposal_distribution=prior_list, + ) + + def test_infer_dim_calls_mean_method(self): + """A custom prior exposing mean() as a method is sized correctly.""" + + class Custom: + def mean(self): + return np.zeros(3) + + def logpdf(self, x): + return 0.0 + + def rvs(self, n): + return np.zeros((n, 3)) + + self.assertEqual(ParameterConfig._infer_dim(Custom()), 3) + params = [Parameter(f"p{i}") for i in range(3)] + ParameterConfig(params, prior=Custom(), initial_proposal_distribution=Custom()) + with self.assertRaises(ValueError): + ParameterConfig( + params[:2], prior=Custom(), initial_proposal_distribution=Custom() + ) + # frozen scipy univariates expose mean() too and stay one-dimensional + self.assertEqual(ParameterConfig._infer_dim(scipy.stats.norm(0, 1)), 1) + + def test_prior_transform_boundary_finite(self): + """u = 0 / 1 are clipped into the open cube before ppf.""" + prior_list = [scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)] + config = ParameterConfig( + params=[self.param1, self.param2], + prior=prior_list, + initial_proposal_distribution=prior_list, + ) + theta = config.prior_transform(np.array([0.0, 1.0])) + self.assertTrue(np.all(np.isfinite(theta))) + def test_prior_transform_generic(self): """Generic prior with prior_transform method is called directly.""" # Use symmetric bounds so the median (u=0.5) maps exactly to mu. diff --git a/test/test_params.py b/test/test_params.py new file mode 100644 index 0000000..abc8bcd --- /dev/null +++ b/test/test_params.py @@ -0,0 +1,52 @@ +import unittest + +import numpy as np + +from rxmc.params import Parameter + + +class TestParameterHashing(unittest.TestCase): + def test_equal_parameters_hash_equal(self): + a = Parameter("g", float, unit="MeV", latex_name="g", bounds=(0.0, 1.0)) + b = Parameter("g", float, unit="MeV", latex_name="g", bounds=(0.0, 1.0)) + self.assertEqual(a, b) + self.assertEqual(hash(a), hash(b)) + + def test_unequal_parameters_differ(self): + a = Parameter("g") + self.assertNotEqual(a, Parameter("h")) + self.assertNotEqual(a, Parameter("g", unit="MeV")) + self.assertNotEqual(a, Parameter("g", bounds=(0.0, 1.0))) + self.assertNotEqual(a, "g") + + def test_usable_in_set_and_dict(self): + a = Parameter("a") + b = Parameter("b") + self.assertEqual(len({a, b, Parameter("a")}), 2) + table = {a: 1, b: 2} + self.assertEqual(table[Parameter("a")], 1) + + def test_bounds_coerced_to_float_tuple(self): + for bounds in ([0, 2], np.array([0.0, 2.0]), (0, 2)): + p = Parameter("x", bounds=bounds) + self.assertEqual(p.bounds, (0.0, 2.0)) + self.assertIsInstance(p.bounds, tuple) + self.assertTrue(all(isinstance(b, float) for b in p.bounds)) + + def test_default_bounds_are_infinite(self): + self.assertEqual(Parameter("x").bounds, (-np.inf, np.inf)) + + def test_bad_bounds_length_raises(self): + with self.assertRaises(ValueError): + Parameter("x", bounds=(0.0, 1.0, 2.0)) + + def test_repr_contains_fields(self): + r = repr(Parameter("V", float, unit="MeV", latex_name=r"V_0", bounds=(0, 9))) + self.assertIn("'V'", r) + self.assertIn("MeV", r) + self.assertIn("V_0", r) + self.assertIn("(0.0, 9.0)", r) + + +if __name__ == "__main__": + unittest.main() diff --git a/test/test_priors.py b/test/test_priors.py index 3fffd88..1350323 100644 --- a/test/test_priors.py +++ b/test/test_priors.py @@ -5,7 +5,12 @@ from rxmc.config import ParameterConfig from rxmc.params import Parameter -from rxmc.priors import IndependentPrior, TruncatedNormalPrior +from rxmc.priors import ( + IndependentPrior, + TruncatedNormalPrior, + as_prior, + clip_unit_cube, +) class TestIndependentPrior(unittest.TestCase): @@ -139,5 +144,36 @@ def test_prior_transform_roundtrip(self): self.assertTrue(np.isfinite(lp)) +class TestUnitCubeClipping(unittest.TestCase): + def test_clip_unit_cube(self): + u = clip_unit_cube([0.0, 0.5, 1.0]) + eps = np.finfo(float).eps + np.testing.assert_allclose(u, [eps, 0.5, 1.0 - eps]) + self.assertEqual(u.dtype, float) + self.assertTrue(np.all(u > 0.0) and np.all(u < 1.0)) + + def test_independent_prior_boundary_is_finite(self): + # an unbounded marginal's ppf is +-inf at exactly 0 / 1 + prior = IndependentPrior([scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)]) + theta = prior.prior_transform([0.0, 1.0]) + self.assertTrue(np.all(np.isfinite(theta))) + self.assertLess(theta[0], 0.0) + self.assertGreater(theta[1], 0.0) + + def test_truncated_normal_boundary_is_finite(self): + prior = TruncatedNormalPrior(mu=[0.0], sigma=[1.0], lower=[-2.0], upper=[3.0]) + theta = prior.prior_transform([0.0]) + self.assertTrue(np.all(np.isfinite(theta))) + np.testing.assert_allclose(theta, [-2.0], atol=1e-6) + + def test_as_prior_wraps_lists_only(self): + dists = [scipy.stats.norm(0, 1)] + wrapped = as_prior(dists) + self.assertIsInstance(wrapped, IndependentPrior) + self.assertIs(wrapped.distributions[0], dists[0]) + prior = TruncatedNormalPrior(mu=[0.0], sigma=[1.0], lower=[-1.0], upper=[1.0]) + self.assertIs(as_prior(prior), prior) + + if __name__ == "__main__": unittest.main() diff --git a/test/test_reaction_models.py b/test/test_reaction_models.py index aae6ae3..964d89b 100644 --- a/test/test_reaction_models.py +++ b/test/test_reaction_models.py @@ -116,5 +116,43 @@ def test_evaluate_and_visualization_smoke(self): self.assertTrue(np.all(np.isfinite(y_vis))) +class TestObservationTypeChecks(unittest.TestCase): + """A reaction model refuses an observation of the wrong class up front + (no solver is touched, so these need no jitr workspace).""" + + def setUp(self): + from rxmc.observation import Observation + + self.plain = Observation(x=np.array([0.1, 0.2]), y=np.array([1.0, 1.0])) + self.elastic = ElasticDifferentialXSModel( + "dXS/dA", + interaction_central=central, + interaction_spin_orbit=spin_orbit, + calculate_interaction_from_params=lambda ws, *x: (tuple(x), ()), + params=[Parameter("Vv")], + ) + self.ias = IsobaricAnalogPNXSModel( + U_p_coulomb=coulomb_charged_sphere, + U_p_central=central, + U_p_spin_orbit=spin_orbit, + U_n_central=central, + U_n_spin_orbit=spin_orbit, + calculate_params=lambda ws, *x: ((), (), (), (), ()), + params=[Parameter("Vv")], + ) + + def test_elastic_model_rejects_foreign_observation(self): + with self.assertRaisesRegex(ValueError, "ElasticDifferentialXSObservation"): + self.elastic.evaluate(self.plain, 1.0) + with self.assertRaisesRegex(ValueError, "ElasticDifferentialXSObservation"): + self.elastic.visualizable_model_prediction(self.plain, 1.0) + + def test_ias_model_rejects_foreign_observation(self): + with self.assertRaisesRegex(ValueError, "IsobaricAnalogPNObservation"): + self.ias.evaluate(self.plain, 1.0) + with self.assertRaisesRegex(ValueError, "IsobaricAnalogPNObservation"): + self.ias.visualizable_model_prediction(self.plain, 1.0) + + if __name__ == "__main__": unittest.main() diff --git a/test/test_reaction_observation.py b/test/test_reaction_observation.py index aaebf7a..d104567 100644 --- a/test/test_reaction_observation.py +++ b/test/test_reaction_observation.py @@ -348,5 +348,75 @@ def test_unit_conversion_divides_offset_not_normalization(self, mock_set_up_solv self.assertEqual(obs.y_sys_err_normalization, 0.02) +class TestSolverSettingsForwarding(unittest.TestCase): + """The basis-size settings must reach ``set_up_solver`` on both classes.""" + + @patch("rxmc.elastic_diffxs_observation.set_up_solver") + def test_elastic_forwards_solver_settings(self, mock_set_up_solver): + mock_set_up_solver.return_value = ( + DummyElasticWorkspace(), + DummyElasticWorkspace(), + object(), + ) + ElasticDifferentialXSObservation( + x=np.array([15.0, 30.0]), + y=np.array([1.0, 0.5]), + Elab=12.0, + reaction=object(), + quantity="dXS/dA", + measurement_quantity="dXS/dA", + y_units="barn / steradian", + lmax=7, + wavelengths_beyond_range=3.5, + zeros_per_node=9, + ) + kwargs = mock_set_up_solver.call_args.kwargs + self.assertEqual(kwargs["lmax"], 7) + self.assertEqual(kwargs["wavelengths_beyond_range"], 3.5) + self.assertEqual(kwargs["zeros_per_node"], 9) + + @patch("rxmc.ias_pn_observation.set_up_solver") + def test_ias_forwards_solver_settings(self, mock_set_up_solver): + mock_set_up_solver.return_value = (object(), object(), object(), object()) + IsobaricAnalogPNObservation( + x=np.array([10.0, 25.0]), + y=np.array([0.4, 0.3]), + Elab=30.0, + reaction=object(), + ExIAS=5.0, + y_units="barn / steradian", + lmax=7, + wavelengths_beyond_range=3.5, + zeros_per_node=9, + ) + kwargs = mock_set_up_solver.call_args.kwargs + self.assertEqual(kwargs["lmax"], 7) + self.assertEqual(kwargs["wavelengths_beyond_range"], 3.5) + self.assertEqual(kwargs["zeros_per_node"], 9) + + +class TestSharedUnits(unittest.TestCase): + def test_one_unit_registry(self): + import rxmc.elastic_diffxs_observation as elastic + import rxmc.ias_pn_observation as ias + from rxmc.observation_from_measurement import ureg + + self.assertIs(elastic.ureg, ureg) + self.assertIs(ias.ureg, ureg) + self.assertEqual(elastic.DEFAULT_LMAX, ias.DEFAULT_LMAX) + + def test_unit_constants_agree(self): + from rxmc.observation_from_measurement import ( + MB_PER_B, + RUTHERFORD_UNIT, + XS_UNIT, + ureg, + ) + + self.assertEqual(MB_PER_B, 1000.0) + self.assertEqual((1 * XS_UNIT).to(RUTHERFORD_UNIT).magnitude, MB_PER_B) + self.assertTrue((1 * ureg("mb/sr")).check(XS_UNIT)) + + if __name__ == "__main__": unittest.main() diff --git a/test/test_sampler.py b/test/test_sampler.py index 461c1c9..a974708 100644 --- a/test/test_sampler.py +++ b/test/test_sampler.py @@ -1,4 +1,7 @@ +import io import unittest +from contextlib import redirect_stdout +from types import SimpleNamespace import numpy as np import scipy.stats @@ -8,9 +11,14 @@ from rxmc.covariance import Term from rxmc.evidence import Evidence from rxmc.observation import Observation -from rxmc.param_sampling import AdaptiveMetropolisSampler, MetropolisHastingsSampler +from rxmc.param_sampling import ( + AdaptiveMetropolisSampler, + BatchedAdaptiveMetropolisSampler, + MetropolisHastingsSampler, +) from rxmc.params import Parameter from rxmc.physical_model import Polynomial +from rxmc.priors import IndependentPrior from rxmc.proposal import NormalProposalDistribution from rxmc.walker import Walker @@ -167,10 +175,191 @@ def sample(self, n_steps, x0, rng, log_posterior, burn=False): self.assertAlmostEqual(lm_sampler.captured(x), expected) +class CapturingSampler: + """Records the conditional posterior a Walker hands it; never samples.""" + + def __init__(self, params, prior): + self.params = list(params) + self.prior = prior + self.captured = None + + def sample(self, n_steps, x0, rng, log_posterior, burn=False): + self.captured = log_posterior + + +class NegInfPrior: + def logpdf(self, x): + return -np.inf + + +def parametric_setup(weight=1.0): + """A one-constraint Evidence with a two-parameter noise term.""" + model = Polynomial(1) + observation = Observation( + x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), + y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), + y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), + ) + constraint = Constraint( + observations=[observation], + physical_model=model, + extra_terms=[floor_slope_noise_term(np.arange(observation.n_data_pts))], + ) + evidence = Evidence(constraints=[constraint], weights=np.array([weight])) + return model, constraint, evidence + + +class TestWalkerPosterior(unittest.TestCase): + """Parity with CalibrationConfig: prior-first short-circuit and tempering.""" + + def test_log_posterior_skips_likelihood_when_prior_neg_inf(self): + calls = [] + evidence = SimpleNamespace( + model_params=[Parameter("a")], + parametric_constraints=[], + log_likelihood=lambda mp, lp: calls.append(mp) or 0.0, + ) + walker = Walker( + model_sampler=SimpleNamespace( + params=evidence.model_params, prior=NegInfPrior() + ), + evidence=evidence, + ) + self.assertEqual(walker.log_posterior((1.0,), []), -np.inf) + self.assertEqual(calls, []) + + def test_gibbs_conditional_skips_likelihood_when_prior_neg_inf(self): + calls = [] + lm_params = [Parameter("nu")] + constraint = SimpleNamespace( + params=lm_params, predict=lambda *mp: [np.zeros(3)] + ) + evidence = SimpleNamespace( + model_params=[Parameter("a")], + parametric_constraints=[constraint], + weighted_marginal_log_likelihood=lambda i, ym, *x: calls.append(x) or 0.0, + ) + lm_sampler = CapturingSampler(lm_params, NegInfPrior()) + walker = Walker( + model_sampler=SimpleNamespace( + params=evidence.model_params, prior=NegInfPrior() + ), + evidence=evidence, + likelihood_samplers=[lm_sampler], + ) + walker.run_likelihood_batches(1, [np.array([1.0])], (0.5,)) + self.assertEqual(lm_sampler.captured(np.array([1.0])), -np.inf) + self.assertEqual(calls, []) + + def test_log_posterior_applies_likelihood_scaling(self): + scaling = 0.25 + model, constraint, evidence = parametric_setup() + model_prior = scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)) + lm_prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) + walker = Walker( + model_sampler=SimpleNamespace( + params=evidence.model_params, prior=model_prior + ), + evidence=evidence, + likelihood_samplers=[CapturingSampler(constraint.params, lm_prior)], + likelihood_scaling=scaling, + ) + mp, x = (0.9, 1.0), np.array([-2.0, -2.0]) + expected = ( + model_prior.logpdf(np.array(mp)) + + lm_prior.logpdf(x) + + scaling * evidence.log_likelihood(mp, [x]) + ) + self.assertAlmostEqual(walker.log_posterior(mp, [x]), float(expected)) + self.assertAlmostEqual( + walker.log_likelihood(mp, [x]), scaling * evidence.log_likelihood(mp, [x]) + ) + + def test_gibbs_conditional_applies_likelihood_scaling_and_weight(self): + # mirrors test_config.py::test_conditional_posterior_tempering + scaling, weight = 0.5, 3.0 + model, constraint, evidence = parametric_setup(weight=weight) + prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) + lm_sampler = CapturingSampler(constraint.params, prior) + walker = Walker( + model_sampler=SimpleNamespace(params=evidence.model_params, prior=prior), + evidence=evidence, + likelihood_samplers=[lm_sampler], + likelihood_scaling=scaling, + ) + mp = (0.9, 1.0) + walker.run_likelihood_batches(1, [np.array([-2.0, -2.0])], mp) + + x = np.array([-2.0, -2.0]) + ym = constraint.predict(*mp) + expected = prior.logpdf( + x + ) + scaling * weight * constraint.marginal_log_likelihood(ym, *x) + self.assertAlmostEqual(lm_sampler.captured(x), float(expected)) + + def test_burn_message_has_no_acceptance_fraction(self): + model = Polynomial(1) + observation = Observation( + x=np.array([0.0, 1.0, 2.0]), + y=np.array([1.0, 2.1, 3.2]), + y_stat_err=np.array([0.1, 0.1, 0.1]), + ) + evidence = Evidence( + constraints=[Constraint(observations=[observation], physical_model=model)] + ) + sampler = MetropolisHastingsSampler( + params=model.params, + prior=scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)), + starting_location=np.array([0.9, 1.0]), + proposal=NormalProposalDistribution(0.01 * np.eye(2)), + ) + walker = Walker(sampler, evidence, rng=np.random.default_rng(0)) + out = io.StringIO() + with redirect_stdout(out): + walker.walk(n_steps=2, burnin=2, batch_size=2, verbose=True) + lines = out.getvalue().splitlines() + burn = [line for line in lines if line.startswith("Burn-in batch")] + self.assertEqual(len(burn), 1) + self.assertNotIn("acceptance", burn[0]) + self.assertTrue(any("acceptance fraction" in line for line in lines)) + self.assertEqual(walker.model_sampler.chain.shape, (2, 2)) + + +class TestSamplerPriors(unittest.TestCase): + def test_sampler_accepts_list_prior(self): + sampler = MetropolisHastingsSampler( + params=[Parameter("x"), Parameter("y")], + prior=[scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)], + starting_location=np.zeros(2), + proposal=NormalProposalDistribution(0.01 * np.eye(2)), + ) + self.assertIsInstance(sampler.prior, IndependentPrior) + self.assertTrue(np.isfinite(sampler.prior.logpdf(np.zeros(2)))) + + def test_batched_adaptive_updates_proposal_after_burn_batch(self): + sampler = BatchedAdaptiveMetropolisSampler( + params=[Parameter("x"), Parameter("y")], + prior=scipy.stats.multivariate_normal(mean=[0.0, 0.0], cov=np.eye(2)), + starting_location=np.zeros(2), + initial_proposal_cov=np.eye(2), + ) + initial = sampler.proposal + sampler.sample( + n_steps=30, + starting_location=np.zeros(2), + rng=np.random.default_rng(7), + log_posterior=lambda x: -0.5 * float(x @ x), + burn=True, + ) + # burn-in records nothing but does adapt; the public proposal follows + self.assertEqual(sampler.chain.shape, (0, 2)) + self.assertIsNot(sampler.proposal, initial) + self.assertIs(sampler.args[0], sampler.proposal) + np.testing.assert_allclose(sampler.proposal.cov, sampler.proposal_cov) + + class TestWalkerValidation(unittest.TestCase): def setUp(self): - from types import SimpleNamespace - self.SimpleNamespace = SimpleNamespace self.model = Polynomial(1) obs = Observation( From 5fbab652d25d188d557d29cddcd053bef22b2bfb Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 10 Sep 2026 14:02:44 -0400 Subject: [PATCH 23/24] Rewrite the ground-up design as the plan of record and add the recipes page docs/groundup_design.md now guides a from-scratch rewrite on a branch of this repository rather than an incremental migration: immutable declarations compiled by one Problem, structured (Woodbury) covariance, external samplers only, a capability map covering every notebook and test behaviour, a harvest table, the gaps to fill, milestones that slot the recipe tests in as capabilities arrive, and the 0.x to 1.0 release path. docs/recipes.md is the companion: 42 user stories with the new spelling, expected behaviour and citations, each of which becomes a test in the rewrite, plus the list of what the API deliberately does not express. --- docs/groundup_design.md | 1409 +++++++++++++++++++++++++++------------ docs/index.rst | 1 + docs/recipes.md | 1314 ++++++++++++++++++++++++++++++++++++ 3 files changed, 2304 insertions(+), 420 deletions(-) create mode 100644 docs/recipes.md diff --git a/docs/groundup_design.md b/docs/groundup_design.md index c5c8d7a..4dcdb56 100644 --- a/docs/groundup_design.md +++ b/docs/groundup_design.md @@ -1,536 +1,1105 @@ # A ground-up rxmc: declare, then compile -This document sketches what `rxmc` would look like if rewritten from scratch -around one principle, compares it with the current `api_generalisation` -design (`design.md`), and lays out an incremental path from one to the other. -It is a design proposal, not a plan of record. - -The conclusion first: the *concepts* in `design.md` survive intact. Evidence -over independent constraints, constraint as the maximal correlated block, one -`Term` with three kinds, likelihood as a functional of `(d2, logdet, n)`, -comparison space owned by the data side, masks as part of support, and the -case A / case B distinction are all things this design keeps. What changes -is the *mechanics*: how parameters are routed, how the covariance is -represented, where solver state lives, and when validation happens. - -## 1. The principle - -**Everything the user constructs is an immutable declaration. One compile -step turns the declaration into evaluators.** - -Today the same objects do both jobs. A `Term` is authored by the user and -then binds its support, caches coordinate transforms, and refuses to be reused -in a second constraint. An `Observation` is "pure data" and also carries a -jitr workspace, a comparison transform, a mask, and an identity key that -`per_observation_scaling` routes on. `Constraint.__init__` is the compile -step for one constraint, `Evidence.__init__` re-validates across constraints, -and `CalibrationConfig` / `Walker` each compile the flat parameter vector -again. Every lifecycle rule in the current docs ("one Term belongs to one -constraint", "masked views share terms", "parameters are constraint-scoped", -"the same Parameter object across constraints is an error") is a consequence -of declaration and evaluation being fused. - -Separating them gives: - -- one place where parameters get slots, names get checked, supports get - resolved, constant pieces get factored, and singular covariances get - reported; -- specs that are reusable, comparable, and serialisable because they hold no - caches; -- a single flat parameter vector that both samplers, model comparison, and - plotting read from through one index instead of ten positional splits. - -## 2. Components - -The declarative layer, bottom up. - -### 2.1 `Parameter` +This document guides a rewrite of `rxmc` from a blank repository. It is the +plan of record for that rewrite, not a comparison with the current code: the +current `api_generalisation` branch stays where it is as the reference +implementation, and `design.md` / `bugs_found.md` remain the record of how +it was designed and what was found wrong with it. `recipes.md` is the +companion: one short user story per use case the rewrite must support, +each with the spelling below and the behaviour a user should expect. + +The *concepts* of `design.md` survive unchanged: evidence as a weighted sum +over independent constraints; a constraint as the maximal block of mutually +correlated data; one `Term` type with three kinds; the likelihood as a +functional of `(d2, logdet, n)`; the comparison space owned by the data side; +masks as part of support; and the case A (couple the data) / case B (share +a parameter) distinction. The *mechanics* are rebuilt around one rule: + +> **Everything the user constructs is an immutable declaration. +> `Problem` is the only compile step.** + +Three goals drive every choice below, in this order: + +1. **The maintainer.** The smallest implementation that covers every + capability the current notebooks and tests demonstrate, with no + lifecycle rules to remember. Budget: about 2,300 lines of package code + in 14 modules, down from 6,199 in 23. +2. **The user.** Declaring a problem, including each statistical modelling + choice in it, reads as a statement of the model. A reviewer should be + able to read the declaration and write down the likelihood. +3. **External samplers only.** emcee, dynesty and the `black-box-bayes` + CLI are the calibration drivers. The in-package Gibbs walker and its + samplers are not carried over. + +## 1. Rules for the maintainer + +These are the review checklist for every change in the new repository. + +1. **Specs hold no caches and no solver state.** `Parameter`, `Dataset`, + `Model`, `Term`, `Comparison`, `Constraint` are frozen dataclasses with + `eq=False`: identity is the equality, for every spec, not only + `Parameter`. (A generated `__eq__` would try to compare the arrays + they hold and raise.) Anything expensive or grid-dependent lives in + the objects `Problem` builds. +2. **Exactly one function walks the parameter graph:** `Problem.__init__`. + Nothing else assigns slots, checks names, resolves supports, or decides + which prior covers which slot. +3. **Gather, never split.** Every callable node receives one integer + gather array at compile time and is evaluated as `node(*theta[gather])`. + There is no `n_model_params`, no `indices[:-1]`, no `split_params`. +4. **Every user-supplied callable has one shape:** `fn(context, *values)`, + where `context` is the grid `x` (models, transforms) or a `TermContext` + (terms, bases, amplitudes) and `values` are the sampled values of the + parameters the node declares, in declaration order. +5. **Sharing is spelled by passing the same `Parameter` object.** Inside a + term, between terms, between a model and a term, across constraints. + There is no second identity notion and no value-equality anywhere. +6. **One factorisation path.** `StructuredCovariance` is the only way a + covariance is factored. The dense matrix exists as a display method + and as the reference in tests. +7. **Fail at compile, and name the dataset.** Singular constant + covariance, duplicate parameter names, a slot no prior covers, an `on=` + that references a block outside its constraint, a non-finite value in + comparison space: all raised by `Problem`, never mid-chain. +8. **Nothing is folded into a covariance silently.** A dataset's reported + systematics become terms only when the user asks + (`block.reported_terms()`). +9. **A `Problem` pickles with `dill`.** `black-box-bayes` ships it to every + MPI rank by path. A round-trip test on a reaction problem is part of + the suite. +10. **Correctness lives in tests that pin numbers**, not in defensive + branches: the closed-form Student-t, delta-method errors under `log`, + the regression log-likelihood `1.195784087817536`, dense-versus- + structured equality on every error-model form. **Every recipe in + `recipes.md` is a test** under `test/recipes/`, one file per recipe + named `test_recipe_NN_.py`, whose docstring quotes the recipe's + intent and whose assertions are its *Expected behaviour* bullets. A + CI check fails when a `## NN.` heading in `recipes.md` has no test + file, or a test file has no heading. + +## 2. The API skeleton + +Read top to bottom. Module names are the package layout of §6. Type hints +are the documentation; the prose says only what the signature cannot. + +### 2.1 `params.py` ```python @dataclass(eq=False, frozen=True) class Parameter: name: str bounds: tuple[float, float] = (-inf, inf) + prior: object | None = None # frozen scipy univariate: logpdf, cdf, ppf, rvs unit: str = "" latex: str | None = None - prior: Distribution | None = None # optional 1-D marginal ``` -- Identity **is** the object. `eq=False` keeps the default identity hash, so - parameters are hashable and can key dicts and sets. This replaces the - current `__eq__`-without-`__hash__` and every `id(p)` table. -- Sharing a parameter anywhere in the graph means passing the same object. - There is one rule and it holds across constraints too. (Today: identity - inside a constraint, value-equality for model parameters across - constraints, and a hard error for covariance parameters across - constraints.) -- A parameter may carry its own marginal prior. Joint priors over several - parameters (e.g. a multivariate normal over the optical-potential set) are - attached at the `Problem` level (§2.8). +`eq=False` keeps identity hashing: a parameter *is* its object, and it can +key a dict. A parameter may carry its own marginal prior. The rules, enforced +once at compile: -### 2.2 `Dataset` +| declared | prior used | +|---|---| +| `prior=dist` | `dist` truncated to `bounds` (log-density `-inf` outside; `ppf` rescaled between `cdf(lo)` and `cdf(hi)`) | +| finite `bounds`, no `prior` | uniform on `bounds` | +| neither | must be covered by a joint prior given to `Problem`, else a compile error naming the parameter | -Pure data, nothing else. +This replaces `IndependentPrior`, `TruncatedNormalPrior`, `as_prior` and the +list-of-scipy-distributions form with no classes at all. + +### 2.2 `transforms.py` + +Harvested from the current module minus `per_observation_scaling` and the +`contextual` flag. ```python +class Transform: + fn: Callable # fn(a, *values) -> array + params: tuple[Parameter, ...] + derivative: Callable | None # d fn / d a, elementwise; finite difference fallback + inverse: Transform | None # parameter-free transforms only + def __call__(self, a, *values) -> ndarray + def __or__(self, other) -> Transform # (f | g)(a) = g(f(a)); params f + g + +identity, log, exp # parameter-free singletons +def scale(parameter=None, log=True) -> Transform # rho * a; default Parameter("log_rho") +def as_transform(t) -> Transform # None -> identity; callable -> parameter-free Transform +``` + +One type, three roles: the comparison space of a `Comparison`, a mean transform +composed onto a `Model`, and the coordinates a `Term` is evaluated in. + +### 2.3 `units.py` and `data.py` + +```python +# units.py — the one pint registry and the unit contract +ureg = UnitRegistry() +XS_UNIT = ureg.barn / ureg.steradian # every cross section stored in b/sr +RUTHERFORD_UNIT = ureg.millibarn / ureg.steradian # what jitr reports +MB_PER_B = 1000.0 +DEFAULT_LMAX = 20 +def check_angle_grid(angles_rad, name) -> None +``` + +```python +# data.py @dataclass(frozen=True) class Dataset: - x: ndarray - y: ndarray - y_err: ndarray # statistical, physical units - meta: Mapping = field(default_factory=dict) - # meta holds: label, units, kinematics (reaction, Elab, ...), - # reported systematics (norm fraction, offset), provenance (subentry) + x: ndarray # angles in radians for reaction data + y: ndarray # physical units (b/sr, dimensionless, ...) + y_err: ndarray # statistical, physical units + norm_err: float | ndarray | None = None # reported fractional normalisation + offset_err: float | ndarray | None = None # reported absolute offset, physical units + label: str = "" + meta: Mapping = field(default_factory=dict) # kinematics: reaction, Elab, ExIAS, quantity, k, ... + +def from_measurement(measurement, *, reaction=None, quantity=None, ExIAS=None) -> Dataset ``` -- No comparison transform, no mask, no solver workspace, no identity key. -- `from_measurement` becomes a free function that reads an EXFOR-style - measurement, converts units once (one shared `UnitRegistry`), and returns a - `Dataset` with `meta` filled. The current `ElasticDifferentialXSObservation` - and `IsobaricAnalogPNObservation` classes disappear; what they store beyond - data moves into `meta`, and the solver they build moves into `bind` (§2.3). +`Dataset` is pure data. No comparison transform, no mask, no solver +workspace, no identity key. + +`from_measurement` is the single EXFOR adapter. It reads the +`exfor_tools.Distribution` fields (`x, y, Einc, quantity, y_units, +statistical_err, systematic_norm_err, systematic_offset_err, subentry`), +converts units once through `ureg`, divides every dimensionful error by the +conversion factor `norm`, passes the fractional normalisation error through +untouched, converts angles to radians, and fills `meta` with `reaction`, +`Elab`, `quantity`, `k` (and `ExIAS` for the (p,n) channel). The +`dXS/dA` ↔ `dXS/dRuth` conversions need the Rutherford cross section on +the data grid. In jitr that is a closed form of the kinematics, +`10 * eta**2 / (4 * k**2 * sin(theta/2)**4)` mb/sr +(`DifferentialWorkspace.rutherford_xs`), so `from_measurement` computes it +from `reaction.kinematics(Elab)` with no workspace. A per-angle `norm` +array is the result in those cases, exactly as today. -### 2.3 `Model` and `Predictor` +### 2.4 `model.py` -A model is a spec of "how to compute observables from parameters". A -predictor is that model **bound to a grid**. +A model is a spec of "observables from parameters". A predictor is that +model bound to a grid. ```python class Model: params: tuple[Parameter, ...] - def bind(self, grid_or_dataset) -> Predictor: ... + def __init__(self, fn, params): ... # fn(x, *values) -> y, physical space + def bind(self, x, meta=None) -> Predictor: ... # generic: closes over x + def __or__(self, transform) -> Model: ... # mean transform; its params appended + def __add__(self, other) -> Model: ... # additive mean discrepancy; params concatenated + def __mul__(self, other) -> Model: ... # multiplicative x-dependent correction; scale() is its constant case class Predictor: - params: tuple[Parameter, ...] # model params (+ transform params) - grid: ndarray - def __call__(self, *values) -> ndarray: ... # physical space, on grid - def __or__(self, transform) -> Predictor: ... # compose a mean transform + params: tuple[Parameter, ...] + x: ndarray + def __call__(self, *values) -> ndarray # physical space, on x + +def polynomial(order) -> Model # a_0 + a_1 x + ... ; params a0..an ``` -- `bind` is where expensive, grid-dependent state is built. For a plain - function model it closes over `x`. For a reaction model it builds the - jitr workspace from `dataset.meta["kinematics"]` and the grid, and caches - it keyed on `(reaction, Elab, lmax, grid)` so that two datasets at the same - energy solve the basis once. The model owns its solver; the data does not. -- Binding to a bare array gives the plotting predictor every notebook - currently hand-writes as `model.y(x, ...)`, and replaces - `visualization_workspace` / `visualizable_model_prediction`. -- A Kennedy–O'Hagan scale is a transform composed onto a predictor: - `model.bind(d) | scale(rho)`. Because a predictor is per block, per-dataset - scales are just distinct `rho_i` objects on distinct predictors. The - contextual transform, `_root`, and `per_observation_scaling`'s id table are - gone. -- The generic model is `Model(params, fn)` with `fn(grid, *values)`, matching - the "one class + callables" style of `Term` and `Transform`. Reaction - models subclass only to override `bind`. - -### 2.4 `Block` - -A block is the unit the residual is formed on: one dataset, one predictor, -one comparison space, one point mask. +- `Model.__or__` composes at the model level, so `omp | scale(rho_1)` is a + model whose parameters are `omp.params + (rho_1,)`; `bind` composes the + bound predictor with the transform. Per-dataset Kennedy–O'Hagan scales + are distinct `rho_i` objects on distinct comparisons. No routing table. +- `Model.__add__` is the explicit mean discrepancy: `omp + delta` with + `delta = Model(lambda x, *phi: ..., phi_params)` predicts + `omp(x) + delta(x)` in physical space, with parameters + `omp.params + delta.params` (a parameter object in both is shared, as + everywhere). `bind` binds both sides to the same grid and sums. This is + the Kennedy–O'Hagan *sampled* discrepancy, in contrast to `kernel`, which + marginalises it into the covariance; the two may be used together. A + reaction model and a plain-function model add without special cases + because addition happens on the bound predictors. Composition is + left-to-right: `(omp + delta) | scale(rho)` scales the sum, + `(omp | scale(rho)) + delta` scales only the model. +- `Model.__mul__` is the multiplicative counterpart: `omp * g` with + `g = Model(lambda x, *phi: ..., phi)` predicts `omp(x) · g(x)`. An + additive discrepancy in log space is exactly this, and `scale(rho)` is + the constant case `omp * Model(lambda x, r: np.exp(r), [rho])`, kept as + a helper. `+` and `*` share one binary-composition implementation; the + parametric use of `|` remains for non-separable transforms only. +- Plotting on a fine grid is `omp.bind(x_fine, d.meta)(*values)`. This + replaces `visualization_workspace` and `visualizable_model_prediction`. +- Reaction models subclass `Model` and override only `bind`. ```python -@dataclass(frozen=True) -class Block: - data: Dataset - predictor: Predictor - space: Transform = identity # parameter-free comparison transform - mask: ndarray | None = None # active points - - n: int; n_active: int - y: ndarray # space(data.y) - y_err: ndarray # |space'(data.y)| * data.y_err - log_jacobian: float - def predict(self, *values) -> ndarray # space(predictor(*values)) - def masked(self, mask) / masked_where(pred) -> Block # shares data+predictor - def reported_terms(self) -> list[Term] # from data.meta, delta-method propagated +# reactions/elastic.py +class ElasticXS(Model): + def __init__(self, quantity, central, spin_orbit, args_from_params, params, + coulomb=None, *, lmax=DEFAULT_LMAX, wavelengths_beyond_range=2.0, + zeros_per_node=5): ... + def bind(self, x, meta) -> Predictor + # reads meta["reaction"], meta["Elab"]; + # builds the jitr IntegralWorkspace + DifferentialWorkspace on x + # (set_up_solver, harvested); returns a Predictor that evaluates the + # potentials on ws.radial_grid(), solves, and extracts dXS/dA | dXS/dRuth | Ay + +def momentum_transfer(x, k) -> ndarray # q = 2 k sin(x/2), for coords= + +# reactions/ias.py +class IsobaricAnalogPN(Model): + def __init__(self, U_p_coulomb, U_p_central, U_p_spin_orbit, U_n_central, + U_n_spin_orbit, args_from_params, params, *, lmax=..., ...): ... + def bind(self, x, meta) -> Predictor # reads reaction, Elab, ExIAS ``` -- The comparison transform lives here, not on `Dataset`, because it is a - modelling choice (a Gaussian in log space is a different distribution from - a Gaussian in linear space, not merely a different covariance). Terms are - still authored in comparison space, exactly as today. -- `masked` returns a new `Block` sharing the dataset and predictor. No - `identity` attribute is needed: anything that wants "the same dataset" - compares `block.data`. - -### 2.5 `Term` +The model owns its solver; the data does not. A masked view, a copy, or an +unpickled problem cannot lose a workspace, because nothing routes on the +identity of a data object. The predictor is a pure function of the +potential: there is no `compound_correction` hook. A compound-elastic +contribution is subtracted from `data.y` as preprocessing (recipe 20), +which keeps the model free of data-side state and works on any grid. Optional, not in v0: cache the +`IntegralWorkspace` on the model instance keyed on +`(Elab, lmax, wavelengths_beyond_range, zeros_per_node)` so two datasets at +one energy solve the basis once. -Unchanged in spirit; changed in what it holds. +### 2.5 `terms.py` ```python +@dataclass(frozen=True) +class TermContext: + x: ndarray # coords(x) on the support + y: ndarray # data on the support, comparison space + ym: ndarray | None # prediction on the support; None while factoring constant parts + def __len__(self) -> int + def meta(self, key) -> ndarray # the owning block's data.meta[key], one value per point; + # for a term spanning blocks, the per-point concatenation + @dataclass(frozen=True) class Term: - fn: Callable | ndarray # fn(c, *values) -> vector or matrix + fn: Callable | ndarray # fn(c: TermContext, *values) -> vector | matrix params: tuple[Parameter, ...] = () kind: Literal["diag", "mode", "matrix"] = "matrix" - on: Block | Sequence[Block] | None = None # None = all blocks of the constraint - coords: Transform = identity - constant: bool = False + on: Comparison | Dataset | Sequence[Comparison | Dataset] | None = None # None = whole constraint + coords: Transform = identity # applied to x before fn sees it; its params appended + constant: bool = False # fn reads neither ym nor parameters ``` -- **Support is a block reference, not stacked integer indices.** `on=obs1` - places the term on that block, `on=[obs1, obs2]` spans both (case A), and - `on=None` means the whole constraint. Compile resolves these to indices. - `stacked_supports` and the `support=np.arange(...)` ceremony in the - notebooks disappear. -- A term holds no state. No `bind`, no `_x_cache`, no `_bound_N`. The - same term object can be placed in two constraints; each compile resolves it - independently. -- The factory helpers (`noise_term`, `normalization_term`, `kernel_term`, …) - keep their signatures with `support=` renamed `on=`. +| `kind` | `fn` returns | contribution | +|---|---|---| +| `"diag"` | standard-deviation vector `v` | `Σ_ii += v_i²` | +| `"mode"` | vector `v` | `Σ += v vᵀ` | +| `"matrix"` | symmetric block `M` | `Σ_block += M` | + +- **Support is a reference, not integer indices.** `on=b1` places the term + on that block, `on=[b1, b2]` spans both (case A), `on=None` is the whole + constraint. `on=` also accepts a block's `Dataset`, and compile resolves + `block is target or block.data is target`, so a term written against a + block still resolves after `masked`/`complement` rebuild the constraint. + `stacked_supports` and `support=np.arange(...)` are gone. +- **A term is stateless.** No `bind`, no cache. The same object may be + placed in two constraints. + +The factory helpers keep their bodies and signatures with `support=` renamed +`on=`: + +```python +statistical(y_err, on=None) +offset(magnitude=None, parameter=None, mask=None, log=True, on=None) +normalization(magnitude=None, parameter=None, mask=None, log=True, on=None) +noise(parameter, log=True, basis=None, basis_params=(), on=None, coords=None) +noise_fraction(parameter, log=True, on=None) +model_error(parameter, averaging=True, log=True, on=None) +systematic(parameter, basis, log=True, basis_params=(), on=None, coords=None) +kernel(kernel, coords=None, amplitude=None, amplitude_params=(), jitter=1e-10, + prefix="discrepancy", params=None, on=None) +# params=: the hyperparameter Parameter objects, one per free element in kernel.theta order; +# None derives fresh ones named f"{prefix}_{name}". Pass the same objects to share +# hyperparameters between per-block kernels. Two kernel terms with derived +# names and the same prefix fail compile on the duplicate name; the error says +# to pass prefix= (distinct kernels) or params= (one shared kernel). +# bases and amplitudes: ones, ym, averaging, x_basis(scale), exp_growth(scale, base=ones), +# constant_amplitude, exp_growth_amplitude(scale) +``` + +**Hierarchy is sharing plus `meta`.** A hyperparameter shared by several +datasets is one `Parameter` object placed in one term per block; anything +dataset-specific the term needs (energy, excitation energy, a flag) comes +from `c.meta(key)`. A discrepancy correlated *across* datasets, such as a +GP over energy and angle, is one `matrix` term spanning the blocks whose +`fn` builds its inputs from `c.meta("Elab")` and `c.x`. It takes the dense +path; there is no Kronecker structure because real data share no angle +grid. Recipes 22–24 spell all three out. + +### 2.6 `likelihood.py` + +Harvested. A likelihood is a functional of `(d2, logdet, n, *values)` with +optional parameters that are ordinary nodes in the index. + +```python +class Likelihood: + params: tuple[Parameter, ...] = () + def log_likelihood(self, d2, logdet, n, *values) -> float + def chi2(self, d2, logdet, n, *values) -> float # d2 + +class Gaussian(Likelihood): ... +class StudentT(Likelihood): # StudentT(nu=None) -> Parameter("nu", bounds=(1, inf)) + # two constraints with the default each derive a "nu"; + # compile fails on the duplicate name and says to pass nu= +class Chi2(Likelihood): ... # -0.5 d2, no log-determinant +``` -### 2.6 `Constraint` +### 2.7 `constraint.py` -A container of blocks and terms plus the likelihood functional and weight. +A block is the unit the residual is formed on: one dataset, one model, one +comparison space. A constraint is a tuple of comparisons plus the terms, +the likelihood functional, the tempering weight, and the active-point +masks. Each comparison is one block of the stacked covariance (§2.9), so +"block" below and in §2.9 means that. ```python +@dataclass(frozen=True) +class Comparison: + data: Dataset + model: Model # bound at construction: model.bind(data.x, data.meta) + space: Transform = identity # parameter-free comparison transform + # derived, computed once in __post_init__ / cached_property: + predictor: Predictor + y: ndarray # space(data.y) + y_err: ndarray # |space'(data.y)| * data.y_err (delta method) + log_jacobian_all: ndarray # log |space'(data.y)| per point + def reported_terms(self) -> list[Term] # offset then normalisation modes from data.norm_err / + # data.offset_err, delta-method propagated, on=self + @dataclass(frozen=True) class Constraint: - blocks: tuple[Block, ...] + comparisons: tuple[Comparison, ...] terms: tuple[Term, ...] = () likelihood: Likelihood = Gaussian() - weight: float = 1.0 - statistical: bool = True # add each block's y_err diagonal - def complement(self) -> Constraint + weight: float = 1.0 # tempering; multiplies the log-likelihood only + statistical: bool = True # add each block's y_err diagonal + masks: tuple[ndarray, ...] | None = None # active points per block; None = all active + def masked(self, masks) -> Constraint + def masked_where(self, predicate) -> Constraint # masks = [predicate(comp.data.x) for comp in comparisons] + def complement(self) -> Constraint # every inactive point active, and vice versa ``` -- Eager checks only on things that do not need the parameter graph: blocks - are distinct, every `on=` references a block in this constraint, an - array-valued term has the right shape. -- `weight` moves here from `Evidence(weights=)` and subsumes - `CalibrationConfig.likelihood_scaling`: one tempering knob, applied to the - likelihood only, honoured by every driver. +- The comparison transform lives on the block because it is a modelling + choice: a Gaussian in log space is a different distribution from one in + linear space. Terms are authored in comparison space, as today. +- **Masks live on the constraint, not on the block or the data.** + `masked`, `masked_where`, `complement` return a `Constraint` with the same + `Comparison`, `Term`, and `Parameter` objects and new masks. No `copy.copy`, + no identity key. A held-out problem built from `complement()` shares + every parameter with the fit, so a posterior sample scores it directly. +- `weight` subsumes both `Evidence(weights=)` and + `CalibrationConfig.likelihood_scaling`: one knob, honoured by every driver. +- Eager checks here need nothing from the parameter graph: comparisons are + distinct, an array-valued term has the right shape for its `on`, the + comparison space is finite on every active point (named block). + +### 2.7b How the pieces thread + +There are exactly two parametric entry points. Everything else is a +constant fixed when the comparison is built. + +| stage | space | what enters | parametric | +|---|---|---|---| +| 1. `Predictor` | physical | `f(x; θ)` on the data grid | model parameters | +| 2. mean modifications, composed on the `Model` | physical | `\| scale(ρ)`, `* g(x; φ)`, `+ δ(x; φ)` | ρ, φ | +| 3. `space` | physical → comparison | `y = space(data.y)`, `ym = space(step 2)`, `y_err = \|space'\| · data.y_err`, `log_jacobian` | none | +| 4. `Term`s, seeing `TermContext(x, y, ym)` | comparison | statistical diagonal; experimental terms (noise, reported modes, USU); model-discrepancy terms (kernel, EFT truncation) | term parameters, and `ym` | +| 5. `Likelihood` | comparison | functional of `y − ym` and Σ | Student-t ν only | + +Two rules follow. Experimental and model-discrepancy covariance terms +are one mechanism; the difference is what the user means, not what the +code does. A term that reads `ym` sees the prediction *after* the mean +modifications and *after* `space`, which is right: a reported +normalisation error applies to the measured scale, so its mode is +`η · ρ f`, and `Comparison.reported_terms()` gets that for free. And: +mean-side discrepancy is physical-space and `x`-aware; covariance-side +discrepancy is comparison-space and `ym`-aware; neither sees the other. +That is why the normalisation stays on the mean rather than dividing the +data: dividing the data would make `space` parametric, with a +ρ-dependent Jacobian and ρ-dependent error propagation, and in linear +space it is the data-side normalisation that Peelle's Pertinent Puzzle +warns about (recipe 27). + +### 2.8 `problem.py` — the compile step -### 2.7 `Evidence` - -A tuple of independent constraints. It no longer validates anything; it -exists so that "the calibration problem" has one name. (It could be a plain -list; keeping the class gives a place for the `compile` entry point.) +```python +class Problem: + def __init__(self, constraints, priors=()): # priors: [(params, joint), ...] + index: ParameterIndex # slot(p), slots(ps), names, bounds, ndim + constraints: tuple[CompiledConstraint, ...] + priors: tuple # the (params, joint) pairs as given; reuse for a held-out Problem + ndim: int + names: list[str] + bounds: ndarray # (ndim, 2) + + def log_prior(self, theta) -> float + def log_likelihood(self, theta) -> float # sum_c c.weight * c.log_likelihood(theta) + def log_posterior(self, theta) -> float # prior first; -inf short-circuits the forward model + def prior_transform(self, u) -> ndarray # unit cube -> theta (dynesty, bbb) + def sample_prior(self, n, rng=None) -> ndarray # (n, ndim) + def predict(self, theta, physical=False) -> list[list[ndarray]] # per constraint, per block + def chi2(self, theta) -> float + def log_jacobian(self) -> float # sum over constraints, active points + def columns(self, params) -> ndarray # chain columns of these parameters + + # black-box-bayes spellings of the same six things + NDIM, parameter_names, starting_location(n), log_posterior_batch(thetas) +``` -### 2.8 `Problem` — the compile step +`Problem.__init__` is the only place that walks the graph. It produces +`index`, the compiled constraints, and the assembled prior. Compile the +same declarations twice and you get two independent problems; nothing +user-facing is mutated. ```python -problem = Problem(evidence, priors=[(omp.params, mvn), (log_eps, halfnormal)]) +def compile(constraints, priors): + index = ParameterIndex() # ordered: Parameter -> slot, first seen + compiled = [] + for c in constraints: + y, y_err, offsets = stack(c.comparisons) # comparison space, one slice per comparison + active = concatenate(offsets[i][mask_i] for each block) + preds = [(offsets[i], index.add_all(b.predictor.params), b.predictor) for i, b in ...] + terms = ([statistical(comp.y_err, on=comp) for comp in c.comparisons] if c.statistical else []) + list(c.terms) + resolved = [(resolve(t.on, c.comparisons, offsets), index.add_all(t.params), t) for t in terms] + like_gather = index.add_all(c.likelihood.params) + cov = StructuredCovariance(resolved, offsets, active, blocks=c.comparisons) + cov.factor_constant_parts() # eager; names the block on failure + compiled.append(CompiledConstraint(...)) + index.check_names_unique() + prior = assemble_prior(index, priors) # every slot covered exactly once + return index, tuple(compiled), prior ``` -`Problem.__init__` is the only place in the package that walks the graph. -It produces: - -- `problem.index: ParameterIndex` — the unique `Parameter` objects in - first-seen order (blocks' predictors, then terms, then likelihoods, - constraint by constraint), each with a slot. `index.slot(p)`, - `index.slots(ps)`, `index.names`, `index.bounds`, `index.ndim`. Name - uniqueness is checked once, here. -- `problem.constraints: tuple[CompiledConstraint, ...]` (§3). -- `problem.prior` — assembled from per-parameter marginals and the joint - priors passed in; every slot must be covered exactly once, checked here. -- The flat interface external samplers want, which is what - `CalibrationConfig` exposes today: - `ndim`, `names`, `log_likelihood(theta)`, `log_prior(theta)`, - `log_posterior(theta)`, `prior_transform(u)`, `starting_location(n)`. -- `problem.groups` — named slot groups for Gibbs drivers: `"model"` (all - predictor slots) and one group per constraint's nuisance slots. Any other - partition is a list of slot arrays. -- `problem.predict(theta) -> list[ndarray]` per block, in comparison or - physical space. - -Nothing user-facing is mutated by compiling. Compile the same evidence twice -and you get two independent problems. - -### 2.9 Likelihood - -Unchanged. A `Likelihood` is a functional of `(d2, logdet, n, *values)` with -optional parameters (`StudentT.nu`). Those parameters are ordinary nodes in -the index like every other. - -## 3. The compiled constraint - -`CompiledConstraint` is what today's `Constraint` + `ConstraintCovariance` -are, minus the parameter splitting. +`index.add_all(params)` returns the gather array for a node, adding unseen +parameters in first-seen order (block predictors, then terms, then the +likelihood, constraint by constraint). That is the whole routing story. + +**Prior assembly.** Each slot is covered by its parameter's marginal +(§2.1) or by exactly one joint block from `priors`. A joint block is +`(params, joint)` where `joint` is any object with `logpdf(values)` over +those parameters in that order, optionally `prior_transform(u)` and +`rvs(n)`; `scipy.stats.multivariate_normal` qualifies. A hyperprior is a +joint block that *includes its hyperparameter*: the children carry no +marginal, the block's `logpdf` is `sum_i log p(child_i | hyper) + log p(hyper)`, +and its `prior_transform` draws the hyperparameter first (recipe 24). `log_prior` sums +marginal log-densities and joint `logpdf`s. `prior_transform` maps each +marginal slot through its rescaled `ppf`; a joint `scipy.stats.multivariate_normal` +block is whitened, `theta = mu + L Φ⁻¹(u)` with `L Lᵀ = cov`; any other joint +must expose `prior_transform(u)` or `Problem.prior_transform` raises a clear +error naming it. A parameter with finite `bounds` inside a joint block is +truncated in `log_prior` only (`-inf` outside the bounds); a truncated joint +has no unit-cube map, so `prior_transform` raises for that problem and names +the parameter. `sample_prior` draws marginals and joints and scatters them +into columns. + +**`CompiledConstraint`** is today's `Constraint` plus `ConstraintCovariance` +minus the parameter splitting: ```python class CompiledConstraint: - x, y, y_err: ndarray # stacked, comparison space - offsets: tuple[slice, ...] # one per block - active: ndarray # stacked indices of active points + y, y_err, x: ndarray # stacked, comparison space, all points + offsets: tuple[slice, ...] + active: ndarray predictors: list[(slice, gather, Predictor)] covariance: StructuredCovariance likelihood: Likelihood; like_gather: ndarray weight: float - - def ym(self, theta) -> ndarray # memoised on theta[predictor slots] + log_jacobian: float + def ym(self, theta) -> ndarray def log_likelihood(self, theta) -> float - def matrix(self, theta) -> ndarray # dense, for display only + def chi2(self, theta) -> float + def matrix(self, theta) -> ndarray # dense, active rows; display and tests ``` -Two things are worth spelling out. - -**Gather, never split.** Every callable node received a gather array at -compile time. Evaluation is `node(*theta[gather])`. The ten positional -splits in the current code (`PhysicalModel.split_params`, -`Constraint._split`, the term's fn/coords split, `_scaled_term`'s -coefficient/basis split, `kernel_term`'s kernel/amplitude split, -`Transform.__or__`, `CalibrationConfig.split_parameters` and its -`prior_transform` cursor, `model_comparison.split_samples`, and -`predictive.total_predictive_band`'s `n_model_params`) all become reads of -`problem.index`. Composite nodes (`f | g`, coefficient times basis) still -concatenate their children's parameters, but they do so once at construction -and the compile step assigns one gather for the composite. - -**Memoised forward model.** `ym(theta)` caches the last prediction keyed on -the values of the predictor slots. A Gibbs sweep over the nuisance group -changes no predictor slot, so it never re-solves the reaction model. This one -mechanism replaces `Constraint.marginal_log_likelihood`, -`Constraint.predict`-then-closure in `Walker.run_likelihood_batches`, -`Evidence.weighted_marginal_log_likelihood`, `CalibrationConfig.predict_parametric` -and `CalibrationConfig.conditional_posterior`. - -## 4. The structured covariance - -This is the one change that is a dramatic simplification *and* a speed-up, -and it needs no API change. +### 2.9 `covariance.py` — the structured covariance The three term kinds already describe a decomposition: ``` -Sigma = D + sum_b M_b + U U^T (+ dense fallback) +Σ = diag(D) + blockdiag(M_b) + U Uᵀ (+ dense fallback) ``` -- `D` is a length-`N` vector: the sum of squares of every `"diag"` term. -- `M_b` is one dense block per observation block: the sum of `"matrix"` terms - whose support lies inside block `b`. -- `U` is `N x r`: one column per `"mode"` term, the mode vector scattered onto - its support and zero elsewhere. A mode spanning several blocks (case A) is - just a column with entries in several blocks. -- A `"matrix"` term that crosses block boundaries (a GP kernel over the union - of two datasets) forces the dense path for that constraint. Everything - else stays structured. +- `D`: length-`N` vector, the sum of squares of every `"diag"` term. +- `M_b`: one dense block per observation block, the sum of `"matrix"` + terms whose support lies inside block `b`. +- `U`: `N × r`, one column per `"mode"` term, scattered onto its support + and zero elsewhere. A mode spanning several blocks (case A) is a column + with entries in several blocks. +- A `"matrix"` term that crosses block boundaries (a GP kernel over the + union of two datasets) forces the dense path for that constraint. With `B = blockdiag(M_b + diag(D_b))` and per-block Cholesky `L_b`: ``` -z = L^{-1} r (block by block) -W = L^{-1} U (block by block, N x r) -S = I_r + W^T W (r x r) -d2 = z^T z - (W^T z)^T S^{-1} (W^T z) -logdet Sigma = sum_b logdet B_b + logdet S +z = L⁻¹ r (block by block) +W = L⁻¹ U (block by block, N × r) +S = I_r + Wᵀ W (r × r) +d2 = zᵀz − (Wᵀz)ᵀ S⁻¹ (Wᵀz) +logdet Σ = Σ_b logdet B_b + logdet S ``` -Cost is `O(sum_b n_b^3 + N r^2 + r^3)` instead of `O(N^3)`. For the -motivating cases (two or three datasets sharing a normalisation mode, -`r = 1`) the cross-block coupling is essentially free. - -Consequences: - -- **All three "known limitations" in `design.md` go away.** There is no - dense `N x N` assembly for non-constant block-diagonal covariances, the - low-rank path exists, and masking is slicing rows out of `D`, `U`, and - `M_b` rather than assembling and then restricting. -- **The block path is the only path.** `uses_block_path`, `block_diagonal`, - `cholesky` versus `block_cholesky`, and the dispatch in `stacked_distance` - collapse into one routine. -- **Constant pieces are still cached.** Each of `D`, `U`, `M_b` is the sum of - a constant part (evaluated once) and a parametric part. When everything is - constant the factors are cached exactly as now. -- **Constraint boundaries carry less weight.** Today a constraint is the - unit of dense factorisation, so the design must forbid sharing across - constraints and push cross-dataset systematics into one constraint. With - Woodbury the cost of a coupling mode is independent of `N`, so the choice - of where to draw constraint boundaries becomes about the likelihood - functional and the weight, not about cost. -- `B` must be positive definite. A block covered by modes alone (no - statistical diagonal, no noise term) is singular in `B` even if `Sigma` is - not. Compile catches this as today's eager singular check does, and the - remedy list is the same; a dense fallback for that constraint is the - escape hatch. - -## 5. Drivers - -### 5.1 External samplers - -`Problem` *is* the interface `black-box-bayes`, `emcee`, and `dynesty` want. -`CalibrationConfig` and `ParameterConfig` are not needed. The prior list -form, `IndependentPrior`, and `TruncatedNormalPrior` collapse into -"a `Parameter` carries a marginal, or a group of parameters carries a joint". - -### 5.2 In-package Gibbs +Cost `O(Σ_b n_b³ + N r² + r³)` instead of `O(N³)`. Consequences: + +- All three "known limitations" of `design.md` are gone: no dense assembly + for block-diagonal covariances, a low-rank path exists, and masking is + slicing rows out of `D`, `U`, and `M_b` before assembly. +- The block path is the only path. `uses_block_path`, `block_diagonal`, + `cholesky` versus `block_cholesky`, and the dispatch in + `stacked_distance` do not exist. +- Each of `D`, `U`, `M_b` is a constant part (evaluated once at compile) + plus a parametric part. When everything is constant the factors are + cached. +- A constraint boundary is now about the likelihood functional and the + weight, not about cost: a coupling mode across blocks is essentially free. +- `B` must be positive definite. A block covered only by modes is singular + in `B` even when `Σ` is not; compile reports it with the comparison's label + and the remedies (reported terms, a noise term, `statistical=True`). ```python -walker = Walker(problem, groups=problem.groups, samplers={...}, rng=rng) -walker.walk(n_steps, burnin, batch_size) -walker.chain # (n, ndim), columns named by problem.index.names +class StructuredCovariance: + def __init__(self, resolved_terms, offsets, active, blocks): ... + def factor_constant_parts(self) -> None + def distance(self, y, ym, theta) -> tuple[float, float] # (d2, logdet) on active rows + def matrix(self, y, ym, theta) -> ndarray # dense, active rows ``` -- A sector is a slot group. The walker alternates over groups, holding the - others fixed, calling `problem.log_posterior` each time. The forward-model - memo makes the nuisance sweeps cheap without special methods. -- There is one chain. The two-sector `model_sampler.chain` / - `likelihood_samplers[i].chain` and the `np.hstack` in every notebook go - away, as does the duplicated validation between `Walker` and - `CalibrationConfig`. +### 2.10 `diagnostics.py` and `predictive.py` -### 5.3 Model comparison and prediction +Harvested statistics with the entry points retargeted to `(problem, +samples)`, where `samples` has shape `(n, ndim)` in `problem.index` order. +That is what emcee's `get_chain(flat=True)`, dynesty's `samples_equal()`, +and bbb's `InferenceData["theta"]` all give. Column selection goes through +`problem.columns(...)`; `split_samples`, `n_model_params`, `theta_cols` are +gone. -`model_comparison` and `predictive` take `(problem, chain)` and select -columns through `problem.index`. `split_samples` is not needed; -`total_predictive_band` gets its kernel columns from -`index.slots(term.params)` instead of a caller-supplied integer. -`Constraint.complement()` works on blocks exactly as it does on observations -today, and the held-out problem shares `Parameter` objects with the fit, so a -posterior sample scores it directly. +```python +# diagnostics.py +predictive_draws(problem, samples, constraint=0, *, n_rep=1, rng=None, model_only=False) +coverage_curve(draws, y, levels=None); coverage_error(draws, y, levels=None) +sharpness(draws, percentiles=(16, 84), transform=None) +heldout_log_predictive(heldout_problem, samples) # Problem([fit.complement()], priors=...) +log_posterior_predictive(logp_samples, logw=None) +logz_summary(logz, logzerr); compare_logz(a, b, sigma=2.0) + +# predictive.py +gp_posterior_predictive(kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10) +predictive_band(draws, levels=(16, 50, 84)) +total_predictive_band(problem, term, predictor, x_pred, samples, *, noise_std=0.0, + train_noise_var=None, levels=(16, 84), n_draws=400, rng=None) +# term is the kernel Term; its columns and the predictor's come from problem.columns +``` -## 6. Worked example +## 3. Worked example: the α+Ca study shape -The α+Ca study shape: two datasets without reported errors, compared in log -space, a noise level shared between them (case B), a normalisation mode -coupling them (case A), one latent scale per dataset, one held out below a -cut, nested sampling. +Two datasets without reported errors, compared in log space, one noise +magnitude shared between them (case B), one normalisation mode coupling them +(case A), one latent scale per dataset, one held out below an angular cut, +nested sampling, then held-out scoring. ```python -import numpy as np, rxmc as rx +import numpy as np, dynesty, rxmc as rx from rxmc import terms as T, transforms as tf +from scipy import stats -d1 = rx.from_measurement(m1) # Dataset, meta filled, units converted -d2 = rx.from_measurement(m2) +d1 = rx.from_measurement(m1, reaction=reaction, quantity="dXS/dA") +d2 = rx.from_measurement(m2, reaction=reaction, quantity="dXS/dA") -omp = MyOpticalModel(params=[...]) # Model; bind() builds jitr workspaces -rho1, rho2 = rx.Parameter("log_rho_1"), rx.Parameter("log_rho_2") -b1 = rx.Block(d1, omp.bind(d1) | tf.scale(rho1), space=tf.log) -b2 = rx.Block(d2, omp.bind(d2) | tf.scale(rho2), space=tf.log) +omp = rx.reactions.ElasticXS("dXS/dA", central, spin_orbit, args_from_params, params=omp_params) +rho1 = rx.Parameter("log_rho_1", prior=stats.norm(0, 0.1)) +rho2 = rx.Parameter("log_rho_2", prior=stats.norm(0, 0.1)) +comp1 = rx.Comparison(d1, omp | tf.scale(rho1), space=tf.log) +comp2 = rx.Comparison(d2, omp | tf.scale(rho2), space=tf.log) -log_eps = rx.Parameter("log_eps", prior=halfnormal) -log_eta = rx.Parameter("log_eta", prior=halfnormal) +log_eps = rx.Parameter("log_eps", prior=stats.norm(-2, 1)) +log_eta = rx.Parameter("log_eta", prior=stats.norm(-2, 1)) c = rx.Constraint( - blocks=[b1, b2], + comparisons=[comp1, comp2], terms=[ - T.noise(log_eps, on=b1), # case B: one magnitude, two blocks - T.noise(log_eps, on=b2), - T.normalization(log_eta, on=[b1, b2]), # case A: one mode across both + T.noise(log_eps, on=comp1), # case B: one magnitude, two comparisons + T.noise(log_eps, on=comp2), + T.normalization(log_eta, on=[comp1, comp2]), # case A: one mode across both ], likelihood=rx.StudentT(), + statistical=False, # no reported errors: the noise term is the diagonal ) -fit = c.masked_where(lambda x: x < cut) +fit = c.masked_where(lambda x: x < cut) held = fit.complement() -problem = rx.Problem([fit], priors=[(omp.params, mvn_prior)]) +problem = rx.Problem([fit], priors=[(omp.params, stats.multivariate_normal(mu, cov))]) sampler = dynesty.NestedSampler(problem.log_likelihood, problem.prior_transform, problem.ndim) -... -heldout = rx.Problem([held], priors=problem.prior) # same Parameter objects -lp = rx.model_comparison.heldout_log_predictive(heldout, chain) +sampler.run_nested() +res = sampler.results +samples = res.samples_equal() + +heldout = rx.Problem([held], priors=problem.priors) # same Parameter objects +lp = rx.diagnostics.heldout_log_predictive(heldout, samples) +score = rx.diagnostics.log_posterior_predictive(lp) +logz = rx.diagnostics.logz_summary(res.logz[-1], res.logzerr[-1]) +# to compare with a linear-space fit of the same data: logz_raw = logz + problem.log_jacobian() ``` -Compare with the current version of the same study: `Observation(..., -transform=log)` per dataset, `stacked_supports` to place the terms, -`per_observation_scaling([obs1, obs2])` on the model with `obs` passed to -three places, `Constraint(...)`, `Evidence([...])`, `ParameterConfig` twice, -`CalibrationConfig`, and `split_samples` to read the chain back. +The same problem under emcee: + +```python +import emcee +p0 = problem.sample_prior(32, rng=np.random.default_rng(1)) +sampler = emcee.EnsembleSampler(32, problem.ndim, problem.log_posterior) +sampler.run_mcmc(p0, 5000) +samples = sampler.get_chain(discard=1000, thin=10, flat=True) +band = rx.predictive.predictive_band( + [omp.bind(x_fine, d1.meta)(*s[problem.columns(omp.params)]) for s in samples[::20]] +) +``` -## 7. Compile, in pseudo-code +And under `black-box-bayes`, which needs a pickle and a six-line module: ```python -def compile(evidence, priors): - index = ParameterIndex() # ordered dict Parameter -> slot - compiled = [] - for c in evidence: - offsets, x, y, err = stack(c.blocks) # comparison space - active = concatenate(offset[b.mask] for each block) - preds = [(offsets[i], index.add_all(b.predictor.params), b.predictor) - for i, b in enumerate(c.blocks)] - terms = list(c.terms) - if c.statistical: - terms = [T.statistical(b.y_err, on=b) for b in c.blocks] + terms - resolved = [(resolve(t.on, c.blocks, offsets), index.add_all(t.params), t) - for t in terms] - like_gather = index.add_all(c.likelihood.params) - cov = StructuredCovariance(resolved, N=len(y), offsets, active) - cov.factor_constant_parts() # eager; names the block on failure - compiled.append(CompiledConstraint(...)) - index.check_names_unique() - prior = assemble_prior(index, priors) # every slot covered exactly once - return Problem(index, compiled, prior) +# make_problem.py +import dill +with open("problem.pkl", "wb") as f: + dill.dump(problem, f) + +# posterior.py +import dill +def init_posterior(path): + global P, NDIM, parameter_names + P = dill.load(open(path, "rb")); NDIM = P.ndim; parameter_names = P.names +def starting_location(n): return P.sample_prior(n) +def log_posterior(theta): return P.log_posterior(theta) +def log_likelihood(theta): return P.log_likelihood(theta) +def prior_transform(u): return P.prior_transform(u) ``` -`index.add_all(params)` returns the gather array for that node, adding new -parameters in first-seen order. That is the whole routing story. +Compare with the current spelling of the same study: `Observation(..., +transform=log)` per dataset, `stacked_supports` to place the terms, +`per_observation_scaling([obs1, obs2])` with `obs` passed to three places, +`Constraint(...)`, `Evidence([...])`, `ParameterConfig` twice with a +`TruncatedNormalPrior` because the MVN prior has no unit-cube map, +`CalibrationConfig`, and `split_samples` to read the chain back. -## 8. Mapping from the current code +## 4. Capability map -| today | ground-up | note | +Every statistical capability a current notebook or test demonstrates, and +its spelling in the new API. This table is the acceptance list for the +rewrite: a capability is done when its row has a test. + +| capability (where it is demonstrated today) | new spelling | pinned by | +|---|---|---| +| user-defined model `y = m x + b` (linear_calibration_demo) | `Model(lambda x, m, b: m*x + b, [m, b])` | test_model | +| `Polynomial(order)` (normalization_inference) | `polynomial(order)` | test_model | +| statistical diagonal only; `chi2 / n` (linear_calibration_demo) | default `Constraint`; `problem.chi2(theta)` | test_problem | +| unknown fractional / constant noise (systematic_err_demo, sampling_algos) | `noise_fraction(log_eps)`, `noise(log_eps)` | test_terms::TestFactories | +| inferred noise *replacing* reported statistics (prose today) | `Constraint(statistical=False, terms=[noise(...)])` | test_constraint | +| reported normalisation / offset as fixed modes (measurement_to_calibration) | `block.reported_terms()`; `normalization(magnitude=)`, `offset(magnitude=)` | test_constraint::reported_terms, regression number | +| free normalisation / offset nuisance (systematic_err_demo) | `normalization(parameter=log_eta)`, `offset(parameter=log_omega)` | test_terms | +| fixed dense covariance; fixed diagonal (systematic_err_demo, normalization_inference gallery) | `Term(C, on=b)`, `Term(sig, kind="diag", on=b)` | test_terms::TestTermKinds | +| case B: one parameter, two block-local terms (systematic_err_demo, correlated_observations) | `noise_fraction(log_eps, on=b1), noise_fraction(log_eps, on=b2)`; or two constraints sharing `log_eps` | test_problem::sharing | +| case A: one mode across blocks (correlated_observations) | `normalization(log_eta, on=[b1, b2])` | test_covariance::case_a, regression | +| per-dataset Kennedy–O'Hagan scale ρᵢ (normalization_inference) | `Comparison(d_i, omp \| scale(rho_i))` | test_model, test_constraint | +| single global ρ (test only) | `omp \| scale(rho)` on every block | test_model | +| sampled mean discrepancy `y = f(x; θ) + δ(x; φ)` (new) | `omp + Model(delta_fn, phi)`; alone or alongside `kernel` | test_model (params order, shared parameter, `\|` precedence) | +| multiplicative `x`-dependent correction, i.e. an additive discrepancy in log space (new) | `omp * Model(g_fn, phi)`; `scale(rho)` is the constant case | test_model (`omp * const(rho)` equals `omp \| scale(rho)`) | +| hyperparameters shared across datasets, per-dataset values from `meta` (new) | one term per block with the same `Parameter` objects; `c.meta("Elab")`; `kernel(params=)` | test_terms (`meta` on one block and on a union), test_problem (one slot per shared object) | +| discrepancy correlated across energies: GP over (E, θ) (new) | one `matrix` `Term` with `on=comps` building inputs from `c.meta` and `c.x`; dense path | test_covariance (dense fallback equals hand-built product kernel) | +| unaccounted-for model error per data type, KDUQ (new, reference) | `model_error(delta_T, averaging=True, on=b)` with one `delta_T` per type; the `k/N` democratic and per-type federal scalings are `Constraint(weight=)`; recipe 26 | test_terms (shared object gives one column per type) | +| Peelle's Pertinent Puzzle avoidance (new, reference) | `normalization()` reads `c.ym`; the `t0` variant as a constant `mode`; recipe 27 | test_terms (data-built mode reproduces the `1/(1+n s²)` bias; prediction-built does not) | +| EFT truncation-error GP with known convergence pattern, BUQEYE (new, reference) | `matrix` `Term` from `c.meta("y_ref")`, `c.meta("Q")`, `c.x`; rank-one form via `systematic`; recipe 28 | test_covariance (dense equals the closed-form covariance) | +| Bayesian model averaging / mixing, domain correction (new, reference) | one `Problem` per model, `logz_summary`, mixed `predictive_draws`; mean mixing as a `Model`; recipe 29 | test_diagnostics | +| stacking by leave-one-dataset-out (new, reference) | `Constraint.masked` dropping a block, `heldout_log_predictive`; recipe 30 | test_diagnostics | +| cut / modular posterior by multiple imputation (new, reference) | stage-1 `Problem`, per-draw stage-2 `Problem` with the module fixed by closure; per-module `weight`; recipe 31 | test_problem (stage-1 marginal unchanged) | +| leave-one-experiment-out prediction (new, reference) | block masks, `complement`, `predictive_draws`, `coverage_curve`; recipe 32 | test_diagnostics | +| posterior predictive check with realised discrepancy (new, reference) | `problem.chi2` at each draw vs replicated data; recipe 33 | test_diagnostics | +| prior / likelihood power-scaling sensitivity (new, reference) | importance weights from `log_prior`, `log_likelihood` on existing samples; recipe 34 | test_problem (`log_prior` on samples) | +| simulation-based calibration of the sampler (new, reference) | `sample_prior`, `predictive_draws`, `dataclasses.replace(d, y=)`; recipe 35 | test_problem (rank uniformity on the linear problem) | +| emulator as `Model`, emulator variance as a `diag` term sharing the model's parameters (new, reference) | recipe 36 | test_terms (a term declaring model parameters receives them) | +| MAP + Laplace (new, reference) | `scipy.optimize` on `log_posterior`, `problem.bounds`; recipe 37 | test_problem | +| global error scale and USU modes (new, reference) | `diag` term scaling `c.meta("y_err")` with `statistical=False`; `offset(parameter=, on=blocks_of_technique)`; recipe 38 | test_terms | +| energy-dependent parameters (new, reference) | per-block `Model` instances closing over `meta`, shared coefficient objects; recipe 39 | test_model | +| discrepancy on a physical basis, Legendre (new, reference) | `systematic` modes or `omp + Model(basis_sum)`; recipe 40 | test_terms | +| correlated systematics between observables of one measurement (new, reference) | two blocks, one constraint, spanning mode; recipe 41 | test_covariance | +| classic normal hierarchical model, BDA3 ch. 5 (new, reference) | marginalised as `noise(log_tau)`, non-centred as a `Model` over `[mu, log_tau, *etas]`, centred as a joint block; recipe 42 | test_problem (marginalised and non-centred agree on `mu, tau`; a parameter on a fully masked block is sampled from its prior) | +| SafeBayes: learn the tempering exponent (new, reference) | driver loop over `replace(c, weight=η)` and `c.masked(prefix)`; next-point density as a log-likelihood difference; recipe 25 | test_problem (`replace` keeps names; `ll(prefix i+1) − ll(prefix i)` equals the Gaussian conditional) | +| hyperprior: per-dataset parameters with a sampled spread (new) | joint block `(children + [hyper], obj)` with `logpdf` and `prior_transform` | test_problem (children uncovered without the block; `prior_transform` round trip) | +| GP discrepancy in x / in momentum transfer with amplitude (gp_discrepancy, TestStudyForms) | `kernel(k, on=b, coords=lambda x: momentum_transfer(x, k), amplitude=..., amplitude_params=...)` | test_terms::TestStudyForms | +| angle-growing noise, mode ∝ θ, `exp_growth`, `x_basis` (TestStudyForms) | same helpers with `on=` | test_terms::TestStudyForms | +| direct two-parameter `Term` escape hatch (TestStudyForms) | `Term(lambda c, e, l: ..., (e, l), kind="diag")` | test_terms | +| Student-t with bounded ν; `Chi2` (robust_likelihoods) | `StudentT(nu=Parameter("nu", bounds=(1, 100)))`; `Chi2()` | test_likelihood closed forms | +| log-space comparison, delta-method errors, `log_jacobian` (tests) | `Comparison(d, m, space=log)`; `problem.log_jacobian()` | test_constraint::TestComparisonSpace | +| masks, `masked_where`, `complement`, held-out scoring (tests) | `Constraint.masked_where`, `.complement()`; `heldout_log_predictive` | test_constraint::TestMask (partition, `ll(fit)+ll(held)==ll(full)`) | +| tempering, two spellings (overconfidence) | `Constraint(weight=)` only | test_problem | +| joint MVN prior over the optical set (most notebooks) | `Problem(..., priors=[(omp.params, mvn)])` | test_problem::priors | +| truncated-normal / bounded independent priors (calibration_config_emcee_dynesty) | `Parameter(prior=stats.norm(...), bounds=(lo, hi))` | test_problem::priors | +| nested-sampling `prior_transform`, now including joint MVN | `problem.prior_transform` | test_problem (round trip, finite at 0 and 1) | +| emcee, dynesty, black-box-bayes drivers | flat interface on `Problem`; dill round trip | test_problem::drivers | +| EXFOR → dataset with unit conversion; per-angle Rutherford `norm` (measurement_to_calibration, tests) | `from_measurement(m, reaction=, quantity=)` | test_data (both conversion directions) | +| elastic `dXS/dA`, `dXS/dRuth`, `Ay` | `ElasticXS(quantity, ...)`; a compound-elastic contribution is subtracted from the data as preprocessing | test_reactions | +| (p,n) IAS channel (tests) | `IsobaricAnalogPN(...)` | test_reactions (Lane term) | +| solver settings reach jitr | `ElasticXS(..., lmax=, wavelengths_beyond_range=, zeros_per_node=)` | test_reactions | +| singular-covariance guard naming the dataset (measurement_to_calibration) | compile-time in `Problem` | test_problem | +| duplicate-name / same-object validation | `ParameterIndex.check_names_unique`; sharing across constraints is legal | test_problem | +| covariance heat-maps (normalization_inference, correlated_observations) | `problem.constraints[i].matrix(theta)` | test_covariance dense equality | +| predictive draws, coverage, sharpness, evidence bookkeeping (tests) | `diagnostics.*` | test_diagnostics | +| GP conditioning; total predictive band (gp_discrepancy) | `predictive.*` | test_predictive vs sklearn | +| fine-grid plotting (every reaction notebook) | `omp.bind(x_fine, d.meta)(*s[problem.columns(omp.params)])` | test_model | + +Four rows are new rather than ported. The sampled mean discrepancy: today a +model-side correction that depends on `x` cannot be written, because the +model transform sees only the prediction. The three hierarchical rows: +today a term cannot read its dataset's metadata, `kernel_term` cannot share +hyperparameters between calls, and a prior cannot depend on a sampled +hyperparameter. + +**Dropped, deliberately:** `Walker`, `MetropolisHastingsSampler`, +`AdaptiveMetropolisSampler`, `BatchedAdaptiveMetropolisSampler`, `proposal`, +`marginal_log_likelihood`, `conditional_posterior`, `predict_parametric`, +`weighted_marginal_log_likelihood`, `CalibrationConfig`, `ParameterConfig`, +`Evidence`, `per_observation_scaling`, `identity` keys, `stacked_supports`, +`split_samples`, `likelihood_scaling`, `IndependentPrior`, +`TruncatedNormalPrior`, the two `Observation` subclasses, `n_dof`. + +## 5. Harvest table + +What comes across from `src/rxmc` on `api_generalisation`, by file. + +### Lift verbatim (about 1,100 lines) + +| current file | pieces | destination | |---|---|---| -| `Parameter` (`__eq__`, no hash) | `Parameter` (identity, hashable, optional prior) | one identity notion | -| `Observation` | `Dataset` + `Block` | data vs. modelling choices | -| `ElasticDifferentialXSObservation`, `IsobaricAnalogPNObservation` | `from_measurement` → `Dataset`; solver in `Model.bind` | classes removed | -| `PhysicalModel(params, transform)` | `Model.bind(grid) -> Predictor`; `predictor \| transform` | per-block mean transforms | -| `per_observation_scaling`, `_root`, `identity` | `omp.bind(d_i) \| scale(rho_i)` | no routing table | -| `Term(support=indices)` + `bind` + caches | `Term(on=blocks)`, stateless | resolved at compile | -| `stacked_supports` | not needed | | -| `Constraint.__init__` + `ConstraintCovariance` | `Constraint` (spec) + `CompiledConstraint` | | -| `ConstraintCovariance.matrix/cholesky/block_cholesky/stacked_distance` | `StructuredCovariance` | Woodbury, one path | -| `Evidence(weights=)` + `likelihood_scaling` | `Constraint.weight` | one knob | -| `Evidence._validate_constraint_params`, `Constraint._validate_parameter_names` | `ParameterIndex.check_names_unique` | once | -| `ParameterConfig`, `CalibrationConfig` | `Problem` | | -| `IndependentPrior`, `TruncatedNormalPrior`, list priors | `Parameter.prior` + joint priors on `Problem` | | -| `Walker(model_sampler, likelihood_samplers)` | `Walker(problem, groups)` | one chain | -| `marginal_log_likelihood`, `predict_parametric`, `conditional_posterior`, `weighted_marginal_log_likelihood` | `CompiledConstraint.ym` memo | | -| `split_samples`, `n_model_params`, `theta_cols` | `problem.index.slots(...)` | | - -## 9. What stays the same - -- The hierarchy: evidence → constraint → block → point. -- `Term` with `kind in {"diag", "mode", "matrix"}`, the factory helpers, bases - and amplitudes as callables of a local context. -- `Transform` as one type with derivative, inverse, and `|` composition, - serving comparison space, mean transforms, and term coordinates. -- Terms authored in comparison space; delta-method propagation of reported - errors; `log_jacobian` for cross-space evidence comparison. -- Likelihood as a functional of `(d2, logdet, n)`; `Gaussian`, `StudentT`, - `Chi2`. -- Masks as part of support; `complement()` sharing parameters with the fit. -- Fail fast on singular constant covariances with a named dataset. -- Tempering applies to the likelihood only. - -## 10. Incremental path - -None of this requires a rewrite. In order of payoff per unit of risk: - -1. **`StructuredCovariance` inside `ConstraintCovariance`.** Replace the - internals of `matrix`, `cholesky`, `block_cholesky`, and - `stacked_distance`; keep `matrix()` as the dense view. No public API - change. The existing dense-versus-block equivalence tests are the - acceptance tests. This alone removes every "known limitation". -2. **Make `Parameter` hashable** (drop `__eq__` or add `__hash__`). -3. **`support=` accepts observation objects** and is resolved in - `Constraint`. Keep integer supports working. -4. **`ParameterIndex` built by `Evidence`**, exposing - `log_likelihood(theta_flat)` alongside the nested form. Point - `CalibrationConfig.split_parameters`, `model_comparison.split_samples`, - `predictive`, and `Walker`'s validation at it. Lift the cross-constraint - sharing ban. This is the step that unifies the two drivers and fixes the - inconsistencies in `bugs_found.md` §5–7. -5. **`Problem`** as the single compile entry point; `CalibrationConfig` - becomes a thin alias, `Walker` takes a `Problem` and slot groups, one - chain. -6. **Bind-time predictors.** Move workspaces off the reaction observations - into `Model.bind`, fold the two observation subclasses into - `from_measurement`. Do this after the α+Ca study lands, since it - touches the classes that study uses. - -Steps 1–3 are local and safe. Step 4 is the structural one. Steps 5–6 are -cleanup that the earlier steps make small. - -## 11. Open questions - -- **Joint priors and `prior_transform`.** Nested sampling needs a - unit-cube map. Independent marginals have one; a multivariate normal - needs a whitening transform. Same situation as today; `Problem` should - reject `prior_transform` for joints without a `ppf`-like method rather - than guess. +| `transforms.py` | `Transform` (minus `contextual`, `_unpack`), `as_transform`, `identity`, `log`, `exp`, `_safe_log`, `_reciprocal`, `scale` | `transforms.py` | +| `likelihood_model.py` | `Likelihood`, `GaussianLikelihood`→`Gaussian`, `StudentT`, `Chi2`, `log_likelihood` | `likelihood.py` | +| `covariance.py` | `TermContext`, `chol_logdet`, `as_2d`, bases `ones`, `ym`, `averaging`, `x_basis`, `exp_growth`, `constant_amplitude`, `exp_growth_amplitude`; helpers `_masked`, `_full`, `_coefficient`, `_scaled_term`, `_kernel_params`; factories `statistical_term`, `offset_term`, `normalization_term`, `noise_term`, `noise_fraction_term`, `model_error_term`, `systematic_term`, `kernel_term` (drop the `_term` suffix, `support=`→`on=`) | `terms.py` | +| `observation_from_measurement.py` | `ureg`, `XS_UNIT`, `RUTHERFORD_UNIT`, `MB_PER_B`, `DEFAULT_LMAX`, `check_angle_grid`, `measurement_kwargs` | `units.py`, `data.py` | +| `elastic_diffxs_observation.py` | `set_up_solver`, the `calculate_normalization` conversion table, `momentum_transfer` | `reactions/elastic.py`, `data.py` | +| `ias_pn_observation.py` | `set_up_solver` | `reactions/ias.py` | +| `elastic_diffxs_model.py` | `_xs` body, `extract_dXS_dA`, `extract_dXS_dRuth`, `extract_Ay` | `reactions/elastic.py` | +| `ias_pn_model.py` | `_xs` body | `reactions/ias.py` | +| `predictive.py` | `gp_posterior_predictive`, `_gp_condition`, `_gp_posterior_mean_var`, `_train_noise_matrix`, `predictive_band` | `predictive.py` | +| `model_comparison.py` | `_psd_factor`, `_rows`, `coverage_curve`, `coverage_error`, `sharpness`, `log_posterior_predictive`, `logz_summary`, `compare_logz` | `diagnostics.py` | +| `priors.py` | `clip_unit_cube` | `problem.py` | + +### Lift with edits + +| current | change | +|---|---| +| `Observation.systematic_terms` | → `Comparison.reported_terms`; same delta-method logic (offset at `y_raw`, normalisation at `ym_raw`), `on=self` | +| `Observation.__init__` transform handling and `_check_finite` | → `Comparison.__post_init__`; error names `data.label` | +| `Constraint._validate_constant_covariance` message | → compile error raised by `StructuredCovariance.factor_constant_parts`, remedies updated to the new spellings | +| `model_comparison.predictive_draws`, `heldout_log_predictive` | take `(problem, samples)`; read `CompiledConstraint.ym`, `.matrix`, `.log_likelihood` | +| `predictive.total_predictive_band` | take `(problem, term, predictor, ...)`; columns from `problem.columns` | +| `ParameterConfig.prior_transform` cursor | → per-slot map in `assemble_prior` | +| `ElasticDifferentialXSObservation.from_measurement`, `IsobaricAnalogPNObservation.from_measurement` | one free `from_measurement`; Rutherford from kinematics | +| `PhysicalModel.Polynomial` | → `polynomial(order)` factory | + +### Rewrite + +`params.py` (identity semantics, `prior`), the `Term` class body (state +removed), `ConstraintCovariance` → `StructuredCovariance`, `constraint.py`, +`evidence.py` + `config.py` → `problem.py`, `physical_model.py` → +`model.py`, the two observation classes → `from_measurement` + `Model.bind`. + +### Drop + +`walker.py`, `param_sampling.py`, `metropolis_hastings.py`, +`adaptive_metropolis.py`, `proposal.py`, `IndependentPrior`, +`TruncatedNormalPrior`, `as_prior`. + +### Tests to port by body + +The bodies below encode behaviour, not API, and port with renamed calls: + +- `test_covariance.py`: `TestTermKinds`, `TestTermCoords`, `TestFactories` + (including `test_old_observation_covariance_equivalence`), + `TestKernelTerm`, `TestStudyForms` (every α+Ca error-model form against + a hand-built dense matrix), `test_custom_term_direct`. +- `test_likelihood_model.py`: the closed-form Student-t and `Chi2` values. +- `test_constraint.py`: `TestComparisonSpaceTransform` (delta method, + `log_jacobian == -Σ log y`, `-inf` likelihood and `+inf` chi2 for a + non-positive prediction), `TestMask` (complement partition, + `ll(fit) + ll(held) == ll(full)`, shared parameters), `TestSingularCovarianceGuard`, + `TestSharedParameterCaseB`, `TestStackedConstraint` (case A differs from + the independent spelling). +- `test_observation.py`: `test_systematic_terms_propagated_by_delta_method`, + offset-then-normalisation order, zero magnitudes skipped. +- `test_regression.py`: all three pins, including `1.195784087817536`. +- `test_model_comparison.py`, `test_predictive.py` (GP matches sklearn's + `GaussianProcessRegressor`). +- `test_reaction_observation.py`: both Rutherford conversion directions, + `TestSolverSettingsForwarding`, `TestSharedUnits`. +- `test_reaction_models.py`: finite non-negative cross sections through + real jitr solves; the Lane-term note for the IAS test. +- `test_config.py::test_black_box_bayes_interface`, + `test_priors.py::TestUnitCubeClipping`. + +New tests the old suite could not have: dense-versus-structured equality on +every `TestStudyForms` form, with masks, with a cross-block kernel (dense +fallback), and with a mode-only block (singular `B`); a parameter shared +across two constraints; a `dill` round trip of an elastic `Problem` with +equal `log_posterior`; MVN `prior_transform` round trip and finiteness at +exactly 0 and 1; `Constraint.weight` scaling the likelihood only. + +The ported bodies are unit tests of modules. The recipe tests under +`test/recipes/` are the acceptance suite, and §9 lists which recipes each +milestone unlocks. Recipe tests use synthetic data and the generic `Model` +wherever the recipe does not require a reaction model, so they stay fast; +reaction recipes patch `set_up_solver` as the current +`test_reaction_observation.py` does, except for one real-solve smoke test. + +## 6. Repository layout and budget + +``` +rxmc/ + __init__.py re-exports; nothing else + params.py ~40 transforms.py ~230 units.py ~60 + data.py ~180 model.py ~120 terms.py ~380 + likelihood.py ~90 constraint.py ~170 covariance.py ~260 + problem.py ~320 diagnostics.py ~250 predictive.py ~200 + reactions/ + __init__.py + elastic.py ~170 ias.py ~120 +test/ unit tests, one file per module, plus test_regression.py +test/recipes/ one file per recipe in docs/recipes.md (~42), the acceptance suite; + oracle.py holds the closed-form linear-Gaussian posterior used by the fast tier +examples/ 9 notebooks (§7) +docs/ design.md rewritten from this document once the code lands +``` + +Runtime dependencies: `numpy`, `scipy`, `pint`, `jitr>=3.0`, +`exfor-tools`. `pandas` and `scikit-learn` leave `requirements.txt` +(neither is imported; kernels stay duck-typed and sklearn moves to the +`examples` extra). Extras: `examples` (emcee, dynesty, corner, matplotlib, +scikit-learn, dill, jupyter), `validation` (examples + pytest, nbmake, +ruff, black, isort). Python ≥ 3.12. Validation is the current contract: +ruff/black/isort on `src test`, nbqa on `examples`, `pytest test`, then +`pytest --nbmake examples`. `pyproject` registers the `slow` marker and +deselects it by default (`addopts = -m "not slow"`, §9). + +## 7. Notebooks + +Nine notebooks, each naming the current one it inherits. Every notebook +is driven by emcee or dynesty. + +| notebook | inherits | driver | new content | +|---|---|---|---| +| `linear_calibration` | linear_calibration_demo | emcee | prior predictive, posterior, predictive band with `problem.columns` | +| `error_models` | systematic_err_demo | emcee | the five-model ladder; two-constraint section with case B via shared `Parameter` | +| `normalization_and_covariance_structure` | normalization_inference | emcee | ρᵢ as `omp \| scale(rho_i)`; the four-case gallery via `matrix(theta)` | +| `correlated_observations` | correlated_observations | emcee | case A vs B, toy and n+⁴⁰Ca | +| `gp_discrepancy` | gp_discrepancy | emcee | `kernel` term; `total_predictive_band(problem, term, ...)`; the same defect fit with a sampled `omp + delta` mean correction for contrast | +| `robust_likelihoods` | robust_likelihoods | emcee | Student-t vs Gaussian; ν bounded on the `Parameter` | +| `measurement_to_calibration` | measurement_to_calibration + 30s_optical_potential_calibration + the tempering/coverage section of overconfidence | dynesty | `from_measurement`, `reported_terms`, the singular-covariance error, `Constraint(weight=)`, `coverage_curve` | +| `alpha_ca_error_model_comparison` | **new** (the `design.md` recipe table) | dynesty | log space, `Parameter(prior=)`, masks, `complement`, `heldout_log_predictive`, `logz_summary` / `compare_logz` with `log_jacobian`, shared noise (B) and coupled normalisation (A) across two datasets, the bbb shim shown but not run | +| `hierarchical_calibration` | **new** (recipes 24, 39, 42) | dynesty | hierarchy on the physics parameters; see below | + +**`hierarchical_calibration` in detail.** The truth is +`y = a0(E) + a1(E) x + a2(E) x²`, measured by J synthetic datasets at known +energies `E_j` (in `meta`) plus one held-out dataset at a new energy. The +true coefficient mappings `a_k(E)` are a smooth trend plus non-monotonic +bumps. Three fits of the same data: + +1. the correct mapping form with global `φ`; +2. a misspecified smooth mapping `a_k(E; φ) = φ_k0 + φ_k1 E` with global `φ`; +3. the same smooth mapping plus a per-dataset deviation vector in parameter + space, non-centred `δ_j = τ ⊙ η_j`, `η_jk ~ N(0, 1)`, + `τ_k ~ HalfNormal`, so the inter-dataset covariance is diagonal with a + learned spread (a full covariance through an LKJ-style joint block is + the named extension). + +Mechanics: one `Model` per block closing over `E_j` (recipe 39). The +held-out block is fully masked, so its `η_new` is sampled from the prior +only, driven by `τ`; `complement()`, `predictive_draws` and +`heldout_log_predictive` then score the new energy with no extra code. The +notebook states this design property explicitly. Plots: the coefficient +mappings against `E` with the truth; per-dataset residuals for case 2; +empirical coverage curves in-sample and on the held-out energy for all +three cases; sharpness; the posterior of `τ`; the held-out log predictive +per case. Expected: case 1 covers in and out of sample; case 2 +under-covers both and shows structured per-dataset residuals; case 3 +recovers coverage with wider, longer-tailed bands at the new energy (a +scale mixture over `τ`), a `τ` posterior away from zero, and the best +held-out score of the misspecified pair. Caveat stated in the notebook: +with few datasets `φ` and `δ_j` trade off, and the hyperprior on `τ` is +what resolves it. + +Dropped: `sampling_algos` (in-package samplers), `calibration_config_emcee_dynesty` +(every notebook is now this), `overconfidence` as a standalone. + +## 8. Gaps: what exists nowhere today + +- **G1 `ParameterIndex` and compile** (`problem.py`): first-seen slot + assignment, `on=` resolution against comparisons and datasets, `masks` → + `active`, name uniqueness, prior coverage. About 120 lines. +- **G2 Prior assembly**: marginal truncation to `bounds`, uniform default, + the joint-block protocol including hyperprior blocks, + joint blocks, `log_prior`, `prior_transform` (rescaled `ppf`; MVN + whitening; other joints must supply their own), `sample_prior`. About + 100 lines. +- **G3 `StructuredCovariance`**: new linear algebra. Verified against the + dense matrix on every `TestStudyForms` case, with masks, with a + cross-block kernel, and with a mode-only block. About 260 lines. +- **G4 Stateless `Term`, `Comparison`, `Constraint` masks**: including + `reported_terms` under a comparison transform and the complement + partition property. +- **G5 Rutherford in `from_measurement`**: resolved, it is a closed form of + `reaction.kinematics(Elab)`; no workspace needed. +- **G6 `dill` picklability**: a test round-trips an elastic `Problem` and + compares `log_posterior`. If a jitr workspace does not pickle, + `Predictor.__reduce__` rebuilds it from `(model, x, meta)`; the factory + closures in `terms.py` pickle under `dill` as they are. +- **G7 Analysis on `(problem, samples)`**: `predictive_draws`, + `heldout_log_predictive`, `total_predictive_band` selecting columns via + `problem.columns`. +- **G8 The α+Ca and hierarchical notebooks** and the bbb `posterior.py` shim. +- **G9 Docs**: `design.md` rewritten from this document; API reference + regenerated; README quickstart in the new spelling. + +## 9. Milestones + +Each step is testable on its own in the new repository. Every milestone +lists the modules it delivers, the unit tests it ports, and the recipe +tests it unlocks: a recipe test lands in the first milestone where every +object it uses exists. A milestone is done when its unit tests and every +recipe test it unlocks pass. + +0. **Bootstrap.** A branch `rewrite` of *this* repository, cut from + `main` after the 0.x close-out (§11), developed in a git worktree at + `~/el/rxmc-ng` with its own virtual environment (`jitr>=3.0` from PyPI, + Python ≥ 3.12). Its first commit removes `src/`, `test/` and + `examples/` and keeps `docs/` (this document and `recipes.md` are the + plan of record) and the configuration. Files that move mostly intact + (`transforms`, `likelihood`, `units`, the term factories) come over by + `git mv` in a commit of their own before any edit, so blame survives + the harvest. Then: a `pyproject` in the current shape with the `slow` + marker registered and deselected by default; ruff, black and isort + configuration carried over; the CI workflow (fast tier on pull + requests, `pytest -m slow` and nbmake on a schedule); a trusted- + publishing workflow that uploads to PyPI on tag push. +1. **`params`, `transforms`, `units`, `likelihood`, `terms`** (verbatim + harvest plus the stateless `Term`). Ported: `TestTermKinds`, + `TestTermCoords`, `TestFactories`, `TestKernelTerm`, `TestStudyForms` + (term values against hand-built matrices), the closed-form Student-t + and `Chi2`, `TestUnitCubeClipping`, `TestSharedUnits`. Recipe tests + unlocked: none end to end (there is no `Problem` yet). The term-level + halves of recipes 19 (fixed-array shape and symmetry checks, a custom + callable) and 27 (a `normalization` mode evaluates from `c.ym`, a + data-built mode from `c.y`) are written here as unit tests and reused + by those recipe tests later. +2. **`data`** (without `from_measurement`), **`model`** (generic and + `polynomial`), **`constraint`** (`Comparison`, `Constraint`, masks, + `reported_terms`). Ported: `TestComparisonSpaceTransform` at block + level, delta-method `reported_terms`, `TestMask` construction and the + `complement` partition of active sets, name and shape validation. + Recipe tests unlocked: none (no likelihood without the covariance). +3. **`covariance`.** New: dense-versus-structured equality on every + `TestStudyForms` form, with masks, with a cross-block kernel (dense + fallback), and with a mode-only block (singular `B` error). No recipe + tests yet. +4. **`problem`**: index, compile, priors, flat interface; emcee and + dynesty smoke tests on the linear problem; `dill` round trip. The + acceptance suite starts here, all on synthetic data with generic + models. Recipe tests unlocked: + - core: 1, 2, 4, 5, 6, 8, 9, 10, 11, 12, 13, 16, 19, 20, 21; + - hierarchy and sharing: 22, 23, 24, 42; + - driver loops needing only `log_likelihood`, `log_prior`, + `sample_prior`: 25 (SafeBayes), 26 (KDUQ weights), 27 (Peelle), 31 + (cut posterior), 34 (power-scaling), 36 (an emulator term sees the + model's parameters), 37 (MAP and Laplace), 38, 39, 40; + - 28 (the BUQEYE covariance from `c.meta`) with synthetic `y_ref`, `Q`. + + Regression pins carried here: `1.195784087817536`, the old-covariance + equivalence, `ll(fit) + ll(held) == ll(full)`, and "a parameter on a + fully masked block is sampled from its prior", which recipe 42 and the + hierarchical notebook rely on. +5. **`reactions/elastic`, `reactions/ias`, `from_measurement`.** Ported: + both Rutherford conversion directions, `TestSolverSettingsForwarding`, + real-solve smoke tests, the Lane-term IAS check. Recipe tests + unlocked: 3, 14, 15, 41; the reaction variants of 7 and 22 + (momentum-transfer coordinates, an energy-running amplitude) run + against a patched solver. +6. **`diagnostics`, `predictive`.** Ported: GP-versus-sklearn, + `predictive_draws` covariance recovery, `heldout_log_predictive`, + `logz_summary` and `compare_logz`. Recipe tests unlocked: 7 + (`total_predictive_band` finds the kernel columns itself), 17, 18, 29, + 30, 32, 33, 35. +7. **CI wiring.** The heading-to-file check between `recipes.md` and + `test/recipes/`; `pytest test` runs both suites; the fast tier must + finish in a few minutes on a laptop (patched solvers, small `J` and + `n`). +8. **Notebooks 1–9.** Each notebook names the recipes it is the tutorial + for: `linear_calibration` (1, 17); `error_models` (2, 4, 5, 19); + `normalization_and_covariance_structure` (3, 6, 27); + `correlated_observations` (5, 41); `gp_discrepancy` (7, 8, 40); + `robust_likelihoods` (9, 38); `measurement_to_calibration` (12, 14, + 15, 16, 21, 26); `alpha_ca_error_model_comparison` (10, 11, 13, 18, + 25); `hierarchical_calibration` (22, 24, 39, 42, and 32 for the + held-out energy). A recipe without a notebook is fine; a notebook must + cite at least one recipe. +9. **`design.md` and README** rewritten from this document. + +### Fast and converged tiers + +Recipe tests must be fast in CI, but some expected behaviours only hold +for a converged sampler. The resolution is two tiers with a strong +preference for assertions that need no sampler at all. + +- **Prefer sampler-free assertions.** Most expected-behaviour bullets are + structural or analytic: names and columns, a covariance equal to a + hand-built matrix, `chi2` identities, `ll(fit) + ll(held) == ll(full)`, + a mode built from `c.ym`, `prior_transform` round trips, compile-time + errors. These are exact and form the core of every recipe test. +- **Linear-Gaussian oracle.** `test/recipes/oracle.py` computes the + closed-form posterior and predictive of any recipe instantiated with a + linear model and Gaussian terms. Tests compare `log_posterior` and + `predictive_draws` statistics against it without sampling. This covers + the coverage-type claims of recipes 1, 6, 12, 17, 26 and the + marginalised form of 42 exactly. +- **Seeded short chains, qualitative assertions.** Ordering claims ("case + 2 under-covers and case 3 recovers"; "the Student-t covers the truth + and the Gaussian does not") use a seeded 16-walker, few-hundred-step + emcee run on a toy problem and assert only the ordering, with a wide + margin. +- **Converged tier.** Tests marked `slow` hold the numeric claims + (coverage within 0.05 of nominal, `τ` recovered within its interval, + evidence differences), record the seed, R-hat and effective sample + size so a failure is diagnosable, and run the notebooks through nbmake. + They are deselected by default; pull-request CI runs the fast tier and a + scheduled job runs `pytest -m slow`. +- **Rules.** The fast tier has a budget of a few minutes and zero + tolerated flakiness. A flaky fast assertion is demoted to `slow`, never + loosened until it passes. Every recipe test file has at least one fast + test; a slow test is optional and holds the numbers. Which tier pins + each bullet is decided per recipe as the implementation lands. + +## 10. Open questions + +- **Term-level partial masks.** The factories accept `mask=` for a partial + support today. `on=(block, point_mask)` would make it a first-class + support form; whether that is worth the extra spelling is a matter of + taste. v0 keeps `mask=` on the factories. +- **Workspace caching across datasets at one energy.** Correct without + it; a factor of a few in setup time with it. Not in v0. - **Cross-constraint modes.** `U` is per constraint so that constraints stay independent and weights stay meaningful. A mode that couples two constraints is, as today, a reason to merge them. -- **`n_dof`.** With sharing across constraints allowed, count unique - slots, not the sum of per-constraint counts. -- **Term-level masks.** Today the factories accept `mask=` for partial - support. With `on=(block, point_mask)` that becomes a first-class support - form; whether it is worth the extra spelling is a matter of taste. +- **Known non-goals.** The closing section of `recipes.md`, "What this API + does not express", lists the calibration classes the skeleton rules out + (non-elliptical likelihoods, chain-dependent masks, per-point latents, + per-point likelihood factors, mixture likelihoods) with the size of the + addition each would need. Revisit when a study needs one. + +## 11. Release path: from 0.x to 1.0 in the same repository + +The GitHub repository, its pull-request history, collaborator branches and +Pages documentation are kept. `rxmc` is not on PyPI, so the name is free +and version history there starts at 1.0. + +1. **Close out 0.x.** Merge `api_generalisation` into `main` by pull + request. Tag the merge `v0.1.0` and add a branch `legacy/0.x` at the + same commit: the last state of the old design, with this plan in its + tree, reachable by name forever. +2. **Rewrite on a branch.** `rewrite` is cut from that `main` (§9, + milestone 0). History stays linear; no orphan branch and no force + push. The README on `main` carries a one-line banner pointing at the + branch while the rewrite is in progress. +3. **Pre-releases by tag.** setuptools_scm reads the version from tags. + Tag `v1.0.0a1` after milestone 4, `v1.0.0b1` after milestone 6, + `v1.0.0rc1` after milestone 8; each tag push publishes to PyPI as a + pre-release (installable with `pip install --pre rxmc`). Publishing + `a1` early claims the PyPI name; try TestPyPI once first. +4. **Release.** Pull request `rewrite` into `main`, ordinary merge, tag + `v1.0.0`, GitHub Release, PyPI publish, Pages rebuild from `main`. The + README then notes that 0.x lives at `v0.1.0` and `legacy/0.x`. +5. **Old branches.** Collaborators' branches are left alone; superseded + ones may be deleted after 1.0. diff --git a/docs/index.rst b/docs/index.rst index e72868d..b34b31e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -25,6 +25,7 @@ full calibration problems (:class:`~rxmc.evidence.Evidence`). installation design groundup_design + recipes bugs_found api examples diff --git a/docs/recipes.md b/docs/recipes.md new file mode 100644 index 0000000..ba241d1 --- /dev/null +++ b/docs/recipes.md @@ -0,0 +1,1314 @@ +# Recipes + +Short user stories for the ground-up `rxmc` described in `groundup_design.md`. +Each recipe says what a user wants, how it is spelled, and what behaviour +they should expect. Together they are the minimal set of use cases the +rewrite must support; every one of them is backed by a notebook or a test +in the current repository, or by a design decision recorded in the design +document. Every recipe is also a test: `test/recipes/test_recipe_NN_.py` +asserts its *Expected behaviour* bullets, and the richest recipes are +tutorial notebooks (design document §7 and §9). Snippets assume: + +```python +import numpy as np, rxmc as rx +from rxmc import terms as T, transforms as tf +from scipy import stats +from sklearn.gaussian_process.kernels import Matern, RBF +``` + +--- + +## 1. Fit a model to data with reported statistical errors + +*I have `x`, `y`, and a statistical error per point, and a model with a few +parameters. I want the posterior.* + +```python +m, b = rx.Parameter("m", prior=stats.norm(0, 5)), rx.Parameter("b", prior=stats.norm(0, 5)) +line = rx.Model(lambda x, m, b: m * x + b, [m, b]) +d = rx.Dataset(x, y, y_err) +problem = rx.Problem([rx.Constraint([rx.Comparison(d, line)])]) +``` + +Expected behaviour: + +- The covariance is `diag(y_err**2)` and nothing else. `problem.chi2(theta)` + equals `sum(((y - ym) / y_err)**2)` exactly. +- `problem.ndim == 2`, `problem.names == ["m", "b"]`, in declaration order. +- `problem.log_posterior`, `problem.sample_prior(n)`, `problem.prior_transform` + are all that emcee or dynesty need (recipe 16). + +## 2. Infer an unknown noise level + +*My data have no usable error bars, or I do not trust them. I want to +infer the noise magnitude alongside the model.* + +```python +log_eps = rx.Parameter("log_eps", prior=stats.norm(-2, 2)) +c = rx.Constraint([rx.Comparison(d, line)], terms=[T.noise(log_eps)], statistical=False) +# or fractional noise: T.noise_fraction(log_eps) +# or model error on the average of data and prediction: T.model_error(log_gamma) +# or noise growing along x: T.noise(log_eps, basis=T.exp_growth(np.pi), basis_params=(slope,)) +``` + +Expected behaviour: + +- With `statistical=False` the inferred noise *replaces* the reported + errors; with the default `statistical=True` it is *added* to them. +- The posterior of `log_eps` reflects the residual scatter. In the + `sampling_algos` scenario its truth is recovered. +- `noise_fraction` and `model_error` scale with the prediction, so the + covariance changes with the model parameters. That is allowed and costs + nothing extra. + +## 3. Use the reported systematic errors + +*The measurement reports a fractional normalisation error and an absolute +offset error. I want them in the likelihood as correlated modes.* + +```python +d = rx.from_measurement(m, reaction=reaction, quantity="dXS/dA") # norm_err, offset_err filled +comp = rx.Comparison(d, omp) +c = rx.Constraint([comp], terms=comp.reported_terms()) +``` + +Expected behaviour: + +- `reported_terms()` returns the offset mode first, then the + prediction-scaled normalisation mode. Zero magnitudes yield no term. +- Without the call, neither systematic enters the covariance. Nothing is + folded in silently. +- Re-adding both terms reproduces the pre-0.1 auto-folded covariance to + the last digit (`test_regression`, log-likelihood `1.195784087817536`). +- Under `space=tf.log` the modes are propagated by the delta method: the + offset at the data, the normalisation at the prediction. + +## 4. Infer a normalisation or offset the experiment did not report + +*I suspect an unreported normalisation (or background offset) and want its +magnitude as a nuisance parameter.* + +```python +log_eta = rx.Parameter("log_eta", prior=stats.norm(-3, 1)) +c = rx.Constraint([comp], terms=[T.normalization(parameter=log_eta)]) +# absolute offset instead: T.offset(parameter=log_omega) +# a mode with any shape: T.systematic(log_s, basis=T.x_basis(np.pi)) +``` + +Expected behaviour: + +- One rank-one mode `exp(log_eta)**2 * outer(ym, ym)` is added. +- The model parameters decorrelate from the overall scale of the data; the + data's normalisation pull moves into `log_eta`. + +## 5. Share an error model between datasets, or couple them + +*Two datasets. Case B: each has its own independent normalisation +measurement, but I believe the two magnitudes are the same. Case A: both +were normalised against the same uncertain flux, so their errors are +correlated.* + +```python +comp1, comp2 = rx.Comparison(d1, omp), rx.Comparison(d2, omp) +log_eta = rx.Parameter("log_eta", prior=stats.norm(-3, 1)) + +# case B: one parameter, two comparison-local modes; the comparisons stay independent +cB = rx.Constraint([comp1, comp2], terms=[T.normalization(log_eta, on=comp1), T.normalization(log_eta, on=comp2)]) +# equivalently, two constraints sharing the parameter object +cB1, cB2 = rx.Constraint([comp1], terms=[T.normalization(log_eta)]), rx.Constraint([comp2], terms=[T.normalization(log_eta)]) + +# case A: one mode spanning both comps; the comps are correlated +cA = rx.Constraint([comp1, comp2], terms=[T.normalization(log_eta, on=[comp1, comp2])]) +``` + +Expected behaviour: + +- All three spellings have exactly one nuisance parameter. +- Case B's covariance is block diagonal; case A's has a non-zero + off-diagonal block. The two likelihoods differ, and treating case A + data as case B is overconfident (`correlated_observations`). +- Sharing is by object: two `Parameter("log_eta")` objects would be two + parameters and a compile error for the duplicate name. +- Case A costs no more than case B: the cross-comparison mode goes through the + low-rank path, never a dense factorisation. + +## 6. One latent scale per dataset + +*Each dataset has its own unknown normalisation. I want a Kennedy–O'Hagan +scale factor on the model prediction, one per dataset, sampled with the +model parameters.* + +```python +rhos = [rx.Parameter(f"log_rho_{i}", prior=stats.norm(0, np.log1p(s))) for i, s in enumerate(sys_errs)] +comps = [rx.Comparison(d_i, omp | tf.scale(rho_i)) for d_i, rho_i in zip(datasets, rhos)] +# one global scale instead: omp | tf.scale(rho) on every comparison +``` + +Expected behaviour: + +- The scale multiplies the *mean*, so it is not a covariance term. Its + parameters follow the model's in `problem.names`. +- A masked or held-out view of the comparison keeps the same `rho_i` because + the comparison, not the data, carries the model. +- Fitting the ρᵢ recovers the true normalisations by MAP + (`normalization_inference`); folding the reported σ_sys in as fixed + normalisation modes (recipe 3) gives statistically the same model + posterior. + +## 7. Absorb model deficiency with a Gaussian process + +*My model is missing physics. I want a smooth correlated discrepancy, in +angle or in momentum transfer, learned from the residuals.* + +```python +log_A = rx.Parameter("log_A", prior=stats.norm(0, 2)) +gp = T.kernel(Matern(1.0, nu=2.5), on=comp, coords=lambda x: x / np.pi, + amplitude=T.constant_amplitude, amplitude_params=(log_A,)) +# in momentum transfer with amplitude A q^(r/2): +q = lambda x: rx.reactions.momentum_transfer(x, d.meta["k"]) +gp_q = T.kernel(RBF(1.0), on=comp, coords=q, amplitude=lambda c, lA, r: np.exp(lA) * c.x ** (r / 2), + amplitude_params=(log_A, r)) +c = rx.Constraint([comp], terms=[gp]) +band = rx.predictive.total_predictive_band(problem, gp, omp.bind(x_fine, d.meta), x_fine, samples) +``` + +Expected behaviour: + +- One parameter per free kernel hyperparameter element, named + `discrepancy_`, sampled in sklearn's log-theta space. +- The model parameters relax from their biased values toward the truth + (`gp_discrepancy`); the learned discrepancy tracks the true defect. +- `total_predictive_band` finds the kernel's columns from the term itself; + no column arithmetic. +- Every error-model form of the α+Ca study reproduces a hand-built dense + matrix (`TestStudyForms`). + +## 8. Sample a mean discrepancy explicitly + +*Instead of marginalising the discrepancy, I want to sample an additive +correction with a parametric shape.* + +```python +phi = [rx.Parameter(f"c{i}", prior=stats.norm(0, 1)) for i in range(3)] +delta = rx.Model(lambda x, c0, c1, c2: c0 + c1 * x + c2 * x**2, phi) +comp = rx.Comparison(d, omp + delta) +``` + +Expected behaviour: + +- The prediction is `omp(x) + delta(x)` in physical space; + `problem.names` lists `omp.params` then `phi`. +- `(omp + delta) | tf.scale(rho)` scales the sum; `(omp | tf.scale(rho)) + delta` + scales only the model. +- A multiplicative, `x`-dependent correction is `omp * Model(g_fn, phi)`; + an additive discrepancy in log space is exactly that. `scale(rho)` is + its constant special case. +- The GP of recipe 7 may be used alongside it. + +## 9. Heavy tails + +*A few points are gross outliers. I do not want them to drag the fit; I +want a likelihood that widens instead of breaking.* + +```python +nu = rx.Parameter("nu", bounds=(1.0, 100.0)) # uniform on the bounds +c = rx.Constraint([comp], likelihood=rx.StudentT(nu=nu)) +``` + +Expected behaviour: + +- Same covariance, different functional. The Gaussian version puts the + truth at several σ; the Student-t version covers it + (`robust_likelihoods`), and the posterior of `nu` is small. +- The multivariate t applies one radial tail to the whole stacked residual + of the constraint. A comparison that needs Gaussian tails goes in its own + constraint. +- `rx.Chi2()` drops the log-determinant for a pure chi-squared objective. +- The Student-t value is pinned to its closed form (`test_likelihood`). + +## 10. Compare in log space + +*Cross sections span orders of magnitude. I want the Gaussian to live in +log space, with the model still written in physical units.* + +```python +comp = rx.Comparison(d, omp, space=tf.log) +c = rx.Constraint([comp], terms=[T.noise(log_eps)], statistical=False) # constant noise in log space +``` + +Expected behaviour: + +- `comp.y == log(d.y)` and `comp.y_err == d.y_err / d.y` (delta method). The + prediction is transformed the same way at every evaluation, so it can + never be double-transformed. +- A non-positive prediction gives `log_likelihood == -inf` and + `chi2 == +inf`. A non-positive datum on an active point is a compile + error naming the dataset. +- `problem.log_jacobian()` is `-sum(log y)` over active points; add it to + the log-evidence of the log-space fit before comparing with a + linear-space fit of the same data. +- Constant noise in log space and fractional noise in linear space are + different models with different evidences. That is the point. + +## 11. Hold out data and score it + +*I want to fit below an angular cut and score the prediction above it, or +compare error models by their held-out predictive density.* + +```python +fit = c.masked_where(lambda x: x < cut) +held = fit.complement() +problem = rx.Problem([fit], priors=priors) +heldout = rx.Problem([held], priors=problem.priors) +lp = rx.diagnostics.heldout_log_predictive(heldout, samples) +score = rx.diagnostics.log_posterior_predictive(lp, logw=res.logwt) # weighted for nested sampling +``` + +Expected behaviour: + +- `fit` and `held` share every `Comparison`, `Term`, and `Parameter`; the two + problems have identical `names`, so a chain from one scores the other. +- Active sets are disjoint, their union is every point, and + `ll(fit) + ll(held) == ll(full)` for a block-local covariance. +- Terms are authored once over all points; masking selects rows, it never + rebuilds anything. + +## 12. Temper the likelihood + +*I have many points and worry the posterior is overconfident, or I want +a power posterior.* + +```python +c = rx.Constraint([comp], weight=2 / n) +``` + +Expected behaviour: + +- The log-likelihood of that constraint is multiplied by `weight`; the + prior is never touched. One knob, honoured by every driver. +- Empirical coverage of the posterior predictive (recipe 17) moves toward + the nominal level as the weight decreases (`overconfidence`). + +## 13. Declare priors + +*I want each nuisance parameter to carry its own prior, the optical +potential to have a correlated multivariate normal prior, and everything +to work with nested sampling.* + +```python +log_eps = rx.Parameter("log_eps", prior=stats.halfnorm(scale=1)) # marginal +nu = rx.Parameter("nu", bounds=(1, 100)) # uniform on bounds +V = rx.Parameter("V", prior=stats.norm(50, 5), bounds=(30, 70)) # truncated marginal +problem = rx.Problem([c], priors=[(omp.params, stats.multivariate_normal(mu, cov))]) # joint block +``` + +Expected behaviour: + +- Every slot is covered exactly once, or `Problem` raises naming the + parameter (uncovered) or the pair of priors (double covered). +- `problem.prior_transform(u)` exists for all of the above: rescaled `ppf` + for marginals, whitening for the multivariate normal. It is finite at + `u = 0` and `u = 1`. +- `problem.sample_prior(n)` gives an `(n, ndim)` array suitable as emcee's + starting positions. + +## 14. From an EXFOR measurement to a dataset + +*I have an `exfor_tools` distribution in mb/sr, or as a ratio to +Rutherford, with its reported errors. I want a dataset in the library's +units with nothing lost.* + +```python +d = rx.from_measurement(m, reaction=reaction, quantity="dXS/dA") # or "dXS/dRuth", "Ay" +d_ias = rx.from_measurement(m, reaction=reaction, ExIAS=Ex) # (p,n) IAS channel +``` + +Expected behaviour: + +- `y`, `y_err` and `offset_err` are divided by the unit conversion + factor; `norm_err` (fractional) passes through untouched. Angles are + stored in radians. +- Requesting `dXS/dRuth` from a `dXS/dA` measurement (or the reverse) + uses the Rutherford cross section on the data angles, a closed form of + the kinematics; the factor is then a per-angle array. +- `d.meta` carries `reaction`, `Elab`, `quantity`, `k` (and `ExIAS`), which + is everything a reaction model needs to bind. +- Incompatible units, or a quantity the measurement cannot be converted + to, raise at conversion time. + +## 15. Evaluate a reaction model on any grid + +*I want the model on the data angles for the likelihood and on a fine +grid for plotting, with the solver set up once per grid.* + +```python +omp = rx.reactions.ElasticXS("dXS/dA", central, spin_orbit, args_from_params, params, + lmax=20, wavelengths_beyond_range=2.0, zeros_per_node=5) +comp = rx.Comparison(d, omp) # bound to d.x, d.meta +fine = omp.bind(np.deg2rad(np.linspace(0.5, 179.5, 200)), d.meta) +ys = [fine(*s[problem.columns(omp.params)]) for s in samples[::50]] +band = rx.predictive.predictive_band(ys, levels=(5, 50, 95)) +``` + +Expected behaviour: + +- The model owns the jitr workspace; the dataset never does. Solver + settings on the model reach jitr (`TestSolverSettingsForwarding`). +- The predictor is a pure function of the potential. A compound-elastic + contribution is subtracted from `d.y` before the dataset is built + (recipe 20); there is no correction hook on the model. +- Cross sections are in b/sr; `dXS/dRuth` and `Ay` are dimensionless. +- `problem.columns(omp.params)` is the only chain bookkeeping a user does. + +## 16. Drive the calibration with an external sampler + +*I want to use emcee, dynesty, or the `black-box-bayes` CLI, and read the +chain back without positional arithmetic.* + +```python +# emcee +p0 = problem.sample_prior(32) +sampler = emcee.EnsembleSampler(32, problem.ndim, problem.log_posterior) +samples = sampler.run_mcmc(p0, 5000) and sampler.get_chain(discard=1000, flat=True) + +# dynesty +ns = dynesty.NestedSampler(problem.log_likelihood, problem.prior_transform, problem.ndim) +ns.run_nested(); samples = ns.results.samples_equal() +logz = rx.diagnostics.logz_summary(ns.results.logz[-1], ns.results.logzerr[-1]) + +# black-box-bayes +dill.dump(problem, open("problem.pkl", "wb")) # posterior.py delegates six names to it +``` + +Expected behaviour: + +- Chains from all three are `(n, ndim)` arrays in `problem.names` order. + Every analysis function takes `(problem, samples)`. +- `log_posterior` evaluates the prior first and never calls the forward + model when the prior is `-inf`. +- `dill.loads(dill.dumps(problem)).log_posterior(theta)` equals + `problem.log_posterior(theta)`, workspaces included. +- `problem.NDIM`, `problem.parameter_names`, `problem.starting_location`, + `problem.log_posterior_batch` are the bbb spellings of the same things. + +## 17. Check the posterior predictive + +*I want to know whether my error model is calibrated: do 68 % intervals +contain 68 % of the points, and how wide are they?* + +```python +draws = rx.diagnostics.predictive_draws(problem, samples, constraint=0, n_rep=4) +cov = rx.diagnostics.coverage_curve(draws, problem.constraints[0].y[problem.constraints[0].active]) +err = rx.diagnostics.coverage_error(draws, y_active) +width = rx.diagnostics.sharpness(draws, transform=np.exp) # widths in physical space for a log fit +``` + +Expected behaviour: + +- Draws are `ym(theta) + L z` on the active points in comparison space; + `model_only=True` returns `ym(theta)` and assembles no covariance. +- Coverage is near nominal for a correct error model and clearly below + it for an overconfident one. +- `logz_summary` reports the max of the replicate half-range and the + sampler's own error; `compare_logz` returns `"tie"` unless the + difference exceeds `sigma * hypot(err_a, err_b)`. + +## 18. Compare error models by evidence + +*The α+Ca study: several error models for data without reported errors. +I want the evidence for each, comparable across comparison spaces.* + +```python +models = { + "L0": rx.Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False), + "E0": rx.Constraint([comp_lin], terms=[T.noise_fraction(log_eps)], statistical=False), + "L2y": rx.Constraint([comp_log], terms=[T.noise(log_eps), T.normalization(log_sys)], statistical=False), + "Lgp": rx.Constraint([comp_log], terms=[T.noise(log_eps), gp], statistical=False), + "L0t": rx.Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False, likelihood=rx.StudentT()), +} +logz = {} +for name, c in models.items(): + p = rx.Problem([c.masked_where(lambda x: x < cut)], priors=priors) + res = run_dynesty(p) + logz[name] = rx.diagnostics.logz_summary(res.logz[-1] + p.log_jacobian(), res.logzerr[-1]) +verdict = rx.diagnostics.compare_logz(logz["Lgp"], logz["L0"]) +``` + +Expected behaviour: + +- The same `log_eps` object is reused across models without conflict: + each `Problem` is compiled independently. +- Adding `log_jacobian` makes the log-space and linear-space evidences + comparable. +- Every term list in the table reproduces the corresponding hand-built + covariance in `TestStudyForms`. + +## 19. Bring my own covariance or term + +*I have a full covariance matrix from a correlated measurement, or a noise +model no helper expresses.* + +```python +fixed = rx.Term(C, on=comp) # any symmetric PD matrix +stat = rx.Term(sig, kind="diag", on=comp) # a fixed std-dev vector +custom = rx.Term(lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (log_e, slope), kind="diag") +``` + +Expected behaviour: + +- A plain array is a fixed contribution, factored once. Shape and + symmetry are checked at construction against the term's `on`. +- A callable sees a `TermContext` with `x` (through `coords`), `y`, `ym`, + and `len(c)`; it returns a vector for `diag`/`mode` or a matrix. +- Fitting correlated data with the correct `Term(C)` instead of its + diagonal is the difference between an honest and an overconfident + posterior (`normalization_inference` gallery). + +## 20. Preprocess instead of asking for a feature + +*I want to mean-subtract, standardise, or project both data and model onto +principal components of a prior predictive ensemble.* + +```python +mu = ens.mean(0); A = np.linalg.svd(ens - mu, full_matrices=False)[2][:k] +d_pc = rx.Dataset(np.arange(k), A @ (d.y - mu), np.zeros(k), label=f"{d.label} PC") +native = omp.bind(d.x, d.meta) +proj = rx.Model(lambda x, *theta: A @ (native(*theta) - mu), omp.params) +stat = rx.Term(A @ np.diag(d.y_err**2) @ A.T, on=d_pc) +c = rx.Constraint([rx.Comparison(d_pc, proj)], terms=[stat, T.noise(log_eps, on=d_pc)], statistical=False) +``` + +Expected behaviour: + +- `Dataset.x` is opaque to the library; a model may ignore its `x` and + close over a predictor on another grid; `y_err` may be zero when + `statistical=False`. None of these is "fixed" later. +- Subtracting a known contribution from the data, such as a compound- + elastic cross section, is the same pattern: `replace(d, y=d.y - cn)`. + A reported *fractional* normalisation error refers to the measured + value, so build that mode from the unsubtracted prediction if it + matters; the offset error is unaffected. +- Pointwise maps (mean subtraction, standardisation) can equally be a + `space=` transform built from closed-over arrays, which keeps the delta + method and `log_jacobian` correct. +- Terms that scale with the native prediction see the projected `ym`; + they must call the native predictor themselves if they need it. +- A projected fit's evidence is not comparable to the unprojected one. + +## 21. Get a useful error, not a `LinAlgError` + +*My measurement reports no statistical error and I forgot to add any +term.* + +```python +d = rx.from_measurement(m_without_errors, reaction=reaction, quantity="dXS/dA") +rx.Problem([rx.Constraint([rx.Comparison(d, omp)])]) +# ValueError: covariance of constraint 0 is singular on comparison 'E1234-002': the dataset +# reports zero statistical error and no term covers its points. Add +# comp.reported_terms(), a noise term, or a fixed Term; or set statistical=False and +# compose the covariance explicitly. +``` + +Expected behaviour: + +- Raised by `Problem`, before any sampler runs, naming the comparison by its + label. A parametric covariance is not checked eagerly (it may be fine + at some parameter values). +- The same compile step reports duplicate parameter names, an uncovered + prior slot, an `on=` outside its constraint, and a non-finite + comparison-space value on an active point. + +## 22. Share hyperparameters across datasets, with values that depend on the dataset + +*I have elastic data at several energies. I want one GP discrepancy per +dataset with a common length scale and an amplitude that runs with energy, +so that two shared parameters describe every dataset.* + +```python +log_A0 = rx.Parameter("log_A0", prior=stats.norm(0, 2)) +p = rx.Parameter("p", prior=stats.norm(0, 1)) +ell = rx.Parameter("gp_length", prior=stats.norm(0, 1)) + +amp = lambda c, lA, p: np.exp(lA) * (c.meta("Elab") / 50.0) ** p +terms = [T.kernel(Matern(1.0, nu=2.5), on=comp, params=[ell], + amplitude=amp, amplitude_params=(log_A0, p)) for comp in comps] +c = rx.Constraint(comps, terms=terms) +``` + +Expected behaviour: + +- `problem.names` contains one `log_A0`, one `p`, one `gp_length`, however + many comparisons there are. Sharing is by object; the loop reuses the same + three. +- `c.meta("Elab")` is the comparison's energy broadcast to every point of the + support, so the amplitude function is written once and works on any + comparison. On a term spanning comparisons it is the per-point concatenation. +- Without `params=[ell]`, each `kernel` call would derive its own length + scale, one per dataset. That is also a legitimate model; it is just not + this one. +- The comparisons stay uncorrelated, so the constraint is on the structured + path. + +## 23. A discrepancy correlated across energies and angles + +*I believe the model's defect varies smoothly in both energy and angle. I +want one GP over (E, θ) that correlates the datasets at different +energies.* + +```python +kE, kθ = RBF(10.0), Matern(0.3, nu=2.5) +lE, lθ, log_A = (rx.Parameter(n, prior=stats.norm(0, 1)) for n in ("log_lE", "log_ltheta", "log_A")) + +def fn(c, lE, lθ, lA): + E, θ = c.meta("Elab")[:, None], c.x[:, None] + K = kE.clone_with_theta([lE])(E) * kθ.clone_with_theta([lθ])(θ) # separable product + return np.exp(2 * lA) * K + 1e-10 * np.eye(len(c)) + +md = rx.Term(fn, (lE, lθ, log_A), kind="matrix", on=comps) +c = rx.Constraint(comps, terms=[md]) +``` + +Expected behaviour: + +- The term spans comparisons, so the constraint's covariance has non-zero + off-diagonal blocks between energies and takes the dense path. Cost + grows as the cube of the total number of points; per-comparison GPs with a + linked amplitude (recipe 22) are the cheap alternative when + cross-energy correlation is not needed. +- Any kernel built from `c.meta` and `c.x` is allowed; the product of two + one-dimensional kernels is the factorised form. There is no Kronecker + speed-up because datasets share no angle grid. +- The dense matrix equals the hand-built product kernel on the stacked + `(E, θ)` inputs. + +## 24. Per-dataset parameters drawn from a sampled hyperprior + +*Each dataset has its own normalisation, and I want to learn how spread +out those normalisations are, rather than fix the spread.* + +```python +rhos = [rx.Parameter(f"log_rho_{i}") for i in range(len(comps))] # no marginal: the joint covers them +log_tau = rx.Parameter("log_tau") + +class RhoHierarchy: + def logpdf(self, v): # v ordered as (rhos..., log_tau) + *r, lt = v + return (stats.norm(0, np.exp(lt)).logpdf(r).sum() + + stats.halfnorm(scale=0.3).logpdf(np.exp(lt)) + lt) # hyperprior on tau, with Jacobian + def prior_transform(self, u): # hyperparameter first, children given it + lt = np.log(stats.halfnorm(scale=0.3).ppf(u[-1])) + return np.append(stats.norm(0, np.exp(lt)).ppf(u[:-1]), lt) + +comps = [rx.Comparison(d_i, omp | tf.scale(rho_i)) for d_i, rho_i in zip(datasets, rhos)] +problem = rx.Problem([rx.Constraint(comps)], priors=[(rhos + [log_tau], RhoHierarchy())]) +``` + +Expected behaviour: + +- `log_tau` is an ordinary column of the chain. Its posterior is the + learned spread of the normalisations; the `rho_i` shrink toward zero + when `tau` is small. +- Forgetting the joint block is a compile error: the `rho_i` carry no + marginal and have infinite bounds, so no prior covers them. +- Nested sampling works because the comparison supplies its own unit-cube map, + drawing the hyperparameter before the children. +- The same mechanism gives per-dataset GP amplitudes with a shared spread, + or any other partially pooled parameter. + +## 25. SafeBayes: learn the tempering exponent + +*I suspect my model is misspecified and want the tempering exponent η +chosen by the data rather than by hand, following Grünwald's SafeBayes +(arXiv:1412.3730): minimise the prequential log-loss of the η-generalised +posterior over prefixes of the data.* + +```python +from dataclasses import replace +order = rng.permutation(n) # one ordering; average a few +prefix = lambda i: [np.isin(np.arange(n), order[:i])] +etas = [1.0, 0.5, 0.25, 0.125] +loss = dict.fromkeys(etas, 0.0) + +for i in range(n0, n): + before = rx.Problem([c.masked(prefix(i))], priors) # untempered, for scoring + after = rx.Problem([c.masked(prefix(i + 1))], priors) + for eta in etas: + post = rx.Problem([replace(c.masked(prefix(i)), weight=eta)], priors) + samples = run(post) # emcee or dynesty + ll_i = np.array([after.log_likelihood(s) - before.log_likelihood(s) for s in samples]) + loss[eta] -= ll_i.mean() # R-log-loss + +eta_hat = min(loss, key=loss.get) +final = rx.Problem([replace(c, weight=eta_hat)], priors) +``` + +Expected behaviour: + +- `replace(c, weight=eta)` and `c.masked(...)` share every comparison, term and + parameter with `c`, so no workspace is rebuilt across the `n × |η|` + problems and every problem has the same `names`. +- `after.log_likelihood(θ) − before.log_likelihood(θ)` is + `log p(y_i | y_= d2_obs) +``` + +Expected behaviour: + +- `chi2_of` is `problem.chi2` evaluated with the replicate in place of the + data; write it as `dataclasses.replace(d, y=y_rep)` and a rebuilt + problem, or from the compiled constraint's factor. A posterior p-value + near 0 or 1 flags misfit. +- For a Gaussian constraint with a fixed covariance the replicated + chi-squared is `χ²(n)`; with sampled covariance parameters it is not, and + the posterior predictive reference is the point. +- The pivoted Cholesky and Mahalanobis diagnostics of recipe 28 are this + check applied to a theory covariance. + +Reference: Gelman, Meng, Stern, *Posterior predictive assessment of model +fitness via realized discrepancies*, Statistica Sinica 6, 733 (1996). + +## 34. Prior and likelihood sensitivity by power-scaling + +*I want to know whether my posterior is driven by the prior, by the +likelihood, or by a conflict between them, without refitting.* + +```python +lp = np.array([problem.log_prior(s) for s in samples]) +ll = np.array([problem.log_likelihood(s) for s in samples]) +def reweighted(alpha, which): + logw = (alpha - 1) * (lp if which == "prior" else ll) + w = np.exp(logw - logsumexp(logw)) + return w # smooth with PSIS before trusting +for alpha in (0.99, 1.01): + for which in ("prior", "likelihood"): + w = reweighted(alpha, which) + shift = weighted_ecdf_distance(samples, w) # per column +``` + +Expected behaviour: + +- Sensitivity to both indicates prior-data conflict; to the prior alone, an + uninformative likelihood; to the likelihood alone, the benign case. +- In a hierarchical joint block only the hyperprior should be scaled. The + user's joint object must expose that term separately; the opaque + `logpdf` alone is not enough for this diagnostic. +- Weights are importance weights on existing draws; keep `alpha` close to + one and use Pareto-smoothed weights. + +Reference: Kallioinen, Paananen, Bürkner, Vehtari, *Detecting and +diagnosing prior and likelihood sensitivity with power-scaling*, Stat. +Comput. 34 (2024), arXiv:2107.14054. + +## 35. Simulation-based calibration of the sampler + +*Before trusting a chain, I want to check that the sampler recovers +parameters drawn from the prior when the data are simulated from the +model.* + +```python +ranks = [] +for theta0 in problem.sample_prior(n_sims, rng): + y_sim = rx.diagnostics.predictive_draws(problem, theta0[None], n_rep=1)[0] + d_sim = dataclasses.replace(d, y=comp.space.inverse(y_sim)) # back to physical units + p_sim = rx.Problem([rx.Constraint([rx.Comparison(d_sim, model)], terms=terms)], priors) + s = run(p_sim)[::thin][:L] + ranks.append((s < theta0).sum(0)) # one rank per column +ranks = np.array(ranks) # uniform on 0..L if correct +``` + +Expected behaviour: + +- Every rank histogram is uniform when the sampler is correct. An inverted + U means the computed posterior is too wide, a U too narrow, a skew a + bias. +- Chains must be thinned to roughly independent draws first, or spurious + boundary spikes appear. +- SBC validates the computation under the assumed model; it says nothing + about whether the model fits real data. That is recipe 33. + +Reference: Talts, Betancourt, Simpson, Vehtari, Gelman, *Validating +Bayesian inference algorithms with simulation-based calibration*, +arXiv:1804.06788. + +## 36. Emulator as the model, emulator variance as a term + +*My model is too expensive to run in the chain. I have a GP or PCA +emulator trained on a design of runs, and I want its predictive variance +in the likelihood.* + +```python +emu = rx.Model(lambda x, *theta: emulator.mean(theta), params) # x ignored: the grid is the design's +emu_var = rx.Term(lambda c, *theta: np.sqrt(emulator.var(theta)), params, kind="diag", on=comp) +c = rx.Constraint([rx.Comparison(d, emu)], terms=[emu_var, T.noise(log_eps)]) +``` + +Expected behaviour: + +- The term declares the *same* `Parameter` objects as the model, so it + receives the current `theta` and can evaluate the emulator variance + there. No special mechanism. +- Bayarri et al. recommend fixing emulator hyperparameters at their + estimates from the design runs (recipe 31 with T = 1) because emulator + uncertainty is usually dominated by calibration and bias uncertainty. +- The only full-posterior nuclear EDF calibration to 2015 replaced the + code by a GP response surface exactly this way. + +References: Higdon et al., J. Am. Stat. Assoc. 103, 570 (2008); McDonnell, +Schunck, Higdon, Sarich, Wild, Nazarewicz, Phys. Rev. Lett. 114, 122501 +(2015); Schunck et al., *Uncertainty quantification and propagation in +nuclear density functional theory*, Eur. Phys. J. A 51, 169 (2015); Bayarri +et al., Technometrics 49, 138 (2007). + +## 37. MAP and Laplace approximation + +*I want a quick Gaussian approximation to the posterior, and to know when +it is good enough.* + +```python +from scipy.optimize import minimize +res = minimize(lambda t: -problem.log_posterior(t), problem.sample_prior(1)[0], method="L-BFGS-B", + bounds=problem.bounds) +H = numerical_hessian(lambda t: -problem.log_posterior(t), res.x) +cov = np.linalg.inv(H) # Laplace covariance +``` + +Expected behaviour: + +- For a near-Gaussian posterior (a five-parameter optical potential with a + flat prior) the Laplace covariance reproduces the emcee uncertainties. + For a six-parameter potential the posterior is banana-shaped and it does + not; compare against a chain before reporting. +- This is the dominant uncertainty-propagation practice in nuclear DFT + (inverse Hessian at the optimum, propagated linearly). +- `problem.bounds` feeds the optimiser; the prior handles the rest. + +References: Pruitt, Lovell, Hebborn, Nunes, *The role of the likelihood for +elastic scattering uncertainty quantification*, arXiv:2403.00753; Schunck +et al., Eur. Phys. J. A 51, 169 (2015). + +## 38. Global error scale factor and unrecognised sources of uncertainty + +*Repeated measurements scatter more than their stated errors. I want a +global scale on the reported errors, or a fully correlated unknown +component per experimental technique.* + +```python +log_s = rx.Parameter("log_s", prior=stats.norm(0, 0.5)) +scaled = rx.Term(lambda c, ls: np.exp(ls) * comp.y_err, (log_s,), kind="diag", on=comp) # closes over the comparison's errors +c = rx.Constraint([comp], terms=[scaled], statistical=False) # s multiplies every stated error + +# USU: one unknown, fully correlated component per technique, shared across its datasets +log_delta = {tech: rx.Parameter(f"log_usu_{tech}") for tech in techniques} +usu = [T.offset(parameter=log_delta[tech], on=[comp for comp in comps if comp.data.meta["technique"] == tech]) + for tech in techniques] +``` + +Expected behaviour: + +- Under a Student-t likelihood only a modest scale is needed where least + squares needs a large one, because the tail absorbs the outliers. +- A global Birge-type rescaling inflates every point equally and is judged + poor evaluation practice; the targeted USU component is preferred, added + only when other explanations are exhausted. +- A USU component inside the fit shifts the evaluated means, not only the + widths, whenever more than one quantity is evaluated. It must be in the + covariance, not added afterwards, which is why it is a sampled term here. +- With `statistical=False` the scaled term *is* the diagonal; it closes + over `comp.y_err`, the comparison-space errors, so it is right under a + `space` transform too. + +References: Hanson, *Lessons about likelihood functions from nuclear +physics*, AIP Conf. Proc. 954 (2007), arXiv:0712.0021; Capote et al., +*Unrecognized sources of uncertainties (USU) in experimental nuclear data*, +Nucl. Data Sheets 163, 191 (2020), arXiv:1911.01825. + +## 39. Energy-dependent parameters and per-comparison model instances + +*A potential depth depends on energy through a few coefficients I want to +share across datasets at different energies.* + +```python +V0, V1 = rx.Parameter("V0", prior=stats.norm(50, 5)), rx.Parameter("V1", prior=stats.norm(-0.3, 0.1)) + +def depth_model(E): + return rx.Model(lambda x, v0, v1, *rest: potential(x, V=v0 + v1 * E, *rest), [V0, V1, *rest_params]) + +comps = [rx.Comparison(d, depth_model(d.meta["Elab"])) for d in datasets] +``` + +Expected behaviour: + +- One model instance per comparison, all sharing the coefficient objects, so + `problem.names` has one `V0` and one `V1`. +- Energy enters by closure at construction; nothing in the library reads + it. The same pattern gives energy-dependent systematic errors in a term + through `c.meta("Elab")` (recipe 22). +- A smooth energy dependence with more freedom is a discrepancy on a basis + (recipe 40) or a GP over energy (recipe 23). + +References: Schnabel, Capote, Koning, Brown, *Nuclear data evaluation with +Bayesian networks*, arXiv:2110.10322; Pruitt, Escher, Rahman, Phys. Rev. C +107, 014602 (2023). + +## 40. Discrepancy on a physically constrained basis + +*I know the shape the model defect can take, say a few Legendre modes in +angle, and want the discrepancy restricted to that basis.* + +```python +from scipy.special import eval_legendre +modes = [T.systematic(rx.Parameter(f"log_s{k}", prior=stats.norm(-3, 1)), + basis=lambda c, k=k: eval_legendre(k, np.cos(c.x)), on=comp) for k in range(1, 4)] +c_marg = rx.Constraint([comp], terms=modes) # marginalised: rank-3 covariance + +coeffs = [rx.Parameter(f"c{k}", prior=stats.norm(0, 0.1)) for k in range(1, 4)] +delta = rx.Model(lambda x, *cs: sum(ck * eval_legendre(k, np.cos(x)) for k, ck in enumerate(cs, 1)), coeffs) +c_samp = rx.Constraint([rx.Comparison(d, omp + delta)]) # sampled: mean correction +``` + +Expected behaviour: + +- Each mode is one rank-one term; the covariance is low rank and stays on + the structured path. +- The sampled form gives the coefficients' posterior directly; the + marginalised form gives their scales. Both confound with the model + parameters if the basis overlaps the model's own response, so put a real + prior on the amplitudes. +- Process-convolution and kernel bases are the same pattern with a + different `basis`. + +Reference: Higdon, Gattiker, Williams, Rightley, J. Am. Stat. Assoc. 103, +570 (2008). + +## 41. Correlated systematics between observables of one measurement + +*One experiment reports both a cross section and an analysing power, and +they share a normalisation or an angle calibration.* + +```python +comp_xs = rx.Comparison(d_xs, rx.reactions.ElasticXS("dXS/dA", *pot, params=p)) +comp_ay = rx.Comparison(d_ay, rx.reactions.ElasticXS("Ay", *pot, params=p)) +log_eta = rx.Parameter("log_eta", prior=stats.norm(-3, 1)) +c = rx.Constraint([comp_xs, comp_ay], terms=[T.normalization(log_eta, on=comp_xs), # the ratio is unaffected + T.systematic(log_dtheta, basis=dydtheta, on=[comp_xs, comp_ay])]) +``` + +Expected behaviour: + +- Two datasets, two comparisons, one constraint; the shared systematic is a + mode spanning both comparisons (case A of recipe 5). +- A normalisation error affects the cross section and not a ratio + observable; an angle-calibration error affects both through their + angular derivatives, which the basis supplies from `c.ym` and `c.x`. +- The multi-quantity extension of the Peelle treatment applies: build the + mode from predictions, not data. + +Reference: Neudecker, Frühwirth, Kawano, Leeb, *Adequate treatment of +correlated experimental data in nuclear data evaluations*, Nucl. Data Sheets +118, 364 (2014). + +## 42. The classic normal hierarchical model (eight schools) + +*Several groups each report an estimate `y_j` with a known standard error +`σ_j`. I believe the group effects `θ_j` are drawn from a common +distribution `N(μ, τ²)` and want to learn `μ`, `τ`, and the shrunken +`θ_j`.* + +```python +d = rx.Dataset(x=np.arange(J), y=estimates, y_err=std_errors) # x is the group index +mu = rx.Parameter("mu", prior=stats.norm(0, 25)) +log_tau = rx.Parameter("log_tau", prior=stats.norm(1, 1)) + +# 1. marginalised: integrate the theta_j out; y_j ~ N(mu, sigma_j^2 + tau^2) +c_marg = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, mu: np.full(len(x), mu), [mu]))], + terms=[T.noise(log_tau)]) +# theta_j afterwards, from the conditional normal at each draw (mu, tau): +# mean = (y_j / s_j^2 + mu / tau^2) / (1 / s_j^2 + 1 / tau^2), var = 1 / (1 / s_j^2 + 1 / tau^2) + +# 2. non-centred: theta_j = mu + tau * eta_j, eta_j ~ N(0, 1); marginal priors only +etas = [rx.Parameter(f"eta_{j}", prior=stats.norm(0, 1)) for j in range(J)] +school = rx.Model(lambda x, mu, lt, *eta: mu + np.exp(lt) * np.asarray(eta), [mu, log_tau, *etas]) +c_nc = rx.Constraint([rx.Comparison(d, school)]) + +# 3. centred: theta_j as parameters, hyperprior as a joint block including mu, tau (recipe 24) +thetas = [rx.Parameter(f"theta_{j}") for j in range(J)] +c_c = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, *th: np.asarray(th), thetas))]) +problem_c = rx.Problem([c_c], priors=[(thetas + [mu, log_tau], SchoolHierarchy())]) +``` + +Expected behaviour: + +- All three spellings give the same posterior for `mu` and `tau`. The + posterior of `tau` piles up near zero, as in the book, and the `theta_j` + shrink toward `mu` as `tau` falls. +- The marginalised form has two columns and is the design's own + philosophy: a Gaussian latent belongs in the covariance. The + non-centred form has `J + 2` columns, all with marginal priors, so + `prior_transform` is available with no joint block. The centred form + has the funnel geometry the book warns about and samples worst with + emcee or dynesty. +- A parameter attached only to a fully masked comparison is sampled from its + prior. Holding out one school therefore leaves its `eta_j` in the + chain, driven by `tau` alone, so `complement()` and `predictive_draws` + give the predictive for a new group with no extra code. +- Meta-analysis on log-odds with per-study standard errors is the same + structure. The beta-binomial rat-tumour example is not expressible: a + binomial likelihood is not elliptical (see the closing section). A + normal approximation with `y_err = sqrt(n_j p_j (1 - p_j))` as a + prediction-scaled `diag` term is expressible but is not the book's + model. + +The notebook `hierarchical_calibration` (design document §7) is the +parameter-space version of this hierarchy: per-dataset deviation vectors on +the physics parameters with a hyperprior on their spread, used to repair a +misspecified energy dependence. + +Reference: Gelman, Carlin, Stern, Dunson, Vehtari, Rubin, *Bayesian Data +Analysis*, 3rd ed., CRC Press (2013), Chapter 5. + +--- + +## What this API does not express + +Each item names the assumption that breaks, the nearest workaround, and +the size of the addition that would lift it. + +- **Non-elliptical likelihoods.** Poisson counts, censored points and upper + limits, and two-component good/bad mixtures `(1 − β) N + β t` (Hanson + 2007) are not functionals of `(d2, logdet, n)`. Workaround: none that is + faithful. Addition: a `Likelihood` that receives the residual and the + factor, plus a second evaluation path in `CompiledConstraint`; about 100 + lines. +- **Chain-dependent masks.** KDUQ's iterative rejection of points more + than 3σ from the current model, updated during the walk, needs a mask + that depends on chain state. Masks are compiled. Workaround: an outer + loop of problems with the mask refit between runs. Addition refused by + design: it is mutable state inside a spec. +- **Per-point latent variables.** Errors-in-variables in `x` (Berkson), + explicit latent function values on a mesh (Schnabel et al. 2021), or a + sampled per-point scale in a scale mixture. Expressible in principle as + one `Parameter` per point, but the dimension defeats the drivers. + Addition: latent nodes with analytic marginalisation; large. +- **Per-point log-likelihood factors** for PSIS-LOO and WAIC under a + correlated covariance. Workaround: the prefix-difference of recipe 25, + one problem per point. Addition: + `CompiledConstraint.pointwise_log_likelihood` from the factor; about 30 + lines. +- **Input-dependent mixture likelihoods.** Bayesian model mixing with a + per-point two-component Gaussian likelihood (Semposki et al. 2022). Mean + mixing is a `Model` (recipe 29); the likelihood form is the first bullet. +- **Correlation across constraints.** By construction. Merge the + constraints. +- **A sampled tempering exponent.** `weight` is a float by type; a + sampled `η` is not a coherent posterior. SafeBayes chooses it outside the + sampler (recipe 25). +- **Nonlinear, non-pointwise comparison maps.** `space` is pointwise so + the delta method and the log-Jacobian stay exact. A linear projection is + preprocessing (recipe 20); a nonlinear feature of the whole vector would + need a full Jacobian. Not planned. +- **Kronecker-structured covariances.** A separable GP over energy and + angle on a common grid could factor as a Kronecker product; real data + share no grid, so the dense path is used (recipe 23). Addition: a fourth + term kind; not planned until a case needs it. +- **Joint integration over emulator hyperparameters** alongside + calibration. Bayarri et al. recommend fixing them; not a gap worth + filling. From f13abba179fa6991b0e8467a825d68603190df72 Mon Sep 17 00:00:00 2001 From: beykyle Date: Thu, 10 Sep 2026 17:14:15 -0400 Subject: [PATCH 24/24] Trim four recipes and renumber the rest Remove the BUQEYE truncation covariance, model averaging and mixing, the realised-discrepancy posterior predictive check and power-scaling sensitivity recipes for brevity; renumber 30-42 to 28-38 and fix every cross-reference in the design document's capability map, milestones and notebook mapping. --- docs/groundup_design.md | 57 ++++++------- docs/recipes.md | 176 ++++------------------------------------ 2 files changed, 42 insertions(+), 191 deletions(-) diff --git a/docs/groundup_design.md b/docs/groundup_design.md index 4dcdb56..fb9ce02 100644 --- a/docs/groundup_design.md +++ b/docs/groundup_design.md @@ -696,21 +696,17 @@ rewrite: a capability is done when its row has a test. | discrepancy correlated across energies: GP over (E, θ) (new) | one `matrix` `Term` with `on=comps` building inputs from `c.meta` and `c.x`; dense path | test_covariance (dense fallback equals hand-built product kernel) | | unaccounted-for model error per data type, KDUQ (new, reference) | `model_error(delta_T, averaging=True, on=b)` with one `delta_T` per type; the `k/N` democratic and per-type federal scalings are `Constraint(weight=)`; recipe 26 | test_terms (shared object gives one column per type) | | Peelle's Pertinent Puzzle avoidance (new, reference) | `normalization()` reads `c.ym`; the `t0` variant as a constant `mode`; recipe 27 | test_terms (data-built mode reproduces the `1/(1+n s²)` bias; prediction-built does not) | -| EFT truncation-error GP with known convergence pattern, BUQEYE (new, reference) | `matrix` `Term` from `c.meta("y_ref")`, `c.meta("Q")`, `c.x`; rank-one form via `systematic`; recipe 28 | test_covariance (dense equals the closed-form covariance) | -| Bayesian model averaging / mixing, domain correction (new, reference) | one `Problem` per model, `logz_summary`, mixed `predictive_draws`; mean mixing as a `Model`; recipe 29 | test_diagnostics | -| stacking by leave-one-dataset-out (new, reference) | `Constraint.masked` dropping a block, `heldout_log_predictive`; recipe 30 | test_diagnostics | -| cut / modular posterior by multiple imputation (new, reference) | stage-1 `Problem`, per-draw stage-2 `Problem` with the module fixed by closure; per-module `weight`; recipe 31 | test_problem (stage-1 marginal unchanged) | -| leave-one-experiment-out prediction (new, reference) | block masks, `complement`, `predictive_draws`, `coverage_curve`; recipe 32 | test_diagnostics | -| posterior predictive check with realised discrepancy (new, reference) | `problem.chi2` at each draw vs replicated data; recipe 33 | test_diagnostics | -| prior / likelihood power-scaling sensitivity (new, reference) | importance weights from `log_prior`, `log_likelihood` on existing samples; recipe 34 | test_problem (`log_prior` on samples) | -| simulation-based calibration of the sampler (new, reference) | `sample_prior`, `predictive_draws`, `dataclasses.replace(d, y=)`; recipe 35 | test_problem (rank uniformity on the linear problem) | -| emulator as `Model`, emulator variance as a `diag` term sharing the model's parameters (new, reference) | recipe 36 | test_terms (a term declaring model parameters receives them) | -| MAP + Laplace (new, reference) | `scipy.optimize` on `log_posterior`, `problem.bounds`; recipe 37 | test_problem | -| global error scale and USU modes (new, reference) | `diag` term scaling `c.meta("y_err")` with `statistical=False`; `offset(parameter=, on=blocks_of_technique)`; recipe 38 | test_terms | -| energy-dependent parameters (new, reference) | per-block `Model` instances closing over `meta`, shared coefficient objects; recipe 39 | test_model | -| discrepancy on a physical basis, Legendre (new, reference) | `systematic` modes or `omp + Model(basis_sum)`; recipe 40 | test_terms | -| correlated systematics between observables of one measurement (new, reference) | two blocks, one constraint, spanning mode; recipe 41 | test_covariance | -| classic normal hierarchical model, BDA3 ch. 5 (new, reference) | marginalised as `noise(log_tau)`, non-centred as a `Model` over `[mu, log_tau, *etas]`, centred as a joint block; recipe 42 | test_problem (marginalised and non-centred agree on `mu, tau`; a parameter on a fully masked block is sampled from its prior) | +| stacking by leave-one-dataset-out (new, reference) | `Constraint.masked` dropping a block, `heldout_log_predictive`; recipe 28 | test_diagnostics | +| cut / modular posterior by multiple imputation (new, reference) | stage-1 `Problem`, per-draw stage-2 `Problem` with the module fixed by closure; per-module `weight`; recipe 29 | test_problem (stage-1 marginal unchanged) | +| leave-one-experiment-out prediction (new, reference) | block masks, `complement`, `predictive_draws`, `coverage_curve`; recipe 30 | test_diagnostics | +| simulation-based calibration of the sampler (new, reference) | `sample_prior`, `predictive_draws`, `dataclasses.replace(d, y=)`; recipe 31 | test_problem (rank uniformity on the linear problem) | +| emulator as `Model`, emulator variance as a `diag` term sharing the model's parameters (new, reference) | recipe 32 | test_terms (a term declaring model parameters receives them) | +| MAP + Laplace (new, reference) | `scipy.optimize` on `log_posterior`, `problem.bounds`; recipe 33 | test_problem | +| global error scale and USU modes (new, reference) | `diag` term scaling `c.meta("y_err")` with `statistical=False`; `offset(parameter=, on=blocks_of_technique)`; recipe 34 | test_terms | +| energy-dependent parameters (new, reference) | per-block `Model` instances closing over `meta`, shared coefficient objects; recipe 35 | test_model | +| discrepancy on a physical basis, Legendre (new, reference) | `systematic` modes or `omp + Model(basis_sum)`; recipe 36 | test_terms | +| correlated systematics between observables of one measurement (new, reference) | two blocks, one constraint, spanning mode; recipe 37 | test_covariance | +| classic normal hierarchical model, BDA3 ch. 5 (new, reference) | marginalised as `noise(log_tau)`, non-centred as a `Model` over `[mu, log_tau, *etas]`, centred as a joint block; recipe 38 | test_problem (marginalised and non-centred agree on `mu, tau`; a parameter on a fully masked block is sampled from its prior) | | SafeBayes: learn the tempering exponent (new, reference) | driver loop over `replace(c, weight=η)` and `c.masked(prefix)`; next-point density as a log-likelihood difference; recipe 25 | test_problem (`replace` keeps names; `ll(prefix i+1) − ll(prefix i)` equals the Gaussian conditional) | | hyperprior: per-dataset parameters with a sampled spread (new) | joint block `(children + [hyper], obj)` with `logpdf` and `prior_transform` | test_problem (children uncovered without the block; `prior_transform` round trip) | | GP discrepancy in x / in momentum transfer with amplitude (gp_discrepancy, TestStudyForms) | `kernel(k, on=b, coords=lambda x: momentum_transfer(x, k), amplitude=..., amplitude_params=...)` | test_terms::TestStudyForms | @@ -850,7 +846,7 @@ rxmc/ __init__.py elastic.py ~170 ias.py ~120 test/ unit tests, one file per module, plus test_regression.py -test/recipes/ one file per recipe in docs/recipes.md (~42), the acceptance suite; +test/recipes/ one file per recipe in docs/recipes.md (~38), the acceptance suite; oracle.py holds the closed-form linear-Gaussian posterior used by the fast tier examples/ 9 notebooks (§7) docs/ design.md rewritten from this document once the code lands @@ -881,7 +877,7 @@ is driven by emcee or dynesty. | `robust_likelihoods` | robust_likelihoods | emcee | Student-t vs Gaussian; ν bounded on the `Parameter` | | `measurement_to_calibration` | measurement_to_calibration + 30s_optical_potential_calibration + the tempering/coverage section of overconfidence | dynesty | `from_measurement`, `reported_terms`, the singular-covariance error, `Constraint(weight=)`, `coverage_curve` | | `alpha_ca_error_model_comparison` | **new** (the `design.md` recipe table) | dynesty | log space, `Parameter(prior=)`, masks, `complement`, `heldout_log_predictive`, `logz_summary` / `compare_logz` with `log_jacobian`, shared noise (B) and coupled normalisation (A) across two datasets, the bbb shim shown but not run | -| `hierarchical_calibration` | **new** (recipes 24, 39, 42) | dynesty | hierarchy on the physics parameters; see below | +| `hierarchical_calibration` | **new** (recipes 24, 35, 38) | dynesty | hierarchy on the physics parameters; see below | **`hierarchical_calibration` in detail.** The truth is `y = a0(E) + a1(E) x + a2(E) x²`, measured by J synthetic datasets at known @@ -897,7 +893,7 @@ bumps. Three fits of the same data: learned spread (a full covariance through an LKJ-style joint block is the named extension). -Mechanics: one `Model` per block closing over `E_j` (recipe 39). The +Mechanics: one `Model` per block closing over `E_j` (recipe 35). The held-out block is fully masked, so its `η_new` is sampled from the prior only, driven by `τ`; `complement()`, `predictive_draws` and `heldout_log_predictive` then score the new energy with no extra code. The @@ -991,28 +987,27 @@ recipe test it unlocks pass. acceptance suite starts here, all on synthetic data with generic models. Recipe tests unlocked: - core: 1, 2, 4, 5, 6, 8, 9, 10, 11, 12, 13, 16, 19, 20, 21; - - hierarchy and sharing: 22, 23, 24, 42; + - hierarchy and sharing: 22, 23, 24, 38; - driver loops needing only `log_likelihood`, `log_prior`, - `sample_prior`: 25 (SafeBayes), 26 (KDUQ weights), 27 (Peelle), 31 - (cut posterior), 34 (power-scaling), 36 (an emulator term sees the - model's parameters), 37 (MAP and Laplace), 38, 39, 40; - - 28 (the BUQEYE covariance from `c.meta`) with synthetic `y_ref`, `Q`. + `sample_prior`: 25 (SafeBayes), 26 (KDUQ weights), 27 (Peelle), 29 + (cut posterior), 32 (an emulator term sees the model's parameters), + 33 (MAP and Laplace), 34, 35, 36. Regression pins carried here: `1.195784087817536`, the old-covariance equivalence, `ll(fit) + ll(held) == ll(full)`, and "a parameter on a - fully masked block is sampled from its prior", which recipe 42 and the + fully masked block is sampled from its prior", which recipe 38 and the hierarchical notebook rely on. 5. **`reactions/elastic`, `reactions/ias`, `from_measurement`.** Ported: both Rutherford conversion directions, `TestSolverSettingsForwarding`, real-solve smoke tests, the Lane-term IAS check. Recipe tests - unlocked: 3, 14, 15, 41; the reaction variants of 7 and 22 + unlocked: 3, 14, 15, 37; the reaction variants of 7 and 22 (momentum-transfer coordinates, an energy-running amplitude) run against a patched solver. 6. **`diagnostics`, `predictive`.** Ported: GP-versus-sklearn, `predictive_draws` covariance recovery, `heldout_log_predictive`, `logz_summary` and `compare_logz`. Recipe tests unlocked: 7 - (`total_predictive_band` finds the kernel columns itself), 17, 18, 29, - 30, 32, 33, 35. + (`total_predictive_band` finds the kernel columns itself), 17, 18, 28, + 30, 31. 7. **CI wiring.** The heading-to-file check between `recipes.md` and `test/recipes/`; `pytest test` runs both suites; the fast tier must finish in a few minutes on a laptop (patched solvers, small `J` and @@ -1020,10 +1015,10 @@ recipe test it unlocks pass. 8. **Notebooks 1–9.** Each notebook names the recipes it is the tutorial for: `linear_calibration` (1, 17); `error_models` (2, 4, 5, 19); `normalization_and_covariance_structure` (3, 6, 27); - `correlated_observations` (5, 41); `gp_discrepancy` (7, 8, 40); - `robust_likelihoods` (9, 38); `measurement_to_calibration` (12, 14, + `correlated_observations` (5, 37); `gp_discrepancy` (7, 8, 36); + `robust_likelihoods` (9, 34); `measurement_to_calibration` (12, 14, 15, 16, 21, 26); `alpha_ca_error_model_comparison` (10, 11, 13, 18, - 25); `hierarchical_calibration` (22, 24, 39, 42, and 32 for the + 25); `hierarchical_calibration` (22, 24, 35, 38, and 30 for the held-out energy). A recipe without a notebook is fine; a notebook must cite at least one recipe. 9. **`design.md` and README** rewritten from this document. @@ -1044,7 +1039,7 @@ preference for assertions that need no sampler at all. linear model and Gaussian terms. Tests compare `log_posterior` and `predictive_draws` statistics against it without sampling. This covers the coverage-type claims of recipes 1, 6, 12, 17, 26 and the - marginalised form of 42 exactly. + marginalised form of 38 exactly. - **Seeded short chains, qualitative assertions.** Ordering claims ("case 2 under-covers and case 3 recovers"; "the Student-t covers the truth and the Gaussian does not") use a seeded 16-walker, few-hundred-step diff --git a/docs/recipes.md b/docs/recipes.md index ba241d1..3eaa9f6 100644 --- a/docs/recipes.md +++ b/docs/recipes.md @@ -748,92 +748,7 @@ Neudecker, Leeb, *Peelle's Pertinent Puzzle and its solution*, EPJ Web Conf. 27, 00008 (2012); Ball et al. (NNPDF), *Fitting parton distribution data with multiplicative normalization uncertainties*, JHEP 05 (2010) 075. -## 28. EFT truncation error as a correlated GP with a known convergence pattern - -*My model is an order-`k` EFT prediction. I know the expansion parameter -`Q(x)` and a reference scale `y_ref(x)`, and I want the omitted orders as a -correlated theory covariance added to the experimental one.* - -```python -cbar = rx.Parameter("cbar", prior=stats.invgamma(3, scale=1)) # or fixed from lower orders -ell = rx.Parameter("ell", prior=stats.lognorm(0.5)) - -def truncation(c, cbar, ell): - yr, Q = c.meta("y_ref"), c.meta("Q") - R = Matern(ell, nu=2.5)(c.x[:, None]) - return cbar**2 * np.outer(yr, yr) * np.outer(Q, Q) ** (k + 1) / (1 - np.outer(Q, Q)) * R - -sig_th = rx.Term(truncation, (cbar, ell), kind="matrix", on=comp) -c = rx.Constraint([comp], terms=[sig_th]) # Σ = Σ_exp + Σ_th - -# the rank-one, next-order-only form (one naturalness-distributed coefficient) -sig_next = T.systematic(log_c, basis=lambda c: c.meta("y_ref") * c.meta("Q") ** (k + 1), on=comp) -``` - -Expected behaviour: - -- Different observables are conditionally independent given the LECs, so - one constraint per observable and shared `cbar`, `ell` across them. -- `cbar` and `ell` may be fixed at values learned from the known - lower-order coefficients, or sampled; with a conjugate prior on `cbar²` - the marginal over it is a Student-t process, which `rx.StudentT()` does - not reproduce exactly (it applies one radial factor to the whole - residual, including the experimental part). Sampling `cbar` is the - faithful spelling. -- The dense matrix equals the closed-form BUQEYE covariance; the pivoted - Cholesky and Mahalanobis diagnostics of the paper are recipe 33 applied to - this term. - -References: Melendez, Furnstahl, Phillips, Pratola, Wesolowski, -*Quantifying correlated truncation errors in effective field theory*, Phys. -Rev. C 100, 044001 (2019), arXiv:1904.10581; Phillips et al., *Get on the -BAND wagon*, J. Phys. G 48, 072001 (2021) for the rank-one form. - -## 29. Bayesian model averaging and mixing across models - -*I have several models of the same observable. I want evidence-weighted -predictions, and I want to handle models that only cover part of the data.* - -```python -problems = {name: rx.Problem([rx.Constraint([rx.Comparison(d, m)], terms=[T.noise(log_eps), gp])], priors) - for name, m in models.items()} -runs = {name: run_dynesty(p) for name, p in problems.items()} -logz = np.array([runs[n].logz[-1] for n in models]) -w = np.exp(logz - logz.max()); w /= w.sum() # p(M_k | y) with uniform prior -draws = np.concatenate([rx.diagnostics.predictive_draws(problems[n], runs[n].samples_equal()[:int(w_k * N)]) - for n, w_k in zip(models, w)]) # the BMA predictive - -# domain correction for a model covering only a subset: score its uncovered -# points under the other models' posteriors -uncovered = rx.Problem([c.masked(cover_k).complement()], priors) -lp = rx.diagnostics.log_posterior_predictive(rx.diagnostics.heldout_log_predictive(uncovered, samples_other)) - -# input-dependent *mean* mixing is a Model -mix = rx.Model(lambda x, a, b, *p: alpha(x, a, b) * f1(x, *p) + (1 - alpha(x, a, b)) * f2(x, *p), [a, b, *p]) -``` - -Expected behaviour: - -- Each model is its own `Problem`; parameters shared across models by - object are one column in each chain and are not mixed across problems. -- The BMA posterior-mean predictor has posterior mean squared error no - larger than any convex combination of the individual model means, with - equality at the evidence weights. -- Setting the uncovered-data factor to one rewards models that withhold - predictions at hard points; the corrective factor above removes that. -- Mixing weights that depend on `x` (Bayesian model mixing) are - expressible for the *mean*; a per-point two-component mixture - *likelihood* is not (see the closing section). - -References: Kejzlar, Neufcourt, Maiti, Viens, *Bayesian averaging of -computer models with domain discrepancies: a nuclear physics perspective*, -arXiv:1904.04793; Neufcourt, Cao, Nazarewicz, Olsen, Viens, *Neutron drip -line in the Ca region from Bayesian model averaging*, Phys. Rev. Lett. 122, -062502 (2019), arXiv:1901.07632; Semposki, Furnstahl, Phillips, -*Interpolating between small- and large-g expansions using Bayesian model -mixing*, Phys. Rev. C 106, 044002 (2022), arXiv:2206.04116. - -## 30. Stacking by leave-one-dataset-out +## 28. Stacking by leave-one-dataset-out *Evidence weights assume the true model is among my candidates. I would rather weight models by how well they predict each dataset when it is left @@ -869,7 +784,7 @@ Bayesian predictive distributions*, Bayesian Analysis 13, 917 (2018); Vehtari, Gelman, Gabry, *Practical Bayesian model evaluation using leave-one-out cross-validation and WAIC*, Stat. Comput. 27, 1413 (2017). -## 31. Cut (modular) posterior by multiple imputation +## 29. Cut (modular) posterior by multiple imputation *One module of my model, say a systematic-error parameter or a GP hyperparameter, should be learned from its own data only and not be @@ -909,7 +824,7 @@ References: Plummer, *Cuts in Bayesian graphical models*, Stat. Comput. 25, learning in models made of modules*, arXiv:1708.08719; Bayarri et al., *A framework for validation of computer models*, Technometrics 49, 138 (2007). -## 32. Leave-one-experiment-out prediction +## 30. Leave-one-experiment-out prediction *I want to know whether the calibrated model, with its discrepancy, predicts an experiment it was not fit to, and with what tolerance.* @@ -938,67 +853,7 @@ References: Higdon, Gattiker, Williams, Rightley, *Computer model calibration using high-dimensional output*, J. Am. Stat. Assoc. 103, 570 (2008); Bayarri et al., Technometrics 49, 138 (2007). -## 33. Posterior predictive checks with a realised discrepancy - -*I want a goodness-of-fit measure that depends on the parameters, such as -the chi-squared at each posterior draw, and a reference distribution for -it.* - -```python -d2_obs = np.array([problem.chi2(s) for s in samples]) -rep = rx.diagnostics.predictive_draws(problem, samples, n_rep=1) # one replicate per draw -d2_rep = np.array([chi2_of(problem, s, y_rep) for s, y_rep in zip(samples, rep)]) -p_value = np.mean(d2_rep >= d2_obs) -``` - -Expected behaviour: - -- `chi2_of` is `problem.chi2` evaluated with the replicate in place of the - data; write it as `dataclasses.replace(d, y=y_rep)` and a rebuilt - problem, or from the compiled constraint's factor. A posterior p-value - near 0 or 1 flags misfit. -- For a Gaussian constraint with a fixed covariance the replicated - chi-squared is `χ²(n)`; with sampled covariance parameters it is not, and - the posterior predictive reference is the point. -- The pivoted Cholesky and Mahalanobis diagnostics of recipe 28 are this - check applied to a theory covariance. - -Reference: Gelman, Meng, Stern, *Posterior predictive assessment of model -fitness via realized discrepancies*, Statistica Sinica 6, 733 (1996). - -## 34. Prior and likelihood sensitivity by power-scaling - -*I want to know whether my posterior is driven by the prior, by the -likelihood, or by a conflict between them, without refitting.* - -```python -lp = np.array([problem.log_prior(s) for s in samples]) -ll = np.array([problem.log_likelihood(s) for s in samples]) -def reweighted(alpha, which): - logw = (alpha - 1) * (lp if which == "prior" else ll) - w = np.exp(logw - logsumexp(logw)) - return w # smooth with PSIS before trusting -for alpha in (0.99, 1.01): - for which in ("prior", "likelihood"): - w = reweighted(alpha, which) - shift = weighted_ecdf_distance(samples, w) # per column -``` - -Expected behaviour: - -- Sensitivity to both indicates prior-data conflict; to the prior alone, an - uninformative likelihood; to the likelihood alone, the benign case. -- In a hierarchical joint block only the hyperprior should be scaled. The - user's joint object must expose that term separately; the opaque - `logpdf` alone is not enough for this diagnostic. -- Weights are importance weights on existing draws; keep `alpha` close to - one and use Pareto-smoothed weights. - -Reference: Kallioinen, Paananen, Bürkner, Vehtari, *Detecting and -diagnosing prior and likelihood sensitivity with power-scaling*, Stat. -Comput. 34 (2024), arXiv:2107.14054. - -## 35. Simulation-based calibration of the sampler +## 31. Simulation-based calibration of the sampler *Before trusting a chain, I want to check that the sampler recovers parameters drawn from the prior when the data are simulated from the @@ -1023,13 +878,14 @@ Expected behaviour: - Chains must be thinned to roughly independent draws first, or spurious boundary spikes appear. - SBC validates the computation under the assumed model; it says nothing - about whether the model fits real data. That is recipe 33. + about whether the model fits real data; that is the posterior predictive + coverage check of recipe 17. Reference: Talts, Betancourt, Simpson, Vehtari, Gelman, *Validating Bayesian inference algorithms with simulation-based calibration*, arXiv:1804.06788. -## 36. Emulator as the model, emulator variance as a term +## 32. Emulator as the model, emulator variance as a term *My model is too expensive to run in the chain. I have a GP or PCA emulator trained on a design of runs, and I want its predictive variance @@ -1047,7 +903,7 @@ Expected behaviour: receives the current `theta` and can evaluate the emulator variance there. No special mechanism. - Bayarri et al. recommend fixing emulator hyperparameters at their - estimates from the design runs (recipe 31 with T = 1) because emulator + estimates from the design runs (recipe 29 with T = 1) because emulator uncertainty is usually dominated by calibration and bias uncertainty. - The only full-posterior nuclear EDF calibration to 2015 replaced the code by a GP response surface exactly this way. @@ -1058,7 +914,7 @@ Schunck, Higdon, Sarich, Wild, Nazarewicz, Phys. Rev. Lett. 114, 122501 nuclear density functional theory*, Eur. Phys. J. A 51, 169 (2015); Bayarri et al., Technometrics 49, 138 (2007). -## 37. MAP and Laplace approximation +## 33. MAP and Laplace approximation *I want a quick Gaussian approximation to the posterior, and to know when it is good enough.* @@ -1085,7 +941,7 @@ References: Pruitt, Lovell, Hebborn, Nunes, *The role of the likelihood for elastic scattering uncertainty quantification*, arXiv:2403.00753; Schunck et al., Eur. Phys. J. A 51, 169 (2015). -## 38. Global error scale factor and unrecognised sources of uncertainty +## 34. Global error scale factor and unrecognised sources of uncertainty *Repeated measurements scatter more than their stated errors. I want a global scale on the reported errors, or a fully correlated unknown @@ -1121,7 +977,7 @@ physics*, AIP Conf. Proc. 954 (2007), arXiv:0712.0021; Capote et al., *Unrecognized sources of uncertainties (USU) in experimental nuclear data*, Nucl. Data Sheets 163, 191 (2020), arXiv:1911.01825. -## 39. Energy-dependent parameters and per-comparison model instances +## 35. Energy-dependent parameters and per-comparison model instances *A potential depth depends on energy through a few coefficients I want to share across datasets at different energies.* @@ -1143,13 +999,13 @@ Expected behaviour: it. The same pattern gives energy-dependent systematic errors in a term through `c.meta("Elab")` (recipe 22). - A smooth energy dependence with more freedom is a discrepancy on a basis - (recipe 40) or a GP over energy (recipe 23). + (recipe 36) or a GP over energy (recipe 23). References: Schnabel, Capote, Koning, Brown, *Nuclear data evaluation with Bayesian networks*, arXiv:2110.10322; Pruitt, Escher, Rahman, Phys. Rev. C 107, 014602 (2023). -## 40. Discrepancy on a physically constrained basis +## 36. Discrepancy on a physically constrained basis *I know the shape the model defect can take, say a few Legendre modes in angle, and want the discrepancy restricted to that basis.* @@ -1179,7 +1035,7 @@ Expected behaviour: Reference: Higdon, Gattiker, Williams, Rightley, J. Am. Stat. Assoc. 103, 570 (2008). -## 41. Correlated systematics between observables of one measurement +## 37. Correlated systematics between observables of one measurement *One experiment reports both a cross section and an analysing power, and they share a normalisation or an angle calibration.* @@ -1206,7 +1062,7 @@ Reference: Neudecker, Frühwirth, Kawano, Leeb, *Adequate treatment of correlated experimental data in nuclear data evaluations*, Nucl. Data Sheets 118, 364 (2014). -## 42. The classic normal hierarchical model (eight schools) +## 38. The classic normal hierarchical model (eight schools) *Several groups each report an estimate `y_j` with a known standard error `σ_j`. I believe the group effects `θ_j` are drawn from a common @@ -1295,7 +1151,7 @@ the size of the addition that would lift it. lines. - **Input-dependent mixture likelihoods.** Bayesian model mixing with a per-point two-component Gaussian likelihood (Semposki et al. 2022). Mean - mixing is a `Model` (recipe 29); the likelihood form is the first bullet. + mixing is a `Model` (`w(x; θ) f1 + (1 − w) f2`); the likelihood form is the first bullet. - **Correlation across constraints.** By construction. Merge the constraints. - **A sampled tempering exponent.** `weight` is a float by type; a