def load_experiments(self): """ Load a specific human experiment. """ fit_mixture_model = self.parameters.get("fit_mixturemodel", False) # Load each experimental dataset for experiment_id in self.experiment_ids: if experiment_id == "bays09": self.experimental_datasets[experiment_id] = load_experimental_data.load_data_bays09( data_dir=self.data_dir, fit_mixture_model=fit_mixture_model ) if self.debug: print "Loading Bays09 dataset" elif experiment_id == "dualrecall": self.experimental_datasets[experiment_id] = load_experimental_data.load_data_dualrecall( data_dir=self.data_dir ) if self.debug: print "Loading double Recall dataset" elif experiment_id == "gorgo11": self.experimental_datasets[experiment_id] = load_experimental_data.load_data_simult( data_dir=self.data_dir, fit_mixture_model=fit_mixture_model ) if self.debug: print "Loading Gorgo11 simult dataset"
def plot_experimental_mixture(): ''' Cheat and get data from Bays 2008 from figure... ''' data_bays2009 = load_experimental_data.load_data_bays09(fit_mixture_model=True) experimental_mixtures_mean = data_bays2009['em_fits_nitems_arrays']['mean'][1:] experimental_mixtures_std = data_bays2009['em_fits_nitems_arrays']['std'][1:] experimental_mixtures_mean[np.isnan(experimental_mixtures_mean)] = 0.0 experimental_mixtures_std[np.isnan(experimental_mixtures_std)] = 0.0 experimental_mixtures_sem = experimental_mixtures_std/np.sqrt(np.unique(data_bays2009['subject']).size) items_space = np.unique(data_bays2009['n_items']) f, ax = plt.subplots() ax = plot_multiple_mean_std_area(items_space, experimental_mixtures_mean, experimental_mixtures_sem, ax_handle=ax, linewidth=2) ax.set_xlim((1.0, 5.0)) ax.set_ylim((0.0, 1.1)) # # ax.set_yticks((0.0, 0.25, 0.5, 0.75, 1.0)) ax.set_yticks((0.0, 0.2, 0.4, 0.6, 0.8, 1.0)) ax.set_xticks((1, 2, 3, 4, 5)) # plt.legend(['Target', 'Non-target', 'Random'], loc='upper right', fancybox=True, borderpad=0.3) return locals()
def plots_boostrap(data_pbs, generator_module=None): ''' Reload bootstrap samples, plot its histogram, fit empirical CDF and save it for quicker later use. ''' #### SETUP # savefigs = True savedata = True load_fit_bootstrap = True plots_hist_cdf = False estimate_bootstrap = True should_fit_bootstrap = True # caching_bootstrap_filename = None caching_bootstrap_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap_bays09.pickle') plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", generator_module.dict_parameters_range.keys() result_bootstrap_nitems_samples = np.squeeze(data_pbs.dict_arrays['result_bootstrap_nitems_samples']['results']) result_bootstrap_subject_nitems_samples = np.squeeze(data_pbs.dict_arrays['result_bootstrap_subject_nitems_samples']['results']) dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) dataset = load_experimental_data.load_data_bays09(fit_mixture_model=True) if load_fit_bootstrap: if caching_bootstrap_filename is not None: if os.path.exists(caching_bootstrap_filename): # Got file, open it and try to use its contents try: with open(caching_bootstrap_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) bootstrap_nitems_samples = cached_data['bootstrap_nitems_samples'] bootstrap_subject_nitems_samples = cached_data['bootstrap_subject_nitems_samples'] should_fit_bootstrap = False except IOError: print "Error while loading ", caching_bootstrap_filename, "falling back to computing the EM fits" if should_fit_bootstrap: bootstrap_nitems_samples = dict() bootstrap_subject_nitems_samples = dict() # Fit ECDF for n_items_i, n_items in enumerate(np.unique(dataset['n_items'])): if n_items > 1: print "Nitems %d, all subjects" % (n_items) current_ecdf_allitems = stmodsdist.empirical_distribution.ECDF(utils.dropnan(result_bootstrap_nitems_samples[n_items_i])) # Store in a dict(n_items_i) -> {ECDF object, n_items} bootstrap_nitems_samples[n_items_i] = dict(ecdf=current_ecdf_allitems, n_items=n_items) for subject_i, subject in enumerate(np.unique(dataset['subject'])): print "Nitems %d, subject %d" % (n_items, subject) current_ecdf_subj_items = stmodsdist.empirical_distribution.ECDF(utils.dropnan(result_bootstrap_subject_nitems_samples[subject_i, n_items_i])) if n_items_i not in bootstrap_subject_nitems_samples: bootstrap_subject_nitems_samples[n_items_i] = dict() bootstrap_subject_nitems_samples[n_items_i][subject_i] = dict(ecdf=current_ecdf_subj_items, n_items=n_items, subject=subject) # Save everything to a file, for faster later plotting if caching_bootstrap_filename is not None: try: with open(caching_bootstrap_filename, 'w') as filecache_out: data_bootstrap = dict(bootstrap_nitems_samples=bootstrap_nitems_samples, bootstrap_subject_nitems_samples=bootstrap_subject_nitems_samples) pickle.dump(data_bootstrap, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_bootstrap_filename if plots_hist_cdf: ## Plots now for n_items_i, n_items in enumerate(np.unique(dataset['n_items'])): if n_items > 1: for subject_i, subject in enumerate(np.unique(dataset['subject'])): # Histogram of samples, for subject/nitems _, axes = plt.subplots(ncols=2, figsize=(12, 6)) axes[0].hist(utils.dropnan(result_bootstrap_subject_nitems_samples[subject_i, n_items_i]), bins=100, normed='density') axes[0].set_xlim([0.0, 1.0]) # ECDF now axes[1].plot(bootstrap_subject_nitems_samples[n_items_i][subject_i]['ecdf'].x, bootstrap_subject_nitems_samples[n_items_i][subject_i]['ecdf'].y, linewidth=2) axes[1].set_xlim([0.0, 1.0]) if savefigs: dataio.save_current_figure('histecdf_bootstrap_nitems%d_subject%d_{label}_{unique_id}.pdf' % (n_items, subject)) # Same for collapsed data accross subjects # Histogram of samples, for subject/nitems _, axes = plt.subplots(ncols=2, figsize=(12, 6)) axes[0].hist(utils.dropnan(result_bootstrap_nitems_samples[n_items_i]), bins=100, normed='density') axes[0].set_xlim([0.0, 1.0]) # ECDF now axes[1].plot(bootstrap_nitems_samples[n_items_i]['ecdf'].x, bootstrap_nitems_samples[n_items_i]['ecdf'].y, linewidth=2) axes[1].set_xlim([0.0, 1.0]) if savefigs: dataio.save_current_figure('histecdf_bootstrap_nitems%d_{label}_{unique_id}.pdf' % (n_items)) if estimate_bootstrap: # Compute bootstrap p-value result_pvalue_bootstrap_nitems = np.empty(dataset['n_items_size'])*np.nan result_pvalue_bootstrap_subject_nitems_samples = np.empty((dataset['n_items_size'], dataset['subject_size']))*np.nan for n_items_i, n_items in enumerate(np.unique(dataset['n_items'])): if n_items > 1: print "Nitems %d, all subjects" % (n_items) # Data collapsed accross subjects ids_filtered = (dataset['n_items'] == n_items).flatten() bootstrap = em_circularmixture.bootstrap_nontarget_stat( dataset['response'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 1:n_items], nontarget_bootstrap_ecdf=bootstrap_nitems_samples[n_items_i]['ecdf']) result_pvalue_bootstrap_nitems[n_items_i] = bootstrap['p_value'] print "p_val:", result_pvalue_bootstrap_nitems for subject_i, subject in enumerate(np.unique(dataset['subject'])): print "Nitems %d, subject %d" % (n_items, subject) # Bootstrap per subject and nitems ids_filtered = (dataset['subject'] == subject).flatten() & (dataset['n_items'] == n_items).flatten() # Get pvalue bootstrap = em_circularmixture.bootstrap_nontarget_stat( dataset['response'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 1:n_items], nontarget_bootstrap_ecdf=bootstrap_subject_nitems_samples[n_items_i][subject_i]['ecdf']) result_pvalue_bootstrap_subject_nitems_samples[n_items_i, subject_i] = bootstrap['p_value'] print "p_val:", result_pvalue_bootstrap_subject_nitems_samples[n_items_i, subject_i] signif_level = 0.05 result_signif_nitems = result_pvalue_bootstrap_nitems < signif_level result_num_signif_subject_nitems = np.sum(result_pvalue_bootstrap_subject_nitems_samples < signif_level, axis=1) print "Summary:" print "Collapsed subjects:", result_signif_nitems print "Per subjects (%d total): %s" % (dataset['subject_size'], result_num_signif_subject_nitems) all_args = data_pbs.loaded_data['args_list'] variables_to_save = ['nb_repetitions', 'signif_level'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='bootstrap_nontargets') plt.show() return locals()
def launcher_do_bootstrap_experimental(args): ''' Compute a bootstrap estimate, using outputs from the experimental data ''' print "Doing a piece of work for launcher_do_bootstrap_experimental" try: # Convert Argparse.Namespace to dict all_parameters = vars(args) except TypeError: # Assume it's already done assert type(args) is dict, "args is neither Namespace nor dict, WHY?" all_parameters = args print all_parameters # Create DataIO # (complete label with current variable state) dataio = DataIO.DataIO(output_folder=all_parameters['output_directory'], label=all_parameters['label'].format(**all_parameters)) save_every = 1 run_counter = 0 # Load the data if all_parameters['subaction'] == 'bays09' or all_parameters['subaction'] == '': # Bays2009 dataset dataset = load_experimental_data.load_data_bays09(fit_mixture_model=True) # Result arrays result_bootstrap_nitems_samples = np.nan*np.empty((dataset['n_items_size'], all_parameters['num_repetitions'])) result_bootstrap_subject_nitems_samples = np.nan*np.empty((dataset['subject_size'], dataset['n_items_size'], all_parameters['num_repetitions'])) search_progress = progress.Progress(dataset['subject_size']*(dataset['n_items_size']-1)) for n_items_i, n_items in enumerate(np.unique(dataset['n_items'])): if n_items > 1: print "Nitems %d, all subjects" % (n_items) # Data collapsed accross subjects ids_filtered = (dataset['n_items'] == n_items).flatten() bootstrap = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat( dataset['response'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 1:n_items], nb_bootstrap_samples=all_parameters['num_repetitions'], resample_targets=False ) result_bootstrap_nitems_samples[n_items_i] = bootstrap['nontarget_bootstrap_samples'] print result_bootstrap_nitems_samples for subject_i, subject in enumerate(np.unique(dataset['subject'])): print "Nitems %d, subject %d" % (n_items, subject) # Bootstrap per subject and nitems ids_filtered = (dataset['subject']==subject).flatten() & (dataset['n_items'] == n_items).flatten() # Compute bootstrap if required bootstrap = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat( dataset['response'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 0], dataset['item_angle'][ids_filtered, 1:n_items], nb_bootstrap_samples=all_parameters['num_repetitions'], resample_targets=False) result_bootstrap_subject_nitems_samples[subject_i, n_items_i] = bootstrap['nontarget_bootstrap_samples'] print result_bootstrap_subject_nitems_samples[:, n_items_i] search_progress.increment() if run_counter % save_every == 0 or search_progress.done(): dataio.save_variables_default(locals()) run_counter += 1 # Finished dataio.save_variables_default(locals()) print "All finished" return locals()
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 = True plot_selected_memory_curves = False 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) ratiohier_space = data_pbs.loaded_data['parameters_uniques']['ratio_hierarchical'] sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] T_space = data_pbs.loaded_data['datasets_list'][0]['T_space'] print ratiohier_space print sigmax_space print T_space print result_all_precisions_mean.shape, result_em_fits_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) gorgo11_experimental_precision = data_simult['precision_nitems_theo'] gorgo11_experimental_kappa = np.array([data['kappa'] for _, data in data_simult['em_fits_nitems']['mean'].items()]) gorgo11_experimental_kappa_std = np.array([data['kappa'] for _, data in data_simult['em_fits_nitems']['std'].items()]) gorgo11_experimental_emfits_mean = np.array([[data[key] for _, data in data_simult['em_fits_nitems']['mean'].items()] for key in ['kappa', 'mixt_target', 'mixt_nontargets', 'mixt_random']]) gorgo11_experimental_emfits_std = np.array([[data[key] for _, data in data_simult['em_fits_nitems']['std'].items()] for key in ['kappa', 'mixt_target', 'mixt_nontargets', 'mixt_random']]) gorgo11_experimental_emfits_sem = gorgo11_experimental_emfits_std/np.sqrt(np.unique(data_simult['subject']).size) gorgo11_T_space = data_simult['data_to_fit']['n_items'] data_bays2009 = load_experimental_data.load_data_bays09(fit_mixture_model=True) bays09_experimental_mixtures_mean = data_bays2009['em_fits_nitems_arrays']['mean'] bays09_experimental_mixtures_std = data_bays2009['em_fits_nitems_arrays']['std'] # add interpolated points for 3 and 5 items emfit_mean_intpfct = spint.interp1d(np.unique(data_bays2009['n_items']), bays09_experimental_mixtures_mean) bays09_experimental_mixtures_mean_compatible = emfit_mean_intpfct(np.arange(1, 7)) emfit_std_intpfct = spint.interp1d(np.unique(data_bays2009['n_items']), bays09_experimental_mixtures_std) bays09_experimental_mixtures_std_compatible = emfit_std_intpfct(np.arange(1, 7)) bays09_T_space_interp = np.arange(1, 7) bays09_T_space = data_bays2009['data_to_fit']['n_items'] # Compute some landscapes of fit! dist_diff_precision_experim = np.sum(np.abs(result_all_precisions_mean[..., :gorgo11_experimental_precision.size] - gorgo11_experimental_precision)**2., axis=-1) dist_diff_emkappa_experim = np.sum(np.abs(result_em_fits_mean[..., :gorgo11_experimental_precision.size, 0] - gorgo11_experimental_kappa)**2., axis=-1) dist_diff_precision_experim_1item = np.abs(result_all_precisions_mean[..., 0] - gorgo11_experimental_precision[0])**2. dist_diff_precision_experim_2item = np.abs(result_all_precisions_mean[..., 1] - gorgo11_experimental_precision[1])**2. dist_diff_emkappa_experim_1item = np.abs(result_em_fits_mean[..., 0, 0] - gorgo11_experimental_kappa[0])**2. dist_diff_em_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: utils.pcolor_2d_data(dist_diff_precision_experim, x=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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_experim*dist_diff_emkappa_experim, x=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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_experim_1item, log_scale=True, x=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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_precision_experim_2item, log_scale=True, x=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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_em_mixtures_bays09, log_scale=True, x=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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=ratiohier_space, y=sigmax_space, xlabel='ratio hier', 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, 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 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 em_plot(sigmax_i, ratiohier_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][ratiohier_i, sigmax_i], result_em_fits_std[..., 0][ratiohier_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][ratiohier_i, sigmax_i], result_em_fits_std[..., 1][ratiohier_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][ratiohier_i, sigmax_i], result_em_fits_std[..., 2][ratiohier_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][ratiohier_i, sigmax_i], result_em_fits_std[..., 3][ratiohier_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_hier %.2f, sigmax %.2f' % (ratiohier_space[ratiohier_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_ratiohier%.2fsigmax%.2f_{label}_{unique_id}.pdf' % (ratiohier_space[ratiohier_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])) if plot_selected_memory_curves: selected_values = [[0.84, 0.23], [0.84, 0.19]] for current_values in selected_values: # Find the indices ratiohier_i = np.argmin(np.abs(current_values[0] - ratiohier_space)) sigmax_i = np.argmin(np.abs(current_values[1] - sigmax_space)) # mem_plot_precision(sigmax_i, ratiohier_i) # mem_plot_kappa(sigmax_i, ratiohier_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, gorgo11_experimental_precision) # 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, gorgo11_T_space, gorgo11_experimental_emfits_mean[0], gorgo11_experimental_emfits_std[0]) # 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) # best_axis2_i_all = np.argmin(dist_diff_em_mixtures_bays09, axis=1) for axis1_i, best_axis2_i in enumerate(best_axis2_i_all): mem_plot_kappa(best_axis2_i, axis1_i, bays09_T_space, bays09_experimental_mixtures_mean[0], bays09_experimental_mixtures_std[0]) # em_plot(best_axis2_i, axis1_i) em_plot_paper(best_axis2_i, axis1_i) all_args = data_pbs.loaded_data['args_list'] variables_to_save = ['gorgo11_experimental_precision', 'gorgo11_experimental_kappa', 'bays09_experimental_mixtures_mean_compatible'] if savedata: dataio.save_variables_default(locals(), additional_variables=variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='memory_curves') plt.show() return locals()
def plots_fit_mixturemodels_random(data_pbs, generator_module=None): ''' Reload runs from PBS ''' #### SETUP # savefigs = True savedata = True savemovies = True plots_dist_bays09 = True plots_per_T = True plots_interpolate = False # do_relaunch_bestparams_pbs = True colormap = None # or 'cubehelix' plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", data_pbs.dataset_infos['parameters'] # parameters: M, ratio_conj, sigmax # Extract data T_space = data_pbs.loaded_data['datasets_list'][0]['T_space'] result_em_fits_flat = np.array(data_pbs.dict_arrays['result_em_fits']['results_flat']) result_dist_bays09_flat = np.array(data_pbs.dict_arrays['result_dist_bays09']['results_flat']) result_dist_gorgo11_flat = np.array(data_pbs.dict_arrays['result_dist_gorgo11']['results_flat']) result_parameters_flat = np.array(data_pbs.dict_arrays['result_em_fits']['parameters_flat']) sigmaoutput_space = data_pbs.loaded_data['parameters_uniques']['sigma_output'] sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] ratio_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] num_repetitions = generator_module.num_repetitions parameter_names_sorted = data_pbs.dataset_infos['parameters'] dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) # Load bays09 data_bays09 = load_experimental_data.load_data_bays09(fit_mixture_model=True) bays09_nitems = data_bays09['data_to_fit']['n_items'] bays09_em_target = np.nan*np.empty((bays09_nitems.max(), 4)) #kappa, prob_target, prob_nontarget, prob_random bays09_em_target[bays09_nitems - 1] = data_bays09['em_fits_nitems_arrays']['mean'].T bays09_emmixt_target = bays09_em_target[:, 1:] ## Compute some stuff # result_dist_bays09_kappa_T1_avg = utils.nanmean(result_dist_bays09_flat[:, 0, 0], axis=-1) # result_dist_bays09_kappa_allT_avg = np.nansum(utils.nanmean(result_dist_bays09_flat[:, :, 0], axis=-1), axis=1) # Square distance to kappa result_dist_bays09_allT_avg = utils.nanmean((result_em_fits_flat[:, :, :4] - bays09_em_target[np.newaxis, :, :, np.newaxis])**2, axis=-1) result_dist_bays09_kappa_sum = np.nansum(result_dist_bays09_allT_avg[:, :, 0], axis=-1) result_dist_bays09_kappa_T1_sum = result_dist_bays09_allT_avg[:, 0, 0] result_dist_bays09_kappa_T25_sum = np.nansum(result_dist_bays09_allT_avg[:, 1:, 0], axis=-1) # Square and KL distance for EM Mixtures result_dist_bays09_emmixt_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, :, 1:], axis=-1), axis=-1) result_dist_bays09_emmixt_T1_sum = np.nansum(result_dist_bays09_allT_avg[:, 0, 1:], axis=-1) result_dist_bays09_emmixt_T25_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, 1:, 1:], axis=-1), axis=-1) result_dist_bays09_emmixt_KL = utils.nanmean(utils.KL_div(result_em_fits_flat[:, :, 1:4], bays09_emmixt_target[np.newaxis, :, :, np.newaxis], axis=-2), axis=-1) # KL over dimension of mixtures, then mean over repetitions result_dist_bays09_emmixt_KL_sum = np.nansum(result_dist_bays09_emmixt_KL, axis=-1) # sum over T result_dist_bays09_emmixt_KL_T1_sum = result_dist_bays09_emmixt_KL[:, 0] result_dist_bays09_emmixt_KL_T25_sum = np.nansum(result_dist_bays09_emmixt_KL[:, 1:], axis=-1) result_dist_bays09_both_normalised = result_dist_bays09_emmixt_sum/np.max(result_dist_bays09_emmixt_sum) + result_dist_bays09_kappa_sum/np.max(result_dist_bays09_kappa_sum) if plots_dist_bays09: nb_best_points = 30 size_normal_points = 8 size_best_points = 50 def plot_scatter(all_vars, result_dist_to_use_name, title='', log_color=True, downsampling=1, label_file=''): fig = plt.figure() ax = Axes3D(fig) result_dist_to_use = all_vars[result_dist_to_use_name] if not log_color: result_dist_to_use = np.exp(result_dist_to_use) utils.scatter3d(result_parameters_flat[:, 0], result_parameters_flat[:, 1], result_parameters_flat[:, 2], s=size_normal_points, c=np.log(result_dist_to_use), xlabel=parameter_names_sorted[0], ylabel=parameter_names_sorted[1], zlabel=parameter_names_sorted[2], title=title, ax_handle=ax) best_points_result_dist_to_use = np.argsort(result_dist_to_use)[:nb_best_points] utils.scatter3d(result_parameters_flat[best_points_result_dist_to_use, 0], result_parameters_flat[best_points_result_dist_to_use, 1], result_parameters_flat[best_points_result_dist_to_use, 2], c='r', s=size_best_points, ax_handle=ax) print "Best points, %s:" % title print '\n'.join(['sigma output %.2f, ratio %.2f, sigmax %.2f: %f' % (result_parameters_flat[i, 0], result_parameters_flat[i, 1], result_parameters_flat[i, 2], result_dist_to_use[i]) for i in best_points_result_dist_to_use]) if savefigs: dataio.save_current_figure('scatter3d_%s%s_{label}_{unique_id}.pdf' % (result_dist_to_use_name, label_file)) if savemovies: try: utils.rotate_plot3d(ax, dataio.create_formatted_filename('scatter3d_%s%s_{label}_{unique_id}.mp4' % (result_dist_to_use_name, label_file)), bitrate=8000, min_duration=8) utils.rotate_plot3d(ax, dataio.create_formatted_filename('scatter3d_%s%s_{label}_{unique_id}.gif' % (result_dist_to_use_name, label_file)), nb_frames=30, min_duration=8) except Exception: # Most likely wrong aggregator... print "failed when creating movies for ", result_dist_to_use_name ax.view_init(azim=90, elev=10) dataio.save_current_figure('scatter3d_view2_%s%s_{label}_{unique_id}.pdf' % (result_dist_to_use_name, label_file)) return ax # Distance for kappa, all T plot_scatter(locals(), 'result_dist_bays09_kappa_sum', 'kappa all T') # Distance for em fits, all T, Squared distance plot_scatter(locals(), 'result_dist_bays09_emmixt_sum', 'em fits, all T') # Distance for em fits, all T, KL distance plot_scatter(locals(), 'result_dist_bays09_emmixt_KL_sum', 'em fits, all T, KL') # Distance for sum of normalised em fits + normalised kappa, all T plot_scatter(locals(), 'result_dist_bays09_both_normalised', 'summed normalised em mixt + kappa') # Distance kappa T = 1 plot_scatter(locals(), 'result_dist_bays09_kappa_T1_sum', 'Kappa T=1') # Distance kappa T = 2...5 plot_scatter(locals(), 'result_dist_bays09_kappa_T25_sum', 'Kappa T=2/5') # Distance em fits T = 1 plot_scatter(locals(), 'result_dist_bays09_emmixt_T1_sum', 'em fits T=1') # Distance em fits T = 2...5 plot_scatter(locals(), 'result_dist_bays09_emmixt_T25_sum', 'em fits T=2/5') # Distance em fits T = 1, KL plot_scatter(locals(), 'result_dist_bays09_emmixt_KL_T1_sum', 'em fits T=1, KL') # Distance em fits T = 2...5, KL plot_scatter(locals(), 'result_dist_bays09_emmixt_KL_T25_sum', 'em fits T=2/5, KL') if plots_per_T: for T_i, T in enumerate(T_space): # Kappa per T, fit to Bays09 result_dist_bays09_kappa_currT = result_dist_bays09_allT_avg[:, T_i, 0] result_dist_bays09_kappa_currT_masked = mask_outliers(result_dist_bays09_kappa_currT) plot_scatter(locals(), 'result_dist_bays09_kappa_currT_masked', 'kappa T %d masked' % T, label_file="T{}".format(T)) # EM Mixt per T, fit to Bays09 result_dist_bays09_emmixt_sum_currT = np.nansum(result_dist_bays09_allT_avg[:, T_i, 1:], axis=-1) result_dist_bays09_emmixt_sum_currT_masked = mask_outliers(result_dist_bays09_emmixt_sum_currT) plot_scatter(locals(), 'result_dist_bays09_emmixt_sum_currT_masked', 'EM mixt T %d masked' % T, label_file="T{}".format(T)) # EM Mixt per T, fit to Bays09 KL divergence result_dist_bays09_emmixt_KL_sum_currT = result_dist_bays09_emmixt_KL[:, T_i] plot_scatter(locals(), 'result_dist_bays09_emmixt_KL_sum_currT', 'KL EM mixt T %d masked' % T, label_file="T{}".format(T)) # # Interpolate # if plots_interpolate: # sigmax_target = 0.9 # M_interp_space = np.arange(6, 625, 5) # ratio_interp_space = np.linspace(0.01, 1.0, 50) # # sigmax_interp_space = np.linspace(0.01, 1.0, 50) # sigmax_interp_space = np.array([sigmax_target]) # params_crossspace = np.array(utils.cross(M_interp_space, ratio_interp_space, sigmax_interp_space)) # interpolated_data = rbf_interpolator(params_crossspace[:, 0], params_crossspace[:, 1], params_crossspace[:, 2]).reshape((M_interp_space.size, ratio_interp_space.size)) # utils.pcolor_2d_data(interpolated_data, M_interp_space, ratio_interp_space, 'M', 'ratio', 'interpolated, fixing sigmax= %.2f' % sigmax_target) # points_closeby = ((result_parameters_flat[:, 2] - sigmax_target)**2)< 0.01 # plt.figure() # # plt.imshow(interpolated_data, extent=(M_interp_space.min(), M_interp_space.max(), ratio_interp_space.min(), ratio_interp_space.max())) # plt.imshow(interpolated_data) # plt.scatter(result_parameters_flat[points_closeby, 0], result_parameters_flat[points_closeby, 1], s=100, c=result_fitexperiments_bic_avg[points_closeby], marker='o') # 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)) all_args = data_pbs.loaded_data['args_list'] variables_to_save = ['parameter_names_sorted'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='output_noise') plt.show() return locals()
def launcher_do_fit_mixturemodels(args): ''' Run the model for 1..T items, computing: - Precision of samples - EM mixture model fits - Theoretical Fisher Information - EM Mixture model distances to set of currently working datasets. ''' print "Doing a piece of work for launcher_do_fit_mixturemodels" all_parameters = utils.argparse_2_dict(args) print all_parameters if all_parameters['burn_samples'] + all_parameters['num_samples'] < 200: print "WARNING> you do not have enough samples I think!", all_parameters['burn_samples'] + all_parameters['num_samples'] # Create DataIO # (complete label with current variable state) dataio = DataIO.DataIO(output_folder=all_parameters['output_directory'], label=all_parameters['label'].format(**all_parameters)) save_every = 1 run_counter = 0 # Load datasets to compare against data_bays2009 = load_experimental_data.load_data_bays09(data_dir=all_parameters['experiment_data_dir'], fit_mixture_model=True) bays09_experimental_mixtures_mean = data_bays2009['em_fits_nitems_arrays']['mean'] # Assume that T_space >= max(T_space_bays09) bays09_T_space = np.unique(data_bays2009['n_items']) data_gorgo11 = load_experimental_data.load_data_simult(data_dir=all_parameters['experiment_data_dir'], fit_mixture_model=True) gorgo11_experimental_emfits_mean = data_gorgo11['em_fits_nitems_arrays']['mean'] gorgo11_T_space = np.unique(data_gorgo11['n_items']) # Parameters to vary T_max = all_parameters['T'] T_space = np.arange(1, T_max+1) repetitions_axis = -1 # Result arrays result_all_precisions = np.nan*np.empty((T_space.size, all_parameters['num_repetitions'])) # result_fi_theo = np.nan*np.empty((T_space.size, all_parameters['num_repetitions'])) # result_fi_theocov = np.nan*np.empty((T_space.size, all_parameters['num_repetitions'])) result_em_fits = np.nan*np.empty((T_space.size, 6, all_parameters['num_repetitions'])) # kappa, mixt_target, mixt_nontarget, mixt_random, ll, bic # result_em_fits_allnontargets = np.nan*np.empty((T_space.size, 5+(T_max-1), all_parameters['num_repetitions'])) # kappa, mixt_target, mixt_nontarget (T-1), mixt_random, ll, bic result_dist_bays09 = np.nan*np.empty((T_space.size, 4, all_parameters['num_repetitions'])) # kappa, mixt_target, mixt_nontarget, mixt_random result_dist_gorgo11 = np.nan*np.empty((T_space.size, 4, all_parameters['num_repetitions'])) # kappa, mixt_target, mixt_nontarget, mixt_random result_dist_bays09_emmixt_KL = np.nan*np.empty((T_space.size, all_parameters['num_repetitions'])) result_dist_gorgo11_emmixt_KL = np.nan*np.empty((T_space.size, all_parameters['num_repetitions'])) # If desired, will automatically save all Model responses. if all_parameters['collect_responses']: print "--- Collecting all responses..." result_responses = np.nan*np.ones((T_space.size, all_parameters['N'], all_parameters['num_repetitions'])) result_target = np.nan*np.ones((T_space.size, all_parameters['N'], all_parameters['num_repetitions'])) result_nontargets = np.nan*np.ones((T_space.size, all_parameters['N'], T_max-1, all_parameters['num_repetitions'])) search_progress = progress.Progress(T_space.size*all_parameters['num_repetitions']) for repet_i in xrange(all_parameters['num_repetitions']): for T_i, T in enumerate(T_space): print "%.2f%%, %s left - %s" % (search_progress.percentage(), search_progress.time_remaining_str(), search_progress.eta_str()) print "Fit for T=%d, %d/%d" % (T, repet_i+1, all_parameters['num_repetitions']) # Update parameter all_parameters['T'] = T ### WORK WORK WORK work? ### # Instantiate (_, _, _, sampler) = launchers.init_everything(all_parameters) # Sample sampler.run_inference(all_parameters) # Compute precision print "get precision..." result_all_precisions[T_i, repet_i] = sampler.get_precision() # Fit mixture model print "fit mixture model..." curr_params_fit = sampler.fit_mixture_model(use_all_targets=False) # curr_params_fit['mixt_nontargets_sum'] = np.sum(curr_params_fit['mixt_nontargets']) result_em_fits[T_i, :, repet_i] = [curr_params_fit[key] for key in ['kappa', 'mixt_target', 'mixt_nontargets_sum', 'mixt_random', 'train_LL', 'bic']] # result_em_fits_allnontargets[T_i, :2, repet_i] = [curr_params_fit['kappa'], curr_params_fit['mixt_target']] # result_em_fits_allnontargets[T_i, 2:(2+T-1), repet_i] = curr_params_fit['mixt_nontargets'] # result_em_fits_allnontargets[T_i, -3:, repet_i] = [curr_params_fit[key] for key in ('mixt_random', 'train_LL', 'bic')] # Compute fisher info # print "compute fisher info" # result_fi_theo[T_i, repet_i] = sampler.estimate_fisher_info_theocov(use_theoretical_cov=False) # result_fi_theocov[T_i, repet_i] = sampler.estimate_fisher_info_theocov(use_theoretical_cov=True) # Compute distances to datasets if T in bays09_T_space: result_dist_bays09[T_i, :, repet_i] = (bays09_experimental_mixtures_mean[:, bays09_T_space == T].flatten() - result_em_fits[T_i, :4, repet_i])**2. result_dist_bays09_emmixt_KL[T_i, repet_i] = utils.KL_div(result_em_fits[T_i, 1:4, repet_i], bays09_experimental_mixtures_mean[1:, bays09_T_space == T].flatten()) if T in gorgo11_T_space: result_dist_gorgo11[T_i, :, repet_i] = (gorgo11_experimental_emfits_mean[:, gorgo11_T_space == T].flatten() - result_em_fits[T_i, :4, repet_i])**2. result_dist_gorgo11_emmixt_KL[T_i, repet_i] = utils.KL_div(result_em_fits[T_i, 1:4, repet_i], gorgo11_experimental_emfits_mean[1:, gorgo11_T_space == T].flatten()) # If needed, store responses if all_parameters['collect_responses']: (responses, target, nontarget) = sampler.collect_responses() result_responses[T_i, :, repet_i] = responses result_target[T_i, :, repet_i] = target result_nontargets[T_i, :, :T_i, repet_i] = nontarget print "collected responses" print "CURRENT RESULTS:\n", result_all_precisions[T_i, repet_i], curr_params_fit, np.sum(result_dist_bays09[T_i, :, repet_i]), np.sum(result_dist_gorgo11[T_i, :, repet_i]), "\n" ### /Work ### search_progress.increment() if run_counter % save_every == 0 or search_progress.done(): dataio.save_variables_default(locals()) run_counter += 1 # Finished dataio.save_variables_default(locals()) print "All finished" return locals()
def compute_result_distemfits_dataset(self, all_variables, experiment_id='bays09', cache_array_name='result_dist_bays09', variable_selection_slice=slice( None, 4), variable_selection_slice_cache=slice( None, None), metric='mse'): ''' Result is the distance (sum squared) to experimental data fits Assume that: - result_em_fits exists. Does an average over repetitions_axis and sums over all others. - metric = 'mse' | 'kl' - variable_selection_slice: slice(0, 1) for kappa, slice(1, 4) for mixt proportions, slice(none, 4) for all EM params ''' assert metric == 'mse' or metric == 'kl', "Metric should be {mse, kl}" repetitions_axis = all_variables.get('repetitions_axis', -1) if cache_array_name in all_variables: # If already computed, use it result_dist_allT = utils.nanmean( all_variables[cache_array_name][:, variable_selection_slice_cache], axis=repetitions_axis) elif 'result_em_fits' in all_variables: # Do some annoying slice manipulation slice_valid_indices = variable_selection_slice.indices( all_variables['result_em_fits'].shape[1]) # Create output variables if metric == 'mse': result_dist_allT = np.nan * np.empty( (all_variables['T_space'].size, slice_valid_indices[1] - slice_valid_indices[0])) elif metric == 'kl': result_dist_allT = np.nan * np.empty((all_variables['T_space'].size)) ### Result computation if experiment_id == 'bays09': data_loaded = load_experimental_data.load_data_bays09( fit_mixture_model=True) elif experiment_id == 'gorgo11': data_loaded = load_experimental_data.load_data_gorgo11( fit_mixture_model=True) else: raise ValueError('wrong experiment_id {}'.format(experiment_id)) experimental_mixtures_mean = data_loaded['em_fits_nitems_arrays']['mean'] experimental_T_space = np.unique(data_loaded['n_items']) curr_result = np.nan for T_i, T in enumerate(all_variables['T_space']): if T in experimental_T_space: if metric == 'mse': curr_result = ( experimental_mixtures_mean[variable_selection_slice, experimental_T_space == T] - all_variables['result_em_fits'][T_i, variable_selection_slice] )**2. elif metric == 'kl': curr_result = utils.KL_div( all_variables['result_em_fits'][T_i, variable_selection_slice], experimental_mixtures_mean[variable_selection_slice, experimental_T_space == T], axis=0) result_dist_allT[T_i] = utils.nanmean( curr_result, axis=repetitions_axis) else: raise ValueError( 'array {}/result_em_fits not present, bad'.format(cache_array_name)) print result_dist_allT # return the overall distance, over all parameters and number of items return np.nansum(result_dist_allT)
def plots_fitmixtmodel_rcscale_effect(data_pbs, generator_module=None): ''' Reload runs from PBS ''' #### SETUP # savefigs = True savedata = True plots_all_T = True plots_per_T = True # do_relaunch_bestparams_pbs = True colormap = None # or 'cubehelix' plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", data_pbs.dataset_infos['parameters'] # parameters: M, ratio_conj, sigmax # Extract data T_space = data_pbs.loaded_data['datasets_list'][0]['T_space'] result_em_fits_flat = np.array(data_pbs.dict_arrays['result_em_fits']['results_flat']) result_precisions_flat = np.array(data_pbs.dict_arrays['result_all_precisions']['results_flat']) result_dist_bays09_flat = np.array(data_pbs.dict_arrays['result_dist_bays09']['results_flat']) result_dist_gorgo11_flat = np.array(data_pbs.dict_arrays['result_dist_gorgo11']['results_flat']) result_dist_bays09_emmixt_KL = np.array(data_pbs.dict_arrays['result_dist_bays09_emmixt_KL']['results_flat']) result_dist_gorgo11_emmixt_KL = np.array(data_pbs.dict_arrays['result_dist_gorgo11_emmixt_KL']['results_flat']) result_parameters_flat = np.array(data_pbs.dict_arrays['result_em_fits']['parameters_flat']) rc_scale_space = data_pbs.loaded_data['parameters_uniques']['rc_scale'] num_repetitions = generator_module.num_repetitions parameter_names_sorted = data_pbs.dataset_infos['parameters'] dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) # Load bays09 data_bays09 = load_experimental_data.load_data_bays09(fit_mixture_model=True) bays09_nitems = data_bays09['data_to_fit']['n_items'] bays09_em_target = np.nan*np.empty((bays09_nitems.max(), 4)) #kappa, prob_target, prob_nontarget, prob_random bays09_em_target[bays09_nitems - 1] = data_bays09['em_fits_nitems_arrays']['mean'].T bays09_emmixt_target = bays09_em_target[:, 1:] ## Compute some stuff result_parameters_flat = result_parameters_flat.flatten() result_em_fits_all_avg = utils.nanmean(result_em_fits_flat, axis=-1) result_em_kappa_allT = result_em_fits_all_avg[..., 0] result_em_emmixt_allT = result_em_fits_all_avg[..., 1:4] result_precisions_all_avg = utils.nanmean(result_precisions_flat, axis=-1) # Square distance to kappa result_dist_bays09_allT_avg = utils.nanmean(result_dist_bays09_flat, axis=-1) result_dist_bays09_emmixt_KL_allT_avg = utils.nanmean(result_dist_bays09_emmixt_KL, axis=-1) result_dist_bays09_kappa_allT = result_dist_bays09_allT_avg[..., 0] # result_dist_bays09_allT_avg = utils.nanmean((result_em_fits_flat[:, :, :4] - bays09_em_target[np.newaxis, :, :, np.newaxis])**2, axis=-1) # result_dist_bays09_kappa_sum = np.nansum(result_dist_bays09_allT_avg[:, :, 0], axis=-1) # result_dist_bays09_kappa_T1_sum = result_dist_bays09_allT_avg[:, 0, 0] # result_dist_bays09_kappa_T25_sum = np.nansum(result_dist_bays09_allT_avg[:, 1:, 0], axis=-1) # # Square and KL distance for EM Mixtures # result_dist_bays09_emmixt_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, :, 1:], axis=-1), axis=-1) # result_dist_bays09_emmixt_T1_sum = np.nansum(result_dist_bays09_allT_avg[:, 0, 1:], axis=-1) # result_dist_bays09_emmixt_T25_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, 1:, 1:], axis=-1), axis=-1) # result_dist_bays09_emmixt_KL = utils.nanmean(utils.KL_div(result_em_fits_flat[:, :, 1:4], bays09_emmixt_target[np.newaxis, :, :, np.newaxis], axis=-2), axis=-1) # KL over dimension of mixtures, then mean over repetitions # result_dist_bays09_emmixt_KL_sum = np.nansum(result_dist_bays09_emmixt_KL, axis=-1) # sum over T # result_dist_bays09_emmixt_KL_T1_sum = result_dist_bays09_emmixt_KL[:, 0] # result_dist_bays09_emmixt_KL_T25_sum = np.nansum(result_dist_bays09_emmixt_KL[:, 1:], axis=-1) # result_dist_bays09_both_normalised = result_dist_bays09_emmixt_sum/np.max(result_dist_bays09_emmixt_sum) + result_dist_bays09_kappa_sum/np.max(result_dist_bays09_kappa_sum) # # Mask kappa for performance too bad # result_dist_bays09_kappa_sum_masked = np.ma.masked_greater(result_dist_bays09_kappa_sum, 2*np.median(result_dist_bays09_kappa_sum)) # result_dist_bays09_emmixt_KL_sum_masked = np.ma.masked_greater(result_dist_bays09_emmixt_KL_sum, 2*np.median(result_dist_bays09_emmixt_KL_sum)) # result_dist_bays09_both_normalised_mult_masked = 1-(1. - result_dist_bays09_emmixt_KL_sum/np.max(result_dist_bays09_emmixt_KL_sum))*(1. - result_dist_bays09_kappa_sum_masked/np.max(result_dist_bays09_kappa_sum_masked)) # Compute optimal rc_scale all_args = data_pbs.loaded_data['args_list'] specific_arg = all_args[0] specific_arg['autoset_parameters'] = True (_, _, _, sampler) = launchers.init_everything(specific_arg) optimal_rc_scale = sampler.random_network.rc_scale[0] if plots_all_T: # Show Kappa evolution wrt rc_scale f, ax = plt.subplots() # utils.plot_mean_std_from_samples(result_parameters_flat, np.nansum(result_em_kappa_allT, axis=-1), bins=60, bins_y=150, xlabel='rc_scale', ylabel='EM kappa', title='Kappa, summed T', ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, np.nansum(result_em_kappa_allT, axis=-1), window=35, xlabel='rc_scale', ylabel='EM kappa', title='Kappa, summed T', ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_kappa_summedT_{label}_{unique_id}.pdf') # Show Mixt proportions f, ax = plt.subplots() for i in xrange(3): # utils.plot_mean_std_from_samples(result_parameters_flat, np.nansum(result_em_emmixt_allT[..., i], axis=-1), bins=60, bins_y=100, xlabel='rc_scale', ylabel='EM mixt proportions', title='EM mixtures, summed T', ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, np.nansum(result_em_emmixt_allT[..., i], axis=-1), window=35, xlabel='rc_scale', ylabel='EM mixt proportions', title='EM mixtures, summed T', ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_mixtprop_summedT_{label}_{unique_id}.pdf') # Show Precision f, ax = plt.subplots() # utils.plot_mean_std_from_samples(result_parameters_flat, np.nansum(result_precisions_all_avg, axis=-1), bins=60, bins_y=150, xlabel='rc_scale', ylabel='Precision', title='Precision, summed T', ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, np.nansum(result_precisions_all_avg, axis=-1), window=35, xlabel='rc_scale', ylabel='Precision', title='Precision, summed T', ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_precision_summedT_{label}_{unique_id}.pdf') plt.close('all') if plots_per_T: for T_i, T in enumerate(T_space): # Show Kappa evolution wrt rc_scale f, ax = plt.subplots() # utils.plot_mean_std_from_samples(result_parameters_flat, result_em_kappa_allT[:, T_i], bins=40, bins_y=100, xlabel='rc_scale', ylabel='EM kappa', title='Kappa, T %d' % T, ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, result_em_kappa_allT[:, T_i], window=35, xlabel='rc_scale', ylabel='EM kappa', title='Kappa, T %d' % T, ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_kappa_T%d_{label}_{unique_id}.pdf' % T) # Show Mixt proportions f, ax = plt.subplots() for i in xrange(3): # utils.plot_mean_std_from_samples(result_parameters_flat, result_em_emmixt_allT[:, T_i, i], bins=40, bins_y=100, xlabel='rc_scale', ylabel='EM mixt proportions', title='EM mixtures, T %d' % T, ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, result_em_emmixt_allT[:, T_i, i], window=35, xlabel='rc_scale', ylabel='EM mixt proportions', title='EM mixtures, T %d' % T, ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_mixtprop_T%d_{label}_{unique_id}.pdf' % T) # Show Precision f, ax = plt.subplots() # utils.plot_mean_std_from_samples(result_parameters_flat, result_precisions_all_avg[:, T_i], bins=40, bins_y=100, xlabel='rc_scale', ylabel='Precision', title='Precision, T %d' % T, ax_handle=ax, show_scatter=False) utils.plot_mean_std_from_samples_rolling(result_parameters_flat, result_precisions_all_avg[:, T_i], window=35, xlabel='rc_scale', ylabel='Precision', title='Precision, T %d' % T, ax_handle=ax, show_scatter=False) ax.axvline(x=optimal_rc_scale, color='g', linewidth=2) ax.axvline(x=2*optimal_rc_scale, color='r', linewidth=2) f.canvas.draw() if savefigs: dataio.save_current_figure('rcscaleeffect_precision_T%d_{label}_{unique_id}.pdf' % T) plt.close('all') # # Interpolate # if plots_interpolate: # sigmax_target = 0.9 # M_interp_space = np.arange(6, 625, 5) # ratio_interp_space = np.linspace(0.01, 1.0, 50) # # sigmax_interp_space = np.linspace(0.01, 1.0, 50) # sigmax_interp_space = np.array([sigmax_target]) # params_crossspace = np.array(utils.cross(M_interp_space, ratio_interp_space, sigmax_interp_space)) # interpolated_data = rbf_interpolator(params_crossspace[:, 0], params_crossspace[:, 1], params_crossspace[:, 2]).reshape((M_interp_space.size, ratio_interp_space.size)) # utils.pcolor_2d_data(interpolated_data, M_interp_space, ratio_interp_space, 'M', 'ratio', 'interpolated, fixing sigmax= %.2f' % sigmax_target) # points_closeby = ((result_parameters_flat[:, 2] - sigmax_target)**2)< 0.01 # plt.figure() # # plt.imshow(interpolated_data, extent=(M_interp_space.min(), M_interp_space.max(), ratio_interp_space.min(), ratio_interp_space.max())) # plt.imshow(interpolated_data) # plt.scatter(result_parameters_flat[points_closeby, 0], result_parameters_flat[points_closeby, 1], s=100, c=result_fitexperiments_bic_avg[points_closeby], marker='o') # 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)) all_args = data_pbs.loaded_data['args_list'] variables_to_save = ['parameter_names_sorted'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='rcscale_characterisation') plt.show() return locals()
def plots_fit_mixturemodels_random(data_pbs, generator_module=None): ''' Reload runs from PBS ''' #### SETUP # savefigs = True savedata = True savemovies = False plots_dist_bays09 = True do_scatters_3d = True do_best_points_extended_plots = True # do_relaunch_bestparams_pbs = True colormap = None # or 'cubehelix' plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", data_pbs.dataset_infos['parameters'] # parameters: M, ratio_conj, sigmax # Extract data result_em_fits_flat = np.array(data_pbs.dict_arrays['result_em_fits']['results_flat']) result_dist_bays09_flat = np.array(data_pbs.dict_arrays['result_dist_bays09']['results_flat']) result_dist_gorgo11_flat = np.array(data_pbs.dict_arrays['result_dist_gorgo11']['results_flat']) result_parameters_flat = np.array(data_pbs.dict_arrays['result_em_fits']['parameters_flat']) M_space = data_pbs.loaded_data['parameters_uniques']['M'] sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] ratio_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] num_repetitions = generator_module.num_repetitions parameter_names_sorted = data_pbs.dataset_infos['parameters'] T_space = data_pbs.loaded_data['datasets_list'][0]['T_space'] all_args = data_pbs.loaded_data['args_list'] all_repeats_completed = data_pbs.dict_arrays['result_em_fits']['repeats_completed'] dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) # Load bays09 data_bays09 = load_experimental_data.load_data_bays09(fit_mixture_model=True) bays09_nitems = data_bays09['data_to_fit']['n_items'] bays09_em_target = np.nan*np.empty((bays09_nitems.max(), 4)) #kappa, prob_target, prob_nontarget, prob_random bays09_em_target[bays09_nitems - 1] = data_bays09['em_fits_nitems_arrays']['mean'].T bays09_emmixt_target = bays09_em_target[:, 1:] # All parameters info plotting_parameters = launcher_memorycurve.load_prepare_datasets() ## Compute some stuff # result_dist_bays09_kappa_T1_avg = utils.nanmean(result_dist_bays09_flat[:, 0, 0], axis=-1) # result_dist_bays09_kappa_allT_avg = np.nansum(utils.nanmean(result_dist_bays09_flat[:, :, 0], axis=-1), axis=1) # Square distance to kappa result_dist_bays09_allT_avg = utils.nanmean((result_em_fits_flat[:, :, :4] - bays09_em_target[np.newaxis, :, :, np.newaxis])**2, axis=-1) result_dist_bays09_kappa_sum = np.nansum(result_dist_bays09_allT_avg[:, :, 0], axis=-1) result_dist_bays09_kappa_sum_masked = np.ma.masked_greater(result_dist_bays09_kappa_sum, 1e8) result_dist_bays09_kappa_T1_sum = result_dist_bays09_allT_avg[:, 0, 0] result_dist_bays09_kappa_T25_sum = np.nansum(result_dist_bays09_allT_avg[:, 1:, 0], axis=-1) # Square and KL distance for EM Mixtures result_dist_bays09_emmixt_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, :, 1:], axis=-1), axis=-1) result_dist_bays09_emmixt_T1_sum = np.nansum(result_dist_bays09_allT_avg[:, 0, 1:], axis=-1) result_dist_bays09_emmixt_T25_sum = np.nansum(np.nansum(result_dist_bays09_allT_avg[:, 1:, 1:], axis=-1), axis=-1) result_dist_bays09_emmixt_KL = utils.nanmean(utils.KL_div(result_em_fits_flat[:, :, 1:4], bays09_emmixt_target[np.newaxis, :, :, np.newaxis], axis=-2), axis=-1) # KL over dimension of mixtures, then mean over repetitions result_dist_bays09_emmixt_KL_sum = np.nansum(result_dist_bays09_emmixt_KL, axis=-1) # sum over T result_dist_bays09_emmixt_KL_T1_sum = result_dist_bays09_emmixt_KL[:, 0] result_dist_bays09_emmixt_KL_T25_sum = np.nansum(result_dist_bays09_emmixt_KL[:, 1:], axis=-1) result_dist_bays09_both_normalised = result_dist_bays09_emmixt_sum/np.max(result_dist_bays09_emmixt_sum) + result_dist_bays09_kappa_sum/np.max(result_dist_bays09_kappa_sum) result_dist_bays09_kappaKL_normalised_summed = result_dist_bays09_emmixt_KL_sum/np.max(result_dist_bays09_emmixt_KL_sum) + result_dist_bays09_kappa_sum/np.max(result_dist_bays09_kappa_sum) if plots_dist_bays09: nb_best_points = 30 size_normal_points = 8 size_best_points = 50 nb_best_points_extended_plots = 3 def plot_memorycurve(result_em_fits, args_used, suptitle=''): packed_data = dict(T_space=T_space, result_em_fits=result_em_fits, all_parameters=args_used) if suptitle: plotting_parameters['suptitle'] = suptitle if savefigs: packed_data['dataio'] = dataio plotting_parameters['reuse_axes'] = False launcher_memorycurve.do_memory_plots(packed_data, plotting_parameters) def plot_scatter(result_dist_to_use, best_points_result_dist_to_use, result_dist_to_use_name='', title=''): fig = plt.figure() ax = Axes3D(fig) utils.scatter3d(result_parameters_flat[:, 0], result_parameters_flat[:, 1], result_parameters_flat[:, 2], s=size_normal_points, c=np.log(result_dist_to_use), xlabel=parameter_names_sorted[0], ylabel=parameter_names_sorted[1], zlabel=parameter_names_sorted[2], title=title, ax_handle=ax) utils.scatter3d(result_parameters_flat[best_points_result_dist_to_use, 0], result_parameters_flat[best_points_result_dist_to_use, 1], result_parameters_flat[best_points_result_dist_to_use, 2], c='r', s=size_best_points, ax_handle=ax) print "Best points, %s:" % title print '\n'.join(['M %d, ratio %.2f, sigmax %.2f: %f' % (result_parameters_flat[i, 0], result_parameters_flat[i, 1], result_parameters_flat[i, 2], result_dist_to_use[i]) for i in best_points_result_dist_to_use]) if savefigs: dataio.save_current_figure('scatter3d_%s_{label}_{unique_id}.pdf' % result_dist_to_use_name) if savemovies: try: utils.rotate_plot3d(ax, dataio.create_formatted_filename('scatter3d_%s_{label}_{unique_id}.mp4' % result_dist_to_use_name), bitrate=8000, min_duration=8) utils.rotate_plot3d(ax, dataio.create_formatted_filename('scatter3d_%s_{label}_{unique_id}.gif' % result_dist_to_use_name), nb_frames=30, min_duration=8) except Exception: # Most likely wrong aggregator... print "failed when creating movies for ", result_dist_to_use_name ax.view_init(azim=90, elev=10) dataio.save_current_figure('scatter3d_%s_view2_{label}_{unique_id}.pdf' % result_dist_to_use_name) return ax def plots_redirects(all_vars, result_dist_to_use_name, log_color=True, title='', avoid_incomplete_repeats=True): result_dist_to_use = all_vars[result_dist_to_use_name] if avoid_incomplete_repeats: result_dist_to_use = np.ma.masked_where(~(all_repeats_completed == num_repetitions-1), result_dist_to_use) if not log_color: result_dist_to_use = np.exp(result_dist_to_use) best_points_result_dist_to_use = np.argsort(result_dist_to_use)[:nb_best_points] # Scatter if do_scatters_3d: plot_scatter(result_dist_to_use, best_points_result_dist_to_use, result_dist_to_use_name, title=title) # Now do the additional plots if required if do_best_points_extended_plots: for best_point_index in best_points_result_dist_to_use[:nb_best_points_extended_plots]: print "extended plot for M %d, ratio %.2f, sigmax %.2f: score %f" % (result_parameters_flat[best_point_index, 0], result_parameters_flat[best_point_index, 1], result_parameters_flat[best_point_index, 2], result_dist_to_use[best_point_index]) plot_memorycurve(result_em_fits_flat[best_point_index], all_args[best_point_index], suptitle=result_dist_to_use_name) # Distance for kappa, all T plots_redirects(locals(), 'result_dist_bays09_kappa_sum', title='kappa all T') # Distance for em fits, all T, Squared distance plots_redirects(locals(), 'result_dist_bays09_emmixt_sum', title='em fits, all T') # Distance for em fits, all T, KL distance plots_redirects(locals(), 'result_dist_bays09_emmixt_KL_sum', title='em fits, all T, KL') # Distance for sum of normalised em fits + normalised kappa, all T plots_redirects(locals(), 'result_dist_bays09_both_normalised', title='summed normalised em mixt + kappa') # Distance kappa T = 1 plots_redirects(locals(), 'result_dist_bays09_kappa_T1_sum', title='Kappa T=1') # Distance kappa T = 2...5 plots_redirects(locals(), 'result_dist_bays09_kappa_T25_sum', title='Kappa T=2/5') # Distance em fits T = 1 plots_redirects(locals(), 'result_dist_bays09_emmixt_T1_sum', title='em fits T=1') # Distance em fits T = 2...5 plots_redirects(locals(), 'result_dist_bays09_emmixt_T25_sum', title='em fits T=2/5') # Distance em fits T = 1, KL plots_redirects(locals(), 'result_dist_bays09_emmixt_KL_T1_sum', title='em fits T=1, KL') # Distance em fits T = 2...5, KL plots_redirects(locals(), 'result_dist_bays09_emmixt_KL_T25_sum', title='em fits T=2/5, KL') # if plots_per_T: # for T in T_space: # currT_indices = result_parameters_flat[:, 2] == T # utils.contourf_interpolate_data_interactive_maxvalue(result_parameters_flat[currT_indices][..., :2], result_fitexperiments_bic_avg[currT_indices], xlabel='Ratio_conj', ylabel='sigma x', title='BIC, T %d' % T, interpolation_numpoints=200, interpolation_method='nearest', log_scale=False) # # Interpolate # if plots_interpolate: # sigmax_target = 0.9 # M_interp_space = np.arange(6, 625, 5) # ratio_interp_space = np.linspace(0.01, 1.0, 50) # # sigmax_interp_space = np.linspace(0.01, 1.0, 50) # sigmax_interp_space = np.array([sigmax_target]) # params_crossspace = np.array(utils.cross(M_interp_space, ratio_interp_space, sigmax_interp_space)) # interpolated_data = rbf_interpolator(params_crossspace[:, 0], params_crossspace[:, 1], params_crossspace[:, 2]).reshape((M_interp_space.size, ratio_interp_space.size)) # utils.pcolor_2d_data(interpolated_data, M_interp_space, ratio_interp_space, 'M', 'ratio', 'interpolated, fixing sigmax= %.2f' % sigmax_target) # points_closeby = ((result_parameters_flat[:, 2] - sigmax_target)**2)< 0.01 # plt.figure() # # plt.imshow(interpolated_data, extent=(M_interp_space.min(), M_interp_space.max(), ratio_interp_space.min(), ratio_interp_space.max())) # plt.imshow(interpolated_data) # plt.scatter(result_parameters_flat[points_closeby, 0], result_parameters_flat[points_closeby, 1], s=100, c=result_fitexperiments_bic_avg[points_closeby], marker='o') # 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)) variables_to_save = ['parameter_names_sorted', 'all_repeats_completed', 'T_space'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='fit_mixturemodels') plt.show() return locals()
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 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 do_error_distrib_fits = True plot_pcolor_fit_precision_to_fisherinfo = True plot_selected_memory_curves = False plot_best_memory_curves = False plot_best_error_distrib = 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(data_pbs.dict_arrays["result_all_precisions"]["results"], axis=-1) result_all_precisions_std = utils.nanstd(data_pbs.dict_arrays["result_all_precisions"]["results"], axis=-1) result_em_fits_mean = utils.nanmean(data_pbs.dict_arrays["result_em_fits"]["results"], axis=-1) result_em_fits_std = utils.nanstd(data_pbs.dict_arrays["result_em_fits"]["results"], axis=-1) result_marginal_inv_fi_mean = utils.nanmean(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"], axis=-1) result_marginal_inv_fi_std = utils.nanstd(data_pbs.dict_arrays["result_marginal_inv_fi"]["results"], axis=-1) result_marginal_fi_mean = utils.nanmean(1.0 / data_pbs.dict_arrays["result_marginal_inv_fi"]["results"], axis=-1) result_marginal_fi_std = utils.nanstd(1.0 / data_pbs.dict_arrays["result_marginal_inv_fi"]["results"], axis=-1) result_responses_all = data_pbs.dict_arrays["result_responses"]["results"] result_target_all = data_pbs.dict_arrays["result_target"]["results"] result_nontargets_all = data_pbs.dict_arrays["result_nontargets"]["results"] M_space = data_pbs.loaded_data["parameters_uniques"]["M"].astype(int) sigmax_space = data_pbs.loaded_data["parameters_uniques"]["sigmax"] T_space = data_pbs.loaded_data["datasets_list"][0]["T_space"] nb_repetitions = result_responses_all.shape[-1] 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 experim_datadir = os.environ.get("WORKDIR_DROP", os.path.split(load_experimental_data.__file__)[0]) data_simult = load_experimental_data.load_data_simult( data_dir=os.path.normpath(os.path.join(experim_datadir, "../../experimental_data/")), fit_mixture_model=True ) gorgo11_experimental_precision = data_simult["precision_nitems_theo"] gorgo11_experimental_kappa = np.array([data["kappa"] for _, data in data_simult["em_fits_nitems"]["mean"].items()]) gorgo11_experimental_emfits_mean = np.array( [ [data[key] for _, data in data_simult["em_fits_nitems"]["mean"].items()] for key in ["kappa", "mixt_target", "mixt_nontargets", "mixt_random"] ] ) gorgo11_experimental_emfits_std = np.array( [ [data[key] for _, data in data_simult["em_fits_nitems"]["std"].items()] for key in ["kappa", "mixt_target", "mixt_nontargets", "mixt_random"] ] ) gorgo11_experimental_emfits_sem = gorgo11_experimental_emfits_std / np.sqrt(np.unique(data_simult["subject"]).size) 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"] bays09_experimental_mixtures_std = data_bays2009["em_fits_nitems_arrays"]["std"] # add interpolated points for 3 and 5 items emfit_mean_intpfct = spint.interp1d(np.unique(data_bays2009["n_items"]), bays09_experimental_mixtures_mean) bays09_experimental_mixtures_mean_compatible = emfit_mean_intpfct(np.arange(1, 7)) emfit_std_intpfct = spint.interp1d(np.unique(data_bays2009["n_items"]), bays09_experimental_mixtures_std) bays09_experimental_mixtures_std_compatible = emfit_std_intpfct(np.arange(1, 7)) T_space_bays09 = np.arange(1, 6) # 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[..., : gorgo11_experimental_kappa.size] - gorgo11_experimental_precision) ** 2.0, axis=-1, ) dist_diff_emkappa_experim = np.sum( np.abs(result_em_fits_mean[..., 0, : gorgo11_experimental_kappa.size] - gorgo11_experimental_kappa) ** 2.0, axis=-1, ) dist_diff_em_mixtures_bays09 = np.sum( np.sum((result_em_fits_mean[..., 1:4] - bays09_experimental_mixtures_mean_compatible[1:].T) ** 2.0, 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.0, axis=-1), axis=-1 ) if do_error_distrib_fits: print "computing error distribution histograms fits" # Now try to fit histograms of errors to target/nontargets bays09_hist_target_mean = data_bays2009["hist_cnts_target_nitems_stats"]["mean"] bays09_hist_target_std = data_bays2009["hist_cnts_target_nitems_stats"]["std"] bays09_hist_nontarget_mean = data_bays2009["hist_cnts_nontarget_nitems_stats"]["mean"] bays09_hist_nontarget_std = data_bays2009["hist_cnts_nontarget_nitems_stats"]["std"] T_space_bays09_filt = np.unique(data_bays2009["n_items"]) angle_space = np.linspace(-np.pi, np.pi, bays09_hist_target_mean.shape[-1] + 1) bins_center = angle_space[:-1] + np.diff(angle_space)[0] / 2 errors_targets = utils.wrap_angles(result_responses_all - result_target_all) hist_targets_all = np.empty( (M_space.size, sigmax_space.size, T_space_bays09_filt.size, angle_space.size - 1, nb_repetitions) ) errors_nontargets = np.nan * np.empty(result_nontargets_all.shape) hist_nontargets_all = np.empty( (M_space.size, sigmax_space.size, T_space_bays09_filt.size, angle_space.size - 1, nb_repetitions) ) for M_i, M in enumerate(M_space): for sigmax_i, sigmax in enumerate(sigmax_space): for T_bays_i, T_bays in enumerate(T_space_bays09_filt): for repet_i in xrange(nb_repetitions): # Could do a nicer indexing but f**k it # Histogram errors to targets hist_targets_all[M_i, sigmax_i, T_bays_i, :, repet_i], x, bins = utils.histogram_binspace( utils.dropnan(errors_targets[M_i, sigmax_i, T_bays - 1, ..., repet_i]), bins=angle_space, norm="density", ) # Compute the error between the responses and nontargets. errors_nontargets[M_i, sigmax_i, T_bays - 1, :, :, repet_i] = utils.wrap_angles( ( result_responses_all[M_i, sigmax_i, T_bays - 1, :, repet_i, np.newaxis] - result_nontargets_all[M_i, sigmax_i, T_bays - 1, :, :, repet_i] ) ) # Histogram it hist_nontargets_all[M_i, sigmax_i, T_bays_i, :, repet_i], x, bins = utils.histogram_binspace( utils.dropnan(errors_nontargets[M_i, sigmax_i, T_bays - 1, ..., repet_i]), bins=angle_space, norm="density", ) hist_targets_mean = utils.nanmean(hist_targets_all, axis=-1).filled(np.nan) hist_targets_std = utils.nanstd(hist_targets_all, axis=-1).filled(np.nan) hist_nontargets_mean = utils.nanmean(hist_nontargets_all, axis=-1).filled(np.nan) hist_nontargets_std = utils.nanstd(hist_nontargets_all, axis=-1).filled(np.nan) # Compute distances to experimental histograms dist_diff_hist_target_bays09 = np.nansum( np.nansum((hist_targets_mean - bays09_hist_target_mean) ** 2.0, axis=-1), axis=-1 ) dist_diff_hist_nontargets_bays09 = np.nansum( np.nansum((hist_nontargets_mean - bays09_hist_nontarget_mean) ** 2.0, axis=-1), axis=-1 ) dist_diff_hist_nontargets_5_6items_bays09 = np.nansum( np.nansum((hist_nontargets_mean[:, :, -2:] - bays09_hist_nontarget_mean[-2:]) ** 2.0, axis=-1), axis=-1 ) if plot_pcolor_fit_precision_to_fisherinfo: # Check fit between precision and Experiments utils.pcolor_2d_data( dist_diff_precision_experim, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", xlabel_format="%d", ) if savefigs: dataio.save_current_figure("match_precision_exper_log_pcolor_{label}_{unique_id}.pdf") utils.pcolor_2d_data( dist_diff_emkappa_experim, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", xlabel_format="%d" ) if savefigs: dataio.save_current_figure("match_emkappa_model_exper_pcolor_{label}_{unique_id}.pdf") utils.pcolor_2d_data( dist_diff_em_mixtures_bays09, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True, xlabel_format="%d", ) if savefigs: dataio.save_current_figure("match_emmixtures_experbays09_log_pcolor_{label}_{unique_id}.pdf") utils.pcolor_2d_data( dist_diff_modelfits_experfits_bays09, log_scale=True, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", xlabel_format="%d", ) if savefigs: dataio.save_current_figure("match_diff_emfits_experbays09_pcolor_{label}_{unique_id}.pdf") if do_error_distrib_fits: utils.pcolor_2d_data( dist_diff_hist_target_bays09, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True, xlabel_format="%d", ) if savefigs: dataio.save_current_figure("match_hist_targets_experbays09_log_pcolor_{label}_{unique_id}.pdf") utils.pcolor_2d_data( dist_diff_hist_nontargets_bays09, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True, xlabel_format="%d", ) if savefigs: dataio.save_current_figure("match_hist_nontargets_experbays09_log_pcolor_{label}_{unique_id}.pdf") utils.pcolor_2d_data( dist_diff_hist_nontargets_5_6items_bays09, x=M_space, y=sigmax_space, xlabel="M", ylabel="sigmax", log_scale=True, xlabel_format="%d", ) if savefigs: dataio.save_current_figure( "match_hist_nontargets_6items_experbays09_log_pcolor_{label}_{unique_id}.pdf" ) # Macro plot def mem_plot_precision(sigmax_i, M_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[M_i, sigmax_i, : mem_exp_prec.size], result_all_precisions_std[M_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][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 = 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, label='Fitted kappa') ax.set_title("M %d, sigmax %.2f" % (M_space[M_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_M%dsigmax%.2f_{label}_{unique_id}.pdf" % (M_space[M_i], sigmax_space[sigmax_i]) ) 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 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 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 hist_errors_targets_nontargets(hists_toplot_mean, hists_toplot_std, title="", M=0, sigmax=0, yaxis_lim="auto"): f1, axes1 = plt.subplots( ncols=hists_toplot_mean.shape[-2], figsize=(hists_toplot_mean.shape[-2] * 6, 6), sharey=True ) for T_bays_i, T_bays in enumerate(T_space_bays09_filt): if not np.all(np.isnan(hists_toplot_mean[T_bays_i])): axes1[T_bays_i].bar( bins_center, hists_toplot_mean[T_bays_i], width=2.0 * np.pi / (angle_space.size - 1), align="center", yerr=hists_toplot_std[T_bays_i], ) axes1[T_bays_i].set_title("N=%d" % T_bays) # axes1[T_{}] axes1[T_bays_i].set_xlim( [bins_center[0] - np.pi / (angle_space.size - 1), bins_center[-1] + np.pi / (angle_space.size - 1)] ) if yaxis_lim == "target": axes1[T_bays_i].set_ylim([0.0, 2.0]) elif yaxis_lim == "nontarget": axes1[T_bays_i].set_ylim([0.0, 0.3]) else: axes1[T_bays_i].set_ylim([0.0, np.nanmax(hists_toplot_mean + hists_toplot_std) * 1.1]) axes1[T_bays_i].set_xticks((-np.pi, -np.pi / 2, 0, np.pi / 2.0, np.pi)) axes1[T_bays_i].set_xticklabels( (r"$-\pi$", r"$-\frac{\pi}{2}$", r"$0$", r"$\frac{\pi}{2}$", r"$\pi$"), fontsize=16 ) f1.canvas.draw() if savefigs: dataio.save_current_figure( "memorycurves_hist_%s_paper_M%dsigmax%.2f_{label}_{unique_id}.pdf" % (title, M, sigmax) ) ################################# if plot_selected_memory_curves: selected_values = [[0.84, 0.23], [0.84, 0.19]] 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)) mem_plot_precision(sigmax_i, M_i) mem_plot_kappa(sigmax_i, M_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, gorgo11_experimental_precision) # 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, gorgo11_experimental_emfits_mean[0], gorgo11_experimental_emfits_std[0] ) # 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) # best_axis2_i_all = np.argmin(dist_diff_em_mixtures_bays09, axis=1) for axis1_i, best_axis2_i in enumerate(best_axis2_i_all): mem_plot_kappa( best_axis2_i, axis1_i, bays09_experimental_mixtures_mean_compatible[0, : T_space_bays09.size], bays09_experimental_mixtures_std_compatible[0, : T_space_bays09.size], ) # em_plot(best_axis2_i, axis1_i) em_plot_paper(best_axis2_i, axis1_i) if plot_best_error_distrib and do_error_distrib_fits: # Best target histograms best_axis2_i_all = np.argmin(dist_diff_hist_target_bays09, axis=1) for axis1_i, best_axis2_i in enumerate(best_axis2_i_all): hist_errors_targets_nontargets( hist_targets_mean[axis1_i, best_axis2_i], hist_targets_std[axis1_i, best_axis2_i], "target", M=M_space[axis1_i], sigmax=sigmax_space[best_axis2_i], yaxis_lim="target", ) # Best nontarget histograms best_axis2_i_all = np.argmin(dist_diff_hist_nontargets_bays09, axis=1) for axis1_i, best_axis2_i in enumerate(best_axis2_i_all): hist_errors_targets_nontargets( hist_nontargets_mean[axis1_i, best_axis2_i], hist_nontargets_std[axis1_i, best_axis2_i], "nontarget", M=M_space[axis1_i], sigmax=sigmax_space[best_axis2_i], yaxis_lim="nontarget", ) all_args = data_pbs.loaded_data["args_list"] variables_to_save = [ "gorgo11_experimental_precision", "gorgo11_experimental_kappa", "bays09_experimental_mixtures_mean_compatible", "T_space", ] 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 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_memory_curves(data_pbs, generator_module=None): ''' Reload and plot memory curve of a conjunctive 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 = False 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./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 experim_datadir = os.environ.get('WORKDIR_DROP', os.path.split(load_experimental_data.__file__)[0]) data_simult = load_experimental_data.load_data_simult(data_dir=os.path.normpath(os.path.join(experim_datadir, '../../experimental_data/')), fit_mixture_model=True) gorgo11_experimental_precision = data_simult['precision_nitems_theo'] gorgo11_experimental_kappa = np.array([data_s['kappa'] for _, data_s in data_simult['em_fits_nitems']['mean'].items()]) gorgo11_experimental_emfits_mean = np.array([[data[key] for _, data in data_simult['em_fits_nitems']['mean'].items()] for key in ['kappa', 'mixt_target', 'mixt_nontargets', 'mixt_random']]) gorgo11_experimental_emfits_std = np.array([[data[key] for _, data in data_simult['em_fits_nitems']['std'].items()] for key in ['kappa', 'mixt_target', 'mixt_nontargets', 'mixt_random']]) gorgo11_experimental_emfits_sem = gorgo11_experimental_emfits_std/np.sqrt(np.unique(data_simult['subject']).size) data_bays2009 = load_experimental_data.load_data_bays09(data_dir=os.path.normpath(os.path.join(experim_datadir, '../../experimental_data/')), fit_mixture_model=True) # add interpolated points for 3 and 5 items emfit_mean_intpfct = spint.interp1d(np.unique(data_bays2009['n_items']), data_bays2009['em_fits_nitems_arrays']['mean']) bays09_experimental_mixtures_mean_compatible = emfit_mean_intpfct(np.arange(1, 6)) emfit_std_intpfct = spint.interp1d(np.unique(data_bays2009['n_items']), data_bays2009['em_fits_nitems_arrays']['std']) bays09_experimental_mixtures_std_compatible = emfit_std_intpfct(np.arange(1, 6)) # 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. - 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 - gorgo11_experimental_precision)**2., axis=-1) dist_diff_emkappa_experim = np.sum(np.abs(result_em_fits_mean[..., 0] - gorgo11_experimental_kappa)**2., axis=-1) dist_diff_precision_experim_1item = np.abs(result_all_precisions_mean[..., 0] - gorgo11_experimental_precision[0])**2. dist_diff_precision_experim_2item = np.abs(result_all_precisions_mean[..., 1] - gorgo11_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] - gorgo11_experimental_kappa[0])**2. dist_diff_margfi_experim_1item = np.abs(result_marginal_fi_mean[..., 0, 0] - gorgo11_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) 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, x=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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=M_space, y=sigmax_space, xlabel='M', 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_emkappa_mixtures_bays09, log_scale=True, x=M_space, y=sigmax_space, xlabel='M', ylabel='sigmax') if savefigs: dataio.save_current_figure('match_diff_mixtures_experbays09_pcolor_{label}_{unique_id}.pdf') # Macro plot def mem_plot_precision(sigmax_i, M_i): ax = utils.plot_mean_std_area(T_space, gorgo11_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[M_i, sigmax_i], result_all_precisions_std[M_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][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 = 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, label='Fitted kappa') 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_precision_M%dsigmax%.2f_{label}_{unique_id}.pdf' % (M_space[M_i], sigmax_space[sigmax_i])) 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 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_selected_memory_curves: selected_values = [[100, 0.1], [196, 0.28], [64, 0.05]] 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)) mem_plot_precision(sigmax_i, M_i) mem_plot_kappa(sigmax_i, M_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, gorgo11_experimental_emfits_mean[0], gorgo11_experimental_emfits_std[0]) mem_plot_precision(best_axis2_i, axis1_i) # Best mixtures fit for Bays09 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 = ['gorgo11_experimental_precision', 'gorgo11_experimental_kappa'] 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 plot_bootstrap_randomsamples(): ''' Do histograms with random samples from bootstrap nontarget estimates ''' dataio = DataIO(label='plotpaper_bootstrap_randomized') nb_bootstrap_samples = 200 dropboxdir = os.environ.get('WORKDIR_DROP', os.path.split(utils.__file__)[0]) datadir = os.path.join(dropboxdir, 'Data/cache_bootstrap_randomsamples_papertheo/') caching_save_filename = 'bootstrap_histo.npy' angle_space = np.linspace(-np.pi, np.pi, 51) bins_center = angle_space[:-1] + np.diff(angle_space)[0]/2 data_bays2009 = load_experimental_data.load_data_bays09(fit_mixture_model=True) data_bootstrap = dict() should_compute_bootstrap = True save_caching_file = False ## Super long simulation, use precomputed data maybe? if caching_save_filename is not None: caching_save_filename = os.path.join(datadir, caching_save_filename) if os.path.exists(caching_save_filename): # Got file, open it and try to use its contents try: with open(caching_save_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) data_bootstrap.update(cached_data) should_compute_bootstrap = False print "reloaded bootstrap data from cache", caching_save_filename except IOError: print "Cannot load ", caching_save_filename else: # No file, create it after everything is computed save_caching_file = True if should_compute_bootstrap: data_bootstrap = compute_bootstrap_samples( data_bays2009, nb_bootstrap_samples, angle_space) if save_caching_file: try: os.makedirs(datadir) with open(caching_save_filename, 'w') as filecache_out: pickle.dump(data_bootstrap, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_save_filename # Unpack for simplicity responses_resampled = data_bootstrap['responses_resampled'] error_nontargets_resampled = data_bootstrap['error_nontargets_resampled'] error_targets_resampled = data_bootstrap['error_targets_resampled'] hist_cnts_nontarget_bootstraps_nitems = data_bootstrap['hist_cnts_nontarget_bootstraps_nitems'] hist_cnts_target_bootstraps_nitems = data_bootstrap['hist_cnts_target_bootstraps_nitems'] # Now show average histogram hist_cnts_target_bootstraps_nitems_mean = np.mean(hist_cnts_target_bootstraps_nitems, axis=-2) hist_cnts_target_bootstraps_nitems_std = np.std(hist_cnts_target_bootstraps_nitems, axis=-2) hist_cnts_target_bootstraps_nitems_sem = hist_cnts_target_bootstraps_nitems_std/np.sqrt(hist_cnts_target_bootstraps_nitems.shape[1]) hist_cnts_nontarget_bootstraps_nitems_mean = np.mean(hist_cnts_nontarget_bootstraps_nitems, axis=-2) hist_cnts_nontarget_bootstraps_nitems_std = np.std(hist_cnts_nontarget_bootstraps_nitems, axis=-2) hist_cnts_nontarget_bootstraps_nitems_sem = hist_cnts_nontarget_bootstraps_nitems_std/np.sqrt(hist_cnts_target_bootstraps_nitems.shape[1]) f1, axes1 = plt.subplots(ncols=np.unique(data_bays2009['n_items']).size-1, figsize=((np.unique(data_bays2009['n_items']).size-1)*6, 6), sharey=True) for n_items_i, n_items in enumerate(np.unique(data_bays2009['n_items'])): if n_items > 1: utils.plot_mean_std_area(bins_center, hist_cnts_nontarget_bootstraps_nitems_mean[n_items_i], hist_cnts_nontarget_bootstraps_nitems_sem[n_items_i], ax_handle=axes1[n_items_i-1], color='k') # Now add the Data histograms axes1[n_items_i-1].bar(bins_center, data_bays2009['hist_cnts_nontarget_nitems_stats']['mean'][n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=data_bays2009['hist_cnts_nontarget_nitems_stats']['sem'][n_items_i]) # axes4[n_items_i-1].set_title('N=%d' % n_items) axes1[n_items_i-1].set_xlim([bins_center[0]-np.pi/(angle_space.size-1), bins_center[-1]+np.pi/(angle_space.size-1)]) # axes3[n_items_i-1].set_ylim([0., 2.0]) axes1[n_items_i-1].set_xticks((-np.pi, -np.pi/2, 0, np.pi/2., np.pi)) axes1[n_items_i-1].set_xticklabels((r'$-\pi$', r'$-\frac{\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$', r'$\pi$'), fontsize=16) # axes1[n_items_i-1].bar(bins_center, hist_cnts_nontarget_bootstraps_nitems_mean[n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=hist_cnts_nontarget_bootstraps_nitems_std[n_items_i]) axes1[n_items_i-1].get_figure().canvas.draw() if dataio is not None: plt.tight_layout() dataio.save_current_figure("hist_error_nontarget_persubj_{label}_{unique_id}.pdf") if False: f2, axes2 = plt.subplots(ncols=np.unique(data_bays2009['n_items']).size-1, figsize=((np.unique(data_bays2009['n_items']).size-1)*6, 6), sharey=True) for n_items_i, n_items in enumerate(np.unique(data_bays2009['n_items'])): utils.plot_mean_std_area(bins_center, hist_cnts_target_bootstraps_nitems_mean[n_items_i], hist_cnts_target_bootstraps_nitems_std[n_items_i], ax_handle=axes2[n_items_i-1]) # axes2[n_items_i-1].bar(bins_center, hist_cnts_target_bootstraps_nitems_mean[n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=hist_cnts_target_bootstraps_nitems_std[n_items_i]) return locals()
def plot_bootstrap_randomsamples(): ''' Do histograms with random samples from bootstrap nontarget estimates ''' dataio = DataIO(label='plotpaper_bootstrap_randomized') nb_bootstrap_samples = 200 use_precomputed = True angle_space = np.linspace(-np.pi, np.pi, 51) bins_center = angle_space[:-1] + np.diff(angle_space)[0]/2 data_bays2009 = load_experimental_data.load_data_bays09(fit_mixture_model=True) ## Super long simulation, use precomputed data maybe? if use_precomputed: data = pickle.load(open('/Users/loicmatthey/Dropbox/UCL/1-phd/Work/Visual_working_memory/code/git-bayesian-visual-working-memory/Data/cache_randomized_bootstrap_samples_plots_paper_theo_plotbootstrapsamples/bootstrap_histo_katz.npy', 'r')) responses_resampled = data['responses_resampled'] error_nontargets_resampled = data['error_nontargets_resampled'] error_targets_resampled = data['error_targets_resampled'] hist_cnts_nontarget_bootstraps_nitems = data['hist_cnts_nontarget_bootstraps_nitems'] hist_cnts_target_bootstraps_nitems = data['hist_cnts_target_bootstraps_nitems'] else: responses_resampled = np.empty((np.unique(data_bays2009['n_items']).size, nb_bootstrap_samples), dtype=np.object) error_nontargets_resampled = np.empty((np.unique(data_bays2009['n_items']).size, nb_bootstrap_samples), dtype=np.object) error_targets_resampled = np.empty((np.unique(data_bays2009['n_items']).size, nb_bootstrap_samples), dtype=np.object) hist_cnts_nontarget_bootstraps_nitems = np.empty((np.unique(data_bays2009['n_items']).size, nb_bootstrap_samples, angle_space.size - 1))*np.nan hist_cnts_target_bootstraps_nitems = np.empty((np.unique(data_bays2009['n_items']).size, nb_bootstrap_samples, angle_space.size - 1))*np.nan for n_items_i, n_items in enumerate(np.unique(data_bays2009['n_items'])): # Data collapsed accross subjects ids_filtered = (data_bays2009['n_items'] == n_items).flatten() if n_items > 1: # Get random bootstrap nontargets bootstrap_nontargets = utils.sample_angle(data_bays2009['item_angle'][ids_filtered, 1:n_items].shape + (nb_bootstrap_samples, )) # Compute associated EM fits bootstrap_results = [] for bootstrap_i in progress.ProgressDisplay(np.arange(nb_bootstrap_samples), display=progress.SINGLE_LINE): em_fit = em_circularmixture_allitems_uniquekappa.fit(data_bays2009['response'][ids_filtered, 0], data_bays2009['item_angle'][ids_filtered, 0], bootstrap_nontargets[..., bootstrap_i]) bootstrap_results.append(em_fit) # Get EM samples responses_resampled[n_items_i, bootstrap_i] = em_circularmixture_allitems_uniquekappa.sample_from_fit(em_fit, data_bays2009['item_angle'][ids_filtered, 0], bootstrap_nontargets[..., bootstrap_i]) # Compute the errors error_nontargets_resampled[n_items_i, bootstrap_i] = utils.wrap_angles(responses_resampled[n_items_i, bootstrap_i][:, np.newaxis] - bootstrap_nontargets[..., bootstrap_i]) error_targets_resampled[n_items_i, bootstrap_i] = utils.wrap_angles(responses_resampled[n_items_i, bootstrap_i] - data_bays2009['item_angle'][ids_filtered, 0]) # Bin everything hist_cnts_nontarget_bootstraps_nitems[n_items_i, bootstrap_i], x, bins = utils.histogram_binspace(utils.dropnan(error_nontargets_resampled[n_items_i, bootstrap_i]), bins=angle_space, norm='density') hist_cnts_target_bootstraps_nitems[n_items_i, bootstrap_i], x, bins = utils.histogram_binspace(utils.dropnan(error_targets_resampled[n_items_i, bootstrap_i]), bins=angle_space, norm='density') # Now show average histogram hist_cnts_target_bootstraps_nitems_mean = np.mean(hist_cnts_target_bootstraps_nitems, axis=-2) hist_cnts_target_bootstraps_nitems_std = np.std(hist_cnts_target_bootstraps_nitems, axis=-2) hist_cnts_target_bootstraps_nitems_sem = hist_cnts_target_bootstraps_nitems_std/np.sqrt(hist_cnts_target_bootstraps_nitems.shape[1]) hist_cnts_nontarget_bootstraps_nitems_mean = np.mean(hist_cnts_nontarget_bootstraps_nitems, axis=-2) hist_cnts_nontarget_bootstraps_nitems_std = np.std(hist_cnts_nontarget_bootstraps_nitems, axis=-2) hist_cnts_nontarget_bootstraps_nitems_sem = hist_cnts_nontarget_bootstraps_nitems_std/np.sqrt(hist_cnts_target_bootstraps_nitems.shape[1]) f1, axes1 = plt.subplots(ncols=np.unique(data_bays2009['n_items']).size-1, figsize=((np.unique(data_bays2009['n_items']).size-1)*6, 6), sharey=True) for n_items_i, n_items in enumerate(np.unique(data_bays2009['n_items'])): if n_items>1: utils.plot_mean_std_area(bins_center, hist_cnts_nontarget_bootstraps_nitems_mean[n_items_i], hist_cnts_nontarget_bootstraps_nitems_sem[n_items_i], ax_handle=axes1[n_items_i-1], color='k') # Now add the Data histograms axes1[n_items_i-1].bar(bins_center, data_bays2009['hist_cnts_nontarget_nitems_stats']['mean'][n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=data_bays2009['hist_cnts_nontarget_nitems_stats']['sem'][n_items_i]) # axes4[n_items_i-1].set_title('N=%d' % n_items) axes1[n_items_i-1].set_xlim([bins_center[0]-np.pi/(angle_space.size-1), bins_center[-1]+np.pi/(angle_space.size-1)]) # axes3[n_items_i-1].set_ylim([0., 2.0]) axes1[n_items_i-1].set_xticks((-np.pi, -np.pi/2, 0, np.pi/2., np.pi)) axes1[n_items_i-1].set_xticklabels((r'$-\pi$', r'$-\frac{\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$', r'$\pi$'), fontsize=16) # axes1[n_items_i-1].bar(bins_center, hist_cnts_nontarget_bootstraps_nitems_mean[n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=hist_cnts_nontarget_bootstraps_nitems_std[n_items_i]) axes1[n_items_i-1].get_figure().canvas.draw() if dataio is not None: plt.tight_layout() dataio.save_current_figure("hist_error_nontarget_persubj_{label}_{unique_id}.pdf") if False: f2, axes2 = plt.subplots(ncols=np.unique(data_bays2009['n_items']).size-1, figsize=((np.unique(data_bays2009['n_items']).size-1)*6, 6), sharey=True) for n_items_i, n_items in enumerate(np.unique(data_bays2009['n_items'])): utils.plot_mean_std_area(bins_center, hist_cnts_target_bootstraps_nitems_mean[n_items_i], hist_cnts_target_bootstraps_nitems_std[n_items_i], ax_handle=axes2[n_items_i-1]) # axes2[n_items_i-1].bar(bins_center, hist_cnts_target_bootstraps_nitems_mean[n_items_i], width=2.*np.pi/(angle_space.size-1), align='center', yerr=hist_cnts_target_bootstraps_nitems_std[n_items_i]) return locals()