guts-base 2.0.0b0__py3-none-any.whl

guts_base/sim/mempy.py

@@ -0,0 +1,290 @@
+import pathlib
+from typing import Dict, Optional, Literal, Protocol, TypedDict, List, Tuple
+import re
+import os
+import numpy as np
+from numpy.ma.core import MaskedConstant
+import pandas as pd
+import xarray as xr
+from pymob.sim.config import Config, DataVariable, Datastructure
+from pymob.sim.config import Param
+from guts_base.sim import GutsBase
+
+__all__ = [
+    "PymobSimulator",
+]
+
+class ParamsInfoDict(TypedDict):
+    name: str
+    min: float
+    max: float
+    initial: float
+    vary: bool
+    prior: str
+    dims: Tuple[str]
+    unit: str|List[str]
+    module: str
+
+class StateVariablesDict(TypedDict):
+    dimensions: List[str]
+    observed: bool
+    y0: List[float]
+
+class Model(Protocol):
+    extra_dim: str
+    params_info: Dict[str, ParamsInfoDict]
+    state_variables: Dict[str, StateVariablesDict]
+    _params_info_defaults: Dict[str, ParamsInfoDict]
+    _it_model: bool
+
+    @staticmethod
+    def _rhs_jax():
+        raise NotImplementedError
+        
+    @staticmethod
+    def _solver_post_processing():
+        raise NotImplementedError
+
+    @staticmethod
+    def _likelihood_func_jax():
+        raise NotImplementedError
+
+
+class PymobSimulator(GutsBase):
+
+    @classmethod
+    def from_model_and_dataset(
+        cls,
+        model: Model,
+        exposure_data: Dict[str, pd.DataFrame],
+        survival_data: pd.DataFrame,
+        info_dict: Dict = {},
+        pymob_config: Optional[Config] = None,
+        output_directory: str|pathlib.Path = pathlib.Path("output/pymob"),
+        default_prior: Literal["uniform", "lognorm"] = "lognorm",
+    ) -> "PymobSimulator":
+        """Construct a PymobSimulator from the 
+        """
+
+        if pymob_config is None:
+            cfg = Config()
+            # Configure: The configuration can be overridden in a subclass to override the 
+            # configuration
+            cls._configure(config=cfg)
+        else:
+            cfg = pymob_config
+
+        if isinstance(output_directory, str):
+            output_directory = pathlib.Path(output_directory)
+
+        cfg.case_study.output = str(output_directory)
+
+        # overrides scenario path. This means the scenario is also expected in the
+        # same folder
+        cfg.case_study.scenario_path_override = str(output_directory)
+        cfg.case_study.scenario = output_directory.stem
+        cfg.case_study.data = cfg.case_study.output_path
+        cfg.case_study.observations = "observations.nc"
+        cfg.create_directory(directory="results", force=True)
+        
+        obs = cls._observations_from_dataframes(
+            exposure_data=exposure_data,
+            survival_data=survival_data,
+            exposure_dim=model.extra_dim,
+            unit_input=cfg.guts_base.unit_input,
+            unit_time=cfg.guts_base.unit_time,
+        )
+
+        obs.to_netcdf(os.path.join(cfg.case_study.output_path, cfg.case_study.observations))
+        
+
+        # configure model and likelihood function
+        # extract the fully qualified name of the model module.name
+        if isinstance(model, type):
+            raise TypeError(
+                f"model '{model.__name__}' must be initialized. Initialize with "+
+                f"{model.__name__}(). Dont forget to specifiy the number of exposures "+
+                "with e.g. RED_SD_DA(num_expos=2) if your model has two exposures."
+            )
+        else:
+            pass
+
+        cfg.simulation.model_class = "{module}.{name}".format(
+            module=model.__module__, name=type(model).__name__
+        )
+        cfg.inference_numpyro.user_defined_error_model = "{module}.{name}".format(
+            module=model._likelihood_func_jax.__module__, 
+            name=model._likelihood_func_jax.__name__
+        )
+
+        # derive data structure and params from the model instance
+        cls._set_data_structure(config=cfg, model=model)
+        cls._set_params(config=cfg, model=model, default_prior=default_prior)
+
+        # configure starting values and input
+        cfg.simulation.x_in = ["exposure=exposure"]
+        cfg.simulation.y0 = [f"{k}={v['y0']}" for k, v in model.state_variables.items() if "y0" in v]
+
+        cfg.guts_base.background_mortality_parameters = cls._get_background_mortality_params(model)
+
+        # create a simulation object
+        # It is essential that all post processing tasks are done in self.setup()
+        # which is extended below. This ensures that the simulation can also be run
+        # from automated tools like pymob-infer
+        sim = cls(config=cfg)
+        sim.setup()
+        return sim
+
+
+    def setup(self, **evaluator_kwargs):
+        super().setup(**evaluator_kwargs)
+        self._obs_backup = self.observations.copy(deep=True)
+
+
+    @classmethod
+    def _configure(cls, config: Config):
+        """This is normally set in the configuration file passed to a SimulationBase class.
+        Since the mempy to pymob converter initializes pymob.SimulationBase from scratch
+        (without using a config file), the necessary settings have to be specified here.
+        """
+        config.case_study.output = "results"
+        config.case_study.simulation = "PymobSimulator"
+
+        # this must be named guts_base,  whihc is the name of the pip package and
+        # this regulates which packages are loaded.
+        config.case_study.name = "guts_base"
+
+        config.simulation.x_dimension = "time"
+        config.simulation.batch_dimension = "id"
+        config.simulation.solver_post_processing = None
+
+        # this is the registered guts-base section
+        # No longer necessary, because these are saved as defaults
+        # config.simulation.unit_time = "day"
+        # config.simulation.n_reindexed_x = 100
+        # config.simulation.forward_interpolate_exposure_data = True
+        
+        config.inference.extra_vars = ["eps", "survivors_before_t", "survivors_at_start"]
+        config.inference.n_predictions = 100
+
+        config.jaxsolver.diffrax_solver = "Tsit5"
+        config.jaxsolver.rtol = 1e-10
+        config.jaxsolver.atol = 1e-12
+        config.jaxsolver.throw_exception = True
+        config.jaxsolver.pcoeff = 0.3
+        config.jaxsolver.icoeff = 0.3
+        config.jaxsolver.dcoeff = 0.0
+        config.jaxsolver.max_steps = 1000000
+        config.jaxsolver.throw_exception = True
+
+
+        config.inference_numpyro.gaussian_base_distribution = True
+        config.inference_numpyro.kernel = "svi"
+        config.inference_numpyro.init_strategy = "init_to_median"
+        config.inference_numpyro.svi_iterations = 10_000
+        config.inference_numpyro.svi_learning_rate = 0.001
+
+    @classmethod
+    def _set_data_structure(cls, config: Config, model: Model):
+        """Takes a dictionary that is specified in the model and uses only keys that
+        are fields of the DataVariable config-model"""
+        
+        state_dict = model.state_variables
+
+        config.data_structure = Datastructure.model_validate({
+            key: DataVariable.model_validate({
+                k: v for k, v in state_info.items()
+                if k in DataVariable.model_fields
+            })
+            for key, state_info in state_dict.items()
+        })
+
+    @staticmethod
+    def _get_background_mortality_params(model: Model):
+        return [k for k, v in model.params_info.items() if v["module"] == "background-mortality"]
+
+
+    @classmethod
+    def _set_params(cls, config: Config, model: Model, default_prior: str):
+        params_info = model.params_info
+
+        if model._it_model:
+            eps = config.jaxsolver.atol * 10
+            params_info["eps"] = {'name':'eps', 'initial':eps, 'vary':False}
+
+
+        for par, param_dict in params_info.items():
+            for k, v in model._params_info_defaults.items():
+                if k not in param_dict:
+                    param_dict.update({k:v})
+
+        param_df = pd.DataFrame(params_info).T
+        param_df["param_index"] = param_df.name.apply(lambda x: re.findall(r"\d+", x))
+        param_df["param_index"] = param_df.param_index.apply(lambda x: int(x[0])-1 if len(x) == 1 else None)
+        param_df["name"] = param_df.name.apply(lambda x: re.sub(r"\d+", "", x).strip("_"))
+
+        for (param_name, ), group in param_df.groupby(["name"]):
+
+            dims = list(dict.fromkeys(group["dims"]))
+            dims = tuple([]) if dims == [None] else tuple(dims)
+
+            prior = list(dict.fromkeys(group["prior"]))
+            prior = prior[0] if len(prior) == 1 else prior
+            
+            _min = np.min(np.ma.masked_invalid(group["min"].values.astype(float)))
+            _max = np.max(np.ma.masked_invalid(group["max"].values.astype(float)))
+            _init = np.array(group["initial"].values.astype(float))
+            _free = np.array(group["vary"].values)
+
+            unit = list(dict.fromkeys(group["unit"]))
+            unit = unit[0] if len(unit) == 1 else unit
+
+            if isinstance(_min, MaskedConstant):
+                _min = None
+            if isinstance(_max, MaskedConstant):
+                _max = None
+            
+            # TODO: allow for parsing one N-D prior from multiple priors
+            # TODO: Another choice would be to parse vary=False priors as deterministic
+            #       and use a composite prior from a deterministic and a free prior as
+            #       the input into the model
+
+            if prior is None:
+                if _min is None or _max is None:
+                    prior = None
+                elif default_prior == "uniform":
+                    _loc = _init * np.logical_not(_free) + _min * _free - config.jaxsolver.atol * 10 * np.logical_not(_free)
+                    _scale = _init * np.logical_not(_free) + _max * _free + config.jaxsolver.atol * 10 * np.logical_not(_free)
+                    _loc = _loc[0] if len(_loc) == 1 else _loc
+                    _scale = _scale[0] if len(_scale) == 1 else _scale
+                    prior = f"uniform(loc={_loc},scale={_scale})"
+                elif default_prior == "lognorm":
+                    _s = 3 * _free + config.jaxsolver.atol * 10 * np.logical_not(_free)
+                    _init = _init[0] if len(_init) == 1 else _init
+                    _s = _s[0] if len(_s) == 1 else _s
+
+                    prior = f"lognorm(scale={_init},s={_s})"
+                else:
+                    raise ValueError(
+                        f"Default prior: '{default_prior}' is not implemented. "+
+                        "Use one of 'uniform', 'lognorm' or specify priors for each "+
+                        "parameter directly with: "+
+                        f"`model.params_dict['prior'] = {default_prior}(...)`"
+                    )
+
+                if prior is not None:
+                    prior = prior.replace(" ", ",")
+
+            # if isinstance(value,float):
+            param = Param.model_validate(dict(
+                value=_init,
+                free=np.max(_free),
+                min=_min,
+                max=_max,
+                prior=prior,
+                dims=dims,
+                unit=unit,
+            ))
+
+            setattr(config.model_parameters, param_name, param)
+

guts_base/sim/report.py

@@ -0,0 +1,405 @@
+from functools import partial
+import os
+import itertools as it
+from typing import List, Dict, Literal, Optional, Union, TYPE_CHECKING
+import numpy as np
+import pandas as pd
+import xarray as xr
+import arviz as az
+from matplotlib import pyplot as plt
+import pint
+
+from pymob import SimulationBase
+from pymob.sim.report import Report, reporting
+from pymob.sim.config import Config, string_to_dict
+from pymob.inference.analysis import round_to_sigfig, format_parameter
+
+from guts_base.plot import plot_survival_multipanel, plot_exposure_multipanel
+from guts_base.sim.ecx import ECxEstimator
+from guts_base.sim.config import GutsBaseConfig
+from guts_base.sim import units
+
+if TYPE_CHECKING:
+    from guts_base.sim import GutsBase
+
+
+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]
+    # ecx_draws: int = 250
+    # ecx_force_draws: bool = False
+    # set_background_mortality_to_zero = True
+    # table_parameter_stat_focus = "mean"
+    # units = xr.Dataset({
+    #     "metric": ["unit"],
+    #     "k_d": ("metric", ["1/T"])
+    # })
+    # format_unit = "~P"
+
+
+    def additional_reports(self, sim: "GutsBase"):
+        super().additional_reports(sim=sim)
+        self.model_input(sim)
+        self.model_fits(sim)
+        self.LCx_estimates(sim)
+
+    @property
+    def units(self):
+        return units.derive_explicit_units(
+            config=self.config,
+            unit=self.observations["unit"]
+        )
+
+
+    @reporting
+    def model_input(self, sim: "GutsBase"):
+        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: "GutsBase"):
+        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."
+        )
+
+
+        if sim._exclude_controls_after_fixing_background_mortality: #type: ignore
+            lab = self._label.format(placeholder='survival_fits_controls')
+
+            # use the plot that is generated in GutsBase.estimate_background_mortality
+            self._write(f"![Surival model fits (control treatments).\label{{{lab}}}]"+
+                        "(survival_multipanel_control_treatments.png)")
+
+        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: "GutsBase"):
+        X = self.config.guts_base.ecx_estimates_x
+        T = self.config.guts_base.ecx_estimates_times
+        P = sim.predefined_scenarios()
+
+        if self.config.guts_base.ecx_set_background_mortality_to_zero:
+            conditions = {p: 0.0 for p in self.config.guts_base.background_mortality_parameters}
+
+        estimates = pd.DataFrame(
+            it.product(X, T, P.keys()), 
+            columns=["x", "time", "scenario"]
+        )
+
+        ecx = []
+
+        for i, row in estimates.iterrows():
+            msg = "Estimating EC_{x}(t={t} {tu}) for scenario '{s}'".format(
+                x=row.x*100, t=row.time, s=row.scenario, tu=self.config.guts_base.unit_time
+            )
+            print(msg)
+            print("=" * len(msg), end="\n")
+            
+            ecx_estimator = ECxEstimator(
+                sim=sim,
+                effect="survival", 
+                x=row.x,
+                time=row.time, 
+                x_in=P[row.scenario], 
+                conditions_posterior=conditions
+            )
+
+            # find a good starting value
+            ecx_estimator.plot_loss_curve(
+                mode="mean",
+                log_x0=0, 
+                # this is a huge interval
+                log_interval_radius=20, 
+                log_interval_num=100
+            )
+
+            plt.close(ecx_estimator.figure_loss_curve)
+
+            ecx_estimator.estimate(
+                mode=sim.config.guts_base.ecx_mode,
+                log_x0=float(np.mean(ecx_estimator.ecx_candidates)),
+                draws=self.config.guts_base.ecx_draws,
+                force_draws=self.config.guts_base.ecx_force_draws,
+                show_plot=False
+            )
+
+            ecx.append(ecx_estimator.results.copy(deep=True))
+            
+        results = pd.DataFrame(ecx)
+        estimates[results.columns] = results
+
+        out = self._write_table(tab=estimates, label_insert="$LC_x$ estimates")
+        
+        return out
+
+
+    @reporting
+    def table_parameter_estimates(self, posterior, indices):
+
+        if self.rc.table_parameter_estimates_with_batch_dim_vars:
+            var_names = {
+                k: k for k, v in self.config.model_parameters.free.items()
+            }
+        else:
+            var_names = {
+                k: k for k, v in self.config.model_parameters.free.items()
+                if self.config.simulation.batch_dimension not in v.dims
+            }
+
+        var_names.update(self.rc.table_parameter_estimates_override_names) # type: ignore
+
+        if len(self.rc.table_parameter_estimates_exclude_vars) > 0:
+            self._write(f"Excluding parameters: {self.rc.table_parameter_estimates_exclude_vars} for meaningful visualization")
+
+            var_names = {
+                k: k for k, v in var_names.items() 
+                if k not in self.rc.table_parameter_estimates_exclude_vars
+            }
+
+        tab_report = create_table(
+            posterior=posterior,
+            vars=var_names,
+            error_metric=self.rc.table_parameter_estimates_error_metric,
+            units=self.units,
+            stat_focus=self.config.guts_base.table_parameter_stat_focus,
+            significant_figures=self.rc.table_parameter_estimates_significant_figures,
+            nesting_dimension=indices.keys(),
+            parameters_as_rows=self.rc.table_parameter_estimates_parameters_as_rows,
+        )
+
+        # rewrite table in the desired output format
+        tab = create_table(
+            posterior=posterior,
+            vars=var_names,
+            error_metric=self.rc.table_parameter_estimates_error_metric,
+            units=self.units,
+            stat_focus=self.config.guts_base.table_parameter_stat_focus,
+            significant_figures=self.rc.table_parameter_estimates_significant_figures,
+            fmt=self.rc.table_parameter_estimates_format,
+            nesting_dimension=indices.keys(),
+            parameters_as_rows=self.rc.table_parameter_estimates_parameters_as_rows,
+        )
+
+        self._write_table(tab=tab, tab_report=tab_report, label_insert="Parameter estimates")
+
+
+def create_table(
+    posterior, 
+    error_metric: Literal["hdi","sd"] = "hdi", 
+    vars: Dict = {}, 
+    nesting_dimension: Optional[Union[List,str]] = None,
+    stat_focus: Literal["mean", "median"] = "mean",
+    units: xr.Dataset = xr.Dataset(),
+    fmt: Literal["csv", "tsv", "latex"] = "csv",
+    significant_figures: int = 3,
+    parameters_as_rows: bool = True,
+) -> pd.DataFrame:
+    """The function is not ready to deal with any nesting dimensionality
+    and currently expects the 2-D case
+    """
+    tab = az.summary(
+        posterior, var_names=list(vars.keys()), 
+        fmt="xarray", kind="stats", stat_focus=stat_focus, 
+        hdi_prob=0.94
+    )
+
+    if TYPE_CHECKING:
+        # just for
+        assert isinstance(tab, xr.Dataset)
+
+    tab = tab.rename(vars)
+
+    _units = flatten_coords(
+        dataset=create_units(dataset=tab, defined_units=units, stat_focus=stat_focus), 
+        keep_dims=["metric"]
+    )
+    tab = flatten_coords(dataset=tab, keep_dims=["metric"])
+
+    tab = tab.apply(np.vectorize(
+        partial(round_to_sigfig, sig_fig=significant_figures)
+    ))
+
+    if stat_focus == "mean" and error_metric == "sd":
+        metrics = ["mean", "sd"]
+    elif stat_focus == "mean" and error_metric == "hdi":
+        metrics = ["mean", "hdi_3%", "hdi_97%"]
+    elif stat_focus == "median" and error_metric == "sd":
+        metrics = ["median", "mad"]
+    else:
+        metrics = ["median", "eti_3%", "eti_97%"]
+
+
+
+    if error_metric == "sd":
+        arrays = []
+        for _, data_var in tab.data_vars.items():
+            par_formatted = data_var.sel(metric=metrics)\
+                .astype(str).str\
+                .join("metric", sep=" ± ")
+            arrays.append(par_formatted)
+
+
+        table = xr.combine_by_coords(arrays)
+        table = table.assign_coords(metric=" ± ".join(metrics)).expand_dims("metric")
+        table = table.to_dataframe().T
+
+    elif error_metric == "hdi":
+        stacked_tab = tab.sel(metric=metrics)\
+            .assign_coords(metric=[m.replace("_", " ") for m in metrics])
+        table = stacked_tab.to_dataframe().T
+
+    else:
+        raise NotImplementedError("Must use one of 'sd' or 'hdi'")
+
+
+    if fmt == "latex":
+        table.columns.names = [str(c).replace('_',' ') for c in table.columns.names]
+        table.index = [format_parameter(i) for i in list(table.index)]
+        table = table.rename(
+            columns={c: c.replace("%", "\\%") for c in table.columns}
+        )
+    else: 
+        pass
+
+    table["unit"] = _units.to_pandas().T
+    
+
+    if parameters_as_rows:
+        return table
+    else:
+        return table.T
+
+def flatten_coords(dataset: xr.Dataset, keep_dims):
+    """flattens extra coordinates beside the keep_dim dimension for all data variables
+    producing a array with harmonized dimensions
+    """
+    ds = dataset.copy()
+    ds = ds.reset_coords(drop=True)
+    for var_name, data_var in ds.data_vars.items():
+        extra_coords = [k for k in list(data_var.coords.keys()) if k not in keep_dims]
+        if len(extra_coords) == 0:
+            continue
+        
+        data_var_ = data_var.stack(index=extra_coords)
+        
+        # otherwise
+        for idx in data_var_["index"].values:
+            new_var_name = f"{var_name}[{','.join([str(e) for e in idx])}]"
+            # reset coordinates to move non-dim index coords from coordinates to the
+            # data variables and then select only the var_name from the data vars
+            new_data_var = data_var_.sel({"index": idx}).reset_coords()[var_name]
+            ds[new_var_name] = new_data_var
+
+        ds = ds.drop(var_name)
+
+    # drop any coordinates that should not be in the dataset at this stage
+    extra_coords = [k for k in list(ds.coords.keys()) if k not in keep_dims]
+    ds = ds.drop(extra_coords)
+
+    return ds
+
+def create_units(dataset: xr.Dataset, defined_units: xr.Dataset, stat_focus):
+    units = dataset.sel(metric=[stat_focus]).astype(str)
+    units = units.assign_coords({"metric": ("metric", ["unit"])})
+    for k, u in units.data_vars.items():
+        if k in defined_units:
+            units = units.assign({k: defined_units[k].astype(units[k].dtype)})
+        else:
+            units[k].values = np.full_like(u.values, "")
+
+    return units
+
+class ParameterConverter:
+    def __init__(
+        self,
+        sim: "GutsBase",
+    ):
+        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.1, rtol=0.05)
+
+    @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.1, rtol=0.05)
+
+    @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.1, rtol=0.05)