def main(subject, session, settings, test=False, skip_calibration=False):
output_dir, output_str = get_output_dir_str(subject, session, 'calibrate',
None)
if test:
log_file = op.abspath(
'logs/test_log/sub-test_ses-test_task-calibrate_events.tsv')
else:
if not skip_calibration:
calibrate_session = run_experiment(CalibrationSession,
task='calibrate',
subject=subject,
session=session,
settings=settings,
use_runs=False)
logging.warn(op.join(output_dir, output_str))
log_file = op.join(output_dir, output_str + '_events.tsv')
x_lower, x_upper = fit_psychometric_curve(log_file)
logging.warn(f'Range: {x_lower}, {x_upper}')
if test:
limit = 1
else:
limit = None
fn = make_trial_design(subject, x_lower, x_upper, limit=limit)
logging.warn(fn)
task_session = run_experiment(TaskSession,
task='task',
session=session,
settings=settings,
subject=subject)
txt, payout = get_payout(subject)
txt += '\nPlease remain seated until you get picked up for payment.'
payout_folder = task_session.settings['output'].get('payout_folder')
if op.exists(payout_folder):
payout_fn = op.join(payout_folder, f'sub-{subject}_payout.txt')
with open(payout_fn, 'w') as f:
f.write(str(payout))
payout_session = TextSession(txt=txt,
output_str='txt',
output_dir=output_dir,
settings_file=task_session.settings_file)
payout_session.run()
# Aggregate all the training options in one dictionary
training_options = {'aec_only_epochs': 3,
'init_full_epochs': 15,
'best_model_epochs': 500,
'num_init_models': 20,
'loss_fn': RelMSE(),
'optimizer': keras.optimizers.Adam,
'optimizer_opts': {},
'batch_size': 32,
'data_train_len': data_train_len,
'loss_weights': loss_weights}
#
# Launch the Experiment
#
# Get a random number generator seed
random_seed = r.randint(0, 10**(10))
# Set the custom objects used in the model (for loading purposes)
custom_objs = {"RelMSE": RelMSE}
# And run the experiment!
run_experiment(random_seed=random_seed,
expt_name=expt_name,
data_file_prefix=data_file_prefix,
training_options=training_options,
network_config=network_config,
custom_objects=custom_objs)
**common_params))
ks = [1, 5, 10]
for i, k in enumerate(ks):
label = "k={} no delay".format(k)
params_with_tag.append(
label_params(label,
useMemory=True,
takeK=k,
takeTop=False,
tau=tau_no_delay,
**common_params))
label = "k={}".format(k)
params_with_tag.append(
label_params(label,
useMemory=True,
takeK=k,
takeTop=False,
tau=tau_delay,
**common_params))
# params_with_tag.append(label_params("top k=10", useMemory=True, takeK=10, takeTop=True, tau=tau_delay, **common_params))
# params_with_tag.append(label_params("top k=1", useMemory=True, takeK=1, takeTop=True, tau=tau_delay, **common_params))
#
# RUN THE EXPERIMENT
#
run_experiment(dataset_params, params_with_tag)
from utils import run_experiment
from task import TaskSessionMRI
if __name__ == '__main__':
session_cls = TaskSessionMRI
task = 'task'
for run in range(1, 5):
run_experiment(session_cls, run=run, session='7t', task=task, settings='7t', use_runs=True)
The part of the pie chart that is lightly colored indicates
the probability of a lottery you will gain the amount of
Swiss Francs represented by the pile.
Your task is to either select the first lottery or
the second lottery, by using your index or middle finger.
Immediately after your choice, we ask how certain you were
about your choice from a scale from 1 (very CERTAIN)
to 4 (very UNCERTAIN).
NOTE: if you are to late in responding, or you do not
respond. You will gain no money for that trial.
Take some time to take a break, if you want to.
Press any of your buttons to continue.
"""
super().__init__(session=session,
trial_nr=trial_nr,
phase_durations=phase_durations,
txt=txt,
**kwargs)
if __name__ == '__main__':
session_cls = TaskSessionMRI
task = 'task'
run_experiment(session_cls, task=task)
#!/usr/bin/env python
import utils
import sys
# Get experiment file from command-line argument
for file in sys.argv[1:]:
print("=== Running %s" % file)
utils.run_experiment(file)
from Agents.NPC import SWA, wSWA
from Agents.PC import CTO, DCTO
from Agents.Naive import Random, RoundRobin
from Environments.RottenBandits import NonParametricRottenBandit, ParametricRottenBandit
from utils import run_experiment
import numpy as np
seed = 0
T = 30000
experiment_repeats = 100
#%% Naive agents < ~1m each experiment
np.random.seed(seed)
run_experiment(NonParametricRottenBandit(), Random, 'NP-Random', T,
experiment_repeats)
run_experiment(NonParametricRottenBandit(), RoundRobin, 'NP-RR', T,
experiment_repeats)
run_experiment(ParametricRottenBandit(seed=seed), Random, 'P-AV-Random', T,
experiment_repeats)
run_experiment(ParametricRottenBandit(seed=seed), RoundRobin, 'P-AV-RR', T,
experiment_repeats)
run_experiment(ParametricRottenBandit(ANV=True, seed=seed), Random,
'P-ANV-Random', T, experiment_repeats)
run_experiment(ParametricRottenBandit(ANV=True, seed=seed), RoundRobin,
'P-ANV-RR', T, experiment_repeats)
#%% SWA and wSWA ~ 1-2m each experiment
np.random.seed(seed)
run_experiment(NonParametricRottenBandit(), SWA, 'NP-SWA', T,
with tf.name_scope('weights'):
nce_weights = tf.Variable(
tf.truncated_normal(
shape=[vocabulary_size, embedding_size],
stddev=1.0 / math.sqrt(embedding_size),
))
with tf.name_scope('biases'):
nce_biases = tf.Variable(tf.zeros([vocabulary_size]))
# Compute the cosine similarity between minibatch examples and all embeddings.
norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True))
normalized_embeddings = embeddings / norm
return dict(
embeddings=embeddings,
nce_weights=nce_weights,
nce_biases=nce_biases,
norm=norm,
normalized_embeddings=normalized_embeddings,
)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument("--filename")
parser.add_argument("--pfile") # parameters file
parser.add_argument("--is_grid")
args = parser.parse_args()
if args.is_grid:
run_grid_search(args, main)
else:
run_experiment(args, main)
dtsets.append(mnist_dataset)
train_dataset = ModifiedDataset(ConcatDataset(dtsets))
test_dataset = ModifiedDataset(datasets.MNIST(root='./data/', train=False, transform=transforms.ToTensor()))
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=1000, shuffle=False)
criterion = nn.CrossEntropyLoss()
#Contains most of the parameters needed for an experiment
#CONFIGURABLE STUFF
NUM_TRIALS = 10
max_training_num = 5020
hyper_params = {"learning_rate": 0.001, "sampling_size": int(len(train_dataset)/6), "selection_size": 250, "max_training_num": max_training_num, "NUM_EPOCHS": 1, "bootstrap_samplesize": 20, "reset_model_per_selection": False}
experiment = Experiment(api_key="Gncqbz3Rhfy3MZJBcX7xKVJoo", project_name="comp652", workspace="comp652")
experiment.log_parameters(hyper_params)
myfunctions = [AcquisitionFunctions.Random, AcquisitionFunctions.Smallest_Margin, AcquisitionFunctions.Density_Max,AcquisitionFunctions.Density_Entropy, AcquisitionFunctions.SN_Entropy, AcquisitionFunctions.SN_BALD, AcquisitionFunctions.Variation_Ratios, AcquisitionFunctions.Mean_STD]
random_bootstrap_samples = random.sample(range(0, len(train_dataset)), hyper_params["bootstrap_samplesize"])
for j in range(len(myfunctions)):
print()
print('-------------------------------------------------------')
print("Processing function {}".format(j+1))
print("Name = {}".format(myfunctions[j].name))
model = convnet_mnist(10).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr= hyper_params["learning_rate"])
myselector = Selector(myfunctions[j](selection_size = hyper_params["selection_size"]))
acc_random = run_experiment(train_dataset, test_dataset, test_loader, model, hyper_params["sampling_size"], myselector, optimizer, criterion, myfunctions[j].name, experiment, max_training_num, NUM_TRIALS, hyper_params["NUM_EPOCHS"], hyper_params["learning_rate"], random_bootstrap_samples, hyper_params["reset_model_per_selection"])
n_repeats_stimulus = self.settings['mapper'].get('n_repeats_stimulus')
colors = sample_isis(n_blocks * block_length * n_repeats_stimulus)
for block in range(n_blocks):
for trial_nr, n_dots in enumerate(design):
trial_nr += block * block_length + 1
color_ix = (trial_nr-1) * \
n_repeats_stimulus, trial_nr*n_repeats_stimulus
self.trials.append(
self.Trial(
session=self,
trial_nr=trial_nr,
phase_durations=[],
n_dots=n_dots,
colors=colors[color_ix[0]:color_ix[1]],
verbose=True,
))
outro_trial = OutroTrial(session=self,
trial_nr=n_blocks * len(design) + 1,
phase_durations=[np.inf])
self.trials.append(outro_trial)
if __name__ == '__main__':
session_cls = MapperSession
task = 'mapper'
run_experiment(session_cls, task=task, n_runs=3)
def run_t1_ttts(parameter):
utils.run_experiment(parameter, select_arm_ttts)
def run_tm_tsus(parameter):
sampler = lambda prior: select_arms_tsus(prior, parameter.m)
utils.run_experiment(parameter, sampler)
def run_tm_ts(parameter):
utils.run_experiment(parameter, select_arms_ts)
def run_tm_uniform(parameter):
utils.run_experiment(parameter, select_arms_uniform)
from Agents.NPC import SWA, wSWA
from Agents.PC import CTO
from Environments.RottenBandits import NonParametricRottenBandit, ParametricRottenBandit
from utils import run_experiment
import numpy as np
np.random.seed(5)
T = 30000
experiment_repeats = 100
experiments = [(ParametricRottenBandit(), wSWA, 'P-AV-wSWA'),
(ParametricRottenBandit(), SWA, 'P-AV-SWA')]
for experiment in experiments:
run_experiment(*experiment, T=T, experiment_repeats=experiment_repeats)
