def check_plots():
smooth_plot = DoseresponsePlot((2, 2))
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
smooth_plot.add_trajectory(a25smoothIfnData, 2.5, 'plot', alpha_palette[4],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(a60smoothIfnData, 60, 'plot', alpha_palette[5],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(a25smoothIfnData, 2.5, 'plot', alpha_palette[0],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(a5smoothIfnData, 5, 'plot', alpha_palette[1],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(a75smoothIfnData, 7.5, 'plot', alpha_palette[2],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(a10smoothIfnData, 10, 'plot', alpha_palette[3],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(a20smoothIfnData, 20, 'plot', alpha_palette[4],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(a60smoothIfnData, 60, 'plot', alpha_palette[5],
(1, 0), 'Alpha')
smooth_plot.add_trajectory(b25smoothIfnData, 2.5, 'plot', beta_palette[4],
(0, 1), 'Beta')
smooth_plot.add_trajectory(b60smoothIfnData, 60, 'plot', beta_palette[5],
(0, 1), 'Beta')
smooth_plot.add_trajectory(b25smoothIfnData, 2.5, 'plot', beta_palette[0],
(1, 1), 'Beta')
smooth_plot.add_trajectory(b5smoothIfnData, 5, 'plot', beta_palette[1],
(1, 1), 'Beta')
smooth_plot.add_trajectory(b75smoothIfnData, 7.5, 'plot', beta_palette[2],
(1, 1), 'Beta')
smooth_plot.add_trajectory(b10smoothIfnData, 10, 'plot', beta_palette[3],
(1, 1), 'Beta')
smooth_plot.add_trajectory(b20smoothIfnData, 20, 'plot', beta_palette[4],
(1, 1), 'Beta')
smooth_plot.add_trajectory(b60smoothIfnData, 60, 'plot', beta_palette[5],
(1, 1), 'Beta')
for idx, t in enumerate([2.5, 60]):
smooth_plot.add_trajectory(newdata,
t,
'scatter',
alpha_palette[idx * 2], (0, 0),
'Alpha',
dn=1)
smooth_plot.add_trajectory(newdata,
t,
'scatter',
beta_palette[idx * 2], (0, 1),
'Beta',
dn=1)
fig, axes = smooth_plot.show_figure()
def check_plots():
smooth_plot = DoseresponsePlot((1, 2))
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
smooth_plot.add_trajectory(a5smoothIfnData, 5, 'plot', alpha_palette[0],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(a15smoothIfnData, 15, 'plot', alpha_palette[1],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(a30smoothIfnData, 30, 'plot', alpha_palette[2],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(a60smoothIfnData, 60, 'plot', alpha_palette[3],
(0, 0), 'Alpha')
smooth_plot.add_trajectory(b5smoothIfnData, 5, 'plot', beta_palette[0],
(0, 1), 'Beta')
smooth_plot.add_trajectory(b15smoothIfnData, 15, 'plot', beta_palette[1],
(0, 1), 'Beta')
smooth_plot.add_trajectory(b30smoothIfnData, 30, 'plot', beta_palette[2],
(0, 1), 'Beta')
smooth_plot.add_trajectory(b60smoothIfnData, 60, 'plot', beta_palette[3],
(0, 1), 'Beta')
for idx, t in enumerate([5, 15, 30, 60]):
smooth_plot.add_trajectory(newdata,
t,
'scatter',
alpha_palette[idx], (0, 0),
'Alpha',
dn=1)
smooth_plot.add_trajectory(newdata,
t,
'scatter',
beta_palette[idx], (0, 1),
'Beta',
dn=1)
fig, axes = smooth_plot.show_figure()
# 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(dra2,
t,
'plot',
alpha_palette[idx], (2, 0),
'Alpha',
label='Alpha ' + t,
linewidth=2.0)
if t not in [str(el) for el in beta_mask]:
dose_response_plot.add_trajectory(drb2,
t,
'plot',
beta_palette[idx], (2, 1),
'Beta',
label='Beta ' + t,
linewidth=2.0)
dose_response_plot.axes[0][0].set_title(r"IFN$\alpha$")
dose_response_plot.axes[0][1].set_title(r"IFN$\beta$")
dose_response_plot.axes[1][0].set_title(r"Double Internalization Rate")
dose_response_plot.axes[1][1].set_title(r"Double Internalization Rate")
dose_response_plot.axes[2][0].set_title(r"0.01 x R1 Recycling")
dose_response_plot.axes[2][1].set_title(r"0.01 x R1 Recycling")
dose_response_plot.show_figure(save_flag=False, save_dir='results')
def plot_posterior(param_file, parameter_names, num_checks, model, posterior,
sf, time_mask, save_dir, plot_data=True):
""" Plot the predictions from ensemble sampling of model parameters.
Plots the dose-response as an envelope containing 1 sigma of predictions.
"""
# Preparation of parameter ensemble
if type(param_file) == str:
log10_parameters = np.load(param_file)
elif type(param_file) == list:
log10_parameters = np.load(param_file[0])
for f in param_file[1:]:
batch_params = np.load(f)
log10_parameters = np.append(log10_parameters, batch_params,
axis=0)
parameters = np.power(10, log10_parameters)
parameters_to_check = [parameters[i] for i in
list(np.random.randint(0, high=len(parameters),
size=num_checks))]
# Compute posterior sample trajectories
posterior_trajectories = []
for p in parameters_to_check:
param_dict = {key: value for key, value in zip(parameter_names, p)}
pp = posterior_prediction(model, param_dict, parameter_names, sf)
posterior_trajectories.append(pp)
# Make aggregate predicitions
mean_alpha, std_alpha, mean_beta, std_beta = \
posterior_IFN_summary_statistics(posterior_trajectories)
std_predictions = {'Alpha': std_alpha,
'Beta': std_beta}
mean_predictions = {'Alpha': mean_alpha,
'Beta': mean_beta}
mean_model = copy.deepcopy(posterior_trajectories[0])
for s in ['Alpha', 'Beta']:
for didx, d in enumerate(mean_model.get_doses()[s]):
for tidx, t in enumerate(mean_model.get_times()[s]):
mean_model.data_set.loc[s][str(t)].loc[d] =\
(mean_predictions[s][didx][tidx],
std_predictions[s][didx][tidx])
# Get aligned data
mean_data = posterior.experiment
# Plot posterior samples
alpha_palette = sns.color_palette("rocket_r", 6)
beta_palette = sns.color_palette("rocket_r", 6)
new_fit = DoseresponsePlot((1, 2))
# Add fits
for idx, t in enumerate([2.5, 5.0, 7.5, 10.0, 20.0, 60.0]):
if t not in time_mask:
new_fit.add_trajectory(mean_model, t, 'envelope',
alpha_palette[idx], (0, 0), 'Alpha',
label='{} min'.format(t),
linewidth=2, alpha=0.2)
if plot_data:
new_fit.add_trajectory(mean_data, t, 'errorbar', 'o',
(0, 0), 'Alpha',
color=alpha_palette[idx])
if t not in time_mask:
new_fit.add_trajectory(mean_model, t, 'envelope',
beta_palette[idx], (0, 1), 'Beta',
label='{} min'.format(t),
linewidth=2, alpha=0.2)
if plot_data:
new_fit.add_trajectory(mean_data, t, 'errorbar', 'o',
(0, 1), 'Beta',
color=beta_palette[idx])
# Change legend transparency
leg = new_fit.fig.legend()
for lh in leg.legendHandles:
lh._legmarker.set_alpha(1)
dr_fig, dr_axes = new_fit.show_figure()
dr_fig.set_size_inches(14, 6)
dr_axes[0].set_title(r'IFN$\alpha$')
dr_axes[1].set_title(r'IFN$\beta$')
if plot_data:
dr_fig.savefig(os.path.join(save_dir,
'posterior_predictions_with_data.pdf'))
else:
dr_fig.savefig(os.path.join(save_dir,
'posterior_predictions.pdf'))
60,
'errorbar',
'o', (0, 0),
'EMP_33',
label='EMP-33',
color=palette[6])
# Add fits
Epo_plot.add_trajectory(dr_Epo,
60.0,
'plot',
palette[1], (0, 0),
'Epo_IC',
label='EPO Model',
linewidth=2)
Epo_plot.axes.set_title('Response at 60 min')
Epo_plot.show_figure()
# --------------------------------
# Fit model to data
# --------------------------------
niterations = 10000
nchains = 5
burn_factor = 0.5
sim_name = 'Epo'
fit_flag = False
if fit_flag == True:
# Make save directory
today = datetime.now()
save_dir = "PyDREAM_" + today.strftime('%d-%m-%Y') + "_" + str(
niterations)
ec50_axes[1].set_title(r"EC50 vs Time for IFN$\beta$")
ec50_axes[0].set_ylabel("EC50 (pM)")
ec50_axes[0].set_yscale('log')
ec50_axes[1].set_yscale('log')
# Add data
line_style_idx = 0
line_styles = ['-', '--']
labels = ['Small cells', 'Large cells']
#for ec50 in [small_ec50, large_ec50]:
# ec50_axes[0].errorbar([el[0] for el in ec50['Alpha']], [el[1] for el in ec50['Alpha']],
# fmt=line_styles[line_style_idx], color=data_palette[3], label=labels[line_style_idx])
# ec50_axes[1].errorbar([el[0] for el in ec50['Beta']], [el[1] for el in ec50['Beta']],
# fmt=line_styles[line_style_idx], color=data_palette[2], label=labels[line_style_idx])
# line_style_idx += 1
for ec50 in [small_ec50, large_ec50]:
ec50_axes[0].errorbar([el[0] for el in ec50['Alpha']],
[el[1] for el in ec50['Alpha']],
yerr=[el[2] for el in ec50['Alpha']],
fmt=line_styles[line_style_idx],
color=data_palette[3],
label=labels[line_style_idx])
ec50_axes[1].errorbar([el[0] for el in ec50['Beta']],
[el[1] for el in ec50['Beta']],
yerr=[el[2] for el in ec50['Beta']],
fmt=line_styles[line_style_idx],
color=data_palette[2],
label=labels[line_style_idx])
line_style_idx += 1
plt.figure(Figure_3.number)
new_fit.show_figure()
label='Beta ' + str(t))
#data_plot_dr.add_trajectory(olddata, t, 'scatter', beta_palette_old[idx], (0, 1), 'Beta', dn=1)
#data_plot_dr.add_trajectory(olddata, t, 'plot', '--', (0, 1), 'Beta', dn=1, color=beta_palette_old[idx], label='Beta ' + str(t))
#data_plot_dr.axes[0][0].set_title(r"IFN$\alpha$ old data")
#data_plot_dr.axes[0][1].set_title(r"IFN$\beta$ old data")
data_plot_dr.axes[0][0].set_title(r"IFN$\alpha$ 2019-01-08 data")
data_plot_dr.axes[0][1].set_title(r"IFN$\beta$ 2019-01-08 data")
data_plot_dr.axes[1][0].set_title(r"IFN$\alpha$ 2019-01-19 data")
data_plot_dr.axes[1][1].set_title(r"IFN$\beta$ 2019-01-19 data")
data_plot_dr.axes[2][0].set_title(r"IFN$\alpha$ 2019-01-21 data")
data_plot_dr.axes[2][1].set_title(r"IFN$\beta$ 2019-01-21 data")
data_plot_dr.axes[3][0].set_title(r"IFN$\alpha$ 2019-02-14 data")
data_plot_dr.axes[3][1].set_title(r"IFN$\beta$ 2019-02-14 data")
dr_fig, dr_axes = data_plot_dr.show_figure(save_flag=False)
dr_fig.set_size_inches(10.5, 28.5)
dr_fig.savefig('results/GAB_NewData/compare_data_dr.pdf')
# -------------------------
# Time courses
# -------------------------
alpha_palette_new = sns.color_palette("Reds", 8)
beta_palette_new = sns.color_palette("Greens", 8)
alpha_palette_old = sns.color_palette("Reds", 8)
beta_palette_old = sns.color_palette("Greens", 8)
data_plot_tc = TimecoursePlot((4, 2))
alpha_mask = [0]
beta_mask = [0]
# Add data
'plot',
beta_palette[idx], (2, 1),
'Beta',
label='Beta ' + str(t),
linewidth=2.0)
dr_plot.axes[0][0].set_title(r"Baseline")
dr_plot.axes[0][1].set_title(r"Baseline")
dr_plot.axes[1][0].set_title(
r"Internalization Rate Increased by {}".format(internalization_sf))
dr_plot.axes[1][1].set_title(
r"Internalization Rate Increased by {}".format(internalization_sf))
dr_plot.axes[2][0].set_title(r"R2 Recycling Rate x {}".format(recycle_sf))
dr_plot.axes[2][1].set_title(r"R2 Recycling Rate x {}".format(recycle_sf))
dr_plot.show_figure(save_flag=False)
# ----------------------------------
# Time course plot
# ----------------------------------
Mixed_Model.reset_parameters()
Mixed_Model.set_parameters({
'R2': 2300 * 2.5,
'R1': 1800 * 1.8,
'k_d4': 0.06,
'kint_b': 0.0003,
'kpu': 0.0028,
'krec_b1': 0.001,
'krec_b2': 0.01,
'k_a1': 4.98E-14,
'k_a2': 8.30e-13 * 4,
response = IfnData('custom',
df=Mixed_Model.mixed_dose_response(
times,
'TotalpSTAT',
'Ib',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor),
conditions={'Beta': {
'Ia': 0
}})
for idx, t in enumerate(times):
new_fit.add_trajectory(response,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label='',
linewidth=1,
alpha=0.2)
subpop.set_parameters({p: subpop.parameters[p] * 1.0 / 0.8})
# Aesthetics
new_fit.axes[0].set_title(r'IFN$\alpha$')
new_fit.axes[1].set_title(r'IFN$\beta$')
for ax in new_fit.axes:
ax.set_ylim((0, 6000))
new_fit.show_figure(save_flag=True,
save_dir=os.path.join(os.getcwd(), 'results',
'kimmel_sensitivity.pdf'))
new_fit.add_trajectory(Sagar_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=alpha_palette[idx])
if t not in beta_mask:
new_fit.add_trajectory(Sagar_data,
t,
'errorbar',
'o', (0, 1),
'Beta',
color=beta_palette[idx])
new_fit.show_figure(save_flag=True,
save_dir=os.path.join(os.getcwd(), 'results',
'Figures', 'Figure_S3',
'Figure_S3.pdf'))
exit()
# ----------------------------------
# Time course plot
# ----------------------------------
# Simulate time courses
alpha_time_courses = []
for d in [10, 90, 600, 4000, 8000]: #[10, 90, 600, 4000, 8000]:
alpha_time_courses.append(
Mixed_Model.timecourse(list(linspace(0, 60, 30)),
'TotalpSTAT', {
'Ia': d * 6.022E23 * 1E-5 * 1E-12,
'Ib': 0
},
return_type='dataframe',
color=alpha_palette[idx])
if t not in beta_mask:
DRplot.add_trajectory(drb60,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label=str(t) + ' min',
linewidth=2)
DRplot.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 1),
'Beta',
color=beta_palette[idx])
DRplot.show_figure()
# -----------------------------
# Now generate new predictions
# -----------------------------
original_parameters = IFN_Model.parameters
ImmGen_label_maps = {
'R1': 'Ifngr1',
'R2': 'Ifngr2',
'S': 'Stat1',
'Initial_SOCS': 'Socs1'
}
# Macrophages
Macrophage_parameters = get_relative_parameters('MF.RP.Sp', 'B.Fo.Sp',
'IFNgamma',
label='15 min')
fig.add_trajectory(SOCS_IFNg_pSTAT3_df,
30,
'plot',
'r', (1, 1),
'IFNgamma',
label='30 min')
fig.add_trajectory(SOCS_IFNg_pSTAT3_df,
60,
'plot',
'r', (1, 1),
'IFNgamma',
label='60 min')
fig.show_figure()
def plot_ec50():
# IFN gamma
fig, ax = plt.subplots(nrows=2, ncols=2)
ax[0][0].set_title('pSTAT1')
ax[0][1].set_title('pSTAT3')
ax[0][0].set_ylabel('EC50 (pM)')
ax[1][0].set_ylabel('Max response (# molec.)')
ax[1][0].set_xlabel('SOCS (# molec.)')
ax[1][1].set_xlabel('SOCS (# molec.)')
colour_palette = sns.color_palette("dark", 6)
for sidx, s in enumerate(np.linspace(0, 2000, num=15)):
for ax_idx, spec in enumerate(dataset.get_dose_species()):
for idx, t in enumerate(
alignment.scaled_data[0].get_times()[spec]):
spec_data = pd.concat([dataset.data_set.loc[spec]],
keys=[spec],
names=['Dose_Species'])
spec_IfnData = IfnData('custom',
df=spec_data,
conditions=dataset.conditions)
dr_plot.add_trajectory(spec_IfnData,
t,
'plot',
colour_palette[0], (idx, ax_idx),
spec,
label=dataset.name[0:8])
dr_fig, dr_axes = dr_plot.show_figure(save_flag=False)
dr_fig.set_size_inches(10.5, 7.1 * num_times)
dr_fig.savefig('results/GAB_NewData/align_dr.pdf')
# -------------------------------
# Plot alignment of Time Course
# -------------------------------
species = alignment.scaled_data[0].get_dose_species()
# Make subtitles
recorded_doses = alignment.scaled_data[0].get_doses()
num_doses = len(recorded_doses[species[0]])
titles = [species[0], species[1]]
titles[0] += "\r\n\r\n{} pM".format(recorded_doses[species[0]][0])
titles[1] += "\r\n\r\n{} pM".format(recorded_doses[species[1]][0])
for d in range(1, num_doses):
for s in species:
# Make dose-response plot
# ---------------------------------
colour_palette = sns.color_palette("rocket_r", 6)
DR_plot = DoseresponsePlot(
(1, 1)) # shape=(1,1) since we only want 1 panel
# Add simulations and data to the DoseresponsePlot
for idx, t in enumerate([2.5, 10.0, 20.0, 60.0]):
DR_plot.add_trajectory(
DR_Simulation,
t, # the time slice being added
'plot', # controls the line type
colour_palette[idx],
(
0, 0
), # the row and column index for the panel; useful when making multi-panel plots
'Alpha', # the dose species, required to index the Pandas dataframe
label=str(t) + ' min', # used to generate a legend
linewidth=2)
DR_plot.add_trajectory(
mean_data,
t,
'errorbar', # the line type will be points with error bars
'o', # the marker shape to use for the mean response
(0, 0), # plot on the same panel as the simulation
'Alpha',
color=colour_palette[idx])
dr_fig, dr_axes = DR_plot.show_figure()
t,
PLOT_KWARGS['line_type'],
beta_palette[idx], (0, 1),
'Beta',
label=str(t) + ' min',
linewidth=2,
alpha=PLOT_KWARGS['alpha'])
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 1),
'Beta',
color=beta_palette[idx])
plt.figure(Figure_2.number)
dr_fig, dr_axes = new_fit.show_figure(show_flag=False)
# Format Figure_2
# Dose response aesthetics
for ax in Figure_2.axes[4:6]:
ax.set_ylim((0, 5000))
Figure_2.axes[4].set_title(r'IFN$\alpha$2')
Figure_2.axes[5].set_title(r'IFN$\beta$')
for direction in ['top', 'right']:
Figure_2.axes[4].spines[direction].set_visible(False)
Figure_2.axes[5].spines[direction].set_visible(False)
# max pSTAT aesthetics
for ax in Figure_2.axes[2:4]:
ax.set_ylim([1500, 5500])
print(best_parameters)
print(best_scale_factor60)
dra60df = stepfit60.model.doseresponse([5, 10, 20, 60], 'TotalpSTAT', 'Ia', list(logspace(-3, 5)),
parameters={'Ib': 0}, return_type='dataframe', dataframe_labels='Alpha')
drb60df = stepfit60.model.doseresponse([5, 10, 20, 60], 'TotalpSTAT', 'Ib', list(logspace(-3, 4)),
parameters={'Ia': 0}, return_type='dataframe', dataframe_labels='Beta')
with open('dra60df.p','wb') as f:
pickle.dump(dra60df,f,2)
with open('drb60df.p','wb') as f:
pickle.dump(drb60df,f,2)
for i in range(4):
dra60df.loc['Alpha'].iloc[:, i] = dra60df.loc['Alpha'].iloc[:, i].apply(scale_data)
drb60df.loc['Beta'].iloc[:, i] = drb60df.loc['Beta'].iloc[:, i].apply(scale_data)
dra60 = IfnData('custom', df=dra60df, conditions={'Alpha': {'Ib': 0}})
drb60 = IfnData('custom', df=drb60df, conditions={'Beta': {'Ia': 0}})
results_plot2 = DoseresponsePlot((1, 2))
# Add fits
for idx, t in enumerate(['5', '10', '20', '60']):
results_plot2.add_trajectory(dra60, t, 'plot', alpha_palette[idx], (0, 0), 'Alpha')
results_plot2.add_trajectory(drb60, t, 'plot', beta_palette[idx], (0,1), 'Beta')
# Add data
for idx, t in enumerate([5, 10, 20, 60]):
results_plot2.add_trajectory(newdata, t, 'scatter', alpha_palette[idx], (0, 0), 'Alpha', dn=1)
results_plot2.add_trajectory(newdata, t, 'scatter', beta_palette[idx], (0, 1), 'Beta', dn=1)
results_plot2.show_figure(save_flag=True)
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')
large_alignment = DataAlignment()
large_alignment.add_data([large_4, large_3, large_2, large_1])
large_alignment.align()
large_alignment.get_scaled_data()
mean_large_data = large_alignment.summarize_data()
# ------------
# Plot data
# ------------
alpha_palette = sns.color_palette("deep", 6)
beta_palette = sns.color_palette("deep", 6)
dr_plot = DoseresponsePlot((2, 2))
for r_idx, cell_size in enumerate([mean_small_data, mean_large_data]):
for c_idx, species in enumerate(['Alpha', 'Beta']):
for t_idx, time in enumerate(cell_size.get_times()[species]):
if species == 'Alpha':
c = alpha_palette[t_idx]
else:
c = beta_palette[t_idx]
dr_plot.add_trajectory(cell_size, time, 'errorbar', 'o--', (r_idx, c_idx), species,
label=str(time)+" min", color=c)
dr_plot.axes[0][0].set_title(r'IFN$\alpha$')
dr_plot.axes[0][0].set_ylabel('Small cell response')
dr_plot.axes[0][1].set_title(r'IFN$\beta$')
dr_plot.axes[1][0].set_ylabel('Large cell response')
for ax in [item for sublist in dr_plot.axes for item in sublist]:
ax.set_ylim(top=6000)
dr_plot.show_figure()
label=str(t) + ' min', linewidth=2)
spec_fig.axes[1][0].set_title(r'$\frac{\mathrm{IFN}\beta \mathrm{\, response}}{\mathrm{IFN}\alpha \mathrm{\, response}}$')
# -----------------------
# Plot difference vs time
# -----------------------
for idx, t in enumerate(times):
if t not in alpha_mask:
spec_fig.add_trajectory(difference_response, t, 'plot', alpha_palette[idx], (1, 1), 'Difference',
label=str(t) + ' min', linewidth=2)
spec_fig.axes[1][1].set_title(r'$\mathrm{IFN}\beta \mathrm{\, response} - \mathrm{IFN}\alpha \mathrm{\, response}$')
# -----------------------
# Plot integral vs time
# -----------------------
t = integral_times[-1]
spec_fig.add_trajectory(integral_response, t, 'plot', alpha_palette[3], (2, 0), 'Alpha_Integral',
label=r'$\mathrm{IFN}\alpha$ 60 min', linewidth=2)
spec_fig.add_trajectory(integral_response, t, 'plot', beta_palette[2], (2, 0), 'Beta_Integral',
label=r'$\mathrm{IFN}\beta$ 60 min', linewidth=2)
spec_fig.axes[2][0].set_ylabel(r'$\int \mathrm{pSTAT}[t] dt$')
# save figure
if platform == "linux" or platform == "linux2":
spec_fig.show_figure(save_flag=True,
save_dir=os.path.join(os.getcwd(), 'results', 'Figures', 'Pure_Theory', 'Alpha_vs_Beta_response.pdf'))
else: # Windows
spec_fig.show_figure(save_flag=True,
save_dir=os.path.join(os.getcwd(), 'results', 'Figures', 'Pure Theory', 'Alpha_vs_Beta_response.pdf'))
new_fit = DoseresponsePlot((1, 2))
new_fit.fig = fig
new_fit.axes = [panelA, panelB, legend_panel]
alpha_palette = sns.color_palette("rocket_r", 6)
beta_palette = sns.color_palette("rocket_r", 6)
t_mask = [2.5, 7.5, 20.]
# Add fits
for idx, t in enumerate(times):
if t not in t_mask:
new_fit.add_trajectory(dra_s, t, 'plot', alpha_palette[idx], (0, 0), 'Alpha', linewidth=2.0)
new_fit.add_trajectory(dra_d, t, 'plot', '--', (0, 0), 'Alpha', color=alpha_palette[idx], linewidth=2.0)
new_fit.add_trajectory(drb_s, t, 'plot', beta_palette[idx], (0, 1), 'Beta', linewidth=2.0)
new_fit.add_trajectory(drb_d, t, 'plot', '--', (0, 1), 'Beta', color=beta_palette[idx], linewidth=2.0)
new_fit.show_figure(show_flag=False, save_flag=False)
# formatting and legend
for ax in [panelA, panelB]:
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.get_legend().remove()
ax.set_ylim([1, 5000])
panelB.set_ylabel('')
panelA.plot([], [], 'k', label='Simple Model', linewidth=2.0)
panelA.plot([], [], 'k--', label='Detailed Model', linewidth=2.0)
for idx, t in enumerate(times):
if t not in t_mask:
panelA.scatter([], [], color=alpha_palette[idx], label='{} min'.format(t), s=30)
panelA.legend()
handles, labels = panelA.get_legend_handles_labels() # get labels and handles
beta_palette[idx], (0, 1),
'Beta',
label='{} min'.format(t),
linewidth=2,
alpha=0.2)
if plot_data == True:
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 1),
'Beta',
color=beta_palette[idx])
# Change legend transparency
leg = new_fit.fig.legend()
for lh in leg.legendHandles:
lh._legmarker.set_alpha(1)
dr_fig, dr_axes = new_fit.show_figure()
dr_fig.set_size_inches(14, 6)
dr_axes[0].set_title(r'IFN$\alpha$')
dr_axes[1].set_title(r'IFN$\beta$')
if plot_data == True:
dr_fig.savefig(
os.path.join(os.getcwd(), output_dir,
'posterior_predictions_with_data.pdf'))
else:
dr_fig.savefig(
os.path.join(os.getcwd(), output_dir, 'posterior_predictions.pdf'))
for idx, t in enumerate(newdata_4.get_times('Alpha')):
dr_plot.add_trajectory(dra60,
t,
'plot',
alpha_model_palette[0], (idx, 0),
'Alpha',
label='Alpha model ' + str(t))
for idx, t in enumerate(newdata_4.get_times('Beta')):
dr_plot.add_trajectory(drb60,
t,
'plot',
beta_model_palette[0], (idx, 1),
'Beta',
label='Beta model ' + str(t))
dr_fig, dr_axes = dr_plot.show_figure(save_flag=False)
dr_fig.set_size_inches(10.5, 7.1 * 6)
dr_fig.savefig('results/GAB_NewData/fit_mean_data.pdf')
# -------------------------------
# Plot dose response paper figure
# -------------------------------
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
dr_plot_mean_fit = DoseresponsePlot((1, 2))
alpha_mask = [7.5]
beta_mask = [7.5]
# Add fits
for idx, t in enumerate(times):
if t not in alpha_mask:
fontsize=16)
ax = dr_fig.axes[1]
ax.errorbar(mean_window_values,
mean_response,
xerr=x_variances,
yerr=y_variances,
fmt='o--',
color=alpha_palette[-1],
alpha=0.75)
ax.set_xlabel('Mean FSC')
ax.set_ylabel('Mean MFI')
ax.set_title('pSTAT1 MFI vs FSC')
ax.set_xscale('linear')
dr_fig.show_figure()
"""
# Convert to multiindex
small_df.set_index(['Dose_Species', 'Dose (pM)'], inplace=True)
small_df = pd.pivot_table(small_df, values='pSTAT', index=['Dose_Species', 'Dose (pM)'], columns=['time'],
aggfunc=np.sum)
small_df.columns.name = None
large_df.set_index(['Dose_Species', 'Dose (pM)'], inplace=True)
large_df = pd.pivot_table(large_df, values='pSTAT', index=['Dose_Species', 'Dose (pM)'], columns=['time'],
aggfunc=np.sum)
large_df.columns.name = None
# Drop zero dose data
#small_df = small_df.drop(index=0.0, level=1)
#large_df = large_df.drop(index=0.0, level=1)
