def dynamic_pipeline_all_sims(folder_names, pipeline_settings):
for folder_name in folder_names:
sim_names = all_sim_names_in_parallel_folder(folder_name)
if not pipeline_settings['parallelize_each_sim']:
for i, sim_name in enumerate(sim_names):
if pipeline_settings['only_plot_certain_num_of_simulations'] is None:
dynamic_pipeline_one_sim(sim_name, pipeline_settings)
elif pipeline_settings['only_plot_certain_num_of_simulations'] > i:
dynamic_pipeline_one_sim(sim_name, pipeline_settings)
else:
all_sim_names = np.array([])
for folder_name in folder_names:
sim_names = all_sim_names_in_parallel_folder(folder_name)
all_sim_names = np.append(all_sim_names, sim_names)
ray.init(num_cpus=pipeline_settings['cores'])
ray_funcs = [dynamic_pipeline_one_sim_remote_memory.remote(sim_name, pipeline_settings)for sim_name in all_sim_names]
ray.get(ray_funcs)
ray.shutdown()
def recreate_sim_name_for_alternativ_folder(sim_data, alternative_folder_name, plot_settings):
sim_names = all_sim_names_in_parallel_folder(alternative_folder_name)
for it_sim_name in sim_names:
if 'Run_{}'.format(sim_data.sim_num) in it_sim_name:
return it_sim_name
raise Exception('No simulation found with "Run_{}" in {} out of {}'.format(sim_data.sim_num, alternative_folder_name, sim_names))
def prepare_data(folder_name_dict, plot_settings):
sim_data_list_each_folder = []
# All folder list dicts (sub critical or critical?)
for key in folder_name_dict:
folder_name_includes_dict = folder_name_dict[key]
# Iteration through all folder names
for folder_num_in_key, folder_name in enumerate(folder_name_includes_dict):
dynamic_range_folder_includes_list = folder_name_includes_dict[folder_name]
# Iterationg through all "dynamic_range_folder_includes", so basically through each specified run of the dynamic_range_pipeline
for dynamic_range_folder_includes_index, dynamic_range_folder_includes in enumerate(dynamic_range_folder_includes_list):
sim_names = all_sim_names_in_parallel_folder(folder_name)
attrs_food_num_lists_each_sim = []
# Iterating through each simulation
for sim_name in sim_names:
attrs_list_each_food_num_all, food_num_list = load_data(sim_name, folder_name,
dynamic_range_folder_includes, plot_settings)
sim_data = ResponseCurveSimData(sim_name, folder_name, key, folder_num_in_key,
attrs_list_each_food_num_all, food_num_list,
dynamic_range_folder_includes, dynamic_range_folder_includes_index)
attrs_food_num_lists_each_sim.append(sim_data)
sim_data_list_each_folder.append(attrs_food_num_lists_each_sim)
return sim_data_list_each_folder
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 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 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 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)
