def main():
"""
Command line interface to import a model in the PEtab
(https://github.com/ICB-DCM/PEtab/) format into AMICI.
"""
args = parse_cli_args()
if args.yaml_file_name:
pp = petab.Problem.from_yaml(args.yaml_file_name)
else:
pp = petab.Problem.from_files(
sbml_file=args.sbml_file_name,
condition_file=args.condition_file_name,
measurement_file=args.measurement_file_name,
parameter_file=args.parameter_file_name,
observable_files=args.observable_file_name)
# First check for valid PEtab
petab.lint_problem(pp)
import_model(model_name=args.model_name,
sbml_model=pp.sbml_model,
condition_table=pp.condition_df,
observable_table=pp.observable_df,
measurement_table=pp.measurement_df,
model_output_dir=args.model_output_dir,
compile=args.compile,
verbose=args.verbose)
def main():
args = parse_cli_args()
init_colorama(autoreset=True)
# First check for valid PEtab
pp = petab.Problem.from_files(sbml_file=args.sbml_file_name,
condition_file=args.condition_file_name,
measurement_file=args.measurement_file_name,
parameter_file=args.parameter_file_name)
petab.lint_problem(pp)
import_model(args.sbml_file_name,
args.condition_file_name,
args.measurement_file_name,
model_output_dir=args.model_output_dir,
compile=args.compile,
verbose=True)
def run_import(model_name):
git_dir = os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT')
if not os.path.exists(git_dir):
subprocess.run([
'git', 'clone', '--depth', '1',
'https://github.com/ICB-DCM/CS_Signalling_ERBB_RAS_AKT']
)
os.chdir(os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT'))
pp = petab.Problem.from_yaml(
'FroehlichKes2018/PEtab/FroehlichKes2018.yaml'
)
petab.lint_problem(pp)
import_model(model_name=model_name,
sbml_model=pp.sbml_model,
condition_table=pp.condition_df,
observable_table=pp.observable_df,
measurement_table=pp.measurement_df,
compile=False,
verbose=True)
def __init__(self,
petab_problem: petab.Problem,
amici_model: amici.Model,
verbose=1):
"""
fileNameSBML: filename of model SBML file (PEtab-style)
fileMeasurements: filename of measurement file
fileFixedParameters: filename with AMICI fixed parameter vectors for
all conditions referred to in the measurement file
fileParameters: PEtab parameter table filename
"""
self.condition_ids = None
self.f: Optional[h5py.File] = None
self.num_condition_vectors: int = 0
self.unique_timepoints = None
self.parameter_mapping: Optional[petab.ParMappingDict] = None
self.parameter_scale_mapping: Optional[petab.ScaleMappingDict] = None
self.optimization_parameter_name_to_index: Dict[str, int] = {}
self.nk: int = 0
self.condition_map = None
self.observable_ids = None
self.ny: int = 0
self.verbose = verbose
self.petab_problem: petab.Problem = petab_problem
self.amici_model: amici.Model = amici_model
# ensure we have valid inputs
petab.lint_problem(self.petab_problem)
# index for no reference/preequilibration condition
self.NO_PREEQ_CONDITION_IDX: int = NO_PREEQ_CONDITION_IDX
# value for unmapped model parameter in opt<->sim mapping
self.UNMAPPED_PARAMETER: int = UNMAPPED_PARAMETER
# hdf5 dataset compression
self.compression = "gzip"
def main():
condition_file_template = 'exp_table.tsv'
measurement_file_template = 'cost_func_newFormat_original.txt'
sbml_file = '../PEtab/CS_Signalling_ERBB_RAS_AKT_petab.xml'
condition_file = '../PEtab/conditions_petab.tsv'
measurement_file = '../PEtab/measurements_petab.tsv'
parameter_file = '../PEtab/parameters_petab.tsv'
sbml_reader = libsbml.SBMLReader()
sbml_document = sbml_reader.readSBML(sbml_file)
sbml_model = sbml_document.getModel()
update_condition_table(condition_file_template, condition_file, sbml_model)
update_measurement_table(measurement_file_template, measurement_file)
create_parameter_table(sbml_file, condition_file, measurement_file,
parameter_file)
# check for valid PEtab
pp = petab.Problem.from_files(
sbml_file=sbml_file,
condition_file=condition_file,
measurement_file=measurement_file,
parameter_file=parameter_file)
petab.lint_problem(pp)
def update_ccle_mclp():
condition_file_template = 'exp_table.tsv'
measurement_file_template = 'measurements_Training_dataset1-2.tsv'
sbml_file = 'CS_Signalling_ERBB_RAS_AKT_CCLE_MCLP_petab.xml'
condition_file = 'conditions_petab.tsv'
measurement_file = 'measurements_CCLE_MCLP_petab.tsv'
parameter_file = 'parameters_CCLE_MCLP_petab.tsv'
sbml_reader = libsbml.SBMLReader()
sbml_document = sbml_reader.readSBML(sbml_file)
sbml_model = sbml_document.getModel()
#update_condition_table(condition_file_template, condition_file, sbml_model)
update_measurement_table(measurement_file_template, measurement_file)
create_parameter_table(sbml_file, condition_file, measurement_file,
parameter_file)
# check for valid PEtab
pp = petab.Problem.from_files(
sbml_file=sbml_file,
condition_file=condition_file,
measurement_file=measurement_file,
parameter_file=parameter_file)
petab.lint_problem(pp)
def __init__(
self,
petab_problem: 'petab.Problem',
output_folder: str = None,
model_name: str = None,
validate_petab: bool = True,
):
"""Initialize importer.
Parameters
----------
petab_problem:
Managing access to the model and data.
output_folder:
Folder to contain the amici model. Defaults to
'./amici_models/{model_name}'.
model_name:
Name of the model, which will in particular be the name of the
compiled model python module.
validate_petab:
Flag indicating if the PEtab problem shall be validated.
"""
self.petab_problem = petab_problem
if validate_petab:
if petab.lint_problem(petab_problem):
raise ValueError("Invalid PEtab problem.")
if output_folder is None:
output_folder = _find_output_folder_name(
self.petab_problem,
model_name=model_name,
)
self.output_folder = output_folder
if model_name is None:
model_name = _find_model_name(self.output_folder)
self.model_name = model_name
def main():
args = parse_cli_args()
script_path = os.path.split(os.path.abspath(__file__))[0]
model_name = 'model_steadystate_scaled'
print(f'{__file__} running in {os.getcwd()}')
print(f'Processing model {args.sbml_file_name}')
# Create sbml model from scratch
cmd = f'bash -c "{script_path}/createSteadystateExampleSBML.py > {args.sbml_file_name}"'
print(cmd)
out = subprocess.check_output(cmd, shell=True)
print(out.decode('utf-8'))
print()
print_model_info(args.sbml_file_name)
print()
fixed_parameters, observables = create_module(args.sbml_file_name,
model_name,
args.model_output_dir)
print('Observables:', observables)
print('Fixed parameters', fixed_parameters)
print()
# load model
sys.path.insert(0, args.model_output_dir)
model_module = importlib.import_module(model_name)
print()
print("--- Creating data ---")
true_parameters, expected_llh = create_data_tables(
model=model_module.getModel(),
measurement_file=args.measurement_file_name,
fixed_parameter_file=args.condition_file_name,
fixed_parameters=fixed_parameters)
# check for valid PEtab
pp = petab.Problem.from_files(sbml_file=args.sbml_file_name,
condition_file=args.condition_file_name,
measurement_file=args.measurement_file_name)
create_parameter_table(problem=pp,
parameter_file=args.parameter_file_name,
nominal_parameters=true_parameters)
petab.lint_problem(pp)
# create training data
generate_hdf5_file(sbml_file_name=args.sbml_file_name,
model_output_dir=args.model_output_dir,
measurement_file_name=args.measurement_file_name,
condition_file_name=args.condition_file_name,
hdf5_file_name=args.hdf5_file_name,
parameter_file_name=args.parameter_file_name,
model_name=model_name)
# create test data
args.test_measurement_file_name = \
"-testset".join(os.path.splitext(args.measurement_file_name))
args.test_parameter_file_name = \
"-testset".join(os.path.splitext(args.parameter_file_name))
df = petab.get_measurement_df(args.measurement_file_name)
df.loc[df.observableParameters == 'scaling_x1_common', 'measurement'] = \
df.loc[df.observableParameters == 'scaling_x1_common', 'measurement'] \
* 2.0
df.loc[~df.observableParameters.isnull(), 'observableParameters'] = \
df.loc[~df.observableParameters.isnull(), 'observableParameters'] \
+ "_test"
df.to_csv(args.test_measurement_file_name, sep='\t', index=False)
df = petab.get_parameter_df(args.parameter_file_name)
df.rename(index={
'scaling_x1_common': 'scaling_x1_common_test',
'offset_x2_batch-0': 'offset_x2_batch-0_test',
'offset_x2_batch-1': 'offset_x2_batch-1_test'
},
inplace=True)
df.to_csv(args.test_parameter_file_name, sep='\t')
generate_hdf5_file(sbml_file_name=args.sbml_file_name,
model_output_dir=args.model_output_dir,
measurement_file_name=args.test_measurement_file_name,
condition_file_name=args.condition_file_name,
hdf5_file_name="-testset".join(
os.path.splitext(args.hdf5_file_name)),
parameter_file_name=args.test_parameter_file_name,
model_name=model_name)
save_expected_results(args.hdf5_file_name, true_parameters, expected_llh)
write_starting_points(args.hdf5_file_name, true_parameters)
def __init__(self,
n_hidden: int,
datafiles: Tuple[str, str, str],
pathway_name: str,
par_modulation_scale: float = 1 / 2):
"""
loads the mechanistic model as theano operator with loss as output and
decoder output as input
:param datafiles:
tuple of paths to measurements, conditions and observables files
:param pathway_name:
name of pathway to use for model
:param n_hidden:
number of nodes in the hidden layer of the encoder
:param par_modulation_scale:
currently this parameter only influences the strength of l2
regularization on the inflate layer (the respective gaussian
prior has its standard deviation defined based on the value of
this parameter). For bounded inflate functions, this parameter
is also intended to rescale the inputs accordingly.
"""
self.data_name = '__'.join(
os.path.splitext(os.path.basename(
datafiles[0]))[0].split('__')[:-1])
self.pathway_name = pathway_name
self.par_modulation_scale = par_modulation_scale
self.petab_importer = load_petab(datafiles, 'pw_' + pathway_name,
par_modulation_scale)
full_measurements = self.petab_importer.petab_problem.measurement_df
filter_observables(self.petab_importer.petab_problem)
petab.lint_problem(self.petab_importer.petab_problem)
self.pypesto_subproblem = self.petab_importer.create_problem()
# extract sample names, ordering of those is important since samples
# must match when reshaping the inflated matrix
samples = []
for name in self.pypesto_subproblem.x_names:
if not name.startswith(MODEL_FEATURE_PREFIX):
continue
sample = name.split('__')[-1]
if sample not in samples:
samples.append(sample)
input_data = full_measurements.loc[
full_measurements.apply(lambda x:
(x[petab.SIMULATION_CONDITION_ID] == x[
petab.PREEQUILIBRATION_CONDITION_ID]) &
(x[petab.TIME] == 0.0),
axis=1), :].pivot_table(
index=petab.SIMULATION_CONDITION_ID,
columns=petab.OBSERVABLE_ID,
values=petab.MEASUREMENT,
aggfunc=np.nanmean).loc[samples, :]
# remove missing values
input_data.dropna(axis='columns', how='any', inplace=True)
self.n_visible = input_data.shape[1]
self.n_samples = input_data.shape[0]
self.n_model_inputs = int(
sum(
name.startswith(MODEL_FEATURE_PREFIX)
for name in self.pypesto_subproblem.x_names) / self.n_samples)
self.n_kin_params = \
self.pypesto_subproblem.dim - self.n_model_inputs * self.n_samples
# zero center input data, this is equivalent to estimating biases
# for linear autoencoders
# https://link.springer.com/article/10.1007/BF00332918
# https://arxiv.org/pdf/1901.08168.pdf
input_data -= input_data.mean()
self.sample_names = list(input_data.index)
super().__init__(input_data=input_data.values,
n_hidden=n_hidden,
n_params=self.n_model_inputs)
# set tolerances
self.pypesto_subproblem.objective._objectives[0].amici_solver\
.setAbsoluteTolerance(1e-12)
self.pypesto_subproblem.objective._objectives[0].amici_solver\
.setRelativeTolerance(1e-10)
self.pypesto_subproblem.objective._objectives[0].amici_solver\
.setAbsoluteToleranceSteadyState(1e-10)
self.pypesto_subproblem.objective._objectives[0].amici_solver\
.setRelativeToleranceSteadyState(1e-8)
#self.pypesto_subproblem.objective._objectives[0].amici_solver\
# .setSensitivityMethod(amici.SensitivityMethod.adjoint)
# define model theano op
self.loss = TheanoLogProbability(self.pypesto_subproblem)
# these are the kinetic parameters that are shared across all samples
self.kin_pars = tt.specify_shape(tt.vector('kinetic_parameters'),
(self.n_kin_params, ))
self.x_names = self.x_names + [
name for ix, name in enumerate(self.pypesto_subproblem.x_names)
if not name.startswith(MODEL_FEATURE_PREFIX)
and ix in self.pypesto_subproblem.x_free_indices
]
# assemble input to model theano op
encoded_pars = self.encode_params(self.encoder_pars)
self.model_pars = tt.concatenate([
self.kin_pars,
tt.reshape(encoded_pars, (self.n_model_inputs * self.n_samples, ))
],
axis=0)
def write_problem(
test_id: int,
parameter_df: pd.DataFrame,
condition_dfs: Union[List[pd.DataFrame], pd.DataFrame],
observable_dfs: Union[List[pd.DataFrame], pd.DataFrame],
measurement_dfs: Union[List[pd.DataFrame], pd.DataFrame],
sbml_files: Union[List[str], str] = None,
) -> None:
"""Write problem to files.
Parameters
----------
test_id: Identifier of the test.
parameter_df: PEtab parameter table.
condition_dfs: PEtab condition tables.
observable_dfs: PEtab observable tables.
measurement_dfs: PEtab measurement tables.
sbml_files: PEtab SBML files. If None, then the default
petabtests.DEFAULT_MODEL_FILE is used.
"""
print(f"Writing case {test_id}...")
# convenience
if isinstance(condition_dfs, pd.DataFrame):
condition_dfs = [condition_dfs]
if isinstance(observable_dfs, pd.DataFrame):
observable_dfs = [observable_dfs]
if isinstance(measurement_dfs, pd.DataFrame):
measurement_dfs = [measurement_dfs]
if isinstance(sbml_files, str):
sbml_files = [sbml_files]
# id to string
id_str = test_id_str(test_id)
dir_ = os.path.join(CASES_DIR, id_str)
# petab yaml
config = {
FORMAT_VERSION:
petab.__format_version__,
PROBLEMS: [
{
SBML_FILES: [],
CONDITION_FILES: [],
MEASUREMENT_FILES: [],
OBSERVABLE_FILES: [],
},
]
}
# copy models
if sbml_files is None:
sbml_files = [DEFAULT_MODEL_FILE]
copied_sbml_files = []
for i_sbml, sbml_file in enumerate(sbml_files):
if len(sbml_files) == 1:
copied_sbml_file = '_model.xml'
else:
copied_sbml_file = f'_model{i_sbml}.xml'
copyfile(os.path.join(dir_, sbml_file),
os.path.join(dir_, copied_sbml_file))
copied_sbml_files.append(copied_sbml_file)
config[PROBLEMS][0][SBML_FILES] = copied_sbml_files
# write parameters
parameters_file = '_parameters.tsv'
petab.write_parameter_df(parameter_df, os.path.join(dir_, parameters_file))
config[PARAMETER_FILE] = parameters_file
# write conditions
_write_dfs_to_files(id_str, 'conditions', petab.write_condition_df,
condition_dfs, config[PROBLEMS][0][CONDITION_FILES])
# write observables
_write_dfs_to_files(id_str, 'observables', petab.write_observable_df,
observable_dfs, config[PROBLEMS][0][OBSERVABLE_FILES])
# write measurements
_write_dfs_to_files(id_str, 'measurements', petab.write_measurement_df,
measurement_dfs,
config[PROBLEMS][0][MEASUREMENT_FILES])
# validate petab yaml
petab.validate(config, path_prefix=dir_)
# write yaml
yaml_file = problem_yaml_name(test_id)
with open(os.path.join(dir_, yaml_file), 'w') as outfile:
yaml.dump(config, outfile, default_flow_style=False)
# validate written PEtab files
problem = petab.Problem.from_yaml(os.path.join(dir_, yaml_file))
petab.lint_problem(problem)
def test_flatten_timepoint_specific_output_overrides():
"""Test flatten_timepoint_specific_output_overrides"""
observable_df = pd.DataFrame(data={
OBSERVABLE_ID: ['obs1'],
OBSERVABLE_FORMULA: [
'observableParameter1_obs1 + observableParameter2_obs1'],
NOISE_FORMULA: ['noiseParameter1_obs1']
})
observable_df.set_index(OBSERVABLE_ID, inplace=True)
observable_df_expected = pd.DataFrame(data={
OBSERVABLE_ID: ['obs1_1', 'obs1_2', 'obs1_3'],
OBSERVABLE_FORMULA: [
'observableParameter1_obs1_1 + observableParameter2_obs1_1',
'observableParameter1_obs1_2 + observableParameter2_obs1_2',
'observableParameter1_obs1_3 + observableParameter2_obs1_3'],
NOISE_FORMULA: ['noiseParameter1_obs1_1',
'noiseParameter1_obs1_2',
'noiseParameter1_obs1_3']
})
observable_df_expected.set_index(OBSERVABLE_ID, inplace=True)
# Measurement table with timepoint-specific overrides
measurement_df = pd.DataFrame(data={
OBSERVABLE_ID:
['obs1', 'obs1', 'obs1', 'obs1'],
SIMULATION_CONDITION_ID:
['condition1', 'condition1', 'condition1', 'condition1'],
PREEQUILIBRATION_CONDITION_ID:
['', '', '', ''],
TIME:
[1.0, 1.0, 2.0, 2.0],
MEASUREMENT:
[np.nan] * 4,
OBSERVABLE_PARAMETERS:
['obsParOverride1;1.0', 'obsParOverride2;1.0',
'obsParOverride2;1.0', 'obsParOverride2;1.0'],
NOISE_PARAMETERS:
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2']
})
measurement_df_expected = pd.DataFrame(data={
OBSERVABLE_ID:
['obs1_1', 'obs1_2', 'obs1_3', 'obs1_3'],
SIMULATION_CONDITION_ID:
['condition1', 'condition1', 'condition1', 'condition1'],
PREEQUILIBRATION_CONDITION_ID:
['', '', '', ''],
TIME:
[1.0, 1.0, 2.0, 2.0],
MEASUREMENT:
[np.nan] * 4,
OBSERVABLE_PARAMETERS:
['obsParOverride1;1.0', 'obsParOverride2;1.0',
'obsParOverride2;1.0', 'obsParOverride2;1.0'],
NOISE_PARAMETERS:
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2']
})
problem = petab.Problem(measurement_df=measurement_df,
observable_df=observable_df)
assert petab.lint_problem(problem) is False
# Ensure having timepoint-specific overrides
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
measurement_df) is True
petab.flatten_timepoint_specific_output_overrides(problem)
# Timepoint-specific overrides should be gone now
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
problem.measurement_df) is False
assert problem.observable_df.equals(observable_df_expected) is True
assert problem.measurement_df.equals(measurement_df_expected) is True
assert petab.lint_problem(problem) is False
def test_flatten_timepoint_specific_output_overrides(minimal_sbml_model):
document, model = minimal_sbml_model
petab.sbml.add_global_parameter(
sbml_model=model, parameter_id='observableParameter1_obs1')
petab.sbml.add_model_output_with_sigma(
sbml_model=model, observable_id='obs1',
observable_formula='observableParameter1_obs1')
# Measurement table with timepoint-specific overrides
measurement_df = pd.DataFrame(data={
'observableId':
['obs1', 'obs1', 'obs1', 'obs1'],
'simulationConditionId':
['condition1', 'condition1', 'condition1', 'condition1'],
'preequilibrationConditionId':
['', '', '', ''],
'time':
[1.0, 1.0, 2.0, 2.0],
'measurement':
[np.nan] * 4,
'observableParameters':
['obsParOverride1', 'obsParOverride2',
'obsParOverride2', 'obsParOverride2'],
'noiseParameters':
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2']
})
measurement_df_expected = pd.DataFrame(data={
'observableId':
['obs1_1', 'obs1_2', 'obs1_3', 'obs1_3'],
'simulationConditionId':
['condition1', 'condition1', 'condition1', 'condition1'],
'preequilibrationConditionId':
['', '', '', ''],
'time':
[1.0, 1.0, 2.0, 2.0],
'measurement':
[np.nan] * 4,
'observableParameters':
['obsParOverride1', 'obsParOverride2',
'obsParOverride2', 'obsParOverride2'],
'noiseParameters':
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2']
})
problem = petab.Problem(sbml_model=model,
measurement_df=measurement_df)
assert petab.lint_problem(problem) is False
# Ensure having timepoint-specific overrides
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
measurement_df) is True
petab.flatten_timepoint_specific_output_overrides(problem)
# Timepoint-specific overrides should be gone now
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
problem.measurement_df) is False
assert problem.measurement_df.equals(measurement_df_expected) is True
assert petab.lint_problem(problem) is False
def main():
args = parse_cli_args()
script_path = os.path.split(os.path.abspath(__file__))[0]
model_name = 'model_steadystate_scaled'
sbml_file_name = "model_steadystate_scaled.sbml"
measurement_file_name = 'example_data.tsv'
condition_file_name = 'example_data_fixed.tsv'
parameter_file_name = 'example_data_parameter.tsv'
observable_file_name = 'model_steasystate_observables.tsv'
yaml_file_name = 'model_steasystate.yaml'
yaml_file_name_test = 'model_steasystate_test.yaml'
print(f'{__file__} running in {os.getcwd()}')
print(f'Processing model {sbml_file_name}')
# Create sbml model from scratch
cmd = f'bash -c "{script_path}/createSteadystateExampleSBML.py '\
f'> {sbml_file_name}"'
print(cmd)
out = subprocess.check_output(cmd, shell=True)
print(out.decode('utf-8'))
print()
print_model_info(sbml_file_name)
print()
# create condition table
condition_df = pd.DataFrame(
data={
ptc.CONDITION_ID:
["condition_0", "condition_1", "condition_2", "condition_3"],
"k0": [1, 1.1, 1.2, 1.3]
})
condition_df.set_index([ptc.CONDITION_ID], inplace=True)
# create observables
observable_df = pd.DataFrame(
data={
ptc.OBSERVABLE_ID: [
"obs_x1", "obs_x2", "obs_x3", "obs_x1_scaled",
"obs_x2_offsetted", "obs_x1withsigma"
],
ptc.OBSERVABLE_FORMULA: [
"x1", "x2", "x3", "observableParameter1_obs_x1_scaled * x1",
"observableParameter1_obs_x2_offsetted + x2", "x1"
],
ptc.NOISE_FORMULA: [
"noiseParameter1_obs_x1", "noiseParameter1_obs_x2",
"noiseParameter1_obs_x3", "noiseParameter1_obs_x1_scaled",
"noiseParameter1_obs_x2_offsetted",
"noiseParameter1_obs_x1withsigma"
],
})
observable_df.set_index([ptc.OBSERVABLE_ID], inplace=True)
create_module(sbml_model_file=sbml_file_name,
model_name=model_name,
model_output_dir=args.model_output_dir,
observable_df=observable_df,
condition_df=condition_df)
# load model
sys.path.insert(0, args.model_output_dir)
model_module = importlib.import_module(model_name)
print()
print("--- Creating data ---")
measurement_df, true_parameters, expected_llh = create_data_tables(
model=model_module.getModel(), condition_df=condition_df)
# assemble PEtab problem
pp = petab.Problem.from_files(sbml_file=sbml_file_name)
pp.observable_df = observable_df
pp.measurement_df = measurement_df
pp.condition_df = condition_df
create_parameter_table(problem=pp, nominal_parameters=true_parameters)
# check for valid PEtab
petab.lint_problem(pp)
# Save remaining tables
pp.to_files(measurement_file=measurement_file_name,
condition_file=condition_file_name,
observable_file=observable_file_name,
parameter_file=parameter_file_name)
# Create PEtab yaml file
config = {
'format_version':
petab.__format_version__,
'parameter_file':
parameter_file_name,
'problems': [
{
ptc.SBML_FILES: [sbml_file_name],
ptc.CONDITION_FILES: [condition_file_name],
ptc.MEASUREMENT_FILES: [measurement_file_name],
ptc.OBSERVABLE_FILES: [observable_file_name],
},
]
}
petab.validate(config) #, path_prefix=model_dir)
with open(yaml_file_name, 'w') as outfile:
yaml.dump(config, outfile, default_flow_style=False)
# create training data
generate_hdf5_file(yaml_file=yaml_file_name,
model_output_dir=args.model_output_dir,
hdf5_file_name=args.hdf5_file_name,
model_name=model_name)
create_test_data(measurement_file_name, parameter_file_name, config,
yaml_file_name_test, args.model_output_dir, model_name,
args.hdf5_file_name)
save_expected_results(args.hdf5_file_name, true_parameters, expected_llh)
write_starting_points(args.hdf5_file_name, true_parameters)
PARAMETER_ID: ['k1', 'k2'],
PARAMETER_SCALE: [LOG] * 2,
LOWER_BOUND: [1e-5] * 2,
UPPER_BOUND: [1e5] * 2,
NOMINAL_VALUE: [k1, k2],
ESTIMATE: [1, 1],
}).set_index(PARAMETER_ID)
petab.write_condition_df(condition_df, "conditions.tsv")
petab.write_measurement_df(measurement_df, "measurements.tsv")
petab.write_observable_df(observable_df, "observables.tsv")
petab.write_parameter_df(parameter_df, "parameters.tsv")
yaml_config = {
FORMAT_VERSION:
1,
PARAMETER_FILE:
"parameters.tsv",
PROBLEMS: [{
SBML_FILES: ["model_conversion_reaction.xml"],
CONDITION_FILES: ["conditions.tsv"],
MEASUREMENT_FILES: ["measurements.tsv"],
OBSERVABLE_FILES: ["observables.tsv"]
}]
}
petab.write_yaml(yaml_config, "conversion_reaction.yaml")
# validate written PEtab files
problem = petab.Problem.from_yaml("conversion_reaction.yaml")
petab.lint_problem(problem)
def write_problem(test_id: int,
parameter_df: pd.DataFrame,
condition_dfs: Union[List[pd.DataFrame], pd.DataFrame],
observable_dfs: Union[List[pd.DataFrame], pd.DataFrame],
measurement_dfs: Union[List[pd.DataFrame], pd.DataFrame],
model_files: Union[List[str], str],
format_: str = 'sbml') -> None:
"""Write problem to files.
Parameters
----------
test_id: Identifier of the test.
parameter_df: PEtab parameter table.
condition_dfs: PEtab condition tables.
observable_dfs: PEtab observable tables.
measurement_dfs: PEtab measurement tables.
model_files: PEtab SBML/PySB files.
format: Model format (SBML/PySB)
"""
print(f"Writing case {test_id} {format_} ...")
# convenience
if isinstance(condition_dfs, pd.DataFrame):
condition_dfs = [condition_dfs]
if isinstance(observable_dfs, pd.DataFrame):
observable_dfs = [observable_dfs]
if isinstance(measurement_dfs, pd.DataFrame):
measurement_dfs = [measurement_dfs]
if isinstance(model_files, str):
model_files = [model_files]
# id to string
dir_ = case_dir(test_id, format_)
# petab yaml
config = {
FORMAT_VERSION:
petab.__format_version__,
PROBLEMS: [
{
SBML_FILES: [],
CONDITION_FILES: [],
MEASUREMENT_FILES: [],
OBSERVABLE_FILES: [],
},
]
}
if format_ == 'sbml':
suffix = '.xml'
else:
suffix = '.py'
# copy models
copied_model_files = []
for i_sbml, model_file in enumerate(model_files):
if len(model_files) == 1:
copied_model_file = f'_model{suffix}'
else:
copied_model_file = f'_model{i_sbml}{suffix}'
copyfile(os.path.join(dir_, model_file),
os.path.join(dir_, copied_model_file))
copied_model_files.append(copied_model_file)
config[PROBLEMS][0][SBML_FILES] = copied_model_files
# write parameters
parameters_file = '_parameters.tsv'
petab.write_parameter_df(parameter_df, os.path.join(dir_, parameters_file))
config[PARAMETER_FILE] = parameters_file
# write conditions
_write_dfs_to_files(dir_, 'conditions', petab.write_condition_df,
condition_dfs, config[PROBLEMS][0][CONDITION_FILES])
# write observables
_write_dfs_to_files(dir_, 'observables', petab.write_observable_df,
observable_dfs, config[PROBLEMS][0][OBSERVABLE_FILES])
# write measurements
_write_dfs_to_files(dir_, 'measurements', petab.write_measurement_df,
measurement_dfs,
config[PROBLEMS][0][MEASUREMENT_FILES])
# validate petab yaml
petab.validate(config, path_prefix=dir_)
# write yaml
yaml_file = problem_yaml_name(test_id)
with open(os.path.join(dir_, yaml_file), 'w') as outfile:
yaml.dump(config, outfile, default_flow_style=False)
# validate written PEtab files
problem = petab.Problem.from_yaml(os.path.join(dir_, yaml_file))
petab.lint_problem(problem)
def main():
arg = sys.argv[1]
if arg == 'compilation':
git_dir = os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT')
if not os.path.exists(git_dir):
subprocess.run([
'git', 'clone', '--depth', '1',
'https://github.com/ICB-DCM/CS_Signalling_ERBB_RAS_AKT'
])
os.chdir(os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT'))
pp = petab.Problem.from_yaml(
'FroehlichKes2018/PEtab/FroehlichKes2018.yaml')
petab.lint_problem(pp)
os.chdir(os.path.dirname(os.path.abspath(os.curdir)))
import_model(model_name='CS_Signalling_ERBB_RAS_AKT_petab',
sbml_model=pp.sbml_model,
condition_table=pp.condition_df,
observable_table=pp.observable_df,
measurement_table=pp.measurement_df,
compile=False,
verbose=True)
os.chdir(os.path.join(os.curdir, 'CS_Signalling_ERBB_RAS_AKT_petab'))
subprocess.run(['python', 'setup.py', 'install'])
return
else:
import CS_Signalling_ERBB_RAS_AKT_petab as model_module
model = model_module.getModel()
solver = model.getSolver()
# TODO
edata = amici.ExpData(model)
edata.setTimepoints([1e8])
edata.setObservedData([1.0])
edata.setObservedDataStdDev([1.0])
if arg == 'forward_simulation':
solver.setSensitivityMethod(amici.SensitivityMethod.none)
solver.setSensitivityOrder(amici.SensitivityOrder.none)
elif arg == 'forward_sensitivities':
model.setParameterList(list(range(100)))
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'adjoint_sensitivities':
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'forward_simulation_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.none)
solver.setSensitivityOrder(amici.SensitivityOrder.none)
elif arg == 'adjoint_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
elif arg == 'forward_steadystate_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.forward)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
edata.setTimepoints([float('inf')])
elif arg == 'adjoint_steadystate_sensitivities_non_optimal_parameters':
tmpPar = model.getParameters()
model.setParameters([0.1 for _ in tmpPar])
solver.setSensitivityMethod(amici.SensitivityMethod.adjoint)
solver.setSensitivityOrder(amici.SensitivityOrder.first)
edata.setTimepoints([float('inf')])
else:
print("Unknown argument:", arg)
sys.exit(1)
rdata = amici.runAmiciSimulation(model, solver, edata)
diagnostics = [
'numsteps', 'numstepsB', 'numrhsevals', 'numrhsevalsB',
'numerrtestfails', 'numerrtestfailsB', 'numnonlinsolvconvfails',
'numnonlinsolvconvfailsB', 'preeq_cpu_time', 'preeq_cpu_timeB',
'cpu_time', 'cpu_timeB', 'posteq_cpu_time', 'posteq_cpu_timeB'
]
for d in diagnostics:
print(d, rdata[d])
assert rdata['status'] == amici.AMICI_SUCCESS
def test_flatten_timepoint_specific_output_overrides_special_cases():
"""Test flatten_timepoint_specific_output_overrides
for special cases:
* no preequilibration
* no observable parameters
"""
observable_df = pd.DataFrame(data={
OBSERVABLE_ID: ['obs1'],
OBSERVABLE_FORMULA: ['species1'],
NOISE_FORMULA: ['noiseParameter1_obs1']
})
observable_df.set_index(OBSERVABLE_ID, inplace=True)
observable_df_expected = pd.DataFrame(data={
OBSERVABLE_ID: ['obs1__noiseParOverride1__condition1',
'obs1__noiseParOverride2__condition1'],
OBSERVABLE_FORMULA: [
'species1',
'species1'],
NOISE_FORMULA: ['noiseParameter1_obs1__noiseParOverride1__condition1',
'noiseParameter1_obs1__noiseParOverride2__condition1']
})
observable_df_expected.set_index(OBSERVABLE_ID, inplace=True)
# Measurement table with timepoint-specific overrides
measurement_df = pd.DataFrame(data={
OBSERVABLE_ID:
['obs1', 'obs1', 'obs1', 'obs1'],
SIMULATION_CONDITION_ID:
['condition1', 'condition1', 'condition1', 'condition1'],
TIME:
[1.0, 1.0, 2.0, 2.0],
MEASUREMENT:
[.1] * 4,
NOISE_PARAMETERS:
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2'],
})
measurement_df_expected = pd.DataFrame(data={
OBSERVABLE_ID:
['obs1__noiseParOverride1__condition1',
'obs1__noiseParOverride1__condition1',
'obs1__noiseParOverride2__condition1',
'obs1__noiseParOverride2__condition1'],
SIMULATION_CONDITION_ID:
['condition1', 'condition1', 'condition1', 'condition1'],
TIME:
[1.0, 1.0, 2.0, 2.0],
MEASUREMENT:
[.1] * 4,
NOISE_PARAMETERS:
['noiseParOverride1', 'noiseParOverride1',
'noiseParOverride2', 'noiseParOverride2'],
})
problem = petab.Problem(measurement_df=measurement_df,
observable_df=observable_df)
assert petab.lint_problem(problem) is False
# Ensure having timepoint-specific overrides
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
measurement_df) is True
petab.flatten_timepoint_specific_output_overrides(problem)
# Timepoint-specific overrides should be gone now
assert petab.lint.measurement_table_has_timepoint_specific_mappings(
problem.measurement_df) is False
assert problem.observable_df.equals(observable_df_expected) is True
assert problem.measurement_df.equals(measurement_df_expected) is True
assert petab.lint_problem(problem) is False
