# -------------------------
# Plot the results
# -------------------------
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
new_fit = DoseresponsePlot((1, 2))
alpha_mask = [0.0, 7.5]
beta_mask = [0.0, 7.5]
# Add fits
for idx, t in enumerate(times):
if t not in alpha_mask:
new_fit.add_trajectory(total_response,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label='Alpha ' + str(t))
if t not in beta_mask:
new_fit.add_trajectory(total_response,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label='Beta ' + str(t))
# Add data
times = [2.5, 5.0, 7.5, 10.0, 20.0, 60.0]
for idx, t in enumerate(times):
if t not in alpha_mask:
new_fit.add_trajectory(mean_data,
ax.set(xscale='log', yscale='linear')
ax.set_xlabel('Dose (pM)')
ax.set_ylabel('Response')
legend_panel = fig.add_subplot(gs[0, 4])
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)
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,
t,
'scatter',
alpha_palette_new[idx], (3, 0),
'Alpha',
dn=1)
data_plot_dr.add_trajectory(newdata_4,
t,
'plot',
'--', (3, 0),
'Alpha',
dn=1,
color=alpha_palette_new[idx],
label='Alpha ' + str(t))
data_plot_dr.add_trajectory(newdata_3,
t,
'scatter',
alpha_palette_new[idx], (2, 0),
'Alpha',
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
new_fit = DoseresponsePlot((3, 1))
new_fit.axes[0].set_title("{} minutes".format(times[0]))
new_fit.axes[0].set_xlabel("")
new_fit.axes[1].set_title("{} minutes".format(times[1]))
new_fit.axes[1].set_xlabel("")
new_fit.axes[2].set_title("{} minutes".format(times[2]))
new_fit.axes[2].set_xlabel("Dose (pM)")
new_fit.fig.set_size_inches(8.5, 25.5)
alpha_mask = []
beta_mask = []
# Add fits
for idx, t in enumerate([el for el in times]):
if t not in alpha_mask:
new_fit.add_trajectory(dra60,
t,
'plot',
alpha_palette[2], (idx, 0),
'Alpha',
label='Alpha')
if t not in beta_mask:
new_fit.add_trajectory(drb60,
t,
'plot',
beta_palette[2], (idx, 0),
'Beta',
label='Beta')
new_fit.show_figure(save_flag=False)
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()
# Plot model dose response curves
# -------------------------------
alpha_palette = sns.color_palette("rocket_r")
beta_palette = sns.color_palette("rocket_r")
new_fit = DoseresponsePlot((1, 2))
new_fit.axes[0].set_ylabel('pSTAT1 (MFI)')
new_fit.axes[1].set_ylabel('pSTAT1 (MFI)')
alpha_mask = [7.5, 10.0]
beta_mask = [7.5, 10.0]
# Add fits
for idx, t in enumerate([2.5, 5.0, 7.5, 10.0, 20.0, 60.0]):
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=alpha_palette[idx])
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 1),
'Beta',
color=beta_palette[idx],
label=str(t) + ' min')
dr_fig, dr_axes = new_fit.show_figure(show_flag=False)
# Format Figure_2
# Dose response aesthetics
for ax in dr_axes:
drb25df = stepfit25.model.doseresponse([5, 10, 20, 60], 'TotalpSTAT', 'Ib', list(logspace(-3, 4)),
parameters={'Ia': 0}, return_type='dataframe', dataframe_labels='Beta')
# Scale by best fit scale factor, so comparison to data is good
for i in range(4):
dra25df.loc['Alpha'].iloc[:, i] = dra25df.loc['Alpha'].iloc[:, i].apply(scale_data)
drb25df.loc['Beta'].iloc[:, i] = drb25df.loc['Beta'].iloc[:, i].apply(scale_data)
# Make the DR curves into IfnData objects, for easy plotting
dra25 = IfnData('custom', df=dra25df, conditions={'Alpha': {'Ib': 0}})
drb25 = IfnData('custom', df=drb25df, conditions={'Beta': {'Ia': 0}})
# Generate figure by adding simulations, then data
results_plot = DoseresponsePlot((1, 2))
for idx, t in enumerate(['5', '10', '20', '60']):
results_plot.add_trajectory(dra25, t, 'plot', alpha_palette[idx], (0, 0), 'Alpha')
results_plot.add_trajectory(drb25, t, 'plot', beta_palette[idx], (0,1), 'Beta')
for idx, t in enumerate([5, 10, 20, 60]):
results_plot.add_trajectory(newdata, t, 'scatter', alpha_palette[idx], (0, 0), 'Alpha', dn=1)
results_plot.add_trajectory(newdata, t, 'scatter', beta_palette[idx], (0, 1), 'Beta', dn=1)
results_plot.save_figure()
# Now try to fit the 60 minute data starting from the 2.5 minute results
# ----------------------------------------------------------------------
stepfit60 = StepwiseFit(stepfit25.model, smooth60IfnData,
{'kSOCSon': (1E-8, 1E-7), 'kd4': (0.03, 0.1), 'k_d4': (0.03, 0.1),
'krec_a2': (0.0005, 0.05), 'krec_b2': (0.01, 0.0001),
'krec_a1': (0.00003, 0.003), 'krec_b1': (0.001, 0.00001)}, n=2)
best_parameters, best_scale_factor60 = stepfit60.fit()
scale_data = lambda q: (best_scale_factor60*q[0], best_scale_factor60*q[1])
'R1': 1200,
'R2': 4920},
return_type='dataframe', dataframe_labels='Alpha',
scale_factor=scale_factor * 0.2)
large_cells_beta = Mixed_Model.doseresponse(times, 'TotalpSTAT', 'Ib',
list(np.logspace(np.log10(doses_beta[0]), np.log10(doses_beta[-1]))),
parameters={'Ia': 0,
'R1': 1200,
'R2': 4920},
return_type='dataframe', dataframe_labels='Beta',
scale_factor=scale_factor * 0.2)
large_cells_alpha_IFNdata = IfnData('custom', df=large_cells_alpha, conditions={'Alpha': {'Ib': 0}})
large_cells_beta_IFNdata = IfnData('custom', df=large_cells_beta, conditions={'Beta': {'Ia': 0}})
# Plot
alpha_palette = sns.color_palette("Reds", 6)
beta_palette = sns.color_palette("Greens", 6)
dr_plot = DoseresponsePlot((1, 2))
# Add fits
dr_plot.add_trajectory(large_cells_alpha_IFNdata, 60.0, 'plot', alpha_palette[5], (0, 0), 'Alpha',
label='Large Cells at 60 minutes')
dr_plot.add_trajectory(small_cells_alpha_IFNdata, 60.0, 'plot', alpha_palette[2], (0, 0), 'Alpha',
label='Small Cells at 60 minutes')
dr_plot.add_trajectory(large_cells_beta_IFNdata, 60.0, 'plot', beta_palette[5], (0, 1), 'Beta',
label='Large Cells at 60 minutes')
dr_plot.add_trajectory(small_cells_beta_IFNdata, 60.0, 'plot', beta_palette[2], (0, 1), 'Beta',
label='Small Cells at 60 minutes')
dr_fig, dr_axes = dr_plot.show_figure(save_flag=False)
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')
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# ------------------------
# Plot
# ------------------------
alpha_mask = [2.5, 5.0, 7.5, 10.0]
beta_mask = [2.5, 5.0, 7.5, 10.0]
plot_original_fit = False
if plot_original_fit == True:
DRplot = DoseresponsePlot((1, 2))
for idx, t in enumerate(times):
if t not in alpha_mask:
DRplot.add_trajectory(dra60,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label=str(t) + ' min',
linewidth=2)
DRplot.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=alpha_palette[idx])
if t not in beta_mask:
DRplot.add_trajectory(drb60,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
list(logspace(-1, 4)),
parameters={'Ia': 0},
sf=scale_factor)
dra60 = IfnData('custom', df=dradf, conditions={'Alpha': {'Ib': 0}})
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# Plot primary predictions
alpha_palette = sns.color_palette("deep", 6)
beta_palette = sns.color_palette("deep", 6)
new_fit = DoseresponsePlot((1, 2))
for idx, t in enumerate(times):
new_fit.add_trajectory(dra60,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label=str(t) + ' min',
linewidth=2)
new_fit.add_trajectory(drb60,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label=str(t) + ' min',
linewidth=2)
# Vary parameters 20%
for subpop_idx, subpop in enumerate(
[Mixed_Model.model_1, Mixed_Model.model_2]):
test_keys = OrderedDict([('R1', 12000.0), ('R2', 1511.1), ('S', 10000),
IFNg_doses,
parameters={
'IFNAR1_IC': 0,
'IFNAR2_IC': 0,
'IFN_alpha2_IC': 0,
'IFN_beta_IC': 0,
'SOCS2_IC': 200
},
return_type='dataframe',
dataframe_labels='IFNgamma')
SOCS_IFNg_pSTAT1_df = IfnData(name='custom', df=IFNg_SOCS_res.xs(['pSTAT1']))
SOCS_IFNg_pSTAT3_df = IfnData(name='custom', df=IFNg_SOCS_res.xs(['pSTAT3']))
fig.add_trajectory(naive_IFNg_pSTAT1_df,
15,
'plot',
'r', (0, 0),
'IFNgamma',
label='15 min')
fig.add_trajectory(naive_IFNg_pSTAT1_df,
30,
'plot',
'r', (0, 0),
'IFNgamma',
label='30 min')
fig.add_trajectory(naive_IFNg_pSTAT1_df,
60,
'plot',
'r', (0, 0),
'IFNgamma',
label='60 min')
'IFN_beta_IC': 0
},
return_type='dataframe',
dataframe_labels='IFNgamma')
pSTAT1_df = IfnData(name='custom', df=model_res.xs(['pSTAT1']))
pSTAT3_df = IfnData(name='custom', df=model_res.xs(['pSTAT3']))
STAT1_palette = sns.color_palette("cubehelix", 6)
STAT3_palette = sns.color_palette("cubehelix", 6)
fig = DoseresponsePlot((1, 2))
fig.axes[0].set_title('pSTAT1')
fig.axes[1].set_title('pSTAT3')
for idx, t in enumerate(times):
fig.add_trajectory(pSTAT1_df,
t,
'plot',
STAT1_palette[idx], (0, 0),
'IFNgamma',
label=str(t) + ' min',
linewidth=2)
fig.add_trajectory(pSTAT3_df,
t,
'plot',
STAT3_palette[idx], (0, 1),
'IFNgamma',
label=str(t) + ' min',
linewidth=2)
fig.show_figure()
# Add fits
for d_idx, dataset in enumerate(alignment.scaled_data):
colour_palette = sns.color_palette(clist[d_idx], 1)
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])
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'))
'kint_b': 0
})
dra60_SOCS, drb60_SOCS = aggregate_response(Mixed_Model, DR_method,
MODEL_TYPE, R_samples)
# --------------------
# Make Plot
# --------------------
dr_plot = DoseresponsePlot((1, 1))
alpha_mask = []
beta_mask = []
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',
linewidth=2.0)
dr_plot.add_trajectory(dra60_int,
t,
'plot',
'--', (0, 0),
'Alpha',
color=alpha_palette[5],
linewidth=2.0)
dr_plot.add_trajectory(dra60_SOCS,
t,
'plot',
':', (0, 0),
'Alpha',
color=alpha_palette[5],
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)
if t not in [str(el) for el in beta_mask]:
dose_response_plot.add_trajectory(drb,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label='Beta ' + t,
linewidth=2.0)
# ----------------------------------------------
# Now symmetrically double internalization rates
# ----------------------------------------------
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()
new_fit.axes[0].set_xlabel('Dose (pM)')
new_fit.axes[0].set_ylabel('pSTAT (MFI)')
new_fit.axes[1].set_xscale('log')
new_fit.axes[1].set_xlabel('Dose (pM)')
new_fit.axes[1].set_ylabel('pSTAT (MFI)')
new_fit.fig = Figure_2
alpha_mask = [7.5, 10.0]
beta_mask = [7.5, 10.0]
# Add fits
for idx, t in enumerate(times):
if t not in alpha_mask:
new_fit.add_trajectory(dra60,
t,
PLOT_KWARGS['line_type'],
alpha_palette[idx], (0, 0),
'Alpha',
label=str(t) + ' min',
linewidth=2,
alpha=PLOT_KWARGS['alpha'])
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=alpha_palette[idx])
if t not in beta_mask:
new_fit.add_trajectory(drb60,
t,
PLOT_KWARGS['line_type'],
beta_palette[idx], (0, 1),
'Beta',
integral_difference_response.add_sigmas()
integral_response.add_sigmas()
# -------------------------------
# Plot model dose response curves
# -------------------------------
alpha_palette = sns.color_palette("deep", 6)
beta_palette = sns.color_palette("deep", 6)
alpha_mask = [7.5]
beta_mask = [7.5]
# Add fits
for idx, t in enumerate(times):
if t not in alpha_mask:
spec_fig.add_trajectory(dra60, t, 'plot', alpha_palette[idx], (0, 0), 'Alpha', label=str(t) + ' min',
linewidth=2)
spec_fig.add_trajectory(mean_data, t, 'errorbar', 'o', (0, 0), 'Alpha', color=alpha_palette[idx])
if t not in beta_mask:
spec_fig.add_trajectory(drb60, t, 'plot', beta_palette[idx], (0, 1), 'Beta', label=str(t) + ' min',
linewidth=2)
spec_fig.add_trajectory(mean_data, t, 'errorbar', 'o', (0, 1), 'Beta', color=beta_palette[idx])
spec_fig.axes[0][0].set_title(r'IFN$\alpha$ fit')
spec_fig.axes[0][1].set_title(r'IFN$\beta$ fit')
# -----------------------
# Plot ratio vs time
# -----------------------
for idx, t in enumerate(times):
if t not in alpha_mask:
spec_fig.add_trajectory(ratio_response, t, 'plot', alpha_palette[idx], (1, 0), 'Ratio',
label=str(t) + ' min', linewidth=2)
new_fit.axes[0].set_ylabel('pSTAT1 (MFI)')
# new_fit.axes[1].set_ylabel('pSTAT1 (MFI)')
# Plot Dose respsonse data
times = [2.5, 5.0, 7.5, 10.0, 20.0, 60.0]
color_palette = sns.color_palette("rocket_r",
6) # sns.color_palette("Paired", 10)
alpha_mask = [2.5, 5.0, 7.5, 20.0]
beta_mask = [2.5, 5.0, 7.5, 20.0]
for idx, t in enumerate([10.0, 60.0]):
if t == 10.0:
new_fit.add_trajectory(mean_large_data,
t,
'errorbar',
'v', (0, 0),
'Alpha',
color=color_palette[3],
linewidth=2.0,
label=r'Large Cells, 10 min',
alpha=0.5)
new_fit.add_trajectory(mean_small_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=color_palette[3],
linewidth=2.0,
label=r'Small Cells, 10 min')
new_fit.add_trajectory(mean_large_data,
t,
'errorbar',
# Plot posterior samples
alpha_palette = sns.color_palette("deep", 6)
beta_palette = sns.color_palette("deep", 6)
new_fit = DoseresponsePlot((1, 2))
alpha_mask = [2.5, 7.5, 10.0] #[2.5, 5.0, 7.5, 10.0, 20.0, 60.0]
beta_mask = [2.5, 7.5, 10.0]
plot_data = True
# Add fits
for idx, t in enumerate(times):
if t not in alpha_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 == True:
new_fit.add_trajectory(mean_data,
t,
'errorbar',
'o', (0, 0),
'Alpha',
color=alpha_palette[idx])
if t not in beta_mask:
new_fit.add_trajectory(mean_model,
t,
'envelope',
beta_palette[idx], (0, 1),
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()
return_type='dataframe',
dataframe_labels=dose_species,
scale_factor=100.0 / model.parameters['EpoR_IC']),
conditions={})
# -------------------------------
# Plot model dose response curves
# -------------------------------
palette = sns.color_palette("muted")
Epo_plot = DoseresponsePlot((1, 1))
# Add data
Epo_plot.add_trajectory(Moraga_data,
60,
'errorbar',
'o', (0, 0),
'T_Epo',
label='EPO',
color=palette[1])
Epo_plot.add_trajectory(Moraga_data,
60,
'errorbar',
'o', (0, 0),
'EMP_1',
label='EMP-1',
color=palette[2])
Epo_plot.add_trajectory(Moraga_data,
60,
'errorbar',
'o', (0, 0),
'EMP_33',
df=dradf_rec,
conditions={'Alpha': {
'Ib': 0
}})
drb60_rec = IfnData('custom', df=drbdf_rec, conditions={'Beta': {'Ia': 0}})
dr_plot = DoseresponsePlot((3, 2))
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[idx], (0, 0),
'Alpha',
label='Alpha ' + str(t),
linewidth=2.0)
dr_plot.add_trajectory(dra60_int,
t,
'plot',
alpha_palette[idx], (1, 0),
'Alpha',
label='Alpha ' + str(t),
linewidth=2.0)
dr_plot.add_trajectory(dra60_rec,
t,
'plot',
alpha_palette[idx], (2, 0),
'Alpha',
drbdf.loc['Beta'].iloc[:,
i] = drbdf.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}})
new_fit = DoseresponsePlot((1, 2))
alpha_mask = [2.5, 7.5]
beta_mask = [2.5, 7.5]
# Add fits
for idx, t in enumerate([str(el) for el in times]):
if t not in [str(el) for el in alpha_mask]:
new_fit.add_trajectory(dra60,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label='Alpha ' + t)
if t not in [str(el) for el in beta_mask]:
new_fit.add_trajectory(drb60,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label='Beta ' + t)
# Add data
for idx, t in enumerate(times):
if t not in alpha_mask:
new_fit.add_trajectory(newdata,
t,
'scatter',
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, )
dr_plot.add_trajectory(dra60_rec, t, 'plot', ':', (0, 0), 'Alpha', color=alpha_palette[1], label='SOCS only', linewidth=2.0)
if t not in beta_mask:
dr_plot.add_trajectory(drb60, t, 'plot', beta_palette[5], (0, 0), 'Beta', label='Beta - No Feedback', linewidth=2.0)
dr_plot.add_trajectory(drb60_int, t, 'plot', '--', (0, 0), 'Beta', color=beta_palette[3],
label='Internalization only', linewidth=2.0)
dr_plot.add_trajectory(drb60_rec, t, 'plot', ':', (0, 0), 'Beta', color=beta_palette[1], label='SOCS only', linewidth=2.0)
dr_plot.fig.suptitle('Internalization vs SOCS')
dir = os.path.join(os.getcwd(), 'results', 'Figures', 'Figure_5')
if not os.path.exists(dir):
os.makedirs(dir)
dr_plot.save_figure(save_dir=os.path.join(dir, 'Figure_5.pdf'))
drbdf.loc['Beta'].iloc[:,
i] = drbdf.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}})
new_fit = DoseresponsePlot((1, 2))
alpha_mask = []
beta_mask = []
# Add fits
for idx, t in enumerate([el for el in times]):
if t not in alpha_mask:
new_fit.add_trajectory(dra60,
t,
'plot',
alpha_palette[idx], (0, 0),
'Alpha',
label='Alpha ' + str(t))
if t not in beta_mask:
new_fit.add_trajectory(drb60,
t,
'plot',
beta_palette[idx], (0, 1),
'Beta',
label='Beta ' + str(t))
# Add data
for idx, t in enumerate(times):
if t not in alpha_mask:
new_fit.add_trajectory(Sagar_data,
t,
'errorbar',
drb60 = IfnData('custom', df=drbdf, conditions={'Beta': {'Ia': 0}})
# -------------------------
# Plot mean trajectory
# -------------------------
alpha_palette = sns.color_palette("Reds", 1)
alpha_model_palette = sns.color_palette("Greys", 1)
beta_palette = sns.color_palette("Greens", 1)
beta_model_palette = sns.color_palette("Greys", 1)
dr_plot = DoseresponsePlot((6, 2))
for idx, t in enumerate(newdata_4.get_times('Alpha')):
dr_plot.add_trajectory(mean_data,
t,
'errorbar',
'o--', (idx, 0),
'Alpha',
label='',
color=alpha_palette[0])
for idx, t in enumerate(newdata_4.get_times('Beta')):
dr_plot.add_trajectory(mean_data,
t,
'errorbar',
'o--', (idx, 1),
'Beta',
label='',
color=beta_palette[0])
# ----------------------------------
# Plot best fit for each time slice
# ----------------------------------
# ---------------------------------
# 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()
