guts-base 0.8.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

guts_base/sim/ecx.py

@@ -9,45 +9,91 @@ from matplotlib import pyplot as plt
 from tqdm import tqdm
 
 from pymob import SimulationBase
+from guts_base.sim.utils import GutsBaseError
 
 class ECxEstimator:
     """Estimates the exposure level that corresponds to a given effect. The algorithm 
-    operates by varying a given exposure profile (x_in)
+    operates by varying a given exposure profile (x_in). For each new estimation, a new
+    estimator is initialized.
+
+    Parameters
+    ----------
+
+    sim : SimulationBase
+        This must be a pymob.SimulationBase object. If the ECxEstimator.estimate method
+        is used with the modes 'draw' or 'mean'    
+    
     """
     _name = "EC"
+    _parameter_msg = (
+        "Manual estimation (mode='manual', without using posterior information) requires " +
+        "specification of parameters={...}. You can obtain and modify " +
+        "parameters using the pymob API: `sim.config.model_parameters.value_dict` " +
+        "returns a dictionary of DEFAULT PARAMETERS that you can customize to your liking " +
+        "(https://pymob.readthedocs.io/en/stable/api/pymob.sim.html#pymob.sim.config.Modelparameters.value_dict)."
+    )                
 
     def __init__(
         self, 
         sim: SimulationBase, 
         effect: str, 
-        x: float=0.5,
-        id: Optional[str]=None, 
-        time: Optional[float]=None, 
-        x_in: Optional[xr.Dataset]=None, 
+        x: float,
+        time: float, 
+        x_in: xr.Dataset, 
     ):
         self.sim = sim.copy()
         self.time = time
         self.x = x
-        self.id = id
         self.effect = effect
         self._mode = None
 
-        if id is None:
-            self.sim.coordinates["id"] = [self.sim.coordinates["id"][0]]
-        else:
-            self.sim.coordinates["id"] = [id]
+        # 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["id"] = x_in["id"]
+        
+        self.sim.config.data_structure.survival.observed = False
+        self.sim.observations = pseudo_obs
 
-        self.sim.model_parameters["x_in"] = x_in
+        # ensure correct coordinate order with x_in and raise errors early
+        self.sim.model_parameters["x_in"] = self.sim.parse_input("x_in", x_in)
 
-        self.sim.config.data_structure.survival.observed = False
-        self.sim.observations = self.sim.observations.sel(id=self.sim.coordinates["id"])
 
-        # fix time after observations have been set
-        self.sim.coordinates["time"] = [time]
+        # fix time after observations have been set. The outcome of the simulation
+        # can dependend on the time vector, because in e.g. IT models, the time resolution
+        # is important. Therefore the time at which the ECx is computed is just inserted
+        # into the time vector at the right position.
+        self.sim.coordinates["time"] = np.unique(np.concatenate([
+            self.sim.coordinates["time"], np.array(time, ndmin=1)
+        ]))
 
         self.sim.model_parameters["y0"] = self.sim.parse_input("y0", drop_dims="time")
         self.sim.dispatch_constructor()
 
+        self.results = pd.Series({
+            "mean": np.nan,
+            "q05": np.nan,
+            "q95": np.nan,
+            "std": np.nan,
+            "cv": np.nan,
+            "msg": np.nan
+        })
+
+        self.figure_profile_and_effect = None
+        self.figure_loss_curve = None
+
+
+    def _assert_posterior(self):
+        try:
+            p = self.sim.inferer.idata.posterior
+        except AttributeError:
+            raise GutsBaseError(
+                "Using mode='mode' or mode='draws', but sim did not contain a posterior. " + 
+                "('sim.inferer.idata.posterior'). " + self._parameter_msg
+            )
+
 
     
     def _evaluate(self, factor, theta):
@@ -80,25 +126,128 @@ class ECxEstimator:
         sample = {k: v["data"] for k, v in sample.to_dict()["data_vars"].items()}
         return sample
 
-    def plot_loss_curve(self):
-        posterior_mean = self._posterior_mean()
+    def plot_loss_curve(self, 
+        mode: Literal["draws", "mean", "manual"] = "draws", 
+        draws: Optional[int] = None, 
+        parameters: Optional[Dict[str,float|List[float]]] = None,
+        log_x0: float = 0.0, 
+        force_draws: bool = False
+    ):
+        """
+        Parameters
+        ----------
 
-        factor = np.linspace(-2,2, 100)
-        y = list(map(partial(self._loss, theta=posterior_mean), factor))
+        mode : Literal['draws', 'mean', 'manual']
+            mode of estimation. mode='mean' takes the mean of the posterior and estimate
+            the ECx for this singular value. mode='draws' takes samples from the posterior
+            and estimate the ECx for each of the parameter draws. mode='manual' takes
+            a parameter set (Dict) in the parameters argument and uses that for estimation. 
+            Default: 'draws'
+        
+        draws : int
+            Number of draws to take from the posterior. Only takes effect if mode='draw'.
+            Raises an exception if draws < 100, because this is insufficient for a 
+            reasonable uncertainty estimate. Default: None (using all samples from the
+            posterior)
+        
+        parameters : Dict[str,float|list[float]]
+            a parameter dictionary passed used as model parameters for finding the ECx
+            value. Default: None
 
+        
+        log_x0 : float
+            the starting value for the multiplication factor of the exposure profile for
+            the minimization algorithm. This value is on the log scale. This means, 
+            exp(log_x0=0.0) = 1.0, which means that the log_x0=0.0 will start at an
+            unmodified exposure profile. Default: 0.0
+        
+        force_draws : bool
+            Force the estimate method to accept a number of draws less than 100. Default: False
+
+        """
+        draws = self._check_mode_and_draws_and_parameters(mode, draws, parameters, force_draws)
+
+
+        factor = np.linspace(-2,2, 100) + log_x0
         fig, ax = plt.subplots(1,1, sharey=True, figsize=(4, 3))
+        
+        for i in tqdm(range(draws)):
+            if mode == "draws":
+                sample = self._posterior_sample(i)
+            elif mode == "mean":
+                sample = self._posterior_mean()
+            elif mode == "manual":
+                sample = parameters
+            else: 
+                raise NotImplementedError(
+                    f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
+                )
+            
+            y = list(map(partial(self._loss, theta=sample), factor))
+
+            ax.plot(
+                np.exp(factor), y, 
+                color="black",
+            )
+
         ax.plot(
-            np.exp(factor), y, 
-            color="black",
+            [], [], color="black",
             label=f"$\ell = S(t={self.time},x_{{in}}=C_{{ext}} \cdot \phi) - {self.x}$"
         )
         ax.set_ylabel("Loss ($\ell$)")
         ax.set_xlabel("Multiplication factor ($\phi$)")
         ax.set_title(f"ID: {self.sim.coordinates['id'][0]}")
-        ax.set_ylim(0, np.max(y) * 1.25)
+        ax.set_ylim(0, ax.get_ylim()[1] * 1.25)
         ax.legend(frameon=False)
         fig.tight_layout()
 
+        self.figure_loss_curve = fig
+
+    def _check_mode_and_draws_and_parameters(self, mode, draws, parameters, force_draws):
+
+        if mode == "draws":
+            self._assert_posterior()
+
+            if draws is None:
+                draws = (
+                    self.sim.inferer.idata.posterior.sizes["chain"] * 
+                    self.sim.inferer.idata.posterior.sizes["draw"]
+                )
+            elif draws < 100 and not force_draws:
+                raise GutsBaseError(
+                    "draws must be larger than 100. Preferably > 1000. " +
+                    f"If you don't want uncertainty assessment of the {self._name} " +
+                    "estimates, use mode='mean'. If you really want to use less than " +
+                    "100 draws, use force_draws=True at your own risk."
+                )
+            else:
+                pass
+            
+            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'"
+            )
+
+        elif mode == "manual":
+            draws = 1
+            if parameters is None:
+                raise GutsBaseError(self._parameter_msg)
+        else:
+            raise GutsBaseError(
+                f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
+            )
+
+        return draws
+
+
     def estimate(
         self, 
         mode: Literal["draws", "mean", "manual"] = "draws", 
@@ -108,6 +257,8 @@ class ECxEstimator:
         accept_tol: float = 1e-5, 
         optimizer_tol: float = 1e-5,
         method: str = "cobyla", 
+        show_plot: bool = True,
+        force_draws: bool = False,
         **optimizer_kwargs
     ):
         """The minimizer for the EC_x operates on the unbounded linear scale, estimating 
@@ -157,40 +308,19 @@ 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
         
+        force_draws : bool
+            Force the estimate method to accept a number of draws less than 100. Default: False
+
         optimizer_kwargs :
             Additional arguments to pass to the optimizer
 
         """
         x0_tries = np.array([0.0, -1.0, 1.0, -2.0, 2.0]) + log_x0
-
-        if mode == "draws":
-            if draws is None:
-                draws = (
-                    self.sim.inferer.idata.posterior.sizes["chain"] * 
-                    self.sim.inferer.idata.posterior.sizes["draw"]
-                )
-            elif draws < 100:
-                raise ValueError(
-                    "draws must be larger than 100. Preferably > 1000. "
-                    f"If you don't want uncertainty assessment of the {self._name} "
-                    "estimates, use mode='mean'"
-                )
-            else:
-                pass
-
-        elif mode == "mean":
-            draws = 1
-        elif mode == "manual":
-            draws = 1
-            if parameters is None:
-                raise ValueError(
-                    "parameters need to be provided if mode='manual'"
-                )
-        else:
-            raise NotImplementedError(
-                f"Bad mode: {mode}. Mode must be one 'mean' or 'draws'"
-            )
+        draws = self._check_mode_and_draws_and_parameters(mode, draws, parameters, force_draws)
 
         self._mode = mode
         mult_factor = []
@@ -220,6 +350,7 @@ class ECxEstimator:
                 ) 
 
                 success = opt_res.fun < accept_tol
+                iteration += 1
 
             # convert to linear scale from log scale
             factor = np.exp(opt_res.x)
@@ -229,24 +360,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)
@@ -262,7 +412,7 @@ class ECxEstimator:
         self.sim.dispatch_constructor()
 
         if self._mode is None:
-            raise RuntimeError(
+            raise GutsBaseError(
                 "Run .estimate() before plot_profile_and_effect()"
             )
         elif self._mode == "mean" or self._mode == "draws":
@@ -327,6 +477,8 @@ class ECxEstimator:
         ax2.set_ylim(0, None)
         fig.tight_layout()
 
+        self.figure_profile_and_effect = fig
+
         self.sim.coordinates["time"] = coordinates_backup
         self.sim.dispatch_constructor()
 
@@ -348,4 +500,10 @@ class LPxEstimator(ECxEstimator):
     ):
         x_in = sim.model_parameters["x_in"].sel(id=[id])
         time = sim.coordinates["time"][-1]
-        super().__init__(sim=sim, effect="survival", x=x, id=id, time=time, x_in=x_in)
+        super().__init__(
+            sim=sim, 
+            effect="survival", 
+            x=x, 
+            time=time, 
+            x_in=x_in
+        )

guts_base/sim/mempy.py

@@ -1,44 +1,64 @@
 import pathlib
-from typing import Dict, Optional, Literal
+from typing import Dict, Optional, Literal, Protocol, TypedDict, List
 import re
-
+import os
 import numpy as np
 import pandas as pd
 import xarray as xr
-from pymob import SimulationBase
 from pymob.sim.config import Config, DataVariable, Datastructure
 from pymob.sim.parameters import Param
 from guts_base.sim import GutsBase
-from mempy.model import (
-    Model, 
-    RED_IT, 
-    RED_SD,
-    RED_IT_DA,
-    RED_SD_DA,
-    RED_IT_IA,
-    RED_SD_IA,
-    BufferGUTS_IT,
-    BufferGUTS_IT_CA,
-    BufferGUTS_IT_DA
-)
 
 __all__ = [
     "PymobSimulator",
 ]
 
+class ParamsInfoDict(TypedDict):
+    name: str
+    min: float
+    max: float
+    initial: float
+    vary: bool
+    prior: str
+
+class StateVariablesDict(TypedDict):
+    dimensions: List[str]
+    observed: bool
+    y0: List[float]
+
+class Model(Protocol):
+    extra_dim: Optional[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_mempy(
+    def from_model_and_dataset(
         cls,
-        exposure_data: Dict,
-        survival_data: Dict,
         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",
-    ) -> SimulationBase:
+    ) -> "PymobSimulator":
         """Construct a PymobSimulator from the 
         """
 
@@ -46,7 +66,7 @@ class PymobSimulator(GutsBase):
             cfg = Config()
             # Configure: The configuration can be overridden in a subclass to override the 
             # configuration
-            cls.configure(config=cfg)
+            cls._configure(config=cfg)
         else:
             cfg = pymob_config
 
@@ -55,6 +75,14 @@ class PymobSimulator(GutsBase):
 
         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)
+        
         # parse observations
         # obs can be simply subset by selection obs.sel(substance="Exposure-Dime")
         observations = xr.combine_by_coords([
@@ -62,9 +90,19 @@ class PymobSimulator(GutsBase):
             cls._survival_data_to_xarray(survival_data)
         ])
 
+        observations.to_netcdf(
+            os.path.join(cfg.case_study.output_path, cfg.case_study.observations)
+        )
+
         # configure model and likelihood function
-        cfg.simulation.model = type(model).__name__
-        cfg.inference_numpyro.user_defined_error_model = str(model._likelihood_func_jax.__name__)
+        # extract the fully qualified name of the model module.name
+        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)
@@ -75,35 +113,37 @@ class PymobSimulator(GutsBase):
         cfg.simulation.y0 = [f"{k}={v['y0']}" for k, v in model.state_variables.items() if "y0" in v]
 
         # 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.config.create_directory(directory="results", force=True)
-
-        # initialize
-        sim.load_modules()
-        sim.set_logger()
-
-        sim.initialize(input={"observations": observations, "model": model})
-        
-        sim.validate()
-        sim.dispatch_constructor()
-
-
+        sim.setup()
         return sim
 
-    def initialize(self, input=None):
-        self.model = input["model"]._rhs_jax
-        self.solver_post_processing = input["model"]._solver_post_processing
+    def reset_observations(self):
+        """Resets the observations to the original observations after using .from_mempy(...)
+        This also resets the sim.coordinates dictionary.
+        """
+
+        self.observations = self._obs_backup
 
-        super().initialize(input=input)
+    def setup(self, **evaluator_kwargs):
+        super().setup(**evaluator_kwargs)
+        self._obs_backup = self.observations.copy(deep=True)
 
 
     @classmethod
-    def configure(cls, config: Config):
+    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"
@@ -132,33 +172,6 @@ class PymobSimulator(GutsBase):
         config.inference_numpyro.svi_iterations = 10_000
         config.inference_numpyro.svi_learning_rate = 0.001
 
-    @staticmethod
-    def _exposure_data_to_xarray(exposure_data: Dict[str, pd.DataFrame], dim: str):
-        """
-        TODO: Currently no rect interpolation
-        """
-        arrays = {}
-        for key, df in exposure_data.items():
-            # this override is necessary to make all dimensions work out
-            df.index.name = "time"
-            arrays.update({
-                key: df.to_xarray().to_dataarray(dim="id", name=key)
-            }) 
-
-        exposure_array = xr.Dataset(arrays).to_array(dim=dim, name="exposure")
-        exposure_array = exposure_array.transpose("id", "time", ...)
-        return xr.Dataset({"exposure": exposure_array})
-
-    @staticmethod
-    def _survival_data_to_xarray(survival_data: pd.DataFrame):
-        # TODO: survival name is currently not kept because the raw data is not transferred from the survival
-        survival_data.index.name = "time"
-        
-        survival_array = survival_data.to_xarray().to_dataarray(dim="id", name="survival")
-        survival_array = survival_array.transpose("id", "time", ...)
-        arrays = {"survival": survival_array}
-        return xr.Dataset(arrays)
-
     @classmethod
     def _set_data_structure(cls, config: Config, model: Model):
         """Takes a dictionary that is specified in the model and uses only keys that
@@ -179,10 +192,7 @@ class PymobSimulator(GutsBase):
     def _set_params(cls, config: Config, model: Model, default_prior: str):
         params_info = model.params_info
 
-        if isinstance(model, (
-            RED_IT, RED_IT_DA, RED_IT_IA, 
-            BufferGUTS_IT, BufferGUTS_IT_CA, BufferGUTS_IT_DA
-        )):
+        if model._it_model:
             eps = config.jaxsolver.atol * 10
             params_info["eps"] = {'name':'eps', 'initial':eps, 'vary':False}
 
@@ -210,6 +220,11 @@ class PymobSimulator(GutsBase):
             _init = group["initial"].values.astype(float)
             _free = group["vary"].values
 
+            if isinstance(_min, np.ma.core.MaskedConstant):
+                _min = None
+            if isinstance(_max, np.ma.core.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

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()), 
@@ -49,7 +52,6 @@ class GutsReport(Report):
                 sim=sim,
                 effect="survival", 
                 x=row.x,
-                id=None, 
                 time=row.time, 
                 x_in=P[row.scenario], 
             )
@@ -57,6 +59,7 @@ class GutsReport(Report):
             ecx_estimator.estimate(
                 mode=sim.ecx_mode,
                 draws=250,
+                show_plot=False
             )
 
             ecx.append(ecx_estimator.results)
@@ -64,9 +67,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