guts-base 1.0.5__tar.gz → 1.0.6__tar.gz

{guts_base-1.0.5 → guts_base-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 1.0.5
+Version: 1.0.6
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{guts_base-1.0.5 → guts_base-1.0.6}/guts_base/__init__.py

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

{guts_base-1.0.5 → guts_base-1.0.6}/guts_base/sim/base.py

@@ -101,7 +101,12 @@ class GutsBase(SimulationBase):
             self.unit_time = self.config.simulation.unit_time  # type: ignore
 
         if hasattr(self.config.simulation, "skip_data_processing"):
-            self._skip_data_processing = bool(self.config.simulation.skip_data_processing)  # type: ignore
+            self._skip_data_processing = not (
+                self.config.simulation.skip_data_processing == "False"  or
+                self.config.simulation.skip_data_processing == "false" or  # type: ignore
+                self.config.simulation.skip_data_processing == "" or # type: ignore
+                self.config.simulation.skip_data_processing == 0  # type: ignore
+            )
 
         if hasattr(self.config.simulation, "results_interpolation"):
             results_interpolation_string = string_to_list(self.config.simulation.results_interpolation)
@@ -418,8 +423,6 @@ class GutsBase(SimulationBase):
             
         self.dispatch_constructor()
         _ = self._prob.posterior_predictions(self, self.inferer.idata) # type: ignore
-        self.inferer.store_results(output=f"{self.output_path}/numpyro_posterior_interp.nc") # type: ignore
-        self.logger.info("Recomputed posterior and storing in `numpyro_posterior_interp.nc`")
 
 
     def prior_predictive_checks(self, **plot_kwargs):
@@ -430,9 +433,12 @@ class GutsBase(SimulationBase):
     def posterior_predictive_checks(self, **plot_kwargs):
         super().posterior_predictive_checks(**plot_kwargs)
 
-        self.recompute_posterior()
+        sim_copy = self.copy()
+        sim_copy.recompute_posterior()
         # TODO: Include posterior_predictive group once the survival predictions are correctly working
-        self._plot.plot_posterior_predictions(self, data_vars=["survival"], groups=["posterior_model_fits"])
+        sim_copy._plot.plot_posterior_predictions(
+            sim_copy, data_vars=["survival"], groups=["posterior_model_fits"]
+        )
 
 
     def plot(self, results):
@@ -802,27 +808,19 @@ class GutsBase(SimulationBase):
 
         self.dispatch_constructor()
 
-    def export(self, directory: Optional[str] = None):
-        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"):
-            # create the tempdir in the output path, because on the remote cluster
-            # the default temporary directory may not have enough space. Using the output
-            # path here resolves any path issues.
-            tmp_basedir = os.path.join(self.output_path, "tmp")
-            os.makedirs(tmp_basedir, exist_ok=True)
-            with tempfile.TemporaryDirectory(dir=tmp_basedir) as name:
-                self.export(directory=name)
-                print(f"Exported files ({name}):", os.listdir(name))
-                sim_copy = type(self).from_directory(name)
-
-        return sim_copy
+    def export(self, directory: Optional[str] = None, mode="export", skip_data_processing=True):
+        self.config.simulation.skip_data_processing = skip_data_processing
+        super().export(directory=directory, mode=mode)
+
+    def export_to_scenario(self, scenario, force=False):
+        """Exports a case study as a new scenario for running inference"""
+        self.config.case_study.scenario = scenario
+        self.config.case_study.data = None
+        self.config.case_study.output = None
+        self.config.case_study.scenario_path_override = None
+        self.config.simulation.skip_data_processing = True
+        self.save_observations(filename=f"observations_{scenario}.nc", force=force)
+        self.config.save(force=force)
 
     @staticmethod
     def _condition_posterior(

{guts_base-1.0.5 → guts_base-1.0.6}/guts_base/sim/report.py

@@ -1,12 +1,15 @@
+from functools import partial
 import os
 import itertools as it
-from typing import List, Dict
+from typing import List, Dict, Literal, Optional, Union
 import numpy as np
 import pandas as pd
 import xarray as xr
+import arviz as az
 
 from pymob import SimulationBase
 from pymob.sim.report import Report, reporting
+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
@@ -17,6 +20,12 @@ class GutsReport(Report):
     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"])
+    })
+
 
     def additional_reports(self, sim: "SimulationBase"):
         super().additional_reports(sim=sim)
@@ -113,6 +122,164 @@ class GutsReport(Report):
         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)
+
+        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,
+            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,
+            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,
+    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="mean", 
+        hdi_prob=0.94
+    )
+
+    tab = tab.rename(vars)
+
+    _units = flatten_coords(
+        dataset=create_units(dataset=tab, defined_units=units), 
+        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 error_metric == "sd":
+        arrays = []
+        for _, data_var in tab.data_vars.items():
+            par_formatted = data_var.sel(metric=["mean", "sd"])\
+                .astype(str).str\
+                .join("metric", sep=" ± ")
+            arrays.append(par_formatted)
+
+
+        table = xr.combine_by_coords(arrays)
+        table = table.assign_coords(metric="mean ± std").expand_dims("metric")
+        table = table.to_dataframe().T
+
+    elif error_metric == "hdi":
+        stacked_tab = tab.sel(metric=["mean", "hdi_3%", "hdi_97%"])\
+            .assign_coords(metric=["mean", "hdi 3%", "hdi 97%"])
+        table = stacked_tab.to_dataframe().T
+
+    else:
+        raise NotImplementedError("Must use one of 'sd' or 'hdi'")
+
+
+    if fmt == "latex":
+        table.columns.names = [c.replace('_',' ') for c in table.columns.names]
+        table.index = [format_parameter(i) for i in list(table.index)]
+        table = table.rename(
+            columns={"hdi 3%": "hdi 3\\%", "hdi 97%": "hdi 97\\%"}
+        )
+    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()
+    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):
+    units = dataset.sel(metric=["mean"]).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,

{guts_base-1.0.5 → guts_base-1.0.6}/guts_base.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guts_base
-Version: 1.0.5
+Version: 1.0.6
 Summary: Basic GUTS model implementation in pymob
 Author-email: Florian Schunck <fluncki@protonmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{guts_base-1.0.5 → guts_base-1.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "guts_base"
-version = "1.0.5"
+version = "1.0.6"
 authors = [
   { name="Florian Schunck", email="fluncki@protonmail.com" },
 ]
@@ -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 = "1.0.5"
+current_version = "1.0.6"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"