def __deepcopy__(self, memodict=None):
model = amici.ModelPtr(self.amici_model.clone())
solver = amici.SolverPtr(self.amici_solver.clone())
edata = [amici.amici.ExpData(data) for data in self.edata]
other = AmiciObjective(model, solver, edata)
for attr in self.__dict__:
if attr not in ['amici_solver', 'amici_model', 'edata']:
other.__dict__[attr] = copy.deepcopy(self.__dict__[attr])
return other
def __deepcopy__(self, memodict=None):
other = self.__class__.__new__(self.__class__)
for key in set(self.__dict__.keys()) - \
set(['amici_model', 'amici_solver', 'edatas']):
other.__dict__[key] = copy.deepcopy(self.__dict__[key])
other.amici_model = amici.ModelPtr(self.amici_model.clone())
other.amici_solver = amici.SolverPtr(self.amici_solver.clone())
other.edatas = [amici.ExpData(data) for data in self.edatas]
return other
def __deepcopy__(self, memodict: Dict = None) -> 'AmiciObjective':
other = self.__class__.__new__(self.__class__)
for key in set(self.__dict__.keys()) - \
{'amici_model', 'amici_solver', 'edatas'}:
other.__dict__[key] = copy.deepcopy(self.__dict__[key])
# copy objects that do not have __deepcopy__
other.amici_model = amici.ModelPtr(self.amici_model.clone())
other.amici_solver = amici.SolverPtr(self.amici_solver.clone())
other.edatas = [amici.ExpData(data) for data in self.edatas]
return other
def __init__(self,
amici_model: AmiciModel,
amici_solver: AmiciSolver,
edatas: Union[Sequence['amici.ExpData'], 'amici.ExpData'],
max_sensi_order: int = None,
x_ids: Sequence[str] = None,
x_names: Sequence[str] = None,
parameter_mapping: 'ParameterMapping' = None,
guess_steadystate: bool = True,
n_threads: int = 1):
"""
Constructor.
Parameters
----------
amici_model:
The amici model.
amici_solver:
The solver to use for the numeric integration of the model.
edatas:
The experimental data. If a list is passed, its entries correspond
to multiple experimental conditions.
max_sensi_order:
Maximum sensitivity order supported by the model. Defaults to 2 if
the model was compiled with o2mode, otherwise 1.
x_ids:
Ids of optimization parameters. In the simplest case, this will be
the AMICI model parameters (default).
x_names:
Names of optimization parameters.
parameter_mapping:
Mapping of optimization parameters to model parameters. Format
as created by `amici.petab_objective.create_parameter_mapping`.
The default is just to assume that optimization and simulation
parameters coincide.
guess_steadystate:
Whether to guess steadystates based on previous steadystates and
respective derivatives. This option may lead to unexpected
results for models with conservation laws and should accordingly
be deactivated for those models.
n_threads:
Number of threads that are used for parallelization over
experimental conditions. If amici was not installed with openMP
support this option will have no effect.
"""
if amici is None:
raise ImportError(
"This objective requires an installation of amici "
"(https://github.com/icb-dcm/amici). "
"Install via `pip3 install amici`.")
if max_sensi_order is None:
# 2 if model was compiled with second orders,
# otherwise 1 can be guaranteed
max_sensi_order = 2 if amici_model.o2mode else 1
fun = self.get_bound_fun()
if max_sensi_order > 0:
grad = True
hess = True
else:
grad = None
hess = None
res = self.get_bound_res()
if max_sensi_order > 0:
sres = True
else:
sres = None
super().__init__(
fun=fun,
grad=grad,
hess=hess,
hessp=None,
res=res,
sres=sres,
fun_accept_sensi_orders=True,
res_accept_sensi_orders=True,
)
self.amici_model = amici.ModelPtr(amici_model.clone())
self.amici_solver = amici.SolverPtr(amici_solver.clone())
# make sure the edatas are a list of edata objects
if isinstance(edatas, amici.amici.ExpData):
edatas = [edatas]
# set the experimental data container
self.edatas = edatas
# set the maximum sensitivity order
self.max_sensi_order = max_sensi_order
self.guess_steadystate = guess_steadystate
# optimization parameter ids
if x_ids is None:
# use model parameter ids as ids
x_ids = list(self.amici_model.getParameterIds())
self.x_ids = x_ids
self.dim = len(self.x_ids)
# mapping of parameters
if parameter_mapping is None:
# use identity mapping for each condition
parameter_mapping = create_identity_parameter_mapping(
amici_model, len(edatas))
self.parameter_mapping = parameter_mapping
# preallocate guesses, construct a dict for every edata for which we
# need to do preequilibration
if self.guess_steadystate:
if self.amici_model.ncl() > 0:
raise ValueError('Steadystate prediciton is not supported for'
'models with conservation laws!')
if self.amici_model.getSteadyStateSensitivityMode() == \
amici.SteadyStateSensitivityMode_simulationFSA:
raise ValueError('Steadystate guesses cannot be enabled when'
' `simulationFSA` as '
'SteadyStateSensitivityMode!')
self.steadystate_guesses = {
'fval': np.inf,
'data': {
iexp: dict()
for iexp, edata in enumerate(self.edatas)
if len(edata.fixedParametersPreequilibration)
or self.amici_solver.getPreequilibration()
}
}
# optimization parameter names
if x_names is None:
# use ids as names
x_names = x_ids
self.x_names = x_names
self.n_threads = n_threads
def __init__(self,
amici_model: AmiciModel,
amici_solver: AmiciSolver,
edatas: Union[Sequence['amici.ExpData'], 'amici.ExpData'],
max_sensi_order: int = None,
x_ids: Sequence[str] = None,
x_names: Sequence[str] = None,
parameter_mapping: 'ParameterMapping' = None,
guess_steadystate: bool = True,
n_threads: int = 1,
fim_for_hess: bool = True,
amici_object_builder: AmiciObjectBuilder = None,
calculator: AmiciCalculator = None):
"""
Constructor.
Parameters
----------
amici_model:
The amici model.
amici_solver:
The solver to use for the numeric integration of the model.
edatas:
The experimental data. If a list is passed, its entries correspond
to multiple experimental conditions.
max_sensi_order:
Maximum sensitivity order supported by the model. Defaults to 2 if
the model was compiled with o2mode, otherwise 1.
x_ids:
Ids of optimization parameters. In the simplest case, this will be
the AMICI model parameters (default).
x_names:
Names of optimization parameters.
parameter_mapping:
Mapping of optimization parameters to model parameters. Format
as created by `amici.petab_objective.create_parameter_mapping`.
The default is just to assume that optimization and simulation
parameters coincide.
guess_steadystate:
Whether to guess steadystates based on previous steadystates and
respective derivatives. This option may lead to unexpected
results for models with conservation laws and should accordingly
be deactivated for those models.
n_threads:
Number of threads that are used for parallelization over
experimental conditions. If amici was not installed with openMP
support this option will have no effect.
fim_for_hess:
Whether to use the FIM whenever the Hessian is requested. This only
applies with forward sensitivities.
With adjoint sensitivities, the true Hessian will be used,
if available.
FIM or Hessian will only be exposed if `max_sensi_order>1`.
amici_object_builder:
AMICI object builder. Allows recreating the objective for
pickling, required in some parallelization schemes.
calculator:
Performs the actual calculation of the function values and
derivatives.
"""
if amici is None:
raise ImportError(
"This objective requires an installation of amici "
"(https://github.com/icb-dcm/amici). "
"Install via `pip3 install amici`.")
self.amici_model = amici.ModelPtr(amici_model.clone())
self.amici_solver = amici.SolverPtr(amici_solver.clone())
# make sure the edatas are a list of edata objects
if isinstance(edatas, amici.amici.ExpData):
edatas = [edatas]
# set the experimental data container
self.edatas = edatas
# set the maximum sensitivity order
self.max_sensi_order = max_sensi_order
self.guess_steadystate = guess_steadystate
# optimization parameter ids
if x_ids is None:
# use model parameter ids as ids
x_ids = list(self.amici_model.getParameterIds())
self.x_ids = x_ids
# mapping of parameters
if parameter_mapping is None:
# use identity mapping for each condition
parameter_mapping = create_identity_parameter_mapping(
amici_model, len(edatas))
self.parameter_mapping = parameter_mapping
# preallocate guesses, construct a dict for every edata for which we
# need to do preequilibration
if self.guess_steadystate:
if self.amici_model.ncl() > 0:
raise ValueError('Steadystate prediction is not supported for '
'models with conservation laws!')
if self.amici_model.getSteadyStateSensitivityMode() == \
amici.SteadyStateSensitivityMode_simulationFSA:
raise ValueError('Steadystate guesses cannot be enabled when'
' `simulationFSA` as '
'SteadyStateSensitivityMode!')
self.steadystate_guesses = {
'fval': np.inf,
'data': {
iexp: {}
for iexp, edata in enumerate(self.edatas)
if len(edata.fixedParametersPreequilibration)
or self.amici_solver.getPreequilibration()
}
}
# optimization parameter names
if x_names is None:
# use ids as names
x_names = x_ids
self.n_threads = n_threads
self.fim_for_hess = fim_for_hess
self.amici_object_builder = amici_object_builder
if calculator is None:
calculator = AmiciCalculator()
self.calculator = calculator
super().__init__(x_names=x_names)
def __init__(self,
amici_model,
amici_solver,
edatas,
max_sensi_order=None,
x_ids=None,
x_names=None,
mapping_par_opt_to_par_sim=None,
mapping_scale_opt_to_scale_sim=None,
guess_steadystate=True,
n_threads=1,
options=None):
"""
Constructor.
Parameters
----------
amici_model: amici.Model
The amici model.
amici_solver: amici.Solver
The solver to use for the numeric integration of the model.
edatas: amici.ExpData or list of amici.ExpData
The experimental data. If a list is passed, its entries correspond
to multiple experimental conditions.
max_sensi_order: int, optional
Maximum sensitivity order supported by the model. Defaults to 2 if
the model was compiled with o2mode, otherwise 1.
x_ids: list of str, optional
Ids of optimization parameters. In the simplest case, this will be
the AMICI model parameters (default).
x_names: list of str, optional
See ``Objective.x_names``.
mapping_par_opt_to_par_sim: optional
Mapping of optimization parameters to model parameters. List array
of size n_simulation_parameters * n_conditions.
The default is just to assume that optimization and simulation
parameters coincide. The default is to assume equality of both.
mapping_scale_opt_to_scale_sim: optional
Mapping of optimization parameter scales to simulation parameter
scales. The default is to just use the scales specified in the
`amici_model` already.
guess_steadystate: bool, optional (default = True)
Whether to guess steadystates based on previous steadystates and
respective derivatives. This option may lead to unexpected
results for models with conservation laws and should accordingly
be deactivated for those models.
n_threads: int, optional (default = 1)
Number of threads that are used for parallelization over
experimental conditions. If amici was not installed with openMP
support this option will have no effect.
options: pypesto.ObjectiveOptions, optional
Further options.
"""
if amici is None:
raise ImportError(
"This objective requires an installation of amici "
"(https://github.com/icb-dcm/amici). "
"Install via `pip3 install amici`.")
if max_sensi_order is None:
# 2 if model was compiled with second orders,
# otherwise 1 can be guaranteed
max_sensi_order = 2 if amici_model.o2mode else 1
fun = self.get_bound_fun()
if max_sensi_order > 0:
grad = True
hess = True
else:
grad = None
hess = None
res = self.get_bound_res()
if max_sensi_order > 0:
sres = True
else:
sres = None
super().__init__(fun=fun,
grad=grad,
hess=hess,
hessp=None,
res=res,
sres=sres,
fun_accept_sensi_orders=True,
res_accept_sensi_orders=True,
options=options)
self.amici_model = amici.ModelPtr(amici_model.clone())
self.amici_solver = amici.SolverPtr(amici_solver.clone())
# make sure the edatas are a list of edata objects
if isinstance(edatas, amici.amici.ExpData):
edatas = [edatas]
# set the experimental data container
self.edatas = edatas
# set the maximum sensitivity order
self.max_sensi_order = max_sensi_order
self.guess_steadystate = guess_steadystate
# optimization parameter ids
if x_ids is None:
# use model parameter ids as ids
x_ids = list(self.amici_model.getParameterIds())
self.x_ids = x_ids
self.dim = len(self.x_ids)
# mapping of parameters
if mapping_par_opt_to_par_sim is None:
# use identity mapping for each condition
mapping_par_opt_to_par_sim = \
[x_ids for _ in range(len(self.edatas))]
self.mapping_par_opt_to_par_sim = mapping_par_opt_to_par_sim
# mapping of parameter scales
if mapping_scale_opt_to_scale_sim is None:
# use scales from amici model
mapping_scale_opt_to_scale_sim = \
create_scale_mapping_from_model(
self.amici_model.getParameterScale(), len(self.edatas))
self.mapping_scale_opt_to_scale_sim = mapping_scale_opt_to_scale_sim
# preallocate guesses, construct a dict for every edata for which we
# need to do preequilibration
if self.guess_steadystate:
if self.amici_model.ncl() > 0:
raise ValueError('Steadystate prediciton is not supported for'
'models with conservation laws!')
if self.amici_model.getSteadyStateSensitivityMode() == \
amici.SteadyStateSensitivityMode_simulationFSA:
raise ValueError('Steadystate guesses cannot be enabled when'
' `simulationFSA` as '
'SteadyStateSensitivityMode!')
self.steadystate_guesses = {
'fval': np.inf,
'data': {
iexp: dict()
for iexp, edata in enumerate(self.edatas)
if len(edata.fixedParametersPreequilibration)
or self.amici_solver.getNewtonPreequilibration()
}
}
# optimization parameter names
if x_names is None:
# use ids as names
x_names = x_ids
self.x_names = x_names
self.n_threads = n_threads