def plot_throttled_performance():
fig, ax = plt.subplots(3,
2,
figsize=(15, 3),
sharex='col',
gridspec_kw={'width_ratios': [1, 3]})
if env[-2:] == '51':
rwd_colrow = (16, 9)
else:
rwd_colrow = (14, 14)
rect = plt.Rectangle(rwd_colrow, 1, 1, color='g', alpha=0.3)
ax[0, 0].pcolor(e_grid, cmap='bone_r', edgecolors='k', linewidths=0.1)
ax[0, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
ax[0, 0].set_aspect('equal')
ax[0, 0].add_patch(rect)
ax[0, 0].get_xaxis().set_visible(False)
ax[0, 0].get_yaxis().set_visible(False)
ax[0, 0].invert_yaxis()
ax[1, 0].axis('off')
ax[2, 0].axis('off')
for g, gb in enumerate(gbs):
for r, rep in enumerate(reps_to_plot):
# ax[0,j] plot average performance with error bars
# ax[1,j] plot variance of differnt rep types
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list, cutoff=5000, smoothing=100)
avg_cos, std_cos = np.mean(avg_), np.mean(std_)
ax[g, 1].bar(2 * r + 0.35 * j,
avg_cos,
yerr=std_cos,
width=0.35,
color=convert_rep_to_color[rep],
alpha=pct / 100)
ax[g, 1].set_ylim([0, 12])
ax[g, 1].set_xticks(np.arange(0, 2 * len(reps_to_plot), 2) + 0.5)
ax[g, 1].set_xticklabels(rep_labels, rotation=0)
ax[g, 1].set_ylabel(f'{dist[g]}')
#ax[1].axhline(y=avg_max_rwd[env[-2:]], color='r', linestyle='--')
p100 = mpatches.Patch(color='gray', alpha=1, label='100')
p75 = mpatches.Patch(color='gray', alpha=0.75, label='75')
p50 = mpatches.Patch(color='gray', alpha=.5, label='50')
p25 = mpatches.Patch(color='gray', alpha=.25, label='25')
plt.legend(handles=[p100, p75, p50, p25],
bbox_to_anchor=(1.01, 1),
loc='upper left',
ncol=1,
title='Episodic Memory\nCapacity (%)')
plt.show()
def plot_all(save=False, cutoff=25000, smoothing=5000):
fig, axs = plt.subplots(4, 3, sharex='col')
for i in range(len(grids)):
rect = plt.Rectangle((15,15), 1, 1, color='g', alpha=0.3)
axs[i,0].pcolor(grids[i],cmap='bone_r',edgecolors='k', linewidths=0.1)
axs[i,0].axis(xmin=0, xmax=20, ymin=0,ymax=20)
axs[i,0].set_aspect('equal')
axs[i,0].add_patch(rect)
axs[i,0].get_xaxis().set_visible(False)
axs[i,0].get_yaxis().set_visible(False)
axs[i,0].invert_yaxis()
for ind, name in enumerate(envs):
for jnd, rep_to_plot in enumerate(reps):
v_list = master_dict[name][rep_to_plot]
for i in v_list:
print(i[0:8])
if i[0:8] in ['69aa8807','9ea97939']:
v_list.remove(i)
avg_, std_ = get_avg_std(v_list,cutoff=cutoff, smoothing=smoothing)
axs[ind,jnd+1].plot(avg_, label=f'{labels_for_plot[rep_to_plot]}',color=convert_rep_to_color[rep_to_plot]) # label=f'n={len(v_list)}'
axs[ind,jnd+1].fill_between(np.arange(len(avg_)),avg_-std_, avg_+std_, alpha=0.1,color=convert_rep_to_color[rep_to_plot])
# compare w
v_list = slave_dict1[name][convert_conv_head_to_ec_labels[rep_to_plot]]
avg_, std_ = get_avg_std(v_list,cutoff=cutoff, smoothing=smoothing)
axs[ind,jnd+1].plot(avg_, ':', color=convert_rep_to_color[rep_to_plot], alpha=0.5) # label=f'n={len(v_list)}'
#axs[ind,1].fill_between(np.arange(len(avg_)),avg_-std_, avg_+std_, alpha=0.3)
v_list = slave_dict2[name][rep_to_plot]
avg_, std_ = get_avg_std(v_list,cutoff=cutoff, smoothing=smoothing)
axs[ind,jnd+1].plot(avg_, ':', color='gray', alpha=0.3) # label=f'n={len(v_list)}'
axs[ind,jnd+1].set_ylim([-4,12])
#axs[ind,1].legend(loc=0)
if ind == len(envs)-1:
axs[ind,1].set_xlabel('Episodes')
#axs[ind,1].set_ylabel('Cumulative \nReward')
axs[0,1].legend(loc='upper center', ncol=1, bbox_to_anchor=(0.2,1.1))
axs[0,2].legend(loc='upper center', ncol=1, bbox_to_anchor=(0.2,1.1))
if save:
plt.savefig('../figures/CH1/ec_testing.svg',format='svg')
plt.show()
def plot_dist_comparison():
fig, ax = plt.subplots(len(reps_to_plot),
len(pcts_to_plot) + 1,
figsize=(15, 3),
sharex='col')
if env[-2:] == '51':
rwd_colrow = (16, 9)
else:
rwd_colrow = (14, 14)
rect = plt.Rectangle(rwd_colrow, 1, 1, color='g', alpha=0.3)
ax[0, 0].pcolor(e_grid, cmap='bone_r', edgecolors='k', linewidths=0.1)
ax[0, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
ax[0, 0].set_aspect('equal')
ax[0, 0].add_patch(rect)
ax[0, 0].get_xaxis().set_visible(False)
ax[0, 0].get_yaxis().set_visible(False)
ax[0, 0].invert_yaxis()
for g, gb in enumerate(gbs):
for r, rep in enumerate(reps_to_plot):
if r == 0:
pass
else:
ax[r, 0].axis('off')
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list, cutoff=5000, smoothing=100)
avg_cos, std_cos = np.mean(avg_), np.mean(std_)
ax[r, j + 1].bar(g,
avg_cos,
yerr=std_cos,
width=1,
color=convert_rep_to_color[rep],
alpha=(g + 1) / 4)
ax[r, j + 1].set_ylim([0, 12])
ax[r, j + 1].set_xticks(np.arange(3))
if r == 0:
ax[r, j + 1].set_title(f'{pct}')
if r == len(reps_to_plot) - 1:
ax[r, j + 1].set_xticklabels(dist, rotation=0)
ax[r, 1].set_ylabel(f'{labels_for_plot[rep]}')
plt.show()
def plot_throttled_performance(gb,envs_to_plot,reps_to_plot,pcts_to_plot,grids,save=False):
fig, ax = plt.subplots(len(envs_to_plot),2,figsize=(12,3*len(envs_to_plot)), sharex='col', gridspec_kw={'width_ratios': [1, 2]})
for i, env in enumerate(envs_to_plot):
if env[-2:] == '51':
rwd_colrow= (16,9)
else:
rwd_colrow=(14,14)
rect = plt.Rectangle(rwd_colrow, 1, 1, color='g', alpha=0.3)
ax[i,0].pcolor(grids[i],cmap='bone_r',edgecolors='k', linewidths=0.1)
ax[i,0].axis(xmin=0, xmax=20, ymin=0,ymax=20)
ax[i,0].set_aspect('equal')
ax[i,0].add_patch(rect)
ax[i,0].get_xaxis().set_visible(False)
ax[i,0].get_yaxis().set_visible(False)
ax[i,0].invert_yaxis()
for r, rep in enumerate(reps_to_plot):
# ax[0,j] plot average performance with error bars
# ax[1,j] plot variance of differnt rep types
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
normalization_factor = avg_max_rwd[env[-2:]]
avg_, std_ = get_avg_std(v_list,normalization_factor=normalization_factor,cutoff=5000, smoothing=100)
avg_cos, std_cos = np.mean(avg_), np.mean(std_)
ax[i,1].bar(2*r+0.35*j,avg_cos, yerr=std_cos,width=0.35,color=convert_rep_to_color[rep], alpha=pct/100)
ax[i,1].set_ylim([0,1.2])
ax[i,1].set_yticks(np.arange(0,1.5,0.25))
ax[i,1].set_yticklabels([0,'',50,'',100,''])
ax[i,1].set_ylabel('% Optimal Performance')
ax[i,1].set_xticks(np.arange(0,2*len(reps_to_plot),2)+0.5)
ax[i,1].set_xticklabels(rep_labels,rotation=0)
#ax[1].axhline(y=avg_max_rwd[env[-2:]], color='r', linestyle='--')
p100 = mpatches.Patch(color='gray',alpha=1, label='100')
p75 = mpatches.Patch(color='gray',alpha=0.75, label='75')
p50 = mpatches.Patch(color='gray',alpha=.5, label='50')
p25 = mpatches.Patch(color='gray',alpha=.25, label='25')
#plt.legend(handles=[p100,p75,p50,p25], bbox_to_anchor=(0.5, len(envs_to_plot)*1.1), loc='lower center', ncol=4, title='Episodic Memory Capacity (%)')
ax[0,1].set_title("Limited Capacity with Structured Representations")
if save:
format = 'svg'
plt.savefig(f'../figures/CH2/forgetting_structured.{format}', format=format)
plt.show()
def plot_3d_avg_var():
for i, env in enumerate(envs_to_plot):
fig = plt.figure()
ax = plt.axes(projection='3d')
for r, rep in enumerate(reps_to_plot):
avg_rwd_var =[[],[]]
# ax[0,j] plot performance curves
# ax[1,j] plot variance of differnt rep types
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list,cutoff=5000, smoothing=100)
avg_rwd_var[0].append(np.mean(avg_))
avg_rwd_var[1].append(np.mean(std_))
print(avg_rwd_var[0],avg_rwd_var[1], 'avg vs std')
ax.plot3D(pcts_to_plot,avg_rwd_var[1], avg_rwd_var[0],'o-',color=convert_rep_to_color[rep])
plt.show()
def plot_throttled_performance():
for i, env in enumerate(envs_to_plot):
fig, ax = plt.subplots(2,len(pcts_to_plot)+1)
tmp_env_obj = gym.make(env)
e_grid = tmp_env_obj.grid
if env[-2:] == '51':
rwd_colrow= (16,9)
else:
rwd_colrow=(14,14)
rect = plt.Rectangle(rwd_colrow, 1, 1, color='g', alpha=0.3)
ax[0,0].pcolor(e_grid,cmap='bone_r',edgecolors='k', linewidths=0.1)
ax[0,0].axis(xmin=0, xmax=20, ymin=0,ymax=20)
ax[0,0].set_aspect('equal')
ax[0,0].add_patch(rect)
ax[0,0].get_xaxis().set_visible(False)
ax[0,0].get_yaxis().set_visible(False)
ax[0,0].invert_yaxis()
for r, rep in enumerate(reps_to_plot):
avg_rwd_var =[[],[]]
# ax[0,j] plot performance curves
# ax[1,j] plot variance of differnt rep types
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list,cutoff=5000, smoothing=100)
ax[0,j+1].plot(avg_, label=f'{labels_for_plot[rep]}',color=convert_rep_to_color[rep])
ax[0,j+1].fill_between(np.arange(len(avg_)),avg_-std_, avg_+std_, color=convert_rep_to_color[rep],alpha=0.3)
ax[0,j+1].set_ylim([-4,12])
ax[0,j+1].set_title(f'{pct}')
ax[1,j+1].bar(r, np.mean(std_),label=f'{labels_for_plot[rep]}', color=convert_rep_to_color[rep])
ax[1,j+1].set_ylim([0,6])
avg_rwd_var[0].append(np.mean(avg_))
avg_rwd_var[1].append(np.mean(std_))
print(avg_rwd_var[0],avg_rwd_var[1], 'avg vs std')
ax[1,0].plot(avg_rwd_var[1], avg_rwd_var[0],'o-',color=convert_rep_to_color[rep])
ax[1,-1].legend(bbox_to_anchor =(1.1,-.05), ncol=len(reps_to_plot))
plt.show()
def plot_all(save=False, 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)
axs[i, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
axs[i, 0].set_aspect('equal')
axs[i, 0].add_patch(rect)
axs[i, 0].get_xaxis().set_visible(False)
axs[i, 0].get_yaxis().set_visible(False)
axs[i, 0].invert_yaxis()
for ind, name in enumerate(envs):
for rep_to_plot in reps:
v_list = list(df_gb.get_group((name, rep_to_plot, 'x')))
for i in v_list:
print(i[0:8])
if i[0:8] in ['69aa8807', '9ea97939']:
v_list.remove(i)
avg_, std_ = get_avg_std(v_list, cutoff=cutoff, smoothing=200)
axs[ind, 1].plot(avg_, label=f'{labels_for_plot[rep_to_plot]}')
axs[ind, 1].fill_between(np.arange(len(avg_)),
avg_ - std_ / np.sqrt(len(v_list)),
avg_ + std_ / np.sqrt(len(v_list)),
alpha=0.3)
axs[ind, 1].set_ylim([-4, 12])
if ind == len(envs) - 1:
axs[ind, 1].set_xlabel('Episodes')
#axs[ind,1].set_ylabel('Cumulative \nReward')
axs[0, 1].legend(loc='upper center', ncol=1, bbox_to_anchor=(0.2, 1.1))
if save:
plt.savefig('../figures/CH1/conv_retraining.svg', format='svg')
plt.show()
#plot_all(cutoff=25000)
def plot_all(save=False):
fig, axs = plt.subplots(4, 2, sharex='col')
#rect = plt.Rectangle((5,5), 1, 1, color='r', alpha=0.3)
for i in range(len(grids)):
rect = plt.Rectangle((15,15), 1, 1, color='g', alpha=0.3)
axs[i,0].pcolor(grids[i],cmap='bone_r',edgecolors='k', linewidths=0.1)
axs[i,0].axis(xmin=0, xmax=20, ymin=0,ymax=20)
axs[i,0].set_aspect('equal')
axs[i,0].add_patch(rect)
axs[i,0].invert_yaxis()
for ind, name in enumerate(envs):
for rep_to_plot in reps:
v_list = master_dict[name][rep_to_plot]
avg_, std_ = get_avg_std(v_list,cutoff=5000)
axs[ind,1].plot(avg_, label=f'{rep_to_plot}')
axs[ind,1].fill_between(np.arange(len(avg_)),avg_-std_, avg_+std_, alpha=0.3)
if ind == len(envs)-1:
axs[ind,1].set_xlabel('Episodes')
axs[ind,1].set_ylabel('Cumulative \nReward')
axs[0,1].legend(loc='upper center', ncol=2, bbox_to_anchor = (0.1,1.1))
if save:
plt.savefig('../figures/CH1/conv_training.svg',format='svg')
plt.show()
env_names = [
'gridworld:gridworld-v1', 'gridworld:gridworld-v4',
'gridworld:gridworld-v3', 'gridworld:gridworld-v5'
]
test_env_names = [
'gridworld:gridworld-v11', 'gridworld:gridworld-v41',
'gridworld:gridworld-v31', 'gridworld:gridworld-v51'
]
fig, ax = plt.subplots(4, 1)
env_number = 1
print(ids2[test_env_names[env_number]])
list_of_representations = ['saved_latents']
for ind, rep_str in enumerate(list_of_representations):
print(rep_str)
av, sd = get_avg_std(ids2[test_env_names[env_number]][rep_str],
cutoff=5000)
ax[0].plot(av, label=rep_str)
ax[0].fill_between(np.arange(len(av)), av - sd, av + sd, alpha=0.3)
#ax[1].bar(ind,np.mean(sd))
ax[0].legend(loc=0)
#plt.ylim([-4,12])
plt.show()
df = pd.read_csv('../../Data/head_only_retrain.csv')
master_dict = {}
envs = df.env_name.unique()
reps = df.representation.unique()
for env in envs:
def plot_throttled_performance():
fig, ax = plt.subplots(2, len(pcts_to_plot) + 1)
if env[-2:] == '51':
rwd_colrow = (16, 9)
else:
rwd_colrow = (14, 14)
rect = plt.Rectangle(rwd_colrow, 1, 1, color='g', alpha=0.3)
ax[0, 0].pcolor(e_grid, cmap='bone_r', edgecolors='k', linewidths=0.1)
ax[0, 0].axis(xmin=0, xmax=20, ymin=0, ymax=20)
ax[0, 0].set_aspect('equal')
ax[0, 0].add_patch(rect)
ax[0, 0].get_xaxis().set_visible(False)
ax[0, 0].get_yaxis().set_visible(False)
ax[0, 0].invert_yaxis()
for r, rep in enumerate(reps_to_plot):
avg_rwd_var = [[], []]
# ax[0,j] plot average performance with error bars
# ax[1,j] plot variance of differnt rep types
for j, pct in enumerate(pcts_to_plot):
v_list = list(gb_cos.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list, cutoff=5000, smoothing=100)
avg_cos, std_cos = np.mean(avg_), np.mean(std_)
ax[0, j + 1].bar(2 * r + 0.5,
avg_cos,
yerr=std_cos,
width=0.5,
color=convert_rep_to_color[rep],
alpha=0.5)
v_list = list(gb_euc.get_group((env, rep, cache_limits[env][pct])))
print(env, rep, pct, v_list)
avg_, std_ = get_avg_std(v_list, cutoff=5000, smoothing=100)
avg_euc, std_euc = np.mean(avg_), np.mean(std_)
ax[0, j + 1].bar(2 * r,
avg_euc,
yerr=std_euc,
width=0.5,
color=convert_rep_to_color[rep],
alpha=1)
ax[0, j + 1].set_ylim([0, 15])
ax[0, j + 1].set_title(f'{pct}')
ax[0, j + 1].set_xticks([0, 2, 4, 6])
ax[0, j + 1].set_xticklabels(rep_labels, rotation=315)
ax[1, j + 1].scatter(avg_cos,
std_cos,
color=convert_rep_to_color[rep],
alpha=0.5)
ax[1, j + 1].scatter(avg_euc,
std_euc,
color=convert_rep_to_color[rep],
alpha=1)
ax[1, j + 1].set_xlim([0, 10])
ax[1, j + 1].set_ylim([0, 6])
ax[1, 0].axis('off')
ax[1, -1].legend(bbox_to_anchor=(1.1, -.05), ncol=len(reps_to_plot))
plt.show()
'gridworld:gridworld-v31', 'gridworld:gridworld-v51'
]
'''
grids = []
for ind, environment_to_plot in enumerate(env_names):
env = gym.make(environment_to_plot)
plt.close()
grids.append(env.grid)
'''
fig, ax = plt.subplots(1, 2)
env_number = 1
print(ids2[test_env_names[env_number]])
for ind, rep_str in enumerate(df2.representation.unique()):
print(rep_str)
av, sd = get_avg_std(ids2[test_env_names[env_number]][rep_str],
cutoff=25000)
ax[0].plot(av, label=rep_str)
ax[0].fill_between(np.arange(len(av)), av - sd, av + sd, alpha=0.3)
ax[1].bar(ind, np.mean(sd))
ax[0].legend(loc=0)
#plt.ylim([-4,12])
plt.show()
### JUNKYARD
'''
reps = df1.representation.unique()
print(reps)
fig, ax = plt.subplots(1,2, sharey=True)
env_number = 1
for rep_str in reps:
