guts-base 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

guts_base/__init__.py

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

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/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/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/sim/ecx.py

@@ -37,23 +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.observations = self.sim.expand_batch_like_coordinate_to_new_dimension(
-        #     coordinate="exposure_path",
-        #     variables=["Flupyradifurone"]
-        # )
-
-        # self.sim.config.data_structure.remove("Flupyradifurone")
-
-        # # TODO: COnstruct a sim if the input dims change
-        # self.sim.config.data_structure.exposure.dimensions = ["id", "time", "exposure_path"]
         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. 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):
@@ -114,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 
@@ -163,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
@@ -184,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:
@@ -226,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)
@@ -235,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/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.4.dist-info → guts_base-0.8.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 0.8.4
+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.4.dist-info → guts_base-0.8.6.dist-info}/RECORD

@@ -1,24 +1,24 @@
-guts_base/__init__.py,sha256=nbBkodGA6V5dM32zjrIl92M4GymO9qogbJ9UhREwZ18,208
-guts_base/mod.py,sha256=gGXV8j4Xm4HprN3wCUuWitIlwxU4SO3TuenE0bk8czE,7247
+guts_base/__init__.py,sha256=dYv5zH5jYPdPZXIzku6YPkvB47XD8qaTlY-0olh-4cA,208
+guts_base/mod.py,sha256=aLb09E-6CwgKgq0GbwIT_Alv167cVFA5zAxwx80F1aE,7454
 guts_base/plot.py,sha256=rjIzyPUikOtubjWI5mX_ZY8ARWl2NiHDmwAZAdoaPS8,5693
 guts_base/prob.py,sha256=k1b-gc8yZNg8DMnxJHJzCy8Pud8_qEygGkrnmS2AcMY,14004
 guts_base/sim.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guts_base/data/__init__.py,sha256=U5sJJgPwEVHVGTLeZNwl8VKLIgn1twpDNkOCMRSV1Nk,808
 guts_base/data/expydb.py,sha256=Kcc6CeZMl3oEelk5UBN9VEfwgNF3CzTh13ooVkufAjE,8218
-guts_base/data/generator.py,sha256=RBlPYIdFBGzTmcbTPWRqD2UrgejuZ4PmAdLq4ajc0LM,2887
+guts_base/data/generator.py,sha256=fos7y-xxTlBVpYsHD_2kdYSH40KILPUQ_Jy0mwjO5jc,2897
 guts_base/data/openguts.py,sha256=WvhYl_AOdvNgzrcVS2f_PYbXNH_wSAz2uIBSR6BMSh0,11078
 guts_base/data/preprocessing.py,sha256=qggYkx2x62ingU1BNhJFyL1eQdFQsDJR2lefVfVWW2U,1732
 guts_base/data/survival.py,sha256=yNNZ7MabzrMeqPHOa8-LPxCgsIN4_X0aj_ANmeC9Wd8,4878
 guts_base/data/time_of_death.py,sha256=hwngUwfRP3u8WmD3dHyXrphuu5d8ZJTKyBovGRwAHNQ,21014
 guts_base/data/utils.py,sha256=u3gGDJK15MfRUP4iIxsS-I1oqxD2qH_ugsT7o_Eac18,236
 guts_base/sim/__init__.py,sha256=vgZu2oi4RHIQuLS19570xBdLQasL75puxabGrbLuIGA,276
-guts_base/sim/base.py,sha256=dgMJdgNNXM-89fKN6hvSu1UCtdR-6cxVoa4F0MHknV4,18037
-guts_base/sim/ecx.py,sha256=dUK4PNqivlKU6VZO2SzJFJaTJJp-A5LOuBEEr80wzaI,12872
+guts_base/sim/base.py,sha256=lxfHQ57pXKz1ZGnFqOIoeUplzvFWM1OjDX0xYQpSgaw,20921
+guts_base/sim/ecx.py,sha256=IvZQnmMs3FLX6unuj7mPv2AaZ7l-S4TJmYmPI4fXE1k,14573
 guts_base/sim/mempy.py,sha256=xsA3Q7jQrdcmQZJzKBdQnr8yZk-f36YgbLlV-VvJpxg,9514
-guts_base/sim/report.py,sha256=EextbyUn3nsgTm16P_rWPOqCtknu9a99VuAk3vvstf4,1992
-guts_base-0.8.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-guts_base-0.8.4.dist-info/METADATA,sha256=8GhahXAzqPd9U96EWE3ewHvRMCKpIof5cfoD7e1rDpg,45419
-guts_base-0.8.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-guts_base-0.8.4.dist-info/entry_points.txt,sha256=icsHzG2jQ90ZS7XvLsI5Qj0-qGuPv2T0RBVN5daGCPU,183
-guts_base-0.8.4.dist-info/top_level.txt,sha256=PxhBgUd4r39W_VI4FyJjARwKbV5_glgCVnd6v_zAGdE,10
-guts_base-0.8.4.dist-info/RECORD,,
+guts_base/sim/report.py,sha256=D_6eoSvjdcsDtB0PlmNkzC1LRk_7WXzb_T6D6AZjQNE,1985
+guts_base-0.8.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+guts_base-0.8.6.dist-info/METADATA,sha256=n0OWLZd2CZWg7j7M2sqcXfFuiOSPqSG60KvQ9IuoqHM,45437
+guts_base-0.8.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+guts_base-0.8.6.dist-info/entry_points.txt,sha256=icsHzG2jQ90ZS7XvLsI5Qj0-qGuPv2T0RBVN5daGCPU,183
+guts_base-0.8.6.dist-info/top_level.txt,sha256=PxhBgUd4r39W_VI4FyJjARwKbV5_glgCVnd6v_zAGdE,10
+guts_base-0.8.6.dist-info/RECORD,,