tdanalysis 1.0.0__py3-none-any.whl

tdanalysis/_compat.py

@@ -0,0 +1,173 @@
+"""Model base class, vendored so an installed copy needs no git dependency.
+
+``mcsamplers`` (https://gitlab.com/vaishakp/parameter-estimation) is not on
+PyPI, and PyPI refuses any distribution whose metadata carries a PEP 508 direct
+URL reference -- extras included.  So a released ``tdanalysis`` cannot declare
+it, and declaring nothing produced the failure this file exists to remove: the
+package imported fine and then died on ``ModuleNotFoundError: 'mcsamplers'`` at
+the first likelihood.
+
+The whole surface actually used was one class, imported identically at every
+site::
+
+    from mcsamplers.model import Model
+
+so it is reproduced here rather than depended on.  Same author, same terms as
+the rest of the package (see NOTICE.md).  ``mcsamplers``' samplers are NOT
+vendored -- only the model contract they call.  Install ``mcsamplers`` itself if
+you want to sample with it; this class stays interface-compatible with it, and
+an installed ``mcsamplers`` is preferred at import time when present.
+
+The contract, unchanged: a model owns ``xdata``/``ydata``, an initial guess, and
+a dict of ``{name: (min, max)}`` uniform priors.  Samplers work in REDUCED
+coordinates -- the unit cube ``[0, 1]^ndim`` -- and the ``*_reduced`` methods
+push a reduced point forward into physical parameters before delegating.
+Subclasses implement ``evaluate_logliklihood`` (spelling preserved).
+"""
+from __future__ import annotations
+
+from abc import ABC
+from collections import namedtuple
+
+import numpy as np
+
+try:                                    # a real mcsamplers install wins
+    from mcsamplers.model import Model  # noqa: F401
+    _VENDORED = False
+except ImportError:
+    _VENDORED = True
+
+__all__ = ["Model", "Uniform", "pushforward_parameter",
+           "pushforward_all_parameters", "vendored"]
+
+#: Uniform prior over ``[min, max]`` for one named parameter.
+Uniform = namedtuple("Uniform", ["name", "min", "max"])
+
+
+def vendored() -> bool:
+    """True when this module's own ``Model`` is in use, not ``mcsamplers``'."""
+    return _VENDORED
+
+
+def pushforward_parameter(X, x_prior):
+    """Map ``X`` in ``[0, 1]`` onto ``[x_prior.min, x_prior.max]``."""
+    return x_prior.min + X * (x_prior.max - x_prior.min)
+
+
+def pushforward_all_parameters(reduced, parameter_priors):
+    """Unit cube -> physical parameters, columnwise.
+
+    Accepts either a single point or a ``(n, ndim)`` batch; the scalar case is
+    promoted and squeezed back, matching the upstream behaviour that several
+    callers rely on.
+    """
+    try:
+        parameters = np.zeros(reduced.shape)
+    except AttributeError:
+        parameters = np.array([0])
+        reduced = np.array([reduced])
+
+    for idx, (p, prior) in enumerate(zip(reduced.T, parameter_priors)):
+        parameters[..., idx] = pushforward_parameter(p, prior)
+
+    return parameters
+
+
+if _VENDORED:
+
+    class Model(ABC):                                  # noqa: F811
+        """Parameter-estimation model over uniform priors.
+
+        Interface-compatible with ``mcsamplers.model.Model``, including the
+        ``liklihood`` spelling, which is load-bearing: the samplers call these
+        names.
+        """
+
+        def __init__(self, xdata, ydata, initial_guess,
+                     parameter_priors_dict, truths=None):
+            self.xdata = xdata
+            self.ydata = ydata
+            self.initial_guess = initial_guess
+            self.parameter_priors_dict = parameter_priors_dict
+            self.truths = truths
+            self.initialize_parameter_priors()
+
+            self.metadata = {
+                "xdata": xdata,
+                "ydata": ydata,
+                "initial_guess": initial_guess,
+                "parameter_priors_dict": parameter_priors_dict,
+                "truths": truths,
+            }
+
+        # ---- pickling -------------------------------------------------
+        # ``parameter_priors`` is a list of namedtuples built at construction;
+        # it is dropped and rebuilt rather than pickled, so a subclass that
+        # extends __getstate__ keeps working.
+
+        def __getstate__(self):
+            state_rep = self.__dict__.copy()
+            state_rep.pop("parameter_priors", None)
+            return state_rep
+
+        def __setstate__(self, other_state):
+            self.__dict__.update(other_state)
+            self.initialize_parameter_priors()
+
+        def initialize_parameter_priors(self):
+            self.parameter_priors = [
+                Uniform(name, rng[0], rng[1])
+                for name, rng in self.parameter_priors_dict.items()
+            ]
+
+        # ---- likelihood ------------------------------------------------
+
+        def evaluate_logliklihood(self, parameters):
+            raise NotImplementedError
+
+        def evaluate(self, parameters):
+            raise NotImplementedError
+
+        def evaluate_liklihood(self, parameters):
+            return np.exp(self.evaluate_logliklihood(parameters))
+
+        def evaluate_logliklihood_reduced(self, reduced_parameters):
+            return self.evaluate_logliklihood(
+                pushforward_all_parameters(reduced_parameters,
+                                           self.parameter_priors))
+
+        def evaluate_liklihood_reduced(self, reduced_parameters):
+            return np.exp(self.evaluate_logliklihood_reduced(reduced_parameters))
+
+        # ---- priors ----------------------------------------------------
+
+        def ln_prior_probability(self, parameters):
+            ln_prob = 0
+            for param, prior in zip(parameters, self.parameter_priors):
+                if prior.min < param < prior.max:
+                    ln_prob += 0
+                else:
+                    ln_prob += -np.inf
+                    break
+            return ln_prob
+
+        def prior_probability(self, parameters):
+            return np.exp(self.ln_prior_probability(parameters))
+
+        def ln_prior_probability_reduced(self, reduced_parameters):
+            return self.ln_prior_probability(
+                pushforward_all_parameters(reduced_parameters,
+                                           self.parameter_priors))
+
+        def prior_probability_reduced(self, reduced_parameters):
+            return self.prior_probability(
+                pushforward_all_parameters(reduced_parameters,
+                                           self.parameter_priors))
+
+        # ---- posterior samples -----------------------------------------
+
+        def pushforward_samples(self, samples):
+            return np.array([
+                pushforward_all_parameters(samples[idx], self.parameter_priors)
+                for idx in range(samples.shape[0])
+            ])