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,