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
