def load_dynamic_range_parameter(sim_data_list_each_folder, plot_settings): ''' Updates sim_data_list_each_folder with dynamic range parameter ''' for sim_data_list in sim_data_list_each_folder: for sim_data in sim_data_list: alternative = True try: alternative_folder_name = plot_settings['alternative_folder_name_for_heat_capacities'][sim_data.folder_name][sim_data.dynamic_range_folder_includes] except KeyError: complete_sim_name = sim_data.sim_name alternative = False if alternative: complete_sim_name = recreate_sim_name_for_alternativ_folder(sim_data, alternative_folder_name, plot_settings) calc_heat_cap_param_settings = {} mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, heat_caps_max_dict, smoothed_heat_caps\ = calc_heat_cap_param_main(complete_sim_name, calc_heat_cap_param_settings) dynamic_range_param_dict = mean_log_beta_distance_dict gens_dynamic_range_param_dict = list(dynamic_range_param_dict.keys()) # !!!! Always loads in heat capacity from last detected generation !!!! index_last_heat_cap_gen = np.argsort(np.array(gens_dynamic_range_param_dict, dtype=int))[-1] last_heat_cap_gen = gens_dynamic_range_param_dict[index_last_heat_cap_gen] dynamic_range_param_last_heat_cap_gen = dynamic_range_param_dict[last_heat_cap_gen] sim_data.dynamic_range_param = dynamic_range_param_last_heat_cap_gen return sim_data_list_each_folder
def plot_dynamic_range_parameter(sim_name, betas, generation, draw_critical, gaussian_kernel): module_settings = {} gen_list = [generation] mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, heat_caps_max_dict, smoothed_heat_caps \ = calc_heat_cap_param_main(sim_name, module_settings, gen_list, gaussian_kernel=gaussian_kernel) mean_log_beta_distance = mean_log_beta_distance_dict[generation] mean_beta_distance = np.mean(betas_max_gen_dict[generation]) mean_max_betas = np.mean(betas_max_gen_dict[generation]) std_max_betas = np.std(betas_max_gen_dict[generation]) # Mark max beta values red plt.scatter(betas_max_gen_dict[generation], heat_caps_max_dict[generation], s=10, c='maroon') # Mean max beta values plt.axvline(mean_max_betas, c='maroon', linestyle='dashed', alpha=0.7, linewidth=2) # Mark hypothetical critical value plt.axvline(1, c='darkorange', linestyle='dashed', alpha=0.7, linewidth=2) # if mean_log_beta_distance > 1.1 and mean_log_beta_distance < 0.9: if draw_critical: text_y_pos = mean_beta_distance + (mean_beta_distance * 0.3) plt.text(text_y_pos, 0.36, r'$\langle \delta_\mathrm{crit} \rangle \approx 0$', fontsize=35) plt.title(r'Critical $\beta=1$') else: if mean_beta_distance < 1: x_min = mean_beta_distance x_max = 1 text_y_pos = mean_beta_distance + (mean_beta_distance * 0.3) plt.text(text_y_pos, 0.36, r'$\langle \delta_\mathrm{sub} \rangle \approx -1$', fontsize=35) plt.title(r'Sub-Critical $\beta=10$') else: x_min = 1 x_max = mean_beta_distance text_y_pos = 1 + (1 * 0.3) plt.text(text_y_pos, 0.36, r'$\langle \delta_\mathrm{super} \rangle \approx 1$', fontsize=35) plt.title(r'Super-Critical $\beta=0.1$') plt.hlines(0.35, x_min, x_max, linestyles='dotted', linewidths=5, colors='darkcyan') return smoothed_heat_caps
def dynamic_regime_param_all_sims(plot_settings, generation): all_deltas = [] for folder_name in plot_settings['all_folder_names']: sim_names = all_sim_names_in_parallel_folder(folder_name) for sim_name in sim_names: mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, \ heat_caps_max_dict, smoothed_heat_caps = calc_heat_cap_param_main(sim_name, {}, gen_list=[generation]) all_deltas.append(mean_log_beta_distance_dict[generation]) return all_deltas
def plot_dynamic_range_parameter_background(sim_name, betas, generation, gaussian_kernel): module_settings = {} gen_list = [generation] mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, heat_caps_max_dict, smoothed_heat_caps \ = calc_heat_cap_param_main(sim_name, module_settings, gen_list, gaussian_kernel=gaussian_kernel) mean_log_beta_distance = mean_log_beta_distance_dict[generation] mean_max_betas = np.mean(betas_max_gen_dict[generation]) std_max_betas = np.std(betas_max_gen_dict[generation]) plt.axvspan(mean_max_betas - std_max_betas, mean_max_betas + std_max_betas, alpha=0.1, color='gray')
def load_dynamic_range_param(folder_name, plot_settings): folder_dir = 'save/{}'.format(folder_name) sim_names = all_sim_names_in_parallel_folder(folder_name) delta_dicts_all_sims = [] deltas_dicts_all_sims = [] for sim_name in sim_names: module_settings = {} mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, \ heat_caps_max_dict, smoothed_heat_caps = calc_heat_cap_param_main(sim_name, module_settings, gaussian_kernel=plot_settings['gaussian_kernel']) delta_dict = mean_log_beta_distance_dict delta_list_dict = log_beta_distance_dict delta_dicts_all_sims.append(delta_dict) deltas_dicts_all_sims.append(delta_list_dict) # settings_list.append(load_settings(dir)) # delta_dicts_all_sims --> men of each generation, deltas_dicts_all_sims --> each individual in a list return (delta_dicts_all_sims, deltas_dicts_all_sims)
def plot_dynamic_range_parameter(sim_name, betas, generation, draw_critical, gaussian_kernel, plot_settings, cmap): module_settings = {} gen_list = [generation] mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, heat_caps_max_dict, smoothed_heat_caps \ = calc_heat_cap_param_main(sim_name, module_settings, gen_list, gaussian_kernel=gaussian_kernel) mean_log_beta_distance = mean_log_beta_distance_dict[generation] mean_beta_distance = np.mean(betas_max_gen_dict[generation]) mean_max_betas = np.mean(betas_max_gen_dict[generation]) std_max_betas = np.std(betas_max_gen_dict[generation]) # Mark max beta values red plt.scatter(betas_max_gen_dict[generation], heat_caps_max_dict[generation], s=15, c='xkcd:dried blood') # Mean max beta values plt.axvline(mean_max_betas, c='gray', linestyle='dashed', alpha=0.7, linewidth=3) # Mark hypothetical critical value plt.axvline(1, c='black', linestyle='dotted', alpha=0.7, linewidth=3) # if mean_log_beta_distance > 1.1 and mean_log_beta_distance < 0.9: if draw_critical: text_y_pos = mean_beta_distance + (mean_beta_distance * 0.4) # plt.text(text_y_pos, 0.35, r'$\langle \delta \rangle = %s$' % np.round(mean_log_beta_distance, decimals=2), fontsize=35) plt.text(text_y_pos, 0.27, plot_settings['dynamical_regime_label']) # plt.title(plot_settings['title']) else: if mean_beta_distance < 1: x_min = mean_beta_distance x_max = 1 text_y_pos = mean_beta_distance + (mean_beta_distance * 0.4) # plt.text(text_y_pos, 0.35, r'$\langle \delta \rangle = %s$' % np.round(mean_log_beta_distance, decimals=2), fontsize=35) plt.text(text_y_pos, 0.360, plot_settings['dynamical_regime_label']) # plt.title(plot_settings['title']) plt.hlines(0.35, x_min, x_max, linestyles='dotted', linewidths=5, colors=cmap(0.8)) else: x_min = 1 x_max = mean_beta_distance text_y_pos = 1 + (1 * 0.4) # plt.text(text_y_pos, 0.35, r'$\langle \delta \rangle = %s$' % np.round(mean_log_beta_distance, decimals=2), fontsize=35) plt.text(text_y_pos, 0.360, plot_settings['dynamical_regime_label']) # plt.title(plot_settings['title']) plt.hlines(0.35, x_min, x_max, linestyles='dotted', linewidths=5, colors=cmap(0.8)) return smoothed_heat_caps
def load_dynamic_range_param(folder_name, gen_list=None): sim_names = all_sim_names_in_parallel_folder(folder_name) delta_dicts_all_sims = [] deltas_dicts_all_sims = [] for sim_name in sim_names: module_settings = {} mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, \ heat_caps_max_dict, smoothed_heat_caps = calc_heat_cap_param_main(sim_name, module_settings, gen_list=gen_list, gaussian_kernel=True) delta_dict = mean_log_beta_distance_dict delta_list_dict = log_beta_distance_dict delta_dicts_all_sims.append(delta_dict) deltas_dicts_all_sims.append(delta_list_dict) # settings_list.append(load_settings(dir)) # delta_dicts_all_sims --> men of each generation, deltas_dicts_all_sims --> each individual in a list delta_dict = converting_list_of_dicts_to_dict_of_lists( delta_dicts_all_sims) deltas_dict = converting_list_of_dicts_to_dict_of_lists( deltas_dicts_all_sims) return delta_dict, deltas_dict
def load_data_from_sims(folder_name, plot_settings): folder_dir = 'save/{}'.format(folder_name) sim_names = all_sim_names_in_parallel_folder(folder_name) sim_plot_data_list = [] for sim_name in sim_names: module_settings = {} mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, \ heat_caps_max_dict, smoothed_heat_caps = calc_heat_cap_param_main(sim_name, module_settings, gaussian_kernel=plot_settings['gaussian_kernel']) delta_dict = mean_log_beta_distance_dict delta_list_dict = log_beta_distance_dict fitness_last_gen, last_gen = load_fitness_last_gen( sim_name, plot_settings) sim_plot_data_list.append( OneSimPlotData(sim_name=sim_name, delta_dict=delta_dict, delta_list_dict=delta_list_dict, fitness_at_given_generation=fitness_last_gen, generation_of_fitness=last_gen)) # settings_list.append(load_settings(dir)) # delta_dicts_all_sims --> men of each generation, deltas_dicts_all_sims --> each individual in a list return sim_plot_data_list
def plot(attrs_lists, plot_settings): if plot_settings['first_plot']: plt.figure(figsize=(10, 7)) # colors = sns.color_palette("dark", len(attrs_lists)) all_deltas = dynamic_regime_param_all_sims( plot_settings, plot_settings['color_according_to_delta_in_generation']) # cmap = plt.get_cmap('brg') cmap = colormap_according_to_delta(0, plot_settings) norm = colors_package.Normalize(vmin=min(all_deltas), vmax=max(all_deltas)) # if plot_settings['last_plot']: cbar = plt.colorbar(cm.ScalarMappable(norm=norm, cmap=cmap)) cbar.set_label(r'$\langle \delta \rangle$ at Generation 0', rotation=270, labelpad=23) sim_names = all_sim_names_in_parallel_folder(plot_settings['folder_name']) deltas = [] for sim_name in sim_names: mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, \ heat_caps_max_dict, smoothed_heat_caps = calc_heat_cap_param_main(sim_name, {}, gen_list=[plot_settings['color_according_to_delta_in_generation']]) deltas.append(mean_log_beta_distance_dict[ plot_settings['color_according_to_delta_in_generation']]) print('Deltas:') print(deltas) print('all Deltas:') print(all_deltas) for attrs_list, delta in zip(attrs_lists, deltas): color = cmap(norm(delta)) generations = np.arange(len(attrs_list)) mean_attrs_list = [np.nanmean(gen_attrs) for gen_attrs in attrs_list] plt.scatter(generations, mean_attrs_list, s=1, alpha=0.085, c=color) if plot_settings['sliding_window']: slided_mean_attrs_list, slided_x_axis = slide_window( mean_attrs_list, plot_settings['sliding_window_size']) plt.plot(slided_x_axis, slided_mean_attrs_list, alpha=0.5, linewidth=2, c=color) if plot_settings['smooth']: ''' Trying to make some sort of regression, that smoothes and interpolates Trying to find an alternative to moving average, where boundary values are cut off ''' # smoothed_mean_attrs_list = gaussian_kernel_smoothing(mean_attrs_list) # Savitzky-Golay filter: smoothed_mean_attrs_list = savgol_filter( mean_attrs_list, 201, 3) # window size, polynomial order # plt.plot(generations, smoothed_mean_attrs_list, c=color) # Uncommand the following, if interpolation shall be applied to smoothed data f_interpolate = interp1d(generations, smoothed_mean_attrs_list, kind='cubic') x_interp = np.linspace(np.min(generations), np.max(generations), num=4000, endpoint=True) y_interp = f_interpolate(x_interp) plt.plot(x_interp, y_interp, c=color, alpha=0.5, linewidth=2) # plt.scatter(generations, mean_attrs_list, s=20, alpha=1) plt.xlabel('Generation') # plt.ylabel(plot_settings['attr']) plt.ylabel(r'$\langle E_\mathrm{org} \rangle$') plt.ylim(plot_settings['ylim']) # plt.title(plot_settings['title'], color=plot_settings['title_color']) if plot_settings['legend'] and plot_settings['last_plot']: create_legend() if plot_settings['last_plot']: save_dir = 'save/{}/figs/several_plots{}/'.format( folder_name, plot_settings['add_save_name']) save_name = 'several_sims_criticial_{}{}_{}_min_ts{}_min_food{}_{}_all_in_one.png'. \ format(plot_settings['attr'], plot_settings['only_copied_str'], plot_settings['folder_name'], plot_settings['min_ts_for_plot'], plot_settings['min_food_for_plot'], plot_settings['plot_generations_str']) if not os.path.exists(save_dir): os.makedirs(save_dir) plt.savefig(save_dir + save_name, bbox_inches='tight', dpi=300)
def main(sim_name, settings, generation_list, recorded, plot_settings, draw_original_heat_cap_data=True, draw_dynamic_range_param=False, draw_legend=False, draw_critical=False, draw_smoothed_heat_caps=False, gaussian_kernel=False): ''' generation list can be set to None recorded is a boolean defining whether we want to visualize recorded heat capacity or dream heat capacity ''' # TODO: make these scripts take these as params loadfile = sim_name folder = 'save/' + loadfile R, thermal_time, beta_low, beta_high, beta_num, y_lim_high = settings['heat_capacity_props'] #R = 10 Nbetas = beta_num betas = 10 ** np.linspace(beta_low, beta_high, Nbetas) numAgents = settings['pop_size'] size = settings['size'] if generation_list is None: if recorded: generation_list = automatic_generation_generation_list(folder + '/C_recorded') else: generation_list = automatic_generation_generation_list(folder + '/C') iter_gen = generation_list # TODO: Repeat averaging seems to work C = np.zeros((R, numAgents, Nbetas, len(iter_gen))) print('Loading data...') for ii, iter in enumerate(iter_gen): #for bind in np.arange(0, 100): for bind in np.arange(1, Nbetas): if recorded: # Depending on whether we are dealing with recorded or dream heat capacity filename = folder + '/C_recorded/C_' + str(iter) + '/C-size_' + str(size) + '-Nbetas_' + \ str(Nbetas) + '-bind_' + str(bind) + '.npy' else: filename = folder + '/C/C_' + str(iter) + '/C-size_' + str(size) + '-Nbetas_' + \ str(Nbetas) + '-bind_' + str(bind) + '.npy' C[:, :, bind, ii] = np.load(filename) print('Done.') plt.rc('text', usetex=True) font = {'family': 'serif', 'size': plot_settings['font_size'], 'serif': ['computer modern roman']} plt.rc('font', **font) plt.rc('legend', **{'fontsize': plot_settings['font_size']}) b = 0.8 alpha = 0.3 print('Generating figures...') for ii, iter in enumerate(iter_gen): if plot_settings['first_plot']: fig, ax = plt.subplots(1, 1, figsize=(30, 8), sharex=True) else: fig, ax = plot_settings['fig, ax'] # fig.text(0.51, 0.030, r'$\beta_{fac}$', ha='center', fontsize=30) # fig.text(0.005, 0.5, r'$C_\mathrm{H}/N$', va='center', rotation='vertical', fontsize=30) plt.xlabel(r'$c_\beta$') plt.ylabel(r'$C_\mathrm{H}/N$') title = 'Specific Heat of Foraging Community\n Generation: ' + str(iter) # fig.suptitle(title) if draw_dynamic_range_param: plot_dynamic_range_parameter_background(sim_name, betas, iter, gaussian_kernel) # CHANGE THIS TO CUSTOMIZE HEIGHT OF PLOT #upperbound = 1.5 * np.max(np.mean(np.mean(C[:, :, :-40, :], axis=0), axis=0)) # upperbound = np.max(np.mean(np.mean(C, axis=0)), axis=0) #upperbound = 0.4 # upperbound = y_lim_high / 100 upperbound = 0.25 upperbound = 0.4 label = iter # cm = plt.get_cmap(plot_settings['cmap']) # cm = plt.get_cmap('gist_earth') # gist_ncar # gist_earth #cmocean.cm.phase cm = LinearSegmentedColormap.from_list('my_cmap', plot_settings['color_list']) cycle_colors = [cm(1.*i/numAgents) for i in range(numAgents)] # cycle_colors.reverse() ax.set_prop_cycle(color=cycle_colors) if draw_original_heat_cap_data: for numOrg in range(numAgents): ax.scatter(betas, np.mean(C[:, numOrg, :, ii], axis=0), s=30, alpha=0.3, marker='.', label=label) # color=[0, 0, 0], if draw_smoothed_heat_caps: module_settings={} mean_log_beta_distance_dict, log_beta_distance_dict, beta_distance_dict, beta_index_max, betas_max_gen_dict, heat_caps_max_dict, smoothed_heat_caps_dict \ = calc_heat_cap_param_main(sim_name, module_settings, [iter], gaussian_kernel=gaussian_kernel) ax.set_prop_cycle(color=[cm(1.*i/numAgents) for i in range(numAgents)]) for numOrg in range(numAgents): # c = np.dot(np.random.random(), [1, 1, 1]) ax.scatter(betas, smoothed_heat_caps_dict[iter][numOrg], s=2, alpha=0.3, marker='o', label=label, color='grey') ax.plot(betas, smoothed_heat_caps_dict[iter][numOrg], linewidth=1, alpha=0.35, label=label, color='grey') if draw_dynamic_range_param: plot_dynamic_range_parameter(sim_name, betas, iter, draw_critical, gaussian_kernel, plot_settings, cm) # xticks = [0.01, 0.05, 0.1, 0.5, 1, 2, 10, 20, 100] ax.set_xscale("log") # , nonposx='clip' ax.tick_params(axis='x', which='major', pad=15) # This makes custom x ticks # ax.set_xticks(xticks) # This makes x-ticks # formatter = FuncFormatter(lambda y, _: '{:.16g}'.format(y)) # ax.get_xaxis().set_major_formatter(formatter) low_xlim = 10 ** beta_low high_xlim = 10 ** beta_high plt.axis([low_xlim, high_xlim, 0, upperbound]) if draw_legend: plot_legend(cm, draw_smoothed_heat_caps) # plot_legend2(cm) # leg = plt.legend(loc=2, title='Generation') # # for lh in leg.legendHandles: # lh.set_alpha(1) # lh.set_sizes(30) if recorded: savefolder = folder + '/figs/C_recorded/' else: savefolder = folder + '/figs/C/' savefilename = savefolder + 'C-size_' + str(size) + '-Nbetas_' + \ str(Nbetas) + '-gen_' + str(iter) + '.png' savefilename_pdf = savefolder + 'C-size_' + str(size) + '-Nbetas_' + \ str(Nbetas) + '-gen_' + str(iter) + '.pdf' if not path.exists(savefolder): makedirs(savefolder) if plot_settings['save_plot']: plt.savefig(savefilename, bbox_inches='tight', dpi=300) plt.savefig(savefilename_pdf, bbox_inches='tight') plt.close() # plt.clf() savemsg = 'Saving ' + savefilename print(savemsg) # plt.show() # plt.pause(0.1) plot_settings['fig, ax'] = (fig, ax) return plot_settings