import logging import numpy as np from tqdm import tqdm import torch from torch import nn import copy from torch import optim from torch.nn import functional as F from torch.utils.data import DataLoader from models.base import BaseLearner from utils.inc_net import AdaptiveNet from utils.toolkit import count_parameters, target2onehot, tensor2numpy from utils.contrastive_loss import DMLLossCosine, DMLLossCosine from utils.bayesian_weighting import AutomaticWeightedLoss from torch.utils.tensorboard import SummaryWriter num_workers=2 EPSILON = 1e-8 batch_size = 64 class BLCL(BaseLearner): """ BLCL: Continual Learning class implementing incremental learning with contrastive and cross-entropy lossusing uncertaintiy-based weighting of the losses. It handles sequential training on new tasks, while preserving knowledge from previously learned classes. """ def __init__(self, args): super().__init__(args) self.args = args self._old_base = None self.args.update({'curr': self._cur_task}) self._network = AdaptiveNet(args, True) logging.info(f'>>> train generalized blocks:{self.args["train_base"]} train_adaptive:{self.args["train_adaptive"]}') self.writer = SummaryWriter(log_dir='runs/{}'.format(args['summary_file'])) def after_task(self): """ Update known classes after finishing a task. Handle freezing or training of generalized blocks based on the task configuration. """ self._known_classes = self._total_classes if self._cur_task == 0: if self.args['train_base']: logging.info("Train Generalized Blocks...") self._network.TaskAgnosticExtractor.train() for param in self._network.TaskAgnosticExtractor.parameters(): param.requires_grad = True else: logging.info("Fix Generalized Blocks...") self._network.TaskAgnosticExtractor.eval() for param in self._network.TaskAgnosticExtractor.parameters(): param.requires_grad = False logging.info('Exemplar size: {}'.format(self.exemplar_size)) def incremental_train(self, data_manager): """ Perform incremental training for the current task. This method updates the model to learn new classes Args: data_manager (DataManager): Manages datasets and provides task-specific data. """ self._cur_task += 1 self._total_classes = self._known_classes + data_manager.get_task_size(self._cur_task) # Update arguments with the current task number. self.args.update({'curr': self._cur_task}) # Update the model's fully connected layer to accommodate new classes. self._network.update_fc(self._total_classes) logging.info("****MODEL ARCHITECTURE after fc update*****") logging.info(self._network) logging.info('Learning on {}-{}'.format(self._known_classes, self._total_classes)) logging.info( "Known_classes: {}\tTotal_classes: {}\tcurrent_task: {}".format(self._known_classes, self._total_classes, self._cur_task) ) if self._cur_task>0: # Freeze the network of the previous trained adaptive network (requires grad = False) logging.info("self._curr_task {} and no of adaptiveExtractors {}".format(self._cur_task, len(self._network.AdaptiveExtractors))) for i in range(self._cur_task): for p in self._network.AdaptiveExtractors[i].parameters(): if self.args['train_adaptive']: p.requires_grad = True else: p.requires_grad = False if self.args["type"] == "avg": break logging.debug('All params: {}'.format(count_parameters(self._network))) logging.debug('Trainable params: {}'.format(count_parameters(self._network, True))) # Get the training dataset, including any rehearsal memory (previously stored samples). _, tr_targets, train_dataset = data_manager.get_dataset( np.arange(self._known_classes, self._total_classes), source='train', mode='train', appendent=self._get_memory(), ret_data=True ) self.train_loader = DataLoader( train_dataset, num_workers=num_workers, batch_size=self.args["batch_size"], shuffle=True ) _, te_targets, test_dataset = data_manager.get_dataset( np.arange(0, self._total_classes), source='test', mode='test', ret_data=True ) self.test_loader = DataLoader( test_dataset, batch_size=self.args["batch_size"], shuffle=False, num_workers=num_workers ) # Setup losses: Automatic weighting of cross-entropy loss and contrastive loss self.contrastive_loss = DMLLossCosine() self.awl = AutomaticWeightedLoss(2) if len(self._multiple_gpus) > 1: self._network = nn.DataParallel(self._network, self._multiple_gpus) self._train(self.train_loader, self.test_loader) self.build_rehearsal_memory(data_manager, self.samples_per_class) if len(self._multiple_gpus) > 1: self._network = self._network.module def set_network(self): if len(self._multiple_gpus) > 1: self._network = self._network.module self._network.train() #All status from eval to train if self.args['train_base']: self._network.TaskAgnosticExtractor.train() else: self._network.TaskAgnosticExtractor.eval() # set adaptive extractor's status self._network.AdaptiveExtractors[-1].train() if self._cur_task >= 1: for i in range(self._cur_task): if self.args['train_adaptive']: self._network.AdaptiveExtractors[i].train() else: self._network.AdaptiveExtractors[i].eval() if self.args["type"] == "avg": break if len(self._multiple_gpus) > 1: self._network = nn.DataParallel(self._network, self._multiple_gpus) def _train(self, train_loader, test_loader): self._network.to(self._device) if self._cur_task==0: logging.debug('## Initial Training ##') optimizer = optim.SGD([{"params": filter(lambda p: p.requires_grad, self._network.parameters()), "momentum": 0.9, "lr": self.args["init_lr"], "weight_decay": self.args["init_weight_decay"]}, {"params": self.awl.parameters(), "weight_decay": 0, "lr": self.args["init_lr"]}]) if self.args['scheduler'] == 'steplr': scheduler = optim.lr_scheduler.MultiStepLR( optimizer=optimizer, milestones=self.args['init_milestones'], gamma=self.args['init_lr_decay'] ) elif self.args['scheduler'] == 'cosine': scheduler = optim.lr_scheduler.CosineAnnealingLR( optimizer=optimizer, T_max=self.args['init_epoch'] ) else: raise NotImplementedError if not self.args['skip']: self._init_train(train_loader, test_loader, optimizer, scheduler) else: if isinstance(self._network, nn.DataParallel): self._network = self._network.module load_acc = self._network.load_checkpoint(self.args) self._network.to(self._device) if len(self._multiple_gpus) > 1: self._network = nn.DataParallel(self._network, self._multiple_gpus) cur_test_acc = self._compute_accuracy(self._network, self.test_loader) logging.info(f"Loaded_Test_Acc:{load_acc} Cur_Test_Acc:{cur_test_acc}") else: optimizer = optim.SGD([{"params": filter(lambda p: p.requires_grad, self._network.parameters()), "momentum": 0.9, "lr": self.args["lrate"], "weight_decay": self.args["weight_decay"]}, {"params": self.awl.parameters(), "weight_decay": 0, "lr": self.args["lrate"]}]) if self.args['scheduler'] == 'steplr': scheduler = optim.lr_scheduler.MultiStepLR( optimizer=optimizer, milestones=self.args['milestones'], gamma=self.args['lrate_decay'] ) elif self.args['scheduler'] == 'cosine': assert self.args['t_max'] is not None scheduler = optim.lr_scheduler.CosineAnnealingLR( optimizer=optimizer, T_max=self.args['t_max'] ) else: raise NotImplementedError self._update_representation(train_loader, test_loader, optimizer, scheduler) if len(self._multiple_gpus) > 1: self._network.module.weight_align(self._total_classes-self._known_classes) else: self._network.weight_align(self._total_classes-self._known_classes) self.writer.add_figure("Confusion matrix", self._createConfusionMatrix(self._network, self.test_loader), self._cur_task) self.writer.add_scalar('Accuracies', self.curr_acc, self._cur_task) def _test_model(self, test_loader, epoch): self._network.eval() self.awl.eval() losses = 0. losses_clf = 0. for i, (_, inputs, targets) in enumerate(test_loader): inputs, targets = inputs.to(self._device), targets.to(self._device) outputs = self._network(inputs) logits =outputs["logits"] loss_clf = F.cross_entropy(logits, targets) loss = loss_clf losses += loss.item() losses_clf += loss_clf.item() self.writer.add_scalar('Task: {} on {}-{} -- test/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses_clf / len(test_loader), epoch) def _init_train(self,train_loader, test_loader, optimizer, scheduler): prog_bar = tqdm(range(self.args["init_epoch"])) for _, epoch in enumerate(prog_bar): self._network.train() losses = 0. losses_clf = 0. losses_contrast = 0. correct, total = 0, 0 for i, (_, inputs, targets) in enumerate(train_loader): inputs, targets = inputs.to(self._device), targets.to(self._device) outputs = self._network(inputs) logits, embeddings =outputs["logits"], outputs["features"] loss_clf = F.cross_entropy(logits,targets) c_loss = self.contrastive_loss(embeddings, targets) loss = self.awl(loss_clf, c_loss) optimizer.zero_grad() loss.backward() optimizer.step() losses += loss.item() losses_clf+=loss_clf.item() losses_contrast+=c_loss.item() _, preds = torch.max(logits, dim=1) correct += preds.eq(targets.expand_as(preds)).cpu().sum() total += len(targets) params = list(next(self.awl.parameters())) self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses_contrast / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses_clf / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/Total_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/clf_weight'.format(self._cur_task, self._known_classes, self._total_classes), params[0], epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_weight'.format(self._cur_task, self._known_classes, self._total_classes), params[1], epoch) scheduler.step() train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2) if epoch%5==0: self._test_model(test_loader=self.test_loader, epoch=epoch) test_acc = self._compute_accuracy(self._network, test_loader) info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format( self._cur_task, epoch+1, self.args['init_epoch'], losses/len(train_loader), train_acc, test_acc) self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes), train_acc, epoch) self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), test_acc, epoch) else: info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Train_accy {:.2f}'.format( self._cur_task, epoch + 1, self.args['init_epoch'], losses/len(train_loader), train_acc) prog_bar.set_description(info) logging.info(info) def _update_representation(self, train_loader, test_loader, optimizer, scheduler): prog_bar = tqdm(range(self.args["epochs"])) for _, epoch in enumerate(prog_bar): self.set_network() losses = 0. losses_clf=0. losses_contrast=0. losses_aux=0. correct, total = 0, 0 for i, (_, inputs, targets) in enumerate(train_loader): inputs, targets = inputs.to(self._device), targets.to(self._device) outputs = self._network(inputs) logits, aux_logits, embeddings=outputs["logits"],outputs["aux_logits"],outputs["features"] loss_clf=F.cross_entropy(logits,targets) c_loss = self.contrastive_loss(embeddings,targets) aux_targets = targets.clone() aux_targets=torch.where(aux_targets-self._known_classes+1>0, aux_targets-self._known_classes+1,0) loss_aux=F.cross_entropy(aux_logits,aux_targets) loss= self.awl(loss_clf, c_loss) + self.args['alpha_aux']*loss_aux optimizer.zero_grad() loss.backward() optimizer.step() losses += loss.item() losses_aux+=loss_aux.item() losses_clf+=loss_clf.item() losses_contrast+=c_loss.item() _, preds = torch.max(logits, dim=1) correct += preds.eq(targets.expand_as(preds)).cpu().sum() total += len(targets) params = list(next(self.awl.parameters())) self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses_contrast / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/classification_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses_clf / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/Total_loss'.format(self._cur_task, self._known_classes, self._total_classes), losses / len(train_loader), epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/clf_weight'.format(self._cur_task, self._known_classes, self._total_classes), params[0], epoch) self.writer.add_scalar('Task: {} on {}-{} -- train/contrastive_weight'.format(self._cur_task, self._known_classes, self._total_classes), params[1], epoch) scheduler.step() train_acc = np.around(tensor2numpy(correct)*100 / total, decimals=2) if epoch % 5 == 0: self._test_model(test_loader=self.test_loader, epoch=epoch) test_acc = self._compute_accuracy(self._network, test_loader) info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}, Test_accy {:.2f}'.format( self._cur_task, epoch+1, self.args["epochs"], losses/len(train_loader),losses_clf/len(train_loader),losses_aux/len(train_loader),train_acc, test_acc) self.writer.add_scalar('Task: {} on {}-{} -- Accuracy train'.format(self._cur_task, self._known_classes, self._total_classes), train_acc, epoch) self.writer.add_scalar('Task: {} on {}-{} -- Accuracy test'.format(self._cur_task, self._known_classes, self._total_classes), test_acc, epoch) else: info = 'Task {}, Epoch {}/{} => Loss {:.3f}, Loss_clf {:.3f}, Loss_aux {:.3f}, Train_accy {:.2f}'.format( self._cur_task, epoch + 1, self.args["epochs"], losses/len(train_loader), losses_clf/len(train_loader), losses_aux/len(train_loader), train_acc) prog_bar.set_description(info) logging.info(info) def _construct_exemplar(self, data_manager, m): logging.info("Constructing exemplars...({} per classes)".format(m)) for class_idx in range(self._known_classes, self._total_classes): data, targets, idx_dataset = data_manager.get_dataset( np.arange(class_idx, class_idx + 1), source="train", mode="test", ret_data=True, ) idx_loader = DataLoader( idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4 ) vectors, _ = self._extract_vectors(idx_loader) vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T class_mean = np.mean(vectors, axis=0) # Select selected_exemplars = [] exemplar_vectors = [] # [n, feature_dim] for k in range(1, m + 1): S = np.sum( exemplar_vectors, axis=0 ) # [feature_dim] sum of selected exemplars vectors mu_p = (vectors + S) / k # [n, feature_dim] sum to all vectors i = np.argmin(np.sqrt(np.sum((class_mean - mu_p) ** 2, axis=1))) selected_exemplars.append( np.array(data[i]) ) # New object to avoid passing by inference exemplar_vectors.append( np.array(vectors[i]) ) # New object to avoid passing by inference vectors = np.delete( vectors, i, axis=0 ) # Remove it to avoid duplicative selection data = np.delete( data, i, axis=0 ) # Remove it to avoid duplicative selection if len(vectors) == 0: break # uniques = np.unique(selected_exemplars, axis=0) # print('Unique elements: {}'.format(len(uniques))) selected_exemplars = np.array(selected_exemplars) # exemplar_targets = np.full(m, class_idx) exemplar_targets = np.full(selected_exemplars.shape[0], class_idx) self._data_memory = ( np.concatenate((self._data_memory, selected_exemplars)) if len(self._data_memory) != 0 else selected_exemplars ) self._targets_memory = ( np.concatenate((self._targets_memory, exemplar_targets)) if len(self._targets_memory) != 0 else exemplar_targets ) # Exemplar mean idx_dataset = data_manager.get_dataset( [], source="train", mode="test", appendent=(selected_exemplars, exemplar_targets), ) idx_loader = DataLoader( idx_dataset, batch_size=batch_size, shuffle=False, num_workers=4 ) vectors, _ = self._extract_vectors(idx_loader) vectors = (vectors.T / (np.linalg.norm(vectors.T, axis=0) + EPSILON)).T mean = np.mean(vectors, axis=0) mean = mean / np.linalg.norm(mean) self._class_means[class_idx, :] = mean