class MAMLFewShotClassifier(nn.Module):
def __init__(self, im_shape, device, args):
"""
Initializes a MAML few shot learning system
:param im_shape: The images input size, in batch, c, h, w shape
:param device: The device to use to use the model on.
:param args: A namedtuple of arguments specifying various hyperparameters.
"""
super(MAMLFewShotClassifier, self).__init__()
self.args = args
self.device = device
self.batch_size = args.batch_size
self.use_cuda = args.use_cuda
self.im_shape = im_shape
self.current_epoch = 0
self.rng = set_torch_seed(seed=args.seed)
if self.args.backbone == 'ResNet12':
self.classifier = ResNet12(im_shape=self.im_shape, num_output_classes=self.args.
num_classes_per_set,
args=args, device=device, meta_classifier=True).to(device=self.device)
else:
self.classifier = VGGReLUNormNetwork(im_shape=self.im_shape, num_output_classes=self.args.
num_classes_per_set,
args=args, device=device, meta_classifier=True).to(device=self.device)
self.task_learning_rate = args.init_inner_loop_learning_rate
self.inner_loop_optimizer = LSLRGradientDescentLearningRule(device=device,
init_learning_rate=self.task_learning_rate,
init_weight_decay=args.init_inner_loop_weight_decay,
total_num_inner_loop_steps=self.args.number_of_training_steps_per_iter,
use_learnable_weight_decay=self.args.alfa,
use_learnable_learning_rates=self.args.alfa,
alfa=self.args.alfa, random_init=self.args.random_init)
names_weights_copy = self.get_inner_loop_parameter_dict(self.classifier.named_parameters())
if self.args.attenuate:
num_layers = len(names_weights_copy)
self.attenuator = nn.Sequential(
nn.Linear(num_layers, num_layers),
nn.ReLU(inplace=True),
nn.Linear(num_layers, num_layers),
nn.Sigmoid()
).to(device=self.device)
self.inner_loop_optimizer.initialise(
names_weights_dict=names_weights_copy)
print("Inner Loop parameters")
for key, value in self.inner_loop_optimizer.named_parameters():
print(key, value.shape)
self.use_cuda = args.use_cuda
self.device = device
self.args = args
self.to(device)
print("Outer Loop parameters")
for name, param in self.named_parameters():
if param.requires_grad:
print(name, param.shape, param.device, param.requires_grad)
# ALFA
if self.args.alfa:
num_layers = len(names_weights_copy)
input_dim = num_layers*2
self.regularizer = nn.Sequential(
nn.Linear(input_dim, input_dim),
nn.ReLU(inplace=True),
nn.Linear(input_dim, input_dim)
).to(device=self.device)
if self.args.attenuate:
if self.args.alfa:
self.optimizer = optim.Adam([
{'params':self.classifier.parameters()},
{'params': self.inner_loop_optimizer.parameters()},
{'params': self.regularizer.parameters()},
{'params':self.attenuator.parameters()},
],lr=args.meta_learning_rate, amsgrad=False)
else:
self.optimizer = optim.Adam([
{'params':self.classifier.parameters()},
{'params':self.attenuator.parameters()},
],lr=args.meta_learning_rate, amsgrad=False)
else:
if self.args.alfa:
if self.args.random_init:
self.optimizer = optim.Adam([
{'params': self.inner_loop_optimizer.parameters()},
{'params': self.regularizer.parameters()},
], lr=args.meta_learning_rate, amsgrad=False)
else:
self.optimizer = optim.Adam([
{'params': self.classifier.parameters()},
{'params': self.inner_loop_optimizer.parameters()},
{'params': self.regularizer.parameters()},
], lr=args.meta_learning_rate, amsgrad=False)
else:
self.optimizer = optim.Adam([
{'params': self.classifier.parameters()},
], lr=args.meta_learning_rate, amsgrad=False)
self.scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer=self.optimizer, T_max=self.args.total_epochs,
eta_min=self.args.min_learning_rate)
self.device = torch.device('cpu')
if torch.cuda.is_available():
print(torch.cuda.device_count())
if torch.cuda.device_count() > 1:
self.to(torch.cuda.current_device())
self.classifier = nn.DataParallel(module=self.classifier)
else:
self.to(torch.cuda.current_device())
self.device = torch.cuda.current_device()
def get_task_embeddings(self, x_support_set_task, y_support_set_task, names_weights_copy):
# Use gradients as task embeddings
support_loss, support_preds = self.net_forward(x=x_support_set_task,
y=y_support_set_task,
weights=names_weights_copy,
backup_running_statistics=True,
training=True, num_step=0)
if torch.cuda.device_count() > 1:
self.classifier.module.zero_grad(names_weights_copy)
else:
self.classifier.zero_grad(names_weights_copy)
grads = torch.autograd.grad(support_loss, names_weights_copy.values(), create_graph=True)
layerwise_mean_grads = []
for i in range(len(grads)):
layerwise_mean_grads.append(grads[i].mean())
layerwise_mean_grads = torch.stack(layerwise_mean_grads)
return layerwise_mean_grads
def attenuate_init(self, task_embeddings, names_weights_copy):
# Generate attenuation parameters
gamma = self.attenuator(task_embeddings)
## Attenuate
updated_names_weights_copy = dict()
i = 0
for key in names_weights_copy.keys():
updated_names_weights_copy[key] = gamma[i] * names_weights_copy[key]
i+=1
return updated_names_weights_copy
def get_per_step_loss_importance_vector(self):
"""
Generates a tensor of dimensionality (num_inner_loop_steps) indicating the importance of each step's target
loss towards the optimization loss.
:return: A tensor to be used to compute the weighted average of the loss, useful for
the MSL (Multi Step Loss) mechanism.
"""
loss_weights = np.ones(shape=(self.args.number_of_training_steps_per_iter)) * (
1.0 / self.args.number_of_training_steps_per_iter)
decay_rate = 1.0 / self.args.number_of_training_steps_per_iter / self.args.multi_step_loss_num_epochs
min_value_for_non_final_losses = 0.03 / self.args.number_of_training_steps_per_iter
for i in range(len(loss_weights) - 1):
curr_value = np.maximum(loss_weights[i] - (self.current_epoch * decay_rate), min_value_for_non_final_losses)
loss_weights[i] = curr_value
curr_value = np.minimum(
loss_weights[-1] + (self.current_epoch * (self.args.number_of_training_steps_per_iter - 1) * decay_rate),
1.0 - ((self.args.number_of_training_steps_per_iter - 1) * min_value_for_non_final_losses))
loss_weights[-1] = curr_value
loss_weights = torch.Tensor(loss_weights).to(device=self.device)
return loss_weights
def get_inner_loop_parameter_dict(self, params):
"""
Returns a dictionary with the parameters to use for inner loop updates.
:param params: A dictionary of the network's parameters.
:return: A dictionary of the parameters to use for the inner loop optimization process.
"""
param_dict = dict()
for name, param in params:
if param.requires_grad:
if self.args.enable_inner_loop_optimizable_bn_params:
param_dict[name] = param.to(device=self.device)
else:
if "norm_layer" not in name:
param_dict[name] = param.to(device=self.device)
return param_dict
def apply_inner_loop_update(self, loss, names_weights_copy, generated_alpha_params, generated_beta_params, use_second_order, current_step_idx):
"""
Applies an inner loop update given current step's loss, the weights to update, a flag indicating whether to use
second order derivatives and the current step's index.
:param loss: Current step's loss with respect to the support set.
:param names_weights_copy: A dictionary with names to parameters to update.
:param use_second_order: A boolean flag of whether to use second order derivatives.
:param current_step_idx: Current step's index.
:return: A dictionary with the updated weights (name, param)
"""
num_gpus = torch.cuda.device_count()
if num_gpus > 1:
self.classifier.module.zero_grad(params=names_weights_copy)
else:
self.classifier.zero_grad(params=names_weights_copy)
grads = torch.autograd.grad(loss, names_weights_copy.values(),
create_graph=use_second_order, allow_unused=True)
names_grads_copy = dict(zip(names_weights_copy.keys(), grads))
names_weights_copy = {key: value[0] for key, value in names_weights_copy.items()}
for key, grad in names_grads_copy.items():
if grad is None:
print('Grads not found for inner loop parameter', key)
names_grads_copy[key] = names_grads_copy[key].sum(dim=0)
names_weights_copy = self.inner_loop_optimizer.update_params(names_weights_dict=names_weights_copy,
names_grads_wrt_params_dict=names_grads_copy,
generated_alpha_params=generated_alpha_params,
generated_beta_params=generated_beta_params,
num_step=current_step_idx)
num_devices = torch.cuda.device_count() if torch.cuda.is_available() else 1
names_weights_copy = {
name.replace('module.', ''): value.unsqueeze(0).repeat(
[num_devices] + [1 for i in range(len(value.shape))]) for
name, value in names_weights_copy.items()}
return names_weights_copy
def get_across_task_loss_metrics(self, total_losses, total_accuracies):
losses = dict()
losses['loss'] = torch.mean(torch.stack(total_losses))
losses['accuracy'] = np.mean(total_accuracies)
return losses
def forward(self, data_batch, epoch, use_second_order, use_multi_step_loss_optimization, num_steps, training_phase):
"""
Runs a forward outer loop pass on the batch of tasks using the MAML/++ framework.
:param data_batch: A data batch containing the support and target sets.
:param epoch: Current epoch's index
:param use_second_order: A boolean saying whether to use second order derivatives.
:param use_multi_step_loss_optimization: Whether to optimize on the outer loop using just the last step's
target loss (True) or whether to use multi step loss which improves the stability of the system (False)
:param num_steps: Number of inner loop steps.
:param training_phase: Whether this is a training phase (True) or an evaluation phase (False)
:return: A dictionary with the collected losses of the current outer forward propagation.
"""
x_support_set, x_target_set, y_support_set, y_target_set = data_batch
[b, ncs, spc] = y_support_set.shape
self.num_classes_per_set = ncs
total_losses = []
total_accuracies = []
total_support_accuracies = [[] for i in range(num_steps)]
total_target_accuracies = [[] for i in range(num_steps)]
per_task_target_preds = [[] for i in range(len(x_target_set))]
if torch.cuda.device_count() > 1:
self.classifier.module.zero_grad()
else:
self.classifier.zero_grad()
for task_id, (x_support_set_task, y_support_set_task, x_target_set_task, y_target_set_task) in \
enumerate(zip(x_support_set,
y_support_set,
x_target_set,
y_target_set)):
task_losses = []
task_accuracies = []
per_step_support_accuracy = []
per_step_target_accuracy = []
per_step_loss_importance_vectors = self.get_per_step_loss_importance_vector()
names_weights_copy = self.get_inner_loop_parameter_dict(self.classifier.named_parameters())
num_devices = torch.cuda.device_count() if torch.cuda.is_available() else 1
names_weights_copy = {
name.replace('module.', ''): value.unsqueeze(0).repeat(
[num_devices] + [1 for i in range(len(value.shape))]) for
name, value in names_weights_copy.items()}
n, s, c, h, w = x_target_set_task.shape
x_support_set_task = x_support_set_task.view(-1, c, h, w)
y_support_set_task = y_support_set_task.view(-1)
x_target_set_task = x_target_set_task.view(-1, c, h, w)
y_target_set_task = y_target_set_task.view(-1)
# Attenuate the initialization for L2F
if self.args.attenuate:
# Obtain gradients from support set for task embedding
task_embeddings = self.get_task_embeddings(x_support_set_task=x_support_set_task,
y_support_set_task=y_support_set_task,
names_weights_copy=names_weights_copy)
names_weights_copy = self.attenuate_init(task_embeddings=task_embeddings,
names_weights_copy=names_weights_copy)
for num_step in range(num_steps):
support_loss, support_preds = self.net_forward(x=x_support_set_task,
y=y_support_set_task,
weights=names_weights_copy,
backup_running_statistics=
True if (num_step == 0) else False,
training=True, num_step=num_step)
generated_alpha_params = {}
generated_beta_params = {}
if self.args.alfa:
support_loss_grad = torch.autograd.grad(support_loss, names_weights_copy.values(), retain_graph=True)
per_step_task_embedding = []
for k, v in names_weights_copy.items():
per_step_task_embedding.append(v.mean())
for i in range(len(support_loss_grad)):
per_step_task_embedding.append(support_loss_grad[i].mean())
per_step_task_embedding = torch.stack(per_step_task_embedding)
generated_params = self.regularizer(per_step_task_embedding)
num_layers = len(names_weights_copy)
generated_alpha, generated_beta = torch.split(generated_params, split_size_or_sections=num_layers)
g = 0
for key in names_weights_copy.keys():
generated_alpha_params[key] = generated_alpha[g]
generated_beta_params[key] = generated_beta[g]
g+=1
names_weights_copy = self.apply_inner_loop_update(loss=support_loss,
names_weights_copy=names_weights_copy,
generated_beta_params=generated_beta_params,
generated_alpha_params=generated_alpha_params,
use_second_order=use_second_order,
current_step_idx=num_step)
if use_multi_step_loss_optimization and training_phase and epoch < self.args.multi_step_loss_num_epochs:
target_loss, target_preds = self.net_forward(x=x_target_set_task,
y=y_target_set_task, weights=names_weights_copy,
backup_running_statistics=False, training=True,
num_step=num_step)
task_losses.append(per_step_loss_importance_vectors[num_step] * target_loss)
else:
if num_step == (self.args.number_of_training_steps_per_iter - 1):
target_loss, target_preds = self.net_forward(x=x_target_set_task,
y=y_target_set_task, weights=names_weights_copy,
backup_running_statistics=False, training=True,
num_step=num_step)
task_losses.append(target_loss)
per_task_target_preds[task_id] = target_preds.detach().cpu().numpy()
_, predicted = torch.max(target_preds.data, 1)
accuracy = predicted.float().eq(y_target_set_task.data.float()).cpu().float()
task_losses = torch.sum(torch.stack(task_losses))
total_losses.append(task_losses)
total_accuracies.extend(accuracy)
if not training_phase:
if torch.cuda.device_count() > 1:
self.classifier.module.restore_backup_stats()
else:
self.classifier.restore_backup_stats()
losses = self.get_across_task_loss_metrics(total_losses=total_losses,
total_accuracies=total_accuracies)
for idx, item in enumerate(per_step_loss_importance_vectors):
losses['loss_importance_vector_{}'.format(idx)] = item.detach().cpu().numpy()
return losses, per_task_target_preds
def net_forward(self, x, y, weights, backup_running_statistics, training, num_step):
"""
A base model forward pass on some data points x. Using the parameters in the weights dictionary. Also requires
boolean flags indicating whether to reset the running statistics at the end of the run (if at evaluation phase).
A flag indicating whether this is the training session and an int indicating the current step's number in the
inner loop.
:param x: A data batch of shape b, c, h, w
:param y: A data targets batch of shape b, n_classes
:param weights: A dictionary containing the weights to pass to the network.
:param backup_running_statistics: A flag indicating whether to reset the batch norm running statistics to their
previous values after the run (only for evaluation)
:param training: A flag indicating whether the current process phase is a training or evaluation.
:param num_step: An integer indicating the number of the step in the inner loop.
:return: the crossentropy losses with respect to the given y, the predictions of the base model.
"""
preds = self.classifier.forward(x=x, params=weights,
training=training,
backup_running_statistics=backup_running_statistics, num_step=num_step)
loss = F.cross_entropy(input=preds, target=y)
return loss, preds
def trainable_parameters(self):
"""
Returns an iterator over the trainable parameters of the model.
"""
for param in self.parameters():
if param.requires_grad:
yield param
def train_forward_prop(self, data_batch, epoch):
"""
Runs an outer loop forward prop using the meta-model and base-model.
:param data_batch: A data batch containing the support set and the target set input, output pairs.
:param epoch: The index of the currrent epoch.
:return: A dictionary of losses for the current step.
"""
losses, per_task_target_preds = self.forward(data_batch=data_batch, epoch=epoch,
use_second_order=self.args.second_order and
epoch > self.args.first_order_to_second_order_epoch,
use_multi_step_loss_optimization=self.args.use_multi_step_loss_optimization,
num_steps=self.args.number_of_training_steps_per_iter,
training_phase=True)
return losses, per_task_target_preds
def evaluation_forward_prop(self, data_batch, epoch):
"""
Runs an outer loop evaluation forward prop using the meta-model and base-model.
:param data_batch: A data batch containing the support set and the target set input, output pairs.
:param epoch: The index of the currrent epoch.
:return: A dictionary of losses for the current step.
"""
losses, per_task_target_preds = self.forward(data_batch=data_batch, epoch=epoch, use_second_order=False,
use_multi_step_loss_optimization=True,
num_steps=self.args.number_of_evaluation_steps_per_iter,
training_phase=False)
return losses, per_task_target_preds
def meta_update(self, loss):
"""
Applies an outer loop update on the meta-parameters of the model.
:param loss: The current crossentropy loss.
"""
self.optimizer.zero_grad()
loss.backward()
#if 'imagenet' in self.args.dataset_name:
# for name, param in self.classifier.named_parameters():
# if param.requires_grad:
# param.grad.data.clamp_(-10, 10) # not sure if this is necessary, more experiments are needed
#for name, param in self.classifier.named_parameters():
# print(param.mean())
self.optimizer.step()
def run_train_iter(self, data_batch, epoch):
"""
Runs an outer loop update step on the meta-model's parameters.
:param data_batch: input data batch containing the support set and target set input, output pairs
:param epoch: the index of the current epoch
:return: The losses of the ran iteration.
"""
epoch = int(epoch)
self.scheduler.step(epoch=epoch)
if self.current_epoch != epoch:
self.current_epoch = epoch
if not self.training:
self.train()
x_support_set, x_target_set, y_support_set, y_target_set = data_batch
x_support_set = torch.Tensor(x_support_set).float().to(device=self.device)
x_target_set = torch.Tensor(x_target_set).float().to(device=self.device)
y_support_set = torch.Tensor(y_support_set).long().to(device=self.device)
y_target_set = torch.Tensor(y_target_set).long().to(device=self.device)
data_batch = (x_support_set, x_target_set, y_support_set, y_target_set)
losses, per_task_target_preds = self.train_forward_prop(data_batch=data_batch, epoch=epoch)
self.meta_update(loss=losses['loss'])
losses['learning_rate'] = self.scheduler.get_lr()[0]
self.optimizer.zero_grad()
self.zero_grad()
return losses, per_task_target_preds
def run_validation_iter(self, data_batch):
"""
Runs an outer loop evaluation step on the meta-model's parameters.
:param data_batch: input data batch containing the support set and target set input, output pairs
:param epoch: the index of the current epoch
:return: The losses of the ran iteration.
"""
if self.training:
self.eval()
x_support_set, x_target_set, y_support_set, y_target_set = data_batch
x_support_set = torch.Tensor(x_support_set).float().to(device=self.device)
x_target_set = torch.Tensor(x_target_set).float().to(device=self.device)
y_support_set = torch.Tensor(y_support_set).long().to(device=self.device)
y_target_set = torch.Tensor(y_target_set).long().to(device=self.device)
data_batch = (x_support_set, x_target_set, y_support_set, y_target_set)
losses, per_task_target_preds = self.evaluation_forward_prop(data_batch=data_batch, epoch=self.current_epoch)
losses['loss'].backward() # uncomment if you get the weird memory error
self.zero_grad()
self.optimizer.zero_grad()
return losses, per_task_target_preds
def save_model(self, model_save_dir, state):
"""
Save the network parameter state and experiment state dictionary.
:param model_save_dir: The directory to store the state at.
:param state: The state containing the experiment state and the network. It's in the form of a dictionary
object.
"""
state['network'] = self.state_dict()
torch.save(state, f=model_save_dir)
def load_model(self, model_save_dir, model_name, model_idx):
"""
Load checkpoint and return the state dictionary containing the network state params and experiment state.
:param model_save_dir: The directory from which to load the files.
:param model_name: The model_name to be loaded from the direcotry.
:param model_idx: The index of the model (i.e. epoch number or 'latest' for the latest saved model of the current
experiment)
:return: A dictionary containing the experiment state and the saved model parameters.
"""
filepath = os.path.join(model_save_dir, "{}_{}".format(model_name, model_idx))
state = torch.load(filepath)
state_dict_loaded = state['network']
self.load_state_dict(state_dict=state_dict_loaded)
return state
class MAMLFewShotClassifier(FewShotClassifier):
def __init__(self, device, args):
"""
Initializes a MAML few shot learning system
:param device: The device to use to use the model on.
:param args: A namedtuple of arguments specifying various hyperparameters.
"""
super(MAMLFewShotClassifier, self).__init__(device, args)
config = AutoConfig.from_pretrained(args.pretrained_weights)
config.num_labels = args.num_classes_per_set
model_initialization = AutoModelForSequenceClassification.from_pretrained(
args.pretrained_weights, config=config
)
slow_model = MetaBERT
# Init fast model
state_dict = model_initialization.state_dict()
config = model_initialization.config
del model_initialization
# Slow model
self.classifier = slow_model.init_from_pretrained(
state_dict,
config,
num_labels=args.num_classes_per_set,
is_distil=self.is_distil,
is_xlm=self.is_xlm,
per_step_layer_norm_weights=args.per_step_layer_norm_weights,
num_inner_loop_steps=args.number_of_training_steps_per_iter,
device=device,
)
self.classifier.to("cpu")
self.classifier.train()
self.inner_loop_optimizer = LSLRGradientDescentLearningRule(
device=torch.device("cpu"),
init_learning_rate=self.task_learning_rate,
total_num_inner_loop_steps=self.args.number_of_training_steps_per_iter,
use_learnable_learning_rates=self.args.learnable_per_layer_per_step_inner_loop_learning_rate,
init_class_head_lr_multiplier=self.args.init_class_head_lr_multiplier,
)
self.inner_loop_optimizer.initialise(
names_weights_dict=self.get_inner_loop_parameter_dict(
params=self.classifier.named_parameters()
)
)
print("Inner Loop parameters")
for key, value in self.inner_loop_optimizer.named_parameters():
print(key, value.shape)
print("Outer Loop parameters")
for name, param in self.named_parameters():
if param.requires_grad:
print(name, param.shape, param.device, param.requires_grad)
self.optimizer = Ranger(
[
{"params": self.classifier.parameters(), "lr": args.meta_learning_rate},
{
"params": self.inner_loop_optimizer.parameters(),
"lr": args.meta_inner_optimizer_learning_rate,
},
],
lr=args.meta_learning_rate,
)
self.scheduler = optim.lr_scheduler.CosineAnnealingLR(
optimizer=self.optimizer,
T_max=self.args.total_epochs * self.args.total_iter_per_epoch,
eta_min=self.args.min_learning_rate,
)
self.inner_loop_optimizer.to(self.device)
self.clip_value = 1.0
# gradient clipping
for p in self.classifier.parameters():
if p.requires_grad:
p.register_hook(
lambda grad: torch.clamp(grad, -self.clip_value, self.clip_value)
)
self.num_freeze_epochs = args.num_freeze_epochs
if self.num_freeze_epochs > 0:
self.classifier.freeze()
def get_inner_loop_parameter_dict(self, params, adapter_only=False):
"""
Returns a dictionary with the parameters to use for inner loop updates.
:param params: A dictionary of the network's parameters.
:return: A dictionary of the parameters to use for the inner loop optimization process.
"""
param_dict = dict()
for name, param in params:
if param.requires_grad:
key = (
name.replace("module.", "", 1)
if name.startswith("module.")
else name
)
if self.args.enable_inner_loop_optimizable_ln_params:
param_dict[key] = param.to(device=self.device)
else:
if "LayerNorm" not in key:
if adapter_only:
if "adapter" in key or "classifier" in key:
param_dict[key] = param.to(device=self.device)
else:
print(key)
else:
param_dict[key] = param.to(device=self.device)
return param_dict
def apply_inner_loop_update(
self,
loss,
names_weights_copy,
use_second_order,
current_step_idx,
allow_unused=True,
):
"""
Applies an inner loop update given current step's loss, the weights to update, a flag indicating whether to use
second order derivatives and the current step's index.
:param loss: Current step's loss with respect to the support set.
:param names_weights_copy: A dictionary with names to parameters to update.
:param use_second_order: A boolean flag of whether to use second order derivatives.
:param current_step_idx: Current step's index.
:return: A dictionary with the updated weights (name, param)
"""
all_names = list(names_weights_copy.keys())
names_weights_copy = {
k: v for k, v in names_weights_copy.items() if v is not None
}
grads = torch.autograd.grad(
loss,
names_weights_copy.values(),
create_graph=use_second_order,
allow_unused=allow_unused,
)
names_grads_wrt_params = dict(zip(names_weights_copy.keys(), grads))
names_weights_copy = self.inner_loop_optimizer.update_params(
names_weights_dict=names_weights_copy,
names_grads_wrt_params_dict=names_grads_wrt_params,
num_step=current_step_idx,
)
del names_grads_wrt_params
for name in all_names:
if name not in names_weights_copy.keys():
names_weights_copy[name] = None
return names_weights_copy
def net_forward(
self,
x,
teacher_unary,
fast_model,
training,
num_step,
return_nr_correct=False,
mask=None,
task_name="",
):
student_logits = self.classifier(
input_ids=x, attention_mask=mask, num_step=num_step, params=fast_model
)[0]
set_kl_loss = False
if task_name in self.gold_label_tasks and self.meta_loss.lower() == "kl":
set_kl_loss = True
self.meta_loss = "ce"
loss = self.inner_loss(
student_logits, teacher_unary, return_nr_correct=return_nr_correct
)
if set_kl_loss:
self.meta_loss = "kl"
return loss
def forward(
self,
data_batch,
epoch,
use_second_order,
num_steps,
training_phase,
):
"""
Runs a forward outer loop pass on the batch of tasks using the MAML/++ framework.
:param data_batch: A data batch containing the support and target sets.
:param epoch: Current epoch's index
:param use_second_order: A boolean saying whether to use second order derivatives.
:param use_multi_step_loss_optimization: Whether to optimize on the outer loop using just the last step's
target loss (True) or whether to use multi step loss which improves the stability of the system (False)
:param num_steps: Number of inner loop steps.
:param training_phase: Whether this is a training phase (True) or an evaluation phase (False)
:return: A dictionary with the collected losses of the current outer forward propagation.
"""
(
x_support_set,
len_support_set,
x_target_set,
len_target_set,
y_support_set,
y_target_set,
teacher_names,
) = data_batch
meta_batch_size = self.args.batch_size
self.classifier.zero_grad()
if self.num_freeze_epochs <= epoch:
self.classifier.unfreeze()
losses = {"loss": 0}
task_accuracies = []
task_lang_logs = []
for (
task_id,
(
x_support_set_task,
len_support_set_task,
y_support_set_task,
x_target_set_task,
len_target_set_task,
y_target_set_task,
teacher_name,
),
) in enumerate(
zip(
x_support_set,
len_support_set,
y_support_set,
x_target_set,
len_target_set,
y_target_set,
teacher_names,
)
):
task_lang_log = [teacher_name, epoch]
task_losses = []
# freeze and unfreeze if necessary to get correct params
if epoch <= self.num_freeze_epochs:
self.classifier.unfreeze()
fast_weights = self.classifier.get_inner_loop_params()
if epoch < self.num_freeze_epochs:
self.classifier.freeze()
total_task_loss = 0
x_support_set_task = x_support_set_task.squeeze()
len_support_set_task = len_support_set_task.squeeze()
y_support_set_task = y_support_set_task.squeeze()
x_target_set_task = x_target_set_task.squeeze()
len_target_set_task = len_target_set_task.squeeze()
y_target_set_task = y_target_set_task.squeeze()
for num_step in range(num_steps):
torch.cuda.empty_cache()
support_loss, is_correct = self.net_forward(
x=x_support_set_task,
mask=len_support_set_task,
num_step=num_step,
teacher_unary=y_support_set_task,
fast_model=fast_weights,
training=True,
return_nr_correct=True,
task_name=teacher_name,
)
fast_weights = self.apply_inner_loop_update(
loss=support_loss,
names_weights_copy=fast_weights,
use_second_order=use_second_order,
current_step_idx=num_step,
)
if num_step == (self.args.number_of_training_steps_per_iter - 1):
# store support set statistics
task_lang_log.append(support_loss.detach().item())
task_lang_log.append(np.mean(is_correct))
target_loss, is_correct = self.net_forward(
x=x_target_set_task,
mask=len_target_set_task,
teacher_unary=y_target_set_task,
num_step=num_step,
fast_model=fast_weights,
training=True,
return_nr_correct=True,
task_name=teacher_name,
)
task_losses.append(target_loss)
accuracy = np.mean(is_correct)
task_accuracies.append(accuracy)
# store query set statistics
task_lang_log.append(target_loss.detach().item())
task_lang_log.append(accuracy)
# Achieve gradient accumulation by already backpropping current loss
torch.cuda.empty_cache()
task_losses = torch.sum(torch.stack(task_losses)) / meta_batch_size
task_losses.backward()
total_task_loss += task_losses.detach().cpu().item()
losses["loss"] += total_task_loss
task_lang_logs.append(task_lang_log)
torch.cuda.synchronize()
losses["accuracy"] = np.mean(task_accuracies)
if training_phase:
return losses, task_lang_logs
else:
return losses
def finetune_epoch(
self,
names_weights_copy,
model_config,
train_dataloader,
dev_dataloader,
best_loss,
eval_every,
model_save_dir,
task_name,
epoch,
train_on_cpu=False,
writer=None,
):
"""
Finetunes the meta-learned classifier on a dataset
:param train_dataloader: Dataloader with train examples
:param dev_dataloader: Dataloader with validation examples
:param best_loss: best achieved loss on dev set up till now
:param eval_every: eval on dev set after eval_every updates
:param model_save_dir: directory to save the model to
:param task_name: name of the task finetuning is performed on
:param epoch: current epoch number
:return: best_loss
"""
if train_on_cpu:
self.device = torch.device("cpu")
self.inner_loop_optimizer.requires_grad_(False)
self.inner_loop_optimizer.eval()
self.inner_loop_optimizer.to(self.device)
self.classifier.to(self.device)
if names_weights_copy is None:
if epoch <= self.num_freeze_epochs:
self.classifier.unfreeze()
# # Get fast weights
names_weights_copy = self.classifier.get_inner_loop_params()
if epoch < self.num_freeze_epochs:
self.classifier.freeze()
eval_every = (
eval_every if eval_every < len(train_dataloader) else len(train_dataloader)
)
if writer is not None: # create histogram of weights
for param_name, param in names_weights_copy.items():
writer.add_histogram(task_name + "/" + param_name, param, 0)
writer.flush()
with tqdm(
initial=0, total=eval_every * self.args.number_of_training_steps_per_iter
) as pbar_train:
for batch_idx, batch in enumerate(train_dataloader):
torch.cuda.empty_cache()
batch = tuple(t.to(self.device) for t in batch)
x, mask, y_true = batch
for train_step in range(self.args.number_of_training_steps_per_iter):
support_loss = self.net_forward(
x,
mask=mask,
teacher_unary=y_true,
num_step=train_step,
fast_model=names_weights_copy,
training=True,
)
names_weights_copy = self.apply_inner_loop_update(
loss=support_loss,
names_weights_copy=names_weights_copy,
use_second_order=False,
current_step_idx=train_step,
)
self.inner_loop_optimizer.zero_grad()
pbar_train.update(1)
pbar_train.set_description(
"finetuning phase {} -> loss: {}".format(
batch_idx * self.args.number_of_training_steps_per_iter
+ train_step
+ 1,
support_loss.item(),
)
)
if writer is not None: # create histogram of weights
for param_name, param in names_weights_copy.items():
writer.add_histogram(
task_name + "/" + param_name, param, train_step + 1
)
writer.flush()
if (batch_idx + 1) % eval_every == 0:
print("Evaluating model...")
losses = []
is_correct_preds = []
if train_on_cpu:
self.device = torch.device("cuda")
self.classifier.to(self.device)
with torch.no_grad():
for batch in tqdm(
dev_dataloader,
desc="Evaluating",
leave=False,
total=len(dev_dataloader),
):
batch = tuple(t.to(self.device) for t in batch)
x, mask, y_true = batch
loss, is_correct = self.net_forward(
x,
mask=mask,
teacher_unary=y_true,
fast_model=names_weights_copy,
training=False,
return_nr_correct=True,
num_step=train_step,
)
losses.append(loss.item())
is_correct_preds.extend(is_correct.tolist())
avg_loss = np.mean(losses)
accuracy = np.mean(is_correct_preds)
print("Accuracy", accuracy)
if avg_loss < best_loss:
best_loss = avg_loss
print(
"New best finetuned model with loss {:.05f}".format(
best_loss
)
)
torch.save(
names_weights_copy,
os.path.join(
model_save_dir,
"model_finetuned_{}".format(
task_name.replace("train/", "", 1)
.replace("val/", "", 1)
.replace("test/", "", 1)
),
),
)
return names_weights_copy, best_loss, avg_loss, accuracy