def posterior_prediction(model, parameter_vector, parameter_names, sf,
test_times=[2.5, 5.0, 7.5, 10.0, 20.0, 60.0],
alpha_doses=np.logspace(-1, 5, 15),
beta_doses=np.logspace(-1, 5, 15)):
"""
Produce predictions for IFNa and IFNb using model with parameters given
as input to the function.
"""
# Make predictions
model.set_parameters(parameter_vector)
dradf = model.doseresponse(test_times, 'TotalpSTAT', 'Ia',
alpha_doses, parameters={'Ib': 0},
scale_factor=sf,
return_type='dataframe',
dataframe_labels='Alpha')
drbdf = model.doseresponse(test_times, 'TotalpSTAT', 'Ib',
beta_doses, parameters={'Ia': 0},
scale_factor=sf,
return_type='dataframe',
dataframe_labels='Beta')
posterior = IfnData('custom', df=pd.concat((dradf, drbdf)),
conditions={'Alpha': {'Ib': 0},
'Beta': {'Ia': 0}})
posterior.drop_sigmas()
return posterior
def posterior_prediction(parameter_vector, parameter_names=parameter_names):
# Make predictions
Mixed_Model.set_parameters(parameter_vector)
dradf = Mixed_Model.doseresponse(times,
'TotalpSTAT',
'Ia',
dose_range,
parameters={'Ib': 0},
scale_factor=sf,
return_type='dataframe',
dataframe_labels='Alpha')
drbdf = Mixed_Model.doseresponse(times,
'TotalpSTAT',
'Ib',
dose_range,
parameters={'Ia': 0},
scale_factor=sf,
return_type='dataframe',
dataframe_labels='Beta')
posterior = IfnData('custom',
df=pd.concat((dradf, drbdf)),
conditions={
'Alpha': {
'Ib': 0
},
'Beta': {
'Ia': 0
}
})
posterior.drop_sigmas()
return posterior
def posterior_prediction(parameter_vector, parameter_names=parameter_names):
# Make predictions
Mixed_Model.update_parameters(parameter_vector)
dradf = Mixed_Model.mixed_dose_response(times, 'TotalpSTAT', 'Ia', list(np.logspace(1, 5.2)),
parameters={'Ib': 0}, sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times, 'TotalpSTAT', 'Ib', list(np.logspace(-1, 4)),
parameters={'Ia': 0}, sf=scale_factor)
posterior = IfnData('custom', df=pd.concat((dradf, drbdf)), conditions={'Alpha': {'Ib': 0}, 'Beta': {'Ia': 0}})
posterior.drop_sigmas()
return posterior
def timecourse_figure():
# Get experimental data
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
# Aligned data, to get scale factors for each data set
alignment = DataAlignment()
alignment.add_data([newdata_4, newdata_3, newdata_2, newdata_1])
alignment.align()
alignment.get_scaled_data()
mean_data = alignment.summarize_data()
# Plot
green = sns.color_palette("deep")[2]
red = sns.color_palette("deep")[3]
light_green = sns.color_palette("pastel")[2]
light_red = sns.color_palette("pastel")[3]
plot = TimecoursePlot((1, 1))
plot.add_trajectory(mean_data,
'errorbar',
'o--', (0, 0),
label=r'10 pM IFN$\alpha$2',
color=light_red,
dose_species='Alpha',
doseslice=10.0,
alpha=0.5)
plot.add_trajectory(mean_data,
'errorbar',
'o--', (0, 0),
label=r'6 pM IFN$\beta$',
color=light_green,
dose_species='Beta',
doseslice=6.0,
alpha=0.5)
plot.add_trajectory(mean_data,
'errorbar',
'o-', (0, 0),
label=r'3000 pM IFN$\alpha$2',
color=red,
dose_species='Alpha',
doseslice=3000.0)
plot.add_trajectory(mean_data,
'errorbar',
'o-', (0, 0),
label=r'2000 pM IFN$\beta$',
color=green,
dose_species='Beta',
doseslice=2000.0)
fname = os.path.join(os.getcwd(), 'results', 'Figures', 'Figure_4',
'Timecourse.pdf')
plot.axes.set_ylabel('pSTAT1 (MFI)')
plot.show_figure(show_flag=False, save_flag=True, save_dir=fname)
def __unpackMCMC__(ID, jobs, result, countQ, build_model, build_data,
model_parameters, temperature):
"""
This function is used by the MCMC class but must be defined externally.
Should not be used by any other program.
"""
model_name, fit_parameters, priors, jump_distributions = build_model
data_set, data_name, build_conditions = build_data
model = IfnModel(model_name)
model.parameters = model_parameters
if data_name is None:
data = IfnData(name='custom', df=data_set, conditions=build_conditions)
else:
data = IfnData(data_name)
processMCMC = MCMC(model, data, fit_parameters, priors, jump_distributions)
processMCMC.temperature = temperature
processMCMC.__run_chain__(ID, jobs, result, countQ)
def _get_data_coordinates(data: IfnData):
"""Generates a list of all (species, dose, time) triplets with non-NaN
values in the IfnData data_set attribute. Returns this list of 3-elemnt
tuples.
"""
coord = []
for s in data.get_dose_species():
for d in data.get_doses(species=s):
for t in data.get_times(species=s):
c = (s, d, t)
if not pd.isnull(data.data_set.loc[c[0:2]][c[2]]):
if type(data.data_set.loc[c[0:2]][c[2]]) == tuple:
if not pd.isnull(data.data_set.loc[c[0:2]][c[2]][0]):
coord.append(c)
else:
coord.append(c)
return coord
def likelihood(parameter_vector,
sampled_parameter_names=pysb_sampled_parameter_names,
model=Mixed_Model):
# Change model parameter values to current location in parameter space (values are in log(value) format)
shared_param_dict = {
pname: 10**pvalue
for pname, pvalue in zip(sampled_parameter_names, parameter_vector)
if pname[-2] != '_'
}
pop1_param_dict = {
pname[:-2]: 10**pvalue
for pname, pvalue in zip(sampled_parameter_names, parameter_vector)
if pname[-2:] == '_1'
}
pop2_param_dict = {
pname[:-2]: 10**pvalue
for pname, pvalue in zip(sampled_parameter_names, parameter_vector)
if pname[-2:] == '_2'
}
model.set_global_parameters(shared_param_dict)
model.model_1.set_parameters(pop1_param_dict)
model.model_2.set_parameters(pop2_param_dict)
#Simulate experimentally measured TotalpSTAT values.
# Alpha
dradf = model.mixed_dose_response(tspan,
'TotalpSTAT',
'Ia',
alpha_doses,
parameters={'Ib': 0},
sf=scale_factor)
drbdf = model.mixed_dose_response(tspan,
'TotalpSTAT',
'Ib',
beta_doses,
parameters={'Ia': 0},
sf=scale_factor)
# Concatenate and flatten
total_simulation_data = IfnData(name='custom',
df=pd.concat([dradf, drbdf]))
sim_data = np.array([[el[0] for el in dose]
for dose in total_simulation_data.data_set.values
]).flatten()
#Calculate log probability contribution from simulated experimental values.
logp_ctotal = np.sum(like_ctot.logpdf(sim_data))
#If model simulation failed due to integrator errors, return a log probability of -inf.
if np.isnan(logp_ctotal):
logp_ctotal = -np.inf
return logp_ctotal
def __posterior_prediction__(self, parameter_dict, test_times,
observable, dose_species, doses,
scale_factor, conditions, dataframe_label):
"""
Produce predictions for IFNa and IFNb using model with parameters given
as input to the function.
"""
# Update parameters
if self.param_dist_flag:
# find all distribution parameters
dist_param_names = []
for key in parameter_dict.keys():
if key.endswith('_mu*'):
dist_param_names.append(key[:-4])
# sample according to mu, std
dist_param_dict = {}
for pname in dist_param_names:
mu = np.log10(parameter_dict[pname + '_mu*'])
std = parameter_dict[pname + '_std*']
sample = 10 ** np.random.normal(loc=mu, scale=std)
dist_param_dict.update({pname: sample})
# remove distribution parameters
parameter_dict.pop(pname + '_mu*')
parameter_dict.pop(pname + '_std*')
# add sample to parameter_dict
parameter_dict.update(dist_param_dict)
parameter_dict.update(conditions)
# Make predictions
df = self.model.doseresponse(test_times, observable, dose_species,
doses, parameters=parameter_dict,
scale_factor=scale_factor,
return_type='dataframe',
dataframe_labels=dataframe_label)
posterior = IfnData('custom', df=df, conditions=conditions)
posterior.drop_sigmas()
return posterior
def mixed_dose_response(self,
times,
observable,
dose_species,
doses,
parameters={},
sf=1,
**kwargs):
return_type = kwargs.get('return_type', 'DataFrame')
if return_type not in ['DataFrame', 'IfnData']:
raise TypeError('Invalid return type requested')
response_1 = self.model_1.doseresponse(
times, observable, dose_species, doses,
parameters=parameters)[observable]
response_2 = self.model_2.doseresponse(
times, observable, dose_species, doses,
parameters=parameters)[observable]
weighted_sum_response = np.add(np.multiply(response_1, self.w1),
np.multiply(response_2, self.w2))
if sf != 1:
weighted_sum_response = [[el * sf for el in row]
for row in weighted_sum_response]
if dose_species == 'Ia':
labelled_data = [[
'Alpha', doses[row], *[(el, nan)
for el in weighted_sum_response[row]]
] for row in range(0, len(weighted_sum_response))]
elif dose_species == 'Ib':
labelled_data = [[
'Beta', doses[row], *[(el, nan)
for el in weighted_sum_response[row]]
] for row in range(0, len(weighted_sum_response))]
else:
labelled_data = [[
'Cytokine', doses[row], *[(el, nan)
for el in weighted_sum_response[row]]
] for row in range(0, len(weighted_sum_response))]
column_labels = ['Dose_Species', 'Dose (pM)'
] + [str(el) for el in times]
drdf = pd.DataFrame.from_records(labelled_data, columns=column_labels)
drdf.set_index(['Dose_Species', 'Dose (pM)'], inplace=True)
if return_type == 'DataFrame':
return drdf
if return_type == 'IfnData':
return IfnData(name='custom', df=drdf, conditions=parameters)
def testing_specific_values():
volEC1 = 1 / (25E9)
volEC2 = 1E-5
# --------------------
# Set up Model
# --------------------
# Parameters found by stepwise fitting GAB mean data
# Note: can remove multiplicative factors on all K1, K2, K4 and still get very good fit to data (worst is 5 min beta)
initial_parameters = {
'k_a1': 4.98E-14 * 2,
'k_a2': 8.30e-13 * 2,
'k_d4': 0.006 * 3.8,
'kpu': 0.00095,
'ka2': 4.98e-13 * 2.45,
'kd4': 0.3 * 2.867,
'kint_a': 0.000124,
'kint_b': 0.00086,
'krec_a1': 0.0028,
'krec_a2': 0.01,
'krec_b1': 0.005,
'krec_b2': 0.05
}
dual_parameters = {
'kint_a': 0.00052,
'kSOCSon': 6e-07,
'kint_b': 0.00052,
'krec_a1': 0.001,
'krec_a2': 0.1,
'krec_b1': 0.005,
'krec_b2': 0.05
}
scale_factor = 1.227
Mixed_Model = DualMixedPopulation('Mixed_IFN_ppCompatible', 0.8, 0.2)
Mixed_Model.model_1.set_parameters(initial_parameters)
Mixed_Model.model_1.set_parameters(dual_parameters)
Mixed_Model.model_1.set_parameters({'R1': 12000.0, 'R2': 1511.1})
Mixed_Model.model_2.set_parameters(initial_parameters)
Mixed_Model.model_2.set_parameters(dual_parameters)
Mixed_Model.model_2.set_parameters({'R1': 6755.56, 'R2': 1511.1})
# ---------------------------------
# Make theory dose response curves
# ---------------------------------
# Make predictions
times = np.arange(0, 120, 0.5) # [2.5, 5.0, 7.5, 10.0, 20.0, 60.0]
alpha_doses_20190108 = [0, 10, 100, 300, 1000, 3000, 10000, 100000]
beta_doses_20190108 = [0, 0.2, 6, 20, 60, 200, 600, 2000]
# 1 uL
ka1 = Mixed_Model.model_1.parameters['ka1']
ka2 = Mixed_Model.model_1.parameters['ka2']
k_a1 = Mixed_Model.model_1.parameters['k_a1']
k_a2 = Mixed_Model.model_1.parameters['k_a2']
Mixed_Model.set_global_parameters({
'volEC': volEC1,
'ka1': ka1 * 1E-5 / volEC1,
'ka2': ka2 * 1E-5 / volEC1,
'k_a1': k_a1 * 1E-5 / volEC1,
'k_a2': k_a2 * 1E-5 / volEC1
})
dradf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ia',
list(logspace(1, 5.2)),
parameters={'Ib': 0},
sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor)
dra15uL = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb15uL = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# 1 mL
Mixed_Model.set_global_parameters({
'volEC': volEC2,
'ka1': ka1 * 1E-5 / volEC2,
'ka2': ka2 * 1E-5 / volEC2,
'k_a1': k_a1 * 1E-5 / volEC2,
'k_a2': k_a2 * 1E-5 / volEC2
})
dradf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ia',
list(logspace(1, 5.2)),
parameters={'Ib': 0},
sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor)
dra5mL = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb5mL = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# -------------------------------
# Plot model dose response curves
# -------------------------------
alpha_palette = sns.color_palette("deep", 6)
beta_palette = sns.color_palette("deep", 6)
new_fit = DoseresponsePlot((2, 2))
alpha_mask = [2.5, 5.0, 10.0, 20.0, 60.0]
beta_mask = [2.5, 5.0, 10.0, 20.0, 60.0]
# Add fits
color_counter = -1
for idx, t in enumerate(times):
if t in alpha_mask:
color_counter += 1
new_fit.add_trajectory(dra15uL,
t,
'plot',
alpha_palette[color_counter], (0, 0),
'Alpha',
label=str(t) + ' min',
linewidth=2)
new_fit.add_trajectory(dra5mL,
t,
'plot',
alpha_palette[color_counter], (1, 0),
'Alpha',
label=str(t) + ' min',
linewidth=2)
if t in beta_mask:
new_fit.add_trajectory(drb15uL,
t,
'plot',
beta_palette[color_counter], (0, 1),
'Beta',
label=str(t) + ' min',
linewidth=2)
new_fit.add_trajectory(drb5mL,
t,
'plot',
beta_palette[color_counter], (1, 1),
'Beta',
label=str(t) + ' min',
linewidth=2)
dr_fig, dr_axes = new_fit.show_figure()
dr_axes[0][0].set_title(r'IFN$\alpha$ at {} L'.format(volEC1))
dr_axes[0][1].set_title(r'IFN$\beta$ at {} L'.format(volEC1))
dr_axes[1][0].set_title(r'IFN$\alpha$ at {} L'.format(volEC2))
dr_axes[1][1].set_title(r'IFN$\beta$ at {} L'.format(volEC2))
dr_fig.tight_layout()
dr_fig.savefig('varying_reaction_volume_dr.pdf')
# -------------------------------
# Plot model dose response curves
# -------------------------------
tc_figure = TimecoursePlot((1, 2))
alpha_testdose = list(logspace(1, 5.2))[24]
beta_testdose = list(logspace(-1, 4))[17]
print("Using {} for IFNalpha".format(alpha_testdose))
print("Using {} for IFNbeta".format(beta_testdose))
tc_figure.add_trajectory(dra15uL,
'plot',
'-',
subplot_idx=(0, 0),
label=r'IFN$\alpha$ at {} L'.format(volEC1),
doseslice=alpha_testdose,
dose_species='Alpha',
color=alpha_palette[1])
tc_figure.add_trajectory(dra5mL,
'plot',
'-',
subplot_idx=(0, 0),
label=r'IFN$\alpha$ at {} L'.format(volEC2),
doseslice=alpha_testdose,
dose_species='Alpha',
color=alpha_palette[4])
tc_figure.add_trajectory(drb15uL,
'plot',
'-',
subplot_idx=(0, 1),
label=r'IFN$\beta$ at {} L'.format(volEC1),
doseslice=beta_testdose,
dose_species='Beta',
color=beta_palette[0])
tc_figure.add_trajectory(drb5mL,
'plot',
'-',
subplot_idx=(0, 1),
label=r'IFN$\beta$ at {} L'.format(volEC2),
doseslice=beta_testdose,
dose_species='Beta',
color=beta_palette[2])
tc_figure.show_figure(save_flag=True,
save_dir='varying_reaction_volume_tc.pdf')
# ------------------------------------
# Now let's quickly look at IFN levels
# ------------------------------------
# 1 uL
Mixed_Model.set_global_parameters({
'volEC': volEC1,
'ka1': ka1 * 1E-5 / volEC1,
'ka2': ka2 * 1E-5 / volEC1,
'k_a1': k_a1 * 1E-5 / volEC1,
'k_a2': k_a2 * 1E-5 / volEC1
})
dradf = Mixed_Model.mixed_dose_response(times,
'Free_Ia',
'Ia',
list(logspace(1, 5.2)),
parameters={'Ib': 0},
sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times,
'Free_Ib',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor)
dra15uL = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb15uL = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# 1 mL
Mixed_Model.set_global_parameters({
'volEC': volEC2,
'ka1': ka1 * 1E-5 / volEC2,
'ka2': ka2 * 1E-5 / volEC2,
'k_a1': k_a1 * 1E-5 / volEC2,
'k_a2': k_a2 * 1E-5 / volEC2
})
dradf = Mixed_Model.mixed_dose_response(times,
'Free_Ia',
'Ia',
list(logspace(1, 5.2)),
parameters={'Ib': 0},
sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times,
'Free_Ib',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor)
dra5mL = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb5mL = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
tc_figure = TimecoursePlot((1, 2))
tc_figure.add_trajectory(dra15uL,
'plot',
'-',
subplot_idx=(0, 0),
label=r'IFN$\alpha$ at {} L'.format(volEC1),
doseslice=alpha_testdose,
dose_species='Alpha',
color=alpha_palette[1])
tc_figure.add_trajectory(dra5mL,
'plot',
'-',
subplot_idx=(0, 0),
label=r'IFN$\alpha$ at {} L'.format(volEC2),
doseslice=alpha_testdose,
dose_species='Alpha',
color=alpha_palette[4])
tc_figure.add_trajectory(drb15uL,
'plot',
'-',
subplot_idx=(0, 1),
label=r'IFN$\beta$ at {} L'.format(volEC1),
doseslice=beta_testdose,
dose_species='Beta',
color=beta_palette[0])
tc_figure.add_trajectory(drb5mL,
'plot',
'-',
subplot_idx=(0, 1),
label=r'IFN$\beta$ at {} L'.format(volEC2),
doseslice=beta_testdose,
dose_species='Beta',
color=beta_palette[2])
for ax in tc_figure.axes.flatten():
ax.set_yscale('log')
ifn_fig, ifn_axes = tc_figure.show_figure()
ifn_axes[0].set_ylabel('IFN-alpha2')
ifn_axes[1].set_ylabel('IFN-beta')
ifn_fig.savefig('varying_reaction_volume_tc_IFN.pdf')
ydata = [top * x**n / (k**n + x**n) for x in xdata]
return ydata
def fit_MM(doses, responses, guesses):
top = guesses[0]
n = guesses[1]
K = guesses[2]
results, covariance = curve_fit(MM, doses, responses, p0=[top, n, K])
top = results[0]
n = results[1]
K = results[2]
return top, n, K
newdata = IfnData("MacParland_Extended")
data = np.transpose([[el[0] for el in r] for r in newdata.data_set.values])
alpha_data = [r[0:5].tolist() for r in data]
beta_data = [r[5:].tolist() for r in data]
# testModel = IfnModel('Mixed_IFN_ppCompatible')
# dra = testModel.doseresponse([0, 5, 15, 30, 60], 'TotalpSTAT', 'Ia', list(logspace(-3, 4)),
# parameters={'Ib': 0}, return_type='dataframe', dataframe_labels='Alpha')
exp_doses_a = [10, 90, 600, 4000, 8000]
exp_doses_b = [10, 90, 600, 3000, 11000]
alpha5 = [[], []]
alpha15 = [[], []]
alpha30 = [[], []]
alpha60 = [[], []]
ydata = [top * x**n / (k**n + x**n) for x in xdata]
return ydata
def fit_MM(doses, responses, guesses):
top = guesses[0]
n = guesses[1]
K = guesses[2]
results, covariance = curve_fit(MM, doses, responses, p0=[top, n, K])
top = results[0]
n = results[1]
K = results[2]
return top, n, K
newdata = IfnData("20181113_B6_IFNs_Dose_Response_Bcells")
data = np.transpose([[el[0] for el in r] for r in newdata.data_set.values])
alpha_data = [r[1:8].tolist() for r in data]
beta_data = [r[9:].tolist() for r in data]
# testModel = IfnModel('Mixed_IFN_ppCompatible')
# dra = testModel.doseresponse([0, 5, 15, 30, 60], 'TotalpSTAT', 'Ia', list(logspace(-3, 4)),
# parameters={'Ib': 0}, return_type='dataframe', dataframe_labels='Alpha')
exp_doses_a = [5, 50, 250, 500, 5000, 25000, 50000]
exp_doses_b = [0.1, 1, 5, 10, 100, 200, 1000]
alpha2_5 = [exp_doses_a[2:], alpha_data[0][2:]]
alpha5 = [exp_doses_a, alpha_data[1]]
alpha7_5 = [exp_doses_a, alpha_data[2]]
def doseresponse(self, times, observable, dose_species, doses, parameters={}, return_type='list',
dataframe_labels=None, scale_factor=1, **kwargs):
no_sigma = kwargs.get('no_sigma', False)
return_type = return_type.lower()
# create dose_response_table dictionary
if type(observable) == list:
dose_response_table = {obs: zeros((len(doses), len(times))) for obs in observable}
else:
dose_response_table = {observable: zeros((len(doses), len(times)))}
# prepare custom parameters dictionary
dose_parameters = copy.deepcopy(self.parameters)
dose_parameters.update(parameters)
# iterate through all doses
picoMolar = 1E-12
Avogadro = 6.022E23
volEC = self.parameters['volEC']
for idx, d in enumerate(doses):
dose_parameters.update({dose_species: d*picoMolar*Avogadro*volEC})
trajectories = self.timecourse(times, observable, parameters=dose_parameters, **kwargs)
# add results to dose_response_table dictionary
for observable_species in trajectories.keys():
dose_response_table[observable_species][idx] = trajectories[observable_species]
# return dose response curves
if return_type == 'list':
for observable_species in dose_response_table.keys():
dose_response_table[observable_species] = dose_response_table[observable_species].tolist()
if scale_factor == 1:
return dose_response_table
else:
if type(observable) == list:
return [multiply(scale_factor, asarray(dose_response_table[obs])).tolist() for obs in observable]
else:
return multiply(scale_factor, asarray(dose_response_table[observable])).tolist()
elif return_type == 'dataframe' or return_type == 'ifndata':
if type(observable) != list:
if dataframe_labels is None:
dataframe_labels == dose_species
data_dict = {'Dose_Species': [dataframe_labels for d in range(len(doses))],
'Dose (pM)': [d for d in doses]}
for t in range(len(times)):
if no_sigma:
data_dict.update({str(times[t]): [dose_response_table[observable][d][t] for d in range(len(doses))]})
else:
data_dict.update({str(times[t]): [(dose_response_table[observable][d][t], nan) for d in range(len(doses))]})
df = pd.DataFrame.from_dict(data_dict)
df.set_index(['Dose_Species', 'Dose (pM)'], inplace=True)
if scale_factor == 1:
if return_type == 'dataframe':
return df
else:
return IfnData('custom', df=df)
else:
if no_sigma:
scale_data = lambda q: scale_factor * q
else:
scale_data = lambda q: (scale_factor * q[0], scale_factor * q[1])
if dose_species == 'Ia':
dose_species = 'Alpha'
elif dose_species == 'Ib':
dose_species = 'Beta'
for i in range(len(times)):
df.loc[dose_species].iloc[:, i] = df.loc[dose_species].iloc[:, i].apply(scale_data)
if return_type == 'dataframe':
return df
else:
return IfnData('custom', df=df)
else:
if dataframe_labels is None:
dataframe_labels == dose_species
total_df = pd.DataFrame()
for obs in observable:
data_dict = {'Observable_Species': [obs for _ in range(len(doses))],
'Dose_Species': [dataframe_labels for _ in range(len(doses))],
'Dose (pM)': [d for d in doses]}
for t in range(len(times)):
data_dict.update({str(times[t]): [(dose_response_table[obs][d][t], nan) for d in range(len(doses))]})
df = pd.DataFrame.from_dict(data_dict)
total_df = total_df.append(df)
total_df.set_index(['Observable_Species', 'Dose_Species', 'Dose (pM)'], inplace=True)
if scale_factor == 1:
if return_type == 'dataframe':
return total_df
else:
return IfnData('custom', df=total_df)
else:
scale_data = lambda q: (scale_factor * q[0], scale_factor * q[1])
if dose_species == 'Ia':
dose_species = 'Alpha'
elif dose_species == 'Ib':
dose_species = 'Beta'
for obs in observable:
for i in range(len(times)):
total_df.loc[obs].loc[dose_species].iloc[:, i] = total_df.loc[obs].loc[dose_species].iloc[:, i].apply(scale_data)
if return_type == 'dataframe':
return total_df
else:
return IfnData('custom', df=total_df)
from ifnclass.ifndata import IfnData
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import Trajectory, TimecoursePlot, DoseresponsePlot
from numpy import linspace, logspace, log10, nan
import seaborn as sns
from ifnclass.ifnfit import StepwiseFit
if __name__ == '__main__':
raw_data = IfnData("20190121_pSTAT1_IFN_Bcell")
Mixed_Model = IfnModel('Mixed_IFN_ppCompatible')
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
times = [2.5, 5, 7.5, 10, 20, 60]
alpha_doses_20190108 = [0, 10, 100, 300, 1000, 3000, 10000, 100000]
beta_doses_20190108 = [0, 0.2, 6, 20, 60, 200, 600, 2000]
Mixed_Model.set_parameters({
'R2': 4140,
'R1': 4920,
'k_a1': 2.49e-15,
'k_a2': 1.328e-12,
'k_d3': 7.5e-06,
'k_d4': 0.06,
'kSOCSon': 5e-08,
'kpu': 0.0024,
'kpa': 2.08e-06,
'ka1': 5.3e-15,
'ka2': 1.22e-12,
'kd4': 0.86,
from ifnclass.ifndata import IfnData, DataAlignment
from ifnclass.ifnplot import DoseresponsePlot, TimecoursePlot
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
if __name__ == '__main__':
# ------------
# Process data
# ------------
small_1 = IfnData("20190108_pSTAT1_IFN_Small_Bcells")
small_2 = IfnData("20190119_pSTAT1_IFN_Small_Bcells")
small_3 = IfnData("20190121_pSTAT1_IFN_Small_Bcells")
small_4 = IfnData("20190214_pSTAT1_IFN_Small_Bcells")
large_1 = IfnData("20190108_pSTAT1_IFN_Large_Bcells")
large_2 = IfnData("20190119_pSTAT1_IFN_Large_Bcells")
large_3 = IfnData("20190121_pSTAT1_IFN_Large_Bcells")
large_4 = IfnData("20190214_pSTAT1_IFN_Large_Bcells")
small_alignment = DataAlignment()
small_alignment.add_data([small_4, small_3, small_2, small_1])
small_alignment.align()
small_alignment.get_scaled_data()
mean_small_data = small_alignment.summarize_data()
large_alignment = DataAlignment()
large_alignment.add_data([large_4, large_3, large_2, large_1])
large_alignment.align()
drbdf = Mixed_Model.doseresponse(times,
'TotalpSTAT',
'Ib',
list(logspace(-2, 4)),
parameters={'Ia': 0},
return_type='dataframe',
dataframe_labels='Beta')
for i in range(len(times)):
dradf.loc['Alpha'].iloc[:, i] = dradf.loc['Alpha'].iloc[:, i].apply(
scale_data)
drbdf.loc['Beta'].iloc[:,
i] = drbdf.loc['Beta'].iloc[:,
i].apply(scale_data)
dra = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
dose_response_plot = DoseresponsePlot((3, 2))
alpha_mask = []
beta_mask = []
# Add fits
for idx, t in enumerate([str(el) for el in times]):
if t not in [str(el) for el in alpha_mask]:
dose_response_plot.add_trajectory(dra,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label='Alpha ' + t,
linewidth=2.0)
from ifnclass.ifndata import IfnData
from ifnclass.ifnplot import DoseresponsePlot, TimecoursePlot
import seaborn as sns
import matplotlib.pyplot as plt
if __name__ == '__main__':
#olddata = IfnData("20181113_B6_IFNs_Dose_Response_Bcells")
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
times = [2.5, 5, 7.5, 10, 20, 60]
alpha_doses = [0, 10, 100, 300, 1000, 3000, 10000, 100000]
beta_doses = [0, 0.2, 6, 20, 60, 200, 600, 2000]
#beta_doses_20181113 = [0.1, 1, 5, 10, 100, 200, 1000]
#alpha_doses_20181113 = [5, 50, 250, 500, 5000, 25000, 50000]
alpha_palette_new = sns.color_palette("Reds", 6)
beta_palette_new = sns.color_palette("Greens", 6)
alpha_palette_old = sns.color_palette("Reds", 6)
beta_palette_old = sns.color_palette("Greens", 6)
data_plot_dr = DoseresponsePlot((4, 2))
alpha_mask = []
beta_mask = []
# Add data
for idx, t in enumerate(times):
if t not in alpha_mask:
data_plot_dr.add_trajectory(newdata_4,
def aggregate_response(model,
method,
model_type,
plist,
times=[60],
scale_factor=1.5):
if model_type == 'MEDIAN':
alpha_traj = []
beta_traj = []
for i in tqdm(range(len(plist))):
p = plist[i]
# simulate IFN alpha-2
tempP = copy.deepcopy(p)
tempP.update({'Ib': 0})
tempA = method(times,
'TotalpSTAT',
'Ia',
list(logspace(-2, 5, num=30)),
parameters=tempP,
return_type='DataFrame',
dataframe_labels='Alpha',
scale_factor=scale_factor,
no_sigma=True)
# simulate IFN beta
tempP = copy.deepcopy(p)
tempP.update({'Ia': 0})
tempB = method(times,
'TotalpSTAT',
'Ib',
list(logspace(-2, 5, num=30)),
parameters=tempP,
return_type='DataFrame',
dataframe_labels='Beta',
scale_factor=scale_factor,
no_sigma=True)
# add to record of trajectories
alpha_traj.append(copy.deepcopy(tempA))
beta_traj.append(copy.deepcopy(tempB))
# get aggregate predictions
dose_species = 'Alpha'
dra60 = IfnData('custom',
df=copy.deepcopy(alpha_traj[0]),
conditions={'Alpha': {
'Ib': 0
}})
mean_alpha_predictions = np.mean([
alpha_traj[i].loc[dose_species].values
for i in range(len(alpha_traj))
],
axis=0)
for didx, d in enumerate(dra60.get_doses()['Alpha']):
for tidx, t in enumerate(dra60.get_times()['Alpha']):
dra60.data_set.loc['Alpha'][str(
t)].loc[d] = mean_alpha_predictions[didx][tidx]
dose_species = 'Beta'
drb60 = IfnData('custom',
df=copy.deepcopy(beta_traj[0]),
conditions={'Beta': {
'Ia': 0
}})
mean_beta_predictions = np.mean([
beta_traj[i].loc[dose_species].values
for i in range(len(beta_traj))
],
axis=0)
for didx, d in enumerate(drb60.get_doses()['Beta']):
for tidx, t in enumerate(drb60.get_times()['Beta']):
drb60.data_set.loc['Beta'][str(
t)].loc[d] = mean_beta_predictions[didx][tidx]
elif model_type == 'SINGLE_CELL':
dradf = method(times,
'TotalpSTAT',
'Ia',
list(logspace(-2, 5)),
parameters={'Ib': 0},
return_type='DataFrame',
dataframe_labels='Alpha',
scale_factor=scale_factor)
drbdf = method(times,
'TotalpSTAT',
'Ib',
list(logspace(-2, 5)),
parameters={'Ia': 0},
return_type='DataFrame',
dataframe_labels='Beta',
scale_factor=scale_factor)
dra60 = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
else:
raise ValueError("Model type must be MEDIAN or SINGLE_CELL")
return dra60, drb60
def run_smooth_trajectories(cell_densities,
IFNAlpha_panel,
IFNBeta_panel,
times,
IFN_in_concentration=True):
# Experimental parameters
volume_panel = [1 / i for i in cell_densities]
# --------------------
# Set up Model
# --------------------
# Parameters found by stepwise fitting GAB mean data
# Note: can remove multiplicative factors on all K1, K2, K4 and still get very good fit to data (worst is 5 min beta)
initial_parameters = {
'k_a1': 4.98E-14 * 2,
'k_a2': 8.30e-13 * 2,
'k_d4': 0.006 * 3.8,
'kpu': 0.00095,
'ka2': 4.98e-13 * 2.45,
'kd4': 0.3 * 2.867,
'kint_a': 0.000124,
'kint_b': 0.00086,
'krec_a1': 0.0028,
'krec_a2': 0.01,
'krec_b1': 0.005,
'krec_b2': 0.05
}
dual_parameters = {
'kint_a': 0.00052,
'kSOCSon': 6e-07,
'kint_b': 0.00052,
'krec_a1': 0.001,
'krec_a2': 0.1,
'krec_b1': 0.005,
'krec_b2': 0.05
}
scale_factor = 1.227
Mixed_Model = DualMixedPopulation('Mixed_IFN_ppCompatible', 0.8, 0.2)
Mixed_Model.model_1.set_parameters(initial_parameters)
Mixed_Model.model_1.set_parameters(dual_parameters)
Mixed_Model.model_1.set_parameters({'R1': 12000.0, 'R2': 1511.1})
Mixed_Model.model_2.set_parameters(initial_parameters)
Mixed_Model.model_2.set_parameters(dual_parameters)
Mixed_Model.model_2.set_parameters({'R1': 6755.56, 'R2': 1511.1})
ka1 = Mixed_Model.model_1.parameters['ka1']
ka2 = Mixed_Model.model_1.parameters['ka2']
k_a1 = Mixed_Model.model_1.parameters['k_a1']
k_a2 = Mixed_Model.model_1.parameters['k_a2']
# ---------------------------------
# Make theory dose response curves
# ---------------------------------
# Make predictions
predictions = {}
for vidx, volume in enumerate(volume_panel):
Mixed_Model.set_global_parameters({
'volEC': volume,
'ka1': ka1 * 1E-5 / volume,
'ka2': ka2 * 1E-5 / volume,
'k_a1': k_a1 * 1E-5 / volume,
'k_a2': k_a2 * 1E-5 / volume
})
dradf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ia',
IFNAlpha_panel,
parameters={'Ib': 0},
sf=scale_factor)
drbdf = Mixed_Model.mixed_dose_response(times,
'TotalpSTAT',
'Ib',
IFNBeta_panel,
parameters={'Ia': 0},
sf=scale_factor)
drIadf = Mixed_Model.mixed_dose_response(times,
'Free_Ia',
'Ia',
IFNAlpha_panel,
parameters={'Ib': 0},
sf=scale_factor)
drIbdf = Mixed_Model.mixed_dose_response(times,
'Free_Ib',
'Ib',
IFNBeta_panel,
parameters={'Ia': 0},
sf=scale_factor)
if IFN_in_concentration:
for d in drIadf.loc['Alpha'].index:
for t in drIadf.loc['Alpha'].columns:
drIadf.loc['Alpha', t][d] = (drIadf.loc['Alpha', t][d][0] /
(6.022E23 * volume * 1E-9),
drIadf.loc['Alpha', t][d][1])
for d in drIbdf.loc['Beta'].index:
for t in drIbdf.loc['Beta'].columns:
drIbdf.loc['Beta', t][d] = (drIbdf.loc['Beta', t][d][0] /
(6.022E23 * volume * 1E-9),
drIbdf.loc['Beta', t][d][1])
draIfnData = IfnData('custom',
df=dradf,
conditions={'Alpha': {
'Ib': 0
}})
drbIfnData = IfnData('custom',
df=drbdf,
conditions={'Beta': {
'Ia': 0
}})
drIaIfnData = IfnData('custom',
df=drIadf,
conditions={'Alpha': {
'Ib': 0
}})
drIbIfnData = IfnData('custom',
df=drIbdf,
conditions={'Beta': {
'Ia': 0
}})
predictions[cell_densities[vidx]] = [
draIfnData, drbIfnData, drIaIfnData, drIbIfnData
]
return predictions
from ifnclass.ifndata import IfnData
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import Trajectory, TimecoursePlot, DoseresponsePlot
from numpy import linspace, logspace, log10, nan
import seaborn as sns
if __name__ == '__main__':
Sagar_data = IfnData("MacParland_Extended")
#Sagar_data.data_set.drop(labels=[4000, 8000], level=1, inplace=True)
Mixed_Model = IfnModel('Mixed_IFN_ppCompatible')
'''
fit_parameters = OrderedDict(
[('kd4', 1.0), ('krec_a1', 3.0000000000000001e-05), ('krec_a2', 0.050000000000000003), ('krec_b2', 0.01),
('krec_b1', 0.001), ('k_d4', 0.00059999999999999995), ('kSOCSon', 1e-08), ('kd3', 0.001),
('k_d3', 2.3999999999999999e-06)])
Mixed_Model.set_parameters(fit_parameters)
Mixed_Model.save_model('fitting_2_5.p')
'''
#Mixed_Model.load_model('fitting_2_5.p')
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
# ---------------------------
# Now try to improve the fit:
# ---------------------------
"""
Results of the 5 minute stepwise fit
OrderedDict([('R2', 500.0), ('kpu', 0.0001), ('R1', 821.42857142857144), ('k_d4', 0.10000000000000001), ('kd4', 0.21642857142857141), ('kd3', 0.00021642857142857143), ('k_d3', 0.00040000000000000002)])
10.6992020307
# Previous attempt
from ifnclass.ifndata import IfnData
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import Trajectory, TimecoursePlot, DoseresponsePlot
from ifnclass.ifnfit import StepwiseFit
from numpy import linspace, logspace, log10, nan
import seaborn as sns
from smooth_B6_IFN import * # Imports smoothed data to fit to
if __name__ == '__main__':
newdata = IfnData("20181113_B6_IFNs_Dose_Response_Bcells")
Mixed_Model = IfnModel('')
Mixed_Model.load_model('fitting_2_5.p')
Mixed_Model.set_parameters({
'kpu': 0.0028,
'R2': 2300 * 2.5,
'R1': 1800 * 1.8,
'k_d4': 0.06,
'kint_b': 0.0003,
'krec_b1': 0.001,
'k_a1': 4.98E-14,
'k_a2': 8.30e-13 * 4,
'kSOCSon': 0.9e-8,
'ka1': 3.321155762205247e-14 * 0.3,
'ka2': 4.98173364330787e-13 * 0.3,
'kint_a': 0.0014,
'krec_a1': 9e-03
})
scale_factor = 0.036
alpha_palette = sns.color_palette("Reds", 9)
beta_palette = sns.color_palette("Greens", 9)
logp_ctotal = np.sum(like_ctot.logpdf(sim_data))
# If model simulation failed due to integrator errors, return a log probability of -inf.
if np.isnan(logp_ctotal):
logp_ctotal = -np.inf
return logp_ctotal
return likelihood
if __name__ == '__main__':
# --------------------
# Import data
#---------------------
Moraga_data = IfnData("2015_pSTAT5_Epo")
# --------------------
# Set up Model
# --------------------
model = IfnModel('Epo_model')
# ---------------------------------
# Make theory dose response curves
# ---------------------------------
IC_names = ['Epo_IC', 'EMP1_IC', 'EMP33_IC']
# Make predictions
response_species = 'T_Epo'
dose_species = 'Epo_IC'
times = [60.0] # min
Epo_doses = Moraga_data.get_doses()['T_Epo'] # pM
scale_data)
drbdf.loc['Beta'].iloc[:,
i] = drbdf.loc['Beta'].iloc[:,
i].apply(scale_data)
dradf_int.loc['Alpha'].iloc[:, i] = dradf_int.loc[
'Alpha'].iloc[:, i].apply(scale_data)
drbdf_int.loc['Beta'].iloc[:,
i] = drbdf_int.loc['Beta'].iloc[:, i].apply(
scale_data)
dradf_rec.loc['Alpha'].iloc[:, i] = dradf_rec.loc[
'Alpha'].iloc[:, i].apply(scale_data)
drbdf_rec.loc['Beta'].iloc[:,
i] = drbdf_rec.loc['Beta'].iloc[:, i].apply(
scale_data)
dra60 = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
dra60_int = IfnData('custom',
df=dradf_int,
conditions={'Alpha': {
'Ib': 0
}})
drb60_int = IfnData('custom', df=drbdf_int, conditions={'Beta': {'Ia': 0}})
dra60_rec = IfnData('custom',
df=dradf_rec,
conditions={'Alpha': {
'Ib': 0
}})
drb60_rec = IfnData('custom', df=drbdf_rec, conditions={'Beta': {'Ia': 0}})
dr_plot = DoseresponsePlot((3, 2))
from ifnclass.ifndata import IfnData, DataAlignment
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import DoseresponsePlot, TimecoursePlot
import seaborn as sns
import numpy as np
import pandas as pd
from ifnclass.ifnfit import StepwiseFit, MCMC, Prior
if __name__ == '__main__':
# ------------------------------
# Align all data
# ------------------------------
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
alignment = DataAlignment()
alignment.add_data([newdata_4, newdata_3, newdata_2, newdata_1])
alignment.align()
alignment.get_scaled_data()
mean_data = alignment.summarize_data()
# -------------------------------
# Initialize model
# -------------------------------
times = newdata_4.get_times('Alpha')
doses_alpha = newdata_4.get_doses('Alpha')
doses_beta = newdata_4.get_doses('Beta')
Mixed_Model = IfnModel('Mixed_IFN_ppCompatible')
Mixed_Model.set_parameters({
parameters={'Ia': 0}, return_type='dataframe', dataframe_labels='Beta',
scale_factor=scale_factor)
# Show SOCS effects
Mixed_Model.reset_parameters()
Mixed_Model.set_parameters({'kIntBasal_r1': 0, 'kIntBasal_r2': 0, 'kint_a': 0, 'kint_b': 0})
# Uncomment this line to tune IFN alpha internalization to match SOCS
#Mixed_Model.set_parameters({'kSOCS': Mixed_Model.parameters['kSOCS'] * 2.5})
dradf_rec = Mixed_Model.doseresponse(times, 'TotalpSTAT', 'Ia', list(logspace(-2, 8)),
parameters={'Ib': 0}, return_type='dataframe', dataframe_labels='Alpha',
scale_factor = scale_factor)
drbdf_rec = Mixed_Model.doseresponse(times, 'TotalpSTAT', 'Ib', list(logspace(-2, 8)),
parameters={'Ia': 0}, return_type='dataframe', dataframe_labels='Beta',
scale_factor=scale_factor)
dra60 = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
dra60_int = IfnData('custom', df=dradf_int, conditions={'Alpha': {'Ib': 0}})
drb60_int = IfnData('custom', df=drbdf_int, conditions={'Beta': {'Ia': 0}})
dra60_rec = IfnData('custom', df=dradf_rec, conditions={'Alpha': {'Ib': 0}})
drb60_rec = IfnData('custom', df=drbdf_rec, conditions={'Beta': {'Ia': 0}})
dr_plot = DoseresponsePlot((1, 1))
alpha_mask = []
beta_mask = []
# Add fits
for idx, t in enumerate([el for el in times]):
if t not in alpha_mask:
dr_plot.add_trajectory(dra60, t, 'plot', alpha_palette[5], (0, 0), 'Alpha', label='Alpha - No Feedback', linewidth=2.0)
dr_plot.add_trajectory(dra60_int, t, 'plot', '--', (0, 0), 'Alpha', color=alpha_palette[3],
label='Internalization only', linewidth=2.0, )
parameters={'Ib': 0},
sf=scale_factor,
**DR_KWARGS)
drb60 = DR_method(times,
'TotalpSTAT',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor,
**DR_KWARGS)
# ----------------------------------
# Get all data set EC50 time courses
# ----------------------------------
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
# 20190108
ec50_20190108 = newdata_1.get_ec50s()
# 20190119
ec50_20190119 = newdata_2.get_ec50s()
# 20190121
ec50_20190121 = newdata_3.get_ec50s()
# 20190214
ec50_20190214 = newdata_4.get_ec50s()
Mixed_Model.model_1.set_parameters({'R1': 12000.0, 'R2': 1511.1})
Mixed_Model.model_2.set_parameters(initial_parameters)
Mixed_Model.model_2.set_parameters(dual_parameters)
Mixed_Model.model_2.set_parameters({'R1': 6755.56, 'R2': 1511.2})
Mixed_Model.model_1.default_parameters = Mixed_Model.model_1.parameters
Mixed_Model.model_2.default_parameters = Mixed_Model.model_2.parameters
tspan = [2.5, 5.0, 7.5, 10.0, 20.0, 60.0]
alpha_doses = [10, 100, 300, 1000, 3000, 10000, 100000]
beta_doses = [0.2, 6, 20, 60, 200, 600, 2000]
# Load experimental data to which model will be fit.
# The "experimental data" is the TotalpSTAT trajectory for Alpha, then Beta, at each dose.
# Standard deviations are kept separate but match the same order.
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
alignment = DataAlignment()
alignment.add_data([newdata_4, newdata_3, newdata_2, newdata_1])
alignment.align()
alignment.get_scaled_data()
mean_data = alignment.summarize_data()
exp_data = np.array([[el[0] for el in dose]
for dose in mean_data.data_set.values]).flatten()
exp_data_std = np.array([[el[1] for el in dose]
for dose in mean_data.data_set.values]).flatten()
#Create scipy normal probability distributions for data likelihoods
from ifnclass.ifndata import IfnData
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import Trajectory, TimecoursePlot, DoseresponsePlot
from ifnclass.ifnfit import StepwiseFit
from numpy import linspace, logspace, log10, nan
import seaborn as sns
from smooth_B6_IFN import * # Imports smoothed data to fit to
import pickle
if __name__ == '__main__':
newdata = IfnData("20181113_B6_IFNs_Dose_Response_Bcells")
Mixed_Model = IfnModel('Mixed_IFN_ppCompatible')
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
# Stepwise fitting
# ----------------
# First fit the 2.5 minute data
stepfit25 = StepwiseFit(Mixed_Model, smooth5IfnData,
{'kpu': (0.001, 0.006), 'kd4': (0.03, 0.1), 'k_d4': (0.03, 0.1),
'R1': (3000, 4000), 'R2': (4000, 5000),
'ka1': (3.321e-14 * 0.5, 3.321e-14 * 2),
'ka2': (4.9817e-13 * 0.5, 4.9817e-13 * 2)}, n=2)
best_parameters, best_scale_factor = stepfit25.fit()
print("The fit for 5 minutes was:")
print(best_parameters)
print(best_scale_factor)
scale_data = lambda q: (best_scale_factor*q[0], best_scale_factor*q[1])
# Generate a figure of this fit
# First simulate continuous dose-response curve
from ifnclass.ifndata import IfnData, DataAlignment
from ifnclass.ifnmodel import IfnModel
from ifnclass.ifnplot import DoseresponsePlot, TimecoursePlot
import seaborn as sns
import numpy as np
import pandas as pd
from ifnclass.ifnfit import StepwiseFit
if __name__ == '__main__':
# ------------------------------
# Align all data
# ------------------------------
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
alignment = DataAlignment()
alignment.add_data([newdata_4, newdata_3, newdata_2, newdata_1])
alignment.align()
alignment.get_scaled_data()
mean_data = alignment.summarize_data()
# -------------------------------
# Initialize model
# -------------------------------
times = newdata_4.get_times('Alpha')
doses_alpha = newdata_4.get_doses('Alpha')
doses_beta = newdata_4.get_doses('Beta')
Mixed_Model = IfnModel('Mixed_IFN_ppCompatible')
Mixed_Model.set_parameters({
if __name__ == '__main__':
# ----------------------
# Set up figure layout
# ----------------------
spec_fig = DoseresponsePlot((3, 2))
spec_fig.fig.set_size_inches(12, 8)
# ---------------------------
# Set up data for comparison
# ---------------------------
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
data_palette = sns.color_palette("muted", 6)
marker_shape = ["o", "v", "s", "P", "d", "1", "x", "*"]
dataset_names = ["20190108", "20190119", "20190121", "20190214"]
newdata_1 = IfnData("20190108_pSTAT1_IFN_Bcell")
newdata_2 = IfnData("20190119_pSTAT1_IFN_Bcell")
newdata_3 = IfnData("20190121_pSTAT1_IFN_Bcell")
newdata_4 = IfnData("20190214_pSTAT1_IFN_Bcell")
# Aligned data, to get scale factors for each data set
alignment = DataAlignment()
alignment.add_data([newdata_4, newdata_3, newdata_2, newdata_1])
alignment.align()
alignment.get_scaled_data()
mean_data = alignment.summarize_data()
# --------------------
# Set up Model
# --------------------
# Parameters found by stepwise fitting GAB mean data
