sup_epoch=supervised_epoch,
n_param=n_param,
n_branch=n_branch,
pad_len=pad_len_load,
def_prob=def_prob,
n_def_tps=n_def_tps,
enc_size=enc_size,
attach_cond=attach_cond,
penalty=penalty_train,
p_rm_ob_enc=p_rm_ob_enc_load,
p_rm_ob_rcl=p_rm_ob_rcl_load,
)
# create logging dirs
log_path, log_subpath = build_log_path(subj_id,
p,
log_root=log_root,
mkdir=False,
verbose=True)
# init env
env_data = load_env_metadata(log_subpath)
def_path = env_data['def_path']
p.env.def_path = def_path
p.update_enc_size(enc_size_test)
task = SequenceLearning(
n_param=p.env.n_param,
n_branch=p.env.n_branch,
p_rm_ob_enc=p_test,
p_rm_ob_rcl=p_test,
similarity_cap_lag=p.n_event_remember,
n_hidden=n_hidden,
n_hidden_dec=n_hidden_dec,
lr=learning_rate,
eta=eta,
)
# init env
task = SequenceLearning(
n_param=p.env.n_param,
n_branch=p.env.n_branch,
pad_len=pad_len_test,
p_rm_ob_enc=p_rm_ob_enc_test,
p_rm_ob_rcl=p_rm_ob_rcl_test,
)
# create logging dirs
log_path, log_subpath = build_log_path(subj_id,
p,
log_root=log_root,
verbose=False)
test_params = [penalty_test, pad_len_test, slience_recall_time]
test_data_dir, test_data_subdir = get_test_data_dir(
log_subpath, epoch_load, test_params)
test_data_fname = get_test_data_fname(n_examples_test, fix_cond)
fpath = os.path.join(test_data_dir, test_data_fname)
test_data_dict = pickle_load_dict(fpath)
results = test_data_dict['results']
XY = test_data_dict['XY']
[dist_a_, Y_, log_cache_, log_cond_] = results
[X_raw, Y_raw] = XY
factor=1 / 2,
patience=30,
threshold=1e-3,
min_lr=1e-8,
verbose=True)
optimizer_rl = torch.optim.Adam(agent.parameters(), lr=p.net.lr)
scheduler_rl = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer_rl,
factor=1 / 2,
patience=30,
threshold=1e-3,
min_lr=1e-8,
verbose=True)
# create logging dirs
log_path, log_subpath = build_log_path(subj_id, p, log_root=log_root)
# save experiment params initial weights
save_all_params(log_subpath['data'], p)
save_ckpt(0, log_subpath['ckpts'], agent, optimizer_sup)
'''task definition'''
log_freq = 200
Log_loss_critic = np.zeros(n_epoch, )
Log_loss_actor = np.zeros(n_epoch, )
Log_loss_sup = np.zeros(n_epoch, )
Log_return = np.zeros(n_epoch, )
Log_pi_ent = np.zeros(n_epoch, )
Log_acc = np.zeros((n_epoch, task.n_parts))
Log_mis = np.zeros((n_epoch, task.n_parts))
Log_dk = np.zeros((n_epoch, task.n_parts))
Log_cond = np.zeros((n_epoch, n_examples))
lca_param = {ptest: None for ptest in penaltys_test}
auc = {ptest: None for ptest in penaltys_test}
acc = {ptest: None for ptest in penaltys_test}
mis = {ptest: None for ptest in penaltys_test}
dk = {ptest: None for ptest in penaltys_test}
ma_lca = defaultdict()
ma_cosine = defaultdict()
# for penalty_train in penaltys_train:
for ptest in penaltys_test:
print(f'penalty_train={penalty_train}, ptest={ptest}')
# create logging dirs
log_path, _ = build_log_path(0,
p,
log_root=log_root,
mkdir=False,
verbose=False)
# load data
dir_all_subjs = os.path.dirname(log_path)
fname = 'p%d-%d.pkl' % (penalty_train, ptest)
data = pickle_load_dict(os.path.join(dir_all_subjs, fname))
# unpack data
lca_param[ptest] = data['lca_param_dicts']
auc[ptest] = data['auc_list']
acc[ptest] = data['acc_dict']
mis[ptest] = data['mis_dict']
dk[ptest] = data['dk_dict']
ma_lca[ptest] = data['lca_ma_list']
ma_cosine[ptest] = data['cosine_ma_list']
p = P(
exp_name=exp_name, sup_epoch=supervised_epoch,
n_param=n_param, n_branch=n_branch, pad_len=pad_len_load,
enc_size=enc_size, penalty=penalty_train, penalty_random=penalty_random,
cmpt=cmpt, p_rm_ob_enc=p_rm_ob_enc_load, p_rm_ob_rcl=p_rm_ob_rcl_load,
)
# init a dummy task
task = SequenceLearning(n_param=p.env.n_param, n_branch=p.env.n_branch)
dacc = np.zeros((n_subjs, n_param, T))
Yob_all, Yhat_all = [], []
o_keys_p1_all, o_keys_p2_all = [], []
for i_s in range(n_subjs):
# create logging dirs
np.random.seed(i_s)
log_path, log_subpath = build_log_path(i_s, p, log_root, mkdir=False)
test_data_fname = get_test_data_fname(n_examples_test, fix_cond=fix_cond)
test_data_dir, _ = get_test_data_dir(log_subpath, epoch_load, test_params)
fpath = os.path.join(test_data_dir, test_data_fname)
if not os.path.exists(fpath):
print('DNE')
continue
# load data
test_data_dict = pickle_load_dict(fpath)
[dist_a_, Y_, log_cache_, log_cond_] = test_data_dict['results']
[X_raw, Y_raw] = test_data_dict['XY']
[C, H, M, CM, DA, V], [inpt] = process_cache(log_cache_, T, p)
n_examples_skip = compute_n_trials_to_skip(log_cond_, p)
# trim data, wait until the model has 2EMs loaded
[dist_a, Y, log_cond, log_cache, X_raw, Y_raw, C, V, CM, inpt] = trim_data(
n_examples_skip,
