def create_parameter_mapping(
petab_problem: petab.Problem,
simulation_conditions: Union[pd.DataFrame, Dict],
scaled_parameters: bool,
amici_model: AmiciModel,
) -> ParameterMapping:
"""Generate AMICI specific parameter mapping.
:param petab_problem:
PEtab problem
:param simulation_conditions:
Result of `petab.get_simulation_conditions`. Can be provided to save
time if this has been obtained before.
:param scaled_parameters:
If True, problem_parameters are assumed to be on the scale provided
in the PEtab parameter table and will be unscaled. If False, they
are assumed to be in linear scale.
:param amici_model:
AMICI model.
:return:
List of the parameter mappings.
"""
if simulation_conditions is None:
simulation_conditions = \
petab_problem.get_simulation_conditions_from_measurement_df()
# Because AMICI globalizes all local parameters during model import,
# we need to do that here as well to prevent parameter mapping errors
# (PEtab does currently not care about SBML LocalParameters)
if petab_problem.sbml_document:
converter_config = libsbml.SBMLLocalParameterConverter() \
.getDefaultProperties()
petab_problem.sbml_document.convert(converter_config)
else:
logger.debug("No petab_problem.sbml_document is set. Cannot convert "
"SBML LocalParameters. If the model contains "
"LocalParameters, parameter mapping will fail.")
prelim_parameter_mapping = \
petab_problem.get_optimization_to_simulation_parameter_mapping(
warn_unmapped=False, scaled_parameters=scaled_parameters,
allow_timepoint_specific_numeric_noise_parameters=
not petab.lint.observable_table_has_nontrivial_noise_formula(
petab_problem.observable_df
)
)
parameter_mapping = ParameterMapping()
for (_, condition), prelim_mapping_for_condition in \
zip(simulation_conditions.iterrows(), prelim_parameter_mapping):
mapping_for_condition = create_parameter_mapping_for_condition(
prelim_mapping_for_condition, condition, petab_problem,
amici_model)
parameter_mapping.append(mapping_for_condition)
return parameter_mapping
def get_summary(
petab_problem: petab.Problem,
petab_problem_id: str = None,
) -> Dict:
"""Get dictionary with stats for the given PEtab problem"""
return {
'petab_problem_id':
petab_problem_id,
'conditions':
petab_problem.get_simulation_conditions_from_measurement_df().shape[0],
'estimated_parameters':
np.sum(petab_problem.parameter_df[petab.ESTIMATE]),
'events':
len(petab_problem.sbml_model.getListOfEvents()),
'measurements':
len(petab_problem.measurement_df.index),
'observables':
len(petab_problem.measurement_df[petab.OBSERVABLE_ID].unique()),
'species':
len(petab_problem.sbml_model.getListOfSpecies()),
'reference_uris':
get_reference_uris(petab_problem.sbml_model),
}
def create_edatas(
amici_model: AmiciModel,
petab_problem: petab.Problem,
simulation_conditions: Union[pd.DataFrame, Dict] = None,
) -> List[amici.ExpData]:
"""Create list of :class:`amici.amici.ExpData` objects for PEtab problem.
:param amici_model:
AMICI model.
:param petab_problem:
Underlying PEtab problem.
:param simulation_conditions:
Result of `petab.get_simulation_conditions`. Can be provided to save
time if this has be obtained before.
:return:
List with one :class:`amici.amici.ExpData` per simulation condition,
with filled in timepoints and data.
"""
if simulation_conditions is None:
simulation_conditions = \
petab_problem.get_simulation_conditions_from_measurement_df()
observable_ids = amici_model.getObservableIds()
edatas = []
for _, condition in simulation_conditions.iterrows():
# Create amici.ExpData for each simulation
edata = create_edata_for_condition(
condition=condition,
amici_model=amici_model,
petab_problem=petab_problem,
observable_ids=observable_ids,
)
edatas.append(edata)
return edatas
def simulate_petab(
petab_problem: petab.Problem,
amici_model: AmiciModel,
solver: Optional[amici.Solver] = None,
problem_parameters: Optional[Dict[str, float]] = None,
simulation_conditions: Union[pd.DataFrame, Dict] = None,
edatas: List[AmiciExpData] = None,
parameter_mapping: ParameterMapping = None,
scaled_parameters: Optional[bool] = False,
log_level: int = logging.WARNING
) -> Dict[str, Any]:
"""Simulate PEtab model.
:param petab_problem:
PEtab problem to work on.
:param amici_model:
AMICI Model assumed to be compatible with ``petab_problem``.
:param solver:
An AMICI solver. Will use default options if None.
:param problem_parameters:
Run simulation with these parameters. If None, PEtab `nominalValues`
will be used). To be provided as dict, mapping PEtab problem
parameters to SBML IDs.
:param simulation_conditions:
Result of `petab.get_simulation_conditions`. Can be provided to save
time if this has be obtained before.
Not required if `edatas` and `parameter_mapping` are provided.
:param edatas:
Experimental data. Parameters are inserted in-place for simulation.
:param parameter_mapping:
Optional precomputed PEtab parameter mapping for efficiency, as
generated by `create_parameter_mapping`.
:param scaled_parameters:
If True, problem_parameters are assumed to be on the scale provided
in the PEtab parameter table and will be unscaled. If False, they
are assumed to be in linear scale.
:param log_level:
Log level, see :mod:`amici.logging` module.
:return:
Dictionary of
* cost function value (LLH),
* const function sensitivity w.r.t. parameters (SLLH),
(**NOTE**: Sensitivities are computed for the scaled parameters)
* list of `ReturnData` (RDATAS),
corresponding to the different simulation conditions.
For ordering of simulation conditions, see
:meth:`petab.Problem.get_simulation_conditions_from_measurement_df`.
"""
logger.setLevel(log_level)
if solver is None:
solver = amici_model.getSolver()
# Get parameters
if problem_parameters is None:
# Use PEtab nominal values as default
problem_parameters = {t.Index: getattr(t, NOMINAL_VALUE) for t in
petab_problem.parameter_df.itertuples()}
scaled_parameters = False
# number of amici simulations will be number of unique
# (preequilibrationConditionId, simulationConditionId) pairs.
# Can be optimized by checking for identical condition vectors.
if simulation_conditions is None and parameter_mapping is None \
and edatas is None:
simulation_conditions = \
petab_problem.get_simulation_conditions_from_measurement_df()
# Get parameter mapping
if parameter_mapping is None:
parameter_mapping = create_parameter_mapping(
petab_problem=petab_problem,
simulation_conditions=simulation_conditions,
scaled_parameters=scaled_parameters,
amici_model=amici_model)
# Get edatas
if edatas is None:
# Generate ExpData with all condition-specific information
edatas = create_edatas(
amici_model=amici_model,
petab_problem=petab_problem,
simulation_conditions=simulation_conditions)
# Fill parameters in ExpDatas (in-place)
fill_in_parameters(
edatas=edatas,
problem_parameters=problem_parameters,
scaled_parameters=scaled_parameters,
parameter_mapping=parameter_mapping,
amici_model=amici_model)
# Simulate
rdatas = amici.runAmiciSimulations(amici_model, solver, edata_list=edatas)
# Compute total llh
llh = sum(rdata['llh'] for rdata in rdatas)
# Compute total sllh
sllh = aggregate_sllh(amici_model=amici_model, rdatas=rdatas,
parameter_mapping=parameter_mapping)
# Log results
sim_cond = petab_problem.get_simulation_conditions_from_measurement_df()
for i, rdata in enumerate(rdatas):
logger.debug(f"Condition: {sim_cond.iloc[i, :].values}, status: "
f"{rdata['status']}, llh: {rdata['llh']}")
return {
LLH: llh,
SLLH: sllh,
RDATAS: rdatas
}
def create_parameterized_edatas(
amici_model: AmiciModel,
petab_problem: petab.Problem,
problem_parameters: Dict[str, numbers.Number],
scaled_parameters: bool = False,
parameter_mapping: ParameterMapping = None,
simulation_conditions: Union[pd.DataFrame, Dict] = None,
) -> List[amici.ExpData]:
"""Create list of :class:amici.ExpData objects with parameters filled in.
:param amici_model:
AMICI Model assumed to be compatible with ``petab_problem``.
:param petab_problem:
PEtab problem to work on.
:param problem_parameters:
Run simulation with these parameters. If None, PEtab `nominalValues`
will be used). To be provided as dict, mapping PEtab problem
parameters to SBML IDs.
:param scaled_parameters:
If True, problem_parameters are assumed to be on the scale provided
in the PEtab parameter table and will be unscaled. If False, they
are assumed to be in linear scale.
:param parameter_mapping:
Optional precomputed PEtab parameter mapping for efficiency, as
generated by `create_parameter_mapping`.
:param simulation_conditions:
Result of `petab.get_simulation_conditions`. Can be provided to save
time if this has been obtained before.
:return:
List with one :class:`amici.amici.ExpData` per simulation condition,
with filled in timepoints, data and parameters.
"""
# number of amici simulations will be number of unique
# (preequilibrationConditionId, simulationConditionId) pairs.
# Can be optimized by checking for identical condition vectors.
if simulation_conditions is None:
simulation_conditions = \
petab_problem.get_simulation_conditions_from_measurement_df()
# Get parameter mapping
if parameter_mapping is None:
parameter_mapping = create_parameter_mapping(
petab_problem=petab_problem,
simulation_conditions=simulation_conditions,
scaled_parameters=scaled_parameters,
amici_model=amici_model)
# Generate ExpData with all condition-specific information
edatas = create_edatas(
amici_model=amici_model,
petab_problem=petab_problem,
simulation_conditions=simulation_conditions)
# Fill parameters in ExpDatas (in-place)
fill_in_parameters(
edatas=edatas,
problem_parameters=problem_parameters,
scaled_parameters=scaled_parameters,
parameter_mapping=parameter_mapping,
amici_model=amici_model)
return edatas
