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()
