(0.0, 0.25), # D
(0.0, -0.25), # U
(0.25, 0.0), # R
(-0.25, 0.0), # L
(0.1, -0.1), # points right and up #J
(-0.1, 0.1), # points left and down # P
]
dx, dy = dxdy[
action] #dxdy[(action-1)%len(dxdy)] ## use if action-space remapping
head_w, head_l = 0.1, 0.1
return dx, dy, head_w, head_l
grids = get_grids([x[-2:] for x in envs])
convert_rep_to_color = {100: 'C2', 200: 'C9', 300: 'C4', 400: 'C3'}
def get_ec_maps():
ec_maps = {}
example_env = gym.make(envs[0])
plt.close()
for ind, name in enumerate(envs):
ec_maps[name] = {}
for jnd, cache_size in enumerate(master_dict[name].keys()):
print(name, cache_size)
v_list = master_dict[name][cache_size]
policy_map = np.zeros(example_env.shape,
dtype=[(x, 'f8')
'conv': 'latents'
}
reps_to_plot = ['conv', 'structured', 'unstructured']
elif split_type == 'allreps':
color_map = plot_specs['rep_colors']
labels = plot_specs['labels']
reps_to_plot = [
'random', 'onehot', 'conv_latents', 'place_cell', 'analytic successor'
]
envs_to_plot = [
'gridworld:gridworld-v11', 'gridworld:gridworld-v41',
'gridworld:gridworld-v31', 'gridworld:gridworld-v51'
]
pcts_to_plot = [100, 90, 80, 70, 60, 50, 40, 30, 20, 10]
grids = get_grids(envs_to_plot)
#avg_performance_over_envs(gb,envs_to_plot,reps_to_plot,pcts_to_plot,grids,colors=color_map,labels=labels,legend='pcts',savename=f'restricted_{split_type}_bars',save=True)
avg_perf_over_envs_lines(gb,
envs_to_plot,
reps_to_plot,
pcts_to_plot,
grids,
colors=color_map,
labels=labels,
legend='reps',
save=True,
savename=f'restricted_{split_type}_lines',
compare_chance=True)
#avg_performance_over_envs_violins(gb,envs_to_plot,reps_to_plot,pcts_to_plot,grids,colors=color_map,labels=labels,legend='reps',savename=f'restricted_{split_type}_violins_inset',compare_chance=False,save=True)
#df = pd.read_csv('../../Data/head_only_retrain.csv')
envs = df.env_name.unique()
reps = df.representation.unique()
print(reps)
envs = np.delete(envs, np.where(envs == 'gridworld:gridworld-v2'))
print('#####', envs)
groups_to_split = ['env_name', 'representation', 'extra_info']
df_gb = df.groupby(groups_to_split)["save_id"]
envs = [
'gridworld:gridworld-v1', 'gridworld:gridworld-v4',
'gridworld:gridworld-v3', 'gridworld:gridworld-v5'
]
grids = get_grids(envs)
labels_for_plot = {
'conv': 'Partially Observable State',
'reward_conv': 'Fully Observable State',
'onehot': 'Unstructured',
'analytic successor': 'Structured'
}
rep_to_col = {
'conv': 'purple',
'reward_conv': 'orange',
'onehot': 'blue',
'analytic successor': 'red'
}
def plot_train_test(df, envs, reps, save=False):
sys.path.append('../../modules/')
from Analysis.analysis_utils import get_avg_std, get_id_dict, get_grids
from Utils import running_mean as rm
data_dir = '../../Data/results/'
df = pd.read_csv('../../Data/conv_mf_training.csv')
#df = pd.read_csv('../../Data/head_only_retrain.csv')
envs = df.env_name.unique()
reps = df.representation.unique()
print(reps)
envs = np.delete(envs, np.where(envs == 'gridworld:gridworld-v2'))
print('#####', envs)
master_dict = get_id_dict(df)
grids = get_grids([1, 3, 4, 5])
labels_for_plot = {
'conv': 'Partially Observable State',
'reward_conv': 'Fully Observable State'
}
def plot_all(save=True, cutoff=25000):
fig, axs = plt.subplots(4, 2, sharex='col')
for i in range(len(grids)):
rect = plt.Rectangle((5, 5), 1, 1, color='g', alpha=0.3)
axs[i, 0].pcolor(grids[i],
cmap='bone_r',
edgecolors='k',
linewidths=0.1)
ax.invert_yaxis()
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
plt.suptitle(f'{plot_name}')
plt.tight_layout()
if save:
save_format = 'svg'
plt.savefig(f'../figures/CH2/mem_map_{env_num}.{save_format}',
format=save_format)
#plt.show()
version = 1
env_name = f'gridworld:gridworld-v{version}1'
grid = get_grids(env_name[-2:])[0]
pcts_to_plot = [100, 75, 50, 25]
reps_to_plot = ['random', 'analytic successor', 'onehot', 'place_cell']
for rep in reps_to_plot:
ind = 0
maps_dict = {}
for pct in pcts_to_plot:
mm = get_mem_map(gb, env_name, rep, pct, ind)
maps_dict[pct] = mm
plt_prefpol(version, grid, maps_dict, plot_name=rep)
plt.show()
def plot_all_maxpol(save=False):
fig, axs = plt.subplots(4, 5, sharex='col')
cmap = plt.cm.Spectral_r
data_dir = '../../Data/results/'
filename = 'conv_head_only_retrain' #'empty_head_only_retrain'
df = pd.read_csv(f'../../Data/{filename}.csv')
envs = df.env_name.unique()
reps = df.representation.unique()
lrs = df.MF_lr.unique()
envs = np.delete(envs, np.where(envs == 'gridworld:gridworld-v2'))
print(df)
gb = df.groupby(['env_name', 'representation',
'MF_lr'])["save_id"] #.apply(list)
for key, item in gb:
print(key, list(item))
print(list(gb.get_group(('gridworld:gridworld-v31', 'conv_latents', 0.001))))
grids = get_grids([11, 31, 41, 51])
labels_for_plot = {
'conv_latents': 'Partially Observable State',
'rwd_conv_latents': 'Fully Observable State'
} # for empty_head_only_retrain
def plot_all(save=True, cutoff=25000):
rep_to_plot = 'conv_latents'
fig, axs = plt.subplots(4, 3, sharex='col')
for i in range(len(grids)):
rect = plt.Rectangle((14, 14), 1, 1, color='g', alpha=0.3)
axs[i, 0].pcolor(grids[i],
cmap='bone_r',
edgecolors='k',
linewidths=0.1)
def plot_perceptron(df, envs_to_plot, reps_to_plot):
grids = get_grids(envs_to_plot)
fig, ax = plt.subplots(len(envs_to_plot), 2, sharey='col', sharex='col')
for e, env in enumerate(envs_to_plot):
scaling_factor = analysis_specs['avg_max_rwd'][env + '1']
if env[-1] == '5':
rwd_colrow0 = (3, 9)
rwd_colrow1 = (16, 9)
else:
rwd_colrow0 = (5, 5)
rwd_colrow1 = (14, 14)
rect0 = plt.Rectangle(rwd_colrow0,
1,
1,
facecolor='gray',
edgecolor=None,
alpha=0.3)
rect1 = plt.Rectangle(rwd_colrow1,
1,
1,
facecolor='g',
edgecolor=None,
alpha=0.3)
ax[e, 0].pcolor(grids[e],
cmap='bone_r',
edgecolors='k',
linewidths=0.1)
ax[e, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
ax[e, 0].set_aspect('equal')
ax[e, 0].add_patch(rect0)
ax[e, 0].add_patch(rect1)
ax[e, 0].get_xaxis().set_visible(False)
ax[e, 0].get_yaxis().set_visible(False)
ax[e, 0].invert_yaxis()
for r, rep in enumerate(reps_to_plot):
id_list = list(df_gb.get_group((env + '1', rep, 10000)))
print(env, rep, len(id_list))
total_avg_reward = []
for i, id_num in enumerate(id_list):
# get training data
train_dat_id = list(
df.loc[df['save_id'] == id_num]['load_from'])[0]
with open(parent_path + f'results/{train_dat_id}_data.p',
'rb') as f:
dats = pickle.load(f)
raw_score = dats['total_reward'][0:5000]
training_transformed = (np.asarray(raw_score) +
2.5) / (scaling_factor + 2.5)
with open(parent_path + f'results/{id_num}_data.p', 'rb') as f:
dats = pickle.load(f)
scaled_ = (np.asarray(dats['total_reward']) +
2.5) / (scaling_factor + 2.5)
train_test = np.concatenate((training_transformed, scaled_))
total_avg_reward.append(rm(train_test, 200))
mean = np.mean(total_avg_reward, axis=0)
stand = np.std(total_avg_reward, axis=0) / np.sqrt(
len(total_avg_reward))
print(len(mean))
#for j in total_avg_reward:
#ax[e,r].plot(j)
ax[e, 1].set_ylim([0, 1.1])
ax[e, 1].set_yticks([0, 1])
ax[e, 1].set_yticklabels([0, 100])
ax[e, 1].set_ylabel('Performance \n(% Optimal)')
ax[e, 1].plot(mean, color=col_to_plot[rep])
ax[e, 1].fill_between(np.arange(len(mean)),
mean - stand,
mean + stand,
color=col_to_plot[rep],
alpha=0.2)
#ax[0,r].set_title(rep)
plt.savefig('../figures/CH1/perceptron_FC.svg')
plt.show()
def plot_shallow(
df,
envs_to_plot,
reps_to_plot,
):
upper_limit = 30000
grids = get_grids(envs_to_plot)
groups_to_split = ['env_name', 'representation', 'extra_info']
df_gb = df.groupby(groups_to_split)["save_id"]
fig, ax = plt.subplots(len(envs_to_plot), 2, sharey='col', sharex='col')
ftsz = 8
for e, env in enumerate(envs_to_plot):
scaling_factor = analysis_specs['avg_max_rwd'][env + '1']
if env[-1] == '5':
rwd_colrow0 = (3, 9)
rwd_colrow1 = (16, 9)
else:
rwd_colrow0 = (5, 5)
rwd_colrow1 = (14, 14)
rect0 = plt.Rectangle(rwd_colrow0,
1,
1,
facecolor='gray',
edgecolor=None,
alpha=0.5)
rect1 = plt.Rectangle(rwd_colrow1,
1,
1,
facecolor='g',
edgecolor=None,
alpha=0.3)
ax[e, 0].pcolor(grids[e],
cmap='bone_r',
edgecolors='k',
linewidths=0.1)
ax[e, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
ax[e, 0].set_aspect('equal')
ax[e, 0].add_patch(rect0)
ax[e, 0].add_patch(rect1)
ax[e, 0].get_xaxis().set_visible(False)
ax[e, 0].get_yaxis().set_visible(False)
ax[e, 0].invert_yaxis()
for r, rep in enumerate(reps_to_plot):
id_list = list(df_gb.get_group((env, rep, 'x')))
print(env, rep, len(id_list))
total_avg_reward = []
for i, id_num in enumerate(id_list):
with open(parent_path + f'results/{id_num}_data.p', 'rb') as f:
dats = pickle.load(f)
scaled_ = (np.asarray(dats['total_reward']) +
2.5) / (scaling_factor + 2.5)
if len(scaled_) < upper_limit:
print('hello', len(scaled_))
num_extras = upper_limit - len(scaled_)
last_200_mean = np.mean(scaled_[-200:])
last_200_std = np.std(scaled_[-200:])
filler = np.random.normal(last_200_mean, last_200_std,
num_extras)
nans = np.zeros(num_extras)
nans[:] = np.nan
if last_200_mean > 0.95:
scaled_ = np.concatenate((scaled_, filler))
else:
scaled_ = np.concatenate((scaled_, nans))
else:
print(len(scaled_))
total_avg_reward.append(scaled_)
mean = rm(np.nanmean(total_avg_reward, axis=0), 200)
stand = rm(
np.nanstd(total_avg_reward, axis=0) /
np.sqrt(len(total_avg_reward)), 200)
print(len(mean))
ax[e, 1].set_ylim([0, 1.1])
ax[e, 1].set_yticks([0, 1])
ax[e, 1].set_yticklabels([0, 100], fontsize=ftsz)
ax[e, 1].set_ylabel('Performance \n(% Optimal)', fontsize=ftsz)
#for index, x in enumerate(total_avg_reward):
# ax[e,r+1].plot(rm(x,200), label=f'{id_list[index][0:8]}')
#ax[e,r+1].legend(loc=0)
ax[e, 1].plot(mean, color=col_to_plot[rep])
ax[e, 1].fill_between(np.arange(len(mean)),
mean - stand,
mean + stand,
color=col_to_plot[rep],
alpha=0.2)
ax[e, 1].set_xlabel('Episodes', fontsize=ftsz)
ax[e, 1].set_xticks([0, 10000, 20000, 30000])
ax[e, 1].set_xticklabels([0, 10000, 20000, 30000], fontsize=ftsz)
plt.savefig('../figures/CH1/shallow_FC.svg')
plt.show()
