guts-base 1.0.0__tar.gz → 1.0.2__tar.gz

{guts_base-1.0.0 → guts_base-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 1.0.0
+Version: 1.0.2
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -693,6 +693,7 @@ Requires-Dist: openpyxl>=3.1.3
 Requires-Dist: Bottleneck>=1.5.0
 Requires-Dist: expydb>=0.6.0
 Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.5.10
+Requires-Dist: pint
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base/__init__.py

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

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base/plot.py

@@ -1,3 +1,4 @@
+from cycler import cycler
 import numpy as np
 import arviz as az
 from matplotlib import pyplot as plt
@@ -119,8 +120,7 @@ def plot_survival_multipanel(sim, results, ncols=6, title=lambda _id: _id):
     for _id, ax in zip(sim.observations.id.values, axes):
         ax.set_ylim(-0.05,1.05)
 
-        # TODO: use time unit from observations (?)
-        ax.set_xlabel("Time")
+        ax.set_xlabel(f"Time [{sim.unit_time}]")
         ax.set_ylabel("Survival")
         ax.plot(mean.time, mean.sel(id=_id).survival.T, **plot_kwargs)
         ax.fill_between(hdi.time, *hdi.sel(id=_id).survival.T, alpha=.5, **plot_kwargs)
@@ -133,6 +133,38 @@ def plot_survival_multipanel(sim, results, ncols=6, title=lambda _id: _id):
 
     return out
 
+def plot_exposure_multipanel(sim, results, ncols=6, title=lambda _id: _id):
+
+    n_panels = results.sizes["id"]
+
+    nrows = int(np.ceil(n_panels / ncols))
+
+    fig, axes = plt.subplots(nrows, ncols, sharex=True, figsize=(ncols*2+2, nrows*1.5+2))
+    axes = axes.flatten()
+    mean = results
+
+    plot_kwargs = {"color": "black"}
+    custom_cycler = (
+        cycler(ls=["-", "--", ":", "-."])
+    )
+    for _id, ax in zip(sim.observations.id.values, axes):
+        ax.set_prop_cycle(custom_cycler)
+
+        ax.set_xlabel(f"Time [{sim.unit_time}]")
+        ax.set_ylabel("Exposure")
+        for expo in sim.coordinates[sim._exposure_dimension]:
+            ax.plot(
+                mean.time, mean.sel({"id":_id, sim._exposure_dimension: expo}).exposure, 
+                **plot_kwargs, label=f"Exposure: {expo}"
+            )
+        ax.set_title(title(_id))
+        ax.legend(fontsize=7)
+
+    out = f"{sim.output_path}/exposure_multipanel.png"
+    fig.tight_layout()
+    fig.savefig(out)
+
+    return out
 
 def multipanel_title(sim, _id): 
     oid = sim.observations.sel(id=_id)

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base/sim/__init__.py

@@ -10,7 +10,7 @@ from .base import (
 )
 
 from .ecx import ECxEstimator, LPxEstimator
-from .report import GutsReport
+from .report import GutsReport, ParameterConverter
 
 from .mempy import PymobSimulator
 from .utils import (

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base/sim/base.py

@@ -3,16 +3,19 @@ import glob
 from functools import partial
 from copy import deepcopy
 import importlib
+import tempfile
 import warnings
 import numpy as np
 import xarray as xr
 from diffrax import Dopri5
 from typing import Literal, Optional, List, Dict, Mapping, Sequence, Tuple
-import tempfile
 import pandas as pd
+import pint
 
 from pymob import SimulationBase
-from pymob.sim.config import DataVariable, Param, string_to_list, NumericArray
+from pymob.sim.config import (
+    DataVariable, Param, string_to_list, string_to_dict, NumericArray
+)
 
 from pymob.solvers import JaxSolver
 from pymob.solvers.base import rect_interpolation
@@ -29,6 +32,8 @@ from guts_base.data import (
 )
 from guts_base.sim.report import GutsReport
 
+ureg = pint.UnitRegistry()
+
 class GutsBase(SimulationBase):
     """
     Initializes GUTS models from a variety of data sources 
@@ -43,6 +48,7 @@ class GutsBase(SimulationBase):
     Report = GutsReport
     results_interpolation: Tuple[float,float,int] = (np.nan, np.nan, 100)
     _skip_data_processing: bool = False
+    ecx_mode: Literal["mean", "draws"] = "mean"
 
     def initialize(self, input: Optional[Dict] = None):
         """Initiaization goes through a couple of steps:
@@ -90,8 +96,6 @@ class GutsBase(SimulationBase):
             self.model = self._model_class._rhs_jax
             self.solver_post_processing = self._model_class._solver_post_processing
 
-        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
@@ -107,6 +111,8 @@ class GutsBase(SimulationBase):
                 int(results_interpolation_string[2])
             )
 
+        self._determine_background_mortality_parameter()
+
     def prepare_simulation_input(self):
         x_in = self.parse_input(input="x_in", reference_data=self.observations, drop_dims=[])
         y0 = self.parse_input(input="y0", reference_data=self.observations, drop_dims=["time"])
@@ -132,7 +138,18 @@ class GutsBase(SimulationBase):
             Timeseries.name == {exposure_path}
         )
 
-    def read_data(self):
+    def read_data(self) -> xr.Dataset:
+        """Reads data and returns an xarray.Dataset. 
+        
+        GutsBase supports reading data from
+        - netcdf (.nc) files
+        - expyDB (SQLite databases)
+        - excel  (directories of excel files)
+
+        expyDB and excel operate by converting data to xarrays while netcdf directly
+        loads xarray Datasets. For highest control over your data, you should always use
+        .nc files, because they are imported as-is.
+        """
         # TODO: Update to new INTERVENTION MODEL
         dataset = str(self.config.case_study.observations)
         
@@ -215,11 +232,9 @@ class GutsBase(SimulationBase):
         Currently these methods, change datasets, indices, etc. in-place.
         This is convenient, but more difficult to re-arragen with other methods
         TODO: Make these methods static if possible
-
         """
         self._create_indices()
         self._indices_to_dimensions()
-
         # define tolerance based on the sovler tolerance
         self.observations = self.observations.assign_coords(eps=self.config.jaxsolver.atol * 10)
 
@@ -237,6 +252,89 @@ class GutsBase(SimulationBase):
         if "exposure" in self.observations:
             self.config.data_structure.exposure.observed=False
 
+    def _convert_exposure_units(self):
+        """
+        TODO: Here I need to decide what to do. Work with rescaled units is dangerous
+        because fitting might be complicated with weird quantities.
+        It would be better to rescale output parameters
+        """
+        if not hasattr(self.config.simulation, "unit_exposure"):
+            return
+         
+        units, unit_conversion_factors = self._convert_units(
+            self.observations.unit.reset_coords("unit", drop=True),
+            target_units=self.config.simulation.unit_exposure 
+        )
+
+        self.observations = self.observations.assign_coords({
+            "unit": units,
+            "unit_conversion_factors": unit_conversion_factors
+        })
+
+        self.observations[self.config.simulation.substance] =\
+              self.observations[self.config.simulation.substance] * unit_conversion_factors
+
+    @staticmethod
+    def _unique_unsorted(values):
+        _, index = np.unique(values, return_index=True)
+        return tuple(np.array(values)[sorted(index)])
+
+    @staticmethod
+    def _convert_units(
+        units: xr.DataArray, 
+        target_units: Dict[str,str]
+    ) -> Tuple[xr.DataArray, xr.DataArray]:
+        """Converts units of values associated with the exposure dimension
+        TODO: Converting before inference could be problem for the calibration, because
+        it is usually good if the values are both not too small and not too large 
+        """
+
+        if len(units.dims) != 1:
+            raise GutsBaseError(
+                "GutsBase_convert_exposure_units only supports 1 dimensional exposure units"
+            )
+        
+        _dim = units.dims[0]
+        _coordinates = units.coords[_dim]
+
+        converted_units = {}
+        _target_units = {}
+
+        for coord in _coordinates.values:
+            unit = str(units.sel({_dim: coord}).values)
+            
+            # get item from config
+            unit_mapping =  string_to_dict(target_units)
+            # split transformation expression from target expression
+            transform, target = unit_mapping[coord].split("->")
+            # insert unit from observations coordinates
+            transform = transform.format(x=unit)
+            
+            # parse and convert units
+            new_unit = ureg.parse_expression(transform).to(target)
+            converted_units.update({coord: new_unit})
+            _target_units.update({coord: target})
+            
+        _units = {k: f"{cu.units:C}" for k, cu in converted_units.items()}
+
+        # assert whether the converted units are the same as the target units
+        # so the target units can be used, because the converted units may reduce
+        # to dimensionless quantities.
+        if not all([
+            cu.units == ureg.parse_expression(tu) 
+            for cu, tu in zip(converted_units.values(), _target_units.values())
+        ]):
+            raise GutsBaseError(
+                f"Mismatch between target units {_target_units} and converted units " +
+                f"{converted_units}."
+            )
+
+        _conversion_factors = {k: cu.magnitude for k, cu in converted_units.items()}
+        new_unit_coords = xr.Dataset(_target_units).to_array(dim=_dim)
+        conversion_factor_coords = xr.Dataset(_conversion_factors).to_array(dim=_dim)
+
+        return new_unit_coords, conversion_factor_coords
+
     def _create_indices(self):
         """Use if indices should be added to sim.indices and sim.observations"""
         pass
@@ -273,6 +371,18 @@ class GutsBase(SimulationBase):
             "is calculated without a dense time resolution, the estimates can be biased!"
         ))
 
+    def _determine_background_mortality_parameter(self):
+        if "hb" in self.config.model_parameters.all:
+            self.background_mortality = "hb"
+        elif "h_b" in self.config.model_parameters.all:
+            self.background_mortality = "h_b"
+        else:
+            raise GutsBaseError(
+                "The background mortality parameter is not defined as 'hb' or 'h_b'. " +
+                f"The defined parameters are {self.config.model_parameters.all}"
+            )
+
+
     def recompute_posterior(self):
         """This function interpolates the posterior with a given resolution
         posterior_predictions calculate proper survival predictions for the
@@ -414,6 +524,28 @@ class GutsBase(SimulationBase):
         arrays = {"survival": survival_array}
         return xr.Dataset(arrays)
 
+    @property
+    def _exposure_dimension(self):
+        standard_dims = [
+            self.config.simulation.batch_dimension, 
+            self.config.simulation.x_dimension
+        ]
+        
+        extra_dims = []
+        for k in self.config.data_structure["exposure"].dimensions:
+            if k not in standard_dims:
+                extra_dims.append(k)
+            else:
+                pass
+
+        if len(extra_dims) > 1:
+            raise GutsBaseError(
+                "Guts Base can currently only handle one exposure dimension beside" +
+                "the standard dimensions."
+            )
+        else:
+            return extra_dims[0]
+        
 
     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
@@ -452,6 +584,7 @@ class GutsBase(SimulationBase):
             # apply automatic broadcasting to increase the size of the new dimension
             # data_var_np1_d = data_var * dummy_3d
             data_var_np1_d = data_var * dummy_categorical
+            data_var_np1_d.attrs = data_var.attrs
 
             # annotate coordinates of the new dimension
             data_var_np1_d = data_var_np1_d.assign_coords({
@@ -464,6 +597,40 @@ class GutsBase(SimulationBase):
 
         return obs
 
+    def map_batch_coordinates_to_extra_dim_coordinates(
+        self, 
+        observations: xr.Dataset, 
+        target_dimension: str,
+        coordinates: Optional[List[str]] = None
+    ) -> xr.Dataset:
+        """Iterates over coordinates and reduces those coordinates to the new dimension
+        which have the same number of unique coordinates as the new dimension has coordinates
+        """
+        if coordinates is None:
+            coordinates = list(observations.coords.keys())
+
+        for key, coord in observations.coords.items():
+            # skips coords, if not specified in coordinates
+            if key not in coordinates:
+                continue
+
+            if self.config.simulation.batch_dimension in coord.dims and key not in observations.dims:
+                if len(coord.dims) == 1:
+                    dim_coords = self._unique_unsorted(coord.values)
+                    if len(dim_coords) == len(observations[target_dimension]):
+                        observations[key] = (target_dimension, list(dim_coords))
+                    else:
+                        pass
+                else:
+                    warnings.warn(
+                        f"Coordinate '{key}' is has dimensions {coord.dims}. " +
+                        "Mapping coordinates with more than 1 dimension to the extra " +
+                        f"dimension '{target_dimension}' is not supported yet."
+                    )
+                    pass
+
+        return observations
+                
 
     def reduce_dimension_to_batch_like_coordinate(self, dimension, variables):
         """This method takes an existing dimension from a N-D array and reduces it to an
@@ -639,6 +806,60 @@ class GutsBase(SimulationBase):
         self.config.simulation.skip_data_processing = False
         super().export(directory=directory)
 
+    def copy(self):
+        """Creates a copy of a SimulationBase object by deepcopying all loose references
+        TODO: If this works out well integrate into pymob. I have the feeling there will
+        still be some problems down the line.
+        """
+        with warnings.catch_warnings(action="ignore"):
+            # using the context manager here will not work, because it will prematurely
+            # remove the tempdir and its contents. This interacts badly with netcdf files.
+            # which are only transferred into memory when the contents are needed. 
+            tempdir = tempfile.TemporaryDirectory()
+            self.export(directory=tempdir.name)
+            print(os.listdir(tempdir.name))
+            sim_copy = type(self).from_directory(tempdir.name)
+
+            # set this attribute so that it can be cleaned up after the copied sim is
+            # no longer necessary.
+            sim_copy.tempdir = tempdir
+
+        return sim_copy
+
+    @staticmethod
+    def _condition_posterior(
+        posterior: xr.Dataset, 
+        parameter: str, 
+        value: float, 
+        exception: Literal["raise", "warn"]="raise"
+    ):
+        """TODO: Provide this method also to SimulationBase"""
+        if parameter not in posterior:
+            keys = list(posterior.keys())
+            msg = (
+                f"{parameter=} was not found in the posterior {keys=}. " +
+                f"Unable to condition the posterior to {value=}. Have you "+
+                "requested the correct parameter for conditioning?"
+            )
+
+            if exception == "raise":
+                raise GutsBaseError(msg)
+            elif exception == "warn":
+                warnings.warn(msg)
+            else:
+                raise GutsBaseError(
+                    "Use one of exception='raise' or exception='warn'. " +
+                    f"Currently using {exception=}"
+                )
+
+        # broadcast value so that methods like drawing samples and hdi still work
+        broadcasted_value = np.full_like(posterior[parameter], value)
+
+        return posterior.assign({
+            parameter: (posterior[parameter].dims, broadcasted_value)
+        })
+
+
 class GutsSimulationConstantExposure(GutsBase):
     t_max = 10
     def initialize_from_script(self):

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base/sim/ecx.py

@@ -23,6 +23,25 @@ class ECxEstimator:
         This must be a pymob.SimulationBase object. If the ECxEstimator.estimate method
         is used with the modes 'draw' or 'mean'    
     
+    effect : str
+        The data variable for which the effect concentration is computed. This is one
+        of sim.observations and sim.results
+
+    x : float
+        Effect level. This is the level of the effect, for which the concentration is 
+        computed.
+
+    time : float
+        Time at which the ECx is computed
+
+    x_in : xr.Dataset
+        The model input 'x_in' for which the effect is computed.
+    
+    conditionals_posterior : Dict
+        Dictionary that overwrites values in the posterior. This is useful if for instance
+        background mortality should be set to a fixed value (e.g. zero). Consequently this
+        setting does not take effect in estimation mode 'manual' but only for mean and 
+        draws. Defaults to an empty dict (no conditions applied).
     """
     _name = "EC"
     _parameter_msg = (
@@ -40,23 +59,30 @@ class ECxEstimator:
         x: float,
         time: float, 
         x_in: xr.Dataset, 
+        conditions_posterior: Dict[str, float] = {}
     ):
         self.sim = sim.copy()
         self.time = time
         self.x = x
         self.effect = effect
         self._mode = None
+        self._conditions_posterior = conditions_posterior
 
         # creates an empty observation dataset with the coordinates of the
         # original observations (especially time), except the ID, which is overwritten
         # and taken from the x_in dataset
         pseudo_obs = self.sim.observations.isel(id=[0])
-        pseudo_obs = pseudo_obs.drop(["exposure","survival"])
+        pseudo_obs = pseudo_obs.drop([v for v in pseudo_obs.data_vars.keys()])
         pseudo_obs["id"] = x_in["id"]
         
         self.sim.config.data_structure.survival.observed = False
         self.sim.observations = pseudo_obs
 
+        # overwrite x_in to make sure that parse_input takes x_in from exposure and
+        # does not use the string that is tied to another data variable which was
+        # originally present
+        self.sim.config.simulation.x_in = ["exposure=exposure"]
+
         # 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)
 
@@ -69,7 +95,7 @@ class ECxEstimator:
             self.sim.coordinates["time"], np.array(time, ndmin=1)
         ]))
 
-        self.sim.model_parameters["y0"] = self.sim.parse_input("y0", drop_dims="time")
+        self.sim.model_parameters["y0"] = self.sim.parse_input("y0", drop_dims=["time"])
         self.sim.dispatch_constructor()
 
         self.results = pd.Series({
@@ -84,6 +110,12 @@ class ECxEstimator:
         self.figure_profile_and_effect = None
         self.figure_loss_curve = None
 
+        self.condition_posterior_parameters(conditions=conditions_posterior)
+
+    def __del__(self):
+        if hasattr(self.sim, "tempdir"):
+            self.sim.tempdir.cleanup()
+
 
     def _assert_posterior(self):
         try:
@@ -94,7 +126,14 @@ class ECxEstimator:
                 "('sim.inferer.idata.posterior'). " + self._parameter_msg
             )
 
-
+    def condition_posterior_parameters(self, conditions: Dict[str, float]):
+        for parameter, value in conditions.items():
+            self.sim.inferer.idata.posterior = self.sim._condition_posterior(
+                posterior=self.sim.inferer.idata.posterior,
+                parameter=parameter,
+                value=value,
+                exception="raise",
+            )
     
     def _evaluate(self, factor, theta):
         evaluator = self.sim.dispatch(
@@ -223,23 +262,31 @@ class ECxEstimator:
             else:
                 pass
             
-            warnings.warn(
-                "Values passed to 'parameters' don't have an effect in mode='draws'"
-            )
+            if parameters is not None:
+                warnings.warn(
+                    "Values passed to 'parameters' don't have an effect in mode='draws'"
+                )
 
         elif mode == "mean":
             self._assert_posterior()
 
             draws = 1
 
-            warnings.warn(
-                "Values passed to 'parameters' don't have an effect in mode='draws'"
-            )
+            if parameters is not None:
+                warnings.warn(
+                    "Values passed to 'parameters' don't have an effect in mode='draws'"
+                )
 
         elif mode == "manual":
             draws = 1
             if parameters is None:
                 raise GutsBaseError(self._parameter_msg)
+            
+            if self._conditions_posterior is not None:
+                warnings.warn(
+                    "Conditions applied to the posterior do not take effect in mode 'manual'"
+                )
+
         else:
             raise GutsBaseError(
                 f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"

guts_base-1.0.2/guts_base/sim/report.py

@@ -0,0 +1,178 @@
+import os
+import itertools as it
+from typing import List, Dict
+import numpy as np
+import pandas as pd
+import xarray as xr
+
+from pymob import SimulationBase
+from pymob.sim.report import Report, reporting
+
+from guts_base.plot import plot_survival_multipanel, plot_exposure_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]
+    set_background_mortality_to_zero = True
+
+    def additional_reports(self, sim: "SimulationBase"):
+        super().additional_reports(sim=sim)
+        self.model_fits(sim)
+        self.LCx_estimates(sim)
+
+    @reporting
+    def model_input(self, sim: SimulationBase):
+        self._write("### Exposure conditions")
+        self._write(
+            "These are the exposure conditions that were assumed for parameter inference. "+
+            "Double check if they are aligned with your expectations. Especially short " +
+            "exposure durations may not be perceivable in this view. In this case it is "+
+            "recommended to have a look at the exposure conditions in the numerical "+
+            "tables provided below." 
+        )
+        
+        out_mp = plot_exposure_multipanel(
+            sim=sim,
+            results=sim.model_parameters["x_in"],
+            ncols=6,
+        )
+
+        lab = self._label.format(placeholder='exposure')
+        self._write(f"![Exposure model fits.\label{{{lab}}}]({os.path.basename(out_mp)})")
+
+        return out_mp
+
+    @reporting
+    def model_fits(self, sim: SimulationBase):
+        self._write("### Survival model fits")
+        
+        self._write(
+            "Survival observations on the unit scale with model fits. The solid line is "+
+            "the average of individual survival probability predictions from multiple "+
+            "draws from the posterior parameter distribution. In case a point estimator "+
+            "was used the solid line indicates the best fit. Grey uncertainty intervals "+
+            "indicate the uncertainty in survival probabilities. Note that the survival "+
+            "probabilities indicate the probability for a given individual or population "+
+            "to be alive when observed at time t."
+        )
+
+        out_mp = plot_survival_multipanel(
+            sim=sim,
+            results=sim.inferer.idata.posterior_model_fits,
+            ncols=6,
+        )
+
+        lab = self._label.format(placeholder='survival_fits')
+        self._write(f"![Surival model fits.\label{{{lab}}}]({os.path.basename(out_mp)})")
+
+        return out_mp
+    
+    @reporting
+    def LCx_estimates(self, sim):
+        X = self.ecx_estimates_x
+        T = self.ecx_estimates_times
+        P = sim.predefined_scenarios()
+
+        if self.set_background_mortality_to_zero:
+            conditions = {sim.background_mortality: 0.0}
+
+        estimates = pd.DataFrame(
+            it.product(X, T, P.keys()), 
+            columns=["x", "time", "scenario"]
+        )
+
+        ecx = []
+
+        for i, row in estimates.iterrows():
+            ecx_estimator = ECxEstimator(
+                sim=sim,
+                effect="survival", 
+                x=row.x,
+                time=row.time, 
+                x_in=P[row.scenario], 
+                conditions_posterior=conditions
+            )
+            
+            ecx_estimator.estimate(
+                mode=sim.ecx_mode,
+                draws=250,
+                show_plot=False
+            )
+
+            ecx.append(ecx_estimator.results.copy(deep=True))
+            
+            # remove ecx_estimator to not blow up temp files.
+            # This triggers the __del__ method of ECxEstimator,
+            # which cleans up a temporary directory if it was
+            # created during init
+            del ecx_estimator
+
+        results = pd.DataFrame(ecx)
+        estimates[results.columns] = results
+
+        out = self._write_table(tab=estimates, label_insert="$LC_x$ estimates")
+        
+        return out
+
+
+class ParameterConverter:
+    def __init__(
+        self,
+        sim: SimulationBase,
+    ):
+        self.sim = sim.copy()
+
+        # this converts the units of exposure in the copied simulation 
+        # and scales the exposure dataarray
+        self.sim._convert_exposure_units()
+        self.convert_parameters()
+        self.sim.prepare_simulation_input()
+        self.sim.dispatch_constructor()
+
+        # self.plot_exposure_and_effect(self.sim, sim, _id=7, data_var="D")
+
+        # if parameters are not rescaled this method should raise an error
+        self.validate_parameter_conversion_default_params(sim_copy=self.sim, sim_orig=sim)
+        self.validate_parameter_conversion_posterior_mean(sim_copy=self.sim, sim_orig=sim)
+        self.validate_parameter_conversion_posterior_map(sim_copy=self.sim, sim_orig=sim)
+
+    def convert_parameters(self):
+        raise NotImplementedError
+
+
+    @staticmethod
+    def plot_exposure_and_effect(sim_copy, sim_orig, _id=1, data_var="survival"):
+        from matplotlib import pyplot as plt
+        fig, (ax1, ax2) = plt.subplots(2,1)
+        results_copy = sim_copy.evaluate(parameters=sim_copy.config.model_parameters.value_dict)
+        results_orig = sim_orig.evaluate(parameters=sim_orig.config.model_parameters.value_dict)
+
+        ax1.plot(results_orig.time, results_orig["exposure"].isel(id=_id), color="red", label="unscaled")
+        ax1.plot(results_copy.time, results_copy["exposure"].isel(id=_id), color="blue", ls="--", label="scaled")
+        ax2.plot(results_orig.time, results_orig[data_var].isel(id=_id), color="red", label="unscaled")
+        ax2.plot(results_copy.time, results_copy[data_var].isel(id=_id), color="blue", ls="--", label="scaled")
+        ax1.legend()
+        ax2.legend()
+        return fig
+
+    @staticmethod
+    def validate_parameter_conversion_default_params(sim_copy, sim_orig):
+        results_copy = sim_copy.evaluate(parameters=sim_copy.config.model_parameters.value_dict)
+        results_orig = sim_orig.evaluate(parameters=sim_orig.config.model_parameters.value_dict)
+
+        np.testing.assert_allclose(results_copy.H, results_orig.H, atol=0.001, rtol=0.001)
+
+    @staticmethod
+    def validate_parameter_conversion_posterior_mean(sim_copy, sim_orig):
+        results_copy = sim_copy.evaluate(parameters=sim_copy.point_estimate("mean", to="dict"))
+        results_orig = sim_orig.evaluate(parameters=sim_orig.point_estimate("mean", to="dict"))
+
+        np.testing.assert_allclose(results_copy.H, results_orig.H, atol=0.001, rtol=0.001)
+
+    @staticmethod
+    def validate_parameter_conversion_posterior_map(sim_copy, sim_orig):
+        results_copy = sim_copy.evaluate(parameters=sim_copy.point_estimate("map", to="dict"))
+        results_orig = sim_orig.evaluate(parameters=sim_orig.point_estimate("map", to="dict"))
+
+        np.testing.assert_allclose(results_copy.H, results_orig.H, atol=0.001, rtol=0.001)

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 1.0.0
+Version: 1.0.2
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -693,6 +693,7 @@ Requires-Dist: openpyxl>=3.1.3
 Requires-Dist: Bottleneck>=1.5.0
 Requires-Dist: expydb>=0.6.0
 Requires-Dist: pymob[interactive,numpyro]<0.6.0,>=0.5.10
+Requires-Dist: pint
 Provides-Extra: dev
 Requires-Dist: pytest>=7.3; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{guts_base-1.0.0 → guts_base-1.0.2}/guts_base.egg-info/requires.txt

@@ -2,6 +2,7 @@ openpyxl>=3.1.3
 Bottleneck>=1.5.0
 expydb>=0.6.0
 pymob[interactive,numpyro]<0.6.0,>=0.5.10
+pint
 
 [dev]
 pytest>=7.3

{guts_base-1.0.0 → guts_base-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "guts_base"
-version = "1.0.0"
+version = "1.0.2"
 authors = [
   { name="Florian Schunck", email="fluncki@protonmail.com" },
 ]
@@ -15,7 +15,8 @@ dependencies=[
     "openpyxl >= 3.1.3",
     "Bottleneck >= 1.5.0",
     "expydb >= 0.6.0",
-    "pymob[numpyro,interactive] >= 0.5.10, < 0.6.0"
+    "pymob[numpyro,interactive] >= 0.5.10, < 0.6.0",
+    "pint",
 ]
 license = {file = "LICENSE"}
 classifiers = [
@@ -48,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 = "1.0.0"
+current_version = "1.0.2"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

guts_base-1.0.0/guts_base/sim/report.py

@@ -1,72 +0,0 @@
-import os
-import itertools as it
-from typing import List
-import pandas as pd
-
-from pymob import SimulationBase
-from pymob.sim.report import Report, reporting
-
-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)
-        self.model_fits(sim)
-        self.LCx_estimates(sim)
-
-    @reporting
-    def model_fits(self, sim: SimulationBase):
-        self._write("### Survival model fits")
-        
-        out_mp = plot_survival_multipanel(
-            sim=sim,
-            results=sim.inferer.idata.posterior_model_fits,
-            ncols=6,
-        )
-
-        lab = self._label.format(placeholder='survival_fits')
-        self._write(f"![Surival model fits.\label{{{lab}}}]({os.path.basename(out_mp)})")
-
-        return out_mp
-
-
-    @reporting
-    def LCx_estimates(self, sim):
-        X = self.ecx_estimates_x
-        T = self.ecx_estimates_times
-        P = sim.predefined_scenarios()
-
-        estimates = pd.DataFrame(
-            it.product(X, T, P.keys()), 
-            columns=["x", "time", "scenario"]
-        )
-
-        ecx = []
-
-        for i, row in estimates.iterrows():
-            ecx_estimator = ECxEstimator(
-                sim=sim,
-                effect="survival", 
-                x=row.x,
-                time=row.time, 
-                x_in=P[row.scenario], 
-            )
-            
-            ecx_estimator.estimate(
-                mode=sim.ecx_mode,
-                draws=250,
-                show_plot=False
-            )
-
-            ecx.append(ecx_estimator.results)
-
-        results = pd.DataFrame(ecx)
-        estimates[results.columns] = results
-
-        out = self._write_table(tab=estimates, label_insert="$LC_x$ estimates")
-        
-        return out