def plot(tspan, traj, obs, save_name, title=None):
if title is not None:
plt.title(title)
result = np.array(traj.observables)[obs]
x = np.array([tr[:] for tr in result]).T
time_in_hours = tspan / 60. / 60.
plt.plot(time_in_hours, x, '0.5', lw=2,
alpha=0.25) # individual trajectories
plt.plot(time_in_hours, x.mean(axis=1), 'b', lw=3, label='mean')
plt.plot(time_in_hours, x.max(axis=1), 'b--', lw=2, label="min/max")
plt.plot(time_in_hours, x.min(axis=1), 'b--', lw=2)
sol = ScipyOdeSimulator(earm_model, tspan)
traj = sol.run()
plt.plot(time_in_hours,
np.array(traj.observables)[obs],
c='red',
label='ode')
plt.legend(loc=0)
plt.savefig(save_name)
print("Done plotting {}".format(save_name))
# plt.show()
plt.close()
def run(n_sim=1000):
tspan = np.linspace(0, 20000, 201)
name = 'tBid_total'
# model.parameters['L_0'].value = 100
# 2.48300004005s 2.42300009727s old way
# 2.33200001717s 2.11500000954s
sim = GPUSimulator(model, tspan=tspan, verbose=True, precision=np.float64)
traj = sim.run(tspan=tspan, number_sim=n_sim, threads=32)
# quit()
for name in obs:
result = traj.dataframe[name]
tout = result.index.levels[1].values
result = result.unstack(0)
result = result.as_matrix()
x = np.array([tr[:] for tr in result]).T
plt.plot(tout, x, '0.5', lw=2, alpha=0.25) # individual trajectories
plt.plot(tout, x.mean(axis=1), 'b', lw=3, label='mean')
plt.plot(tout, x.max(axis=1), 'b--', lw=2, label="min/max")
plt.plot(tout, x.min(axis=1), 'b--', lw=2)
sol = ScipyOdeSimulator(model, tspan)
traj = sol.run()
plt.plot(tspan, np.array(traj.observables)[name], 'k-', label='ode')
plt.legend(loc=0)
plt.tight_layout()
plt.savefig('example_ssa_earm_{}.png'.format(name),
dpi=200,
bbox_inches='tight')
plt.close()
def run_scipy(tspan, model, simulations, name, ):
integrator_option = dict(rtol=RTOL, atol=ATOL, mxstep=mxstep)
scipy_solver = ScipyOdeSimulator(model, tspan,
integrator_options=integrator_option,
integrator='lsoda', )
cols = ['model', 'nsims', 'scipytime', 'rtol', 'atol', 'mxsteps', 't_end',
'n_steps', 'cpu', 'GHz', ]
all_output = []
for num_particles in simulations:
out_list = []
start_time = time.time()
for i in range(num_particles):
x = scipy_solver.run()
total_time = time.time() - start_time
out_list.append(name)
out_list.append(num_particles)
out_list.append(total_time)
out_list.append(RTOL)
out_list.append(ATOL)
out_list.append(mxstep)
out_list.append(np.max(tspan))
out_list.append(len(tspan))
out_list.append(CPU)
out_list.append(GHZ)
print(" ".join(str(i) for i in out_list))
all_output.append(out_list)
df = pd.DataFrame(all_output, columns=cols)
df.to_csv('{}_scipy_timings.csv'.format(name), index=False)
return df
def run():
# The observable of the model
observable = 'Y3'
# The values of each initial concentration to samples
# These values will be per initial concentration
vals = [.8, 1.0, 1.2]
# need to create a solver to run the model
solver = ScipyOdeSimulator(model, tspan)
# initialize the sensitivity class
sens = InitialsSensitivity(
values_to_sample=vals,
observable=observable,
objective_function=obj_func_cell_cycle,
solver=solver
)
# runs the function, can pass save_name and out_dir to save sens matrices
sens.run()
# some sample plotting commands to help view the sensitivities
sens.create_individual_pairwise_plots(save_name='pairwise_individual',
out_dir='tyson_sensitivity')
sens.create_plot_p_h_pprime(save_name='matrices',
out_dir='tyson_sensitivity')
# creates a heatplot of all initial concentration in a mirrored grid
# also decomposed heatplot into single initial concentration species
sens.create_boxplot_and_heatplot(save_name='tyson_sensitivity',
out_dir='tyson_sensitivity',
show=False)
print("Results saved in tyson_sensitivity directory")
def setUp(self):
self.tspan = np.linspace(0, 200, 5001)
self.observable = 'Y3'
self.savename = 'sens_out_test'
self.output_dir = tempfile.mkdtemp()
self.vals = np.linspace(.8, 1.2, 5)
self.vals = [.8, .9, 1., 1.1, 1.2]
self.model = model
self.solver = ScipyOdeSimulator(self.model,
tspan=self.tspan,
integrator='lsoda',
integrator_options={'rtol': 1e-8,
'atol': 1e-8,
'mxstep': 20000})
self.sens = InitialsSensitivity(
solver=self.solver,
values_to_sample=self.vals,
objective_function=self.obj_func_cell_cycle,
observable=self.observable
)
self.p_simulated = np.array(
[[0., 0., 0., 0., 0., 5.0301, 2.6027, 0., -2.5118, -4.5758],
[0., 0., 0., 0., 0., 5.0301, 2.5832, 0., -2.5313, -4.5823],
[0., 0., 0., 0., 0., 5.0301, 2.5767, 0., -2.5313, -4.5953],
[0., 0., 0., 0., 0., 5.0301, 2.5767, 0., -2.5313, -4.6082],
[0., 0., 0., 0., 0., 5.0301, 2.5767, 0., -2.5313, -4.60829],
[5.0301, 5.0301, 5.0301, 5.0301, 5.0301, 0., 0., 0., 0., 0.],
[2.6027, 2.5832, 2.5767, 2.5767, 2.5767, 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[-2.5118, -2.5313, -2.5313, -2.5313, -2.5313, 0., 0., 0., 0., 0.],
[-4.5758, -4.5823, -4.5953, -4.6082, -4.6082, 0., 0., 0., 0.,
0.]])
self.sens.run()
def test_param_not_in_model(self):
vals = [.8, .9, 1.1, 1.2, 1.3]
solver = ScipyOdeSimulator(self.model,
tspan=self.tspan,
integrator='lsoda',
integrator_options={
'rtol': 1e-8,
'atol': 1e-8,
'mxstep': 20000
})
sens = PairwiseSensitivity(values_to_sample=vals,
objective_function=self.obj_func_cell_cycle,
observable=self.observable,
solver=solver,
sample_list=['a0'])
def test_vode_run(self):
solver_vode = ScipyOdeSimulator(self.model,
tspan=self.tspan,
integrator='vode',
integrator_options={'rtol': 1e-8,
'atol': 1e-8,
'nsteps': 20000})
sens_vode = InitialsSensitivity(
solver=solver_vode,
values_to_sample=self.vals,
objective_function=self.obj_func_cell_cycle,
observable=self.observable
)
sens_vode.run()
npt.assert_almost_equal(self.sens.p_matrix, self.p_simulated,
decimal=3)
def test_unique_simulations_only(self):
vals = [.8, .9, 1.1, 1.2, 1.3]
solver = ScipyOdeSimulator(self.model,
tspan=self.tspan,
integrator='lsoda',
integrator_options={'rtol': 1e-8,
'atol': 1e-8,
'mxstep': 20000})
sens = InitialsSensitivity(
values_to_sample=vals,
objective_function=self.obj_func_cell_cycle,
observable=self.observable,
solver=solver
)
sens.run()
self.sens.create_plot_p_h_pprime(save_name='test4',
out_dir=self.output_dir)
assert os.path.exists(os.path.join(self.output_dir,
'test4_P_H_P_prime.png'))
def sims_kd(label):
pars_ref1 = np.copy(pars[0])
pars_ref2 = np.copy(pars[0])
if label == 0:
"""
Cluster 0:
Dominant reactions:
BidM_BaxC, BidM_Bcl2M, Bid_BclxLM
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
# pars_label1[:, 58] = pars_ref1[58] * 0.2 # 20% Knock down of bcl2
# pars_label1[:, 56] = pars_ref[56] * 0.8 # 20% knocl down of bclxl
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 1:
"""
Cluster 1:
Dominant reactions:
BidM_BaxC, BidM_BclxLM, Bid_Mcl1M
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
# pars_label1[:, 64] = pars_label1[64] * 0.8 # 20% Knock down of bak
# pars_label1[:, 56] = pars_ref1[56] * 0.2 # 20% Knock down of bclxl
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 2:
"""
Cluster 2:
Dominant reactions:
BidM_BaxC, BidM_Bcl2M, Bid_Mcl1 M
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
# pars_label1[:, 57] = pars_ref1[57] * 0.2 # 20% Knock down of mcl1
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 3:
"""
Cluster 3:
Dominant reactions:
BidM_BaxC, BidM_Mcl1M
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
# pars_label1[:, 57] = pars_ref1[57] * 0.2 # 20% Knock down of mcl1
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 4:
"""
Cluster 4:
Dominant reactions:
BidM_BaxC
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 5:
"""
Cluster 5:
Dominant reactions:
BidM_BaxC, BidM_BclxLM
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of Bax
# pars_label1[:, 56] = pars_ref1[56] * 0.2 # 20% Knock down of BclxL
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
if label == 6:
"""
Cluster 6:
Dominant reactions:
BidM_BaxC, BidM_Bcl2M
"""
pars_label1 = pars[np.where(clus_sp37_labels == label)]
pars_label1[:, 63] = pars_ref1[63] * 0.2 # 80% Knock down of bax
# pars_label1[:, 58] = pars_ref1[58] * 0.2 # 20% Knock down of Bcl2
# pars_label1[:, 64] = pars_label1[64] * 0.8 # 80% Knock down of bak
# pars_label1[:, 57] = pars_label1[57] * 0.8 # 80% Knock down of mcl1
sim1 = ScipyOdeSimulator(model, tspan=tspan,
param_values=pars_label1).run()
sim1.save(
'sims_baxkd80_sensitivities_sampled_kd/earm_scipyode_sims_good{0}.h5'
.format(label))
return
algorithm='tau_leaping')
return traj
if __name__ == "__main__":
# """
name = 'Product'
opt = 'earm'
#
if opt == 'earm':
sol = ScipyOdeSimulator(earm_model)
tspan = np.linspace(0, 8000, 101)
name = 'cSmac_total'
# name = 'tBid_total'
traj = sol.run(tspan=tspan)
plt.figure(0)
plt.plot(tspan, traj.observables[name], '--o', color='black', label='ode-lsoda')
# traj = run_model(earm_model, tspan, 500, simulator='gpu_ssa')
traj = run_model(earm_model, tspan, 50, simulator='gpu_ssa',
precision=np.float64)
# traj2 = run_model(earm_model, tspan, 500, simulator='cutauleaping')
if opt =='ras':
tspan = np.linspace(0, 1000, 101)
traj = run_model(ras_model, tspan, 1000, simulator='gpu_ssa')
traj1 = run_model(ras_model, tspan, 1000, simulator='gpu_ssa', precision=np.float64)
dRBPJ(Rbox=1) % pRBPJ(nicd=2, Rbox=1, loc='nuc') % NICD(rbpj=2, loc='nuc'), Ka, Ka_r)
Observable('delta', Delta())
Observable('Rcm', mRBPJ())
Observable('Hcm', mHes1())
Observable('Nm', mNotch())
Observable('Rcp', pRBPJ(nicd=None, Rbox=None, loc='cyt'))
Observable('Hcp', pHes1(pHes1=None, Hbox=None, loc='cyt'))
Observable('Np', pNotch())
Observable('Hnp', pHes1(pHes1=None, Hbox=None, loc='nuc'))
Observable('H2np', pHes1(pHes1=ANY, Hbox=None, loc='nuc'), match='species')
### SIMULATION ###
ScipyOdeSimulator._use_cython = True
sim = ScipyOdeSimulator(model, verbose=0, integrator_options={'atol': 1e-8, 'rtol': 1e-6})
# sim = BngSimulator(model, verbose=5)
plt.figure('Hes1 concentration over varying KaHp')
#multiplier for KaHp value
kahp_multiplier = np.arange(0.5, 3.5, 0.5)
for m, mult in enumerate(kahp_multiplier):
####START OF "TWO INITIAL SIMULATIONS" SECTION####
print('This is m: ' + str(m)+ ' This is mult: {0:.2f}'.format(mult))
KaHp.value = mult* 1 * 0.02535 # original value of KaHp.value is 1 * 0.02535
#first part of run, to initialize
init_time = 750
import numpy as np
from earm2_flat import model
from tropical.dynamic_signatures_range import run_tropical
from pysb.simulator.scipyode import ScipyOdeSimulator
parameters = np.load('calibrated_6572pars.npy')
t = np.linspace(0, 20000, 100)
sim = ScipyOdeSimulator(model, tspan=t, param_values=parameters[0]).run()
a = run_tropical(model, simulations=sim, diff_par=1, sp_to_vis=[37])
dRBPJ(Rbox=1) % pRBPJ(nicd=2, Rbox=1, loc='nuc') % NICD(rbpj=2, loc='nuc'), Ka, Ka_r)
#Observable('delta', Delta())
Observable('Rcm', mRBPJ())
Observable('Hcm', mHes1())
Observable('Nm', mNotch())
Observable('Rcp', pRBPJ(nicd=None, Rbox=None, loc='cyt'))
Observable('Hcp', pHes1(pHes1=None, Hbox=None, loc='cyt'))
Observable('Np', pNotch())
Observable('Hnp', pHes1(pHes1=None, Hbox=None, loc='nuc'))
Observable('H2np', pHes1(pHes1=ANY, Hbox=None, loc='nuc'), match='species')
### SIMULATION ###
ScipyOdeSimulator._use_cython = True
sim = ScipyOdeSimulator(model, verbose=True, integrator_options={'atol': 1e-8, 'rtol': 1e-6})
# sim = BngSimulator(model, verbose=5)
tspan1 = np.linspace(0, 750, 751)
# print("Hello")
# quit()
x = sim.run(tspan=tspan1)
for obs in ['delta', 'Rcm', 'Hcm', 'Nm', 'Rcp', 'Hcp', 'Np', 'Hnp', 'H2np']:
plt.figure(obs)
vol = Vnuc if obs in ['Hnp', 'H2np'] else Vcyt
plt.plot(tspan1, x.observables[obs] / 6.022e23 / vol, lw=2, label=obs)
# if obs == 'H2np':
# plt.plot(tspan1, 0.5*KaHp.value/KrHp.value*x.observables['Hnp']**2, '--k')
plt.legend()
dir_path = os.path.dirname(__file__)
data_path = os.path.join(dir_path, 'data',
'EC-RP_IMS-RP_IC-RP_data_for_models.csv')
exp_data = pd.read_csv(data_path, delimiter=',')
# print(exp_data)
color = cm.rainbow(np.linspace(0, 1, len(earm_model.initial_conditions)))
momp_obs_total = earm_model.parameters['mSmac_0'].value
momp_data = np.array([9810.0, 180.0, momp_obs_total])
momp_var = np.array([7245000.0, 3600.0, 1e4])
tspan = np.linspace(0, 20000, 201)
sim = ScipyOdeSimulator(earm_model, tspan)
traj = sim.run()
smac = np.array(traj.observables['cSmac_total'])
smac = smac / np.nanmax(smac)
st, sc, sk = scipy.interpolate.splrep(tspan, smac)
t10_0 = scipy.interpolate.sproot((st, sc - 0.10, sk))[0]
t90_0 = scipy.interpolate.sproot((st, sc - 0.90, sk))[0]
td_standard = (t10_0 + t90_0) / 2
def likelihood(traj, time=tspan):
time_of_death = []
for t, trajectory in traj.groupby('simulation'):
smac = np.array(trajectory['cSmac_total'])
smac = smac / np.nanmax(smac)
Observable('delta', Delta())
Observable('Rcm', mRBPJ())
Observable('Hcm', mHes1())
Observable('Nm', mNotch())
Observable('Rcp', pRBPJ(nicd=None, Rbox=None, loc='cyt'))
Observable('Hcp', pHes1(pHes1=None, Hbox=None, loc='cyt'))
Observable('Np', pNotch())
Observable('Hnp', pHes1(pHes1=None, Hbox=None, loc='nuc'))
Observable('H2np', pHes1(pHes1=ANY, Hbox=None, loc='nuc'), match='species')
### SIMULATION ###
ScipyOdeSimulator._use_cython = True #was True but we could not get to work
sim = ScipyOdeSimulator(model,
verbose=1,
integrator_options={
'atol': 1e-8,
'rtol': 1e-6
})
# sim = BngSimulator(model, verbose=5)
####START OF "TWO INITIAL SIMULATIONS" SECTION####
#first part of run, to initialize
init_time = 750
tspan1 = np.linspace(0, init_time, init_time + 1)
x = sim.run(tspan=tspan1)
plt.figure('Observable')
#does changing this delta to capital effect anything?
obs_list = ['delta', 'Rcm', 'Hcm', 'Nm', 'Rcp', 'Hcp', 'Np', 'Hnp', 'H2np']