def _encoder_model(self, input_shape, hyperparameters):
squeezenet = SqueezeNet(
input_shape=(self.input_shape[0], self.input_shape[1], 3),
include_top=False,
)
x = Flatten()(squeezenet.output)
embedding = Dense(np.prod(hyperparameters['embedding_dim']), activation='relu')(x)
encoder = Model(squeezenet.input, embedding)
utils.freeze_layers(squeezenet)
return encoder
def fit(self, x_texts, y_train, validation_split=0, epochs=1):
utils.freeze_layers(self.language_model)
# Freeze language model
y_train = utils.one_hot_encode(y_train, self.num_classes)
x_train = self.vectorize_text(x_texts)
if validation_split > 0.:
callbacks = [EarlyStopping(patience=3)]
else:
callbacks = None
with self.graph.as_default():
history = self.classifier.fit(
x_train,
y_train,
validation_split=validation_split,
callbacks=callbacks,
epochs=epochs,
verbose=0,
)
return history.history['loss'][0], history.history['acc'][0]
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))
args.traj_classes = list(range(963))
#
dataset = df.DatasetFactory.get_dataset(args.dataset,
background=True,
train=True,
all=True)
dataset_test = df.DatasetFactory.get_dataset(args.dataset,
background=False,
train=True,
all=True)
sampler = ts.SamplerFactory.get_sampler(args.dataset, args.classes,
dataset, dataset)
sampler_test = ts.SamplerFactory.get_sampler(args.dataset,
list(range(600)),
dataset_test, dataset_test)
config = mf.ModelFactory.get_model("na", "omniglot-fc")
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_few_shot_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 % 20 == 0:
writer.add_scalar('/metatrain/train/accuracy', accs[-1], step)
logger.info('step: %d \t training acc %s', step, str(accs))
logger.info("Loss = %s", str(loss[-1].item()))
if step % 600 == 599:
torch.save(maml.net, my_experiment.path + "learner.model")
accs_avg = None
for temp_temp in range(0, 40):
t1_test = np.random.choice(list(range(600)),
args.tasks,
replace=False)
d_traj_test_iterators = []
for t in t1_test:
d_traj_test_iterators.append(sampler_test.sample_task([t]))
x_spt, y_spt, x_qry, y_qry = maml.sample_few_shot_training_data(
d_traj_test_iterators,
None,
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.finetune(x_spt, y_spt, x_qry, y_qry)
if accs_avg is None:
accs_avg = accs
else:
accs_avg += accs
logger.info("Loss = %s", str(loss[-1].item()))
writer.add_scalar('/metatest/train/accuracy', accs_avg[-1] / 40,
step)
logger.info('TEST: step: %d \t testing acc %s', step,
str(accs_avg / 40))
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(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")
def train(p, train_loader, model, optimizer, epoch, amp):
losses = AverageMeter('Loss', ':.4e')
contrastive_losses = AverageMeter('Contrastive', ':.4e')
saliency_losses = AverageMeter('CE', ':.4e')
top1 = AverageMeter('Acc@1', ':6.2f')
top5 = AverageMeter('Acc@5', ':6.2f')
progress = ProgressMeter(
len(train_loader),
[losses, contrastive_losses, saliency_losses, top1, top5],
prefix="Epoch: [{}]".format(epoch))
model.train()
if p['freeze_layers']:
model = freeze_layers(model)
for i, batch in enumerate(train_loader):
# Forward pass
im_q = batch['query']['image'].cuda(p['gpu'], non_blocking=True)
im_k = batch['key']['image'].cuda(p['gpu'], non_blocking=True)
sal_q = batch['query']['sal'].cuda(p['gpu'], non_blocking=True)
sal_k = batch['key']['sal'].cuda(p['gpu'], non_blocking=True)
logits, labels, saliency_loss = model(im_q=im_q,
im_k=im_k,
sal_q=sal_q,
sal_k=sal_k)
# Use E-Net weighting for calculating the pixel-wise loss.
uniq, freq = torch.unique(labels, return_counts=True)
p_class = torch.zeros(logits.shape[1],
dtype=torch.float32).cuda(p['gpu'],
non_blocking=True)
p_class_non_zero_classes = freq.float() / labels.numel()
p_class[uniq] = p_class_non_zero_classes
w_class = 1 / torch.log(1.02 + p_class)
contrastive_loss = cross_entropy(logits,
labels,
weight=w_class,
reduction='mean')
# Calculate total loss and update meters
loss = contrastive_loss + saliency_loss
contrastive_losses.update(contrastive_loss.item())
saliency_losses.update(saliency_loss.item())
losses.update(loss.item())
acc1, acc5 = accuracy(logits, labels, topk=(1, 5))
top1.update(acc1[0], im_q.size(0))
top5.update(acc5[0], im_q.size(0))
# Update model
optimizer.zero_grad()
if amp is not None: # Mixed precision
with amp.scale_loss(loss, optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss.backward()
optimizer.step()
# Display progress
if i % 25 == 0:
progress.display(i)