def __init__(self): # all data self.data_train = MyDataset.get_data_split(Config.data_root, split="train") self.task_train = RandomAndCssDataset(self.data_train, Config.num_way, Config.num_shot, Config.transform_train, Config.transform_test) self.task_train_loader = DataLoader(self.task_train, Config.batch_size, True, num_workers=Config.num_workers) # model self.net = RunnerTool.to_cuda(Config.net) RunnerTool.to_cuda(self.net.apply(RunnerTool.weights_init)) self.norm = Normalize(2) # optim self.loss = RunnerTool.to_cuda(nn.MSELoss()) self.net_optim = torch.optim.SGD(self.net.parameters(), lr=Config.learning_rate, momentum=0.9, weight_decay=5e-4) # Eval self.test_tool_fsl = FSLTestTool( self.matching_test, data_root=Config.data_root, num_way=Config.num_way_test, num_shot=Config.num_shot, episode_size=Config.episode_size, test_episode=Config.test_episode, transform=self.task_train.transform_test) pass
def __init__(self, config): self.config = config # model self.norm = Normalize(2) self.matching_net = RunnerTool.to_cuda(self.config.matching_net) pass
def __init__(self): self.adjust_learning_rate = Config.ic_adjust_learning_rate # data self.data_train = TieredImageNetICDataset.get_data_all( Config.data_root) self.tiered_imagenet_dataset = TieredImageNetICDataset(self.data_train) self.ic_train_loader = DataLoader(self.tiered_imagenet_dataset, Config.ic_batch_size, shuffle=True, num_workers=Config.num_workers) self.ic_train_loader_eval = DataLoader(self.tiered_imagenet_dataset, Config.ic_batch_size, shuffle=False, num_workers=Config.num_workers) # IC self.produce_class = ProduceClass(len(self.data_train), Config.ic_out_dim, Config.ic_ratio) self.produce_class.init() # model self.ic_model = RunnerTool.to_cuda( ICResNet(low_dim=Config.ic_out_dim, encoder=Config.ic_net)) RunnerTool.to_cuda(self.ic_model.apply(RunnerTool.weights_init)) self.ic_loss = RunnerTool.to_cuda(nn.CrossEntropyLoss()) self.ic_model_optim = torch.optim.SGD(self.ic_model.parameters(), lr=Config.ic_learning_rate, momentum=0.9, weight_decay=5e-4) # Eval self.test_tool_ic = ICTestTool( feature_encoder=None, ic_model=self.ic_model, data_root=Config.data_root, batch_size=Config.ic_batch_size, num_workers=Config.num_workers, ic_out_dim=Config.ic_out_dim, transform=self.ic_train_loader.dataset.transform_test, k=Config.ic_knn) pass
def eval(self): self.ic_model.eval() with torch.no_grad(): ic_classes = np.zeros(shape=(len(self.tiered_imagenet_dataset), ), dtype=np.int) for image, label, idx in tqdm(self.ic_train_loader_eval): ic_out_logits, ic_out_l2norm = self.ic_model( RunnerTool.to_cuda(image)) ic_classes[idx] = np.argmax(ic_out_l2norm.cpu().numpy(), axis=-1) pass return self.data_train, ic_classes
def __init__(self, data_train, classes): # all data self.data_train = data_train self.task_train = TieredImageNetFSLDataset(self.data_train, classes, Config.fsl_num_way, Config.fsl_num_shot) self.task_train_loader = DataLoader(self.task_train, Config.fsl_batch_size, True, num_workers=Config.num_workers) # model self.matching_net = RunnerTool.to_cuda(Config.fsl_matching_net) self.matching_net = RunnerTool.to_cuda( nn.DataParallel(self.matching_net)) cudnn.benchmark = True RunnerTool.to_cuda(self.matching_net.apply(RunnerTool.weights_init)) self.norm = Normalize(2) # optim self.matching_net_optim = torch.optim.Adam( self.matching_net.parameters(), lr=Config.fsl_learning_rate) self.matching_net_scheduler = MultiStepLR(self.matching_net_optim, Config.fsl_lr_schedule, gamma=1 / 3) # loss self.fsl_loss = RunnerTool.to_cuda(nn.MSELoss()) # Eval self.test_tool_fsl = FSLTestTool( self.matching_test, data_root=Config.data_root, num_way=Config.fsl_num_way, num_shot=Config.fsl_num_shot, episode_size=Config.fsl_episode_size, test_episode=Config.fsl_test_episode, transform=self.task_train.transform_test) pass
def __init__(self, config): self.config = config # model self.norm = Normalize(2) self.matching_net = RunnerTool.to_cuda(self.config.matching_net) # check if self.config.is_check: return # Eval self.test_tool_fsl = FSLTestTool(self.matching_test, data_root=self.config.data_root, num_way=self.config.num_way, num_shot=self.config.num_shot, episode_size=self.config.episode_size, test_episode=self.config.test_episode, transform=self.config.transform_test, txt_path=self.config.log_file) pass
def __init__(self, config): self.config = config # all data self.data_train = MyDataset.get_data_split( self.config.data_root, split=MyDataset.dataset_split_train) self.task_train = TrainDataset( self.data_train, self.config.num_way, self.config.num_shot, transform_train_ic=self.config.transform_train_ic, transform_train_fsl=self.config.transform_train_fsl, transform_test=self.config.transform_test) self.task_train_loader = DataLoader( self.task_train, self.config.batch_size, True, num_workers=self.config.num_workers) # IC self.produce_class = ProduceClass(len(self.data_train), self.config.ic_out_dim, self.config.ic_ratio) self.produce_class.init() self.task_train.set_samples_class(self.produce_class.classes) # model self.norm = Normalize(2) self.matching_net = RunnerTool.to_cuda(self.config.matching_net) self.ic_model = RunnerTool.to_cuda( ICResNet(low_dim=self.config.ic_out_dim, resnet=self.config.resnet, modify_head=self.config.modify_head)) RunnerTool.to_cuda(self.matching_net.apply(RunnerTool.weights_init)) RunnerTool.to_cuda(self.ic_model.apply(RunnerTool.weights_init)) # optim self.matching_net_optim = torch.optim.SGD( self.matching_net.parameters(), lr=self.config.learning_rate, momentum=0.9, weight_decay=5e-4) self.ic_model_optim = torch.optim.SGD(self.ic_model.parameters(), lr=self.config.learning_rate, momentum=0.9, weight_decay=5e-4) # loss self.ic_loss = RunnerTool.to_cuda(nn.CrossEntropyLoss()) self.fsl_loss = RunnerTool.to_cuda(nn.MSELoss()) # Eval self.test_tool_fsl = FSLTestTool( self.matching_test, data_root=self.config.data_root, num_way=self.config.num_way, num_shot=self.config.num_shot, episode_size=self.config.episode_size, test_episode=self.config.test_episode, transform=self.task_train.transform_test, txt_path=self.config.log_file) self.test_tool_ic = ICTestTool( feature_encoder=None, ic_model=self.ic_model, data_root=self.config.data_root, batch_size=self.config.batch_size, num_workers=self.config.num_workers, ic_out_dim=self.config.ic_out_dim, transform=self.task_train.transform_test, txt_path=self.config.log_file) pass
def train(self): Tools.print() best_accuracy = 0.0 Tools.print("Training...", txt_path=self.config.log_file) # Init Update try: self.matching_net.eval() self.ic_model.eval() Tools.print("Init label {} .......", txt_path=self.config.log_file) self.produce_class.reset() for task_data, task_labels, task_index, task_ok in tqdm( self.task_train_loader): ic_labels = RunnerTool.to_cuda(task_index[:, -1]) task_data, task_labels = RunnerTool.to_cuda( task_data), RunnerTool.to_cuda(task_labels) ic_out_logits, ic_out_l2norm = self.ic_model(task_data[:, -1]) self.produce_class.cal_label(ic_out_l2norm, ic_labels) pass Tools.print("Epoch: {}/{}".format(self.produce_class.count, self.produce_class.count_2), txt_path=self.config.log_file) finally: pass for epoch in range(1, 1 + self.config.train_epoch): self.matching_net.train() self.ic_model.train() Tools.print() mn_lr = self.config.adjust_learning_rate(self.matching_net_optim, epoch, self.config.first_epoch, self.config.t_epoch, self.config.learning_rate) ic_lr = self.config.adjust_learning_rate(self.ic_model_optim, epoch, self.config.first_epoch, self.config.t_epoch, self.config.learning_rate) Tools.print('Epoch: [{}] mn_lr={} ic_lr={}'.format( epoch, mn_lr, ic_lr), txt_path=self.config.log_file) self.produce_class.reset() Tools.print(self.task_train.classes) is_ok_total, is_ok_acc = 0, 0 all_loss, all_loss_fsl, all_loss_ic = 0.0, 0.0, 0.0 for task_data, task_labels, task_index, task_ok in tqdm( self.task_train_loader): ic_labels = RunnerTool.to_cuda(task_index[:, -1]) task_data, task_labels = RunnerTool.to_cuda( task_data), RunnerTool.to_cuda(task_labels) ########################################################################### # 1 calculate features relations = self.matching(task_data) ic_out_logits, ic_out_l2norm = self.ic_model(task_data[:, -1]) # 2 ic_targets = self.produce_class.get_label(ic_labels) self.produce_class.cal_label(ic_out_l2norm, ic_labels) # 3 loss loss_fsl = self.fsl_loss(relations, task_labels) loss_ic = self.ic_loss(ic_out_logits, ic_targets) loss = loss_fsl * self.config.loss_fsl_ratio + loss_ic * self.config.loss_ic_ratio all_loss += loss.item() all_loss_fsl += loss_fsl.item() all_loss_ic += loss_ic.item() # 4 backward self.ic_model.zero_grad() loss_ic.backward() self.ic_model_optim.step() self.matching_net.zero_grad() loss_fsl.backward() self.matching_net_optim.step() # is ok is_ok_acc += torch.sum(torch.cat(task_ok)) is_ok_total += torch.prod( torch.tensor(torch.cat(task_ok).shape)) ########################################################################### pass ########################################################################### # print Tools.print( "{:6} loss:{:.3f} fsl:{:.3f} ic:{:.3f} ok:{:.3f}({}/{})". format(epoch + 1, all_loss / len(self.task_train_loader), all_loss_fsl / len(self.task_train_loader), all_loss_ic / len(self.task_train_loader), int(is_ok_acc) / int(is_ok_total), is_ok_acc, is_ok_total), txt_path=self.config.log_file) Tools.print("Train: [{}] {}/{}".format(epoch, self.produce_class.count, self.produce_class.count_2), txt_path=self.config.log_file) ########################################################################### ########################################################################### # Val if epoch % self.config.val_freq == 0: self.matching_net.eval() self.ic_model.eval() self.test_tool_ic.val(epoch=epoch) val_accuracy = self.test_tool_fsl.val(episode=epoch, is_print=True) if val_accuracy > best_accuracy: best_accuracy = val_accuracy torch.save(self.matching_net.state_dict(), Tools.new_dir(self.config.mn_dir)) torch.save(self.ic_model.state_dict(), Tools.new_dir(self.config.ic_dir)) Tools.print("Save networks for epoch: {}".format(epoch), txt_path=self.config.log_file) pass pass ########################################################################### pass pass
def train(self): Tools.print() Tools.print("Training...") best_accuracy = 0.0 for epoch in range(1, 1 + Config.fsl_train_epoch): self.matching_net.train() Tools.print() all_loss, is_ok_total, is_ok_acc = 0.0, 0, 0 for task_data, task_labels, task_index, task_ok in tqdm( self.task_train_loader): task_data, task_labels = RunnerTool.to_cuda( task_data), RunnerTool.to_cuda(task_labels) ########################################################################### # 1 calculate features relations = self.matching(task_data) # 3 loss loss = self.fsl_loss(relations, task_labels) all_loss += loss.item() # 4 backward self.matching_net.zero_grad() loss.backward() self.matching_net_optim.step() # is ok is_ok_acc += torch.sum(torch.cat(task_ok)) is_ok_total += torch.prod( torch.tensor(torch.cat(task_ok).shape)) ########################################################################### pass ########################################################################### # print Tools.print("{:6} loss:{:.3f} ok:{:.3f}({}/{}) lr:{}".format( epoch, all_loss / len(self.task_train_loader), int(is_ok_acc) / int(is_ok_total), is_ok_acc, is_ok_total, self.matching_net_scheduler.get_last_lr())) self.matching_net_scheduler.step() ########################################################################### ########################################################################### # Val if epoch % Config.fsl_val_freq == 0: self.matching_net.eval() val_accuracy = self.test_tool_fsl.val(episode=epoch, is_print=True, has_test=False) if val_accuracy > best_accuracy: best_accuracy = val_accuracy torch.save(self.matching_net.state_dict(), Config.mn_dir) Tools.print("Save networks for epoch: {}".format(epoch)) pass pass ########################################################################### pass pass
def train(self): Tools.print() Tools.print("Training...") best_accuracy = 0.0 # Init Update try: self.ic_model.eval() Tools.print("Init label {} .......") self.produce_class.reset() with torch.no_grad(): for image, label, idx in tqdm(self.ic_train_loader): image, idx = RunnerTool.to_cuda(image), RunnerTool.to_cuda( idx) ic_out_logits, ic_out_l2norm = self.ic_model(image) self.produce_class.cal_label(ic_out_l2norm, idx) pass pass Tools.print("Epoch: {}/{}".format(self.produce_class.count, self.produce_class.count_2)) finally: pass for epoch in range(1, 1 + Config.ic_train_epoch): self.ic_model.train() Tools.print() ic_lr = self.adjust_learning_rate(self.ic_model_optim, epoch, Config.ic_first_epoch, Config.ic_t_epoch, Config.ic_learning_rate) Tools.print('Epoch: [{}] ic_lr={}'.format(epoch, ic_lr)) all_loss = 0.0 self.produce_class.reset() for image, label, idx in tqdm(self.ic_train_loader): image, label, idx = RunnerTool.to_cuda( image), RunnerTool.to_cuda(label), RunnerTool.to_cuda(idx) ########################################################################### # 1 calculate features ic_out_logits, ic_out_l2norm = self.ic_model(image) # 2 calculate labels ic_targets = self.produce_class.get_label(idx) self.produce_class.cal_label(ic_out_l2norm, idx) # 3 loss loss = self.ic_loss(ic_out_logits, ic_targets) all_loss += loss.item() # 4 backward self.ic_model.zero_grad() loss.backward() self.ic_model_optim.step() ########################################################################### pass ########################################################################### # print Tools.print("{:6} loss:{:.4f}".format( epoch, all_loss / len(self.ic_train_loader))) Tools.print("Train: [{}] {}/{}".format(epoch, self.produce_class.count, self.produce_class.count_2)) ########################################################################### ########################################################################### # Val if epoch % Config.ic_val_freq == 0: self.ic_model.eval() val_accuracy = self.test_tool_ic.val(epoch=epoch) if val_accuracy > best_accuracy: best_accuracy = val_accuracy torch.save(self.ic_model.state_dict(), Config.ic_dir) Tools.print("Save networks for epoch: {}".format(epoch)) pass pass ########################################################################### pass pass
def train(self): Tools.print() Tools.print("Training...") best_accuracy = 0.0 for epoch in range(1, 1 + Config.train_epoch): self.net.train() Tools.print() all_loss = 0.0 net_lr = Config.adjust_learning_rate(self.net_optim, epoch, Config.first_epoch, Config.t_epoch, Config.learning_rate) Tools.print('Epoch: [{}] net_lr={}'.format(epoch, net_lr)) for task_data, task_labels, task_index in tqdm( self.task_train_loader): task_data, task_labels = RunnerTool.to_cuda( task_data), RunnerTool.to_cuda(task_labels) ########################################################################### # 1 calculate features relations = self.matching(task_data) # 2 loss loss = self.loss(relations, task_labels) all_loss += loss.item() # 3 backward self.net.zero_grad() loss.backward() self.net_optim.step() ########################################################################### pass ########################################################################### # print Tools.print("{:6} loss:{:.3f}".format( epoch, all_loss / len(self.task_train_loader))) ########################################################################### ########################################################################### # Val if epoch % Config.val_freq == 0: Tools.print() Tools.print("Test {} {} .......".format( epoch, Config.model_name)) self.net.eval() val_accuracy = self.test_tool_fsl.val(episode=epoch, is_print=True) if val_accuracy > best_accuracy: best_accuracy = val_accuracy torch.save(self.net.state_dict(), Config.net_dir) Tools.print("Save networks for epoch: {}".format(epoch)) pass pass ########################################################################### pass pass