hoppMCMC 2.2.0__tar.gz → 2.2.2__tar.gz

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2}/NEWS.txt

@@ -1,14 +1,13 @@
 News
 ====
 
-2.2.0
+2.2.2
 -----
 
 *Release date: 13-Jul-2026*
 
 inferFun is now updated to include ABCModel and inferABCModels as the main ABC-SMC inference tools
 
-2.1.0
 1.2.1
 1.2
 1.1 *13-Sep-2018*

{hoppmcmc-2.2.0/src/hoppMCMC.egg-info → hoppmcmc-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hoppMCMC
-Version: 2.2.0
+Version: 2.2.2
 Summary: An adaptive basin-hopping Markov-chain Monte Carlo algorithm for Bayesian optimisation
 Author: Kamil Erguler
 Author-email: Kamil Erguler <kerguler@gmail.com>

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hoppMCMC"
-version = "2.2.0"
+version = "2.2.2"
 description = "An adaptive basin-hopping Markov-chain Monte Carlo algorithm for Bayesian optimisation"
 authors = [{ name = "Kamil Erguler", email = "kerguler@gmail.com" }]
 license = { text = "GPLv3" }

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = hoppMCMC
-version = 2.2.0
+version = 2.2.2
 description = Adaptive basin-hopping MCMC and ABC inference with MPI support
 author = Kamil Erguler
 author_email = k.erguler@cyi.ac.cy

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2}/src/hoppMCMC/__init__.py

@@ -6,7 +6,7 @@ This is the python (v2.7) implementation of the hoppMCMC algorithm aiming to ide
 
 """
 
-__version__ = '2.2.0'
+__version__ = '2.2.2'
 
 import os
 import sys

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2/src/hoppMCMC.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hoppMCMC
-Version: 2.2.0
+Version: 2.2.2
 Summary: An adaptive basin-hopping Markov-chain Monte Carlo algorithm for Bayesian optimisation
 Author: Kamil Erguler
 Author-email: Kamil Erguler <kerguler@gmail.com>

{hoppmcmc-2.2.0 → hoppmcmc-2.2.2}/src/inferFun/__init__.py

@@ -477,18 +477,137 @@ class inferABCModels:
 
     def log_kernel_density(self, model_id, x, mean, kernel):
         inferpar = self.inferpars[model_id]
-
-        x_inf = x[inferpar]
-        mean_inf = mean[inferpar]
+        x_inf = numpy.asarray(x[inferpar], dtype=float)
+        mean_inf = numpy.asarray(mean[inferpar], dtype=float)
+        d = len(inferpar)
 
         kernel = numpy.asarray(kernel, dtype=float)
         if kernel.ndim == 0:
-            kernel = numpy.array([[kernel]])
-
-        # Add small jitter to avoid singular covariance problems.
-        kernel = kernel + numpy.eye(kernel.shape[0]) * self.jitter
-
-        return multivariate_normal.logpdf(x_inf, mean=mean_inf, cov=kernel, allow_singular=False)
+            kernel = numpy.array([[float(kernel)]], dtype=float)
+        elif kernel.ndim == 1:
+            kernel = numpy.diag(kernel)
+        elif kernel.ndim != 2:
+            raise ValueError(
+                f"Kernel for model {model_id} ({self.model_names[model_id]}) "
+                f"must be scalar, 1D, or 2D. Got shape {kernel.shape}."
+            )
+        if kernel.shape != (d, d):
+            raise ValueError(
+                f"Kernel dimension mismatch for model {model_id} "
+                f"({self.model_names[model_id]}). "
+                f"Expected {(d, d)}, got {kernel.shape}. "
+                f"inferpar={inferpar}"
+            )
+        if not numpy.all(numpy.isfinite(x_inf)):
+            raise ValueError(
+                f"Non-finite x values for model {model_id} "
+                f"({self.model_names[model_id]}): {x_inf}"
+            )
+        if not numpy.all(numpy.isfinite(mean_inf)):
+            raise ValueError(
+                f"Non-finite kernel mean for model {model_id} "
+                f"({self.model_names[model_id]}): {mean_inf}"
+            )
+        if not numpy.all(numpy.isfinite(kernel)):
+            raise ValueError(
+                f"Non-finite kernel entries for model {model_id} "
+                f"({self.model_names[model_id]}):\n{kernel}"
+            )
+        # Symmetrise, just in case floating-point noise introduced asymmetry.
+        kernel = 0.5 * (kernel + kernel.T)
+        diag = numpy.diag(kernel)
+        if numpy.any(diag < 0):
+            raise ValueError(
+                f"Negative diagonal variance in kernel for model {model_id} "
+                f"({self.model_names[model_id]}).\n"
+                f"Diagonal={diag}\n"
+                f"Kernel=\n{kernel}"
+            )
+        eigvals, eigvecs = numpy.linalg.eigh(kernel)
+        max_eig = numpy.max(eigvals)
+        # A purely absolute jitter may be too small if the largest variance is large.
+        # This floor is both absolute and relative.
+        eig_floor = max(self.jitter, self.jitter * max(1.0, max_eig))
+        if numpy.any(eigvals <= eig_floor):
+            bad = numpy.where(eigvals <= eig_floor)[0]
+            if self.verbose:
+                print(
+                    f"Warning: regularising near-singular kernel for model {model_id} "
+                    f"({self.model_names[model_id]}).",
+                    flush=True
+                )
+                print(f"  parameter indices: {inferpar}", flush=True)
+                print(f"  diagonal variances: {diag}", flush=True)
+                print(f"  eigenvalues before regularisation: {eigvals}", flush=True)
+                print(f"  eigenvalue floor: {eig_floor:g}", flush=True)
+                #
+                for b in bad:
+                    direction = eigvecs[:, b]
+                    order = numpy.argsort(numpy.abs(direction))[::-1]
+                    print(
+                        f"  problematic eigenvalue {b}: {eigvals[b]:g}",
+                        flush=True
+                    )
+                    print("  strongest dimensions in this direction:", flush=True)
+                    for k in order[:min(5, len(order))]:
+                        print(
+                            f"    kernel dim {k}, parameter index {inferpar[k]}, "
+                            f"loading={direction[k]:g}, "
+                            f"variance={diag[k]:g}",
+                            flush=True
+                        )
+            # Regularise eigenvalues, not only diagonal entries.
+            eigvals = numpy.maximum(eigvals, eig_floor)
+            kernel = eigvecs @ numpy.diag(eigvals) @ eigvecs.T
+            kernel = 0.5 * (kernel + kernel.T)
+        # Final check by Cholesky. This is stricter and clearer than waiting for SciPy.
+        try:
+            numpy.linalg.cholesky(kernel)
+        except numpy.linalg.LinAlgError as err:
+            eigvals_final = numpy.linalg.eigvalsh(kernel)
+            raise ValueError(
+                f"Kernel is still not positive definite for model {model_id} "
+                f"({self.model_names[model_id]}).\n"
+                f"parameter indices={inferpar}\n"
+                f"x={x_inf}\n"
+                f"mean={mean_inf}\n"
+                f"diagonal variances={numpy.diag(kernel)}\n"
+                f"eigenvalues={eigvals_final}\n"
+                f"kernel=\n{kernel}"
+            ) from err
+        try:
+            value = multivariate_normal.logpdf(
+                x_inf,
+                mean=mean_inf,
+                cov=kernel,
+                allow_singular=False
+            )
+        except Exception as err:
+            eigvals_final = numpy.linalg.eigvalsh(kernel)
+            raise ValueError(
+                f"multivariate_normal.logpdf failed for model {model_id} "
+                f"({self.model_names[model_id]}).\n"
+                f"parameter indices={inferpar}\n"
+                f"x={x_inf}\n"
+                f"mean={mean_inf}\n"
+                f"diagonal variances={numpy.diag(kernel)}\n"
+                f"eigenvalues={eigvals_final}\n"
+                f"kernel=\n{kernel}"
+            ) from err
+        if not numpy.isfinite(value):
+            eigvals_final = numpy.linalg.eigvalsh(kernel)
+            raise ValueError(
+                f"Non-finite kernel log density for model {model_id} "
+                f"({self.model_names[model_id]}).\n"
+                f"logpdf={value}\n"
+                f"parameter indices={inferpar}\n"
+                f"x={x_inf}\n"
+                f"mean={mean_inf}\n"
+                f"diagonal variances={numpy.diag(kernel)}\n"
+                f"eigenvalues={eigvals_final}\n"
+                f"kernel=\n{kernel}"
+            )
+        return value
 
     def calc_weights(self, mat_new, mat_old, kernels):
         """