guts-base 0.8.5__tar.gz → 0.8.6__tar.gz

{guts_base-0.8.5 → guts_base-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 0.8.5
+Version: 0.8.6
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -686,14 +686,14 @@ Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.10
+Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openpyxl>=3.1.3
 Requires-Dist: Bottleneck>=1.5.0
 Requires-Dist: expydb>=0.6.0
 Requires-Dist: mempyguts>=1.5.0
-Requires-Dist: pymob[numpyro]<1.0.0,>=0.4.1
+Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.4.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/__init__.py

@@ -4,7 +4,7 @@ from . import data
 from . import prob
 from . import plot
 
-__version__ = "0.8.5"
+__version__ = "0.8.6"
 
 from .sim import (
     GutsBase,

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/data/generator.py

@@ -67,7 +67,8 @@ def design_exposure_scenario(
     """
     TODO: tmax, dt and eps are probably not necessary
     """
-    time = np.arange(0, t_max, step=dt)  # daily time resolution
+    # add dt so that tmax is definitely inclded
+    time = np.arange(0, t_max+dt, step=dt)  # daily time resolution
     time = np.unique(np.concatenate([time] + [
         np.array([time[-1] if vals["end"] is None else vals["end"]])
         for key, vals in exposures.items()
@@ -79,13 +80,12 @@ def design_exposure_scenario(
         treat = design_exposure_timeseries(time, expo, eps)
         treatments.update({key: treat})
 
-    data = np.column_stack(list(treatments.values())).squeeze()
+    data = np.column_stack(list(treatments.values()))
     data = np.expand_dims(data, axis=0)
 
     coords = {"id": [0], "time": time}
     
-    if len(exposures) > 1:
-        coords.update({exposure_dimension: list(treatments.keys())})
+    coords.update({exposure_dimension: list(treatments.keys())})
 
     exposures_dataset = xr.Dataset(
         data_vars={"exposure": (tuple(coords.keys()), data)},

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/mod.py

@@ -32,7 +32,13 @@ from mempy.model import (
 )
 
 red_sd = RED_SD._rhs_jax
+red_sd_post_processing = RED_SD._solver_post_processing
+
 red_it = RED_IT._rhs_jax
+red_it_post_processing = RED_IT._solver_post_processing
+
+red_sd_ia = RED_SD_IA._rhs_jax
+red_sd_ia_post_processing = RED_SD_IA._solver_post_processing
 
 
 def p_survival(results, t, interpolation, z, k_k, h_b):

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/sim/base.py

@@ -1,5 +1,7 @@
 import os
 import glob
+from functools import partial
+from copy import deepcopy
 import warnings
 import numpy as np
 import xarray as xr
@@ -13,6 +15,7 @@ from pymob.sim.config import DataVariable, Param, string_to_list
 
 from pymob.solvers import JaxSolver
 from pymob.solvers.base import rect_interpolation
+from pymob.sim.config import ParameterDict
 from expyDB.intervention_model import (
     Treatment, Timeseries, select, from_expydb
 )
@@ -24,7 +27,6 @@ from guts_base.data import (
 )
 from guts_base.sim.report import GutsReport
 
-
 class GutsBase(SimulationBase):
     """
     Initializes GUTS models from a variety of data sources 
@@ -36,15 +38,15 @@ class GutsBase(SimulationBase):
     """
     solver = JaxSolver
     Report = GutsReport
-    unit_time: Literal["day", "hour", "minute", "second"] = "day"
-    results_interpolation: Optional[List[float|int]] = [np.nan, np.nan, 100]
-    ecx_mode: Literal["mean", "draws"] = "mean"
 
     def initialize(self, input: Dict = None):
+        self.ecx_mode: Literal["mean", "draws"] = "mean"
 
+        self.unit_time: Literal["day", "hour", "minute", "second"] = "day"
         if hasattr(self.config.simulation, "unit_time"):
             self.unit_time = self.config.simulation.unit_time  # type: ignore
 
+        self.results_interpolation: Optional[List[float|int]] = [np.nan, np.nan, 100]
         if hasattr(self.config.simulation, "results_interpolation"):
             self.results_interpolation = string_to_list(self.config.simulation.results_interpolation)
             self.results_interpolation[0] = float(self.results_interpolation[0])
@@ -229,6 +231,9 @@ class GutsBase(SimulationBase):
         """This function interpolates the posterior with a given resolution
         posterior_predictions calculate proper survival predictions for the
         posterior.
+
+        It also makes sure that the new interpolation does not include fewer values
+        than the original dataset
         """
 
         if np.isnan(self.results_interpolation[0]):
@@ -244,8 +249,15 @@ class GutsBase(SimulationBase):
                 stop=self.results_interpolation[1],
                 num=self.results_interpolation[2] 
             )
+
+            # combine original coordinates and interpolation. This 
+            # a) helps error checking during posterior predictions.
+            # b) makes sure that the original time vector is retained, which may be
+            #    relevant for the simulation success (e.g. IT model)
             self.observations = self.observations.reindex(
-                time=time_interpolate
+                time=np.unique(np.concatenate(
+                    [time_interpolate, self.observations["time"]]
+                ))
             )
             
         self.dispatch_constructor()
@@ -272,35 +284,85 @@ class GutsBase(SimulationBase):
 
     def copy(self):
         with warnings.catch_warnings(action="ignore"):
-            sim_copy = type(self)(self.config)
-            sim_copy.observations = self.observations
-            sim_copy.model_parameters = self.model_parameters
-            if self.inferer is not None:
-                sim_copy.inferer = type(self.inferer)(self)
-                sim_copy.inferer.idata = self.inferer.idata
+            sim_copy = type(self)(self.config.copy(deep=True))
+            sim_copy.observations = self.observations.copy(deep=True)
+            
+            # must copy individual parts of the dict due to the on_update method
+            model_parameters = {k: deepcopy(v) for k, v in self.model_parameters.items()}
+            
+            # TODO: Refactor this once the parameterize method is removed.
+            sim_copy.parameterize = partial(sim_copy.parameterize, model_parameters=model_parameters)
+            sim_copy._model_parameters = ParameterDict(model_parameters, callback=sim_copy._on_params_updated)
+
+            sim_copy.load_modules()
+            if hasattr(self, "inferer"):
+                sim_copy.inferer = type(self.inferer)(sim_copy)
+                # idata uses deepcopy by default
+                sim_copy.inferer.idata = self.inferer.idata.copy()
             sim_copy.model = self.model
             sim_copy.solver_post_processing = self.solver_post_processing
-            sim_copy.load_modules()
 
         return sim_copy
-
     
-    @property
     def predefined_scenarios(self):
-        # this produces a exposure x_in dataset with only the dimensions ID and TIME
-        oral_acute_1d = design_exposure_scenario(
-            exposures={
-                "oral":dict(start=0, end=1.0, concentration=1.0),
-            },
-            t_max=10.01,
-            dt=1/24,
-            exposure_dimension="exposure_path"
+        """
+        TODO: Fix timescale to observations
+        TODO: Incorporate extra exposure patterns (constant, pulse_1day, pulse_2day)
+        """
+        # get the maximum possible time to provide exposure scenarios that are definitely
+        # long enough
+        time_max = max(
+            self.observations[self.config.simulation.x_dimension].max(), 
+            *self.Report.ecx_estimates_times
         )
 
-        return dict(
-            oral_acute_1d=oral_acute_1d
+        # this produces a exposure x_in dataset with only the dimensions ID and TIME
+        standard_dimensions = (
+            self.config.simulation.batch_dimension,
+            self.config.simulation.x_dimension, 
         )
 
+        # get dimensions different from standard dimensions
+        exposure_dimension = [
+            d for d in self.observations.exposure.dims if d not in 
+            standard_dimensions
+        ]
+
+        # raise an error if the number of extra dimensions is larger than 1
+        if len(exposure_dimension) > 1:
+            raise ValueError(
+                f"{type(self).__name__} can currently handle one additional dimension for "+
+                f"the exposure beside {standard_dimensions}. You provided an exposure "+ 
+                f"array with the dimensions: {self.observations.exposure.dims}"
+            )
+        else:
+            exposure_dimension = exposure_dimension[0]
+
+        # iterate over the coordinates of the exposure dimensions to 
+        exposure_coordinates = self.observations.exposure[exposure_dimension].values
+
+        scenarios = {}
+        for coord in exposure_coordinates:
+            concentrations = np.where(coord == exposure_coordinates, 1, 0)
+
+            exposure_dict = {
+                coord: dict(start=0.0, end=1.0, concentration=conc)
+                for coord, conc in zip(exposure_coordinates, concentrations)
+            }
+
+            scenario = design_exposure_scenario(
+                exposures=exposure_dict,
+                t_max=time_max,
+                dt=1/24,
+                exposure_dimension=exposure_dimension
+            )
+
+            scenarios.update({
+                f"1day_exposure_{coord}": scenario
+            })
+
+        return scenarios
+
     def expand_batch_like_coordinate_to_new_dimension(self, coordinate, variables):
         """This method will take an existing coordinate of a dataset that has the same
         coordinate has the batch dimension. It will then re-express the coordinate as a

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/sim/ecx.py

@@ -37,17 +37,32 @@ class ECxEstimator:
         else:
             self.sim.coordinates["id"] = [id]
 
-        self.sim.model_parameters["x_in"] = x_in
+        # ensure correct coordinate order with x_in and raise errors early
+        self.sim.model_parameters["x_in"] = self.sim.parse_input("x_in", x_in)
 
         self.sim.config.data_structure.survival.observed = False
         self.sim.observations = self.sim.observations.sel(id=self.sim.coordinates["id"])
 
-        # fix time after observations have been set
-        self.sim.coordinates["time"] = [time]
+        # fix time after observations have been set. The outcome of the simulation
+        # can dependend on the time vector, because in e.g. IT models, the time resolution
+        # is important. Therefore the time at which the ECx is computed is just inserted
+        # into the time vector at the right position.
+        self.sim.coordinates["time"] = np.unique(np.concatenate([
+            self.sim.coordinates["time"], np.array(time, ndmin=1)
+        ]))
 
         self.sim.model_parameters["y0"] = self.sim.parse_input("y0", drop_dims="time")
         self.sim.dispatch_constructor()
 
+        self.results = pd.Series({
+            "mean": np.nan,
+            "q05": np.nan,
+            "q95": np.nan,
+            "std": np.nan,
+            "cv": np.nan,
+            "msg": np.nan
+        })
+
 
     
     def _evaluate(self, factor, theta):
@@ -108,6 +123,7 @@ class ECxEstimator:
         accept_tol: float = 1e-5, 
         optimizer_tol: float = 1e-5,
         method: str = "cobyla", 
+        show_plot: bool = True,
         **optimizer_kwargs
     ):
         """The minimizer for the EC_x operates on the unbounded linear scale, estimating 
@@ -157,6 +173,9 @@ class ECxEstimator:
         method : str
             Minization algorithm. See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html
             Default: 'cobyla'
+
+        show_plot : bool
+            Show the results plot of the lpx. Default: True
         
         optimizer_kwargs :
             Additional arguments to pass to the optimizer
@@ -178,9 +197,18 @@ class ECxEstimator:
                 )
             else:
                 pass
+            
+            warnings.warn(
+                "Values passed to 'parameters' don't have an effect in mode='draws'"
+            )
 
         elif mode == "mean":
             draws = 1
+
+            warnings.warn(
+                "Values passed to 'parameters' don't have an effect in mode='draws'"
+            )
+
         elif mode == "manual":
             draws = 1
             if parameters is None:
@@ -220,6 +248,7 @@ class ECxEstimator:
                 ) 
 
                 success = opt_res.fun < accept_tol
+                iteration += 1
 
             # convert to linear scale from log scale
             factor = np.exp(opt_res.x)
@@ -229,24 +258,43 @@ class ECxEstimator:
             loss.append(opt_res.fun)
 
         res_full = pd.DataFrame(dict(factor = mult_factor, loss=loss, retries=iterations))
-        if sum(res_full.loss >= accept_tol) > 0:
+        self.results_full = res_full
+
+        metric = "{name}_{x}".format(name=self._name, x=int(self.x * 100),)
+
+        successes = sum(res_full.loss < accept_tol)
+        if successes < draws:
             warnings.warn(
-                f"Not all optimizations converged on the {self._name}_{self.x}. " +
+                f"Not all optimizations converged on the {metric} ({successes/draws*100}%). " +
                 "Adjust starting values and method")
             print(res_full)
+
+        short_msg = f"Estimation success rate: {successes/draws*100}%"
+        self.results["msg"] = short_msg
         
         res = res_full.loc[res_full.loss < accept_tol,:]
 
-        summary = {
-            "mean": np.round(np.mean(res.factor.values), 4),
-            "q05": np.round(np.quantile(res.factor.values, 0.05), 4),
-            "q95": np.round(np.quantile(res.factor.values, 0.95), 4),
-            "std": np.round(np.std(res.factor.values), 4),
-            "cv": np.round(np.std(res.factor.values)/np.mean(res.factor.values), 2),
-        }
+        if len(res) == 0:
+            self.msg = (
+                f"{metric} could not be found. Two reasons typically cause this problem: "+
+                f"1) no expoure before the time at which the {metric} is calculated. "+
+                "Check the the exposure profile. " + 
+                f"2) Too high background mortality. If the time at which the {metric} is "+
+                f"calculated is large and background mortality is high, the {metric}, " +
+                "may be reached independent of the effect and optimization cannot succeed."
+            )
 
-        self.results = pd.Series(summary)
-        self.results_full = res_full
+            print(self.msg)
+            return
+
+        self.results["mean"] = np.round(np.mean(res.factor.values), 4)
+        self.results["q05"] = np.round(np.quantile(res.factor.values, 0.05), 4)
+        self.results["q95"] = np.round(np.quantile(res.factor.values, 0.95), 4)
+        self.results["std"] = np.round(np.std(res.factor.values), 4)
+        self.results["cv"] = np.round(np.std(res.factor.values)/np.mean(res.factor.values), 2)
+
+        if show_plot:
+            self.plot_profile_and_effect(parameters=parameters)
 
         print("{name}_{x}".format(name=self._name, x=int(self.x * 100),))
         print(self.results)

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base/sim/report.py

@@ -1,5 +1,6 @@
 import os
 import itertools as it
+from typing import List
 import pandas as pd
 
 from pymob import SimulationBase
@@ -9,6 +10,8 @@ from guts_base.plot import plot_survival_multipanel
 from guts_base.sim.ecx import ECxEstimator
 
 class GutsReport(Report):
+    ecx_estimates_times: List = [1, 2, 4, 10]
+    ecx_estimates_x: List = [0.1, 0.25, 0.5, 0.75, 0.9]
 
     def additional_reports(self, sim: "SimulationBase"):
         super().additional_reports(sim=sim)
@@ -33,9 +36,9 @@ class GutsReport(Report):
 
     @reporting
     def LCx_estimates(self, sim):
-        X = [0.1, 0.25, 0.5, 0.75, 0.9]
-        T = [1, 2]
-        P = sim.predefined_scenarios
+        X = self.ecx_estimates_x
+        T = self.ecx_estimates_times
+        P = sim.predefined_scenarios()
 
         estimates = pd.DataFrame(
             it.product(X, T, P.keys()), 
@@ -57,6 +60,7 @@ class GutsReport(Report):
             ecx_estimator.estimate(
                 mode=sim.ecx_mode,
                 draws=250,
+                show_plot=False
             )
 
             ecx.append(ecx_estimator.results)
@@ -64,9 +68,6 @@ class GutsReport(Report):
         results = pd.DataFrame(ecx)
         estimates[results.columns] = results
 
-
-        estimates.to_csv()
-        file = os.path.join(sim.output_path, "lcx_estimates.csv")
-        lab = self._label.format(placeholder='$LC_x$ estimates')
-        self._write_table(tab=estimates, label_insert=f"$LC_x$ estimates \label{{{lab}}}]({os.path.basename(file)})")
+        out = self._write_table(tab=estimates, label_insert="$LC_x$ estimates")
         
+        return out

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 0.8.5
+Version: 0.8.6
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -686,14 +686,14 @@ Classifier: Natural Language :: English
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Requires-Python: >=3.10
+Requires-Python: <3.12,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: openpyxl>=3.1.3
 Requires-Dist: Bottleneck>=1.5.0
 Requires-Dist: expydb>=0.6.0
 Requires-Dist: mempyguts>=1.5.0
-Requires-Dist: pymob[numpyro]<1.0.0,>=0.4.1
+Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.4.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base.egg-info/SOURCES.txt

@@ -26,7 +26,9 @@ guts_base/sim/ecx.py
 guts_base/sim/mempy.py
 guts_base/sim/report.py
 tests/test_data_import.py
+tests/test_ecx.py
 tests/test_from_pymob.py
 tests/test_scripted_simulations.py
 tests/test_simulations.py
+tests/test_simulations_from_mempy.py
 tests/test_symbolic_solve.py

{guts_base-0.8.5 → guts_base-0.8.6}/guts_base.egg-info/requires.txt

@@ -2,7 +2,7 @@ openpyxl>=3.1.3
 Bottleneck>=1.5.0
 expydb>=0.6.0
 mempyguts>=1.5.0
-pymob[numpyro]<1.0.0,>=0.4.1
+pymob[interactive,numpyro]<0.6.0,>=0.4.1
 
 [dev]
 pytest>=7.3

{guts_base-0.8.5 → guts_base-0.8.6}/pyproject.toml

@@ -4,19 +4,19 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "guts_base"
-version = "0.8.5"
+version = "0.8.6"
 authors = [
   { name="Florian Schunck", email="fluncki@protonmail.com" },
 ]
 description = "Basic GUTS model implementation in pymob"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.10, <3.12"
 dependencies=[
     "openpyxl >= 3.1.3",
     "Bottleneck >= 1.5.0",
     "expydb >= 0.6.0",
     "mempyguts >= 1.5.0",
-    "pymob[numpyro] >= 0.4.1, < 1.0.0"
+    "pymob[numpyro,interactive] >= 0.4.1, < 0.6.0"
 ]
 license = {file = "LICENSE"}
 classifiers = [
@@ -49,7 +49,7 @@ import-openguts = "guts_base.data.openguts:create_database_and_import_data"
 convert-time-of-death-to-openguts = "guts_base.data.time_of_death:time_of_death_to_openguts"
 
 [tool.bumpver]
-current_version = "0.8.5"
+current_version = "0.8.6"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

guts_base-0.8.6/tests/test_ecx.py

@@ -0,0 +1,62 @@
+import pytest
+import arviz as az
+
+from guts_base import LPxEstimator, GutsBase
+
+from tests.conftest import construct_sim, idfunc
+
+
+# Derive simulations for testing from fixtures
+@pytest.fixture(params=[
+    (GutsBase, "red_sd_ia", "ecx/idata_red_sd_ia.nc", "FLUA.5"),
+    (GutsBase, "red_it", "ecx/idata_red_it.nc", "T 1"),
+], ids=idfunc,)
+def lpx_estimator(request, tmp_path):
+    simulation_class, scenario, idata, id = request.param
+    yield construct_estimator(
+        simulation_class=simulation_class,
+        scenario=scenario,
+        idata=idata, 
+        id=id,
+        output_path=tmp_path
+    )
+
+def construct_estimator(simulation_class, scenario, idata, id, output_path=None):
+    sim = construct_sim(
+        simulation_class=simulation_class, 
+        scenario=scenario,
+        output_path=output_path
+    )
+    sim.set_inferer("numpyro")
+    sim.inferer.idata = az.from_netcdf(f"data/testing/{idata}")
+
+    return LPxEstimator(sim=sim, id=id)
+
+@pytest.mark.slow
+def test_lp50(lpx_estimator):
+    # pytest.skip()
+
+    theta_mean = lpx_estimator.sim.inferer.idata.posterior.mean(("chain", "draw"))
+    theta_mean = {k: v["data"] for k, v in theta_mean.to_dict()["data_vars"].items()}
+
+    lpx_estimator._loss(log_factor=0.0, theta=theta_mean)
+
+    lpx_estimator.plot_loss_curve()
+
+    lpx_estimator.estimate(mode="mean")
+    lpx_estimator.estimate(mode="manual", parameters=lpx_estimator._posterior_mean())
+    lpx_estimator.estimate(mode="draws")
+
+    lpx_estimator.results
+    lpx_estimator.results_full
+
+def test_copy(lpx_estimator):
+    e = lpx_estimator.sim.dispatch()
+    e()
+    e.results
+
+
+if __name__ == "__main__":
+    # test_inference(sim=construct_sim("test_scenario_v2", Simulation_v2), backend="numpyro")
+    # test_lp50(simulation_class=GutsBase, scenario="red_sd_ia", idata="ecx/idata_red_sd_ia.nc", id="FLUA.5")
+    test_copy(construct_estimator(GutsBase, "red_sd_ia", "ecx/idata_red_sd_ia.nc", "FLUA.5"))

guts_base-0.8.6/tests/test_simulations.py

@@ -0,0 +1,87 @@
+import pytest
+
+from guts_base import GutsBase
+
+from tests.conftest import construct_sim, idfunc
+
+# List test scenarios and simulations
+@pytest.fixture(params=[
+    (GutsBase, "red_sd"),
+    (GutsBase, "red_it"),
+    (GutsBase, "red_sd_ia"),
+], ids=idfunc)
+def sim_and_scenario(request):
+    return request.param
+
+
+# Derive simulations for testing from fixtures
+@pytest.fixture
+def sim(sim_and_scenario, tmp_path):
+    simulation_class, scenario = sim_and_scenario
+    yield construct_sim(
+        scenario=scenario, 
+        simulation_class=simulation_class, 
+        output_path=tmp_path
+    )
+
+
+# run tests with the Simulation fixtures
+def test_setup(sim):
+    """Tests the construction method"""
+    assert True
+
+
+def test_simulation(sim):
+    """Tests if a forward simulation pass can be computed"""
+    sim.dispatch_constructor()
+    evaluator = sim.dispatch()
+    evaluator()
+    evaluator.results
+
+    assert True
+            
+def test_copy(sim):
+    sim.dispatch_constructor()
+    e_orig = sim.dispatch()
+    e_orig()
+    e_orig.results
+
+    sim_copy = sim.copy()
+    
+    sim_copy.dispatch_constructor()
+    e_copy = sim_copy.dispatch()
+    e_copy()
+
+    assert (e_copy.results == e_orig.results).all().to_array().all().values
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("backend", ["numpyro"])
+def test_inference(sim: GutsBase, backend):
+    """Tests if prior predictions can be computed for arbitrary backends"""
+    sim.dispatch_constructor()
+    sim.set_inferer(backend)
+
+    sim.config.inference.n_predictions = 2
+    sim.prior_predictive_checks()
+    
+    sim.config.inference_numpyro.kernel = "svi"
+    sim.config.inference_numpyro.svi_iterations = 10
+    sim.config.inference_numpyro.svi_learning_rate = 0.05
+    sim.config.inference_numpyro.draws = 10
+    sim.config.inference.n_predictions = 10
+
+    sim.inferer.run()
+
+    sim.inferer.idata
+    sim.inferer.store_results()
+
+    sim.posterior_predictive_checks()
+
+    sim.inferer.load_results()
+    sim.config.report.debug_report = True
+    sim.report()
+
+
+if __name__ == "__main__":
+    test_inference(sim=construct_sim("red_sd", GutsBase), backend="numpyro")

guts_base-0.8.6/tests/test_simulations_from_mempy.py

@@ -0,0 +1,119 @@
+from typing import Tuple
+import pytest
+import numpy as np
+import xarray as xr
+from mempy.model import (
+    RED_IT, RED_SD, RED_SD_DA, Reduced,
+    BufferGUTS_SD, BufferGUTS_IT, BufferGUTS_SD_CA
+)
+from mempy.input_data import read_exposure_survival
+from guts_base import PymobSimulator
+
+from tests.conftest import idfunc
+
+# results are from Bürger and Focks 2025 (https://doi.org/10.1093/etojnl/vgae058) 
+# supplementary material (Tab. 5.3)
+OPENGUTS_ESTIMATES = dict(
+    red_sd = xr.Dataset(dict(kd=0.712, m=2.89, b=0.619, hb=0.008)).to_array().sortby("variable"),
+    red_sd_da = None,
+    bufferguts_sd_ca = None,
+)
+
+def read_data(file):
+    data = read_exposure_survival(
+        "data/testing", file, 
+        survival_name="Survival",
+        exposure_name="Exposure",
+        visualize=False,
+        with_raw_exposure_data=True
+    )
+
+    exposure_funcs, survival_data, num_expos, exposure_data = data
+    info_dict = {}
+
+    return exposure_funcs, survival_data, num_expos, info_dict, exposure_data
+
+
+def construct_sim(dataset: Tuple, model: type, output_path="results/testing"):
+    """Helper function to construct simulations for debugging"""
+    _, survival_data, num_expos, _, exposure_data = read_data(file=dataset)
+
+    if model in (RED_IT, RED_SD, BufferGUTS_SD, BufferGUTS_IT):
+        _model = model()
+    else:
+        _model = model(num_expos=num_expos)
+
+    sim = PymobSimulator.from_mempy(
+        exposure_data=exposure_data,
+        survival_data=survival_data,
+        model=_model,
+        output_directory=output_path
+    )
+
+    return sim
+
+
+@pytest.fixture(params=[
+    ("ringtest_A_SD.xlsx", RED_SD),
+    ("Fit_Data_Cloeon_final.xlsx", RED_SD_DA,),
+    ("osmia_multiexpo_synthetic.xlsx", BufferGUTS_SD_CA,),
+], ids=idfunc)
+def dataset_and_model(request) -> Reduced:
+    yield request.param
+
+
+# Derive simulations for testing from fixtures
+@pytest.fixture
+def sim(dataset_and_model, tmp_path):
+    dataset, model = dataset_and_model
+    yield construct_sim(dataset=dataset, model=model, output_path=tmp_path)
+
+
+# run tests with the Simulation fixtures
+def test_setup(sim):
+    """Tests the construction method"""
+    assert True
+
+
+def test_simulation(sim):
+    """Tests if a forward simulation pass can be computed"""
+    # sim.dispatch_constructor()
+    evaluator = sim.dispatch()
+    evaluator()
+    evaluator.results
+
+    assert True
+
+@pytest.mark.slow
+@pytest.mark.parametrize("backend", ["numpyro"])
+def test_inference(sim: PymobSimulator, backend):
+    """Tests if prior predictions can be computed for arbitrary backends"""
+
+    sim.set_inferer(backend)
+
+    sim.prior_predictive_checks()
+    sim.inferer.run()
+
+    sim.posterior_predictive_checks()
+
+    sim.config.report.debug_report = True
+    sim.report()
+
+    # test if inferer converged on the true estmiates
+    pymob_estimates = sim.inferer.idata.posterior.mean(("chain", "draw")).to_array().sortby("variable")
+    openguts_estimates = OPENGUTS_ESTIMATES[sim.config.simulation.model.lower()]
+
+    if openguts_estimates is None:
+        # this explicitly skips testing the results, since they are not available,
+        # but does not fail the test.
+        pytest.skip()
+
+    np.testing.assert_allclose(pymob_estimates, openguts_estimates, rtol=0.05, atol=0.1)
+
+
+
+
+if __name__ == "__main__":
+    # test_inference(sim=construct_sim("ringtest_A_SD.xlsx", RED_SD), backend="numpyro",)
+    test_inference(sim=construct_sim("osmia_multiexpo_synthetic.xlsx", BufferGUTS_SD_CA), backend="numpyro",)
+    # test_inference(sim=construct_sim("Fit_Data_Cloeon_final.xlsx", RED_SD_DA), backend="numpyro",)

guts_base-0.8.5/tests/test_simulations.py

@@ -1,109 +0,0 @@
-import pytest
-import arviz as az
-
-from guts_base import LPxEstimator, GutsBase
-from mempy.model import RED_SD_DA, RED_IT
-
-def construct_sim(scenario, simulation_class):
-    """Helper function to construct simulations for debugging"""
-    sim = simulation_class(f"scenarios/{scenario}/settings.cfg")
-
-    # this sets a different output directory
-    sim.config.case_study.scenario = "testing"
-    sim.setup()
-    return sim
-
-
-# List test scenarios and simulations
-@pytest.fixture(scope="session", params=[
-    # (GutsBase, "red_sd"),
-])
-def sim_and_scenario(request):
-    return request.param
-
-
-# Derive simulations for testing from fixtures
-@pytest.fixture(scope="session")
-def sim(sim_and_scenario):
-    simulation_class, scenario = sim_and_scenario
-    yield construct_sim(scenario, simulation_class)
-
-
-# run tests with the Simulation fixtures
-def test_setup(sim):
-    """Tests the construction method"""
-    assert True
-
-
-def test_simulation(sim):
-    """Tests if a forward simulation pass can be computed"""
-    sim.dispatch_constructor()
-    evaluator = sim.dispatch()
-    evaluator()
-    evaluator.results
-
-    assert True
-            
-
-@pytest.mark.slow
-@pytest.mark.parametrize("backend", ["numpyro"])
-def test_inference(sim: GutsBase, backend):
-    """Tests if prior predictions can be computed for arbitrary backends"""
-    sim.dispatch_constructor()
-    sim.set_inferer(backend)
-
-    sim.config.inference.n_predictions = 2
-    sim.prior_predictive_checks()
-    
-    sim.config.inference_numpyro.kernel = "svi"
-    sim.config.inference_numpyro.svi_iterations = 10
-    sim.config.inference_numpyro.svi_learning_rate = 0.05
-    sim.config.inference_numpyro.draws = 10
-    sim.config.inference.n_predictions = 10
-
-    sim.inferer.run()
-
-    sim.inferer.idata
-    sim.inferer.store_results()
-
-    sim.posterior_predictive_checks()
-
-    sim.inferer.load_results()
-    sim.config.report.debug_report = True
-    sim.report()
-
-@pytest.mark.slow
-@pytest.mark.parametrize("model,dataset,idata,id", [
-    (RED_SD_DA, "Fit_Data_Cloeon_final.xlsx", "idata_red_sd_da.nc", "FLUA.5"),
-    (RED_IT, "ringtest_A_IT.xlsx", "idata_red_it.nc", "T 1")
-])
-def test_lp50(model, dataset, idata, id):
-    pytest.skip()
-    sim=construct_sim(dataset=dataset, model=model)
-    sim.set_inferer("numpyro")
-    sim.inferer.idata = az.from_netcdf(f"data/testing/{idata}")
-
-    lpx_estimator = LPxEstimator(sim=sim, id=id)
-
-    theta_mean = lpx_estimator.sim.inferer.idata.posterior.mean(("chain", "draw"))
-    theta_mean = {k: v["data"] for k, v in theta_mean.to_dict()["data_vars"].items()}
-
-    lpx_estimator._loss(log_factor=0.0, theta=theta_mean)
-
-    lpx_estimator.plot_loss_curve()
-
-    lpx_estimator.estimate(mode="mean")
-    lpx_estimator.plot_profile_and_effect()
-    lpx_estimator.estimate(mode="manual", parameters=lpx_estimator._posterior_mean())
-    lpx_estimator.plot_profile_and_effect(parameters=lpx_estimator._posterior_mean())
-
-    lpx_estimator.estimate(mode="draws")
-    lpx_estimator.plot_profile_and_effect()
-
-    lpx_estimator.results
-    lpx_estimator.results_full
-
-
-if __name__ == "__main__":
-    # test_inference(sim=construct_sim("test_scenario_v2", Simulation_v2), backend="numpyro")
-    test_inference(sim=construct_sim("red_it", GutsBase), backend="numpyro",)