def __init__(self, net, size, mean=0.0, std=1.0, nms_method=None, iou_threshold=0.45, filter_threshold=0.01, candidate_size=200, sigma=0.5, device=None): self.net = net self.transform = PredictionTransform(size, mean, std) self.iou_threshold = iou_threshold self.filter_threshold = filter_threshold self.candidate_size = candidate_size self.nms_method = nms_method self.sigma = sigma if device: self.device = device else: self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") self.net.to(self.device) self.net.eval() self.timer = Timer()
def __init__(self, net, size, mean=0.0, std=1.0, nms_method=None, iou_threshold=0.45, filter_threshold=0.01, candidate_size=200, sigma=0.5, device=None): """Implement Predictor while testing of the model Arguments: net: an object of net to used for prediction size: variable containing size of image as input mean: an array variable containing mean value of all the channels of input std: variable containing standard deviation of image as input nms_method : string variable contaning type of negative mining iou_threshold : a float variable containing threshold value of IOU filter_threshold : a float variable containing threshold value of filter candidate_size: only consider the candidates with the highest scores sigma: the parameter in score re-computation. (for soft negative mining) scores[i] = scores[i] * exp(-(iou_i)^2 / simga) device : variable containing device on which net needs to do computation """ self.net = net self.transform = PredictionTransform(size, mean, std) self.iou_threshold = iou_threshold self.filter_threshold = filter_threshold self.candidate_size = candidate_size self.nms_method = nms_method self.sigma = sigma if device: self.device = device else: self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") self.net.to(self.device) self.net.eval() self.timer = Timer()
def __init__(self, log_dir): self.writer = None self.selected_module = "" self.writer = SummaryWriter(str(log_dir)) self.step = 0 self.mode = "" self.tb_writer_ftns = { "add_scalar", "add_scalars", "add_image", "add_images", "add_audio", "add_text", "add_histogram", "add_pr_curve", "add_embedding", } self.tag_mode_exceptions = {"add_histogram", "add_embedding"} self.timer = Timer()
def get_data_df(self): doc = self.doc i_0 = self.first_i predicates = doc._.lex_matches n = len(predicates) t = Timer() t.start() data = [{ 'i': i_0 + tok.i, 'sent_i': i_0 + tok.sent.start, 't': i_0 + tok._.subsent_root.i, 'neg': tok._.negated, 'lemma': tok.lemma_, 'text': tok.text, 'R_agent': agent.root.text if agent else None, 'R_patient': patient.root.text if patient else None, **{('L_' + doc.vocab[cat].text): 1.0 for cat in tok._.lex}, } for tok in predicates for agent in (tok._.agents or [None]) for patient in (tok._.patients or [None])] table = pd.DataFrame(data).sort_values('i') predicate_cols = [c for c in list(table.columns) if c.startswith('L_')] table[predicate_cols] = table[predicate_cols].fillna(0) t.stop() logger.debug('%d predicates (%d distinct) [%s]', len(table.index), n, t) return table
def get_entities_df(self): t = Timer() t.start() ent_cls = proc_ent.entity_classifier(self.doc.vocab) df = pd.DataFrame(ent_cls(self.doc)) t.stop() logger.debug('%d entities [%s]', len(df.index), t) return df
labels = labels.to(device) num += 1 with torch.no_grad(): confidence, locations = net(images) regression_loss, classification_loss = criterion(confidence, locations, labels, boxes) loss = regression_loss + classification_loss running_loss += loss.item() running_regression_loss += regression_loss.item() running_classification_loss += classification_loss.item() return running_loss / num, running_regression_loss / num, running_classification_loss / num if __name__ == '__main__': timer = Timer() logging.info(args) if args.net == 'vgg16-ssd': create_net = create_vgg_ssd config = vgg_ssd_config elif args.net == 'mb1-ssd': create_net = create_mobilenetv1_ssd config = mobilenetv1_ssd_config elif args.net == 'mb1-ssd-lite': create_net = create_mobilenetv1_ssd_lite config = mobilenetv1_ssd_config elif args.net == 'sq-ssd-lite': create_net = create_squeezenet_ssd_lite config = squeezenet_ssd_config elif args.net == 'mb2-ssd-lite':
class Predictor: def __init__(self, net, size, mean=0.0, std=1.0, nms_method=None, iou_threshold=0.45, filter_threshold=0.01, candidate_size=200, sigma=0.5, device=None): """Implement Predictor while testing of the model Arguments: net: an object of net to used for prediction size: variable containing size of image as input mean: an array variable containing mean value of all the channels of input std: variable containing standard deviation of image as input nms_method : string variable contaning type of negative mining iou_threshold : a float variable containing threshold value of IOU filter_threshold : a float variable containing threshold value of filter candidate_size: only consider the candidates with the highest scores sigma: the parameter in score re-computation. (for soft negative mining) scores[i] = scores[i] * exp(-(iou_i)^2 / simga) device : variable containing device on which net needs to do computation """ self.net = net self.transform = PredictionTransform(size, mean, std) self.iou_threshold = iou_threshold self.filter_threshold = filter_threshold self.candidate_size = candidate_size self.nms_method = nms_method self.sigma = sigma print("Predictor arg device", device) if device: self.device = device else: self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") self.net.to(self.device) self.net.eval() self.timer = Timer() def predict(self, image, top_k=-1, prob_threshold=None): """Implement Predictor while testing of the model Arguments: image: image input for predictor prob_threshold: threshold for probability top_k: keep top_k results. If k <= 0, keep all the results. Returns: predicted boxes, labels and their probability """ cpu_device = torch.device("cpu") height, width, _ = image.shape image = self.transform(image) images = image.unsqueeze(0) images = images.to(self.device) with torch.no_grad(): self.timer.start() scores, boxes = self.net.forward(images) print("Inference time: ", self.timer.end()) boxes = boxes[0] scores = scores[0] if not prob_threshold: prob_threshold = self.filter_threshold # this version of nms is slower on GPU, so we move data to CPU. boxes = boxes.to(cpu_device) scores = scores.to(cpu_device) picked_box_probs = [] picked_labels = [] for class_index in range(1, scores.size(1)): probs = scores[:, class_index] mask = probs > prob_threshold probs = probs[mask] if probs.size(0) == 0: continue subset_boxes = boxes[mask, :] box_probs = torch.cat([subset_boxes, probs.reshape(-1, 1)], dim=1) box_probs = box_utils.nms(box_probs, self.nms_method, score_threshold=prob_threshold, iou_threshold=self.iou_threshold, sigma=self.sigma, top_k=top_k, candidate_size=self.candidate_size) picked_box_probs.append(box_probs) picked_labels.extend([class_index] * box_probs.size(0)) if not picked_box_probs: return torch.tensor([]), torch.tensor([]), torch.tensor([]) picked_box_probs = torch.cat(picked_box_probs) picked_box_probs[:, 0] *= width picked_box_probs[:, 1] *= height picked_box_probs[:, 2] *= width picked_box_probs[:, 3] *= height return picked_box_probs[:, :4], torch.tensor( picked_labels), picked_box_probs[:, 4]
def train(self): """The function for the pre-train phase.""" # Set the pretrain log trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['train_iou'] = [] trlog['val_iou'] = [] trlog['max_iou'] = 0.0 trlog['max_iou_epoch'] = 0 # Set the timer timer = Timer() # Set global count to zero global_count = 0 # Set tensorboardX writer = SummaryWriter(comment=self.args.save_path) # Start pretrain for epoch in range(1, self.args.pre_max_epoch + 1): # Update learning rate self.lr_scheduler.step() # Set the model to train mode self.model.train() self.model.mode = 'train' # Set averager classes to record training losses and accuracies train_loss_averager = Averager() train_acc_averager = Averager() train_iou_averager = Averager() # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, label = [_.cuda() for _ in batch] else: data = batch[0] label = batch[1] # Output logits for model logits = self.model(data) # Calculate train loss # CD loss is modified in the whole project to incorporate ony Cross Entropy loss. Modify as per requirement. #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label) loss = self.CD(logits, label) # Calculate train accuracy self._reset_metrics() seg_metrics = eval_metrics(logits, label, self.args.num_classes) self._update_seg_metrics(*seg_metrics) pixAcc, mIoU, _ = self._get_seg_metrics( self.args.num_classes).values() # Add loss and accuracy for the averagers train_loss_averager.add(loss.item()) train_acc_averager.add(pixAcc) train_iou_averager.add(mIoU) # Print loss and accuracy till this step tqdm_gen.set_description( 'Epoch {}, Loss={:.4f} Acc={:.4f} IOU={:.4f}'.format( epoch, train_loss_averager.item(), train_acc_averager.item() * 100.0, train_iou_averager.item())) # Loss backwards and optimizer updates self.optimizer.zero_grad() loss.backward() self.optimizer.step() # Update the averagers train_loss_averager = train_loss_averager.item() train_acc_averager = train_acc_averager.item() train_iou_averager = train_iou_averager.item() writer.add_scalar('data/train_loss(Pre)', float(train_loss_averager), epoch) writer.add_scalar('data/train_acc(Pre)', float(train_acc_averager) * 100.0, epoch) writer.add_scalar('data/train_iou (Pre)', float(train_iou_averager), epoch) print( 'Epoch {}, Train: Loss={:.4f}, Acc={:.4f}, IoU={:.4f}'.format( epoch, train_loss_averager, train_acc_averager * 100.0, train_iou_averager)) # Start validation for this epoch, set model to eval mode self.model.eval() self.model.mode = 'val' # Set averager classes to record validation losses and accuracies val_loss_averager = Averager() val_acc_averager = Averager() val_iou_averager = Averager() # Print previous information if epoch % 1 == 0: print('Best Val Epoch {}, Best Val IoU={:.4f}'.format( trlog['max_iou_epoch'], trlog['max_iou'])) # Run validation for i, batch in enumerate(self.val_loader, 1): if torch.cuda.is_available(): data, labels, _ = [_.cuda() for _ in batch] else: data = batch[0] label = labels[0] p = self.args.way * self.args.shot data_shot, data_query = data[:p], data[p:] label_shot, label = labels[:p], labels[p:] par = data_shot, label_shot, data_query logits = self.model(par) # Calculate preval loss #loss = self.FL(logits, label) + self.CD(logits,label) + self.LS(logits,label) loss = self.CD(logits, label) # Calculate val accuracy self._reset_metrics() seg_metrics = eval_metrics(logits, label, self.args.way) self._update_seg_metrics(*seg_metrics) pixAcc, mIoU, _ = self._get_seg_metrics(self.args.way).values() val_loss_averager.add(loss.item()) val_acc_averager.add(pixAcc) val_iou_averager.add(mIoU) # Update validation averagers val_loss_averager = val_loss_averager.item() val_acc_averager = val_acc_averager.item() val_iou_averager = val_iou_averager.item() writer.add_scalar('data/val_loss(Pre)', float(val_loss_averager), epoch) writer.add_scalar('data/val_acc(Pre)', float(val_acc_averager) * 100.0, epoch) writer.add_scalar('data/val_iou (Pre)', float(val_iou_averager), epoch) # Print loss and accuracy for this epoch print('Epoch {}, Val: Loss={:.4f} Acc={:.4f} IoU={:.4f}'.format( epoch, val_loss_averager, val_acc_averager * 100.0, val_iou_averager)) # Update best saved model if val_iou_averager > trlog['max_iou']: trlog['max_iou'] = val_iou_averager trlog['max_iou_epoch'] = epoch print("model saved in max_iou") self.save_model('max_iou') # Save model every 10 epochs if epoch % 10 == 0: self.save_model('epoch' + str(epoch)) # Update the logs trlog['train_loss'].append(train_loss_averager) trlog['train_acc'].append(train_acc_averager) trlog['val_loss'].append(val_loss_averager) trlog['val_acc'].append(val_acc_averager) trlog['train_iou'].append(train_iou_averager) trlog['val_iou'].append(val_iou_averager) # Save log torch.save(trlog, osp.join(self.args.save_path, 'trlog')) if epoch % 1 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) writer.close()
testset_list = os.path.join('/home/gyt/dataset', args.dataset, 'ImageSets/Main/test.txt') with open(testset_list, 'r') as fr: test_dataset = fr.read().split() num_images = len(test_dataset) # testing scale if args.dataset == "FDDB": resize = 2.5 elif args.dataset == "PASCAL": resize = 2.5 elif args.dataset == "AFW" or "WIDER" in args.dataset: resize = 1 _t = {'forward_pass': Timer(), 'misc': Timer()} # name_list = ["0_Parade_Parade_0_519.jpg"] # testing begin for i, img_name in enumerate(test_dataset): iter_idx = i image_path = testset_folder + img_name + '.jpg' img = np.float32(cv2.imread(image_path, cv2.IMREAD_COLOR)) origin_scale = torch.Tensor( [img.shape[1], img.shape[0], img.shape[1], img.shape[0]]) landmark_origin_scale = torch.Tensor([img.shape[1], img.shape[0]]).repeat(5) if resize != 1:
def train(self, trial): """The function for the meta-train phase.""" # Set the meta-train log trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['max_acc'] = 0.0 trlog['max_acc_epoch'] = 0 # Set the timer timer = Timer() # Set global count to zero global_count = 0 # Set tensorboardX writer = SummaryWriter(comment=self.args.save_path) # Generate the labels for train set of the episodes label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) worstClasses = [] # Start meta-train for epoch in range(1, self.args.max_epoch + 1): # Update learning rate self.lr_scheduler.step() # Set the model to train mode self.model.train() # Set averager classes to record training losses and accuracies train_loss_averager = Averager() train_acc_averager = Averager() # Generate the labels for test set of the episodes during meta-train updates label = torch.arange(self.args.way).repeat(self.args.train_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, targ = [_.cuda() for _ in batch] else: data, targ = batch p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] # Output logits for model if self.args.cross_att: label_one_hot = self.one_hot(label).to(label.device) ytest, cls_scores, logits = self.model( (data_shot, label_shot, data_query), ytest=label_one_hot) pids = label_shot loss = self.crossAttLoss(ytest, cls_scores, label, pids) logits = logits[0] else: logits = self.model((data_shot, label_shot, data_query)) # Calculate meta-train loss loss = F.cross_entropy(logits, label) if self.args.distill_id: teachLogits = self.teacher( (data_shot, label_shot, data_query)) kl = F.kl_div(F.log_softmax(logits / self.args.kl_temp, dim=1), F.softmax(teachLogits / self.args.kl_temp, dim=1), reduction="batchmean") loss = (kl * self.args.kl_interp * self.args.kl_temp * self.args.kl_temp + loss * (1 - self.args.kl_interp)) acc = count_acc(logits, label) # Write the tensorboardX records writer.add_scalar('data/loss', float(loss), global_count) writer.add_scalar('data/acc', float(acc), global_count) # Print loss and accuracy for this step tqdm_gen.set_description( 'Epoch {}, Loss={:.4f} Acc={:.4f}'.format( epoch, loss.item(), acc)) # Add loss and accuracy for the averagers train_loss_averager.add(loss.item()) train_acc_averager.add(acc) # Loss backwards and optimizer updates self.optimizer.zero_grad() loss.backward() self.optimizer.step() if self.args.hard_tasks: if len(worstClasses) == self.args.way: inds = self.train_sampler.hardBatch(worstClasses) batch = [self.trainset[i][0] for i in inds] data_shot, data_query = data[:p], data[p:] logits = self.model( (data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) self.optimizer.zero_grad() loss.backward() self.optimizer.step() worstClasses = [] else: error_mat = (logits.argmax(dim=1) == label).view( self.args.train_query, self.args.way) worst = error_mat.float().mean(dim=0).argmin() worst_trueInd = targ[worst] worstClasses.append(worst_trueInd) # Update the averagers train_loss_averager = train_loss_averager.item() train_acc_averager = train_acc_averager.item() # Start validation for this epoch, set model to eval mode self.model.eval() # Set averager classes to record validation losses and accuracies val_loss_averager = Averager() val_acc_averager = Averager() # Generate the labels for test set of the episodes during meta-val for this epoch label = torch.arange(self.args.way).repeat(self.args.val_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) # Print previous information if epoch % 10 == 0: print('Best Epoch {}, Best Val Acc={:.4f}'.format( trlog['max_acc_epoch'], trlog['max_acc'])) # Run meta-validation for i, batch in enumerate(self.val_loader, 1): if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] if self.args.cross_att: label_one_hot = self.one_hot(label).to(label.device) ytest, cls_scores, logits = self.model( (data_shot, label_shot, data_query), ytest=label_one_hot) pids = label_shot loss = self.crossAttLoss(ytest, cls_scores, label, pids) logits = logits[0] else: logits = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) val_loss_averager.add(loss.item()) val_acc_averager.add(acc) # Update validation averagers val_loss_averager = val_loss_averager.item() val_acc_averager = val_acc_averager.item() # Write the tensorboardX records writer.add_scalar('data/val_loss', float(val_loss_averager), epoch) writer.add_scalar('data/val_acc', float(val_acc_averager), epoch) # Print loss and accuracy for this epoch print('Epoch {}, Val, Loss={:.4f} Acc={:.4f}'.format( epoch, val_loss_averager, val_acc_averager)) # Update best saved model if val_acc_averager > trlog['max_acc']: trlog['max_acc'] = val_acc_averager trlog['max_acc_epoch'] = epoch self.save_model('max_acc') # Update the logs trlog['train_loss'].append(train_loss_averager) trlog['train_acc'].append(train_acc_averager) trlog['val_loss'].append(val_loss_averager) trlog['val_acc'].append(val_acc_averager) # Save log torch.save(trlog, osp.join(self.args.save_path, 'trlog')) if epoch % 10 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) trial.report(val_acc_averager, epoch) writer.close()
pretrained_dict = {k: v for k, v in pretrained_net_dict.items() if k in model_dict} # 2. overwrite entries in the existing state dict model_dict.update(pretrained_dict) pred_enc.load_state_dict(model_dict) model_dict = pred_dec.state_dict() # 1. filter out unnecessary keys pretrained_dict = {k: v for k, v in pretrained_net_dict.items() if k in model_dict} # 2. overwrite entries in the existing state dict model_dict.update(pretrained_dict) pred_dec.load_state_dict(model_dict) if __name__ == '__main__': timer = Timer() logging.info(args) config = mobilenetv1_ssd_config #config file for priors etc. train_transform = TrainAugmentation(config.image_size, config.image_mean, config.image_std) target_transform = MatchPrior(config.priors, config.center_variance, config.size_variance, 0.5) test_transform = TestTransform(config.image_size, config.image_mean, config.image_std) logging.info("Prepare training datasets.") train_dataset = VIDDataset(args.datasets, transform=train_transform, target_transform=target_transform) label_file = os.path.join("models/", "vid-model-labels.txt") store_labels(label_file, train_dataset._classes_names) num_classes = len(train_dataset._classes_names)
def get_map(net_para, dataset, label_file): DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") eval_path = pathlib.Path("eval_results") eval_path.mkdir(exist_ok=True) timer = Timer() class_names = [name.strip() for name in open(label_file).readlines()] dataset = VOCDataset(dataset, is_test=True) true_case_stat, all_gb_boxes, all_difficult_cases = group_annotation_by_class( dataset) net = create_mobilenetv2_ssd_lite(len(class_names), width_mult=1.0, is_test=True) timer.start("Load Model") net.load_weight(net_para) net = net.to(DEVICE) predictor = create_mobilenetv2_ssd_lite_predictor(net, nms_method="hard", device=DEVICE) results = [] for i in tqdm(range(len(dataset))): timer.start("Load Image") image = dataset.get_image(i) timer.start("Predict") boxes, labels, probs = predictor.predict(image) indexes = torch.ones(labels.size(0), 1, dtype=torch.float32) * i results.append( torch.cat( [ indexes.reshape(-1, 1), labels.reshape(-1, 1).float(), probs.reshape(-1, 1), boxes + 1.0 # matlab's indexes start from 1 ], dim=1)) results = torch.cat(results) for class_index, class_name in enumerate(class_names): if class_index == 0: continue # ignore background prediction_path = eval_path / f"det_test_{class_name}.txt" with open(prediction_path, "w") as f: sub = results[results[:, 1] == class_index, :] for i in range(sub.size(0)): prob_box = sub[i, 2:].numpy() image_id = dataset.ids[int(sub[i, 0])] print(image_id + " " + " ".join([str(v) for v in prob_box]), file=f) aps = [] print("\n\nAverage Precision Per-class:") for class_index, class_name in enumerate(class_names): if class_index == 0: continue prediction_path = eval_path / f"det_test_{class_name}.txt" ap = compute_average_precision_per_class( true_case_stat[class_index], all_gb_boxes[class_index], all_difficult_cases[class_index], prediction_path, 0.5, True) aps.append(ap) print(f"{class_name}: {ap}") print(f"\nAverage Precision Across All Classes:{sum(aps) / len(aps)}") return sum(aps) / len(aps)
def train(self): trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['max_acc'] = 0.0 trlog['max_acc_epoch'] = 0 timer = Timer() global_count = 0 writer = SummaryWriter(logdir=self.args.save_path) for epoch in range(1, self.args.max_epoch + 1): self.lr_scheduler.step() self.model.train() tl = Averager() ta = Averager() label = torch.arange(self.args.way).repeat(self.args.train_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): global_count = global_count + 1 if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] logits, combination_list, basestep_list = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) writer.add_scalar('data/loss', float(loss), global_count) writer.add_scalar('data/acc', float(acc), global_count) writer.add_scalar('combination_value/0', float(combination_list[0][0]), global_count) writer.add_scalar('combination_value/24', float(combination_list[24][0]), global_count) writer.add_scalar('combination_value/49', float(combination_list[49][0]), global_count) writer.add_scalar('combination_value/74', float(combination_list[74][0]), global_count) writer.add_scalar('combination_value/99', float(combination_list[99][0]), global_count) writer.add_scalar('basestep_value/0', float(basestep_list[0][0]), global_count) writer.add_scalar('basestep_value/24', float(basestep_list[24][0]), global_count) writer.add_scalar('basestep_value/49', float(basestep_list[49][0]), global_count) writer.add_scalar('basestep_value/74', float(basestep_list[74][0]), global_count) writer.add_scalar('basestep_value/99', float(basestep_list[99][0]), global_count) tqdm_gen.set_description('Epoch {}, Loss={:.4f} Acc={:.4f}'.format(epoch, loss.item(), acc)) tl.add(loss.item()) ta.add(acc) self.optimizer.zero_grad() loss.backward() self.optimizer.step() tl = tl.item() ta = ta.item() self.model.eval() vl = Averager() va = Averager() label = torch.arange(self.args.way).repeat(self.args.val_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) print('Best Epoch {}, Best Val Acc={:.4f}'.format(trlog['max_acc_epoch'], trlog['max_acc'])) tqdm_gen1 = tqdm.tqdm(self.val_loader) for i, batch in enumerate(tqdm_gen1, 1): if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] logits, _, _ = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) vl.add(loss.item()) va.add(acc) vl = vl.item() va = va.item() writer.add_scalar('data/val_loss', float(vl), epoch) writer.add_scalar('data/val_acc', float(va), epoch) print('Epoch {}, Val, Loss={:.4f} Acc={:.4f}'.format(epoch, vl, va)) if va > trlog['max_acc']: trlog['max_acc'] = va trlog['max_acc_epoch'] = epoch self.save_model('max_acc') if epoch % 10 == 0: self.save_model('epoch'+str(epoch)) trlog['train_loss'].append(tl) trlog['train_acc'].append(ta) trlog['val_loss'].append(vl) trlog['val_acc'].append(va) torch.save(trlog, osp.join(self.args.save_path, 'trlog')) self.save_model('epoch-last') writer.close()
class TensorboardWriter: """A second class for interfacing with tensorboard. Derived from the wrapper provided with Pytorch-Template by Victor Huang. (https://github.com/victoresque/pytorch-template) """ def __init__(self, log_dir): self.writer = None self.selected_module = "" self.writer = SummaryWriter(str(log_dir)) self.step = 0 self.mode = "" self.tb_writer_ftns = { "add_scalar", "add_scalars", "add_image", "add_images", "add_audio", "add_text", "add_histogram", "add_pr_curve", "add_embedding", } self.tag_mode_exceptions = {"add_histogram", "add_embedding"} self.timer = Timer() def set_step(self, step, mode="train"): self.mode = mode self.step = step if step == 0: self.timer.reset() else: duration = self.timer.check() self.add_scalar("steps_per_sec", 1 / duration) def __getattr__(self, name): """ If visualization is configured to use: return add_data() methods of tensorboard with additional information (step, tag) added. Otherwise: return a blank function handle that does nothing """ if name in self.tb_writer_ftns: add_data = getattr(self.writer, name, None) def wrapper(tag, data, *args, **kwargs): if add_data is not None: # add mode(train/valid) tag if name not in self.tag_mode_exceptions: tag = f"{tag}/{self.mode}" add_data(tag, data, self.step, *args, **kwargs) return wrapper else: # default action for returning methods defined in this class, set_step() # for instance. try: attr = object.__getattr__(name) except AttributeError: msg = "type object '{}' has no attribute '{}'" raise AttributeError(msg.format(self.selected_module, name)) return attr
def train(self): trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['max_acc'] = 0.0 trlog['max_acc_epoch'] = 0 timer = Timer() global_count = 0 writer = SummaryWriter(comment=self.args.save_path) for epoch in range(1, self.args.pre_max_epoch + 1): self.lr_scheduler.step() self.model.train() self.model.mode = 'pre' tl = Averager() ta = Averager() tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): global_count = global_count + 1 if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] label = batch[1] if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) logits = self.model(data) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) writer.add_scalar('data/loss', float(loss), global_count) writer.add_scalar('data/acc', float(acc), global_count) tqdm_gen.set_description( 'Epoch {}, Loss={:.4f} Acc={:.4f}'.format( epoch, loss.item(), acc)) tl.add(loss.item()) ta.add(acc) self.optimizer.zero_grad() loss.backward() self.optimizer.step() tl = tl.item() ta = ta.item() self.model.eval() self.model.mode = 'preval' vl = Averager() va = Averager() label = torch.arange(self.args.way).repeat(self.args.val_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) print('Best Epoch {}, Best Val acc={:.4f}'.format( trlog['max_acc_epoch'], trlog['max_acc'])) for i, batch in enumerate(self.val_loader, 1): if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] logits = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) vl.add(loss.item()) va.add(acc) vl = vl.item() va = va.item() writer.add_scalar('data/val_loss', float(vl), epoch) writer.add_scalar('data/val_acc', float(va), epoch) print('Epoch {}, Val, Loss={:.4f} Acc={:.4f}'.format( epoch, vl, va)) if va > trlog['max_acc']: trlog['max_acc'] = va trlog['max_acc_epoch'] = epoch self.save_model('max_acc') if epoch % 20 == 0: self.save_model('epoch' + str(epoch)) trlog['train_loss'].append(tl) trlog['train_acc'].append(ta) trlog['val_loss'].append(vl) trlog['val_acc'].append(va) torch.save(trlog, osp.join(self.args.save_path, 'trlog')) if epoch > self.args.pre_max_epoch - 2: self.save_model('epoch-last') torch.save( self.optimizer.state_dict(), osp.join(self.args.save_path, 'optimizer_latest.pth')) print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) writer.close()
def train(self): """The function for the meta-train phase.""" # Set the meta-train log trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['max_acc'] = 0.0 trlog['max_acc_epoch'] = 0 # Set the timer timer = Timer() # Set global count to zero global_count = 0 # Set tensorboardX writer = SummaryWriter(comment=self.args.save_path) # Generate the labels for train set of the episodes label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) # Start meta-train for epoch in range(1, self.args.max_epoch + 1): # Update learning rate self.lr_scheduler.step() # Set the model to train mode self.model.train() # Set averager classes to record training losses and accuracies train_loss_averager = Averager() train_acc_averager = Averager() # Generate the labels for test set of the episodes during meta-train updates label = torch.arange(self.args.way).repeat(self.args.train_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] # Output logits for model logits = self.model((data_shot, label_shot, data_query)) # Calculate meta-train loss loss = F.cross_entropy(logits, label) # Calculate meta-train accuracy acc = count_acc(logits, label) # Write the tensorboardX records writer.add_scalar('data/loss', float(loss), global_count) writer.add_scalar('data/acc', float(acc), global_count) # Print loss and accuracy for this step tqdm_gen.set_description( 'Epoch {}, Loss={:.4f} Acc={:.4f}'.format( epoch, loss.item(), acc)) # Add loss and accuracy for the averagers train_loss_averager.add(loss.item()) train_acc_averager.add(acc) # Loss backwards and optimizer updates self.optimizer.zero_grad() loss.backward() self.optimizer.step() # Update the averagers train_loss_averager = train_loss_averager.item() train_acc_averager = train_acc_averager.item() # Start validation for this epoch, set model to eval mode self.model.eval() # Set averager classes to record validation losses and accuracies val_loss_averager = Averager() val_acc_averager = Averager() # Generate the labels for test set of the episodes during meta-val for this epoch label = torch.arange(self.args.way).repeat(self.args.val_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) # Print previous information if epoch % 10 == 0: print('Best Epoch {}, Best Val Acc={:.4f}'.format( trlog['max_acc_epoch'], trlog['max_acc'])) # Run meta-validation for i, batch in enumerate(self.val_loader, 1): if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] logits = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) val_loss_averager.add(loss.item()) val_acc_averager.add(acc) # Update validation averagers val_loss_averager = val_loss_averager.item() val_acc_averager = val_acc_averager.item() # Write the tensorboardX records writer.add_scalar('data/val_loss', float(val_loss_averager), epoch) writer.add_scalar('data/val_acc', float(val_acc_averager), epoch) # Print loss and accuracy for this epoch print('Epoch {}, Val, Loss={:.4f} Acc={:.4f}'.format( epoch, val_loss_averager, val_acc_averager)) # Update best saved model if val_acc_averager > trlog['max_acc']: trlog['max_acc'] = val_acc_averager trlog['max_acc_epoch'] = epoch self.save_model('max_acc') # Save model every 10 epochs if epoch % 10 == 0: self.save_model('epoch' + str(epoch)) # Update the logs trlog['train_loss'].append(train_loss_averager) trlog['train_acc'].append(train_acc_averager) trlog['val_loss'].append(val_loss_averager) trlog['val_acc'].append(val_acc_averager) # Save log torch.save(trlog, osp.join(self.args.save_path, 'trlog')) if epoch % 10 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) writer.close()
def main(): parser = argparse.ArgumentParser( description="SSD Evaluation on VOC Dataset.") parser.add_argument("--trained_model", type=str) parser.add_argument( "--dataset_type", default="voc", type=str, help='Specify dataset type. Currently support voc and open_images.') parser.add_argument( "--dataset", type=str, help="The root directory of the VOC dataset or Open Images dataset.") parser.add_argument("--label_file", type=str, help="The label file path.") parser.add_argument("--use_cuda", type=str2bool, default=True) parser.add_argument("--use_2007_metric", type=str2bool, default=True) parser.add_argument("--nms_method", type=str, default="hard") parser.add_argument("--iou_threshold", type=float, default=0.5, help="The threshold of Intersection over Union.") parser.add_argument("--eval_dir", default="eval_results", type=str, help="The directory to store evaluation results.") parser.add_argument('--mb2_width_mult', default=1.0, type=float, help='Width Multiplifier for MobilenetV2') args = parser.parse_args() DEVICE = torch.device( "cuda:0" if torch.cuda.is_available() and args.use_cuda else "cpu") eval_path = pathlib.Path(args.eval_dir) eval_path.mkdir(exist_ok=True) timer = Timer() class_names = [name.strip() for name in open(args.label_file).readlines()] if args.dataset_type == "voc": dataset = VOCDataset(args.dataset, is_test=True) true_case_stat, all_gb_boxes, all_difficult_cases = group_annotation_by_class( dataset) net = create_mobilenetv2_ssd_lite(len(class_names), width_mult=args.mb2_width_mult, is_test=True) timer.start("Load Model") net.load(args.trained_model) net = net.to(DEVICE) print(f'It took {timer.end("Load Model")} seconds to load the model.') predictor = create_mobilenetv2_ssd_lite_predictor( net, nms_method=args.nms_method, device=DEVICE) results = [] for i in range(len(dataset)): print("process image", i) timer.start("Load Image") image = dataset.get_image(i) print("Load Image: {:4f} seconds.".format(timer.end("Load Image"))) timer.start("Predict") boxes, labels, probs = predictor.predict(image) print("Prediction: {:4f} seconds.".format(timer.end("Predict"))) indexes = torch.ones(labels.size(0), 1, dtype=torch.float32) * i results.append( torch.cat( [ indexes.reshape(-1, 1), labels.reshape(-1, 1).float(), probs.reshape(-1, 1), boxes + 1.0 # matlab's indexes start from 1 ], dim=1)) results = torch.cat(results) for class_index, class_name in enumerate(class_names): if class_index == 0: continue # ignore background prediction_path = eval_path / f"det_test_{class_name}.txt" with open(prediction_path, "w") as f: sub = results[results[:, 1] == class_index, :] for i in range(sub.size(0)): prob_box = sub[i, 2:].numpy() image_id = dataset.ids[int(sub[i, 0])] print(image_id + " " + " ".join([str(v) for v in prob_box]), file=f) aps = [] print("\n\nAverage Precision Per-class:") for class_index, class_name in enumerate(class_names): if class_index == 0: continue prediction_path = eval_path / f"det_test_{class_name}.txt" ap = compute_average_precision_per_class( true_case_stat[class_index], all_gb_boxes[class_index], all_difficult_cases[class_index], prediction_path, args.iou_threshold, args.use_2007_metric) aps.append(ap) print(f"{class_name}: {ap}") print(f"\nAverage Precision Across All Classes:{sum(aps)/len(aps)}")
class Predictor: def __init__(self, net, size, mean=0.0, std=1.0, nms_method=None, iou_threshold=0.45, filter_threshold=0.01, candidate_size=200, sigma=0.5, device=None): self.net = net self.transform = PredictionTransform(size, mean, std) self.iou_threshold = iou_threshold self.filter_threshold = filter_threshold self.candidate_size = candidate_size self.nms_method = nms_method self.sigma = sigma if device: self.device = device else: self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") self.net.to(self.device) self.net.eval() self.timer = Timer() def predict(self, image, top_k=-1, prob_threshold=None): cpu_device = torch.device("cpu") height, width, _ = image.shape image = self.transform(image) images = image.unsqueeze(0) images = images.to(self.device) with torch.no_grad(): self.timer.start() scores, boxes = self.net.forward(images) boxes = boxes[0] scores = scores[0] if not prob_threshold: prob_threshold = self.filter_threshold # this version of nms is slower on GPU, so we move data to CPU. boxes = boxes.to(cpu_device) scores = scores.to(cpu_device) picked_box_probs = [] picked_labels = [] for class_index in range(1, scores.size(1)): probs = scores[:, class_index] mask = probs > prob_threshold probs = probs[mask] if probs.size(0) == 0: continue subset_boxes = boxes[mask, :] box_probs = torch.cat([subset_boxes, probs.reshape(-1, 1)], dim=1) box_probs = box_utils.nms(box_probs, self.nms_method, score_threshold=prob_threshold, iou_threshold=self.iou_threshold, sigma=self.sigma, top_k=top_k, candidate_size=self.candidate_size) picked_box_probs.append(box_probs) picked_labels.extend([class_index] * box_probs.size(0)) if not picked_box_probs: return torch.tensor([]), torch.tensor([]), torch.tensor([]) picked_box_probs = torch.cat(picked_box_probs) picked_box_probs[:, 0] *= width picked_box_probs[:, 1] *= height picked_box_probs[:, 2] *= width picked_box_probs[:, 3] *= height return picked_box_probs[:, :4], torch.tensor( picked_labels), picked_box_probs[:, 4]
def train(self): """The function for the pre-train phase.""" # Set the pretrain log trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['val_loss'] = [] trlog['train_acc'] = [] trlog['val_acc'] = [] trlog['max_acc'] = 0.0 trlog['max_acc_epoch'] = 0 # Set the timer timer = Timer() # Set global count to zero global_count = 0 # Set tensorboardX writer = SummaryWriter(comment=self.args.save_path) # Start pretrain for epoch in range(1, self.args.pre_max_epoch + 1): # Set the model to train mode print('Epoch {}'.format(epoch)) self.model.train() self.model.mode = 'pre' # Set averager classes to record training losses and accuracies train_loss_averager = Averager() train_acc_averager = Averager() # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.train_loader) #for i, batch in enumerate(self.train_loader): for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] label = batch[1] if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) logits = self.model(data) loss = F.cross_entropy(logits, label) # Calculate train accuracy acc = count_acc(logits, label) # Write the tensorboardX records writer.add_scalar('data/loss', float(loss), global_count) writer.add_scalar('data/acc', float(acc), global_count) # Print loss and accuracy for this step train_loss_averager.add(loss.item()) train_acc_averager.add(acc) # Loss backwards and optimizer updates self.optimizer.zero_grad() loss.backward() self.optimizer.step() # Update the averagers train_loss_averager = train_loss_averager.item() train_acc_averager = train_acc_averager.item() # start the original evaluation self.model.eval() self.model.mode = 'origval' _, valid_results = self.val_orig(self.valset.X_val, self.valset.y_val) print('validation accuracy ', valid_results[0]) # Start validation for this epoch, set model to eval mode self.model.eval() self.model.mode = 'preval' # Set averager classes to record validation losses and accuracies val_loss_averager = Averager() val_acc_averager = Averager() # Generate the labels for test label = torch.arange(self.args.way).repeat(self.args.val_query) if torch.cuda.is_available(): label = label.type(torch.cuda.LongTensor) else: label = label.type(torch.LongTensor) label_shot = torch.arange(self.args.way).repeat(self.args.shot) if torch.cuda.is_available(): label_shot = label_shot.type(torch.cuda.LongTensor) else: label_shot = label_shot.type(torch.LongTensor) # Run meta-validation for i, batch in enumerate(self.val_loader, 1): if torch.cuda.is_available(): data, _ = [_.cuda() for _ in batch] else: data = batch[0] #data=data.float() p = self.args.shot * self.args.way data_shot, data_query = data[:p], data[p:] logits = self.model((data_shot, label_shot, data_query)) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) val_loss_averager.add(loss.item()) val_acc_averager.add(acc) # Update validation averagers val_loss_averager = val_loss_averager.item() val_acc_averager = val_acc_averager.item() # Write the tensorboardX records writer.add_scalar('data/val_loss', float(val_loss_averager), epoch) writer.add_scalar('data/val_acc', float(val_acc_averager), epoch) # Update best saved model if val_acc_averager > trlog['max_acc']: trlog['max_acc'] = val_acc_averager trlog['max_acc_epoch'] = epoch self.save_model('max_acc') # Save model every 10 epochs if epoch % 10 == 0: self.save_model('epoch' + str(epoch)) # Update the logs trlog['train_loss'].append(train_loss_averager) trlog['train_acc'].append(train_acc_averager) trlog['val_loss'].append(val_loss_averager) trlog['val_acc'].append(val_acc_averager) # Save log torch.save(trlog, osp.join(self.args.save_path, 'trlog')) if epoch % 10 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) writer.close()
false_positive[i] = 1 true_positive = true_positive.cumsum() false_positive = false_positive.cumsum() precision = true_positive / (true_positive + false_positive) recall = true_positive / num_true_cases if use_2007_metric: return measurements.compute_voc2007_average_precision(precision, recall) else: return measurements.compute_average_precision(precision, recall) if __name__ == '__main__': eval_path = pathlib.Path(args.eval_dir) eval_path.mkdir(exist_ok=True) timer = Timer() class_names = [name.strip() for name in open(args.label_file).readlines()] dataset = ImagenetDataset(args.dataset, is_val=True) config = mobilenetv1_ssd_config true_case_stat, all_gb_boxes, all_difficult_cases = group_annotation_by_class(dataset) if args.net == 'basenet': pred_enc = mvod_basenet.MobileNetV1(num_classes=num_classes, alpha = args.width_mult) pred_dec = mvod_basenet.SSD(num_classes=num_classes, alpha = args.width_mult, is_test=True, config= config, batch_size=1) net = mvod_basenet.MobileVOD(pred_enc, pred_dec) elif args.net == 'lstm1': pred_enc = mvod_bottlneck_lstm1.MobileNetV1(num_classes=num_classes, alpha = args.width_mult) pred_dec = mvod_bottlneck_lstm1.SSD(num_classes=num_classes, alpha = args.width_mult, is_test=True, config= config, batch_size=1) net = mvod_bottlneck_lstm1.MobileVOD(pred_enc, pred_dec) elif args.net == 'lstm2': pred_enc = mvod_bottlneck_lstm2.MobileNetV1(num_classes=num_classes, alpha = args.width_mult) pred_dec = mvod_bottlneck_lstm2.SSD(num_classes=num_classes, alpha = args.width_mult, is_test=True, config= config, batch_size=1)
def train(self): """The function for the meta-train phase.""" # Set the meta-train log #Change when resuming training initial_epoch = 25 trlog = {} trlog['args'] = vars(self.args) trlog['train_loss'] = [] trlog['train_acc'] = [] trlog['train_iou'] = [] # Set the meta-val log trlog['val_loss'] = [] trlog['val_acc'] = [] trlog['val_iou'] = [] trlog['max_iou'] = 0.2856 trlog['max_iou_epoch'] = 4 # Set the timer timer = Timer() # Set global count to zero global_count = 0 # Set tensorboardX writer = SummaryWriter(comment=self.args.save_path) K = self.args.way + 1 #included Background as class N = self.args.train_query Q = self.args.test_query # Start meta-train for epoch in range(initial_epoch, self.args.max_epoch + 1): print( '----------------------------------------------------------------------------------------------------------------------------------------------------------' ) # Update learning rate self.lr_scheduler.step() # Set the model to train mode self.model.train() # Set averager classes to record training losses and accuracies train_loss_averager = Averager() train_acc_averager = Averager() train_iou_averager = Averager() # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.train_loader) for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, labels, _ = [_.cuda() for _ in batch] else: data = batch[0] labels = batch[1] #print(data.shape) #print(labels.shape) p = K * N im_train, im_test = data[:p], data[p:] #Adjusting labels for each meta task labels = downlabel(labels, K) out_train, out_test = labels[:p], labels[p:] ''' print(im_train.shape) print(im_test.shape) print(out_train.shape) print(out_test.shape) ''' if (torch.cuda.is_available()): im_train = im_train.cuda() im_test = im_test.cuda() out_train = out_train.cuda() out_test = out_test.cuda() #Reshaping train set ouput Ytr = out_train.reshape(-1) Ytr = onehot(Ytr, K) #One hot encoding for loss Yte = out_test.reshape(out_test.shape[0], -1) if (torch.cuda.is_available()): Ytr = Ytr.cuda() Yte = Yte.cuda() # Output logits for model Gte = self.model(im_train, Ytr, im_test, Yte) GteT = torch.transpose(Gte, 1, 2) # Calculate meta-train loss #loss = self.CD(GteT,Yte) loss = self.FL(GteT, Yte) #loss = self.LS(GteT,Yte) self._reset_metrics() # Calculate meta-train accuracy seg_metrics = eval_metrics(GteT, Yte, K) self._update_seg_metrics(*seg_metrics) pixAcc, mIoU, _ = self._get_seg_metrics(K).values() # Print loss and accuracy for this step tqdm_gen.set_description( 'Epoch {}, Loss={:.4f} Acc={:.4f} IoU={:.4f}'.format( epoch, loss.item(), pixAcc * 100.0, mIoU)) # Add loss and accuracy for the averagers # Calculate the running averages train_loss_averager.add(loss.item()) train_acc_averager.add(pixAcc) train_iou_averager.add(mIoU) # Loss backwards and optimizer updates self.optimizer.zero_grad() loss.backward() self.optimizer.step() # Update the averagers train_loss_averager = train_loss_averager.item() train_acc_averager = train_acc_averager.item() train_iou_averager = train_iou_averager.item() #Adding to Tensorboard writer.add_scalar('data/train_loss (Meta)', float(train_loss_averager), epoch) writer.add_scalar('data/train_acc (Meta)', float(train_acc_averager) * 100.0, epoch) writer.add_scalar('data/train_iou (Meta)', float(train_iou_averager), epoch) # Update best saved model if validation set is not present and save it if (self.args.valdata == 'No'): if train_iou_averager > trlog['max_iou']: print("New Best!") trlog['max_iou'] = train_iou_averager trlog['max_iou_epoch'] = epoch self.save_model('max_iou') # Save model every 2 epochs if epoch % 2 == 0: self.save_model('epoch' + str(epoch)) # Update the logs trlog['train_loss'].append(train_loss_averager) trlog['train_acc'].append(train_acc_averager) trlog['train_iou'].append(train_iou_averager) if epoch % 1 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) print('Epoch:{}, Average Loss: {:.4f}, Average mIoU: {:.4f}'. format(epoch, train_loss_averager, train_iou_averager)) """The function for the meta-val phase.""" if (self.args.valdata == 'Yes'): # Start meta-val # Set the model to val mode self.model.eval() # Set averager classes to record training losses and accuracies val_loss_averager = Averager() val_acc_averager = Averager() val_iou_averager = Averager() # Using tqdm to read samples from train loader tqdm_gen = tqdm.tqdm(self.val_loader) for i, batch in enumerate(tqdm_gen, 1): # Update global count number global_count = global_count + 1 if torch.cuda.is_available(): data, labels, _ = [_.cuda() for _ in batch] else: data = batch[0] labels = batch[1] #print(data.shape) #print(labels.shape) p = K * N im_train, im_test = data[:p], data[p:] #Adjusting labels for each meta task labels = downlabel(labels, K) out_train, out_test = labels[:p], labels[p:] ''' print(im_train.shape) print(im_test.shape) print(out_train.shape) print(out_test.shape) ''' if (torch.cuda.is_available()): im_train = im_train.cuda() im_test = im_test.cuda() out_train = out_train.cuda() out_test = out_test.cuda() #Reshaping val set ouput Ytr = out_train.reshape(-1) Ytr = onehot(Ytr, K) #One hot encoding for loss Yte = out_test.reshape(out_test.shape[0], -1) if (torch.cuda.is_available()): Ytr = Ytr.cuda() Yte = Yte.cuda() # Output logits for model Gte = self.model(im_train, Ytr, im_test, Yte) GteT = torch.transpose(Gte, 1, 2) self._reset_metrics() # Calculate meta-train accuracy seg_metrics = eval_metrics(GteT, Yte, K) self._update_seg_metrics(*seg_metrics) pixAcc, mIoU, _ = self._get_seg_metrics(K).values() # Print loss and accuracy for this step tqdm_gen.set_description( 'Epoch {}, Val Loss={:.4f} Val Acc={:.4f} Val IoU={:.4f}' .format(epoch, loss.item(), pixAcc * 100.0, mIoU)) # Add loss and accuracy for the averagers # Calculate the running averages val_loss_averager.add(loss.item()) val_acc_averager.add(pixAcc) val_iou_averager.add(mIoU) # Update the averagers val_loss_averager = val_loss_averager.item() val_acc_averager = val_acc_averager.item() val_iou_averager = val_iou_averager.item() #Adding to Tensorboard writer.add_scalar('data/val_loss (Meta)', float(val_loss_averager), epoch) writer.add_scalar('data/val_acc (Meta)', float(val_acc_averager) * 100.0, epoch) writer.add_scalar('data/val_iou (Meta)', float(val_iou_averager), epoch) # Update best saved model if val_iou_averager > trlog['max_iou']: print("New Best (Validation)") trlog['max_iou'] = val_iou_averager trlog['max_iou_epoch'] = epoch self.save_model('max_iou') # Save model every 2 epochs if epoch % 2 == 0: self.save_model('epoch' + str(epoch)) # Update the logs trlog['val_loss'].append(val_loss_averager) trlog['val_acc'].append(val_acc_averager) trlog['val_iou'].append(val_iou_averager) if epoch % 1 == 0: print('Running Time: {}, Estimated Time: {}'.format( timer.measure(), timer.measure(epoch / self.args.max_epoch))) print( 'Epoch:{}, Average Val Loss: {:.4f}, Average Val mIoU: {:.4f}' .format(epoch, val_loss_averager, val_iou_averager)) # Save log torch.save(trlog, osp.join(self.args.save_path, 'trlog')) print( '----------------------------------------------------------------------------------------------------------------------------------------------------------' ) writer.close()