def plotQuantity(self, identifier, param_values, n, bars=True):
''' Plot a simulated quantity vs its data points using Tellurium.'''
i = self.measured_quantities.index(identifier)
reference_quantity = self.reference_quantities[:, i]
r = RoadRunner(self.sbml)
if param_values is not None:
self._setParameterVector(param_values, self.param_list, r)
s = r.simulate(0, float(self.reference_time[-1]), n,
['time', identifier])
simulated_quantity = s[:, 1]
residuals = simulated_quantity - reference_quantity
# relative residuals
# print('avg relative deviation for ', identifier, ': {:.1f}'.format(mean(abs(residuals/reference_quantity))*100.), '%')
# residuals normalized to overall mean
print(
'avg relative deviation for ', identifier, ': {:.1f}'.format(
mean(abs(residuals)) / mean(abs(reference_quantity)) * 100.),
'%')
r.reset()
s = r.simulate(0, float(self.reference_time[-1]), 1000,
['time', identifier])
import tellurium as te
te.plot(self.reference_time,
reference_quantity,
scatter=True,
name=identifier + ' data',
show=False,
error_y_pos=maximum(residuals, 0),
error_y_neg=-minimum(residuals, 0))
te.plot(s[:, 0], s[:, 1], name=identifier + ' sim')
def plotQuantity(self, quantity, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import name_to_id_map, conc_indices
quantity_id = name_to_id_map[quantity]
iq = self.measured_quantities.index(quantity_id)
reference_data = array(self.scaled_data[:, iq])
r = RoadRunner(self.sbml)
self._setParameterVector(param_values, self.param_list, r)
r.reset()
t_now = 0.
residuals = zeros((len(self.time_values), ))
residuals[0] = r[quantity_id] - reference_data[0]
for it_next in range(1, len(self.time_values)):
self._setParameterVector(param_values, self.param_list, r)
r.simulate(t_now, self.time_values[it_next], 100)
t_now = self.time_values[it_next]
residuals[it_next] = r[quantity_id] - reference_data[it_next]
r.reset()
s = r.simulate(0, float(self.time_values[-1]), 1000,
['time', quantity_id])
# print(quantity, sqrt(mean(residuals**2))/self.reference_value_means[iq])
import tellurium as te
te.plot(self.time_values,
reference_data,
scatter=True,
name=quantity + ' data',
show=False,
error_y_pos=maximum(residuals, 0),
error_y_neg=-minimum(residuals, 0))
te.plot(s[:, 0], s[:, 1], name=quantity + ' sim')
def plotQuantity(self, quantity_id, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import measured_quantity_ids, measured_quantity_id_to_name_map
from data import t1, t2, time_end, n1, n2, n3
quantity_name = measured_quantity_id_to_name_map.get(quantity_id,quantity_id)
iq = measured_quantity_ids.index(quantity_id)
reference_data = array(self.reference_values[:,iq])
r = RoadRunner(self.sbml)
r.reset()
r.resetAll()
r.resetToOrigin()
self._setParameterVector(param_values, self.param_list, r)
# r.oneStep(0., 10)
# print('plotQuantity OAA\' = {}'.format(r["OAA'"]))
s1 = r.simulate(0., t1, n1, ['time', quantity_id])
s2 = r.simulate(t1, t2, n2, ['time', quantity_id])
# print(quantity_id)
# if quantity_id == 'GLC':
# print('BM before {}'.format(r['[BM]']))
# print(iq)
# print(reference_data)
s3 = r.simulate(t2, time_end, n3, ['time', quantity_id])
sim = vstack((
s1,
s2,
s3,
))
assert sim.shape[0] == reference_data.shape[0]
residuals = sim[:,1] - reference_data
r.reset()
r.resetAll()
r.resetToOrigin()
self._setParameterVector(param_values, self.param_list, r)
# self._setParameterVector(param_values, self.param_list, r)
s = r.simulate(0,time_end,1000,['time',quantity_id])
import tellurium as te
te.plot(sim[:,0], reference_data, scatter=True,
name=quantity_name+' data', show=False,
title=quantity_name,
error_y_pos=maximum(residuals,0),
error_y_neg=-minimum(residuals,0))
te.plot(s[:,0], s[:,1], name=quantity_name+' sim')
def plotQuantity(self, quantity_id, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import time_values, measured_quantity_ids, measured_quantity_id_to_name_map
quantity_name = measured_quantity_id_to_name_map[quantity_id]
iq = measured_quantity_ids.index(quantity_id)
reference_data = array(self.reference_values[:, iq])
r = RoadRunner(self.sbml)
self._setParameterVector(param_values, self.param_list, r)
r.reset()
# r.resetAll()
# r.resetToOrigin()
# r.integrator = 'euler'
# r.integrator = 'rk4'
# r.integrator.subdivision_steps = 1000
# r.integrator.absolute_tolerance = 1e-10
# r.integrator.relative_tolerance = 1e-4
# r.integrator.initial_time_step = 0.001
# r.integrator.minimum_time_step = 0.0001
# r.integrator.maximum_time_step = 0.1
# print(r.integrator)
sim = r.simulate(0., 119., 120, ['time', quantity_id])
assert sim.shape[0] == reference_data.shape[0]
residuals = sim[:, 1] - reference_data
r.reset()
# r.resetAll()
# r.resetToOrigin()
s = r.simulate(0, float(time_values[-1]), 121, ['time', quantity_id])
# print('mse for {}: '.format(quantity_name), sqrt(mean((residuals**2)/(self.reference_norms[:,iq]**2))))
import tellurium as te
te.plot(time_values,
reference_data,
scatter=True,
name=quantity_name + ' data',
show=False,
title=quantity_name,
error_y_pos=maximum(residuals, 0),
error_y_neg=-minimum(residuals, 0))
te.plot(s[:, 0], s[:, 1], name=quantity_name + ' sim')
import numpy as np
from roadrunner import RoadRunner
from timeit import default_timer
r = RoadRunner('WolfGlycolysis.xml')
#orders = 5
#for multiplier in np.logspace(0,orders,orders+1):
##print('multiplier = {}'.format(multiplier))
#t1 = default_timer()
#r.reset()
#r.simulate(0,2*int(multiplier),1000*int(multiplier))
#t2 = default_timer()
#print('{} simulation, duration = {}'.format(2*int(multiplier), t2-t1))
##r.plot()
# COPASI 4:20
t1 = default_timer()
r.reset()
r.simulate(0,20000,200000)
t2 = default_timer()
class B3Problem(TimecourseSimBiopredyn):
''' Class that performs a timecourse simulation
and evaluates the objective function for b1.'''
def __init__(self, sbml):
self.sbml = sbml
self.r = RoadRunner(sbml)
from data import measured_quantity_ids, exp_data
self.measured_quantity_ids = measured_quantity_ids
self.reference_values = exp_data
self.reference_value_means_squared = mean(self.reference_values, axis=0)**2
from params import new_param_ids as param_ids
self.param_list = param_ids
self.penalty_scale = 1.
def evaluate(self, x):
# type: (array) -> SupportsFloat
"""
Evaluate and return the objective function.
"""
from interruptingcow import timeout
# from data import time_end, n_points
from data import t1, t2, time_end, n1, n2, n3
self.reset()
self.r.resetAll()
self.r.resetToOrigin()
self.setParameterVector(x)
self.r.reset()
def worker():
# sim = array(self.r.simulate(0., time_end, n_points, self.measured_quantity_ids))
s1 = self.r.simulate(0., t1, n1, self.measured_quantity_ids)
s2 = self.r.simulate(t1, t2, n2, self.measured_quantity_ids)
s3 = self.r.simulate(t2, time_end, n3, self.measured_quantity_ids)
sim = vstack((
s1,
s2,
s3,
))
residuals = sim-self.reference_values
normalized_mse_per_quantity = mean(residuals**2,axis=0)/self.reference_value_means_squared
# from pprint import pprint
# print('residuals:')
# pprint({id: value for id,value in zip(self.measured_quantity_ids, sqrt(normalized_mse_per_quantity))})
return sqrt(mean(normalized_mse_per_quantity))
try:
with timeout(10, StalledSimulation):
return worker()
except (RuntimeError, StalledSimulation):
# if convergence fails, use a penalty score
return 1e9*self.penalty_scale
def plotQuantity(self, quantity_id, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import measured_quantity_ids, measured_quantity_id_to_name_map
from data import t1, t2, time_end, n1, n2, n3
quantity_name = measured_quantity_id_to_name_map.get(quantity_id,quantity_id)
iq = measured_quantity_ids.index(quantity_id)
reference_data = array(self.reference_values[:,iq])
r = RoadRunner(self.sbml)
r.reset()
r.resetAll()
r.resetToOrigin()
self._setParameterVector(param_values, self.param_list, r)
# r.oneStep(0., 10)
# print('plotQuantity OAA\' = {}'.format(r["OAA'"]))
s1 = r.simulate(0., t1, n1, ['time', quantity_id])
s2 = r.simulate(t1, t2, n2, ['time', quantity_id])
# print(quantity_id)
# if quantity_id == 'GLC':
# print('BM before {}'.format(r['[BM]']))
# print(iq)
# print(reference_data)
s3 = r.simulate(t2, time_end, n3, ['time', quantity_id])
sim = vstack((
s1,
s2,
s3,
))
assert sim.shape[0] == reference_data.shape[0]
residuals = sim[:,1] - reference_data
r.reset()
r.resetAll()
r.resetToOrigin()
self._setParameterVector(param_values, self.param_list, r)
# self._setParameterVector(param_values, self.param_list, r)
s = r.simulate(0,time_end,1000,['time',quantity_id])
import tellurium as te
te.plot(sim[:,0], reference_data, scatter=True,
name=quantity_name+' data', show=False,
title=quantity_name,
error_y_pos=maximum(residuals,0),
error_y_neg=-minimum(residuals,0))
te.plot(s[:,0], s[:,1], name=quantity_name+' sim')
# print('deviation for {}: {}/{} = {}'.format(quantity_id, sqrt(mean(residuals**2)), sqrt(self.reference_value_means_squared[iq]), sqrt(mean(residuals**2)/self.reference_value_means_squared[iq])))
def getParameterValue(self,param_index):
from params import param_index_to_name_map
try:
return self.r[param_index_to_name_map[param_index]]
except KeyError:
raise KeyError('No such parameter for index {}, must be 0-1758 inclusive'.format(param_index))
class B4Problem(TimecourseSimBiopredyn):
''' Class that performs a timecourse simulation
and calculates the residuals for b4.'''
def __init__(self, sbml):
'''
Constructor.
:param measured_quantities: A list of the measured quantities.
:param scaled_data: The scaled reference data.
:param scaled_error: The scaled reference error.
'''
from params import param_ids
from data import time_values, conc_ids, scaled_data, scaled_error
self.sbml = sbml
self.r = RoadRunner(sbml)
self.r.selections = ['time'] + conc_ids
self.time_values = time_values
assert self.time_values[0] == 0.
self.measured_quantities = conc_ids
self.param_list = param_ids
self.reference_values = scaled_data
self.reference_value_means = mean(self.reference_values, axis=0)
self.scaled_data = scaled_data
self.scaled_error = scaled_error
self.penalty_scale = 1.
def evaluate_original(self, x):
# type: (array) -> SupportsFloat
"""
Evaluate the objective function and return the result. Identical to original
biopredynbench evaluation, i.e. divides by scaled error. Difficult to compare
across models.
"""
from interruptingcow import timeout
self.reset()
self.setParameterVector(x)
self.r.reset()
def worker():
t_now = 0.
scaled_residuals = zeros(
(len(self.time_values), len(self.measured_quantities)))
for it_next in range(1, len(self.time_values)):
t_now = self.r.simulate(t_now, self.time_values[it_next], 100)
t_now = self.time_values[it_next]
if self.divergent():
return 1e9 * self.penalty_scale
for iq, q in enumerate(self.measured_quantities):
scaled_residuals[
it_next - 1,
iq] = (self.r[q] - self.scaled_data[it_next - 1, iq]
) / self.scaled_error[it_next - 1, iq]
return sqrt(mean(scaled_residuals**2.))
try:
with timeout(10, StalledSimulation):
return worker()
except (RuntimeError, StalledSimulation):
# if convergence fails, use a penalty score
return 1e9 * self.penalty_scale
def evaluate(self, x):
# type: (array) -> SupportsFloat
"""
Evaluate the objective function and return the result.
"""
from interruptingcow import timeout
self.reset()
self.setParameterVector(x)
self.r.reset()
def worker():
t_now = 0.
scaled_residuals = zeros(
(len(self.time_values), len(self.measured_quantities)))
for it_next in range(0, len(self.time_values)):
for iq, q in enumerate(self.measured_quantities):
scaled_residuals[it_next,
iq] = (self.r[q] -
self.scaled_data[it_next, iq]
) / self.reference_value_means[iq]
if it_next + 1 < len(self.time_values):
self.r.simulate(t_now, self.time_values[it_next + 1], 100)
t_now = self.time_values[it_next + 1]
if self.divergent():
return 1e9 * self.penalty_scale
# print('normalized errors: ', sqrt(mean(scaled_residuals**2, axis=0)))
return sqrt(mean(scaled_residuals**2.))
try:
with timeout(10, StalledSimulation):
return worker()
except (RuntimeError, StalledSimulation):
# if convergence fails, use a penalty score
return 1e9 * self.penalty_scale
def plotQuantity(self, quantity, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import name_to_id_map, conc_indices
quantity_id = name_to_id_map[quantity]
iq = self.measured_quantities.index(quantity_id)
reference_data = array(self.scaled_data[:, iq])
r = RoadRunner(self.sbml)
self._setParameterVector(param_values, self.param_list, r)
r.reset()
t_now = 0.
residuals = zeros((len(self.time_values), ))
residuals[0] = r[quantity_id] - reference_data[0]
for it_next in range(1, len(self.time_values)):
self._setParameterVector(param_values, self.param_list, r)
r.simulate(t_now, self.time_values[it_next], 100)
t_now = self.time_values[it_next]
residuals[it_next] = r[quantity_id] - reference_data[it_next]
r.reset()
s = r.simulate(0, float(self.time_values[-1]), 1000,
['time', quantity_id])
# print(quantity, sqrt(mean(residuals**2))/self.reference_value_means[iq])
import tellurium as te
te.plot(self.time_values,
reference_data,
scatter=True,
name=quantity + ' data',
show=False,
error_y_pos=maximum(residuals, 0),
error_y_neg=-minimum(residuals, 0))
te.plot(s[:, 0], s[:, 1], name=quantity + ' sim')
def test_delayed_choice(self):
inpil = """
length a = 5
length b = 15
length c = 15
length d = 15
length e = 15
length z = 15
RC1 = d( e( z ) ) b*( a* + ) c( + ) d @i 1e-8 M
RC1b = d e( z ) d*( b*( a* + ) c( + ) ) @i 1e-8 M
R0 = a b c @i 1e-7 M
R21 = b c( + ) d @i 0 M
R22 = d( e( z ) ) b*( a*( + ) ) c @i 0 M
R31 = b c @i 0 M
RC32b = d e( z ) d*( b*( a*( + ) ) c( + ) ) @i 0 M
RC32 = d( e( z ) ) b*( a*( + ) ) c( + ) d @i 0 M
TC1 = a( b c + b( c( + ) d + d( e( z ) ) ) ) @i 0 M
TC2 = a( b c + b( c( + ) d( + d e( z ) ) ) ) @i 0 M
TC3 = a( b( c + b c( + ) d( + d e( z ) ) ) ) @i 0 M
"""
enum, out = enumerate_pil(inpil, is_file=False, condensed=True)
xml = write_sbml(enum, condensed=True)
rr = RoadRunner()
rr.load(xml)
ExecutableModel = rr.model
RC32 = 'RC32' if 'RC32' in rr.model.getFloatingSpeciesIds(
) else 'RC32b'
RC1 = 'RC1' if 'RC1' in rr.model.getFloatingSpeciesIds() else 'RC1b'
# Compartment
assert ExecutableModel.getCompartmentVolumes() == 1.
assert ExecutableModel.getNumCompartments() == 1
assert ExecutableModel.getCompartmentIds() == ['TestTube']
# Species
speciesIDs = ['R0', RC32, 'R22', 'R31', 'R21', RC1]
ini_spIDs = sorted('init({})'.format(x) for x in speciesIDs)
concIDs = [
'[R0]', '[' + RC32 + ']', '[R22]', '[R31]', '[R21]',
'[' + RC1 + ']'
]
ini_coIDs = sorted('init({})'.format(x) for x in concIDs)
assert ExecutableModel.getNumFloatingSpecies() == len(speciesIDs)
assert sorted(
ExecutableModel.getFloatingSpeciesIds()) == sorted(speciesIDs)
assert sorted(
ExecutableModel.getFloatingSpeciesInitAmountIds()) == sorted(
ini_spIDs)
assert sorted(ExecutableModel.getFloatingSpeciesInitConcentrationIds()
) == sorted(ini_coIDs)
#print(sorted(ini_coIDs))
#print(ExecutableModel.getFloatingSpeciesInitAmounts())
#print(ExecutableModel.getFloatingSpeciesInitConcentrations())
# Reactions
rxnIDs = [
'R0_' + RC1 + '__' + RC32 + '_R31', 'R0_' + RC1 + '__R22_R21'
]
assert ExecutableModel.getNumReactions() == len(rxnIDs)
assert sorted(ExecutableModel.getReactionIds()) == sorted(rxnIDs)
assert rr.model[RC32] == 0
assert rr.model[RC1] == 2e-8
# simulate deterministic
rr.model['init([R0])'] = 1e-8
assert rr.model['init(R0)'] == 1e-8
Vol = 1.66e-15
rr.model.setCompartmentVolumes([Vol])
rr.model['init([R0])'] = 1e-8 * Vol
rr.model[f'init({RC1})'] = 2e-8 * Vol
rr.integrator.absolute_tolerance = 1e-12 * Vol
rr.integrator.relative_tolerance = 1e-12 * Vol
rr.integrator.initial_time_step = 0.00001
result = rr.simulate(0, 500, steps=100)
#print(result)
#rr.plot() # look at it if you like!
# NOTE: something is off with the units with stochastic simulations, weird...
#print(rr.model.getCompartmentVolumes())
#print(rr.model.getFloatingSpeciesInitConcentrations())
#print(rr.model.getFloatingSpeciesInitAmounts())
#print(rr.model.getFloatingSpeciesConcentrations())
#print(rr.model.getFloatingSpeciesAmounts())
rr.reset()
class B5Problem(TimecourseSimBiopredyn):
''' Class that performs a timecourse simulation
and evaluates the objective function for b1.'''
def __init__(self, sbml):
self.sbml = sbml
self.r = RoadRunner(sbml)
self.r.integrator.absolute_tolerance = 1e-15
self.r.integrator.relative_tolerance = 1e-9
self.r.integrator.stiff = True
from observables import observables
self.measured_quantity_ids = observables
from json import load
with open(join(dirname(realpath(__file__)), 'exp_data.json')) as f:
self.reference_value_collection = [array(a) for a in load(f)]
self.reference_value_means_squared_collection = []
for a in self.reference_value_collection:
self.reference_value_means_squared_collection.append(
mean(a, axis=0)**2)
with open(join(dirname(realpath(__file__)), 'exp_y0.json')) as f:
self.exp_y0_collection = [array(a) for a in load(f)]
with open(join(dirname(realpath(__file__)), 'stimuli.json')) as f:
self.stimuli_collection = [d for d in load(f)]
from parameters import param_ids
self.param_list = param_ids
self.penalty_scale = 1.
def setExperimentNumber(self, n):
'''
Villaverde et al. use a set of 10 different experiments with respective
different stimuli combinations and expected results.
This method initialized appropriate variables for the given experiment.
'''
self.reference_values = self.reference_value_collection[n]
self.reference_value_means_squared = self.reference_value_means_squared_collection[
n]
self.exp_y0 = self.exp_y0_collection[n]
from species import species
for k, s in enumerate(species):
self.r.setValue('init({})'.format(s), float(self.exp_y0[k]))
self.stimuli = self.stimuli_collection[n]
for s, b in self.stimuli.items():
print('{} = {}'.format(s, b * 1.))
self.r[s] = b * 1.
def evaluate(self, x):
# type: (array) -> SupportsFloat
"""
Evaluate and return the objective function.
"""
from interruptingcow import timeout
for n in range(10):
self.setExperimentNumber(n)
self.reset()
def worker():
self.r.reset()
self.r.resetAll()
self.setParameterVector(x, exponential=False)
sim = self.r.simulate(0., 30., 16, self.measured_quantity_ids)
residuals = sim - self.reference_values
normalized_mse_per_quantity = mean(
residuals**2, axis=0) / self.reference_value_means_squared
return sqrt(mean(normalized_mse_per_quantity))
try:
with timeout(10, StalledSimulation):
return worker()
except (RuntimeError, StalledSimulation):
# if convergence fails, use a penalty score
return 1e9 * self.penalty_scale
def plotQuantity(self, quantity_id, param_values, exp_number):
''' Plot a simulated quantity vs its data points using Tellurium.'''
self.setExperimentNumber(exp_number)
iq = self.measured_quantity_ids.index(quantity_id)
reference_data = array(self.reference_values[:, iq])
# self.r.reset()
# self.r.resetAll()
# # r.resetToOrigin()
# self.setParameterVector(param_values, exponential=False)
# sim = self.r.simulate(0., 30., 16, ['time', quantity_id])
# # print(self.r.getReactionRates())
# assert sim.shape[0] == reference_data.shape[0]
# residuals = sim[:,1] - reference_data
self.r.reset()
self.r.resetAll()
# r.resetToOrigin()
self.setParameterVector(param_values, exponential=False)
s = self.r.simulate(0, 25., 100, ['time', quantity_id])
import tellurium as te
# te.plot(sim[:,0], reference_data, scatter=True,
# name=quantity_id+' data', show=False,
# title=quantity_id,
# error_y_pos=maximum(residuals,0),
# error_y_neg=-minimum(residuals,0))
print(quantity_id + ' sim')
te.plot(s[:, 0], s[:, 1], name=quantity_id + ' sim')
def getParameterValue(self, param_index):
from params import param_index_to_name_map
try:
return self.r[param_index_to_name_map[param_index]]
except KeyError:
raise KeyError(
'No such parameter for index {}, must be 0-1758 inclusive'.
format(param_index))
class B1Problem(TimecourseSimBiopredyn):
''' Class that performs a timecourse simulation
and evaluates the objective function for b1.'''
def __init__(self, sbml):
self.sbml = sbml
self.r = RoadRunner(sbml)
# self.r.integrator = 'rk4'
# print(self.r.integrator)
# self.r.integrator.absolute_tolerance = 1e-10
# self.r.integrator.relative_tolerance = 1e-4
from data import measured_quantity_ids, exp_data, norm_data
self.measured_quantity_ids = measured_quantity_ids
self.reference_values = exp_data
# self.reference_value_means_squared = mean(self.reference_values, axis=0)**2
self.reference_norms = maximum(norm_data, 0.0005)
# self.reference_norms_squared = maximum(norm_data, 0.0005)**2
self.quantity_norms = array([
0.0466906, 0.1666200, 0.1325631, 0.0757189, 0.1266561, 0.11634345,
0.1143341, 0.1104889, 0.2808254, 0.1275417, 0.1163108, 0.26822369,
0.1866278, 0.1555892, 0.4453806, 0.1598696, 0.1222940, 0.14366202,
0.1259413, 0.1473395, 0.1407897, 0.1246730, 0.1153060, 0.12375571,
0.1814630, 0.2199502, 0.1608888, 0.1903940, 0.1242392, 0.11704526,
0.1287076, 0.1319431, 0.1324937, 0.0690382, 0.1316586, 2.15109423,
0.1215476, 0.1414125, 0.1112873, 0.1297432, 0.1288462, 0.1155096,
0.1203922, 0.18807463
])**2
# UDP-D-glucose excluded because it has buggy errors
self.overall_norm = float(
mean(
array([
0.0466906, 0.1666200, 0.1325631, 0.0757189, 0.1266561,
0.11634345, 0.1143341, 0.1104889, 0.2808254, 0.1275417,
0.1163108, 0.26822369, 0.1866278, 0.1555892, 0.4453806,
0.1598696, 0.1222940, 0.14366202, 0.1259413, 0.1473395,
0.1407897, 0.1246730, 0.1153060, 0.12375571, 0.1814630,
0.2199502, 0.1608888, 0.1903940, 0.1242392, 0.11704526,
0.1287076, 0.1319431, 0.1324937, 0.0690382, 0.1316586,
0.1215476, 0.1414125, 0.1112873, 0.1297432, 0.1288462,
0.1155096, 0.1203922, 0.18807463
])))
from params import param_ids
self.param_list = param_ids
self.penalty_scale = 1.
def evaluate(self, x):
# type: (array) -> SupportsFloat
"""
Evaluate and return the objective function.
"""
from interruptingcow import timeout
self.reset()
self.setParameterVector(x)
self.r.reset()
def worker():
# skip the first timepoint
# self.r.simulate(0., 1., 10, self.measured_quantity_ids)
sim = self.r.simulate(0., 119., 120, self.measured_quantity_ids)
# sim = array(sim[0:-1:10,:])
residuals = (sim - self.reference_values) / self.reference_norms
normalized_mse_per_quantity = mean(residuals**2, axis=0)
# print('sqrt(normalized_mse_per_quantity) = ', sqrt(normalized_mse_per_quantity))
# print('normed residuals', normalized_mse_per_quantity/self.quantity_norms)
return float(
sqrt(mean(normalized_mse_per_quantity /
self.quantity_norms))) * self.overall_norm
try:
with timeout(10, StalledSimulation):
return worker()
except (RuntimeError, StalledSimulation):
# if convergence fails, use a penalty score
return 1e9 * self.penalty_scale
def plotQuantity(self, quantity_id, param_values):
''' Plot a simulated quantity vs its data points using Tellurium.'''
from data import time_values, measured_quantity_ids, measured_quantity_id_to_name_map
quantity_name = measured_quantity_id_to_name_map[quantity_id]
iq = measured_quantity_ids.index(quantity_id)
reference_data = array(self.reference_values[:, iq])
r = RoadRunner(self.sbml)
self._setParameterVector(param_values, self.param_list, r)
r.reset()
# r.resetAll()
# r.resetToOrigin()
# r.integrator = 'euler'
# r.integrator = 'rk4'
# r.integrator.subdivision_steps = 1000
# r.integrator.absolute_tolerance = 1e-10
# r.integrator.relative_tolerance = 1e-4
# r.integrator.initial_time_step = 0.001
# r.integrator.minimum_time_step = 0.0001
# r.integrator.maximum_time_step = 0.1
# print(r.integrator)
sim = r.simulate(0., 119., 120, ['time', quantity_id])
assert sim.shape[0] == reference_data.shape[0]
residuals = sim[:, 1] - reference_data
r.reset()
# r.resetAll()
# r.resetToOrigin()
s = r.simulate(0, float(time_values[-1]), 121, ['time', quantity_id])
# print('mse for {}: '.format(quantity_name), sqrt(mean((residuals**2)/(self.reference_norms[:,iq]**2))))
import tellurium as te
te.plot(time_values,
reference_data,
scatter=True,
name=quantity_name + ' data',
show=False,
title=quantity_name,
error_y_pos=maximum(residuals, 0),
error_y_neg=-minimum(residuals, 0))
te.plot(s[:, 0], s[:, 1], name=quantity_name + ' sim')
def getParameterValue(self, param_index):
from params import param_index_to_name_map
try:
return self.r[param_index_to_name_map[param_index]]
except KeyError:
raise KeyError(
'No such parameter for index {}, must be 0-1758 inclusive'.
format(param_index))
def getCurrentValues_matlab(self):
# identical to matlab version
return array([
self.r.s_0075,
self.r.s_0180,
self.r.s_0188,
self.r.s_0259,
self.r.s_0260,
self.r.s_0359,
self.r.s_0362,
self.r.s_0394,
self.r.s_0409,
self.r.s_0423,
self.r.s_0434,
self.r.s_0555,
self.r.s_0557,
self.r.s_0563,
self.r.s_0567,
self.r.s_0568,
self.r.s_0586,
self.r.s_0629,
self.r.s_0680,
self.r.s_0765,
self.r.s_0764,
self.r.s_0767,
self.r.s_0785,
self.r.s_0849,
self.r.s_0955,
self.r.s_0991,
self.r.s_1003,
self.r.s_1039,
self.r.s_1045,
self.r.s_1198,
self.r.s_1203,
self.r.s_1360,
self.r.s_1399,
self.r.s_1520,
self.r.s_1538,
self.r.s_1543,
self.r.s_1559,
self.r.s_1565,
self.getParameterValue(1613) * (self.r.s_0565 - self.r.s_0563) /
self.getParameterValue(1614) /
(1 + self.r.s_0565 / self.getParameterValue(1614) + 1 +
self.r.s_0563 / self.getParameterValue(1615) - 1),
self.getParameterValue(1628) * self.r.s_0456 /
self.getParameterValue(1629) /
(1 + self.r.s_0456 / self.getParameterValue(1629)),
self.getParameterValue(1642) * self.r.s_0680 /
self.getParameterValue(1643) /
(1 + self.r.s_0680 / self.getParameterValue(1643)),
self.getParameterValue(1608) * self.r.s_0362 /
self.getParameterValue(1609) /
(1 + self.r.s_0362 / self.getParameterValue(1609)),
self.getParameterValue(1616) * self.r.s_0765 /
self.getParameterValue(1617) /
(1 + self.r.s_0765 / self.getParameterValue(1617)),
self.getParameterValue(1657) * self.r.s_1520 /
self.getParameterValue(1658) /
(1 + self.r.s_1520 / self.getParameterValue(1658)),
])
def getCurrentValues(self):
return array([
self.r.s_0075,
self.r.s_0180,
self.r.s_0188,
self.r.s_0259,
self.r.s_0260,
self.r.s_0359,
self.r.s_0362,
self.r.s_0394,
self.r.s_0409,
self.r.s_0423,
self.r.s_0434,
self.r.s_0555,
self.r.s_0557,
self.r.s_0563,
self.r.s_0567,
self.r.s_0568,
self.r.s_0586,
self.r.s_0629,
self.r.s_0680,
self.r.s_0765,
self.r.s_0764,
self.r.s_0767,
self.r.s_0785,
self.r.s_0849,
self.r.s_0955,
self.r.s_0991,
self.r.s_1003,
self.r.s_1039,
self.r.s_1045,
self.r.s_1198,
self.r.s_1203,
self.r.s_1360,
self.r.s_1399,
self.r.s_1520,
self.r.s_1538,
self.r.s_1543,
self.r.s_1559,
self.r.s_1565,
# reactions
self.r.r_1166,
self.r.r_1697,
self.r.r_1762,
self.r.r_1106,
self.r.r_1172,
self.r.r_2079,
])
