inference-tools 0.13.3__py3-none-any.whl → 0.13.4__py3-none-any.whl

inference/mcmc/utilities.py

@@ -103,26 +103,26 @@ class Bounds:
         if self.lower.ndim > 1 or self.upper.ndim > 1:
             raise ValueError(
                 f"""\n
-                [ {error_source} error ]
-                >> Lower and upper bounds must be one-dimensional arrays, but
-                >> instead have dimensions {self.lower.ndim} and {self.upper.ndim} respectively.
+                \r[ {error_source} error ]
+                \r>> Lower and upper bounds must be one-dimensional arrays, but
+                \r>> instead have dimensions {self.lower.ndim} and {self.upper.ndim} respectively.
                 """
             )
 
         if self.lower.size != self.upper.size:
             raise ValueError(
                 f"""\n
-                [ {error_source} error ]
-                >> Lower and upper bounds must be arrays of equal size, but
-                >> instead have sizes {self.lower.size} and {self.upper.size} respectively.
+                \r[ {error_source} error ]
+                \r>> Lower and upper bounds must be arrays of equal size, but
+                \r>> instead have sizes {self.lower.size} and {self.upper.size} respectively.
                 """
             )
 
         if (self.lower >= self.upper).any():
             raise ValueError(
                 f"""\n
-                [ {error_source} error ]
-                >> All given upper bounds must be larger than the corresponding lower bounds.
+                \r[ {error_source} error ]
+                \r>> All given upper bounds must be larger than the corresponding lower bounds.
                 """
             )
 
@@ -152,7 +152,7 @@ class Bounds:
         n = q % 2
         return self.lower + (1 - 2 * n) * rem + n * self.width
 
-    def reflect_momenta(self, theta: ndarray):
+    def reflect_momenta(self, theta: ndarray) -> tuple[ndarray, ndarray]:
         q, rem = np_divmod(theta - self.lower, self.width)
         n = q % 2
         reflection = 1 - 2 * n

inference/pdf/kde.py

@@ -42,8 +42,8 @@ class GaussianKDE(DensityEstimator):
     def __init__(
         self,
         sample: ndarray,
-        bandwidth=None,
-        cross_validation=False,
+        bandwidth: float = None,
+        cross_validation: bool = False,
         max_cv_samples=5000,
     ):
         self.sample = sort(array(sample).flatten())  # sorted array of the samples
@@ -136,7 +136,7 @@ class GaussianKDE(DensityEstimator):
         # A simple estimate which assumes the distribution close to a Gaussian
         return 1.06 * std(self.sample) / (self.sample.size**0.2)
 
-    def cross_validation_bandwidth_estimator(self, initial_h):
+    def cross_validation_bandwidth_estimator(self, initial_h: float) -> float:
         """
         Selects the bandwidth by maximising a log-probability derived
         using a 'leave-one-out cross-validation' approach.

inference/pdf/unimodal.py

@@ -4,6 +4,7 @@ from numpy import array, ndarray, linspace, zeros, atleast_1d
 from scipy.integrate import simpson, quad
 from scipy.optimize import minimize
 from inference.pdf.base import DensityEstimator
+from inference.pdf.hdi import sample_hdi
 
 
 class UnimodalPdf(DensityEstimator):
@@ -21,9 +22,9 @@ class UnimodalPdf(DensityEstimator):
 
     def __init__(self, sample: ndarray):
         self.sample = array(sample).flatten()
-        self.n_samps = sample.size
+        self.n_samps = self.sample.size
 
-        # chebyshev quadtrature weights and axes
+        # chebyshev quadrature weights and axes
         self.sd = 0.2
         self.n_nodes = 128
         k = linspace(1, self.n_nodes, self.n_nodes)
@@ -34,27 +35,31 @@ class UnimodalPdf(DensityEstimator):
         # first minimise based on a slice of the sample, if it's large enough
         self.cutoff = 2000
         self.skip = max(self.n_samps // self.cutoff, 1)
-
-        self.x = self.sample[:: self.skip]
-        self.n = len(self.x)
+        self.fitted_samples = self.sample[:: self.skip]
 
         # makes guesses based on sample moments
-        guesses = self.generate_guesses()
-
-        # sort the guesses by the lowest score
-        minfunc = lambda x: -self.posterior(x)
-        guesses = sorted(guesses, key=minfunc)
+        guesses, self.bounds = self.generate_guesses_and_bounds()
+        # sort the guesses by the lowest cost
+        cost_func = lambda x: -self.posterior(x)
+        guesses = sorted(guesses, key=cost_func)
 
         # minimise based on the best guess
-        self.min_result = minimize(minfunc, guesses[0], method="Nelder-Mead")
+        opt_method = "Nelder-Mead"
+        self.min_result = minimize(
+            fun=cost_func, x0=guesses[0], bounds=self.bounds, method=opt_method
+        )
         self.MAP = self.min_result.x
         self.mode = self.MAP[0]
 
         # if we were using a reduced sample, use full sample
         if self.skip > 1:
-            self.x = self.sample
-            self.n = self.n_samps
-            self.min_result = minimize(minfunc, self.MAP, method="Nelder-Mead")
+            self.fitted_samples = self.sample
+            self.min_result = minimize(
+                fun=cost_func,
+                x0=self.MAP,
+                bounds=self.bounds,
+                method=opt_method,
+            )
             self.MAP = self.min_result.x
             self.mode = self.MAP[0]
 
@@ -66,25 +71,34 @@ class UnimodalPdf(DensityEstimator):
         self.upr_limit = x0 + s0 * (4 * exp(f) + 1)
         self.lwr_limit = x0 - s0 * (4 * exp(-f) + 1)
 
-    def generate_guesses(self):
-        mu, sigma, skew = self.sample_moments()
-
-        x0 = [mu, mu - sigma * skew * 0.15, mu - sigma * skew * 0.3]
-        v = [0, 5.0]
+    def generate_guesses_and_bounds(self) -> tuple[list, list]:
+        mu, sigma, skew = self.sample_moments(self.fitted_samples)
+        lwr, upr = sample_hdi(sample=self.sample, fraction=0.5)
+
+        bounds = [
+            (lwr, upr),
+            (sigma * 0.1, sigma * 10),
+            (0.0, 5.0),
+            (-3.0, 3.0),
+            (1e-2, 20.0),
+            (1.0, 6.0),
+        ]
+        x0 = [lwr * (1 - f) + upr * f for f in [0.3, 0.5, 0.7]]
         s0 = [sigma, sigma * 2]
+        ln_v = [0.25, 2.0]
         f = [0.5 * skew, skew]
         k = [1.0, 4.0, 8.0]
         q = [2.0]
 
-        return [array(i) for i in product(x0, s0, v, f, k, q)]
+        return [array(i) for i in product(x0, s0, ln_v, f, k, q)], bounds
 
-    def sample_moments(self):
-        mu = mean(self.x)
-        x2 = self.x**2
-        x3 = x2 * self.x
+    @staticmethod
+    def sample_moments(samples: ndarray) -> tuple[float, float, float]:
+        mu = mean(samples)
+        x2 = samples**2
+        x3 = x2 * samples
         sig = sqrt(mean(x2) - mu**2)
         skew = (mean(x3) - 3 * mu * sig**2 - mu**3) / sig**3
-
         return mu, sig, skew
 
     def __call__(self, x: ndarray) -> ndarray:
@@ -112,35 +126,31 @@ class UnimodalPdf(DensityEstimator):
         integral = intervals.cumsum()[inverse_sort]
         return integral if x.size > 1 else integral[0]
 
-    def posterior(self, paras):
-        x0, s0, v, f, k, q = paras
+    def evaluate_model(self, x: ndarray, theta: ndarray) -> ndarray:
+        return self.pdf_model(x, theta) / self.norm(theta)
 
-        # prior checks
-        if (s0 > 0) & (0 < k < 20) & (1 < q < 6):
-            normalisation = self.n * log(self.norm(paras))
-            return self.log_pdf_model(self.x, paras).sum() - normalisation
-        else:
-            return -1e50
+    def posterior(self, theta: ndarray) -> float:
+        normalisation = self.fitted_samples.size * log(self.norm(theta))
+        return self.log_pdf_model(self.fitted_samples, theta).sum() - normalisation
 
-    def norm(self, pvec):
-        v = self.pdf_model(self.u, [0.0, self.sd, *pvec[2:]])
-        integral = (self.w * v).sum() * pvec[1]
+    def norm(self, theta: ndarray) -> float:
+        v = self.pdf_model(self.u, [0.0, self.sd, *theta[2:]])
+        integral = (self.w * v).sum() * theta[1]
         return integral
 
-    def pdf_model(self, x, pvec):
-        return exp(self.log_pdf_model(x, pvec))
+    def pdf_model(self, x: ndarray, theta: ndarray) -> ndarray:
+        return exp(self.log_pdf_model(x, theta))
 
-    def log_pdf_model(self, x, pvec):
-        x0, s0, v, f, k, q = pvec
-        v = exp(v) + 1
+    def log_pdf_model(self, x: ndarray, theta: ndarray) -> ndarray:
+        x0, s0, ln_v, f, k, q = theta
+        v = exp(ln_v)
         z0 = (x - x0) / s0
-        ds = exp(f * tanh(z0 / k))
-        z = z0 / ds
+        z = z0 * exp(-f * tanh(z0 / k))
 
         log_prob = -(0.5 * (1 + v)) * log(1 + (abs(z) ** q) / v)
         return log_prob
 
-    def moments(self):
+    def moments(self) -> tuple[float, ...]:
         """
         Calculate the mean, variance skewness and excess kurtosis of the estimated PDF.
 

inference/posterior.py

@@ -2,6 +2,8 @@
 .. moduleauthor:: Chris Bowman <chris.bowman.physics@gmail.com>
 """
 
+from numpy import ndarray
+
 
 class Posterior:
     """
@@ -20,7 +22,7 @@ class Posterior:
         self.likelihood = likelihood
         self.prior = prior
 
-    def __call__(self, theta):
+    def __call__(self, theta: ndarray) -> float:
         """
         Returns the log-posterior probability for the given set of model parameters.
 
@@ -32,7 +34,7 @@ class Posterior:
         """
         return self.likelihood(theta) + self.prior(theta)
 
-    def gradient(self, theta):
+    def gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the log-posterior with respect to model parameters.
 
@@ -44,7 +46,7 @@ class Posterior:
         """
         return self.likelihood.gradient(theta) + self.prior.gradient(theta)
 
-    def cost(self, theta):
+    def cost(self, theta: ndarray) -> float:
         """
         Returns the 'cost', defined as the negative log-posterior probability, for the
         given set of model parameters. Minimising the value of the cost therefore
@@ -58,7 +60,7 @@ class Posterior:
         """
         return -(self.likelihood(theta) + self.prior(theta))
 
-    def cost_gradient(self, theta):
+    def cost_gradient(self, theta: ndarray) -> ndarray:
         """
         Returns the gradient of the negative log-posterior with respect to model parameters.