hoppMCMC 2.0.0__tar.gz → 2.2.0__tar.gz

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

@@ -1,74 +1,32 @@
 News
 ====
 
-1.2.1
+2.2.0
 -----
 
-*UNRELEASED*
+*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*
+1.0 *30-Jul-2018*
+0.6
+0.5 *14-Feb-2017*
+0.4 *14-Oct-2015*
+0.3 *09-Oct-2015*
+0.2 *28-Sep-2015*
+0.1 *28-Sep-2015*
 -----
 
-*UNRELEASED*
-
 * Prevented premature termination during kde.evaluate (needs a better solution)
-
-1.1
------
-
-*Release date: 13-Sep-2018*
-
 * Fixed a bug in reading output (Python 3)
-
-1.0
------
-
-*Release date: 30-Jul-2018*
-
 * Compatible with Python 3
-
-0.6
------
-
-*UNRELEASED*
-
 * Print out the covariates in addition to the parameters
-
-0.5
------
-
-*Release date: 14-Feb-2017*
-
 * Minor improvement on pulsevarUpdate
-
-0.4
------
-
-*Release date: 14-Oct-2015*
-
 * Fixed an issue with default parameters
-
-0.3
------
-
-*Release date: 09-Oct-2015*
-
 * This version includes an improvement in compareAUCs
-
-
-0.2
------
-
-*Release date: 28-Sep-2015*
-
 * This version includes a documentation and examples
-
-
-0.1
------
-
-*Release date: 28-Sep-2015*
-
-* Initial commit
-
-
+* Initial commit

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hoppMCMC
-Version: 2.0.0
+Version: 2.2.0
 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.0.0 → hoppmcmc-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hoppMCMC"
-version = "2.0.0"
+version = "2.2.0"
 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.0.0 → hoppmcmc-2.2.0}/setup.cfg

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

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

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

hoppmcmc-2.2.0/src/hoppMCMC/examples/example4.py

@@ -0,0 +1,135 @@
+import numpy
+import pandas
+import seaborn
+
+from matplotlib import pyplot as plt
+
+import myMPI
+from inferFun import ABCModel, inferABCModels
+
+# ---------------------------------------------------------------------
+# Synthetic observation data
+# ---------------------------------------------------------------------
+
+temperatures = numpy.array([15, 18, 21, 24, 27, 30, 33, 36, 39], dtype=float)
+observed_rates = numpy.array([0.07508502, 0.15548009, 0.25742823, 0.31720884, 0.39438616, 0.43292063, 0.41474694, 0.33905526, 0.        ])
+
+def briere_rate(temp, c, tmin, tmax):
+    """
+    Brière temperature response.
+
+    The response is zero below tmin and above tmax.
+    Between tmin and tmax, it rises and then falls near tmax.
+    """
+    temp = numpy.asarray(temp, dtype=float)
+    rate = c * temp * (temp - tmin) * numpy.sqrt(numpy.maximum(tmax - temp, 0.0))
+    rate[(temp <= tmin) | (temp >= tmax)] = 0.0
+    return rate
+
+# ---------------------------------------------------------------------
+# Distance function
+# ---------------------------------------------------------------------
+
+def normalised_rmse(predicted, observed):
+    """
+    Normalised root mean squared error.
+
+    The normalisation keeps the ABC threshold easier to interpret across
+    examples.
+    """
+    predicted = numpy.asarray(predicted, dtype=float)
+    observed = numpy.asarray(observed, dtype=float)
+    scale = numpy.std(observed)
+    if scale == 0:
+        scale = 1.0
+    return numpy.sqrt(numpy.mean((predicted - observed) ** 2)) / scale
+
+def score_briere(par, verbose=False):
+    c, tmin, tmax = par
+    # Invalid thermal limits are rejected by returning an infinite score.
+    if tmin >= tmax:
+        return numpy.inf
+    predicted = briere_rate(temperatures, c=c, tmin=tmin, tmax=tmax)
+    return normalised_rmse(predicted, observed_rates)
+
+# ---------------------------------------------------------------------
+# Brière model definition
+# ---------------------------------------------------------------------
+
+model_briere = ABCModel(
+    name="briere",
+    pargen=lambda: numpy.array([2.5e-4, 10.0, 38.0]),
+    score=score_briere,
+    lower=numpy.array([1e-6, 0.0, 30.0]),
+    upper = numpy.array([1e-3, 20.0, 45.0]),
+    prior=0.5,
+    inferpar=[0, 1, 2],
+    kernel=numpy.array([1e-8, 0.5, 0.5])
+)
+
+# ---------------------------------------------------------------------
+# Run single-model ABC
+# ---------------------------------------------------------------------
+
+abc = inferABCModels(
+    models=[model_briere],
+    epsseq=[0.5],
+    size=100,
+    niter=20,
+    adapt=2,
+    retain=True,
+    verbose=True
+)
+
+# ---------------------------------------------------------------------
+# Summarise model posterior probabilities
+# ---------------------------------------------------------------------
+
+if myMPI.MPI_RANK == myMPI.MPI_MASTER:
+    plt.plot(abc.results[:,abc.infocol['iter']],
+             abc.results[:,abc.infocol['param0']],
+             '.')
+    plt.show()
+
+if myMPI.MPI_RANK == myMPI.MPI_MASTER:
+    # Use abc.result, unless your class stores it as abc.results
+    mat = abc.result
+    param_start = abc.infocol["param0"]
+    params = mat[:, param_start:]
+    # Remove padded NaN columns, useful if inferABCModels stores variable-length parameters
+    valid_cols = ~numpy.all(numpy.isnan(params), axis=0)
+    params = params[:, valid_cols]
+    df = pandas.DataFrame(
+        params,
+        columns=[f"par{i+1}" for i in range(params.shape[1])]
+    )
+    df["score"] = mat[:, abc.infocol["score"]]
+    #
+    g = seaborn.pairplot(
+        df,
+        vars=[c for c in df.columns if c.startswith("par")],
+        corner=True,
+        diag_kind="kde",
+        plot_kws={
+            "s": 35,
+            "alpha": 0.65,
+            "edgecolor": "none"
+        },
+        diag_kws={
+            "fill": True,
+            "alpha": 0.45
+        }
+    )
+    g.figure.suptitle("ABC posterior parameter samples", y=1.02)
+    g.figure.set_size_inches(8, 8)
+    plt.tight_layout()
+    plt.show()    
+
+if myMPI.MPI_RANK == myMPI.MPI_MASTER:
+    model_probs = abc.model_posterior()
+    print("\nPosterior model probabilities")
+    print(model_probs)
+    # Optional: inspect the final particle population.
+    particles = abc.result
+    print("\nFinal particle matrix shape:")
+    print(particles.shape)

hoppmcmc-2.2.0/src/hoppMCMC/examples/example5.py

@@ -0,0 +1,203 @@
+import numpy
+import pandas
+import seaborn
+
+from matplotlib import pyplot as plt
+
+import myMPI
+from inferFun import ABCModel, inferABCModels
+
+# ---------------------------------------------------------------------
+# Synthetic observation data
+# ---------------------------------------------------------------------
+
+temperatures = numpy.array([15, 18, 21, 24, 27, 30, 33, 36, 39], dtype=float)
+observed_rates = numpy.array([0.07508502, 0.15548009, 0.25742823, 0.31720884, 0.39438616, 0.43292063, 0.41474694, 0.33905526, 0.        ])
+
+def briere_rate(temp, c, tmin, tmax):
+    """
+    Brière temperature response.
+
+    The response is zero below tmin and above tmax.
+    Between tmin and tmax, it rises and then falls near tmax.
+    """
+    temp = numpy.asarray(temp, dtype=float)
+    rate = c * temp * (temp - tmin) * numpy.sqrt(numpy.maximum(tmax - temp, 0.0))
+    rate[(temp <= tmin) | (temp >= tmax)] = 0.0
+    return rate
+
+def exponential_rate(temp, a, b):
+    """
+    Exponential temperature response.
+
+    This model can increase with temperature but cannot represent a
+    high-temperature decline.
+    """
+    temp = numpy.asarray(temp, dtype=float)
+    return a * numpy.exp(b * temp)
+
+# ---------------------------------------------------------------------
+# Shared distance function helper
+# ---------------------------------------------------------------------
+
+def normalised_rmse(predicted, observed):
+    """
+    Normalised root mean squared error.
+
+    The normalisation keeps the ABC threshold easier to interpret across
+    examples.
+    """
+    predicted = numpy.asarray(predicted, dtype=float)
+    observed = numpy.asarray(observed, dtype=float)
+    scale = numpy.std(observed)
+    if scale == 0:
+        scale = 1.0
+    return numpy.sqrt(numpy.mean((predicted - observed) ** 2)) / scale
+
+# ---------------------------------------------------------------------
+# Exponential model definition
+# ---------------------------------------------------------------------
+
+lower_exp = numpy.array([1e-5, 0.001])
+upper_exp = numpy.array([0.05, 0.25])
+
+def pargen_exponential():
+    return numpy.random.uniform(lower_exp, upper_exp)
+
+def score_exponential(par, verbose=False):
+    a, b = par
+    predicted = exponential_rate(
+        temperatures,
+        a=a,
+        b=b
+    )
+    return normalised_rmse(predicted, observed_rates)
+
+model_exponential = ABCModel(
+    name="exponential",
+    pargen=pargen_exponential,
+    score=score_exponential,
+    lower=lower_exp,
+    upper=upper_exp,
+    prior=0.5,
+    inferpar=[0, 1],
+    kernel=numpy.array([1e-4, 1e-4])
+)
+
+# ---------------------------------------------------------------------
+# Brière model definition
+# ---------------------------------------------------------------------
+
+lower_briere = numpy.array([1e-6, 0.0, 30.0])
+upper_briere = numpy.array([1e-3, 20.0, 45.0])
+
+def pargen_briere():
+    return numpy.random.uniform(lower_briere, upper_briere)
+
+def score_briere(par, verbose=False):
+    c, tmin, tmax = par
+    # Invalid thermal limits are rejected by returning an infinite score.
+    if tmin >= tmax:
+        return numpy.inf
+    predicted = briere_rate(
+        temperatures,
+        c=c,
+        tmin=tmin,
+        tmax=tmax
+    )
+    return normalised_rmse(predicted, observed_rates)
+
+model_briere = ABCModel(
+    name="briere",
+    pargen=pargen_briere,
+    score=score_briere,
+    lower=lower_briere,
+    upper=upper_briere,
+    prior=0.5,
+    inferpar=[0, 1, 2],
+    kernel=numpy.array([1e-8, 0.5, 0.5])
+)
+
+# ---------------------------------------------------------------------
+# Run multi-model ABC
+# ---------------------------------------------------------------------
+
+abc = inferABCModels(
+    models=[
+        model_exponential,
+        model_briere
+    ],
+    epsseq=[
+        1.5,
+        1.0,
+        0.5
+    ],
+    size=100,
+    niter=10,
+    adapt=2,
+    retain=True,
+    verbose=True
+)
+
+# ---------------------------------------------------------------------
+# Summarise model posterior probabilities
+# ---------------------------------------------------------------------
+
+if myMPI.MPI_RANK == myMPI.MPI_MASTER:
+    model_probs = abc.model_posterior()
+    print("\nPosterior model probabilities")
+    print(model_probs)
+    # Optional: inspect the final particle population.
+    particles = abc.result
+    print("\nFinal particle matrix shape:")
+    print(particles.shape)
+
+if myMPI.MPI_RANK == myMPI.MPI_MASTER:
+    mats = [abc.results[:abc.size,:], abc.result]
+    p0 = abc.infocol["param0"]
+    #
+    for ipop,mat in enumerate(mats):
+        plt.figure(figsize=(7, 5))
+        # Observations
+        plt.scatter(
+            temperatures,
+            observed_rates,
+            s=50,
+            color="black",
+            label="observed",
+            zorder=10
+        )
+        # Exponential posterior population
+        model_id = abc.model_names.index("exponential")
+        sub = mat[mat[:, abc.infocol["model"]] == model_id]
+        for row in sub:
+            par = row[p0:p0 + abc.parsizes[model_id]]
+            y = exponential_rate(temperatures, par[0], par[1])
+            plt.plot(
+                temperatures,
+                y,
+                color="tab:blue",
+                alpha=0.5
+            )
+        # Brière posterior population
+        model_id = abc.model_names.index("briere")
+        sub = mat[mat[:, abc.infocol["model"]] == model_id]
+        for row in sub:
+            par = row[p0:p0 + abc.parsizes[model_id]]
+            y = briere_rate(temperatures, par[0], par[1], par[2])
+            plt.plot(
+                temperatures,
+                y,
+                color="tab:orange",
+                alpha=0.5
+            )
+        #
+        # Dummy lines for legend
+        plt.plot([], [], color="tab:blue", label="exponential")
+        plt.plot([], [], color="tab:orange", label="Brière")
+        plt.xlabel("Temperature")
+        plt.ylabel("Rate")
+        plt.title(f"{["First","Final"][ipop]} ABC posterior population")
+        plt.legend()
+        plt.tight_layout()
+        plt.show()

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hoppMCMC
-Version: 2.0.0
+Version: 2.2.0
 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.0.0 → hoppmcmc-2.2.0}/src/hoppMCMC.egg-info/SOURCES.txt

@@ -16,5 +16,7 @@ src/hoppMCMC/doc/hoppMCMC_manual.pdf
 src/hoppMCMC/examples/example1.py
 src/hoppMCMC/examples/example2.py
 src/hoppMCMC/examples/example3.py
+src/hoppMCMC/examples/example4.py
+src/hoppMCMC/examples/example5.py
 src/inferFun/__init__.py
 src/myMPI/__init__.py