def create_settings_for_repeat(settings, sim_name, pipeline_settings): # settings['TimeSteps'] = 5 if pipeline_settings['varying_parameter'] == 'time_steps': settings['random_time_steps'] = False elif pipeline_settings['varying_parameter'] == 'food': settings['random_food_seasons'] = False settings = copy.deepcopy(settings) complete_sim_folder = sim_name settings['loadfile'] = complete_sim_folder if pipeline_settings['load_last_generation']: settings['iter'] = detect_all_isings(complete_sim_folder)[-1] pipeline_settings['load_generation'] = detect_all_isings(complete_sim_folder)[-1] else: settings['iter'] = pipeline_settings['load_generation'] settings['LoadIsings'] = True settings['switch_off_evolution'] = True settings['save_data'] = False settings['switch_seasons_repeat_pipeline'] = True settings['dynamic_range_pipeline'] = True # Animations: settings['plot_generations'] = pipeline_settings['animation_for_repeats'] settings['repeat_pipeline_switched_boo'] = None settings['random_time_steps_power_law'] = False settings['commands_in_folder_name'] = False settings['plot_pipeline'] = False # switches off animation: settings['plot'] = False settings['save_energies_velocities_last_gen'] = False settings['compress_save_isings'] = pipeline_settings['compress_save_isings'] return settings
def main(sim_name1, sim_name2): all_generations1 = detect_all_isings(sim_name1) all_generations2 = detect_all_isings(sim_name2) if all_generations1 != all_generations2: warnings.warn( 'Both simulations have a differnt amount of generations, plotting generationb {} of simulation 1 ' 'and generation {} of simulation 2'.format(all_generations1[-1], all_generations2[-1])) load_isings_attributes_from_list(sim_name1, all_generations1, 'avg_energy')
def load_fitness_last_gen(sim_name, plot_settings): generation = detect_all_isings(sim_name)[-1] isings_last_gen = load_isings_from_list( sim_name, [generation], decompress=plot_settings['decompress'])[0] isings_last_gen = choose_copied_isings(isings_last_gen) fitness_last_gen = np.mean([I.avg_energy for I in isings_last_gen]) return fitness_last_gen, generation
def only_fittest_individuals(sim_name, save_subfolder): ''' This function takes last generation of run, selects the fittest individuals and saves them as additional last generation (This generation thus has fewer individuals) ''' complete_sim_folder = '{}/{}'.format(save_subfolder, sim_name) last_generation_num = detect_all_isings(complete_sim_folder)[-1] last_isings = load_isings_from_list(complete_sim_folder, [last_generation_num])[0] fitness_list = [I.avg_energy for I in last_isings] # Sort isings according to fitness: # sorted_isings = [I for _, I in np.sort(zip(fitness_list, last_isings))] # sorted_zip = zip(fitness_list, last_isings) # sorted_zip = sorted(sorted_zip) # sorted_isings = [I for f, I in sorted_zip] # Choose first third of the fittes isings: sorted_isings = sort_list_acc_to_other_list(last_isings, fitness_list) fittest_isings = sorted_isings[:int(len(sorted_isings)/3)] pop_size = len(fittest_isings) #save/switch_seasons_20200524-030645_num_rep_200_same_rep_1_f_sum_100_f_win10_default_food/b10_summer_0/sim-20200524-030647/isings ising_save_folder = 'save/{}/isings/gen[{}]-isings.pickle'.format(complete_sim_folder, last_generation_num + 1) pickle_out = open(ising_save_folder, 'wb') pickle.dump(fittest_isings, pickle_out) pickle_out.close() return pop_size
def create_repeats(sim_name, save_subfolder, settings, num_repeats, food_summer, food_winter, only_fittest): settings = copy.deepcopy(settings) if only_fittest: pop_size = only_fittest_individuals(sim_name, save_subfolder) settings['pop_size'] = pop_size complete_sim_folder = '{}/{}'.format(save_subfolder, sim_name) settings['loadfile'] = complete_sim_folder settings['iter'] = detect_all_isings(complete_sim_folder)[-1] settings['LoadIsings'] = True settings['switch_off_evolution'] = True settings['save_data'] = False settings['switch_seasons_repeat_pipeline'] = True # Animations: settings['plot_generations'] = [1] # Number of repeats # Iterations = 200 Iterations = num_repeats settings['repeat_pipeline_switched_boo'] = False train.run(settings, Iterations) # switch seasons if settings['food_num'] == food_summer: settings['food_num'] = food_winter elif settings['food_num'] == food_winter: settings['food_num'] = food_summer settings['repeat_pipeline_switched_boo'] = True train.run(settings, Iterations)
def create_settings_for_repeat(settings, sim_name, pipeline_settings): # settings['TimeSteps'] = 5 settings['random_food_seasons'] = False settings = copy.deepcopy(settings) complete_sim_folder = sim_name settings['loadfile'] = complete_sim_folder settings['iter'] = detect_all_isings(complete_sim_folder)[-1] settings['LoadIsings'] = True settings['switch_off_evolution'] = True settings['save_data'] = False settings['switch_seasons_repeat_pipeline'] = True settings['dynamic_range_pipeline'] = True # Animations: settings['plot_generations'] = [1] settings['repeat_pipeline_switched_boo'] = None settings['random_time_steps_power_law'] = False settings['commands_in_folder_name'] = False settings['plot_pipeline'] = False # switches off animation: settings['plot'] = False return settings
def load_trained_vals(trained_sim_name, attr, n_last_gens=100): load_gens_trained = detect_all_isings(trained_sim_name) load_gens_trained = load_gens_trained[-(n_last_gens):] trained_isings_list = load_isings_from_list(trained_sim_name, load_gens_trained) trained_vals = extract_attr(trained_isings_list, attr) # trained_avg = np.avg(trained_vals) # trained_std = np.std(trained_vals) return trained_vals
def test_robustness(sim_name, save_dir, animate_reps, num_evaluate_different_inds=4, repeat_mutations=20, load_generation=False, pop_size=50, time_steps=2000, attr_name='avg_energy'): if not load_generation: load_generation = detect_all_isings(sim_name)[-1] settings = load_settings(sim_name) settings['pop_size'] = pop_size settings['TimeSteps'] = time_steps settings['save_data'] = False settings['plot_pipeline'] = False settings['fading_traces_animation'] = True # Das ist nur zu test-pfuschzwecken da kann irgendwann weg:_ settings['random_time_steps'] = False foods = [] for i in range(0, settings['food_num']): foods.append(food(settings)) isings = load_isings_from_list(sim_name, [load_generation], wait_for_memory=False)[0] all_inds_evaluated = [] for ind in range(num_evaluate_different_inds): # Only take first 20 inds, those are the not recently mutated chosen_I = copy.deepcopy(isings[ind]) one_agend_all_repeats_list = [] for rep in range(repeat_mutations): if rep in animate_reps: settings['mutation_robustness_path'] = save_dir settings['plot_generations'] = [0] else: settings['mutation_robustness_path'] = '' settings['plot_generations'] = [] chosen_I_copy = copy.deepcopy(chosen_I) # Mutation! if not rep == 0: network_edge_positions = np.argwhere(chosen_I.maskJ==True) rand_pos = np.random.randint(0, len(network_edge_positions)) mutate_edge_pos = network_edge_positions[rand_pos] # Don't use chosen_I_copy if with each iteration there shouls be more mutations chosen_I_copy.J[mutate_edge_pos[0], mutate_edge_pos[1]] = np.random.uniform(-1, 1) * chosen_I_copy.max_weights clone_isings = [] for i in range(pop_size): clone_isings.append(copy.deepcopy(chosen_I_copy)) blub, evaluated_isings = EvolutionLearning(clone_isings, foods, settings, Iterations=1) one_agend_all_repeats_list.append(evaluated_isings) all_inds_evaluated.append(one_agend_all_repeats_list) return all_inds_evaluated
def main(sim_name, settings, generations=None, recorded=False, add_subfolder_to_sim_name=True): if add_subfolder_to_sim_name: sim_name = '{}/{}'.format(settings['save_subfolder'], sim_name) if generations is None: gen_nums = detect_all_isings(sim_name) generations = [gen_nums[-1]] cores = settings['cores'] compute_plot_heat_capacity(sim_name, generations, cores, settings, recorded)
def merge_ising_files(sim_name1, sim_name2, settings): last_gen1 = detect_all_isings(sim_name1)[-1] last_gen2 = detect_all_isings(sim_name2)[-1] isings1 = load_isings_from_list(sim_name1, [last_gen1], wait_for_memory=False)[0] isings2 = load_isings_from_list(sim_name2, [last_gen2], wait_for_memory=False)[0] for I_1 in isings1: I_1.species = 0 I_1.shared_fitness = 0 if settings['isolated_populations']: I_1.isolated_population = 0 for I_2 in isings2: I_2.species = 1 I_2.shared_fitness = 0 if settings['isolated_populations']: I_2.isolated_population = 1 isings_new = isings1[:25] + isings2[:25] return isings_new
def main(sim_name, isings_list_dict, attr, colors=['darkorange', 'royalblue', 'maroon'], name_extension=''): iter_list = detect_all_isings(sim_name) folder = 'save/' + sim_name savefolder = folder + '/figs/' + attr + '/' # + '_line/' savefilename = savefolder + '{}_gen{}-{}-_{}.png'.format( attr, str(iter_list[0]), str(iter_list[-1]), name_extension) if not path.exists(savefolder): makedirs(savefolder) #colors = ['red', 'blue', 'green'] plt.figure(figsize=(19, 10)) legend_elements = [] for i, iso_pop_name in enumerate(isings_list_dict): y_axis = [] for isings in isings_list_dict[iso_pop_name]: attr_values_onegen = [] for I in isings: exec('attr_values_onegen.append(I.{})'.format(attr)) gen_avg = np.mean(attr_values_onegen) y_axis.append(gen_avg) x_axis = np.arange(len(y_axis)) legend_elements.append( Line2D([0], [0], marker='o', color='w', label='population {}'.format(iso_pop_name), markerfacecolor=colors[i], markersize=5, alpha=0.75)) plt.scatter(x_axis, y_axis, c=colors[i], alpha=0.15) if attr == 'norm_food_and_ts_avg_energy': plt.ylim(0, 0.0002) # plt.legend(loc="lower right", bbox_to_anchor=(0.95, 0.05), handles=legend_elements) plt.legend(handles=legend_elements) plt.xlabel('Generation') plt.ylabel(attr) plt.savefig(savefilename, dpi=300, bbox_inches='tight')
def run_hyperparams(iterations, settings_tune, settings): #settings['continuous_species'] = settings_tune['continuous_species'] #Constants for delta formula c_top, c_weight, c_beta #settings['shared_fitness_constants'] = settings_tune['shared_fitness_constants'] settings['delta_threshold_speciation'] = settings_tune[ 'delta_threshold_speciation'] #settings['add_save_name'] = '_HYPERPARAM_con_species_{}_delta_{}'.format(settings_tune['continuous_species'], settings_tune['delta_threshold_speciation']) settings['add_save_name'] = 'delta_{}'.format( settings_tune['delta_threshold_speciation']) sim_name = run(settings, iterations) last_ising = detect_all_isings(sim_name)[-1] isings_last_gen = load_isings_from_list(sim_name, [last_ising])[0] all_avg_energies = [I.avg_energy for I in isings_last_gen] avg_fitness_last_gen = np.average(all_avg_energies) settings_tune['sim_name'] = sim_name return settings_tune, avg_fitness_last_gen
def compute_heat_cap_retrospectively(folder_name, every_nth_gen, heat_cap_settings): sim_names = all_sim_names_in_parallel_folder(folder_name) for sim_name in sim_names: gens_in_curr_sim = detect_all_isings(sim_name) number_of_gens_calculate = int(len(gens_in_curr_sim) / every_nth_gen) gens = np.linspace(gens_in_curr_sim[0], gens_in_curr_sim[-1], number_of_gens_calculate).astype(int) orig_settings = load_settings(sim_name) for key, val in heat_cap_settings.items(): orig_settings[key] = val save_settings(sim_name, orig_settings) compute_and_plot_heat_capacity_automatic.main( sim_name, orig_settings, generations=gens, recorded=True, add_subfolder_to_sim_name=False)
def merge(first_sim, second_sim): '''Copies the ising files from second_sim into first_sim. The names of the ising files of the second_sim are renamed counting upwards from the highest generation of first_sim''' first_folder = 'save/{}/isings/'.format(first_sim) second_folder = 'save/{}/isings/'.format(second_sim) max_gen_first = np.max(detect_all_isings(first_sim)) all_isings_second = [ f for f in listdir(second_folder) if isfile(join(second_folder, f)) and f.endswith('isings.pickle') ] all_isings_second_new = [] for name in all_isings_second: i_begin = name.find('[') + 1 i_end = name.find(']') curr_gen = int(name[i_begin:i_end]) new_gen = curr_gen + max_gen_first + 1 new_name = name[:i_begin] + str(new_gen) + name[i_end:] all_isings_second_new.append(new_name) for old_second, new_second in zip(all_isings_second, all_isings_second_new): copyfile(second_folder + old_second, first_folder + new_second)
def main(loadfile, settings, isings_list, plot_var_x, plot_var_y, i_type, s=0.8, alpha=0.13, autoLoad=True, x_lim=None, y_lim=None, log=True, y_noise=True): loadfiles = [loadfile] #loadfiles = ['sim-20191114-000009_server'] iter_list = detect_all_isings(loadfile, i_type) # iter_list = np.arange(0, 2000, 1) # energy_model = settings['energy_model'] if i_type == 'pred': numAgents = settings['pop_size_pred'] elif i_type == 'prey': numAgents = settings['pop_size_prey'] #autoLoad = True saveFigBool = True fixGen2000 = False new_order = [2, 0, 1] labels = [r'$\beta_i = 0.1$', r'$\beta_i = 1$', r'$\_i = 10$'] cmap = plt.get_cmap('seismic') norm = colors.Normalize(vmin=0, vmax=len(loadfiles)) # age/color mapping # norm = [[194, 48, 32, 255], # [146, 49, 182, 255], # [44, 112, 147, 255] # ] # norm = np.divide(norm, 255) a = 0.15 # alpha x_pars_list, y_pars_list = fitness(loadfile, iter_list, isings_list, numAgents, autoLoad, saveFigBool, plot_var_x, plot_var_y) #fig, ax = plt.subplots() cmap = plt.get_cmap('plasma') norm = colors.Normalize(vmin=0, vmax=len(iter_list)) font = {'family': 'normal', 'weight': 'bold', 'size': 10} plt.rc('font', **font) plt.figure() for gen, (x_pars, y_pars) in enumerate(zip(x_pars_list, y_pars_list)): c = cmap(norm(gen)) if y_noise: y_pars = y_pars.astype(float) y_pars = y_pars + np.random.rand(np.shape(y_pars)[0]) - 0.5 ax = plt.scatter(x_pars, y_pars, s=s, alpha=alpha, c=c) if y_noise: plt.ylim(1, 1000) if log: plt.xscale('log') plt.yscale('log') #TODO:colour acc to generation!! plt.xlim(x_lim) plt.ylim(y_lim) plt.xlabel('{}'.format(plot_var_x.replace('_', ' '))) plt.ylabel('{}'.format(plot_var_y.replace('_', ' '))) folder = 'save/' + loadfile if i_type == 'pred': savefolder = folder + '/figs_pred/' + plot_var_x + '_vs_' + plot_var_y + '_line/' elif i_type == 'prey': savefolder = folder + '/figs_prey/' + plot_var_x + '_vs_' + plot_var_y + '_line/' savefilename = savefolder + plot_var_x + '_vs_' + plot_var_y + '_gen' + str( iter_list[0]) + '-' + str(iter_list[-1]) + '.png' if not path.exists(savefolder): makedirs(savefolder) if saveFigBool: plt.savefig(savefilename, bbox_inches='tight', dpi=500) plt.show() # Trying to fix memory leak with this: plt.cla() plt.clf() plt.close('all') '''
def main(loadfile, settings, isings_list, plot_var_x, plot_var_y, s=0.8, alpha=0.13, autoLoad=True, x_lim=None, y_lim=None, xlog=False, ylog=False, y_noise=False, name_extension=''): loadfiles = [loadfile]#loadfiles = ['sim-20191114-000009_server'] iter_list = detect_all_isings(loadfile) # iter_list = np.arange(0, 2000, 1) # energy_model = settings['energy_model'] numAgents = settings['pop_size'] #autoLoad = True saveFigBool = True fixGen2000 = False plot_first = 20 new_order = [2, 0, 1] labels = [r'$\beta_i = 0.1$', r'$\beta_i = 1$', r'$\_i = 10$'] norm = colors.Normalize(vmin=0, vmax=len(loadfiles)) # age/color mapping # norm = [[194, 48, 32, 255], # [146, 49, 182, 255], # [44, 112, 147, 255] # ] # norm = np.divide(norm, 255) a = 0.15 # alpha color1 = 'green' color2 = 'red' isings_list_1 = [] isings_list_2 = [] for isings in isings_list: isings_list_1.append(isings[:plot_first]) isings_list_2.append(isings[plot_first:]) x_pars_list1, y_pars_list1 = fitness(loadfile, iter_list, isings_list_1, len(isings_list_1[0]), autoLoad, saveFigBool, plot_var_x, plot_var_y) x_pars_list2, y_pars_list2 = fitness(loadfile, iter_list, isings_list_2, len(isings_list_2[0]), autoLoad, saveFigBool, plot_var_x, plot_var_y) #fig, ax = plt.subplots() cmap = plt.get_cmap('plasma') norm = colors.Normalize(vmin=0, vmax=len(iter_list)) font = {'family': 'normal', 'weight': 'bold', 'size': 10} plt.rc('font', **font) plt.figure() plot(x_pars_list2, y_pars_list2, iter_list, s, alpha, color2, xlog, ylog, y_noise, y_lim, x_lim, name_extension, saveFigBool, label='Mutated') plot(x_pars_list1, y_pars_list1, iter_list, s, alpha, color1, xlog, ylog, y_noise, y_lim, x_lim, name_extension, saveFigBool, label='Fittest from last generation ') plt.xlim(x_lim) plt.ylim(y_lim) plt.xlabel('{}'.format(plot_var_x.replace('_', ' '))) plt.ylabel('{}'.format(plot_var_y.replace('_', ' '))) legend_elements = [ Line2D([0], [0], marker='o', color='w', label='Fittest/Selected of last generation', markerfacecolor='green', markersize= 5, alpha=0.75), Line2D([0], [0], marker='o', color='w', label='Mutated', markerfacecolor='red', markersize= 5, alpha=0.75) ] plt.legend(handles=legend_elements)# loc="lower right", bbox_to_anchor=(0.95, 0.05), folder = 'save/' + loadfile savefolder = folder + '/figs/' + plot_var_x + '_vs_' + plot_var_y + '_ising_order_color_line/' savefilename = savefolder + plot_var_x + '_vs_' + plot_var_y + '_gen' + str(iter_list[0]) + '-' + str( iter_list[-1]) + name_extension + '.png' if not path.exists(savefolder): makedirs(savefolder) if saveFigBool: plt.savefig(savefilename, bbox_inches='tight', dpi=300) plt.show() # Trying to fix memory leak with this: plt.cla() plt.clf() plt.close('all')
def main(sim_name, settings, i_type, generations=None): if generations is None: gen_nums = detect_all_isings(sim_name, i_type) generations = [gen_nums[-1]] cores = settings['cores'] compute_plot_heat_capacity(sim_name, generations, cores, settings, i_type)
def compute_plot_heat_capacity(sim_name, generation_list, cores, settings, i_type): gens_str = list_to_blank_seperated_str(generation_list) os.system( 'bash bash-heat-capacity-generational-automatic.sh {} "{}" {} {}'. format(sim_name, gens_str, cores, i_type)) try: visualize_heat_capacity_generational_automatic.main( sim_name, settings, None, i_type) except Exception: print('Could not generate heat capacity plots for sim {}'.format( sim_name)) if __name__ == '__main__': #sim_name = 'sim-20200403-192708-g_5_-t_20_-ref_0_-tt_10' # 'Laptop_HEL_runs/single_runs_HEL/sim-20200209-124814-ser_-b_10_-f_100_-n_1'#'sim-20200327-220128-g_8000_-b_1_-ref_2000_-a_500_1000_2000_4000_6000_8000_-n_3_sensors' sim_names = [ 'sim-20200403-211835-g_4000_-t_2000_-b_10_-ref_250_-a_0_250_500_750_1000_1500_2000_3000_3999_-n_second_test_pred_prey' ] # ['sim-20200403-211845-g_4000_-t_2000_-b_1_-ref_250_-a_0_250_500_750_1000_1500_2000_3000_3999_-n_second_test_pred_prey', 'sim-20200403-211835-g_4000_-t_2000_-b_10_-ref_250_-a_0_250_500_750_1000_1500_2000_3000_3999_-n_second_test_pred_prey', 'sim-20200403-211857-g_4000_-t_2000_-b_0.1_-ref_250_-a_0_250_500_750_1000_1500_2000_3000_3999_-n_second_test_pred_prey'] for sim_name in sim_names: cores = 20 gen_nums = detect_all_isings(sim_name, 'pred') generation_list = [0, gen_nums[-1]] #generation_list = [0] settings = load_settings(sim_name) compute_plot_heat_capacity(sim_name, generation_list, cores, settings, 'pred') compute_plot_heat_capacity(sim_name, generation_list, cores, settings, 'prey')
def main(sim_name, isings_list, attr_tuple, colors=['darkorange', 'royalblue', 'maroon'], attr_c='isolated_population', name_extension=''): attr_x, attr_y = attr_tuple attr_tuple = (attr_x, attr_y, attr_c) iter_list = detect_all_isings(sim_name) folder = 'save/' + sim_name savefolder = folder + '/figs/' + attr_x + '_vs_' + attr_y + '/' # + '_line/' savefilename = savefolder + '{}_vs_{}_color_{}_gen{}-{}-_{}.png'.format( attr_x, attr_y, attr_c, str(iter_list[0]), str(iter_list[-1]), name_extension) if not path.exists(savefolder): makedirs(savefolder) # All individuals = generations * num_individuals: num_inds_in_run = len(isings_list) * len(isings_list[0]) # x_value, y_value, colour_value all_inds_plot_arr = np.zeros((num_inds_in_run, 3)) tot_ind_num = 0 for isings in isings_list: for I in isings: for i, attr in enumerate(attr_tuple): exec('all_inds_plot_arr[tot_ind_num, i] = I.{}'.format(attr)) tot_ind_num += 1 plt.figure(figsize=(19, 10)) legend_elements = [] plt.figure(figsize=(19, 10)) plot_colors = list(map(generate_colors_from_var_c, all_inds_plot_arr[:, 2])) plt.scatter(all_inds_plot_arr[:, 0], all_inds_plot_arr[:, 1], c=plot_colors, s=0.8, alpha=0.15) # all_plotting_elemnts = [generation legend_elements = [] for i in range(2): legend_elements.append( Line2D([0], [0], marker='o', color='w', label='population {}'.format(i), markerfacecolor=colors[i], markersize=5, alpha=0.75)) # plt.legend(loc="lower right", bbox_to_anchor=(0.95, 0.05), handles=legend_elements) if attr_y == 'Beta': plt.yscale('log') elif attr_y == 'norm_food_and_ts_avg_energy': plt.ylim(0, 0.0002) plt.legend(handles=legend_elements) plt.xlabel(attr_x) plt.ylabel(attr_y) plt.savefig(savefilename, dpi=300, bbox_inches='tight') print('Saving figure: {}'.format(savefilename)) plt.show()
sim_name = 'sim-20200621-123120-g_1_-t_30000_-l_sim-20200619-173349-g_2001_-ref_0_-noplt_-b_1_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_2000_-n_random_time_steps_last_gen_very_long_ENERGIES_saved_this_time' sim_name = 'sim-20200621-123007-g_1_-t_30000_-l_sim-20200619-173340-g_2001_-ref_0_-noplt_-b_10_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_2000_-n_random_time_steps_last_gen_very_long_ENERGIES_saved_this_time' sim_name = 'sim-20200622-004643-g_1_-t_500000_-noplt_-l_sim-20200619-173349-g_2001_-ref_0_-noplt_-b_1_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_1999_-n_random_time_steps_super_long_last_gen' #sim_name = 'sim-20200622-004717-g_1_-t_500000_-noplt_-l_sim-20200619-173340-g_2001_-ref_0_-noplt_-b_10_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_1999_-n_random_time_steps_super_long_last_gen' sim_name = 'sim-20200621-224919-g_1_-t_120000_-noplt_-li_1999_-l_sim-20200619-174456-g_2001_-t_6000_-b_10_-dream_c_1000_-ref_0_-noplt_-c_4_-a_2000_-n_long_run_save_energies_-n_long_last_gen_for_6000ts_sim' sim_name = 'sim-20200621-205137-g_1_-t_120000_-li_1999_-l_sim-20200606-014837-g_2000_-t_4000_-b_10_-dream_c_0_-nat_c_0_-ref_0_-rec_c_0_-noplt_-n_energies_velocities_saved_more_time_steps_-noplt_-n_very_long_last_gen_from_4000' sim_name = 'sim-20200621-205137-g_1_-t_120000_-li_1999_-l_sim-20200606-014837-g_2000_-t_4000_-b_10_-dream_c_0_-nat_c_0_-ref_0_-rec_c_0_-noplt_-n_energies_velocities_saved_more_time_steps_-noplt_-n_very_long_last_gen_from_4000' sim_name = 'sim-20200621-205056-g_1_-t_120000_-li_1999_-l_sim-20200606-014815-g_2000_-t_4000_-b_1_-dream_c_0_-nat_c_0_-ref_0_-rec_c_0_-noplt_-n_energies_velocities_saved_more_time_steps_-noplt_-n_very_long_last_gen_from_4000' sim_name = 'sim-20200622-142753-g_1_-t_3000_-noplt_-l_sim-20200619-173349-g_2001_-ref_0_-noplt_-b_1_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_2000_-n_last_gen_random_time_steps_3000ts' #sim_name = 'sim-20200622-142821-g_1_-t_3000_-noplt_-l_sim-20200619-173340-g_2001_-ref_0_-noplt_-b_10_-dream_c_500_-c_4_-a_1995_1996_1997_1998_1999_-n_random_time_steps_save_energies_4_-li_2000_-n_last_gen_random_time_steps_3000ts' sim_name = 'sim-20200621-205137-g_1_-t_120000_-li_1999_-l_sim-20200606-014837-g_2000_-t_4000_-b_10_-dream_c_0_-nat_c_0_-ref_0_-rec_c_0_-noplt_-n_energies_velocities_saved_more_time_steps_-noplt_-n_very_long_last_gen_from_4000' sim_name = 'sim-20200621-205056-g_1_-t_120000_-li_1999_-l_sim-20200606-014815-g_2000_-t_4000_-b_1_-dream_c_0_-nat_c_0_-ref_0_-rec_c_0_-noplt_-n_energies_velocities_saved_more_time_steps_-noplt_-n_very_long_last_gen_from_4000' sim_name = 'sim-20200619-174456-g_2001_-t_6000_-b_10_-dream_c_1000_-ref_0_-noplt_-c_4_-a_2000_-n_long_run_save_energies' #sim_name = 'sim-20200619-174503-g_2001_-t_6000_-b_1_-dream_c_1000_-ref_0_-noplt_-c_4_-a_2000_-n_long_run_save_energies' sim_name = 'sim-20201003-000428-g_4000_-t_2000_-rec_c_1000_-c_props_100_50_-2_2_100_40_-iso_-ref_1000_-c_4_-a_1000_2000_3999_-no_trace_-n_different_betas_2000_fixed_ts_3_COMPARE_and_DYNAMIC_RANGE_FOOD_TS' sim_name = 'sim-20201022-175746-g_1_-energies_0_-t_120000_-li_1999_-l_sim-20201019-153950_parallel_parallel_mean_4000_ts_b10_fixed_ts/sim-20201019-153952-b_10_-g_2000_-t_4000_-noplt_-subfolder_sim-20201019-153950_parallel_parallel_mean_4000_ts_b10_fixed_ts_-n_Run_3_-n_life_time_analysis' sim_name = 'sim-20201026-224709_parallel_b10_fixed_4000ts_/sim-20201026-224711-b_10_-g_8000_-t_4000_-rec_c_2000_-c_props_10_10_-2_2_100_40_-c_1_-subfolder_sim-20201026-224709_parallel_b10_fixed_4000ts_-n_Run_1' sim_name = 'sim-20201026-224709_parallel_b10_fixed_4000ts_/sim-20201026-224711-b_10_-g_8000_-t_4000_-rec_c_2000_-c_props_10_10_-2_2_100_40_-c_1_-subfolder_sim-20201026-224709_parallel_b10_fixed_4000ts_-n_Run_1' win_size = 2000#500#2000#500 settings = load_settings(sim_name) generations = settings['save_energies_velocities_gens'] #np.arange(1990, 2000) last_gen = detect_all_isings(sim_name)[-1] # For last generation velocties are always saved if type(generations) is list: generations.append(last_gen) else: generations = [last_gen] inds = np.arange(10) #inds = [0] main(sim_name, list_attr, generations, inds, win_size)
def create_repeats_parallel(sim_name, settings): settings['loadfile'] = sim_name settings['iter'] = detect_all_isings(sim_name)[-1] pool = Pool(processes=2) pool.map(_run_process, processes)
def main(loadfiles, plot_var, i_type, isings_lists = None, autoLoad = True, sim_labels = [r'$\beta_i = 0.1$', r'$\beta_i = 1$', r'$\beta_i = 10$'], scatter = True): ''' Can either plot one or multiple simulations in a combined plot :param loadfile: save names of simulations; list of strings :param plot_var: isings attribute to ne plotted over generation :param isings_lists: list of isings list (one isings list for each simulation to be plotted) :param autoLoad: If previously plotted should npz file be loaded to speed up process? :param sim_labels: Labels of simulation in plot in case multi_sim = True ''' if type(loadfiles) == str: loadfiles = [loadfiles] if type(isings_lists) == str: isings_lists == [isings_lists] #loadfiles = [loadfile]#loadfiles = ['sim-20191114-000009_server'] #Boo shows whether there are multiple simulations in one plot multiple_sim = len(loadfiles) > 1 #energy_model = settings['energy_model'] #autoLoad = True saveFigBool = True fixGen2000 = False new_order = [2, 0, 1] labels = sim_labels cmap = plt.get_cmap('seismic') norm = colors.Normalize(vmin=0, vmax=len(loadfiles)) # age/color mapping a = 0.15 # alpha ########################### FOODS = [] for loadfile, isings_list in zip(loadfiles, isings_lists): iter_list = detect_all_isings(loadfile, i_type) # iter_list = np.arange(0, 2000, 1) settings = load_settings(loadfile) if i_type == 'pred': numAgents = settings['pop_size_pred'] elif i_type == 'prey': numAgents = settings['pop_size_prey'] f = fitness(loadfile, iter_list, isings_list, numAgents, autoLoad, saveFigBool, plot_var) # FIX THE DOUBLE COUNTING PROBLEM if f.shape[0] > 2000 and fixGen2000: print('Fixing Double Counting at Gen 2000') f[2000, :] = f[2000, :] - f[1999, :] FOODS.append(f) # FIX THE DOUBLE COUNTING OF THE FITNESS plt.rc('text', usetex=True) font = {'family': 'serif', 'size': 28, 'serif': ['computer modern roman']} plt.rc('font', **font) plt.rc('legend', **{'fontsize': 20}) fig, ax = plt.subplots(1, 1, figsize=(19, 10)) fig.text(0.51, 0.035, r'Generation', ha='center', fontsize=20) # fig.text(0.07, 0.5, r'$Avg. Food Consumed$', va='center', rotation='vertical', fontsize=20) fig.text(0.07, 0.5, r'%s' %plot_var.replace('_',' '), va='center', rotation='vertical', fontsize=20) title = '' #'Food consumed per organism' fig.suptitle(title) for i, FOOD in enumerate(FOODS): c = cmap(norm(i)) muF = np.mean(FOOD, axis=1) if scatter: ax.scatter(iter_list, muF, color=c, label=labels[i], alpha=0.15) else: ax.plot(iter_list, muF, color=c, label=labels[i]) if not scatter: sigmaF = FOOD.std(axis=1) ax.fill_between(iter_list, muF + sigmaF, muF - sigmaF, color=c, alpha=a ) custom_legend = [Line2D([0], [0], marker='o', color='w', markerfacecolor=cmap(norm(0)), markersize=15), Line2D([0], [0], marker='o', color='w', markerfacecolor=cmap(norm(1)), markersize=15), Line2D([0], [0], marker='o', color='w', markerfacecolor=cmap(norm(2)), markersize=15),] #Custom legend for multiple runs in one plot removed: if multiple_sim: ax.legend(custom_legend, sim_labels, loc='upper left') #ax.legend(custom_legend, [r'$\beta = 10$', r'$\beta = 1$', r'$\beta = 0.1$'], loc='upper left') if multiple_sim: savefolder = 'multi_sim_plots/' for loadfile in loadfiles: savefolder += loadfile[0:18] + '__' savefolder += '/' else: folder = 'save/' + loadfile if i_type == 'pred': savefolder = folder + '/figs_pred/' + plot_var + '_line/' elif i_type == 'prey': savefolder = folder + '/figs_prey/' + plot_var + '_line/' savefilename = savefolder + plot_var + '_gen' + str(iter_list[0]) + '-' + str(iter_list[-1]) + '.png' if not path.exists(savefolder): makedirs(savefolder) if saveFigBool: plt.savefig(savefilename, bbox_inches='tight', dpi=300) # plt.close() savemsg = 'Saving ' + savefilename print(savemsg) plt.show() # Trying to fix memory leak with this: plt.cla() plt.clf() plt.close('all') ax.clear()
def main(loadfile, settings, isings_list, plot_var_x='avg_velocity', plot_var_y='food', plot_var_c='avg_energy', s=3, alpha=0.8, autoLoad=False, x_lim=None, y_lim=None, log=True, y_noise=True): loadfiles = [loadfile] #loadfiles = ['sim-20191114-000009_server'] iter_list = detect_all_isings( loadfile) # iter_list = np.arange(0, 2000, 1) # energy_model = settings['energy_model'] numAgents = settings['pop_size'] saveFigBool = True # if settings['server_mode']: # plt.rcParams['animation.ffmpeg_path'] = '/data-uwks159/home/jprosi/ffmpeg-4.2.1-linux-64/ffmpeg' # #'/usr/local/bin/ffmpeg' # else: plt.rcParams[ 'animation.ffmpeg_path'] = "D:/Program Files/ffmpeg-20191217-bd83191-win64-static/bin/ffmpeg.exe" new_order = [2, 0, 1] labels = [r'$\beta_i = 0.1$', r'$\beta_i = 1$', r'$\_i = 10$'] cmap = plt.get_cmap('seismic') norm = colors.Normalize(vmin=0, vmax=len(loadfiles)) # age/color mapping # norm = [[194, 48, 32, 255], # [146, 49, 182, 255], # [44, 112, 147, 255] # ] # norm = np.divide(norm, 255) a = 0.15 # alpha x_pars_list, y_pars_list, c_pars_list = fitness(loadfile, iter_list, isings_list, numAgents, autoLoad, saveFigBool, plot_var_x, plot_var_y, plot_var_c) #fig, ax = plt.subplots() fig = plt.figure() if y_noise: y_pars_list = [noise(y_pars) for y_pars in y_pars_list] ani = animation.FuncAnimation( fig, update_plot, fargs=[x_pars_list, y_pars_list, c_pars_list, s, alpha], interval=1, frames=len(x_pars_list)) Writer = animation.FFMpegFileWriter writer = Writer(fps=settings['animation_fps'], metadata=dict(artist='Sina Abdollahi, Jan Prosi'), bitrate=1800) writer.frame_format = 'png' folder = 'save/' + loadfile savefolder = folder + '/scatter_ani' + format( time.strftime("%Y%m%d-%H%M%S") ) + '/' + plot_var_x + '_vs_' + plot_var_y + '_line/' savefilename = savefolder + plot_var_x + '_vs_' + plot_var_y + '_gen' + str( iter_list[0]) + '-' + str(iter_list[-1]) + '.mpg' if not path.exists(savefolder): makedirs(savefolder) ani.save(savefilename, writer=writer) plt.show()