def __plot_memcurves(self, model_em_fits, suptitle_text=None, ax=None):
'''
Nice plot for the memory fidelity, as in Fig6 of the paper theo
Changes to using the subject fits if FitExperimentAllTSubject used.
'''
T_space = self.fit_exp.T_space
data_em_fits = self.fit_exp.get_em_fits_arrays()
if ax is None:
_, ax = plt.subplots()
else:
ax.hold(False)
ax = utils.plot_mean_std_area(
T_space,
data_em_fits['mean'][0],
data_em_fits['std'][0],
linewidth=3, fmt='o-', markersize=8,
label='Data',
ax_handle=ax
)
ax.hold(True)
ax = utils.plot_mean_std_area(
T_space,
model_em_fits['mean'][..., 0],
model_em_fits['std'][..., 0],
xlabel='Number of items',
ylabel="Memory fidelity $[rad^{-2}]$",
linewidth=3,
fmt='o-', markersize=8,
label='Model',
ax_handle=ax
)
ax.legend(loc='upper right',
bbox_to_anchor=(1., 1.)
)
ax.set_xlim([0.9, T_space.max()+0.1])
ax.set_xticks(range(1, T_space.max()+1))
ax.set_xticklabels(range(1, T_space.max()+1))
if suptitle_text:
ax.set_title(suptitle_text)
# ax.get_figure().suptitle(suptitle_text)
ax.hold(False)
ax.get_figure().canvas.draw()
return ax
def __plot_memcurves(self, model_em_fits, suptitle_text=None, ax=None):
"""
Nice plot for the memory fidelity, as in Fig6 of the paper theo
"""
T_space = self.fit_exp.T_space
data_em_fits = self.fit_exp.experimental_dataset["em_fits_nitems_arrays"]
if ax is None:
_, ax = plt.subplots()
else:
ax.hold(False)
ax = utils.plot_mean_std_area(
T_space,
data_em_fits["mean"][0],
data_em_fits["std"][0],
linewidth=3,
fmt="o-",
markersize=8,
label="Experimental data",
ax_handle=ax,
)
ax.hold(True)
ax = utils.plot_mean_std_area(
T_space,
model_em_fits["mean"][..., 0],
model_em_fits["std"][..., 0],
xlabel="Number of items",
ylabel="Memory error $[rad^{-2}]$",
linewidth=3,
fmt="o-",
markersize=8,
label="Fitted kappa",
ax_handle=ax,
)
ax.legend(prop={"size": 15}, loc="center right", bbox_to_anchor=(1.1, 0.5))
ax.set_xlim([0.9, T_space.max() + 0.1])
ax.set_xticks(range(1, T_space.max() + 1))
ax.set_xticklabels(range(1, T_space.max() + 1))
if suptitle_text:
ax.get_figure().suptitle(suptitle_text)
ax.get_figure().canvas.draw()
return ax
def mem_plot_kappa(sigmax_i, ratiohier_i, T_space_exp, exp_kappa_mean, exp_kappa_std=None):
ax = utils.plot_mean_std_area(T_space_exp, exp_kappa_mean, exp_kappa_std, linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space[:T_space_exp.max()], result_em_fits_mean[..., :T_space_exp.max(), 0][ratiohier_i, sigmax_i], result_em_fits_std[..., :T_space_exp.max(), 0][ratiohier_i, sigmax_i], xlabel='Number of items', ylabel="Memory error $[rad^{-2}]$", linewidth=3, fmt='o-', markersize=8, label='Fitted kappa', ax_handle=ax)
ax.set_title('ratio_hier %.2f, sigmax %.2f' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, T_space_exp.max()+0.1])
ax.set_xticks(range(1, T_space_exp.max()+1))
ax.set_xticklabels(range(1, T_space_exp.max()+1))
ax.get_figure().canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_kappa_ratiohier%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
def mem_plot_kappa(sigmax_i, ratioconj_i):
ax = utils.plot_mean_std_area(T_space, memory_experimental_kappa, memory_experimental_kappa_std, linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratioconj_i, sigmax_i], result_em_fits_std[..., 0][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Memory error $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa')
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][ratioconj_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][ratioconj_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
if savefigs:
dataio.save_current_figure('memorycurves_kappa_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
def plot_precision_rcscale(ax=None):
if ax is not None:
plt.figure(ax.get_figure().number)
ax.hold(False)
# Curve of precision evolution.
ax = utils.plot_mean_std_area(rcscale_space, result_precision_stats['mean'], result_precision_stats['std'], linewidth=3, fmt='o-', markersize=8, label='Precision', ax_handle=ax)
ax.hold(True)
ax.axvline(x=optimal_scale, color='r', linewidth=3)
ax.axvline(x=optimal_scale_corrected, color='k', linewidth=3)
ax.legend()
ax.set_title("Precision {code_type} {M} {sigmax:.3f} {sigmay:.2f}".format(**variables_launcher_running['all_parameters']))
ax.set_xlim(rcscale_space.min(), rcscale_space.max())
ax.set_ylim(bottom=0.0)
ax.get_figure().canvas.draw()
dataio.save_current_figure('precision_rcscale_{code_type}_M{M}_sigmax{sigmax}_sigmay{sigmay}_{{label}}_{{unique_id}}.pdf'.format(**variables_launcher_running['all_parameters']))
return ax
def mem_plot_kappa(sigmax_i, M_i, experim_data_mean, experim_data_std=None):
ax = utils.plot_mean_std_area(T_space, experim_data_mean, experim_data_std, linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][M_i, sigmax_i], result_em_fits_std[..., 0][M_i, sigmax_i], xlabel='Number of items', ylabel="Inverse variance $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa')
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][M_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][M_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
ax.set_title('M %d, sigmax %.2f' % (M_space[M_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
ax.get_figure().canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_kappa_M%dsigmax%.2f_{label}_{unique_id}.pdf' % (M_space[M_i], sigmax_space[sigmax_i]))
def mem_plot_precision(sigmax_i, ratiohier_i, mem_exp_prec):
ax = utils.plot_mean_std_area(T_space[:mem_exp_prec.size], mem_exp_prec, np.zeros(mem_exp_prec.size), linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space[:mem_exp_prec.size], result_all_precisions_mean[ratiohier_i, sigmax_i, :mem_exp_prec.size], result_all_precisions_std[ratiohier_i, sigmax_i, :mem_exp_prec.size], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Precision of samples')
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][ratiohier_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][ratiohier_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
# ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratiohier_i, sigmax_i], result_em_fits_std[..., 0][ratiohier_i, sigmax_i], ax_handle=ax, xlabel='Number of items', ylabel="Inverse variance $[rad^{-2}]$", linewidth=3, fmt='o-', markersize=8, label='Fitted kappa')
ax.set_title('ratio_hier %.2f, sigmax %.2f' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, mem_exp_prec.size + 0.1])
ax.set_xticks(range(1, mem_exp_prec.size + 1))
ax.set_xticklabels(range(1, mem_exp_prec.size + 1))
if savefigs:
dataio.save_current_figure('memorycurves_precision_ratiohier%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
def em_plot(sigmax_i, ratioconj_i):
# TODO finish checking this up.
f, ax = plt.subplots()
ax2 = ax.twinx()
# left axis, kappa
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratioconj_i, sigmax_i], result_em_fits_std[..., 0][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Inverse variance $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa', color='k')
# Right axis, mixture probabilities
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 1][ratioconj_i, sigmax_i], result_em_fits_std[..., 1][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Target')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 2][ratioconj_i, sigmax_i], result_em_fits_std[..., 2][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Nontarget')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 3][ratioconj_i, sigmax_i], result_em_fits_std[..., 3][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Random')
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax.legend(lines + lines2, labels + labels2)
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
f.canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_emfits_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
def sigmaoutput_plot_mixtures(sigmaoutput_space, result_em_fits_mean, result_em_fits_std, exp_name='', ax=None):
if ax is None:
_, ax = plt.subplots()
if ax is not None:
plt.figure(ax.get_figure().number)
ax.hold(False)
# mixture probabilities
print result_em_fits_mean[..., 1]
result_em_fits_mean[np.isnan(result_em_fits_mean)] = 0.0
result_em_fits_std[np.isnan(result_em_fits_std)] = 0.0
utils.plot_mean_std_area(sigmaoutput_space, result_em_fits_mean[..., 1], result_em_fits_std[..., 1], xlabel='sigma output', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Target')
ax.hold(True)
utils.plot_mean_std_area(sigmaoutput_space, result_em_fits_mean[..., 2], result_em_fits_std[..., 2], xlabel='sigma output', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Nontarget')
utils.plot_mean_std_area(sigmaoutput_space, result_em_fits_mean[..., 3], result_em_fits_std[..., 3], xlabel='sigma output', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Random')
ax.legend(prop={'size':15})
ax.set_title("{{exp_name}} {T} {M} {ratio_conj:.2f} {sigmax:.3f} {sigmay:.2f}".format(**variables_launcher_running['all_parameters']).format(exp_name=exp_name))
ax.set_ylim([0.0, 1.1])
ax.get_figure().canvas.draw()
dataio.save_current_figure('memorycurves_emfits_%s_T{T}_M{M}_ratio{ratio_conj}_sigmax{sigmax}_sigmay{sigmay}_{{label}}_{{unique_id}}.pdf'.format(**variables_launcher_running['all_parameters']) % (exp_name))
return ax
def plot_mixtures_rcscale(ax=None):
if ax is None:
_, ax = plt.subplots()
if ax is not None:
plt.figure(ax.get_figure().number)
ax.hold(False)
result_em_fits_stats['mean'][np.isnan(result_em_fits_stats['mean'])] = 0.0
result_em_fits_stats['std'][np.isnan(result_em_fits_stats['std'])] = 0.0
utils.plot_mean_std_area(rcscale_space, result_em_fits_stats['mean'][..., 1], result_em_fits_stats['std'][..., 1], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Target')
ax.hold(True)
utils.plot_mean_std_area(rcscale_space, result_em_fits_stats['mean'][..., 2], result_em_fits_stats['std'][..., 2], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Nontarget')
utils.plot_mean_std_area(rcscale_space, result_em_fits_stats['mean'][..., 3], result_em_fits_stats['std'][..., 3], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Random')
ax.axvline(x=optimal_scale, color='r', linewidth=3)
ax.axvline(x=optimal_scale_corrected, color='k', linewidth=3)
ax.set_xlim(rcscale_space.min(), rcscale_space.max())
ax.set_ylim(bottom=0.0, top=1.0)
ax.legend(prop={'size':15})
ax.set_title("mixts {code_type} {M} {sigmax:.3f} {sigmay:.2f}".format(**variables_launcher_running['all_parameters']))
ax.get_figure().canvas.draw()
dataio.save_current_figure('em_mixts_rcscale_{code_type}_M{M}_sigmax{sigmax}_sigmay{sigmay}_{{label}}_{{unique_id}}.pdf'.format(**variables_launcher_running['all_parameters']))
return ax
def mem_plot_kappa(sigmax_i, M_i, exp_kappa_mean, exp_kappa_std=None):
ax = utils.plot_mean_std_area(
T_space[: exp_kappa_mean.size],
exp_kappa_mean,
exp_kappa_std,
linewidth=3,
fmt="o-",
markersize=8,
label="Experimental data",
)
ax = utils.plot_mean_std_area(
T_space[: exp_kappa_mean.size],
result_em_fits_mean[..., : exp_kappa_mean.size, 0][M_i, sigmax_i],
result_em_fits_std[..., : exp_kappa_mean.size, 0][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Memory error $[rad^{-2}]$",
linewidth=3,
fmt="o-",
markersize=8,
label="Fitted kappa",
ax_handle=ax,
)
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][M_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][M_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
ax.set_title("M %d, sigmax %.2f" % (M_space[M_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, exp_kappa_mean.size + 0.1])
ax.set_xticks(range(1, exp_kappa_mean.size + 1))
ax.set_xticklabels(range(1, exp_kappa_mean.size + 1))
ax.get_figure().canvas.draw()
if savefigs:
dataio.save_current_figure(
"memorycurves_kappa_M%dsigmax%.2f_{label}_{unique_id}.pdf" % (M_space[M_i], sigmax_space[sigmax_i])
)
def _plot_emmixture_mean_error(T_space, mean, yerror, ax=None, title='',
**args):
'''
Main plotting function to show the evolution of an EM Mixture.
'''
if ax is None:
f, ax = plt.subplots()
utils.plot_mean_std_area(
T_space, mean, np.ma.masked_invalid(yerror).filled(0.0),
ax_handle=ax, linewidth=3, markersize=8, **args)
# ax.legend(prop={'size': 15}, loc='best')
if title:
ax.set_title('Mixture prop: %s' % title)
ax.set_xlim([0.9, T_space.max() + 0.1])
ax.set_ylim([0.0, 1.01])
ax.set_xticks(range(1, T_space.max()+1))
ax.set_xticklabels(range(1, T_space.max()+1))
ax.get_figure().canvas.draw()
return ax
def em_plot_paper(sigmax_i, M_i):
f, ax = plt.subplots()
# Right axis, mixture probabilities
utils.plot_mean_std_area(
T_space_bays09,
result_em_fits_mean[..., 1][M_i, sigmax_i][: T_space_bays09.size],
result_em_fits_std[..., 1][M_i, sigmax_i][: T_space_bays09.size],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Target",
)
utils.plot_mean_std_area(
T_space_bays09,
result_em_fits_mean[..., 2][M_i, sigmax_i][: T_space_bays09.size],
result_em_fits_std[..., 2][M_i, sigmax_i][: T_space_bays09.size],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Nontarget",
)
utils.plot_mean_std_area(
T_space_bays09,
result_em_fits_mean[..., 3][M_i, sigmax_i][: T_space_bays09.size],
result_em_fits_std[..., 3][M_i, sigmax_i][: T_space_bays09.size],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Random",
)
ax.legend(prop={"size": 15})
ax.set_title("M %d, sigmax %.2f" % (M_space[M_i], sigmax_space[sigmax_i]))
ax.set_xlim([1.0, T_space_bays09.size])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, T_space_bays09.size + 1))
ax.set_xticklabels(range(1, T_space_bays09.size + 1))
f.canvas.draw()
if savefigs:
dataio.save_current_figure(
"memorycurves_emfits_paper_M%dsigmax%.2f_{label}_{unique_id}.pdf"
% (M_space[M_i], sigmax_space[sigmax_i])
)
def sigmaoutput_plot_kappa(sigmaoutput_space, result_em_fits_mean, result_em_fits_std=None, exp_name='', ax=None):
if ax is not None:
plt.figure(ax.get_figure().number)
ax.hold(False)
ax = utils.plot_mean_std_area(sigmaoutput_space, result_em_fits_mean[..., 0], result_em_fits_std[..., 0], xlabel='sigma output', ylabel='Memory fidelity', linewidth=3, fmt='o-', markersize=8, label='Noise output effect', ax_handle=ax)
ax.hold(True)
ax.set_title("{{exp_name}} {T} {M} {ratio_conj:.2f} {sigmax:.3f} {sigmay:.2f}".format(**variables_launcher_running['all_parameters']).format(exp_name=exp_name))
ax.legend()
# ax.set_xlim([0.9, T_space_exp.max()+0.1])
# ax.set_xticks(range(1, T_space_exp.max()+1))
# ax.set_xticklabels(range(1, T_space_exp.max()+1))
ax.get_figure().canvas.draw()
dataio.save_current_figure('noiseoutput_kappa_%s_T{T}_M{M}_ratio{ratio_conj}_sigmax{sigmax}_sigmay{sigmay}_{{label}}_{{unique_id}}.pdf'.format(**variables_launcher_running['all_parameters']) % (exp_name))
return ax
def em_plot_paper(sigmax_i, M_i):
f, ax = plt.subplots()
# Right axis, mixture probabilities
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 1][M_i, sigmax_i], result_em_fits_std[..., 1][M_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Target')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 2][M_i, sigmax_i], result_em_fits_std[..., 2][M_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Nontarget')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 3][M_i, sigmax_i], result_em_fits_std[..., 3][M_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Random')
ax.legend(prop={'size':15})
ax.set_title('M %d, sigmax %.2f' % (M_space[M_i], sigmax_space[sigmax_i]))
ax.set_xlim([1.0, 5.0])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
f.canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_emfits_paper_M%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (M_space[M_i], sigmax_space[sigmax_i]))
def em_plot_paper(sigmax_i, ratiohier_i):
f, ax = plt.subplots()
# mixture probabilities
utils.plot_mean_std_area(bays09_T_space_interp, result_em_fits_mean[..., 1][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], result_em_fits_std[..., 1][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Target')
utils.plot_mean_std_area(bays09_T_space_interp, result_em_fits_mean[..., 2][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], result_em_fits_std[..., 2][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Nontarget')
utils.plot_mean_std_area(bays09_T_space_interp, result_em_fits_mean[..., 3][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], result_em_fits_std[..., 3][ratiohier_i, sigmax_i][:bays09_T_space_interp.size], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Random')
ax.legend(prop={'size':15})
ax.set_title('ratio_hier %.2f, sigmax %.2f' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
ax.set_xlim([1.0, bays09_T_space_interp.size])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, bays09_T_space_interp.size+1))
ax.set_xticklabels(range(1, bays09_T_space_interp.size+1))
f.canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_emfits_paper_ratiohier%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratiohier_space[ratiohier_i], sigmax_space[sigmax_i]))
def plots_memory_curves(data_pbs, generator_module=None):
'''
Reload and plot memory curve of a Mixed code.
Can use Marginal Fisher Information and fitted Mixture Model as well
'''
#### SETUP
#
savefigs = True
savedata = True
plot_pcolor_fit_precision_to_fisherinfo = False
plot_selected_memory_curves = False
plot_best_memory_curves = False
plot_subplots_persigmax = True
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
# ratio_space, sigmax_space, T, 5
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_marginal_inv_fi_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_inv_fi_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_fi_mean = utils.nanmean(np.squeeze(1./data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_fi_std = utils.nanstd(np.squeeze(1./data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
ratioconj_space = data_pbs.loaded_data['parameters_uniques']['ratio_conj']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
T_space = data_pbs.loaded_data['datasets_list'][0]['T_space']
print ratioconj_space
print sigmax_space
print T_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape, result_marginal_inv_fi_mean.shape
dataio = DataIO.DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
## Load Experimental data
data_simult = load_experimental_data.load_data_simult(data_dir=os.path.normpath(os.path.join(os.path.split(load_experimental_data.__file__)[0], '../../experimental_data/')), fit_mixture_model=True)
memory_experimental_precision = data_simult['precision_nitems_theo']
memory_experimental_kappa = np.array([data['kappa'] for _, data in data_simult['em_fits_nitems']['mean'].items()])
memory_experimental_kappa_std = np.array([data['kappa'] for _, data in data_simult['em_fits_nitems']['std'].items()])
experim_datadir = os.environ.get('WORKDIR_DROP', os.path.split(load_experimental_data.__file__)[0])
data_bays2009 = load_experimental_data.load_data_bays09(data_dir=os.path.normpath(os.path.join(experim_datadir, '../../experimental_data/')), fit_mixture_model=True)
bays09_experimental_mixtures_mean = data_bays2009['em_fits_nitems_arrays']['mean']
# add interpolated points for 3 and 5 items
bays3 = (bays09_experimental_mixtures_mean[:, 2] + bays09_experimental_mixtures_mean[:, 1])/2.
bays5 = (bays09_experimental_mixtures_mean[:, -1] + bays09_experimental_mixtures_mean[:, -2])/2.
bays09_experimental_mixtures_mean_compatible = np.c_[bays09_experimental_mixtures_mean[:,:2], bays3, bays09_experimental_mixtures_mean[:, 2], bays5]
# Boost non-targets
# bays09_experimental_mixtures_mean_compatible[1] *= 1.5
# bays09_experimental_mixtures_mean_compatible[2] /= 1.5
# bays09_experimental_mixtures_mean_compatible /= np.sum(bays09_experimental_mixtures_mean_compatible, axis=0)
# Compute some landscapes of fit!
dist_diff_precision_margfi = np.sum(np.abs(result_all_precisions_mean*2. - result_marginal_fi_mean[..., 0])**2., axis=-1)
dist_ratio_precision_margfi = np.sum(np.abs((result_all_precisions_mean*2.)/result_marginal_fi_mean[..., 0] - 1.0)**2., axis=-1)
dist_diff_emkappa_margfi = np.sum(np.abs(result_em_fits_mean[..., 0]*2. - result_marginal_fi_mean[..., 0])**2., axis=-1)
dist_ratio_emkappa_margfi = np.sum(np.abs((result_em_fits_mean[..., 0]*2.)/result_marginal_fi_mean[..., 0] - 1.0)**2., axis=-1)
dist_diff_precision_experim = np.sum(np.abs(result_all_precisions_mean - memory_experimental_precision)**2., axis=-1)
dist_diff_emkappa_experim = np.sum(np.abs(result_em_fits_mean[..., 0] - memory_experimental_kappa)**2., axis=-1)
dist_diff_precision_experim_1item = np.abs(result_all_precisions_mean[..., 0] - memory_experimental_precision[0])**2.
dist_diff_precision_experim_2item = np.abs(result_all_precisions_mean[..., 1] - memory_experimental_precision[1])**2.
dist_diff_precision_margfi_1item = np.abs(result_all_precisions_mean[..., 0]*2. - result_marginal_fi_mean[..., 0, 0])**2.
dist_diff_emkappa_experim_1item = np.abs(result_em_fits_mean[..., 0, 0] - memory_experimental_kappa[0])**2.
dist_diff_margfi_experim_1item = np.abs(result_marginal_fi_mean[..., 0, 0] - memory_experimental_precision[0])**2.
dist_diff_emkappa_mixtures_bays09 = np.sum(np.sum((result_em_fits_mean[..., 1:4] - bays09_experimental_mixtures_mean_compatible[1:].T)**2., axis=-1), axis=-1)
dist_diff_modelfits_experfits_bays09 = np.sum(np.sum((result_em_fits_mean[..., :4] - bays09_experimental_mixtures_mean_compatible.T)**2., axis=-1), axis=-1)
if plot_pcolor_fit_precision_to_fisherinfo:
# Check fit between precision and fisher info
utils.pcolor_2d_data(dist_diff_precision_margfi, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_precision_margfi_log_pcolor_{label}_{unique_id}.pdf')
# utils.pcolor_2d_data(dist_diff_precision_margfi, x=ratioconj_space, y=sigmax_space[2:], xlabel='ratio conj', ylabel='sigmax')
# if savefigs:
# dataio.save_current_figure('match_precision_margfi_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_ratio_precision_margfi, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_ratio_precision_margfi_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_emkappa_margfi, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_diff_emkappa_margfi_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_ratio_emkappa_margfi, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_ratio_emkappa_margfi_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_precision_experim, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_diff_precision_experim_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_emkappa_experim, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_diff_emkappa_experim_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_precision_margfi*dist_diff_emkappa_margfi*dist_diff_precision_experim*dist_diff_emkappa_experim, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax', log_scale=True)
if savefigs:
dataio.save_current_figure('match_bigmultiplication_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_precision_margfi_1item, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_precision_margfi_1item_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_precision_experim_1item, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_precision_experim_1item_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_emkappa_experim_1item, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_emkappa_experim_1item_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_margfi_experim_1item, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_margfi_experim_1item_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_precision_experim_2item, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_precision_experim_2item_log_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_emkappa_mixtures_bays09, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_mixtures_experbays09_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_diff_modelfits_experfits_bays09, log_scale=True, x=ratioconj_space, y=sigmax_space, xlabel='ratio conj', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_diff_emfits_experbays09_pcolor_{label}_{unique_id}.pdf')
# Macro plot
def mem_plot_precision(sigmax_i, ratioconj_i):
ax = utils.plot_mean_std_area(T_space, memory_experimental_precision, np.zeros(T_space.size), linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space, result_all_precisions_mean[ratioconj_i, sigmax_i], result_all_precisions_std[ratioconj_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Precision of samples')
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][ratioconj_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][ratioconj_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
# ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratioconj_i, sigmax_i], result_em_fits_std[..., 0][ratioconj_i, sigmax_i], ax_handle=ax, xlabel='Number of items', ylabel="Inverse variance $[rad^{-2}]$", linewidth=3, fmt='o-', markersize=8, label='Fitted kappa')
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
if savefigs:
dataio.save_current_figure('memorycurves_precision_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
def mem_plot_kappa(sigmax_i, ratioconj_i):
ax = utils.plot_mean_std_area(T_space, memory_experimental_kappa, memory_experimental_kappa_std, linewidth=3, fmt='o-', markersize=8, label='Experimental data')
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratioconj_i, sigmax_i], result_em_fits_std[..., 0][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Memory error $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa')
# ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][ratioconj_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][ratioconj_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Marginal Fisher Information')
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.legend()
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
if savefigs:
dataio.save_current_figure('memorycurves_kappa_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
def em_plot(sigmax_i, ratioconj_i):
# TODO finish checking this up.
f, ax = plt.subplots()
ax2 = ax.twinx()
# left axis, kappa
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][ratioconj_i, sigmax_i], result_em_fits_std[..., 0][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Inverse variance $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa', color='k')
# Right axis, mixture probabilities
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 1][ratioconj_i, sigmax_i], result_em_fits_std[..., 1][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Target')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 2][ratioconj_i, sigmax_i], result_em_fits_std[..., 2][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Nontarget')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 3][ratioconj_i, sigmax_i], result_em_fits_std[..., 3][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Random')
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax.legend(lines + lines2, labels + labels2)
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
f.canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_emfits_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
def em_plot_paper(sigmax_i, ratioconj_i):
f, ax = plt.subplots()
# Right axis, mixture probabilities
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 1][ratioconj_i, sigmax_i], result_em_fits_std[..., 1][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Target')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 2][ratioconj_i, sigmax_i], result_em_fits_std[..., 2][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Nontarget')
utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 3][ratioconj_i, sigmax_i], result_em_fits_std[..., 3][ratioconj_i, sigmax_i], xlabel='Number of items', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='o-', markersize=5, label='Random')
ax.legend(prop={'size':15})
ax.set_title('ratio_conj %.2f, sigmax %.2f' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
ax.set_xlim([1.0, 5.0])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
f.canvas.draw()
if savefigs:
dataio.save_current_figure('memorycurves_emfits_paper_ratioconj%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratioconj_space[ratioconj_i], sigmax_space[sigmax_i]))
if plot_selected_memory_curves:
selected_values = [[0.84, 0.23], [0.84, 0.19]]
for current_values in selected_values:
# Find the indices
ratioconj_i = np.argmin(np.abs(current_values[0] - ratioconj_space))
sigmax_i = np.argmin(np.abs(current_values[1] - sigmax_space))
mem_plot_precision(sigmax_i, ratioconj_i)
mem_plot_kappa(sigmax_i, ratioconj_i)
if plot_best_memory_curves:
# Best precision fit
best_axis2_i_all = np.argmin(dist_diff_precision_experim, axis=1)
for axis1_i, best_axis2_i in enumerate(best_axis2_i_all):
mem_plot_precision(best_axis2_i, axis1_i)
# Best kappa fit
best_axis2_i_all = np.argmin(dist_diff_emkappa_experim, axis=1)
for axis1_i, best_axis2_i in enumerate(best_axis2_i_all):
mem_plot_kappa(best_axis2_i, axis1_i)
em_plot(best_axis2_i, axis1_i)
# Best em parameters fit to Bays09
best_axis2_i_all = np.argmin(dist_diff_modelfits_experfits_bays09, axis=1)
for axis1_i, best_axis2_i in enumerate(best_axis2_i_all):
mem_plot_kappa(best_axis2_i, axis1_i)
# em_plot(best_axis2_i, axis1_i)
em_plot_paper(best_axis2_i, axis1_i)
if plot_subplots_persigmax:
# Do subplots with ratio_conj on x, one plot per T and different figures per sigmax. Looks a bit like reloader_hierarchical_constantMMlower_maxlik_allresponses_221213.py
sigmax_selected_indices = np.array([np.argmin((sigmax_space - sigmax_select)**2.) for sigmax_select in [0.1, 0.2, 0.3, 0.4, 0.5]])
for sigmax_select_i in sigmax_selected_indices:
# two plots per sigmax.
f, axes = plt.subplots(nrows=T_space[-1], ncols=1, sharex=True, figsize=(10, 12))
# all_lines_bis = []
for T_i, T in enumerate(T_space):
# Plot EM mixtures
utils.plot_mean_std_area(ratioconj_space, result_em_fits_mean[:, sigmax_select_i, T_i, 1], result_em_fits_std[:, sigmax_select_i, T_i, 1], ax_handle=axes[T_i], linewidth=3, fmt='o-', markersize=5)
utils.plot_mean_std_area(ratioconj_space, result_em_fits_mean[:, sigmax_select_i, T_i, 2], result_em_fits_std[:, sigmax_select_i, T_i, 2], ax_handle=axes[T_i], linewidth=3, fmt='o-', markersize=5)
utils.plot_mean_std_area(ratioconj_space, result_em_fits_mean[:, sigmax_select_i, T_i, 3], result_em_fits_std[:, sigmax_select_i, T_i, 3], ax_handle=axes[T_i], linewidth=3, fmt='o-', markersize=5)
# ratio_MMlower_space, result_emfits_filtered[:, i, 1:4], 0*result_emfits_filtered[:, i, 1:4], ax_handle=axes[T_i], linewidth=2) #, color=all_lines[T_i].get_color())
# curr_lines = axes[T_i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[T_i].get_color())
axes[T_i].grid()
axes[T_i].set_xticks(np.linspace(0., 1.0, 5))
axes[T_i].set_xlim((0.0, 1.0))
# axes[T_i].set_yticks([])
# axes[T_i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1))
axes[T_i].set_ylim((0.0, 1.05))
axes[T_i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
axes[0].set_title('Sigmax: %.3f' % sigmax_space[sigmax_select_i])
axes[-1].set_xlabel('Proportion of conjunctive units')
if savefigs:
dataio.save_current_figure('results_subplots_emmixtures_sigmax%.2f_{label}_global_{unique_id}.pdf' % sigmax_space[sigmax_select_i])
f, axes = plt.subplots(nrows=T_space[-1], ncols=1, sharex=True, figsize=(10, 12))
# Kappa kappa
for T_i, T in enumerate(T_space):
# Plot kappa mixture
utils.plot_mean_std_area(ratioconj_space, result_em_fits_mean[:, sigmax_select_i, T_i, 0], result_em_fits_std[:, sigmax_select_i, T_i, 0], ax_handle=axes[T_i], linewidth=3, fmt='o-', markersize=5)
# utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 0], 0*result_emfits_filtered[:, i, 0], ax_handle=axes[T_i], linewidth=2) #, color=all_lines[T_i].get_color())
# curr_lines = axes[T_i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[T_i].get_color())
axes[T_i].grid()
axes[T_i].set_xticks(np.linspace(0., 1.0, 5))
axes[T_i].set_xlim((0.0, 1.0))
# axes[T_i].set_yticks([])
# axes[T_i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1))
# axes[T_i].set_ylim((0.0, 1.0))
axes[T_i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
axes[0].set_title('Sigmax: %.3f' % sigmax_space[sigmax_select_i])
axes[-1].set_xlabel('Proportion of conjunctive units')
# f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
if savefigs:
dataio.save_current_figure('results_subplots_emkappa_sigmax%.2f_{label}_global_{unique_id}.pdf' % sigmax_space[sigmax_select_i])
all_args = data_pbs.loaded_data['args_list']
variables_to_save = ['memory_experimental_precision', 'memory_experimental_kappa', 'bays09_experimental_mixtures_mean_compatible']
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='memory_curves')
plt.show()
return locals()
def em_plot(sigmax_i, M_i):
f, ax = plt.subplots()
ax2 = ax.twinx()
# left axis, kappa
ax = utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 0][M_i, sigmax_i],
result_em_fits_std[..., 0][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Inverse variance $[rad^{-2}]$",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=8,
label="Fitted kappa",
color="k",
)
# Right axis, mixture probabilities
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 1][M_i, sigmax_i],
result_em_fits_std[..., 1][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax2,
linewidth=3,
fmt="o-",
markersize=8,
label="Target",
)
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 2][M_i, sigmax_i],
result_em_fits_std[..., 2][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax2,
linewidth=3,
fmt="o-",
markersize=8,
label="Nontarget",
)
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 3][M_i, sigmax_i],
result_em_fits_std[..., 3][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax2,
linewidth=3,
fmt="o-",
markersize=8,
label="Random",
)
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax.legend(lines + lines2, labels + labels2)
ax.set_title("M %d, sigmax %.2f" % (M_space[M_i], sigmax_space[sigmax_i]))
ax.set_xlim([0.9, T_space.size])
ax.set_xticks(range(1, T_space.size + 1))
ax.set_xticklabels(range(1, T_space.size + 1))
f.canvas.draw()
if savefigs:
dataio.save_current_figure(
"memorycurves_emfits_M%dsigmax%.2f_{label}_{unique_id}.pdf" % (M_space[M_i], sigmax_space[sigmax_i])
)
def check_precision_sensitivity_determ():
''' Let's construct a situation where we have one Von Mises component and one random component. See how the random component affects the basic precision estimator we use elsewhere.
'''
N = 1000
kappa_space = np.array([3., 10., 20.])
# kappa_space = np.array([3.])
nb_repeats = 20
ratio_to_kappa = False
savefigs = True
precision_nb_samples = 101
N_rnd_space = np.linspace(0, N/2, precision_nb_samples).astype(int)
precision_all = np.zeros((N_rnd_space.size, nb_repeats))
kappa_estimated_all = np.zeros((N_rnd_space.size, nb_repeats))
precision_squared_all = np.zeros((N_rnd_space.size, nb_repeats))
kappa_mixtmodel_all = np.zeros((N_rnd_space.size, nb_repeats))
mixtmodel_all = np.zeros((N_rnd_space.size, nb_repeats, 2))
dataio = DataIO.DataIO()
target_samples = np.zeros(N)
for kappa in kappa_space:
true_kappa = kappa*np.ones(N_rnd_space.size)
# First sample all as von mises
samples_all = spst.vonmises.rvs(kappa, size=(N_rnd_space.size, nb_repeats, N))
for repeat in progress.ProgressDisplay(xrange(nb_repeats)):
for i, N_rnd in enumerate(N_rnd_space):
samples = samples_all[i, repeat]
# Then set K of them to random [-np.pi, np.pi] values.
samples[np.random.randint(N, size=N_rnd)] = utils.sample_angle(N_rnd)
# Estimate precision from those samples.
precision_all[i, repeat] = utils.compute_precision_samples(samples, square_precision=False, remove_chance_level=False)
precision_squared_all[i, repeat] = utils.compute_precision_samples(samples, square_precision=True)
# convert circular std dev back to kappa
kappa_estimated_all[i, repeat] = utils.stddev_to_kappa(1./precision_all[i, repeat])
# Fit mixture model
params_fit = em_circularmixture.fit(samples, target_samples)
kappa_mixtmodel_all[i, repeat] = params_fit['kappa']
mixtmodel_all[i, repeat] = params_fit['mixt_target'], params_fit['mixt_random']
print "%d/%d N_rnd: %d, Kappa: %.3f, precision: %.3f, kappa_tilde: %.3f, precision^2: %.3f, kappa_mixtmod: %.3f" % (repeat, nb_repeats, N_rnd, kappa, precision_all[i, repeat], kappa_estimated_all[i, repeat], precision_squared_all[i, repeat], kappa_mixtmodel_all[i, repeat])
if ratio_to_kappa:
precision_all /= kappa
precision_squared_all /= kappa
kappa_estimated_all /= kappa
true_kappa /= kappa
f, ax = plt.subplots()
ax.plot(N_rnd_space/float(N), true_kappa, 'k-', linewidth=3, label='Kappa_true')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(precision_all, axis=-1), np.std(precision_all, axis=-1), ax_handle=ax, label='precision')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(precision_squared_all, axis=-1), np.std(precision_squared_all, axis=-1), ax_handle=ax, label='precision^2')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(kappa_estimated_all, axis=-1), np.std(kappa_estimated_all, axis=-1), ax_handle=ax, label='kappa_tilde')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(kappa_mixtmodel_all, axis=-1), np.std(kappa_mixtmodel_all, axis=-1), ax_handle=ax, label='kappa mixt model')
ax.legend()
ax.set_title('Effect of random samples on precision. kappa: %.2f. ratiokappa %s' % (kappa, ratio_to_kappa))
ax.set_xlabel('Proportion random samples. N tot %d' % N)
ax.set_ylabel('Kappa/precision (not same units)')
f.canvas.draw()
if savefigs:
dataio.save_current_figure("precision_sensitivity_kappa%dN%d_{unique_id}.pdf" % (kappa, N))
# Do another plot, with kappa and mixt_target/mixt_random. Use left/right axis separately
f, ax = plt.subplots()
ax2 = ax.twinx()
# left axis, kappa
ax.plot(N_rnd_space/float(N), true_kappa, 'k-', linewidth=3, label='kappa true')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(kappa_mixtmodel_all, axis=-1), np.std(kappa_mixtmodel_all, axis=-1), ax_handle=ax, label='kappa')
# Right axis, mixture probabilities
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(mixtmodel_all[..., 0], axis=-1), np.std(mixtmodel_all[..., 0], axis=-1), ax_handle=ax2, label='mixt target', color='r')
utils.plot_mean_std_area(N_rnd_space/float(N), np.mean(mixtmodel_all[..., 1], axis=-1), np.std(mixtmodel_all[..., 1], axis=-1), ax_handle=ax2, label='mixt random', color='g')
ax.set_title('Mixture model parameters evolution. kappa: %.2f, ratiokappa %s' % (kappa, ratio_to_kappa))
ax.set_xlabel('Proportion random samples. N tot %d' % N)
ax.set_ylabel('Kappa')
ax2.set_ylabel('Mixture proportions')
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax.legend(lines + lines2, labels + labels2)
if savefigs:
dataio.save_current_figure("precision_sensitivity_mixtmodel_kappa%dN%d_{unique_id}.pdf" % (kappa, N))
return locals()
def plots_specific_stimuli_hierarchical(data_pbs, generator_module=None):
'''
Reload and plot behaviour of mixed population code on specific Stimuli
of 3 items.
'''
#### SETUP
#
savefigs = True
savedata = True
plot_per_min_dist_all = True
specific_plots_paper = True
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
nb_repetitions = np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']).shape[-1]
enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
MMlower_valid_space = data_pbs.loaded_data['datasets_list'][0]['MMlower_valid_space']
ratio_space = MMlower_valid_space[:, 0]/float(np.sum(MMlower_valid_space[0]))
print enforce_min_distance_space
print sigmax_space
print MMlower_valid_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
if plot_per_min_dist_all:
# Do one plot per min distance.
for min_dist_i, min_dist in enumerate(enforce_min_distance_space):
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist)
if savefigs:
dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True)
if savefigs:
dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated model precision
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated Target, nontarget and random mixture components, in multiple subplots
_, axes = plt.subplots(1, 3, figsize=(18, 6))
plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5)
if savefigs:
dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot Log-likelihood of Mixture model, sanity check
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
if specific_plots_paper:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.09
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
## Do for each distance
# for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]:
for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot precision
utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa fitted
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa-stddev fitted. Easier to visualize
utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot LLH
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot mixture parameters
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T)
plt.ylim([0.0, 1.1])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot mixture parameters, SEM
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions))
plt.ylim([0.0, 1.1])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
all_args = data_pbs.loaded_data['args_list']
variables_to_save = ['result_all_precisions_mean', 'result_em_fits_mean', 'result_all_precisions_std', 'result_em_fits_std', 'result_em_kappastddev_mean', 'result_em_kappastddev_std', 'enforce_min_distance_space', 'sigmax_space', 'ratio_space', 'all_args']
if savedata:
dataio.save_variables(variables_to_save, locals())
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli')
plt.show()
return locals()
def plots_specific_stimuli_mixed(data_pbs, generator_module=None):
'''
Reload and plot behaviour of mixed population code on specific Stimuli
of 3 items.
'''
#### SETUP
#
savefigs = True
savedata = True
plot_per_min_dist_all = False
specific_plots_paper = False
plots_emfit_allitems = False
plot_min_distance_effect = True
compute_bootstraps = False
should_fit_allitems_model = True
# caching_emfit_filename = None
mixturemodel_to_use = 'allitems_uniquekappa'
# caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfitallitems_uniquekappa.pickle')
# mixturemodel_to_use = 'allitems_fikappa'
caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfit%s.pickle' % mixturemodel_to_use)
compute_fisher_info_perratioconj = True
caching_fisherinfo_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_fisherinfo.pickle')
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
all_args = data_pbs.loaded_data['args_list']
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_responses_all = np.squeeze(data_pbs.dict_arrays['result_responses']['results'])
result_target_all = np.squeeze(data_pbs.dict_arrays['result_target']['results'])
result_nontargets_all = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results'])
nb_repetitions = result_responses_all.shape[-1]
K = result_nontargets_all.shape[-2]
N = result_responses_all.shape[-2]
enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
ratio_space = data_pbs.loaded_data['datasets_list'][0]['ratio_space']
print enforce_min_distance_space
print sigmax_space
print ratio_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape
print result_responses_all.shape
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
# Reload cached emfitallitems
if caching_emfit_filename is not None:
if os.path.exists(caching_emfit_filename):
# Got file, open it and try to use its contents
try:
with open(caching_emfit_filename, 'r') as file_in:
# Load and assign values
print "Reloader EM fits from cache", caching_emfit_filename
cached_data = pickle.load(file_in)
result_emfitallitems = cached_data['result_emfitallitems']
mixturemodel_used = cached_data.get('mixturemodel_used', '')
if mixturemodel_used != mixturemodel_to_use:
print "warning, reloaded model used a different mixture model class"
should_fit_allitems_model = False
except IOError:
print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits"
# Load the Fisher Info from cache if exists. If not, compute it.
if caching_fisherinfo_filename is not None:
if os.path.exists(caching_fisherinfo_filename):
# Got file, open it and try to use its contents
try:
with open(caching_fisherinfo_filename, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
result_fisherinfo_mindist_sigmax_ratio = cached_data['result_fisherinfo_mindist_sigmax_ratio']
compute_fisher_info_perratioconj = False
except IOError:
print "Error while loading ", caching_fisherinfo_filename, "falling back to computing the Fisher Info"
if compute_fisher_info_perratioconj:
# We did not save the Fisher info, but need it if we want to fit the mixture model with fixed kappa. So recompute them using the args_dicts
result_fisherinfo_mindist_sigmax_ratio = np.empty((enforce_min_distance_space.size, sigmax_space.size, ratio_space.size))
# Invert the all_args_i -> min_dist, sigmax indexing
parameters_indirections = data_pbs.loaded_data['parameters_dataset_index']
# min_dist_i, sigmax_level_i, ratio_i
for min_dist_i, min_dist in enumerate(enforce_min_distance_space):
for sigmax_i, sigmax in enumerate(sigmax_space):
# Get index of first dataset with the current (min_dist, sigmax) (no need for the others, I think)
arg_index = parameters_indirections[(min_dist, sigmax)][0]
# Now using this dataset, reconstruct a RandomFactorialNetwork and compute the fisher info
curr_args = all_args[arg_index]
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# Update param
curr_args['ratio_conj'] = ratio_conj
# curr_args['stimuli_generation'] = 'specific_stimuli'
(_, _, _, sampler) = launchers.init_everything(curr_args)
# Theo Fisher info
result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_i, ratio_conj_i] = sampler.estimate_fisher_info_theocov()
print "Min dist: %.2f, Sigmax: %.2f, Ratio: %.2f: %.3f" % (min_dist, sigmax, ratio_conj, result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_i, ratio_conj_i])
# Save everything to a file, for faster later plotting
if caching_fisherinfo_filename is not None:
try:
with open(caching_fisherinfo_filename, 'w') as filecache_out:
data_cache = dict(result_fisherinfo_mindist_sigmax_ratio=result_fisherinfo_mindist_sigmax_ratio)
pickle.dump(data_cache, filecache_out, protocol=2)
except IOError:
print "Error writing out to caching file ", caching_fisherinfo_filename
if plot_per_min_dist_all:
# Do one plot per min distance.
for min_dist_i, min_dist in enumerate(enforce_min_distance_space):
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist)
if savefigs:
dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True)
if savefigs:
dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated model precision
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated Target, nontarget and random mixture components, in multiple subplots
_, axes = plt.subplots(1, 3, figsize=(18, 6))
plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5)
if savefigs:
dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot Log-likelihood of Mixture model, sanity check
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
if specific_plots_paper:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
## Do for each distance
# for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]:
for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot precision
if False:
utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, np.max(result_all_precisions_mean[min_dist_i, sigmax_level_i] + result_all_precisions_std[min_dist_i, sigmax_level_i])])
if savefigs:
dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa fitted
ax_handle = utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa')
# Add distance between items in kappa units
dist_items_kappa = utils.stddev_to_kappa(enforce_min_distance_space[min_dist_i])
ax_handle.plot(ratio_space, dist_items_kappa*np.ones(ratio_space.size), 'k--', linewidth=3)
plt.ylim([-0.1, np.max((np.max(result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0] + result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]), 1.1*dist_items_kappa))])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa-stddev fitted. Easier to visualize
ax_handle = utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev')
# Add distance between items in std dev units
dist_items_std = (enforce_min_distance_space[min_dist_i])
ax_handle.plot(ratio_space, dist_items_std*np.ones(ratio_space.size), 'k--', linewidth=3)
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, 1.1*np.max((np.max(result_em_kappastddev_mean[min_dist_i, sigmax_level_i] + result_em_kappastddev_std[min_dist_i, sigmax_level_i]), dist_items_std))])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if False:
# Plot LLH
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot mixture parameters, std
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T)
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Mixture parameters, SEM
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions))
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if plots_emfit_allitems:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
min_dist_i_plotting_space = np.array([min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i])
if should_fit_allitems_model:
# kappa, mixt_target, mixt_nontargets (K), mixt_random, LL, bic
# result_emfitallitems = np.empty((min_dist_i_plotting_space.size, ratio_space.size, 2*K+5))*np.nan
result_emfitallitems = np.empty((enforce_min_distance_space.size, ratio_space.size, K+5))*np.nan
## Do for each distance
# for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space):
for min_dist_i in xrange(enforce_min_distance_space.size):
# Fit the mixture model
for ratio_i, ratio in enumerate(ratio_space):
print "Refitting EM all items. Ratio:", ratio, "Dist:", enforce_min_distance_space[min_dist_i]
if mixturemodel_to_use == 'allitems_uniquekappa':
em_fit = em_circularmixture_allitems_uniquekappa.fit(
result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)))
elif mixturemodel_to_use == 'allitems_fikappa':
em_fit = em_circularmixture_allitems_kappafi.fit(result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)),
kappa=result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_level_i, ratio_i])
else:
raise ValueError("Wrong mixturemodel_to_use, %s" % mixturemodel_to_use)
result_emfitallitems[min_dist_i, ratio_i] = [em_fit['kappa'], em_fit['mixt_target']] + em_fit['mixt_nontargets'].tolist() + [em_fit[key] for key in ('mixt_random', 'train_LL', 'bic')]
# Save everything to a file, for faster later plotting
if caching_emfit_filename is not None:
try:
with open(caching_emfit_filename, 'w') as filecache_out:
data_em = dict(result_emfitallitems=result_emfitallitems, target_sigmax=target_sigmax)
pickle.dump(data_em, filecache_out, protocol=2)
except IOError:
print "Error writing out to caching file ", caching_emfit_filename
## Plots now, for each distance!
# for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space):
for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot now
_, ax = plt.subplots()
ax.plot(ratio_space, result_emfitallitems[min_dist_i, :, 1:5], linewidth=3)
plt.ylim([0.0, 1.1])
plt.legend(['Target', 'Nontarget 1', 'Nontarget 2', 'Random'], loc='upper left')
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobsfullitems_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if plot_min_distance_effect:
conj_receptive_field_size = 2.*np.pi/((all_args[0]['M']*ratio_space)**0.5)
target_vs_nontargets_mindist_ratio = result_emfitallitems[..., 1]/np.sum(result_emfitallitems[..., 1:4], axis=-1)
nontargetsmean_vs_targnontarg_mindist_ratio = np.mean(result_emfitallitems[..., 2:4]/np.sum(result_emfitallitems[..., 1:4], axis=-1)[..., np.newaxis], axis=-1)
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# Do one plot per ratio, putting the receptive field size on each
f, ax = plt.subplots()
ax.plot(enforce_min_distance_space[1:], target_vs_nontargets_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='target mixture')
ax.plot(enforce_min_distance_space[1:], nontargetsmean_vs_targnontarg_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='non-target mixture')
# ax.plot(enforce_min_distance_space[1:], result_emfitallitems[1:, ratio_conj_i, 1:5], linewidth=3)
ax.axvline(x=conj_receptive_field_size[ratio_conj_i]/2., color='k', linestyle='--', linewidth=2)
ax.axvline(x=conj_receptive_field_size[ratio_conj_i]*2., color='r', linestyle='--', linewidth=2)
plt.legend(loc='upper left')
plt.grid()
# ax.set_xlabel('Stimuli separation')
# ax.set_ylabel('Ratio Target to Non-targets')
plt.axis('tight')
ax.set_ylim([0.0, 1.0])
ax.set_xlim([enforce_min_distance_space[1:].min(), enforce_min_distance_space[1:].max()])
if savefigs:
dataio.save_current_figure('ratio%.2f_mindistpred_ratiotargetnontarget_{label}_{unique_id}.pdf' % ratio_conj)
if compute_bootstraps:
## Bootstrap evaluation
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.5
target_mindist_high = 1.
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
# cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap.pickle')
cache_bootstrap_fn = '/Users/loicmatthey/Dropbox/UCL/1-phd/Work/Visual_working_memory/code/git-bayesian-visual-working-memory/Experiments/specific_stimuli/specific_stimuli_corrected_mixed_sigmaxmindistance_autoset_repetitions5mult_collectall_281113_outputs/cache_bootstrap.pickle'
try:
with open(cache_bootstrap_fn, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
bootstrap_ecdf_bays_sigmax_T = cached_data['bootstrap_ecdf_bays_sigmax_T']
bootstrap_ecdf_allitems_sum_sigmax_T = cached_data['bootstrap_ecdf_allitems_sum_sigmax_T']
bootstrap_ecdf_allitems_all_sigmax_T = cached_data['bootstrap_ecdf_allitems_all_sigmax_T']
should_fit_bootstrap = False
except IOError:
print "Error while loading ", cache_bootstrap_fn
ratio_i = 0
# bootstrap_allitems_nontargets_allitems_uniquekappa = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat(
# result_responses_all[min_dist_level_low_i, sigmax_level_i, ratio_i].flatten(),
# result_target_all[min_dist_level_low_i, sigmax_level_i, ratio_i].flatten(),
# result_nontargets_all[min_dist_level_low_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)),
# sumnontargets_bootstrap_ecdf=bootstrap_ecdf_allitems_sum_sigmax_T[sigmax_level_i][K]['ecdf'],
# allnontargets_bootstrap_ecdf=bootstrap_ecdf_allitems_all_sigmax_T[sigmax_level_i][K]['ecdf']
# TODO FINISH HERE
variables_to_save = ['nb_repetitions']
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli')
plt.show()
return locals()
def plots_misbinding_logposterior(data_pbs, generator_module=None):
'''
Reload 3D volume runs from PBS and plot them
'''
#### SETUP
#
savedata = False
savefigs = True
plot_logpost = False
plot_error = False
plot_mixtmodel = True
plot_hist_responses_fisherinfo = True
compute_plot_bootstrap = False
compute_fisher_info_perratioconj = True
# mixturemodel_to_use = 'original'
mixturemodel_to_use = 'allitems'
# mixturemodel_to_use = 'allitems_kappafi'
caching_fisherinfo_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_fisherinfo.pickle')
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_log_posterior = np.squeeze(data_pbs.dict_arrays['result_all_log_posterior']['results'])
result_all_thetas = np.squeeze(data_pbs.dict_arrays['result_all_thetas']['results'])
ratio_space = data_pbs.loaded_data['parameters_uniques']['ratio_conj']
print ratio_space
print result_all_log_posterior.shape
N = result_all_thetas.shape[-1]
result_prob_wrong = np.zeros((ratio_space.size, N))
result_em_fits = np.empty((ratio_space.size, 6))*np.nan
all_args = data_pbs.loaded_data['args_list']
fixed_means = [-np.pi*0.6, np.pi*0.6]
all_angles = np.linspace(-np.pi, np.pi, result_all_log_posterior.shape[-1])
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
plt.rcParams['font.size'] = 18
if plot_hist_responses_fisherinfo:
# From cache
if caching_fisherinfo_filename is not None:
if os.path.exists(caching_fisherinfo_filename):
# Got file, open it and try to use its contents
try:
with open(caching_fisherinfo_filename, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
result_fisherinfo_ratio = cached_data['result_fisherinfo_ratio']
compute_fisher_info_perratioconj = False
except IOError:
print "Error while loading ", caching_fisherinfo_filename, "falling back to computing the Fisher Info"
if compute_fisher_info_perratioconj:
# We did not save the Fisher info, but need it if we want to fit the mixture model with fixed kappa. So recompute them using the args_dicts
result_fisherinfo_ratio = np.empty(ratio_space.shape)
# Invert the all_args_i -> ratio_conj direction
parameters_indirections = data_pbs.loaded_data['parameters_dataset_index']
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# Get index of first dataset with the current ratio_conj (no need for the others, I think)
arg_index = parameters_indirections[(ratio_conj,)][0]
# Now using this dataset, reconstruct a RandomFactorialNetwork and compute the fisher info
curr_args = all_args[arg_index]
curr_args['stimuli_generation'] = lambda T: np.linspace(-np.pi*0.6, np.pi*0.6, T)
(random_network, data_gen, stat_meas, sampler) = launchers.init_everything(curr_args)
# Theo Fisher info
result_fisherinfo_ratio[ratio_conj_i] = sampler.estimate_fisher_info_theocov()
del curr_args['stimuli_generation']
# Save everything to a file, for faster later plotting
if caching_fisherinfo_filename is not None:
try:
with open(caching_fisherinfo_filename, 'w') as filecache_out:
data_cache = dict(result_fisherinfo_ratio=result_fisherinfo_ratio)
pickle.dump(data_cache, filecache_out, protocol=2)
except IOError:
print "Error writing out to caching file ", caching_fisherinfo_filename
# Now plots. Do histograms of responses (around -pi/6 and pi/6), add Von Mises derived from Theo FI on top, and vertical lines for the correct target/nontarget angles.
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# Histogram
ax = utils.hist_angular_data(result_all_thetas[ratio_conj_i], bins=100, title='ratio %.2f, fi %.0f' % (ratio_conj, result_fisherinfo_ratio[ratio_conj_i]))
bar_heights, _, _ = utils.histogram_binspace(result_all_thetas[ratio_conj_i], bins=100, norm='density')
# Add Fisher info prediction on top
x = np.linspace(-np.pi, np.pi, 1000)
if result_fisherinfo_ratio[ratio_conj_i] < 700:
# Von Mises PDF
utils.plot_vonmises_pdf(x, utils.stddev_to_kappa(1./result_fisherinfo_ratio[ratio_conj_i]**0.5), mu=fixed_means[-1], ax_handle=ax, linewidth=3, color='r', scale=np.max(bar_heights), fmt='-')
else:
# Switch to Gaussian instead
utils.plot_normal_pdf(x, mu=fixed_means[-1], std=1./result_fisherinfo_ratio[ratio_conj_i]**0.5, ax_handle=ax, linewidth=3, color='r', scale=np.max(bar_heights), fmt='-')
# ax.set_xticks([])
# ax.set_yticks([])
# Add vertical line to correct target/nontarget
ax.axvline(x=fixed_means[0], color='g', linewidth=2)
ax.axvline(x=fixed_means[1], color='r', linewidth=2)
ax.get_figure().canvas.draw()
if savefigs:
# plt.tight_layout()
dataio.save_current_figure('results_misbinding_histresponses_vonmisespdf_ratioconj%.2f{label}_{unique_id}.pdf' % (ratio_conj))
if plot_logpost:
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# ax = utils.plot_mean_std_area(all_angles, nanmean(result_all_log_posterior[ratio_conj_i], axis=0), nanstd(result_all_log_posterior[ratio_conj_i], axis=0))
# ax.set_xlim((-np.pi, np.pi))
# ax.set_xticks((-np.pi, -np.pi / 2, 0, np.pi / 2., np.pi))
# ax.set_xticklabels((r'$-\pi$', r'$-\frac{\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$', r'$\pi$'))
# ax.set_yticks(())
# ax.get_figure().canvas.draw()
# if savefigs:
# dataio.save_current_figure('results_misbinding_logpost_ratioconj%.2f_{label}_global_{unique_id}.pdf' % ratio_conj)
# Compute the probability of answering wrongly (from fitting mixture distrib onto posterior)
for n in xrange(result_all_log_posterior.shape[1]):
result_prob_wrong[ratio_conj_i, n], _, _ = utils.fit_gaussian_mixture_fixedmeans(all_angles, np.exp(result_all_log_posterior[ratio_conj_i, n]), fixed_means=fixed_means, normalise=True, return_fitted_data=False, should_plot=False)
# ax = utils.plot_mean_std_area(ratio_space, nanmean(result_prob_wrong, axis=-1), nanstd(result_prob_wrong, axis=-1))
plt.figure()
plt.plot(ratio_space, utils.nanmean(result_prob_wrong, axis=-1))
# ax.get_figure().canvas.draw()
if savefigs:
dataio.save_current_figure('results_misbinding_probwrongpost_allratioconj_{label}_global_{unique_id}.pdf')
if plot_error:
## Compute Standard deviation/precision from samples and plot it as a function of ratio_conj
stats = utils.compute_mean_std_circular_data(utils.wrap_angles(result_all_thetas - fixed_means[1]).T)
f = plt.figure()
plt.plot(ratio_space, stats['std'])
plt.ylabel('Standard deviation [rad]')
if savefigs:
dataio.save_current_figure('results_misbinding_stddev_allratioconj_{label}_global_{unique_id}.pdf')
f = plt.figure()
plt.plot(ratio_space, utils.compute_angle_precision_from_std(stats['std'], square_precision=False), linewidth=2)
plt.ylabel('Precision [$1/rad$]')
plt.xlabel('Proportion of conjunctive units')
plt.grid()
if savefigs:
dataio.save_current_figure('results_misbinding_precision_allratioconj_{label}_global_{unique_id}.pdf')
## Compute the probability of misbinding
# 1) Just count samples < 0 / samples tot
# 2) Fit a mixture model, average over mixture probabilities
prob_smaller0 = np.sum(result_all_thetas <= 1, axis=1)/float(result_all_thetas.shape[1])
em_centers = np.zeros((ratio_space.size, 2))
em_covs = np.zeros((ratio_space.size, 2))
em_pk = np.zeros((ratio_space.size, 2))
em_ll = np.zeros(ratio_space.size)
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
cen_lst, cov_lst, em_pk[ratio_conj_i], em_ll[ratio_conj_i] = pygmm.em(result_all_thetas[ratio_conj_i, np.newaxis].T, K = 2, max_iter = 400, init_kw={'cluster_init':'fixed', 'fixed_means': fixed_means})
em_centers[ratio_conj_i] = np.array(cen_lst).flatten()
em_covs[ratio_conj_i] = np.array(cov_lst).flatten()
# print em_centers
# print em_covs
# print em_pk
f = plt.figure()
plt.plot(ratio_space, prob_smaller0)
plt.ylabel('Misbound proportion')
if savefigs:
dataio.save_current_figure('results_misbinding_countsmaller0_allratioconj_{label}_global_{unique_id}.pdf')
f = plt.figure()
plt.plot(ratio_space, np.max(em_pk, axis=-1), 'g', linewidth=2)
plt.ylabel('Mixture proportion, correct')
plt.xlabel('Proportion of conjunctive units')
plt.grid()
if savefigs:
dataio.save_current_figure('results_misbinding_emmixture_allratioconj_{label}_global_{unique_id}.pdf')
# Put everything on one figure
f = plt.figure(figsize=(10, 6))
norm_for_plot = lambda x: (x - np.min(x))/np.max((x - np.min(x)))
plt.plot(ratio_space, norm_for_plot(stats['std']), ratio_space, norm_for_plot(utils.compute_angle_precision_from_std(stats['std'], square_precision=False)), ratio_space, norm_for_plot(prob_smaller0), ratio_space, norm_for_plot(em_pk[:, 1]), ratio_space, norm_for_plot(em_pk[:, 0]))
plt.legend(('Std dev', 'Precision', 'Prob smaller 1', 'Mixture proportion correct', 'Mixture proportion misbinding'))
# plt.plot(ratio_space, norm_for_plot(compute_angle_precision_from_std(stats['std'], square_precision=False)), ratio_space, norm_for_plot(em_pk[:, 1]), linewidth=2)
# plt.legend(('Precision', 'Mixture proportion correct'), loc='best')
plt.grid()
if savefigs:
dataio.save_current_figure('results_misbinding_allmetrics_allratioconj_{label}_global_{unique_id}.pdf')
if plot_mixtmodel:
# Fit Paul's model
target_angle = np.ones(N)*fixed_means[1]
nontarget_angles = np.ones((N, 1))*fixed_means[0]
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
print "Ratio: ", ratio_conj
responses = result_all_thetas[ratio_conj_i]
if mixturemodel_to_use == 'allitems_kappafi':
curr_params_fit = em_circularmixture_allitems_kappafi.fit(responses, target_angle, nontarget_angles, kappa=result_fisherinfo_ratio[ratio_conj_i])
elif mixturemodel_to_use == 'allitems':
curr_params_fit = em_circularmixture_allitems_uniquekappa.fit(responses, target_angle, nontarget_angles)
else:
curr_params_fit = em_circularmixture.fit(responses, target_angle, nontarget_angles)
result_em_fits[ratio_conj_i] = [curr_params_fit['kappa'], curr_params_fit['mixt_target']] + utils.arrnum_to_list(curr_params_fit['mixt_nontargets']) + [curr_params_fit[key] for key in ('mixt_random', 'train_LL', 'bic')]
print curr_params_fit
if False:
f, ax = plt.subplots()
ax2 = ax.twinx()
# left axis, kappa
ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 0], 0*result_em_fits[:, 0], xlabel='Proportion of conjunctive units', ylabel="Inverse variance $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa', color='k')
# Right axis, mixture probabilities
utils.plot_mean_std_area(ratio_space, result_em_fits[:, 1], 0*result_em_fits[:, 1], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Target')
utils.plot_mean_std_area(ratio_space, result_em_fits[:, 2], 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Nontarget')
utils.plot_mean_std_area(ratio_space, result_em_fits[:, 3], 0*result_em_fits[:, 3], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Random')
lines, labels = ax.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax.legend(lines + lines2, labels + labels2, fontsize=12, loc='right')
# ax.set_xlim([0.9, 5.1])
# ax.set_xticks(range(1, 6))
# ax.set_xticklabels(range(1, 6))
plt.grid()
f.canvas.draw()
if True:
# Mixture probabilities
ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 1], 0*result_em_fits[:, 1], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", linewidth=3, fmt='-', markersize=8, label='Target')
utils.plot_mean_std_area(ratio_space, result_em_fits[:, 2], 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='-', markersize=8, label='Nontarget')
utils.plot_mean_std_area(ratio_space, result_em_fits[:, 3], 0*result_em_fits[:, 3], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='-', markersize=8, label='Random')
ax.legend(loc='right')
# ax.set_xlim([0.9, 5.1])
# ax.set_xticks(range(1, 6))
# ax.set_xticklabels(range(1, 6))
plt.grid()
if savefigs:
dataio.save_current_figure('results_misbinding_emmixture_allratioconj_{label}_global_{unique_id}.pdf')
if True:
# Kappa
# ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 0], 0*result_em_fits[:, 0], xlabel='Proportion of conjunctive units', ylabel="$\kappa [rad^{-2}]$", linewidth=3, fmt='-', markersize=8, label='Kappa')
ax = utils.plot_mean_std_area(ratio_space, utils.kappa_to_stddev(result_em_fits[:, 0]), 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Standard deviation [rad]", linewidth=3, fmt='-', markersize=8, label='Mixture model $\kappa$')
# Add Fisher Info theo
ax = utils.plot_mean_std_area(ratio_space, utils.kappa_to_stddev(result_fisherinfo_ratio), 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Standard deviation [rad]", linewidth=3, fmt='-', markersize=8, label='Fisher Information', ax_handle=ax)
ax.legend(loc='best')
# ax.set_xlim([0.9, 5.1])
# ax.set_xticks(range(1, 6))
# ax.set_xticklabels(range(1, 6))
plt.grid()
if savefigs:
dataio.save_current_figure('results_misbinding_kappa_allratioconj_{label}_global_{unique_id}.pdf')
if compute_plot_bootstrap:
## Compute the bootstrap pvalue for each ratio
# use the bootstrap CDF from mixed runs, not the exact current ones, not sure if good idea.
bootstrap_to_load = 1
if bootstrap_to_load == 1:
cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap_mixed_from_bootstrapnontargets.pickle')
bootstrap_ecdf_sum_label = 'bootstrap_ecdf_allitems_sum_sigmax_T'
bootstrap_ecdf_all_label = 'bootstrap_ecdf_allitems_all_sigmax_T'
elif bootstrap_to_load == 2:
cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap_misbinding_mixed.pickle')
bootstrap_ecdf_sum_label = 'bootstrap_ecdf_allitems_sum_ratioconj'
bootstrap_ecdf_all_label = 'bootstrap_ecdf_allitems_all_ratioconj'
try:
with open(cache_bootstrap_fn, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
assert bootstrap_ecdf_sum_label in cached_data
assert bootstrap_ecdf_all_label in cached_data
should_fit_bootstrap = False
except IOError:
print "Error while loading ", cache_bootstrap_fn
# Select the ECDF to use
if bootstrap_to_load == 1:
sigmax_i = 3 # corresponds to sigmax = 2, input here.
T_i = 1 # two possible targets here.
bootstrap_ecdf_sum_used = cached_data[bootstrap_ecdf_sum_label][sigmax_i][T_i]['ecdf']
bootstrap_ecdf_all_used = cached_data[bootstrap_ecdf_all_label][sigmax_i][T_i]['ecdf']
elif bootstrap_to_load == 2:
ratio_conj_i = 4
bootstrap_ecdf_sum_used = cached_data[bootstrap_ecdf_sum_label][ratio_conj_i]['ecdf']
bootstrap_ecdf_all_used = cached_data[bootstrap_ecdf_all_label][ratio_conj_i]['ecdf']
result_pvalue_bootstrap_sum = np.empty(ratio_space.size)*np.nan
result_pvalue_bootstrap_all = np.empty((ratio_space.size, nontarget_angles.shape[-1]))*np.nan
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
print "Ratio: ", ratio_conj
responses = result_all_thetas[ratio_conj_i]
bootstrap_allitems_nontargets_allitems_uniquekappa = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat(responses, target_angle, nontarget_angles,
sumnontargets_bootstrap_ecdf=bootstrap_ecdf_sum_used,
allnontargets_bootstrap_ecdf=bootstrap_ecdf_all_used)
result_pvalue_bootstrap_sum[ratio_conj_i] = bootstrap_allitems_nontargets_allitems_uniquekappa['p_value']
result_pvalue_bootstrap_all[ratio_conj_i] = bootstrap_allitems_nontargets_allitems_uniquekappa['allnontarget_p_value']
## Plots
# f, ax = plt.subplots()
# ax.plot(ratio_space, result_pvalue_bootstrap_all, linewidth=2)
# if savefigs:
# dataio.save_current_figure("pvalue_bootstrap_all_ratioconj_{label}_{unique_id}.pdf")
f, ax = plt.subplots()
ax.plot(ratio_space, result_pvalue_bootstrap_sum, linewidth=2)
plt.grid()
if savefigs:
dataio.save_current_figure("pvalue_bootstrap_sum_ratioconj_{label}_{unique_id}.pdf")
# plt.figure()
# plt.plot(ratio_MMlower, results_filtered_smoothed/np.max(results_filtered_smoothed, axis=0), linewidth=2)
# plt.plot(ratio_MMlower[np.argmax(results_filtered_smoothed, axis=0)], np.ones(results_filtered_smoothed.shape[-1]), 'ro', markersize=10)
# plt.grid()
# plt.ylim((0., 1.1))
# plt.subplots_adjust(right=0.8)
# plt.legend(['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='center right', bbox_to_anchor=(1.3, 0.5))
# plt.xticks(np.linspace(0, 1.0, 5))
variables_to_save = ['target_angle', 'nontarget_angles']
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='misbindings')
plt.show()
return locals()
def __plot_mixtcurves(self, model_em_fits, suptitle_text=None, ax=None):
"""
Similar kind of plot, but showing the mixture proportions, as in Figure13
"""
T_space = self.fit_exp.T_space
data_em_fits = self.fit_exp.experimental_dataset["em_fits_nitems_arrays"]
if ax is None:
_, ax = plt.subplots()
else:
ax.hold(False)
model_em_fits["mean"][np.isnan(model_em_fits["mean"])] = 0.0
model_em_fits["std"][np.isnan(model_em_fits["std"])] = 0.0
# Show model fits
utils.plot_mean_std_area(
T_space,
model_em_fits["mean"][..., 1],
model_em_fits["std"][..., 1],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Target",
)
ax.hold(True)
utils.plot_mean_std_area(
T_space,
model_em_fits["mean"][..., 2],
model_em_fits["std"][..., 2],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Nontarget",
)
utils.plot_mean_std_area(
T_space,
model_em_fits["mean"][..., 3],
model_em_fits["std"][..., 3],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Random",
)
# Now data
utils.plot_mean_std_area(
T_space,
data_em_fits["mean"][0],
data_em_fits["std"][0],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=2,
fmt="o:",
markersize=5,
label="Data target",
)
utils.plot_mean_std_area(
T_space,
data_em_fits["mean"][1],
data_em_fits["std"][1],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=2,
fmt="o:",
markersize=5,
label="Data nontarget",
)
utils.plot_mean_std_area(
T_space,
data_em_fits["mean"][2],
data_em_fits["std"][2],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=2,
fmt="o:",
markersize=5,
label="Data random",
)
ax.legend(prop={"size": 15}, loc="center right", bbox_to_anchor=(1.1, 0.5))
ax.set_xlim([0.9, T_space.max() + 0.1])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, T_space.max() + 1))
ax.set_xticklabels(range(1, T_space.max() + 1))
if suptitle_text:
ax.get_figure().suptitle(suptitle_text)
ax.get_figure().canvas.draw()
return ax
def plots_specific_stimuli_hierarchical(data_pbs, generator_module=None):
'''
Reload and plot behaviour of mixed population code on specific Stimuli
of 3 items.
'''
#### SETUP
#
savefigs = True
savedata = True
plot_per_min_dist_all = False
specific_plots_paper = False
plots_emfit_allitems = False
plot_min_distance_effect = True
should_fit_allitems_model = True
# caching_emfit_filename = None
caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfitallitems_uniquekappa.pickle')
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_responses_all = np.squeeze(data_pbs.dict_arrays['result_responses']['results'])
result_target_all = np.squeeze(data_pbs.dict_arrays['result_target']['results'])
result_nontargets_all = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results'])
all_args = data_pbs.loaded_data['args_list']
nb_repetitions = np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']).shape[-1]
print nb_repetitions
nb_repetitions = result_responses_all.shape[-1]
print nb_repetitions
K = result_nontargets_all.shape[-2]
N = result_responses_all.shape[-2]
enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
MMlower_valid_space = data_pbs.loaded_data['datasets_list'][0]['MMlower_valid_space']
ratio_space = MMlower_valid_space[:, 0]/float(np.sum(MMlower_valid_space[0]))
print enforce_min_distance_space
print sigmax_space
print MMlower_valid_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
# Relaod cached emfitallitems
if caching_emfit_filename is not None:
if os.path.exists(caching_emfit_filename):
# Got file, open it and try to use its contents
try:
with open(caching_emfit_filename, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
result_emfitallitems = cached_data['result_emfitallitems']
should_fit_allitems_model = False
except IOError:
print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits"
if plot_per_min_dist_all:
# Do one plot per min distance.
for min_dist_i, min_dist in enumerate(enforce_min_distance_space):
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist)
if savefigs:
dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True)
if savefigs:
dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated model precision (kappa)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated Target, nontarget and random mixture components, in multiple subplots
_, axes = plt.subplots(1, 3, figsize=(18, 6))
plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5)
if savefigs:
dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot Log-likelihood of Mixture model, sanity check
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
if specific_plots_paper:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.09
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
## Do for each distance
# for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]:
for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot precision
if False:
utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, np.max(result_all_precisions_mean[min_dist_i, sigmax_level_i] + result_all_precisions_std[min_dist_i, sigmax_level_i])])
if savefigs:
dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa fitted
ax_handle = utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa')
# Add distance between items in kappa units
dist_items_kappa = utils.stddev_to_kappa(enforce_min_distance_space[min_dist_i])
ax_handle.plot(ratio_space, dist_items_kappa*np.ones(ratio_space.size), 'k--', linewidth=3)
plt.ylim([-0.1, np.max((np.max(result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0] + result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]), 1.1*dist_items_kappa))])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa-stddev fitted. Easier to visualize
ax_handle = utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev')
# Add distance between items in std dev units
dist_items_std = (enforce_min_distance_space[min_dist_i])
ax_handle.plot(ratio_space, dist_items_std*np.ones(ratio_space.size), 'k--', linewidth=3)
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, 1.1*np.max((np.max(result_em_kappastddev_mean[min_dist_i, sigmax_level_i] + result_em_kappastddev_std[min_dist_i, sigmax_level_i]), dist_items_std))])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if False:
# Plot LLH
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot mixture parameters, std
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T)
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Mixture parameters, SEM
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions))
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if plots_emfit_allitems:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
min_dist_i_plotting_space = np.array([min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i])
if should_fit_allitems_model:
# kappa, mixt_target, mixt_nontargets (K), mixt_random, LL, bic
# result_emfitallitems = np.empty((min_dist_i_plotting_space.size, ratio_space.size, 2*K+5))*np.nan
result_emfitallitems = np.empty((enforce_min_distance_space.size, ratio_space.size, K+5))*np.nan
## Do for each distance
# for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space):
for min_dist_i in xrange(enforce_min_distance_space.size):
# Fit the mixture model
for ratio_i, ratio in enumerate(ratio_space):
print "Refitting EM all items. Ratio:", ratio, "Dist:", enforce_min_distance_space[min_dist_i]
em_fit = em_circularmixture_allitems_uniquekappa.fit(
result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)))
result_emfitallitems[min_dist_i, ratio_i] = [em_fit['kappa'], em_fit['mixt_target']] + em_fit['mixt_nontargets'].tolist() + [em_fit[key] for key in ('mixt_random', 'train_LL', 'bic')]
# Save everything to a file, for faster later plotting
if caching_emfit_filename is not None:
try:
with open(caching_emfit_filename, 'w') as filecache_out:
data_em = dict(result_emfitallitems=result_emfitallitems)
pickle.dump(data_em, filecache_out, protocol=2)
except IOError:
print "Error writing out to caching file ", caching_emfit_filename
## Plots now, for each distance!
# for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space):
for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot now
_, ax = plt.subplots()
ax.plot(ratio_space, result_emfitallitems[min_dist_i, :, 1:5], linewidth=3)
plt.ylim([0.0, 1.1])
plt.legend(['Target', 'Nontarget 1', 'Nontarget 2', 'Random'], loc='upper left')
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobsfullitems_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if plot_min_distance_effect:
conj_receptive_field_size = 2.*np.pi/((all_args[0]['M']*ratio_space)**0.5)
target_vs_nontargets_mindist_ratio = result_emfitallitems[..., 1]/np.sum(result_emfitallitems[..., 1:4], axis=-1)
nontargetsmean_vs_targnontarg_mindist_ratio = np.mean(result_emfitallitems[..., 2:4]/np.sum(result_emfitallitems[..., 1:4], axis=-1)[..., np.newaxis], axis=-1)
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
# Do one plot per ratio, putting the receptive field size on each
f, ax = plt.subplots()
ax.plot(enforce_min_distance_space[1:], target_vs_nontargets_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='target mixture')
ax.plot(enforce_min_distance_space[1:], nontargetsmean_vs_targnontarg_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='non-target mixture')
# ax.plot(enforce_min_distance_space[1:], result_emfitallitems[1:, ratio_conj_i, 1:5], linewidth=3)
ax.axvline(x=conj_receptive_field_size[ratio_conj_i]/2., color='k', linestyle='--', linewidth=2)
ax.axvline(x=conj_receptive_field_size[ratio_conj_i]*2., color='r', linestyle='--', linewidth=2)
plt.legend(loc='upper left')
plt.grid()
# ax.set_xlabel('Stimuli separation')
# ax.set_ylabel('Ratio Target to Non-targets')
plt.axis('tight')
ax.set_ylim([0.0, 1.0])
ax.set_xlim([enforce_min_distance_space[1:].min(), enforce_min_distance_space[1:].max()])
if savefigs:
dataio.save_current_figure('ratio%.2f_mindistpred_ratiotargetnontarget_{label}_{unique_id}.pdf' % ratio_conj)
variables_to_save = ['nb_repetitions']
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli')
plt.show()
return locals()
def plots_3dvolume_hierarchical_M_Mlayerone(data_pbs, generator_module=None):
'''
Reload 3D volume runs from PBS and plot them
'''
#### SETUP
#
savefigs = True
savedata = False
plots_pcolors = False
plots_singleaxe = False
plots_multipleaxes = True
plots_multipleaxes_emfits = True
load_fit_mixture_model = True
# caching_emfit_filename = None
caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_emfit.pickle')
plt.rcParams['font.size'] = 16
#
#### /SETUP
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
print "Order parameters: ", generator_module.dict_parameters_range.keys()
results_precision_constant_M_Mlower = np.squeeze(utils.nanmean(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1))
results_precision_constant_M_Mlower_std = np.squeeze(utils.nanstd(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1))
results_responses = np.squeeze(data_pbs.dict_arrays['result_responses']['results'])
results_targets = np.squeeze(data_pbs.dict_arrays['result_targets']['results'])
results_nontargets = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results'])
results_emfits_M_T = np.squeeze(data_pbs.dict_arrays['results_emfits_M_T']['results'])
M_space = data_pbs.loaded_data['parameters_uniques']['M']
M_layer_one_space = data_pbs.loaded_data['parameters_uniques']['M_layer_one']
ratio_MMlower_space = M_space/generator_module.filtering_function_parameters['target_M_total']
filtering_indices = (np.arange(M_space.size), np.arange(-M_layer_one_space.size, 0)[::-1])
T = results_precision_constant_M_Mlower.shape[-1]
T_space = np.arange(T)
print M_space
print M_layer_one_space
print results_precision_constant_M_Mlower.shape
# print results_precision_constant_M_Mlower
T = results_precision_constant_M_Mlower.shape[-1]
results_precision_filtered = results_precision_constant_M_Mlower[filtering_indices]
results_precision_filtered_std = results_precision_constant_M_Mlower_std[filtering_indices]
results_responses_filtered = results_responses[filtering_indices]
results_targets_filtered = results_targets[filtering_indices]
results_nontargets_filtered = results_nontargets[filtering_indices]
results_emfits_M_T_filtered = results_emfits_M_T[filtering_indices]
results_precision_filtered_smoothed = np.apply_along_axis(smooth, 0, results_precision_filtered, *(10, 'bartlett'))
if load_fit_mixture_model:
# Fit the mixture model on the samples
if caching_emfit_filename is not None:
if os.path.exists(caching_emfit_filename):
# Got file, open it and try to use its contents
try:
with open(caching_emfit_filename, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
result_emfits_filtered = cached_data['result_emfits_filtered']
print "Loading from cache file %s" % caching_emfit_filename
load_fit_mixture_model = False
except IOError:
print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits"
load_fit_mixture_model = False
if load_fit_mixture_model:
result_emfits_filtered = np.nan*np.empty((ratio_MMlower_space.size, T, 5))
# Fit EM model
print "fitting EM model"
for ratio_MMlower_i, ratio_MMlower in enumerate(ratio_MMlower_space):
for T_i in T_space:
if np.any(~np.isnan(results_responses_filtered[ratio_MMlower_i, T_i])):
print "ratio MM, T:", ratio_MMlower, T_i+1
curr_em_fits = em_circularmixture_allitems_uniquekappa.fit(results_responses_filtered[ratio_MMlower_i, T_i], results_targets_filtered[ratio_MMlower_i, T_i], results_nontargets_filtered[ratio_MMlower_i, T_i, :, :T_i])
curr_em_fits['mixt_nontargets_sum'] = np.sum(curr_em_fits['mixt_nontargets'])
result_emfits_filtered[ratio_MMlower_i, T_i] = [curr_em_fits[key] for key in ('kappa', 'mixt_target', 'mixt_nontargets_sum', 'mixt_random', 'train_LL')]
# Save everything to a file, for faster later plotting
if caching_emfit_filename is not None:
try:
with open(caching_emfit_filename, 'w') as filecache_out:
data_emfit = dict(result_emfits_filtered=result_emfits_filtered)
pickle.dump(data_emfit, filecache_out, protocol=2)
print "cache file %s written" % caching_emfit_filename
except IOError:
print "Error writing out to caching file ", caching_emfit_filename
if plots_pcolors:
utils.pcolor_2d_data(results_precision_filtered, log_scale=True, x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10)
plt.plot(np.argmax(results_precision_filtered, axis=0), np.arange(results_precision_filtered.shape[-1]), 'ko', markersize=10)
if savefigs:
dataio.save_current_figure('results_2dlog_{label}_global_{unique_id}.pdf')
utils.pcolor_2d_data(results_precision_filtered/np.max(results_precision_filtered, axis=0), x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10)
plt.plot(np.argmax(results_precision_filtered, axis=0), np.arange(results_precision_filtered.shape[-1]), 'ko', markersize=10)
if savefigs:
dataio.save_current_figure('results_2dnorm_{label}_global_{unique_id}.pdf')
utils.pcolor_2d_data(results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0), x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10)
plt.plot(np.argmax(results_precision_filtered_smoothed, axis=0), np.arange(results_precision_filtered_smoothed.shape[-1]), 'ko', markersize=10)
if savefigs:
dataio.save_current_figure('results_2dsmoothnorm_{label}_global_{unique_id}.pdf')
if plots_singleaxe:
plt.figure()
plt.plot(ratio_MMlower_space, results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0), linewidth=2)
plt.plot(ratio_MMlower_space[np.argmax(results_precision_filtered_smoothed, axis=0)], np.ones(results_precision_filtered_smoothed.shape[-1]), 'ro', markersize=10)
plt.grid()
plt.ylim((0., 1.1))
plt.subplots_adjust(right=0.8)
plt.legend(['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='center right', bbox_to_anchor=(1.3, 0.5))
plt.xticks(np.linspace(0, 1.0, 5))
if savefigs:
dataio.save_current_figure('results_1dsmoothnormsame_{label}_global_{unique_id}.pdf')
plt.figure()
moved_results_precision_filtered_smoothed = 1.2*np.arange(results_precision_filtered_smoothed.shape[-1]) + results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0)
all_lines = []
for i, max_i in enumerate(np.argmax(results_precision_filtered_smoothed, axis=0)):
curr_lines = plt.plot(ratio_MMlower_space, moved_results_precision_filtered_smoothed[:, i], linewidth=2)
plt.plot(ratio_MMlower_space[max_i], moved_results_precision_filtered_smoothed[max_i, i], 'o', markersize=10, color=curr_lines[0].get_color())
all_lines.extend(curr_lines)
plt.plot(np.linspace(0.0, 1.0, 100), np.outer(np.ones(100), 1.2*np.arange(1, results_precision_filtered_smoothed.shape[-1])), 'k:')
plt.grid()
plt.legend(all_lines, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='best')
plt.ylim((0., moved_results_precision_filtered_smoothed.max()*1.05))
plt.yticks([])
plt.xticks(np.linspace(0, 1.0, 5))
if savefigs:
dataio.save_current_figure('results_1dsmoothnorm_{label}_global_{unique_id}.pdf')
if plots_multipleaxes:
# Plot smooth precisions, all T on multiple subplots.
# all_lines = []
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
for i, max_ind in enumerate(np.argmax(results_precision_filtered_smoothed, axis=0)):
curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered_smoothed[:, i], linewidth=2) # , color=all_lines[i].get_color())
axes[i].plot(ratio_MMlower_space[max_ind], results_precision_filtered_smoothed[max_ind, i], 'o', markersize=10, color=curr_lines[0].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
axes[i].set_ylim((np.min(results_precision_filtered_smoothed[:, i]), results_precision_filtered_smoothed[max_ind, i]*1.1))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines.extend(curr_lines)
f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
# f.tight_layout()
if savefigs:
dataio.save_current_figure('results_subplots_1dsmoothnorm_{label}_global_{unique_id}.pdf')
# Plot precisions with standard deviation around
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
# all_lines_bis = []
for i, max_ind in enumerate(np.argmax(results_precision_filtered, axis=0)):
utils.plot_mean_std_area(ratio_MMlower_space, results_precision_filtered[:, i], results_precision_filtered_std[:, i], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color())
# curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
axes[i].set_ylim((np.min(results_precision_filtered[:, i]), results_precision_filtered[max_ind, i]*1.1))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
if savefigs:
dataio.save_current_figure('results_subplots_1dnorm_{label}_global_{unique_id}.pdf')
if plots_multipleaxes_emfits:
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
all_lines_bis = []
for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)):
utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 0], 0*result_emfits_filtered[:, i, 0], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color())
# curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
# axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
if savefigs:
dataio.save_current_figure('results_subplots_emkappa_{label}_global_{unique_id}.pdf')
variables_to_save = []
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='hierarchicalrandomnetwork_characterisation')
plt.show()
return locals()
def plots_memory_curves(data_pbs, generator_module=None):
"""
Reload and plot memory curve of a feature code.
Can use Marginal Fisher Information and fitted Mixture Model as well
"""
#### SETUP
#
savefigs = True
savedata = True
plot_pcolor_fit_precision_to_fisherinfo = True
plot_selected_memory_curves = True
plot_best_memory_curves = True
colormap = None # or 'cubehelix'
plt.rcParams["font.size"] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(
np.squeeze(data_pbs.dict_arrays["result_all_precisions"]["results"]), axis=-1
)
result_all_precisions_std = utils.nanstd(
np.squeeze(data_pbs.dict_arrays["result_all_precisions"]["results"]), axis=-1
)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays["result_em_fits"]["results"]), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays["result_em_fits"]["results"]), axis=-1)
result_marginal_inv_fi_mean = utils.nanmean(
np.squeeze(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"]), axis=-1
)
result_marginal_inv_fi_std = utils.nanstd(
np.squeeze(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"]), axis=-1
)
result_marginal_fi_mean = utils.nanmean(
1.0 / np.squeeze(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"]), axis=-1
)
result_marginal_fi_std = utils.nanstd(
1.0 / np.squeeze(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"]), axis=-1
)
M_space = data_pbs.loaded_data["parameters_uniques"]["M"]
sigmax_space = data_pbs.loaded_data["parameters_uniques"]["sigmax"]
T_space = data_pbs.loaded_data["datasets_list"][0]["T_space"]
print M_space
print sigmax_space
print T_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape, result_marginal_inv_fi_mean.shape
dataio = DataIO.DataIO(
output_folder=generator_module.pbs_submission_infos["simul_out_dir"] + "/outputs/",
label="global_" + dataset_infos["save_output_filename"],
)
## Load Experimental data
data_simult = load_experimental_data.load_data_simult(
data_dir=os.path.normpath(
os.path.join(os.path.split(load_experimental_data.__file__)[0], "../../experimental_data/")
)
)
memory_experimental = data_simult["precision_nitems_theo"]
data_bays2009 = load_experimental_data.load_data_bays09(
data_dir=os.path.normpath(
os.path.join(os.path.split(load_experimental_data.__file__)[0], "../../experimental_data/")
),
fit_mixture_model=True,
)
bays09_experimental_mixtures_mean = data_bays2009["em_fits_nitems_arrays"]["mean"][1:]
# add interpolated points for 3 and 5 items
bays3 = (bays09_experimental_mixtures_mean[:, 2] + bays09_experimental_mixtures_mean[:, 1]) / 2.0
bays5 = (bays09_experimental_mixtures_mean[:, -1] + bays09_experimental_mixtures_mean[:, -2]) / 2.0
bays09_experimental_mixtures_mean_compatible = c_[
bays09_experimental_mixtures_mean[:, :2], bays3, bays09_experimental_mixtures_mean[:, 2], bays5
]
# Boost non-targets
bays09_experimental_mixtures_mean_compatible[1] *= 1.5
bays09_experimental_mixtures_mean_compatible[2] /= 1.5
bays09_experimental_mixtures_mean_compatible /= np.sum(bays09_experimental_mixtures_mean_compatible, axis=0)
# Force non target em fit mixture to be zero and not nan
result_em_fits_mean[..., 0, 2] = 0
result_em_fits_std[..., 0, 2] = 0
# Compute some landscapes of fit!
dist_diff_precision_margfi = np.sum(
np.abs(result_all_precisions_mean * 2.0 - result_marginal_fi_mean[..., 0]) ** 2.0, axis=-1
)
dist_diff_precision_margfi_1item = (
np.abs(result_all_precisions_mean[..., 0] * 2.0 - result_marginal_fi_mean[..., 0, 0]) ** 2.0
)
dist_diff_emkappa_margfi = np.sum(
np.abs(result_em_fits_mean[..., 0] * 2.0 - result_marginal_fi_mean[..., 0]) ** 2.0, axis=-1
)
dist_ratio_emkappa_margfi = np.sum(
np.abs((result_em_fits_mean[..., 0] * 2.0) / result_marginal_fi_mean[..., 0] - 1.0) ** 2.0, axis=-1
)
dist_diff_precision_experim = np.sum(np.abs(result_all_precisions_mean - memory_experimental) ** 2.0, axis=-1)
dist_diff_precision_experim_1item = np.abs(result_all_precisions_mean[..., 0] - memory_experimental[0]) ** 2.0
dist_diff_emkappa_experim = np.sum(np.abs(result_em_fits_mean[..., 0] - memory_experimental) ** 2.0, axis=-1)
dist_diff_emkappa_experim_1item = np.abs(result_em_fits_mean[..., 0, 0] - memory_experimental[0]) ** 2.0
dist_diff_margfi_experim_1item = np.abs(result_marginal_fi_mean[..., 0, 0] - memory_experimental[0]) ** 2.0
dist_diff_emkappa_mixtures_bays09 = np.sum(
np.sum((result_em_fits_mean[..., 1:4] - bays09_experimental_mixtures_mean_compatible.T) ** 2.0, axis=-1),
axis=-1,
)
if plot_pcolor_fit_precision_to_fisherinfo:
# Check fit between precision and fisher info
utils.pcolor_2d_data(
dist_diff_precision_margfi, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
if savefigs:
dataio.save_current_figure("match_precision_margfi_log_pcolor_{label}_{unique_id}.pdf")
# utils.pcolor_2d_data(dist_diff_precision_margfi, x=M_space, y=sigmax_space[2:], xlabel='M', ylabel='sigmax')
# if savefigs:
# dataio.save_current_figure('match_precision_margfi_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(
dist_diff_precision_experim, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True
)
utils.pcolor_2d_data(
dist_diff_emkappa_experim, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True
)
utils.pcolor_2d_data(
dist_diff_precision_margfi
* dist_diff_emkappa_margfi
* dist_diff_precision_experim
* dist_diff_emkappa_experim,
x=M_space,
y=sigmax_space,
xlabel="M",
ylabel="sigmax",
log_scale=True,
)
utils.pcolor_2d_data(
dist_diff_precision_margfi_1item, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
utils.pcolor_2d_data(
dist_diff_precision_experim_1item, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
utils.pcolor_2d_data(
dist_diff_emkappa_experim_1item, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
utils.pcolor_2d_data(
dist_diff_margfi_experim_1item, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
utils.pcolor_2d_data(
dist_diff_emkappa_mixtures_bays09, log_scale=False, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax"
)
if plot_selected_memory_curves:
selected_values = [[100, 0.8], [200, 0.27], [100, 0.1], [200, 0.8], [100, 0.17], [100, 0.08], [50, 0.21]]
for current_values in selected_values:
# Find the indices
M_i = np.argmin(np.abs(current_values[0] - M_space))
sigmax_i = np.argmin(np.abs(current_values[1] - sigmax_space))
ax = utils.plot_mean_std_area(
T_space, memory_experimental, np.zeros(T_space.size), linewidth=3, fmt="o-", markersize=8
)
ax = utils.plot_mean_std_area(
T_space,
result_all_precisions_mean[M_i, sigmax_i],
result_all_precisions_std[M_i, sigmax_i],
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=8,
)
ax = utils.plot_mean_std_area(
T_space,
0.5 * result_marginal_fi_mean[..., 0][M_i, sigmax_i],
0.5 * result_marginal_fi_std[..., 0][M_i, sigmax_i],
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=8,
)
ax = utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 0][M_i, sigmax_i],
result_em_fits_std[..., 0][M_i, sigmax_i],
ax_handle=ax,
xlabel="Number of items",
ylabel="Inverse variance $[rad^{-2}]$",
linewidth=3,
fmt="o-",
markersize=8,
)
# ax.set_title('M %d, sigmax %.2f' % (M_space[M_i], sigmax_space[sigmax_i]))
plt.legend(["Experimental data", "Precision of samples", "Marginal Fisher Information", "Fitted kappa"])
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
if savefigs:
dataio.save_current_figure(
"memorycurves_M%dsigmax%.2f_{label}_{unique_id}.pdf" % (M_space[M_i], sigmax_space[sigmax_i])
)
def em_plot_paper(sigmax_i, M_i):
f, ax = plt.subplots()
# Right axis, mixture probabilities
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 1][M_i, sigmax_i],
result_em_fits_std[..., 1][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Target",
)
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 2][M_i, sigmax_i],
result_em_fits_std[..., 2][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Nontarget",
)
utils.plot_mean_std_area(
T_space,
result_em_fits_mean[..., 3][M_i, sigmax_i],
result_em_fits_std[..., 3][M_i, sigmax_i],
xlabel="Number of items",
ylabel="Mixture probabilities",
ax_handle=ax,
linewidth=3,
fmt="o-",
markersize=5,
label="Random",
)
ax.legend(prop={"size": 15})
ax.set_title("M %d, sigmax %.2f" % (M_space[M_i], sigmax_space[sigmax_i]))
ax.set_xlim([1.0, 5.0])
ax.set_ylim([0.0, 1.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
f.canvas.draw()
if savefigs:
dataio.save_current_figure(
"memorycurves_emfits_paper_M%.2fsigmax%.2f_{label}_{unique_id}.pdf"
% (M_space[M_i], sigmax_space[sigmax_i])
)
if plot_best_memory_curves:
# Best mixtures fit
best_axis2_i_all = np.argmin(dist_diff_emkappa_mixtures_bays09, axis=1)
for axis1_i, best_axis2_i in enumerate(best_axis2_i_all):
em_plot_paper(best_axis2_i, axis1_i)
all_args = data_pbs.loaded_data["args_list"]
variables_to_save = [
"result_all_precisions_mean",
"result_em_fits_mean",
"result_marginal_inv_fi_mean",
"result_all_precisions_std",
"result_em_fits_std",
"result_marginal_inv_fi_std",
"result_marginal_fi_mean",
"result_marginal_fi_std",
"M_space",
"sigmax_space",
"T_space",
"all_args",
]
if savedata:
dataio.save_variables(variables_to_save, locals())
# Make link to Dropbox
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder="memory_curves")
plt.show()
return locals()
def plots_3dvolume_hierarchical_M_Mlayerone(data_pbs, generator_module=None):
'''
Reload 3D volume runs from PBS and plot them
'''
#### SETUP
#
savefigs = True
savedata = False # warning, huge file created...
plots_pcolors = False
plots_singleaxe = False
plots_multipleaxes = True
plots_multipleaxes_emfits = True
load_fit_mixture_model = True
# caching_emfit_filename = None
caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_emfit_newshapes.pickle')
plt.rcParams['font.size'] = 16
#
#### /SETUP
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
print "Order parameters: ", generator_module.dict_parameters_range.keys()
results_precision_constant_M_Mlower = np.squeeze(utils.nanmean(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1))
results_precision_constant_M_Mlower_std = np.squeeze(utils.nanstd(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1))
results_responses = np.squeeze(data_pbs.dict_arrays['result_responses']['results'])
results_targets = np.squeeze(data_pbs.dict_arrays['result_targets']['results'])
results_nontargets = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results'])
# results_emfits_M_T = np.squeeze(data_pbs.dict_arrays['results_emfits_M_T']['results'])
M_space = data_pbs.loaded_data['parameters_uniques']['M']
M_layer_one_space = data_pbs.loaded_data['parameters_uniques']['M_layer_one']
ratio_MMlower_space = M_space/generator_module.filtering_function_parameters['target_M_total']
filtering_indices = (np.arange(M_space.size), np.arange(-M_layer_one_space.size, 0)[::-1])
T = results_precision_constant_M_Mlower.shape[-1]
T_space = np.arange(T)
N = results_nontargets.shape[-2]
num_repetitions = data_pbs.loaded_data['args_list'][0]['num_repetitions']
# Fix after @3625585, now the shape are:
# results_responses, results_targets: M_space.size, M_layer_one_space.size, T, wrong num_repet, N
# results_nontargets: M_space.size, M_layer_one_space.size, T, wrong num_repet, N, T-1
if data_pbs.loaded_data['nb_datasets_per_parameters'] > 1:
num_repetitions = data_pbs.loaded_data['nb_datasets_per_parameters']
# Filter and reshape
results_responses = results_responses[:, :, :, :num_repetitions, :]
results_responses.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N)
results_targets = results_targets[:, :, :, :num_repetitions, :]
results_targets.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N)
results_nontargets = results_nontargets[:, :, :, :num_repetitions, :, :]
results_nontargets.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N, T-1)
print M_space
print M_layer_one_space
print results_precision_constant_M_Mlower.shape
# print results_precision_constant_M_Mlower
results_precision_filtered = results_precision_constant_M_Mlower[filtering_indices]
del results_precision_constant_M_Mlower
results_precision_filtered_std = results_precision_constant_M_Mlower_std[filtering_indices]
del results_precision_constant_M_Mlower_std
results_responses_filtered = results_responses[filtering_indices]
del results_responses
results_targets_filtered = results_targets[filtering_indices]
del results_targets
results_nontargets_filtered = results_nontargets[filtering_indices]
del results_nontargets
# results_emfits_M_T_filtered = results_emfits_M_T[filtering_indices]
# del results_emfits_M_T
results_precision_filtered_smoothed = np.apply_along_axis(smooth, 0, results_precision_filtered, *(10, 'bartlett'))
if load_fit_mixture_model:
# Fit the mixture model on the samples
if caching_emfit_filename is not None:
if os.path.exists(caching_emfit_filename):
# Got file, open it and try to use its contents
try:
with open(caching_emfit_filename, 'r') as file_in:
# Load and assign values
cached_data = pickle.load(file_in)
result_emfits_filtered = cached_data['result_emfits_filtered']
results_responses_sha1_loaded = cached_data.get('results_responses_sha1', '')
# Check that the sha1 is the same, if not recompute!
if results_responses_sha1_loaded == hashlib.sha1(results_responses_filtered).hexdigest():
print "Loading from cache file %s" % caching_emfit_filename
load_fit_mixture_model = False
else:
print "Tried loading from cache file %s, but data changed, recomputing..." % caching_emfit_filename
load_fit_mixture_model = True
except IOError:
print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits"
load_fit_mixture_model = False
if load_fit_mixture_model:
result_emfits_filtered = np.nan*np.empty((ratio_MMlower_space.size, T, 5))
# Fit EM model
print "fitting EM model"
for ratio_MMlower_i, ratio_MMlower in enumerate(ratio_MMlower_space):
for T_i in T_space:
if np.any(~np.isnan(results_responses_filtered[ratio_MMlower_i, T_i])):
print "ratio MM, T:", ratio_MMlower, T_i+1
curr_em_fits = em_circularmixture_allitems_uniquekappa.fit(results_responses_filtered[ratio_MMlower_i, T_i], results_targets_filtered[ratio_MMlower_i, T_i], results_nontargets_filtered[ratio_MMlower_i, T_i, :, :T_i])
curr_em_fits['mixt_nontargets_sum'] = np.sum(curr_em_fits['mixt_nontargets'])
result_emfits_filtered[ratio_MMlower_i, T_i] = [curr_em_fits[key] for key in ('kappa', 'mixt_target', 'mixt_nontargets_sum', 'mixt_random', 'train_LL')]
# Save everything to a file, for faster later plotting
if caching_emfit_filename is not None:
try:
with open(caching_emfit_filename, 'w') as filecache_out:
results_responses_sha1 = hashlib.sha1(results_responses_filtered).hexdigest()
data_emfit = dict(result_emfits_filtered=result_emfits_filtered, results_responses_sha1=results_responses_sha1)
pickle.dump(data_emfit, filecache_out, protocol=2)
print "cache file %s written" % caching_emfit_filename
except IOError:
print "Error writing out to caching file ", caching_emfit_filename
if plots_multipleaxes:
# Plot precisions with standard deviation around
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
# all_lines_bis = []
for i, max_ind in enumerate(np.argmax(results_precision_filtered, axis=0)):
utils.plot_mean_std_area(ratio_MMlower_space, results_precision_filtered[:, i], results_precision_filtered_std[:, i], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color())
# curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
axes[i].set_ylim((np.min(results_precision_filtered[:, i]), results_precision_filtered[max_ind, i]*1.1))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
if savefigs:
dataio.save_current_figure('results_subplots_1dnorm_{label}_global_{unique_id}.pdf')
if plots_multipleaxes_emfits:
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
all_lines_bis = []
for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)):
# Plot Target mixture
utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 1:4], 0*result_emfits_filtered[:, i, 1:4], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color())
# curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
# axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1))
axes[i].set_ylim((0.0, 1.05))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
if savefigs:
dataio.save_current_figure('results_subplots_emtarget_{label}_global_{unique_id}.pdf')
f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12))
for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)):
# Plot kappa mixture
utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 0], 0*result_emfits_filtered[:, i, 0], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color())
# curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color())
axes[i].grid()
axes[i].set_xticks(np.linspace(0., 1.0, 5))
axes[i].set_xlim((0.0, 1.0))
# axes[i].set_yticks([])
# axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1))
# axes[i].set_ylim((0.0, 1.0))
axes[i].locator_params(axis='y', tight=True, nbins=4)
# all_lines_bis.extend(curr_lines)
# f.subplots_adjust(right=0.75)
# plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5))
if savefigs:
dataio.save_current_figure('results_subplots_emkappa_{label}_global_{unique_id}.pdf')
variables_to_save = []
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='hierarchicalrandomnetwork_characterisation')
plt.show()
return locals()
def plots_specific_stimuli_mixed(data_pbs, generator_module=None):
'''
Reload and plot behaviour of mixed population code on specific Stimuli
of 3 items.
'''
#### SETUP
#
savefigs = True
savedata = True
plot_per_min_dist_all = False
specific_plots_paper = False
specific_plots_emfits = True
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1)
result_responses_all = np.squeeze(data_pbs.dict_arrays['result_responses']['results'])
result_target_all = np.squeeze(data_pbs.dict_arrays['result_target']['results'])
result_nontargets_all = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results'])
nb_repetitions = result_responses_all.shape[-1]
K = result_nontargets_all.shape[-2]
N = result_responses_all.shape[-2]
enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
ratio_space = data_pbs.loaded_data['datasets_list'][0]['ratio_space']
print enforce_min_distance_space
print sigmax_space
print ratio_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape
print result_responses_all.shape
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
if plot_per_min_dist_all:
# Do one plot per min distance.
for min_dist_i, min_dist in enumerate(enforce_min_distance_space):
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist)
if savefigs:
dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Show log precision
utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True)
if savefigs:
dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated model precision
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot estimated Target, nontarget and random mixture components, in multiple subplots
_, axes = plt.subplots(1, 3, figsize=(18, 6))
plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5)
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5)
if savefigs:
dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
# Plot Log-likelihood of Mixture model, sanity check
utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False)
if savefigs:
dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist)
if specific_plots_paper:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
## Do for each distance
for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]:
# for min_dist_i in xrange(enforce_min_distance_space.size):
# Plot precision
utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, np.max(result_all_precisions_mean[min_dist_i, sigmax_level_i] + result_all_precisions_std[min_dist_i, sigmax_level_i])])
if savefigs:
dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa fitted
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa')
plt.ylim([-0.1, np.max(result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0] + result_em_fits_std[min_dist_i, sigmax_level_i, :, 0])])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot kappa-stddev fitted. Easier to visualize
utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
plt.ylim([0, 1.1*np.max(result_em_kappastddev_mean[min_dist_i, sigmax_level_i] + result_em_kappastddev_std[min_dist_i, sigmax_level_i])])
if savefigs:
dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot LLH
utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit')
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
if savefigs:
dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Plot mixture parameters, std
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T)
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
# Mixture parameters, SEM
utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions))
plt.ylim([0.0, 1.1])
# plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i])
# plt.legend("Target", "Non-target", "Random")
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
if specific_plots_emfits:
# We need to choose 3 levels of min_distances
target_sigmax = 0.25
target_mindist_low = 0.15
target_mindist_medium = 0.36
target_mindist_high = 1.5
sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax))
min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low))
min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium))
min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high))
min_dist_i_plotting_space = np.array([min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i])
# kappa (K+1), mixt_target, mixt_nontargets (K), mixt_random, LL, bic
result_emfitallitems = np.empty((min_dist_i_plotting_space.size, ratio_space.size, 2*K+5))*np.nan
## Do for each distance
for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space):
# Fit the mixture model
for ratio_i, ratio in enumerate(ratio_space):
print "Refitting EM all items. Ratio:", ratio, "Dist:", enforce_min_distance_space[min_dist_i]
em_fit = em_circularmixture_allitems.fit(
result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(),
result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)))
result_emfitallitems[min_dist_plotting_i, ratio_i] = em_fit['kappa'].tolist() + [em_fit['mixt_target']] + em_fit['mixt_nontargets'].tolist() + [em_fit[key] for key in ('mixt_random', 'train_LL', 'bic')]
# Plot now
_, ax = plt.subplots()
ax.plot(ratio_space, result_emfitallitems[min_dist_plotting_i, :, 3:7])
if savefigs:
dataio.save_current_figure('mindist%.2f_emprobsfullitems_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i])
all_args = data_pbs.loaded_data['args_list']
variables_to_save = ['nb_repetitions']
if savedata:
dataio.save_variables_default(locals(), variables_to_save)
dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli')
plt.show()
return locals()
def plots_memory_curves(data_pbs, generator_module=None):
'''
Reload and plot memory curve of a feature code.
Can use Marginal Fisher Information and fitted Mixture Model as well
'''
#### SETUP
#
savefigs = True
savedata = True
plot_pcolor_fit_precision_to_fisherinfo = True
plot_selected_memory_curves = True
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1)
result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1)
result_marginal_inv_fi_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_inv_fi_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_fi_mean = utils.nanmean(1./np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
result_marginal_fi_std = utils.nanstd(1./np.squeeze(data_pbs.dict_arrays['result_marginal_inv_fi']['results']), axis=-1)
M_space = data_pbs.loaded_data['parameters_uniques']['M']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
T_space = data_pbs.loaded_data['datasets_list'][0]['T_space']
print M_space
print sigmax_space
print T_space
print result_all_precisions_mean.shape, result_em_fits_mean.shape, result_marginal_inv_fi_mean.shape
dataio = DataIO.DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
## Load Experimental data
data_simult = load_experimental_data.load_data_simult(data_dir=os.path.normpath(os.path.join(os.path.split(load_experimental_data.__file__)[0], '../../experimental_data/')))
memory_experimental = data_simult['precision_nitems_theo']
# Compute some landscapes of fit!
dist_diff_precision_margfi = np.sum(np.abs(result_all_precisions_mean*2. - result_marginal_fi_mean[..., 0])**2., axis=-1)
dist_diff_precision_margfi_1item = np.abs(result_all_precisions_mean[..., 0]*2. - result_marginal_fi_mean[..., 0, 0])**2.
dist_diff_all_precision_margfi = np.abs(result_all_precisions_mean*2. - result_marginal_fi_mean[..., 0])**2.
dist_ratio_precision_margfi = np.sum(np.abs((result_all_precisions_mean*2.)/result_marginal_fi_mean[..., 0] - 1.0)**2., axis=-1)
dist_diff_emkappa_margfi = np.sum(np.abs(result_em_fits_mean[..., 0]*2. - result_marginal_fi_mean[..., 0])**2., axis=-1)
dist_ratio_emkappa_margfi = np.sum(np.abs((result_em_fits_mean[..., 0]*2.)/result_marginal_fi_mean[..., 0] - 1.0)**2., axis=-1)
dist_diff_precision_experim = np.sum(np.abs(result_all_precisions_mean - memory_experimental)**2., axis=-1)
dist_diff_emkappa_experim = np.sum(np.abs(result_em_fits_mean[..., 0] - memory_experimental)**2., axis=-1)
if plot_pcolor_fit_precision_to_fisherinfo:
# Check fit between precision and fisher info
utils.pcolor_2d_data(dist_diff_precision_margfi, log_scale=True, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax')
if savefigs:
dataio.save_current_figure('match_precision_margfi_log_pcolor_{label}_{unique_id}.pdf')
# utils.pcolor_2d_data(dist_diff_precision_margfi, x=M_space, y=sigmax_space[2:], xlabel='M', ylabel='sigmax')
# if savefigs:
# dataio.save_current_figure('match_precision_margfi_pcolor_{label}_{unique_id}.pdf')
utils.pcolor_2d_data(dist_ratio_precision_margfi[4:], x=M_space[4:], y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_diff_emkappa_margfi, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_ratio_emkappa_margfi[4:], x=M_space[4:], y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_diff_precision_experim, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_diff_emkappa_experim, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_diff_precision_margfi*dist_diff_emkappa_margfi*dist_diff_precision_experim*dist_diff_emkappa_experim, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax', log_scale=True)
utils.pcolor_2d_data(dist_diff_precision_margfi_1item, log_scale=True, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax')
if plot_selected_memory_curves:
selected_values = [[20, 0.19], [40, 0.15], [100, 0.44], [140, 0.15], [40, 0.17], [60, 0.50]]
for current_values in selected_values:
# Find the indices
M_i = np.argmin(np.abs(current_values[0] - M_space))
sigmax_i = np.argmin(np.abs(current_values[1] - sigmax_space))
ax = utils.plot_mean_std_area(T_space, memory_experimental, np.zeros(T_space.size), linewidth=3, fmt='o-', markersize=8)
ax = utils.plot_mean_std_area(T_space, result_all_precisions_mean[M_i, sigmax_i], result_all_precisions_std[M_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8)
ax = utils.plot_mean_std_area(T_space, 0.5*result_marginal_fi_mean[..., 0][M_i, sigmax_i], 0.5*result_marginal_fi_std[..., 0][M_i, sigmax_i], ax_handle=ax, linewidth=3, fmt='o-', markersize=8)
ax = utils.plot_mean_std_area(T_space, result_em_fits_mean[..., 0][M_i, sigmax_i], result_em_fits_std[..., 0][M_i, sigmax_i], ax_handle=ax, xlabel='Number of items', ylabel='Kappa/Inverse variance', linewidth=3, fmt='o-', markersize=8)
ax.set_title('M %d, sigmax %.2f' % (M_space[M_i], sigmax_space[sigmax_i]))
plt.legend(['Experimental data', 'Precision of samples', 'Marginal Fisher Information', 'Fitted kappa'])
ax.set_xlim([0.9, 5.1])
ax.set_xticks(range(1, 6))
ax.set_xticklabels(range(1, 6))
if savefigs:
dataio.save_current_figure('memorycurves_M%dsigmax%.2f_{label}_{unique_id}.pdf' % (M_space[M_i], sigmax_space[sigmax_i]))
all_args = data_pbs.loaded_data['args_list']
variables_to_save = ['result_all_precisions_mean', 'result_em_fits_mean', 'result_marginal_inv_fi_mean', 'result_all_precisions_std', 'result_em_fits_std', 'result_marginal_inv_fi_std', 'result_marginal_fi_mean', 'result_marginal_fi_std', 'M_space', 'sigmax_space', 'T_space', 'all_args']
if savedata:
dataio.save_variables(variables_to_save, locals())
plt.show()
return locals()
def plots_logposterior_mixed_autoset(data_pbs, generator_module=None):
'''
Reload 2D volume runs from PBS and plot them
'''
#### SETUP
#
savefigs = True
plot_per_ratio = False
plot_2d_pcolor = False
do_relaunch_bestparams_pbs = True
colormap = None # or 'cubehelix'
plt.rcParams['font.size'] = 16
#
#### /SETUP
print "Order parameters: ", generator_module.dict_parameters_range.keys()
result_log_posterior_mean = np.squeeze(data_pbs.dict_arrays['result_log_posterior_mean']['results'])
result_log_posterior_std = np.squeeze(data_pbs.dict_arrays['result_log_posterior_std']['results'])
ratio_space = data_pbs.loaded_data['parameters_uniques']['ratio_conj']
sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax']
exp_dataset = data_pbs.loaded_data['args_list'][0]['experiment_id']
print ratio_space
print sigmax_space
print result_log_posterior_mean.shape, result_log_posterior_std.shape
dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename'])
if plot_per_ratio:
# Plot the evolution of loglike as a function of sigmax, with std shown
for ratio_conj_i, ratio_conj in enumerate(ratio_space):
ax = utils.plot_mean_std_area(sigmax_space, result_log_posterior_mean[ratio_conj_i], result_log_posterior_std[ratio_conj_i])
ax.get_figure().canvas.draw()
if savefigs:
dataio.save_current_figure('results_fitexp_%s_loglike_ratioconj%.2f_{label}_global_{unique_id}.pdf' % (exp_dataset, ratio_conj))
if plot_2d_pcolor:
# Plot the mean loglikelihood as a 2d surface
utils.pcolor_2d_data(result_log_posterior_mean, x=ratio_space, y=sigmax_space, xlabel="Ratio conj", ylabel="Sigma x", title="Loglikelihood of experimental data, \n3 items dualrecall, rcscale automatically set", ticks_interpolate=5, cmap=colormap)
# plt.tight_layout()
if savefigs:
dataio.save_current_figure('results_fitexp_%s_loglike_2d_ratiosigmax_{label}_global_{unique_id}.pdf' % exp_dataset)
if do_relaunch_bestparams_pbs:
# Will check the best fitting parameters, and relaunch simulations for them, in order to get new cool plots.
# We can actually use the original dictionary for submission informations, and just change the launcher to one produces the appropriate results
generator_parameters_dict = generator_module.__dict__
generator_parameters_dict['pbs_submission_infos']['other_options'].update(dict(
action_to_do='launcher_do_memory_curve_marginal_fi',
subaction='collect_responses',
inference_method='sample',
N=300,
T=6,
num_samples=500,
selection_method='last',
num_repetitions=3,
burn_samples=500,
stimuli_generation='random',
stimuli_generation_recall='random',
session_id='fitting_experiments_relaunchs',
result_computation='filenameoutput'))
generator_parameters_dict['pbs_submission_infos']['other_options']['label'] = 'fitting_experiment_rerun_nitems{T}M{M}_090414'.format(T = generator_parameters_dict['n_items_to_fit'], M = generator_parameters_dict['M'])
generator_parameters_dict['sleeping_period'] = dict(min=5, max=10)
submit_pbs = submitpbs.SubmitPBS(pbs_submission_infos=generator_parameters_dict['pbs_submission_infos'], debug=True)
# Now run a series of Jobs to obtain the required data
# the "Result" of them are the filename of their output. Should then save those in a dictionary.
# For later processing, if the exact same parameters are used, then everything will be reloaded automatically, MAAAGIC.
# Extract the parameters to try
best_params_to_try = []
best_axis2_i_all = np.argmax(result_log_posterior_mean, axis=1)
for axis1_i, best_axis2_i in enumerate(best_axis2_i_all):
parameter_dict = dict(ratio_conj=ratio_space[axis1_i], sigmax=sigmax_space[best_axis2_i])
best_params_to_try.append(parameter_dict)
# Submit them, waiting on them in the process. Should obtain a list of filenames back
utils.chdir_safe(generator_parameters_dict['pbs_submission_infos']['simul_out_dir'])
result_minibatch_filenames = submit_pbs.submit_minibatch_jobswrapper(best_params_to_try, generator_parameters_dict)
result_reloaded_datasets = []
for filename_i, result_filename in enumerate(result_minibatch_filenames):
curr_reloaded_dataset = utils.load_npy(result_filename + '.npy')
result_reloaded_datasets.append(curr_reloaded_dataset)
utils.chdir_safe('../')
all_args = data_pbs.loaded_data['args_list']
variables_to_save = ['exp_dataset']
if savefigs:
dataio.save_variables_default(locals(), variables_to_save)
plt.show()
return locals()
