eulerpi.core.models.sbml_model module

class SBMLModel(sbml_file: str, central_param: ndarray, param_limits: ndarray, timepoints: list, param_ids: list | None = None, state_ids: list | None = None, skip_creation: bool = False, name: str | None = None, **kwargs)

Bases: BaseModel

The SBMLModel class is a wrapper for the AMICI python interface to simulate SBML models using this package.

Parameters:

• sbml_file (str) – The path to the SBML model file.

• param_ids (list) – A list of ids of parameter, which will be estimated during the inference. If None all parameter ids are extracted from the SBML model.

• state_ids (list) – A list of state ids, for which data will be given during the inference. If None all state ids are extracted from the SBML model.

• timepoints (list) – List of measurement time points, this is where the sbml model is evaluated and compared to the data

• skip_creation (bool) – If True the model is not created againg based on the SBML file. Instead the model is loaded from a previously created model. (Default value = False)

• central_param (np.ndarray) – The central parameter for the model

• param_limits (np.ndarray) – The parameter limits for the model

forward(params)

Executed the forward pass of the model to obtain data from a parameter.

Parameters:

param (np.ndarray) – The parameter for which the data should be generated.

Returns:

The data generated from the parameter.

Return type:

np.ndarray

Examples:

import numpy as np
from eulerpi.examples.heat import Heat
from eulerpi.core.models import JaxModel
from jax import vmap

# instantiate the heat model
model = Heat()

# define a 3D example parameter for the heat model
example_param = np.array([1.4, 1.6, 0.5])

# the forward simulation is achieved by using the forward method of the model
sim_result = model.forward(example_param)

# in a more realistic scenario, we would like to perform the forward pass on multiple parameters at once
multiple_params = np.array([[1.5, 1.5, 0.5],
                            [1.4, 1.4, 0.6],
                            [1.6, 1.6, 0.4],
                            model.central_param,
                            [1.5, 1.4, 0.4]])
multiple_sim_results = model.forward_vectorized(multiple_params)

forward_and_jacobian(params: ndarray) → Tuple[ndarray, ndarray]

Evaluates the jacobian and the forward pass of the model at the same time. If the method is not overwritten in a subclass it, it simply calls forward() and jacobian(). It can be vectorized in the same way as the forward and jacobian methods.

Parameters:

param (np.ndarray) – The parameter for which the jacobian should be evaluated.

Returns:

The data generated from the parameter and the jacobian for the variables returned by the forward() method with respect to the parameters.

Return type:

Tuple[np.ndarray, np.ndarray]

static indices_from_ids(ids: list, all_ids: list) → list

Returns the indices of the ids in the all_ids list.

Parameters:

• ids (list) – The ids for which the indices should be returned.

• all_ids (list) – The list of all ids.

Returns:

The indices of the ids in the all_ids list.

Return type:

list

Throws:

ValueError: If one of the ids is not in the all_ids list.

jacobian(params)

Evaluates the jacobian of the forward() method.

Parameters:

param (np.ndarray) – The parameter for which the jacobian should be evaluated.

Returns:

The jacobian for the variables returned by the forward() method with respect to the parameters.

Return type:

np.ndarray

Examples:

import numpy as np
from eulerpi.examples.heat import Heat
from eulerpi.core.models import JaxModel
from jax import vmap

# instantiate the heat model
model = Heat()

# define a 3D example parameter for the heat model
example_param = np.array([1.4, 1.6, 0.5])

sim_jacobian = model.jacobian(example_param)

# Similar to the forward pass, also the evaluation of the jacobian can be vectorized.
# This yields a 3D array of shape (num_params, data_dim, param_dim) = (4,5,3) in this example.

multiple_params = np.array([[1.5, 1.5, 0.5],
                            [1.4, 1.4, 0.6],
                            model.central_param,
                            [1.5, 1.4, 0.4]])

# try to use jax vmap for vectorization if possible
if isinstance(model, JaxModel):
    multiple_sim_jacobians = vmap(model.jacobian, in_axes=0)(multiple_params)

# if the model is not a jax model, we can use numpy vectorize to vectorize
else:
    multiple_sim_jacobians = np.vectorize(model.jacobian, signature="(n)->(m)")(multiple_params)

load_amici_model_and_solver()

Loads the AMICI model from the previously generated model.

setSensitivities()

Tell the underlying amici solver to calculate sensitivities based on the attribute self.param_ids

property data_dim

The dimension of a data point returned by the model.

property param_dim

The number of parameters of the model.

is_amici_available()