def train_all_tanhgru(seed=0, model_dir='tanhgru'):
"""Training of all tasks with Tanh GRUs."""
model_dir = os.path.join(DATAPATH, model_dir, str(seed))
hp = {'activation': 'tanh', 'rnn_type': 'LeakyGRU'}
rule_prob_map = {'contextdm1': 5, 'contextdm2': 5}
train.train(model_dir,
hp=hp,
ruleset='all',
rule_prob_map=rule_prob_map,
seed=seed)
# Analyses
variance.compute_variance(model_dir)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
data_analysis.compute_var_all(model_dir)
setups = [1, 2, 3]
for setup in setups:
taskset.compute_taskspace(model_dir,
setup,
restore=False,
representation='rate')
taskset.compute_replacerule_performance(model_dir, setup, False)
def train_all_mixrule_softplus(seed=0, root_dir='mixrule_softplus'):
"""Training of all tasks."""
model_dir = os.path.join(DATAPATH, root_dir, str(seed))
hp = {
'activation': 'softplus',
'w_rec_init': 'diag',
'use_separate_input': True,
'mix_rule': True
}
rule_prob_map = {'contextdm1': 5, 'contextdm2': 5}
train.train(model_dir,
hp=hp,
ruleset='all',
rule_prob_map=rule_prob_map,
seed=seed)
# Analyses
variance.compute_variance(model_dir)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
setups = [1, 2, 3]
for setup in setups:
taskset.compute_taskspace(model_dir,
setup,
restore=False,
representation='rate')
taskset.compute_replacerule_performance(model_dir, setup, False)
def mante_tanh(seed=0, model_dir='mante_tanh'):
"""Training of only the Mante task."""
hp = {'activation': 'tanh', 'target_perf': 0.9}
model_dir = os.path.join(DATAPATH, model_dir, str(seed))
train.train(model_dir, hp=hp, ruleset='mante', seed=seed)
# Analyses
variance.compute_variance(model_dir)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
data_analysis.compute_var_all(model_dir)
def train_vary_hp(i):
"""Vary the hyperparameters.
This experiment loops over a set of hyperparameters.
Args:
i: int, the index of the hyperparameters list
"""
# Ranges of hyperparameters to loop over
hp_ranges = OrderedDict()
# hp_ranges['activation'] = ['softplus', 'relu', 'tanh', 'retanh']
# hp_ranges['rnn_type'] = ['LeakyRNN', 'LeakyGRU']
# hp_ranges['w_rec_init'] = ['diag', 'randortho']
hp_ranges['activation'] = ['softplus']
hp_ranges['rnn_type'] = ['LeakyRNN']
hp_ranges['w_rec_init'] = ['randortho']
hp_ranges['l1_h'] = [0, 1e-9, 1e-8, 1e-7,
1e-6] # TODO(gryang): Change this?
hp_ranges['l2_h'] = [0]
hp_ranges['l1_weight'] = [0, 1e-7, 1e-6, 1e-5]
# TODO(gryang): add the level of overtraining
# Unravel the input index
keys = hp_ranges.keys()
dims = [len(hp_ranges[k]) for k in keys]
n_max = np.prod(dims)
indices = np.unravel_index(i % n_max, dims=dims)
# Set up new hyperparameter
hp = dict()
for key, index in zip(keys, indices):
hp[key] = hp_ranges[key][index]
model_dir = os.path.join(DATAPATH, 'varyhp_reg2', str(i))
rule_prob_map = {'contextdm1': 5, 'contextdm2': 5}
train.train(model_dir,
hp,
ruleset='all',
rule_prob_map=rule_prob_map,
seed=i // n_max)
# Analyses
variance.compute_variance(model_dir)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
data_analysis.compute_var_all(model_dir)
def compute_n_cluster(model_dirs):
for model_dir in model_dirs:
print(model_dir)
log = tools.load_log(model_dir)
hp = tools.load_hp(model_dir)
try:
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
log['model_dir'] = model_dir
tools.save_log(log)
except IOError:
# Training never finished
assert log['perf_min'][-1] <= hp['target_perf']
# analysis.plot_example_unit()
# analysis.plot_variance()
# analysis.plot_2Dvisualization()
print("done")
def train_all_analysis(seed=0, root_dir='train_all'):
model_dir = os.path.join(DATAPATH, root_dir, str(seed))
# Analyses
variance.compute_variance(model_dir)
variance.compute_variance(model_dir, random_rotation=True)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
data_analysis.compute_var_all(model_dir)
for rule in ['dm1', 'contextdm1', 'multidm']:
performance.compute_choicefamily_varytime(model_dir, rule)
setups = [1, 2, 3]
for setup in setups:
taskset.compute_taskspace(model_dir,
setup,
restore=False,
representation='rate')
taskset.compute_replacerule_performance(model_dir, setup, False)
def _base_vary_hp_mante(i, hp_ranges, base_name):
"""Vary hyperparameters for mante tasks."""
# Unravel the input index
keys = hp_ranges.keys()
dims = [len(hp_ranges[k]) for k in keys]
n_max = np.prod(dims)
indices = np.unravel_index(i % n_max, dims=dims)
# Set up new hyperparameter
hp = dict()
for key, index in zip(keys, indices):
hp[key] = hp_ranges[key][index]
model_dir = os.path.join(DATAPATH, base_name, str(i))
train.train(model_dir, hp, ruleset='mante', max_steps=1e7, seed=i // n_max)
# Analyses
variance.compute_variance(model_dir)
log = tools.load_log(model_dir)
analysis = clustering.Analysis(model_dir, 'rule')
log['n_cluster'] = analysis.n_cluster
tools.save_log(log)
data_analysis.compute_var_all(model_dir)
def do_eval(sess, model, log, rule_train):
"""Do evaluation.
Args:
sess: tensorflow session
model: Model class instance
log: dictionary that stores the log
rule_train: string or list of strings, the rules being trained
"""
hp = model.hp
if not hasattr(rule_train, '__iter__'):
rule_name_print = rule_train
else:
rule_name_print = ' & '.join(rule_train)
print('Trial {:7d}'.format(log['trials'][-1]) +
' | Time {:0.2f} s'.format(log['times'][-1]) + ' | Now training ' +
rule_name_print)
for rule_test in hp['rules']:
n_rep = 16
batch_size_test_rep = int(hp['batch_size_test'] / n_rep)
clsq_tmp = list()
creg_tmp = list()
perf_tmp = list()
for i_rep in range(n_rep):
trial = generate_trials(rule_test,
hp,
'random',
batch_size=batch_size_test_rep)
feed_dict = tools.gen_feed_dict(model, trial, hp)
c_lsq, c_reg, y_hat_test = sess.run(
[model.cost_lsq, model.cost_reg, model.y_hat],
feed_dict=feed_dict)
# Cost is first summed over time,
# and averaged across batch and units
# We did the averaging over time through c_mask
perf_test = np.mean(get_perf(y_hat_test, trial.y_loc))
clsq_tmp.append(c_lsq)
creg_tmp.append(c_reg)
perf_tmp.append(perf_test)
log['cost_' + rule_test].append(np.mean(clsq_tmp, dtype=np.float64))
log['creg_' + rule_test].append(np.mean(creg_tmp, dtype=np.float64))
log['perf_' + rule_test].append(np.mean(perf_tmp, dtype=np.float64))
print('{:15s}'.format(rule_test) +
'| cost {:0.6f}'.format(np.mean(clsq_tmp)) +
'| c_reg {:0.6f}'.format(np.mean(creg_tmp)) +
' | perf {:0.2f}'.format(np.mean(perf_tmp)))
sys.stdout.flush()
# TODO: This needs to be fixed since now rules are strings
if hasattr(rule_train, '__iter__'):
rule_tmp = rule_train
else:
rule_tmp = [rule_train]
perf_tests_mean = np.mean([log['perf_' + r][-1] for r in rule_tmp])
log['perf_avg'].append(perf_tests_mean)
perf_tests_min = np.min([log['perf_' + r][-1] for r in rule_tmp])
log['perf_min'].append(perf_tests_min)
# Saving the model
model.save()
tools.save_log(log)
return log
