def main(args):
utils.set_seed(args.seed)
my_experiment = experiment(args.name,
args,
"results/",
commit_changes=args.commit)
writer = SummaryWriter(my_experiment.path + "tensorboard")
logger = logging.getLogger('experiment')
# Using first 963 classes of the omniglot as the meta-training set
args.classes = list(range(963))
args.traj_classes = list(range(int(963 / 2), 963))
dataset = df.DatasetFactory.get_dataset(args.dataset,
background=True,
train=True,
all=True)
dataset_test = df.DatasetFactory.get_dataset(args.dataset,
background=True,
train=False,
all=True)
# Iterators used for evaluation
iterator_test = torch.utils.data.DataLoader(dataset_test,
batch_size=5,
shuffle=True,
num_workers=1)
iterator_train = torch.utils.data.DataLoader(dataset,
batch_size=5,
shuffle=True,
num_workers=1)
sampler = ts.SamplerFactory.get_sampler(args.dataset, args.classes,
dataset, dataset_test)
config = mf.ModelFactory.get_model("na", args.dataset)
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
maml = MetaLearingClassification(args, config).to(device)
utils.freeze_layers(args.rln, maml)
for step in range(args.steps):
t1 = np.random.choice(args.traj_classes, args.tasks, replace=False)
d_traj_iterators = []
for t in t1:
d_traj_iterators.append(sampler.sample_task([t]))
d_rand_iterator = sampler.get_complete_iterator()
x_spt, y_spt, x_qry, y_qry = maml.sample_training_data(
d_traj_iterators,
d_rand_iterator,
steps=args.update_step,
reset=not args.no_reset)
if torch.cuda.is_available():
x_spt, y_spt, x_qry, y_qry = x_spt.cuda(), y_spt.cuda(
), x_qry.cuda(), y_qry.cuda()
accs, loss = maml(x_spt, y_spt, x_qry, y_qry)
# Evaluation during training for sanity checks
if step % 40 == 39:
writer.add_scalar('/metatrain/train/accuracy', accs[-1], step)
logger.info('step: %d \t training acc %s', step, str(accs))
if step % 300 == 299:
utils.log_accuracy(maml, my_experiment, iterator_test, device,
writer, step)
utils.log_accuracy(maml, my_experiment, iterator_train, device,
writer, step)
def main(args):
utils.set_seed(args.seed)
my_experiment = experiment(args.name,
args,
"../results/",
commit_changes=args.commit)
writer = SummaryWriter(my_experiment.path + "tensorboard")
logger = logging.getLogger("experiment")
# Using first 963 classes of the omniglot as the meta-training set
args.classes = list(range(963))
if torch.cuda.is_available():
device = torch.device("cuda")
use_cuda = True
else:
device = torch.device("cpu")
use_cuda = False
dataset = df.DatasetFactory.get_dataset(
args.dataset,
background=True,
train=True,
all=True,
prefetch_gpu=args.prefetch_gpu,
device=device,
)
dataset_test = dataset
# dataset_test = df.DatasetFactory.get_dataset(
# args.dataset, background=True, train=False, all=True
# )
# Iterators used for evaluation
iterator_test = torch.utils.data.DataLoader(dataset_test,
batch_size=5,
shuffle=True,
num_workers=1)
iterator_train = torch.utils.data.DataLoader(dataset,
batch_size=5,
shuffle=True,
num_workers=1)
sampler = ts.SamplerFactory.get_sampler(
args.dataset,
args.classes,
dataset,
dataset_test,
prefetch_gpu=args.prefetch_gpu,
use_cuda=use_cuda,
)
config = mf.ModelFactory.get_model(args.treatment, args.dataset)
maml = MetaLearingClassification(args, config, args.treatment).to(device)
if args.checkpoint:
checkpoint = torch.load(args.saved_model, map_location="cpu")
for idx in range(len(checkpoint)):
maml.net.parameters()[idx].data = checkpoint.parameters()[idx].data
maml = maml.to(device)
utils.freeze_layers(args.rln, maml)
for step in range(args.steps):
t1 = np.random.choice(args.classes, args.tasks, replace=False)
d_traj_iterators = []
for t in t1:
d_traj_iterators.append(sampler.sample_task([t]))
d_rand_iterator = sampler.get_complete_iterator()
x_spt, y_spt, x_qry, y_qry = maml.sample_training_data(
d_traj_iterators,
d_rand_iterator,
steps=args.update_step,
reset=not args.no_reset,
)
if torch.cuda.is_available():
x_spt, y_spt, x_qry, y_qry = (
x_spt.cuda(),
y_spt.cuda(),
x_qry.cuda(),
y_qry.cuda(),
)
accs, loss = maml(x_spt, y_spt, x_qry, y_qry) # , args.tasks)
# Evaluation during training for sanity checks
if step % 40 == 0:
# writer.add_scalar('/metatrain/train/accuracy', accs, step)
logger.info("step: %d \t training acc %s", step, str(accs))
if step % 100 == 0 or step == 19999:
torch.save(maml.net, args.model_name)
if step % 2000 == 0 and step != 0:
utils.log_accuracy(maml, my_experiment, iterator_test, device,
writer, step)
utils.log_accuracy(maml, my_experiment, iterator_train, device,
writer, step)
def main():
p = class_parser.Parser()
total_seeds = len(p.parse_known_args()[0].seed)
rank = p.parse_known_args()[0].rank
all_args = vars(p.parse_known_args()[0])
print("All args = ", all_args)
args = utils.get_run(vars(p.parse_known_args()[0]), rank)
utils.set_seed(args['seed'])
my_experiment = experiment(args['name'],
args,
"../results/",
commit_changes=False,
rank=0,
seed=1)
writer = SummaryWriter(my_experiment.path + "tensorboard")
logger = logging.getLogger('experiment')
# Using first 963 classes of the omniglot as the meta-training set
args['classes'] = list(range(963))
# args['traj_classes'] = list(range(int(963/2), 963))
args['traj_classes'] = list(range(963))
dataset = df.DatasetFactory.get_dataset(args['dataset'],
background=True,
train=True,
path=args["path"],
all=True)
dataset_test = df.DatasetFactory.get_dataset(args['dataset'],
background=True,
train=False,
path=args["path"],
all=True)
# Iterators used for evaluation
iterator_test = torch.utils.data.DataLoader(dataset_test,
batch_size=5,
shuffle=True,
num_workers=1)
iterator_train = torch.utils.data.DataLoader(dataset,
batch_size=5,
shuffle=True,
num_workers=1)
sampler = ts.SamplerFactory.get_sampler(args['dataset'], args['classes'],
dataset, dataset_test)
config = mf.ModelFactory.get_model("na",
args['dataset'],
output_dimension=1000)
gpu_to_use = rank % args["gpus"]
if torch.cuda.is_available():
device = torch.device('cuda:' + str(gpu_to_use))
logger.info("Using gpu : %s", 'cuda:' + str(gpu_to_use))
else:
device = torch.device('cpu')
maml = MetaLearingClassification(args, config).to(device)
for step in range(args['steps']):
t1 = np.random.choice(args['traj_classes'],
args['tasks'],
replace=False)
d_traj_iterators = []
for t in t1:
d_traj_iterators.append(sampler.sample_task([t]))
d_rand_iterator = sampler.get_complete_iterator()
x_spt, y_spt, x_qry, y_qry = maml.sample_training_data(
d_traj_iterators,
d_rand_iterator,
steps=args['update_step'],
reset=not args['no_reset'])
if torch.cuda.is_available():
x_spt, y_spt, x_qry, y_qry = x_spt.to(device), y_spt.to(
device), x_qry.to(device), y_qry.to(device)
accs, loss = maml(x_spt, y_spt, x_qry, y_qry)
# Evaluation during training for sanity checks
if step % 40 == 5:
writer.add_scalar('/metatrain/train/accuracy', accs[-1], step)
logger.info('step: %d \t training acc %s', step, str(accs))
if step % 300 == 3:
utils.log_accuracy(maml, my_experiment, iterator_test, device,
writer, step)
utils.log_accuracy(maml, my_experiment, iterator_train, device,
writer, step)
def main(args):
# Placeholder variables
old_accs = [0]
old_meta_losses = [2.**30, 0]
utils.set_seed(args.seed)
my_experiment = experiment(args.name,
args,
"./results/",
commit_changes=args.commit)
writer = SummaryWriter(my_experiment.path + "tensorboard")
logger = logging.getLogger('experiment')
# Using first 963 classes of the omniglot as the meta-training set
args.classes = list(range(963))
args.traj_classes = list(range(int(963 / 2), 963))
dataset = df.DatasetFactory.get_dataset(args.dataset,
background=True,
train=True,
all=True)
dataset_test = df.DatasetFactory.get_dataset(args.dataset,
background=True,
train=False,
all=True)
# print("ONE ITEM", len(dataset.__getitem__(0)),dataset.__getitem__(0)[0].shape,dataset.__getitem__(0)[1])
# Iterators used for evaluation
iterator_test = torch.utils.data.DataLoader(dataset_test,
batch_size=5,
shuffle=True,
num_workers=1)
iterator_train = torch.utils.data.DataLoader(dataset,
batch_size=5,
shuffle=True,
num_workers=1)
sampler = ts.SamplerFactory.get_sampler(args.dataset, args.classes,
dataset, dataset_test)
# print("NUM CLASSES",args.classes)
config = mf.ModelFactory.get_model("na", args.dataset)
if torch.cuda.is_available():
device = torch.device('cuda')
else:
device = torch.device('cpu')
# maml = MetaLearingClassification(args, config).to(device)
maml = MetaLearingClassification(args, config).to(device)
utils.freeze_layers(args.rln, maml) # freeze layers
for step in range(args.steps): #epoch
print("STEP: ", step)
t1 = np.random.choice(args.traj_classes, args.tasks,
replace=False) #sample sine waves
# print("TRAJ CLASSES<",args.tasks)
d_traj_iterators = []
for t in t1:
d_traj_iterators.append(sampler.sample_task([t]))
# print("ANNOYINGNESS",d_traj_iterators)
d_rand_iterator = sampler.get_complete_iterator()
# Sample trajectory and random batch (support and query)
x_spt, y_spt, x_qry, y_qry = maml.sample_training_data(
d_traj_iterators,
d_rand_iterator,
steps=args.update_step,
reset=not args.no_reset)
if torch.cuda.is_available():
x_spt, y_spt, x_qry, y_qry = x_spt.cuda(), y_spt.cuda(
), x_qry.cuda(), y_qry.cuda()
# One training loop
accs, loss = maml(x_spt, y_spt, x_qry, y_qry, step, old_accs,
old_meta_losses, args, config)
# if loss[-2] >= old_meta_losses[-2]: #if training improves it,
# maml.set_self(other.get_self_state_dict())
# old_meta_losses = loss
# else: #if not improved
# other.set_self(maml.get_self_state_dict())
# Evaluation during training for sanity checks
if step % 40 == 39:
writer.add_scalar('/metatrain/train/accuracy', accs[-1], step)
logger.info('step: %d \t training acc %s', step, str(accs))
if step % 300 == 299:
utils.log_accuracy(maml, my_experiment, iterator_test, device,
writer, step)
utils.log_accuracy(maml, my_experiment, iterator_train, device,
writer, step)
torch.save(maml.net, my_experiment.path + "omniglot_classifier.model")