def plots_3dvolume_hierarchical_M_Mlayerone(data_pbs, generator_module=None): ''' Reload 3D volume runs from PBS and plot them ''' #### SETUP # savefigs = True savedata = False # warning, huge file created... plots_pcolors = False plots_singleaxe = False plots_multipleaxes = True plots_multipleaxes_emfits = True load_fit_mixture_model = True # caching_emfit_filename = None caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_emfit_newshapes.pickle') plt.rcParams['font.size'] = 16 # #### /SETUP dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) print "Order parameters: ", generator_module.dict_parameters_range.keys() results_precision_constant_M_Mlower = np.squeeze(utils.nanmean(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1)) results_precision_constant_M_Mlower_std = np.squeeze(utils.nanstd(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1)) results_responses = np.squeeze(data_pbs.dict_arrays['result_responses']['results']) results_targets = np.squeeze(data_pbs.dict_arrays['result_targets']['results']) results_nontargets = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results']) # results_emfits_M_T = np.squeeze(data_pbs.dict_arrays['results_emfits_M_T']['results']) M_space = data_pbs.loaded_data['parameters_uniques']['M'] M_layer_one_space = data_pbs.loaded_data['parameters_uniques']['M_layer_one'] ratio_MMlower_space = M_space/generator_module.filtering_function_parameters['target_M_total'] filtering_indices = (np.arange(M_space.size), np.arange(-M_layer_one_space.size, 0)[::-1]) T = results_precision_constant_M_Mlower.shape[-1] T_space = np.arange(T) N = results_nontargets.shape[-2] num_repetitions = data_pbs.loaded_data['args_list'][0]['num_repetitions'] # Fix after @3625585, now the shape are: # results_responses, results_targets: M_space.size, M_layer_one_space.size, T, wrong num_repet, N # results_nontargets: M_space.size, M_layer_one_space.size, T, wrong num_repet, N, T-1 if data_pbs.loaded_data['nb_datasets_per_parameters'] > 1: num_repetitions = data_pbs.loaded_data['nb_datasets_per_parameters'] # Filter and reshape results_responses = results_responses[:, :, :, :num_repetitions, :] results_responses.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N) results_targets = results_targets[:, :, :, :num_repetitions, :] results_targets.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N) results_nontargets = results_nontargets[:, :, :, :num_repetitions, :, :] results_nontargets.shape = (M_space.size, M_layer_one_space.size, T, num_repetitions*N, T-1) print M_space print M_layer_one_space print results_precision_constant_M_Mlower.shape # print results_precision_constant_M_Mlower results_precision_filtered = results_precision_constant_M_Mlower[filtering_indices] del results_precision_constant_M_Mlower results_precision_filtered_std = results_precision_constant_M_Mlower_std[filtering_indices] del results_precision_constant_M_Mlower_std results_responses_filtered = results_responses[filtering_indices] del results_responses results_targets_filtered = results_targets[filtering_indices] del results_targets results_nontargets_filtered = results_nontargets[filtering_indices] del results_nontargets # results_emfits_M_T_filtered = results_emfits_M_T[filtering_indices] # del results_emfits_M_T results_precision_filtered_smoothed = np.apply_along_axis(smooth, 0, results_precision_filtered, *(10, 'bartlett')) if load_fit_mixture_model: # Fit the mixture model on the samples if caching_emfit_filename is not None: if os.path.exists(caching_emfit_filename): # Got file, open it and try to use its contents try: with open(caching_emfit_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) result_emfits_filtered = cached_data['result_emfits_filtered'] results_responses_sha1_loaded = cached_data.get('results_responses_sha1', '') # Check that the sha1 is the same, if not recompute! if results_responses_sha1_loaded == hashlib.sha1(results_responses_filtered).hexdigest(): print "Loading from cache file %s" % caching_emfit_filename load_fit_mixture_model = False else: print "Tried loading from cache file %s, but data changed, recomputing..." % caching_emfit_filename load_fit_mixture_model = True except IOError: print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits" load_fit_mixture_model = False if load_fit_mixture_model: result_emfits_filtered = np.nan*np.empty((ratio_MMlower_space.size, T, 5)) # Fit EM model print "fitting EM model" for ratio_MMlower_i, ratio_MMlower in enumerate(ratio_MMlower_space): for T_i in T_space: if np.any(~np.isnan(results_responses_filtered[ratio_MMlower_i, T_i])): print "ratio MM, T:", ratio_MMlower, T_i+1 curr_em_fits = em_circularmixture_allitems_uniquekappa.fit(results_responses_filtered[ratio_MMlower_i, T_i], results_targets_filtered[ratio_MMlower_i, T_i], results_nontargets_filtered[ratio_MMlower_i, T_i, :, :T_i]) curr_em_fits['mixt_nontargets_sum'] = np.sum(curr_em_fits['mixt_nontargets']) result_emfits_filtered[ratio_MMlower_i, T_i] = [curr_em_fits[key] for key in ('kappa', 'mixt_target', 'mixt_nontargets_sum', 'mixt_random', 'train_LL')] # Save everything to a file, for faster later plotting if caching_emfit_filename is not None: try: with open(caching_emfit_filename, 'w') as filecache_out: results_responses_sha1 = hashlib.sha1(results_responses_filtered).hexdigest() data_emfit = dict(result_emfits_filtered=result_emfits_filtered, results_responses_sha1=results_responses_sha1) pickle.dump(data_emfit, filecache_out, protocol=2) print "cache file %s written" % caching_emfit_filename except IOError: print "Error writing out to caching file ", caching_emfit_filename if plots_multipleaxes: # Plot precisions with standard deviation around f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) # all_lines_bis = [] for i, max_ind in enumerate(np.argmax(results_precision_filtered, axis=0)): utils.plot_mean_std_area(ratio_MMlower_space, results_precision_filtered[:, i], results_precision_filtered_std[:, i], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color()) # curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) axes[i].set_ylim((np.min(results_precision_filtered[:, i]), results_precision_filtered[max_ind, i]*1.1)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines_bis.extend(curr_lines) f.subplots_adjust(right=0.75) # plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5)) if savefigs: dataio.save_current_figure('results_subplots_1dnorm_{label}_global_{unique_id}.pdf') if plots_multipleaxes_emfits: f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) all_lines_bis = [] for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)): # Plot Target mixture utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 1:4], 0*result_emfits_filtered[:, i, 1:4], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color()) # curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) # axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1)) axes[i].set_ylim((0.0, 1.05)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines_bis.extend(curr_lines) if savefigs: dataio.save_current_figure('results_subplots_emtarget_{label}_global_{unique_id}.pdf') f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)): # Plot kappa mixture utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 0], 0*result_emfits_filtered[:, i, 0], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color()) # curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) # axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1)) # axes[i].set_ylim((0.0, 1.0)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines_bis.extend(curr_lines) # f.subplots_adjust(right=0.75) # plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5)) if savefigs: dataio.save_current_figure('results_subplots_emkappa_{label}_global_{unique_id}.pdf') variables_to_save = [] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='hierarchicalrandomnetwork_characterisation') plt.show() return locals()
def plots_specific_stimuli_hierarchical(data_pbs, generator_module=None): ''' Reload and plot behaviour of mixed population code on specific Stimuli of 3 items. ''' #### SETUP # savefigs = True savedata = True plot_per_min_dist_all = False specific_plots_paper = False plots_emfit_allitems = False plot_min_distance_effect = True should_fit_allitems_model = True # caching_emfit_filename = None caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfitallitems_uniquekappa.pickle') colormap = None # or 'cubehelix' plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", generator_module.dict_parameters_range.keys() result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1) result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1) result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1) result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1) result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1) result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1) result_responses_all = np.squeeze(data_pbs.dict_arrays['result_responses']['results']) result_target_all = np.squeeze(data_pbs.dict_arrays['result_target']['results']) result_nontargets_all = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results']) all_args = data_pbs.loaded_data['args_list'] nb_repetitions = np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']).shape[-1] print nb_repetitions nb_repetitions = result_responses_all.shape[-1] print nb_repetitions K = result_nontargets_all.shape[-2] N = result_responses_all.shape[-2] enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance'] sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] MMlower_valid_space = data_pbs.loaded_data['datasets_list'][0]['MMlower_valid_space'] ratio_space = MMlower_valid_space[:, 0]/float(np.sum(MMlower_valid_space[0])) print enforce_min_distance_space print sigmax_space print MMlower_valid_space print result_all_precisions_mean.shape, result_em_fits_mean.shape dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) # Relaod cached emfitallitems if caching_emfit_filename is not None: if os.path.exists(caching_emfit_filename): # Got file, open it and try to use its contents try: with open(caching_emfit_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) result_emfitallitems = cached_data['result_emfitallitems'] should_fit_allitems_model = False except IOError: print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits" if plot_per_min_dist_all: # Do one plot per min distance. for min_dist_i, min_dist in enumerate(enforce_min_distance_space): # Show log precision utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist) if savefigs: dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Show log precision utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True) if savefigs: dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot estimated model precision (kappa) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio layer two', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False) if savefigs: dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot estimated Target, nontarget and random mixture components, in multiple subplots _, axes = plt.subplots(1, 3, figsize=(18, 6)) plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5) if savefigs: dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot Log-likelihood of Mixture model, sanity check utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False) if savefigs: dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) if specific_plots_paper: # We need to choose 3 levels of min_distances target_sigmax = 0.25 target_mindist_low = 0.09 target_mindist_medium = 0.36 target_mindist_high = 1.5 sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax)) min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low)) min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium)) min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high)) ## Do for each distance # for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]: for min_dist_i in xrange(enforce_min_distance_space.size): # Plot precision if False: utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall') # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) plt.ylim([0, np.max(result_all_precisions_mean[min_dist_i, sigmax_level_i] + result_all_precisions_std[min_dist_i, sigmax_level_i])]) if savefigs: dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot kappa fitted ax_handle = utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa') # Add distance between items in kappa units dist_items_kappa = utils.stddev_to_kappa(enforce_min_distance_space[min_dist_i]) ax_handle.plot(ratio_space, dist_items_kappa*np.ones(ratio_space.size), 'k--', linewidth=3) plt.ylim([-0.1, np.max((np.max(result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0] + result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]), 1.1*dist_items_kappa))]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) if savefigs: dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot kappa-stddev fitted. Easier to visualize ax_handle = utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev') # Add distance between items in std dev units dist_items_std = (enforce_min_distance_space[min_dist_i]) ax_handle.plot(ratio_space, dist_items_std*np.ones(ratio_space.size), 'k--', linewidth=3) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) plt.ylim([0, 1.1*np.max((np.max(result_em_kappastddev_mean[min_dist_i, sigmax_level_i] + result_em_kappastddev_std[min_dist_i, sigmax_level_i]), dist_items_std))]) if savefigs: dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if False: # Plot LLH utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit') # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) if savefigs: dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot mixture parameters, std utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T) plt.ylim([0.0, 1.1]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) # plt.legend("Target", "Non-target", "Random") if savefigs: dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Mixture parameters, SEM utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions)) plt.ylim([0.0, 1.1]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) # plt.legend("Target", "Non-target", "Random") if savefigs: dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if plots_emfit_allitems: # We need to choose 3 levels of min_distances target_sigmax = 0.25 target_mindist_low = 0.15 target_mindist_medium = 0.36 target_mindist_high = 1.5 sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax)) min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low)) min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium)) min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high)) min_dist_i_plotting_space = np.array([min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]) if should_fit_allitems_model: # kappa, mixt_target, mixt_nontargets (K), mixt_random, LL, bic # result_emfitallitems = np.empty((min_dist_i_plotting_space.size, ratio_space.size, 2*K+5))*np.nan result_emfitallitems = np.empty((enforce_min_distance_space.size, ratio_space.size, K+5))*np.nan ## Do for each distance # for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space): for min_dist_i in xrange(enforce_min_distance_space.size): # Fit the mixture model for ratio_i, ratio in enumerate(ratio_space): print "Refitting EM all items. Ratio:", ratio, "Dist:", enforce_min_distance_space[min_dist_i] em_fit = em_circularmixture_allitems_uniquekappa.fit( result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K))) result_emfitallitems[min_dist_i, ratio_i] = [em_fit['kappa'], em_fit['mixt_target']] + em_fit['mixt_nontargets'].tolist() + [em_fit[key] for key in ('mixt_random', 'train_LL', 'bic')] # Save everything to a file, for faster later plotting if caching_emfit_filename is not None: try: with open(caching_emfit_filename, 'w') as filecache_out: data_em = dict(result_emfitallitems=result_emfitallitems) pickle.dump(data_em, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_emfit_filename ## Plots now, for each distance! # for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space): for min_dist_i in xrange(enforce_min_distance_space.size): # Plot now _, ax = plt.subplots() ax.plot(ratio_space, result_emfitallitems[min_dist_i, :, 1:5], linewidth=3) plt.ylim([0.0, 1.1]) plt.legend(['Target', 'Nontarget 1', 'Nontarget 2', 'Random'], loc='upper left') if savefigs: dataio.save_current_figure('mindist%.2f_emprobsfullitems_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if plot_min_distance_effect: conj_receptive_field_size = 2.*np.pi/((all_args[0]['M']*ratio_space)**0.5) target_vs_nontargets_mindist_ratio = result_emfitallitems[..., 1]/np.sum(result_emfitallitems[..., 1:4], axis=-1) nontargetsmean_vs_targnontarg_mindist_ratio = np.mean(result_emfitallitems[..., 2:4]/np.sum(result_emfitallitems[..., 1:4], axis=-1)[..., np.newaxis], axis=-1) for ratio_conj_i, ratio_conj in enumerate(ratio_space): # Do one plot per ratio, putting the receptive field size on each f, ax = plt.subplots() ax.plot(enforce_min_distance_space[1:], target_vs_nontargets_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='target mixture') ax.plot(enforce_min_distance_space[1:], nontargetsmean_vs_targnontarg_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='non-target mixture') # ax.plot(enforce_min_distance_space[1:], result_emfitallitems[1:, ratio_conj_i, 1:5], linewidth=3) ax.axvline(x=conj_receptive_field_size[ratio_conj_i]/2., color='k', linestyle='--', linewidth=2) ax.axvline(x=conj_receptive_field_size[ratio_conj_i]*2., color='r', linestyle='--', linewidth=2) plt.legend(loc='upper left') plt.grid() # ax.set_xlabel('Stimuli separation') # ax.set_ylabel('Ratio Target to Non-targets') plt.axis('tight') ax.set_ylim([0.0, 1.0]) ax.set_xlim([enforce_min_distance_space[1:].min(), enforce_min_distance_space[1:].max()]) if savefigs: dataio.save_current_figure('ratio%.2f_mindistpred_ratiotargetnontarget_{label}_{unique_id}.pdf' % ratio_conj) variables_to_save = ['nb_repetitions'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli') plt.show() return locals()
def plots_3dvolume_hierarchical_M_Mlayerone(data_pbs, generator_module=None): ''' Reload 3D volume runs from PBS and plot them ''' #### SETUP # savefigs = True savedata = False plots_pcolors = False plots_singleaxe = False plots_multipleaxes = True plots_multipleaxes_emfits = True load_fit_mixture_model = True # caching_emfit_filename = None caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_emfit.pickle') plt.rcParams['font.size'] = 16 # #### /SETUP dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) print "Order parameters: ", generator_module.dict_parameters_range.keys() results_precision_constant_M_Mlower = np.squeeze(utils.nanmean(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1)) results_precision_constant_M_Mlower_std = np.squeeze(utils.nanstd(data_pbs.dict_arrays['results_precision_M_T']['results'], axis=-1)) results_responses = np.squeeze(data_pbs.dict_arrays['result_responses']['results']) results_targets = np.squeeze(data_pbs.dict_arrays['result_targets']['results']) results_nontargets = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results']) results_emfits_M_T = np.squeeze(data_pbs.dict_arrays['results_emfits_M_T']['results']) M_space = data_pbs.loaded_data['parameters_uniques']['M'] M_layer_one_space = data_pbs.loaded_data['parameters_uniques']['M_layer_one'] ratio_MMlower_space = M_space/generator_module.filtering_function_parameters['target_M_total'] filtering_indices = (np.arange(M_space.size), np.arange(-M_layer_one_space.size, 0)[::-1]) T = results_precision_constant_M_Mlower.shape[-1] T_space = np.arange(T) print M_space print M_layer_one_space print results_precision_constant_M_Mlower.shape # print results_precision_constant_M_Mlower T = results_precision_constant_M_Mlower.shape[-1] results_precision_filtered = results_precision_constant_M_Mlower[filtering_indices] results_precision_filtered_std = results_precision_constant_M_Mlower_std[filtering_indices] results_responses_filtered = results_responses[filtering_indices] results_targets_filtered = results_targets[filtering_indices] results_nontargets_filtered = results_nontargets[filtering_indices] results_emfits_M_T_filtered = results_emfits_M_T[filtering_indices] results_precision_filtered_smoothed = np.apply_along_axis(smooth, 0, results_precision_filtered, *(10, 'bartlett')) if load_fit_mixture_model: # Fit the mixture model on the samples if caching_emfit_filename is not None: if os.path.exists(caching_emfit_filename): # Got file, open it and try to use its contents try: with open(caching_emfit_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) result_emfits_filtered = cached_data['result_emfits_filtered'] print "Loading from cache file %s" % caching_emfit_filename load_fit_mixture_model = False except IOError: print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits" load_fit_mixture_model = False if load_fit_mixture_model: result_emfits_filtered = np.nan*np.empty((ratio_MMlower_space.size, T, 5)) # Fit EM model print "fitting EM model" for ratio_MMlower_i, ratio_MMlower in enumerate(ratio_MMlower_space): for T_i in T_space: if np.any(~np.isnan(results_responses_filtered[ratio_MMlower_i, T_i])): print "ratio MM, T:", ratio_MMlower, T_i+1 curr_em_fits = em_circularmixture_allitems_uniquekappa.fit(results_responses_filtered[ratio_MMlower_i, T_i], results_targets_filtered[ratio_MMlower_i, T_i], results_nontargets_filtered[ratio_MMlower_i, T_i, :, :T_i]) curr_em_fits['mixt_nontargets_sum'] = np.sum(curr_em_fits['mixt_nontargets']) result_emfits_filtered[ratio_MMlower_i, T_i] = [curr_em_fits[key] for key in ('kappa', 'mixt_target', 'mixt_nontargets_sum', 'mixt_random', 'train_LL')] # Save everything to a file, for faster later plotting if caching_emfit_filename is not None: try: with open(caching_emfit_filename, 'w') as filecache_out: data_emfit = dict(result_emfits_filtered=result_emfits_filtered) pickle.dump(data_emfit, filecache_out, protocol=2) print "cache file %s written" % caching_emfit_filename except IOError: print "Error writing out to caching file ", caching_emfit_filename if plots_pcolors: utils.pcolor_2d_data(results_precision_filtered, log_scale=True, x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10) plt.plot(np.argmax(results_precision_filtered, axis=0), np.arange(results_precision_filtered.shape[-1]), 'ko', markersize=10) if savefigs: dataio.save_current_figure('results_2dlog_{label}_global_{unique_id}.pdf') utils.pcolor_2d_data(results_precision_filtered/np.max(results_precision_filtered, axis=0), x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10) plt.plot(np.argmax(results_precision_filtered, axis=0), np.arange(results_precision_filtered.shape[-1]), 'ko', markersize=10) if savefigs: dataio.save_current_figure('results_2dnorm_{label}_global_{unique_id}.pdf') utils.pcolor_2d_data(results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0), x=ratio_MMlower_space, y=np.arange(1, T+1), xlabel="$\\frac{M}{M+M_{layer one}}$", ylabel='$T$', ticks_interpolate=10) plt.plot(np.argmax(results_precision_filtered_smoothed, axis=0), np.arange(results_precision_filtered_smoothed.shape[-1]), 'ko', markersize=10) if savefigs: dataio.save_current_figure('results_2dsmoothnorm_{label}_global_{unique_id}.pdf') if plots_singleaxe: plt.figure() plt.plot(ratio_MMlower_space, results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0), linewidth=2) plt.plot(ratio_MMlower_space[np.argmax(results_precision_filtered_smoothed, axis=0)], np.ones(results_precision_filtered_smoothed.shape[-1]), 'ro', markersize=10) plt.grid() plt.ylim((0., 1.1)) plt.subplots_adjust(right=0.8) plt.legend(['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='center right', bbox_to_anchor=(1.3, 0.5)) plt.xticks(np.linspace(0, 1.0, 5)) if savefigs: dataio.save_current_figure('results_1dsmoothnormsame_{label}_global_{unique_id}.pdf') plt.figure() moved_results_precision_filtered_smoothed = 1.2*np.arange(results_precision_filtered_smoothed.shape[-1]) + results_precision_filtered_smoothed/np.max(results_precision_filtered_smoothed, axis=0) all_lines = [] for i, max_i in enumerate(np.argmax(results_precision_filtered_smoothed, axis=0)): curr_lines = plt.plot(ratio_MMlower_space, moved_results_precision_filtered_smoothed[:, i], linewidth=2) plt.plot(ratio_MMlower_space[max_i], moved_results_precision_filtered_smoothed[max_i, i], 'o', markersize=10, color=curr_lines[0].get_color()) all_lines.extend(curr_lines) plt.plot(np.linspace(0.0, 1.0, 100), np.outer(np.ones(100), 1.2*np.arange(1, results_precision_filtered_smoothed.shape[-1])), 'k:') plt.grid() plt.legend(all_lines, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='best') plt.ylim((0., moved_results_precision_filtered_smoothed.max()*1.05)) plt.yticks([]) plt.xticks(np.linspace(0, 1.0, 5)) if savefigs: dataio.save_current_figure('results_1dsmoothnorm_{label}_global_{unique_id}.pdf') if plots_multipleaxes: # Plot smooth precisions, all T on multiple subplots. # all_lines = [] f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) for i, max_ind in enumerate(np.argmax(results_precision_filtered_smoothed, axis=0)): curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered_smoothed[:, i], linewidth=2) # , color=all_lines[i].get_color()) axes[i].plot(ratio_MMlower_space[max_ind], results_precision_filtered_smoothed[max_ind, i], 'o', markersize=10, color=curr_lines[0].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) axes[i].set_ylim((np.min(results_precision_filtered_smoothed[:, i]), results_precision_filtered_smoothed[max_ind, i]*1.1)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines.extend(curr_lines) f.subplots_adjust(right=0.75) # plt.figlegend(all_lines, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5)) # f.tight_layout() if savefigs: dataio.save_current_figure('results_subplots_1dsmoothnorm_{label}_global_{unique_id}.pdf') # Plot precisions with standard deviation around f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) # all_lines_bis = [] for i, max_ind in enumerate(np.argmax(results_precision_filtered, axis=0)): utils.plot_mean_std_area(ratio_MMlower_space, results_precision_filtered[:, i], results_precision_filtered_std[:, i], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color()) # curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) axes[i].set_ylim((np.min(results_precision_filtered[:, i]), results_precision_filtered[max_ind, i]*1.1)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines_bis.extend(curr_lines) f.subplots_adjust(right=0.75) # plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5)) if savefigs: dataio.save_current_figure('results_subplots_1dnorm_{label}_global_{unique_id}.pdf') if plots_multipleaxes_emfits: f, axes = plt.subplots(nrows=T, ncols=1, sharex=True, figsize=(10, 12)) all_lines_bis = [] for i, max_ind in enumerate(np.nanargmax(result_emfits_filtered[..., 0], axis=0)): utils.plot_mean_std_area(ratio_MMlower_space, result_emfits_filtered[:, i, 0], 0*result_emfits_filtered[:, i, 0], ax_handle=axes[i], linewidth=2) #, color=all_lines[i].get_color()) # curr_lines = axes[i].plot(ratio_MMlower_space, results_precision_filtered[:, i], linewidth=2, color=all_lines[i].get_color()) axes[i].grid() axes[i].set_xticks(np.linspace(0., 1.0, 5)) axes[i].set_xlim((0.0, 1.0)) # axes[i].set_yticks([]) # axes[i].set_ylim((np.min(result_emfits_filtered[:, i, 0]), result_emfits_filtered[max_ind, i, 0]*1.1)) axes[i].locator_params(axis='y', tight=True, nbins=4) # all_lines_bis.extend(curr_lines) f.subplots_adjust(right=0.75) # plt.figlegend(all_lines_bis, ['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='right', bbox_to_anchor=(1.0, 0.5)) if savefigs: dataio.save_current_figure('results_subplots_emkappa_{label}_global_{unique_id}.pdf') variables_to_save = [] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='hierarchicalrandomnetwork_characterisation') plt.show() return locals()
def fit_mixture_model(self): # Initialize empty arrays self.dataset['em_fits'] = dict( kappa=np.empty(self.dataset['probe'].size), mixt_target=np.empty(self.dataset['probe'].size), mixt_nontarget=np.empty(self.dataset['probe'].size), mixt_random=np.empty(self.dataset['probe'].size), resp_target=np.empty(self.dataset['probe'].size), resp_nontarget=np.empty(self.dataset['probe'].size), resp_random=np.empty(self.dataset['probe'].size), train_LL=np.empty(self.dataset['probe'].size), test_LL=np.empty(self.dataset['probe'].size)) for key in self.dataset['em_fits']: self.dataset['em_fits'][key].fill(np.nan) self.dataset['target'] = np.empty(self.dataset['probe'].size) self.dataset['em_fits_subjects_nitems'] = dict() for subject in np.unique(self.dataset['subject']): self.dataset['em_fits_subjects_nitems'][subject] = dict() self.dataset['em_fits_nitems'] = dict(mean=dict(), std=dict(), values=dict()) # Compute mixture model fits per n_items and per subject for n_items in np.unique(self.dataset['n_items']): for subject in np.unique(self.dataset['subject']): ids_filtered = (self.dataset['subject']==subject).flatten() & (self.dataset['n_items'] == n_items).flatten() print "Fit mixture model, %d items, subject %d, %d datapoints" % (subject, n_items, np.sum(ids_filtered)) self.dataset['target'][ids_filtered] = self.dataset['item_angle'][ids_filtered, 0] # params_fit = em_circularmixture.fit(self.dataset['response'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 1:]) params_fit = em_circularmixture_allitems_uniquekappa.fit(self.dataset['response'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 1:]) params_fit['mixt_nontargets_sum'] = np.sum(params_fit['mixt_nontargets']) # print self.dataset['response'][ids_filtered, 0].shape, self.dataset['item_angle'][ids_filtered, 0].shape, self.dataset['item_angle'][ids_filtered, 1:].shape # cross_valid_outputs = em_circularmixture.cross_validation_kfold(self.dataset['response'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 1:], K=10, shuffle=True, debug=False) # params_fit = cross_valid_outputs['best_fit'] # resp = em_circularmixture.compute_responsibilities(self.dataset['response'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 1:], params_fit) resp = em_circularmixture_allitems_uniquekappa.compute_responsibilities(self.dataset['response'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 0], self.dataset['item_angle'][ids_filtered, 1:], params_fit) self.dataset['em_fits']['kappa'][ids_filtered] = params_fit['kappa'] self.dataset['em_fits']['mixt_target'][ids_filtered] = params_fit['mixt_target'] # self.dataset['em_fits']['mixt_nontarget'][ids_filtered] = params_fit['mixt_nontargets'] self.dataset['em_fits']['mixt_nontarget'][ids_filtered] = params_fit['mixt_nontargets_sum'] self.dataset['em_fits']['mixt_random'][ids_filtered] = params_fit['mixt_random'] self.dataset['em_fits']['resp_target'][ids_filtered] = resp['target'] self.dataset['em_fits']['resp_nontarget'][ids_filtered] = np.sum(resp['nontargets'], axis=1) self.dataset['em_fits']['resp_random'][ids_filtered] = resp['random'] self.dataset['em_fits']['train_LL'][ids_filtered] = params_fit['train_LL'] # self.dataset['em_fits']['test_LL'][ids_filtered] = cross_valid_outputs['best_test_LL'] self.dataset['em_fits_subjects_nitems'][subject][n_items] = params_fit ## Now compute mean/std em_fits per n_items self.dataset['em_fits_nitems']['mean'][n_items] = dict() self.dataset['em_fits_nitems']['std'][n_items] = dict() self.dataset['em_fits_nitems']['values'][n_items] = dict() # Need to extract the values for a subject/nitems pair, for all keys of em_fits. Annoying dictionary indexing needed emfits_keys = params_fit.keys() for key in emfits_keys: values_allsubjects = [self.dataset['em_fits_subjects_nitems'][subject][n_items][key] for subject in np.unique(self.dataset['subject'])] self.dataset['em_fits_nitems']['mean'][n_items][key] = np.mean(values_allsubjects) self.dataset['em_fits_nitems']['std'][n_items][key] = np.std(values_allsubjects) self.dataset['em_fits_nitems']['values'][n_items][key] = values_allsubjects ## Construct array versions of the em_fits_nitems mixture proportions, for convenience self.construct_arrays_em_fits()
def plots_specific_stimuli_mixed(data_pbs, generator_module=None): ''' Reload and plot behaviour of mixed population code on specific Stimuli of 3 items. ''' #### SETUP # savefigs = True savedata = True plot_per_min_dist_all = False specific_plots_paper = False plots_emfit_allitems = False plot_min_distance_effect = True compute_bootstraps = False should_fit_allitems_model = True # caching_emfit_filename = None mixturemodel_to_use = 'allitems_uniquekappa' # caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfitallitems_uniquekappa.pickle') # mixturemodel_to_use = 'allitems_fikappa' caching_emfit_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_emfit%s.pickle' % mixturemodel_to_use) compute_fisher_info_perratioconj = True caching_fisherinfo_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_fisherinfo.pickle') colormap = None # or 'cubehelix' plt.rcParams['font.size'] = 16 # #### /SETUP print "Order parameters: ", generator_module.dict_parameters_range.keys() all_args = data_pbs.loaded_data['args_list'] result_all_precisions_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1) result_all_precisions_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_all_precisions']['results']), axis=-1) result_em_fits_mean = utils.nanmean(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1) result_em_fits_std = utils.nanstd(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results']), axis=-1) result_em_kappastddev_mean = utils.nanmean(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1) result_em_kappastddev_std = utils.nanstd(utils.kappa_to_stddev(np.squeeze(data_pbs.dict_arrays['result_em_fits']['results'])[..., 0, :]), axis=-1) result_responses_all = np.squeeze(data_pbs.dict_arrays['result_responses']['results']) result_target_all = np.squeeze(data_pbs.dict_arrays['result_target']['results']) result_nontargets_all = np.squeeze(data_pbs.dict_arrays['result_nontargets']['results']) nb_repetitions = result_responses_all.shape[-1] K = result_nontargets_all.shape[-2] N = result_responses_all.shape[-2] enforce_min_distance_space = data_pbs.loaded_data['parameters_uniques']['enforce_min_distance'] sigmax_space = data_pbs.loaded_data['parameters_uniques']['sigmax'] ratio_space = data_pbs.loaded_data['datasets_list'][0]['ratio_space'] print enforce_min_distance_space print sigmax_space print ratio_space print result_all_precisions_mean.shape, result_em_fits_mean.shape print result_responses_all.shape dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) # Reload cached emfitallitems if caching_emfit_filename is not None: if os.path.exists(caching_emfit_filename): # Got file, open it and try to use its contents try: with open(caching_emfit_filename, 'r') as file_in: # Load and assign values print "Reloader EM fits from cache", caching_emfit_filename cached_data = pickle.load(file_in) result_emfitallitems = cached_data['result_emfitallitems'] mixturemodel_used = cached_data.get('mixturemodel_used', '') if mixturemodel_used != mixturemodel_to_use: print "warning, reloaded model used a different mixture model class" should_fit_allitems_model = False except IOError: print "Error while loading ", caching_emfit_filename, "falling back to computing the EM fits" # Load the Fisher Info from cache if exists. If not, compute it. if caching_fisherinfo_filename is not None: if os.path.exists(caching_fisherinfo_filename): # Got file, open it and try to use its contents try: with open(caching_fisherinfo_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) result_fisherinfo_mindist_sigmax_ratio = cached_data['result_fisherinfo_mindist_sigmax_ratio'] compute_fisher_info_perratioconj = False except IOError: print "Error while loading ", caching_fisherinfo_filename, "falling back to computing the Fisher Info" if compute_fisher_info_perratioconj: # We did not save the Fisher info, but need it if we want to fit the mixture model with fixed kappa. So recompute them using the args_dicts result_fisherinfo_mindist_sigmax_ratio = np.empty((enforce_min_distance_space.size, sigmax_space.size, ratio_space.size)) # Invert the all_args_i -> min_dist, sigmax indexing parameters_indirections = data_pbs.loaded_data['parameters_dataset_index'] # min_dist_i, sigmax_level_i, ratio_i for min_dist_i, min_dist in enumerate(enforce_min_distance_space): for sigmax_i, sigmax in enumerate(sigmax_space): # Get index of first dataset with the current (min_dist, sigmax) (no need for the others, I think) arg_index = parameters_indirections[(min_dist, sigmax)][0] # Now using this dataset, reconstruct a RandomFactorialNetwork and compute the fisher info curr_args = all_args[arg_index] for ratio_conj_i, ratio_conj in enumerate(ratio_space): # Update param curr_args['ratio_conj'] = ratio_conj # curr_args['stimuli_generation'] = 'specific_stimuli' (_, _, _, sampler) = launchers.init_everything(curr_args) # Theo Fisher info result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_i, ratio_conj_i] = sampler.estimate_fisher_info_theocov() print "Min dist: %.2f, Sigmax: %.2f, Ratio: %.2f: %.3f" % (min_dist, sigmax, ratio_conj, result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_i, ratio_conj_i]) # Save everything to a file, for faster later plotting if caching_fisherinfo_filename is not None: try: with open(caching_fisherinfo_filename, 'w') as filecache_out: data_cache = dict(result_fisherinfo_mindist_sigmax_ratio=result_fisherinfo_mindist_sigmax_ratio) pickle.dump(data_cache, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_fisherinfo_filename if plot_per_min_dist_all: # Do one plot per min distance. for min_dist_i, min_dist in enumerate(enforce_min_distance_space): # Show log precision utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist) if savefigs: dataio.save_current_figure('precision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Show log precision utils.pcolor_2d_data(result_all_precisions_mean[min_dist_i].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Precision, min_dist=%.3f' % min_dist, log_scale=True) if savefigs: dataio.save_current_figure('logprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot estimated model precision utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 0].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM precision, min_dist=%.3f' % min_dist, log_scale=False) if savefigs: dataio.save_current_figure('logemprecision_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot estimated Target, nontarget and random mixture components, in multiple subplots _, axes = plt.subplots(1, 3, figsize=(18, 6)) plt.subplots_adjust(left=0.05, right=0.97, wspace = 0.3, bottom=0.15) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Target, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[0], ticks_interpolate=5) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 2].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Nontarget, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[1], ticks_interpolate=5) utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., 3].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='Random, min_dist=%.3f' % min_dist, log_scale=False, ax_handle=axes[2], ticks_interpolate=5) if savefigs: dataio.save_current_figure('em_mixtureprobs_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) # Plot Log-likelihood of Mixture model, sanity check utils.pcolor_2d_data(result_em_fits_mean[min_dist_i, ..., -1].T, x=ratio_space, y=sigmax_space, xlabel='ratio', ylabel='sigma_x', title='EM loglik, min_dist=%.3f' % min_dist, log_scale=False) if savefigs: dataio.save_current_figure('em_loglik_permindist_mindist%.2f_ratiosigmax_{label}_{unique_id}.pdf' % min_dist) if specific_plots_paper: # We need to choose 3 levels of min_distances target_sigmax = 0.25 target_mindist_low = 0.15 target_mindist_medium = 0.36 target_mindist_high = 1.5 sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax)) min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low)) min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium)) min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high)) ## Do for each distance # for min_dist_i in [min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]: for min_dist_i in xrange(enforce_min_distance_space.size): # Plot precision if False: utils.plot_mean_std_area(ratio_space, result_all_precisions_mean[min_dist_i, sigmax_level_i], result_all_precisions_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Precision of recall') # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) plt.ylim([0, np.max(result_all_precisions_mean[min_dist_i, sigmax_level_i] + result_all_precisions_std[min_dist_i, sigmax_level_i])]) if savefigs: dataio.save_current_figure('mindist%.2f_precisionrecall_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot kappa fitted ax_handle = utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0], result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa') # Add distance between items in kappa units dist_items_kappa = utils.stddev_to_kappa(enforce_min_distance_space[min_dist_i]) ax_handle.plot(ratio_space, dist_items_kappa*np.ones(ratio_space.size), 'k--', linewidth=3) plt.ylim([-0.1, np.max((np.max(result_em_fits_mean[min_dist_i, sigmax_level_i, :, 0] + result_em_fits_std[min_dist_i, sigmax_level_i, :, 0]), 1.1*dist_items_kappa))]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) if savefigs: dataio.save_current_figure('mindist%.2f_emkappa_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot kappa-stddev fitted. Easier to visualize ax_handle = utils.plot_mean_std_area(ratio_space, result_em_kappastddev_mean[min_dist_i, sigmax_level_i], result_em_kappastddev_std[min_dist_i, sigmax_level_i]) #, xlabel='Ratio conjunctivity', ylabel='Fitted kappa_stddev') # Add distance between items in std dev units dist_items_std = (enforce_min_distance_space[min_dist_i]) ax_handle.plot(ratio_space, dist_items_std*np.ones(ratio_space.size), 'k--', linewidth=3) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) plt.ylim([0, 1.1*np.max((np.max(result_em_kappastddev_mean[min_dist_i, sigmax_level_i] + result_em_kappastddev_std[min_dist_i, sigmax_level_i]), dist_items_std))]) if savefigs: dataio.save_current_figure('mindist%.2f_emkappastddev_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if False: # Plot LLH utils.plot_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, -1], result_em_fits_std[min_dist_i, sigmax_level_i, :, -1]) #, xlabel='Ratio conjunctivity', ylabel='Loglikelihood of Mixture model fit') # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) if savefigs: dataio.save_current_figure('mindist%.2f_emllh_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Plot mixture parameters, std utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T) plt.ylim([0.0, 1.1]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) # plt.legend("Target", "Non-target", "Random") if savefigs: dataio.save_current_figure('mindist%.2f_emprobs_forpaper_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) # Mixture parameters, SEM utils.plot_multiple_mean_std_area(ratio_space, result_em_fits_mean[min_dist_i, sigmax_level_i, :, 1:4].T, result_em_fits_std[min_dist_i, sigmax_level_i, :, 1:4].T/np.sqrt(nb_repetitions)) plt.ylim([0.0, 1.1]) # plt.title('Min distance %.3f' % enforce_min_distance_space[min_dist_i]) # plt.legend("Target", "Non-target", "Random") if savefigs: dataio.save_current_figure('mindist%.2f_emprobs_forpaper_sem_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if plots_emfit_allitems: # We need to choose 3 levels of min_distances target_sigmax = 0.25 target_mindist_low = 0.15 target_mindist_medium = 0.36 target_mindist_high = 1.5 sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax)) min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low)) min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium)) min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high)) min_dist_i_plotting_space = np.array([min_dist_level_low_i, min_dist_level_medium_i, min_dist_level_high_i]) if should_fit_allitems_model: # kappa, mixt_target, mixt_nontargets (K), mixt_random, LL, bic # result_emfitallitems = np.empty((min_dist_i_plotting_space.size, ratio_space.size, 2*K+5))*np.nan result_emfitallitems = np.empty((enforce_min_distance_space.size, ratio_space.size, K+5))*np.nan ## Do for each distance # for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space): for min_dist_i in xrange(enforce_min_distance_space.size): # Fit the mixture model for ratio_i, ratio in enumerate(ratio_space): print "Refitting EM all items. Ratio:", ratio, "Dist:", enforce_min_distance_space[min_dist_i] if mixturemodel_to_use == 'allitems_uniquekappa': em_fit = em_circularmixture_allitems_uniquekappa.fit( result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K))) elif mixturemodel_to_use == 'allitems_fikappa': em_fit = em_circularmixture_allitems_kappafi.fit(result_responses_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_target_all[min_dist_i, sigmax_level_i, ratio_i].flatten(), result_nontargets_all[min_dist_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)), kappa=result_fisherinfo_mindist_sigmax_ratio[min_dist_i, sigmax_level_i, ratio_i]) else: raise ValueError("Wrong mixturemodel_to_use, %s" % mixturemodel_to_use) result_emfitallitems[min_dist_i, ratio_i] = [em_fit['kappa'], em_fit['mixt_target']] + em_fit['mixt_nontargets'].tolist() + [em_fit[key] for key in ('mixt_random', 'train_LL', 'bic')] # Save everything to a file, for faster later plotting if caching_emfit_filename is not None: try: with open(caching_emfit_filename, 'w') as filecache_out: data_em = dict(result_emfitallitems=result_emfitallitems, target_sigmax=target_sigmax) pickle.dump(data_em, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_emfit_filename ## Plots now, for each distance! # for min_dist_plotting_i, min_dist_i in enumerate(min_dist_i_plotting_space): for min_dist_i in xrange(enforce_min_distance_space.size): # Plot now _, ax = plt.subplots() ax.plot(ratio_space, result_emfitallitems[min_dist_i, :, 1:5], linewidth=3) plt.ylim([0.0, 1.1]) plt.legend(['Target', 'Nontarget 1', 'Nontarget 2', 'Random'], loc='upper left') if savefigs: dataio.save_current_figure('mindist%.2f_emprobsfullitems_{label}_{unique_id}.pdf' % enforce_min_distance_space[min_dist_i]) if plot_min_distance_effect: conj_receptive_field_size = 2.*np.pi/((all_args[0]['M']*ratio_space)**0.5) target_vs_nontargets_mindist_ratio = result_emfitallitems[..., 1]/np.sum(result_emfitallitems[..., 1:4], axis=-1) nontargetsmean_vs_targnontarg_mindist_ratio = np.mean(result_emfitallitems[..., 2:4]/np.sum(result_emfitallitems[..., 1:4], axis=-1)[..., np.newaxis], axis=-1) for ratio_conj_i, ratio_conj in enumerate(ratio_space): # Do one plot per ratio, putting the receptive field size on each f, ax = plt.subplots() ax.plot(enforce_min_distance_space[1:], target_vs_nontargets_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='target mixture') ax.plot(enforce_min_distance_space[1:], nontargetsmean_vs_targnontarg_mindist_ratio[1:, ratio_conj_i], linewidth=3, label='non-target mixture') # ax.plot(enforce_min_distance_space[1:], result_emfitallitems[1:, ratio_conj_i, 1:5], linewidth=3) ax.axvline(x=conj_receptive_field_size[ratio_conj_i]/2., color='k', linestyle='--', linewidth=2) ax.axvline(x=conj_receptive_field_size[ratio_conj_i]*2., color='r', linestyle='--', linewidth=2) plt.legend(loc='upper left') plt.grid() # ax.set_xlabel('Stimuli separation') # ax.set_ylabel('Ratio Target to Non-targets') plt.axis('tight') ax.set_ylim([0.0, 1.0]) ax.set_xlim([enforce_min_distance_space[1:].min(), enforce_min_distance_space[1:].max()]) if savefigs: dataio.save_current_figure('ratio%.2f_mindistpred_ratiotargetnontarget_{label}_{unique_id}.pdf' % ratio_conj) if compute_bootstraps: ## Bootstrap evaluation # We need to choose 3 levels of min_distances target_sigmax = 0.25 target_mindist_low = 0.15 target_mindist_medium = 0.5 target_mindist_high = 1. sigmax_level_i = np.argmin(np.abs(sigmax_space - target_sigmax)) min_dist_level_low_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_low)) min_dist_level_medium_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_medium)) min_dist_level_high_i = np.argmin(np.abs(enforce_min_distance_space - target_mindist_high)) # cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap.pickle') cache_bootstrap_fn = '/Users/loicmatthey/Dropbox/UCL/1-phd/Work/Visual_working_memory/code/git-bayesian-visual-working-memory/Experiments/specific_stimuli/specific_stimuli_corrected_mixed_sigmaxmindistance_autoset_repetitions5mult_collectall_281113_outputs/cache_bootstrap.pickle' try: with open(cache_bootstrap_fn, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) bootstrap_ecdf_bays_sigmax_T = cached_data['bootstrap_ecdf_bays_sigmax_T'] bootstrap_ecdf_allitems_sum_sigmax_T = cached_data['bootstrap_ecdf_allitems_sum_sigmax_T'] bootstrap_ecdf_allitems_all_sigmax_T = cached_data['bootstrap_ecdf_allitems_all_sigmax_T'] should_fit_bootstrap = False except IOError: print "Error while loading ", cache_bootstrap_fn ratio_i = 0 # bootstrap_allitems_nontargets_allitems_uniquekappa = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat( # result_responses_all[min_dist_level_low_i, sigmax_level_i, ratio_i].flatten(), # result_target_all[min_dist_level_low_i, sigmax_level_i, ratio_i].flatten(), # result_nontargets_all[min_dist_level_low_i, sigmax_level_i, ratio_i].transpose((0, 2, 1)).reshape((N*nb_repetitions, K)), # sumnontargets_bootstrap_ecdf=bootstrap_ecdf_allitems_sum_sigmax_T[sigmax_level_i][K]['ecdf'], # allnontargets_bootstrap_ecdf=bootstrap_ecdf_allitems_all_sigmax_T[sigmax_level_i][K]['ecdf'] # TODO FINISH HERE variables_to_save = ['nb_repetitions'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='specific_stimuli') plt.show() return locals()
def plots_misbinding_logposterior(data_pbs, generator_module=None): ''' Reload 3D volume runs from PBS and plot them ''' #### SETUP # savedata = False savefigs = True plot_logpost = False plot_error = False plot_mixtmodel = True plot_hist_responses_fisherinfo = True compute_plot_bootstrap = False compute_fisher_info_perratioconj = True # mixturemodel_to_use = 'original' mixturemodel_to_use = 'allitems' # mixturemodel_to_use = 'allitems_kappafi' caching_fisherinfo_filename = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'cache_fisherinfo.pickle') # #### /SETUP print "Order parameters: ", generator_module.dict_parameters_range.keys() result_all_log_posterior = np.squeeze(data_pbs.dict_arrays['result_all_log_posterior']['results']) result_all_thetas = np.squeeze(data_pbs.dict_arrays['result_all_thetas']['results']) ratio_space = data_pbs.loaded_data['parameters_uniques']['ratio_conj'] print ratio_space print result_all_log_posterior.shape N = result_all_thetas.shape[-1] result_prob_wrong = np.zeros((ratio_space.size, N)) result_em_fits = np.empty((ratio_space.size, 6))*np.nan all_args = data_pbs.loaded_data['args_list'] fixed_means = [-np.pi*0.6, np.pi*0.6] all_angles = np.linspace(-np.pi, np.pi, result_all_log_posterior.shape[-1]) dataio = DataIO(output_folder=generator_module.pbs_submission_infos['simul_out_dir'] + '/outputs/', label='global_' + dataset_infos['save_output_filename']) plt.rcParams['font.size'] = 18 if plot_hist_responses_fisherinfo: # From cache if caching_fisherinfo_filename is not None: if os.path.exists(caching_fisherinfo_filename): # Got file, open it and try to use its contents try: with open(caching_fisherinfo_filename, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) result_fisherinfo_ratio = cached_data['result_fisherinfo_ratio'] compute_fisher_info_perratioconj = False except IOError: print "Error while loading ", caching_fisherinfo_filename, "falling back to computing the Fisher Info" if compute_fisher_info_perratioconj: # We did not save the Fisher info, but need it if we want to fit the mixture model with fixed kappa. So recompute them using the args_dicts result_fisherinfo_ratio = np.empty(ratio_space.shape) # Invert the all_args_i -> ratio_conj direction parameters_indirections = data_pbs.loaded_data['parameters_dataset_index'] for ratio_conj_i, ratio_conj in enumerate(ratio_space): # Get index of first dataset with the current ratio_conj (no need for the others, I think) arg_index = parameters_indirections[(ratio_conj,)][0] # Now using this dataset, reconstruct a RandomFactorialNetwork and compute the fisher info curr_args = all_args[arg_index] curr_args['stimuli_generation'] = lambda T: np.linspace(-np.pi*0.6, np.pi*0.6, T) (random_network, data_gen, stat_meas, sampler) = launchers.init_everything(curr_args) # Theo Fisher info result_fisherinfo_ratio[ratio_conj_i] = sampler.estimate_fisher_info_theocov() del curr_args['stimuli_generation'] # Save everything to a file, for faster later plotting if caching_fisherinfo_filename is not None: try: with open(caching_fisherinfo_filename, 'w') as filecache_out: data_cache = dict(result_fisherinfo_ratio=result_fisherinfo_ratio) pickle.dump(data_cache, filecache_out, protocol=2) except IOError: print "Error writing out to caching file ", caching_fisherinfo_filename # Now plots. Do histograms of responses (around -pi/6 and pi/6), add Von Mises derived from Theo FI on top, and vertical lines for the correct target/nontarget angles. for ratio_conj_i, ratio_conj in enumerate(ratio_space): # Histogram ax = utils.hist_angular_data(result_all_thetas[ratio_conj_i], bins=100, title='ratio %.2f, fi %.0f' % (ratio_conj, result_fisherinfo_ratio[ratio_conj_i])) bar_heights, _, _ = utils.histogram_binspace(result_all_thetas[ratio_conj_i], bins=100, norm='density') # Add Fisher info prediction on top x = np.linspace(-np.pi, np.pi, 1000) if result_fisherinfo_ratio[ratio_conj_i] < 700: # Von Mises PDF utils.plot_vonmises_pdf(x, utils.stddev_to_kappa(1./result_fisherinfo_ratio[ratio_conj_i]**0.5), mu=fixed_means[-1], ax_handle=ax, linewidth=3, color='r', scale=np.max(bar_heights), fmt='-') else: # Switch to Gaussian instead utils.plot_normal_pdf(x, mu=fixed_means[-1], std=1./result_fisherinfo_ratio[ratio_conj_i]**0.5, ax_handle=ax, linewidth=3, color='r', scale=np.max(bar_heights), fmt='-') # ax.set_xticks([]) # ax.set_yticks([]) # Add vertical line to correct target/nontarget ax.axvline(x=fixed_means[0], color='g', linewidth=2) ax.axvline(x=fixed_means[1], color='r', linewidth=2) ax.get_figure().canvas.draw() if savefigs: # plt.tight_layout() dataio.save_current_figure('results_misbinding_histresponses_vonmisespdf_ratioconj%.2f{label}_{unique_id}.pdf' % (ratio_conj)) if plot_logpost: for ratio_conj_i, ratio_conj in enumerate(ratio_space): # ax = utils.plot_mean_std_area(all_angles, nanmean(result_all_log_posterior[ratio_conj_i], axis=0), nanstd(result_all_log_posterior[ratio_conj_i], axis=0)) # ax.set_xlim((-np.pi, np.pi)) # ax.set_xticks((-np.pi, -np.pi / 2, 0, np.pi / 2., np.pi)) # ax.set_xticklabels((r'$-\pi$', r'$-\frac{\pi}{2}$', r'$0$', r'$\frac{\pi}{2}$', r'$\pi$')) # ax.set_yticks(()) # ax.get_figure().canvas.draw() # if savefigs: # dataio.save_current_figure('results_misbinding_logpost_ratioconj%.2f_{label}_global_{unique_id}.pdf' % ratio_conj) # Compute the probability of answering wrongly (from fitting mixture distrib onto posterior) for n in xrange(result_all_log_posterior.shape[1]): result_prob_wrong[ratio_conj_i, n], _, _ = utils.fit_gaussian_mixture_fixedmeans(all_angles, np.exp(result_all_log_posterior[ratio_conj_i, n]), fixed_means=fixed_means, normalise=True, return_fitted_data=False, should_plot=False) # ax = utils.plot_mean_std_area(ratio_space, nanmean(result_prob_wrong, axis=-1), nanstd(result_prob_wrong, axis=-1)) plt.figure() plt.plot(ratio_space, utils.nanmean(result_prob_wrong, axis=-1)) # ax.get_figure().canvas.draw() if savefigs: dataio.save_current_figure('results_misbinding_probwrongpost_allratioconj_{label}_global_{unique_id}.pdf') if plot_error: ## Compute Standard deviation/precision from samples and plot it as a function of ratio_conj stats = utils.compute_mean_std_circular_data(utils.wrap_angles(result_all_thetas - fixed_means[1]).T) f = plt.figure() plt.plot(ratio_space, stats['std']) plt.ylabel('Standard deviation [rad]') if savefigs: dataio.save_current_figure('results_misbinding_stddev_allratioconj_{label}_global_{unique_id}.pdf') f = plt.figure() plt.plot(ratio_space, utils.compute_angle_precision_from_std(stats['std'], square_precision=False), linewidth=2) plt.ylabel('Precision [$1/rad$]') plt.xlabel('Proportion of conjunctive units') plt.grid() if savefigs: dataio.save_current_figure('results_misbinding_precision_allratioconj_{label}_global_{unique_id}.pdf') ## Compute the probability of misbinding # 1) Just count samples < 0 / samples tot # 2) Fit a mixture model, average over mixture probabilities prob_smaller0 = np.sum(result_all_thetas <= 1, axis=1)/float(result_all_thetas.shape[1]) em_centers = np.zeros((ratio_space.size, 2)) em_covs = np.zeros((ratio_space.size, 2)) em_pk = np.zeros((ratio_space.size, 2)) em_ll = np.zeros(ratio_space.size) for ratio_conj_i, ratio_conj in enumerate(ratio_space): cen_lst, cov_lst, em_pk[ratio_conj_i], em_ll[ratio_conj_i] = pygmm.em(result_all_thetas[ratio_conj_i, np.newaxis].T, K = 2, max_iter = 400, init_kw={'cluster_init':'fixed', 'fixed_means': fixed_means}) em_centers[ratio_conj_i] = np.array(cen_lst).flatten() em_covs[ratio_conj_i] = np.array(cov_lst).flatten() # print em_centers # print em_covs # print em_pk f = plt.figure() plt.plot(ratio_space, prob_smaller0) plt.ylabel('Misbound proportion') if savefigs: dataio.save_current_figure('results_misbinding_countsmaller0_allratioconj_{label}_global_{unique_id}.pdf') f = plt.figure() plt.plot(ratio_space, np.max(em_pk, axis=-1), 'g', linewidth=2) plt.ylabel('Mixture proportion, correct') plt.xlabel('Proportion of conjunctive units') plt.grid() if savefigs: dataio.save_current_figure('results_misbinding_emmixture_allratioconj_{label}_global_{unique_id}.pdf') # Put everything on one figure f = plt.figure(figsize=(10, 6)) norm_for_plot = lambda x: (x - np.min(x))/np.max((x - np.min(x))) plt.plot(ratio_space, norm_for_plot(stats['std']), ratio_space, norm_for_plot(utils.compute_angle_precision_from_std(stats['std'], square_precision=False)), ratio_space, norm_for_plot(prob_smaller0), ratio_space, norm_for_plot(em_pk[:, 1]), ratio_space, norm_for_plot(em_pk[:, 0])) plt.legend(('Std dev', 'Precision', 'Prob smaller 1', 'Mixture proportion correct', 'Mixture proportion misbinding')) # plt.plot(ratio_space, norm_for_plot(compute_angle_precision_from_std(stats['std'], square_precision=False)), ratio_space, norm_for_plot(em_pk[:, 1]), linewidth=2) # plt.legend(('Precision', 'Mixture proportion correct'), loc='best') plt.grid() if savefigs: dataio.save_current_figure('results_misbinding_allmetrics_allratioconj_{label}_global_{unique_id}.pdf') if plot_mixtmodel: # Fit Paul's model target_angle = np.ones(N)*fixed_means[1] nontarget_angles = np.ones((N, 1))*fixed_means[0] for ratio_conj_i, ratio_conj in enumerate(ratio_space): print "Ratio: ", ratio_conj responses = result_all_thetas[ratio_conj_i] if mixturemodel_to_use == 'allitems_kappafi': curr_params_fit = em_circularmixture_allitems_kappafi.fit(responses, target_angle, nontarget_angles, kappa=result_fisherinfo_ratio[ratio_conj_i]) elif mixturemodel_to_use == 'allitems': curr_params_fit = em_circularmixture_allitems_uniquekappa.fit(responses, target_angle, nontarget_angles) else: curr_params_fit = em_circularmixture.fit(responses, target_angle, nontarget_angles) result_em_fits[ratio_conj_i] = [curr_params_fit['kappa'], curr_params_fit['mixt_target']] + utils.arrnum_to_list(curr_params_fit['mixt_nontargets']) + [curr_params_fit[key] for key in ('mixt_random', 'train_LL', 'bic')] print curr_params_fit if False: f, ax = plt.subplots() ax2 = ax.twinx() # left axis, kappa ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 0], 0*result_em_fits[:, 0], xlabel='Proportion of conjunctive units', ylabel="Inverse variance $[rad^{-2}]$", ax_handle=ax, linewidth=3, fmt='o-', markersize=8, label='Fitted kappa', color='k') # Right axis, mixture probabilities utils.plot_mean_std_area(ratio_space, result_em_fits[:, 1], 0*result_em_fits[:, 1], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Target') utils.plot_mean_std_area(ratio_space, result_em_fits[:, 2], 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Nontarget') utils.plot_mean_std_area(ratio_space, result_em_fits[:, 3], 0*result_em_fits[:, 3], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax2, linewidth=3, fmt='o-', markersize=8, label='Random') lines, labels = ax.get_legend_handles_labels() lines2, labels2 = ax2.get_legend_handles_labels() ax.legend(lines + lines2, labels + labels2, fontsize=12, loc='right') # ax.set_xlim([0.9, 5.1]) # ax.set_xticks(range(1, 6)) # ax.set_xticklabels(range(1, 6)) plt.grid() f.canvas.draw() if True: # Mixture probabilities ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 1], 0*result_em_fits[:, 1], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", linewidth=3, fmt='-', markersize=8, label='Target') utils.plot_mean_std_area(ratio_space, result_em_fits[:, 2], 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='-', markersize=8, label='Nontarget') utils.plot_mean_std_area(ratio_space, result_em_fits[:, 3], 0*result_em_fits[:, 3], xlabel='Proportion of conjunctive units', ylabel="Mixture probabilities", ax_handle=ax, linewidth=3, fmt='-', markersize=8, label='Random') ax.legend(loc='right') # ax.set_xlim([0.9, 5.1]) # ax.set_xticks(range(1, 6)) # ax.set_xticklabels(range(1, 6)) plt.grid() if savefigs: dataio.save_current_figure('results_misbinding_emmixture_allratioconj_{label}_global_{unique_id}.pdf') if True: # Kappa # ax = utils.plot_mean_std_area(ratio_space, result_em_fits[:, 0], 0*result_em_fits[:, 0], xlabel='Proportion of conjunctive units', ylabel="$\kappa [rad^{-2}]$", linewidth=3, fmt='-', markersize=8, label='Kappa') ax = utils.plot_mean_std_area(ratio_space, utils.kappa_to_stddev(result_em_fits[:, 0]), 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Standard deviation [rad]", linewidth=3, fmt='-', markersize=8, label='Mixture model $\kappa$') # Add Fisher Info theo ax = utils.plot_mean_std_area(ratio_space, utils.kappa_to_stddev(result_fisherinfo_ratio), 0*result_em_fits[:, 2], xlabel='Proportion of conjunctive units', ylabel="Standard deviation [rad]", linewidth=3, fmt='-', markersize=8, label='Fisher Information', ax_handle=ax) ax.legend(loc='best') # ax.set_xlim([0.9, 5.1]) # ax.set_xticks(range(1, 6)) # ax.set_xticklabels(range(1, 6)) plt.grid() if savefigs: dataio.save_current_figure('results_misbinding_kappa_allratioconj_{label}_global_{unique_id}.pdf') if compute_plot_bootstrap: ## Compute the bootstrap pvalue for each ratio # use the bootstrap CDF from mixed runs, not the exact current ones, not sure if good idea. bootstrap_to_load = 1 if bootstrap_to_load == 1: cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap_mixed_from_bootstrapnontargets.pickle') bootstrap_ecdf_sum_label = 'bootstrap_ecdf_allitems_sum_sigmax_T' bootstrap_ecdf_all_label = 'bootstrap_ecdf_allitems_all_sigmax_T' elif bootstrap_to_load == 2: cache_bootstrap_fn = os.path.join(generator_module.pbs_submission_infos['simul_out_dir'], 'outputs', 'cache_bootstrap_misbinding_mixed.pickle') bootstrap_ecdf_sum_label = 'bootstrap_ecdf_allitems_sum_ratioconj' bootstrap_ecdf_all_label = 'bootstrap_ecdf_allitems_all_ratioconj' try: with open(cache_bootstrap_fn, 'r') as file_in: # Load and assign values cached_data = pickle.load(file_in) assert bootstrap_ecdf_sum_label in cached_data assert bootstrap_ecdf_all_label in cached_data should_fit_bootstrap = False except IOError: print "Error while loading ", cache_bootstrap_fn # Select the ECDF to use if bootstrap_to_load == 1: sigmax_i = 3 # corresponds to sigmax = 2, input here. T_i = 1 # two possible targets here. bootstrap_ecdf_sum_used = cached_data[bootstrap_ecdf_sum_label][sigmax_i][T_i]['ecdf'] bootstrap_ecdf_all_used = cached_data[bootstrap_ecdf_all_label][sigmax_i][T_i]['ecdf'] elif bootstrap_to_load == 2: ratio_conj_i = 4 bootstrap_ecdf_sum_used = cached_data[bootstrap_ecdf_sum_label][ratio_conj_i]['ecdf'] bootstrap_ecdf_all_used = cached_data[bootstrap_ecdf_all_label][ratio_conj_i]['ecdf'] result_pvalue_bootstrap_sum = np.empty(ratio_space.size)*np.nan result_pvalue_bootstrap_all = np.empty((ratio_space.size, nontarget_angles.shape[-1]))*np.nan for ratio_conj_i, ratio_conj in enumerate(ratio_space): print "Ratio: ", ratio_conj responses = result_all_thetas[ratio_conj_i] bootstrap_allitems_nontargets_allitems_uniquekappa = em_circularmixture_allitems_uniquekappa.bootstrap_nontarget_stat(responses, target_angle, nontarget_angles, sumnontargets_bootstrap_ecdf=bootstrap_ecdf_sum_used, allnontargets_bootstrap_ecdf=bootstrap_ecdf_all_used) result_pvalue_bootstrap_sum[ratio_conj_i] = bootstrap_allitems_nontargets_allitems_uniquekappa['p_value'] result_pvalue_bootstrap_all[ratio_conj_i] = bootstrap_allitems_nontargets_allitems_uniquekappa['allnontarget_p_value'] ## Plots # f, ax = plt.subplots() # ax.plot(ratio_space, result_pvalue_bootstrap_all, linewidth=2) # if savefigs: # dataio.save_current_figure("pvalue_bootstrap_all_ratioconj_{label}_{unique_id}.pdf") f, ax = plt.subplots() ax.plot(ratio_space, result_pvalue_bootstrap_sum, linewidth=2) plt.grid() if savefigs: dataio.save_current_figure("pvalue_bootstrap_sum_ratioconj_{label}_{unique_id}.pdf") # plt.figure() # plt.plot(ratio_MMlower, results_filtered_smoothed/np.max(results_filtered_smoothed, axis=0), linewidth=2) # plt.plot(ratio_MMlower[np.argmax(results_filtered_smoothed, axis=0)], np.ones(results_filtered_smoothed.shape[-1]), 'ro', markersize=10) # plt.grid() # plt.ylim((0., 1.1)) # plt.subplots_adjust(right=0.8) # plt.legend(['%d item' % i + 's'*(i>1) for i in xrange(1, T+1)], loc='center right', bbox_to_anchor=(1.3, 0.5)) # plt.xticks(np.linspace(0, 1.0, 5)) variables_to_save = ['target_angle', 'nontarget_angles'] if savedata: dataio.save_variables_default(locals(), variables_to_save) dataio.make_link_output_to_dropbox(dropbox_current_experiment_folder='misbindings') plt.show() return locals()