def validate(val_loader, model, criterion): # list to store the losses and accuracies: [loss, pixel_acc, iou ] results = utils.AverageMeter(3) # switch to evaluate mode model.eval() for i, sample in enumerate(val_loader): input, weight_map, target = sample weight_map = weight_map.float().div(20) if weight_map.dim() == 4: weight_map = weight_map.squeeze(1) weight_map_var = weight_map.cuda() # for b in range(input.size(0)): # utils.show_figures((input[b, 0, :, :].numpy(), target[b,0,:,:].numpy(), weight_map[b, :, :])) if torch.max(target) == 255: target = target / 255 if target.dim() == 4: target = target.squeeze(1) target_var = target.cuda() size = opt.train['input_size'] overlap = opt.train['val_overlap'] output = utils.split_forward(model, input, size, overlap, opt.model['out_c']) log_prob_maps = F.log_softmax(output, dim=1) loss_map = criterion(log_prob_maps, target_var) loss_map *= weight_map_var loss_CE = loss_map.mean() if opt.train['alpha'] != 0: prob_maps = F.softmax(output, dim=1) target_labeled = torch.zeros(target.size()).long() for k in range(target.size(0)): target_labeled[k] = torch.from_numpy(measure.label(target[k].numpy() == 1)) # utils.show_figures((target[k].numpy(), target[k].numpy()==1, target_labeled[k].numpy())) loss_var = criterion_var(prob_maps, target_labeled.cuda()) loss = loss_CE + opt.train['alpha'] * loss_var else: loss = loss_CE # measure accuracy and record loss pred = np.argmax(log_prob_maps.data.cpu().numpy(), axis=1) metrics = utils.accuracy_pixel_level(pred, target.numpy()) pixel_accu = metrics[0] iou = metrics[1] results.update([loss.item(), pixel_accu, iou]) del output, target_var, log_prob_maps, loss logger.info('\t=> Val Avg: Loss {r[0]:.4f}\tPixel_Acc {r[1]:.4f}' '\tIoU {r[2]:.4f}'.format(r=results.avg)) return results.avg
def get_probmaps(input, model, opt): size = opt.test['patch_size'] overlap = opt.test['overlap'] output = utils.split_forward(model, input, size, overlap, with_uncertainty=False) output = output.squeeze(0) prob_maps = F.softmax(output, dim=0).cpu().numpy() return prob_maps
def get_probmaps(input, model, opt): size = opt.test['patch_size'] overlap = opt.test['overlap'] if size == 0: with torch.no_grad(): output = model(input.cuda()) else: output = utils.split_forward(model, input, size, overlap) output = output.squeeze(0) prob_maps = F.softmax(output, dim=0).cpu().numpy() return prob_maps
def get_probmaps(input, model, opt): size = opt.test['patch_size'] overlap = opt.test['overlap'] if size == 0: with torch.no_grad(): output = model(input.cuda()) else: output = utils.split_forward(model, input, size, overlap, opt.model['out_c']) output = torch.sigmoid(output[0, 0, :, :]).cpu().numpy() return output
def get_probmaps(input, model, opt): size = opt.test['patch_size'] overlap = opt.test['overlap'] if size == 0: with torch.no_grad(): output = model(input.cuda()) else: output = utils.split_forward(model, input, size, overlap) output = output.squeeze(0) prob_maps = torch.sigmoid(output[0, :, :]) return prob_maps
def get_probmaps(input, model, opt): size = opt.test['patch_size'] overlap = opt.test['overlap'] output, log_var = utils.split_forward(model, input, size, overlap, with_uncertainty=True) output = output.squeeze(0) log_var = log_var.squeeze(0) return output.cpu().numpy(), log_var.cpu().numpy()
def validate(val_loader, model, criterion): # list to store the losses and accuracies: [loss, pixel_acc, iou ] results = utils.AverageMeter(5) # switch to evaluate mode model.eval() for i, sample in enumerate(val_loader): if params.train['weight_map']: input, weight_map, target = sample weight_map = weight_map.float().div(20) if weight_map.dim() == 4: weight_map = weight_map.squeeze(1) weight_map_var = weight_map.cuda() else: input, target = sample # no classification if params.model['out_c'] == 3: target[target == 2] = 1 target[target == 3] = 1 target[target == 4] = 2 # no edge or classification if params.model['out_c'] == 2: target[target > 0] = 1 if target.dim() == 4: target = target.squeeze(1) target_var = target.cuda() size = params.train['input_size'] overlap = params.train['val_overlap'] output = utils.split_forward(model, input, size, overlap, params.model['out_c']) log_prob_maps = F.log_softmax(output, dim=1) if params.train['weight_map']: loss_map = criterion(log_prob_maps, target_var) loss_map *= weight_map_var loss_CE = loss_map.sum() / (loss_map.size(0) * loss_map.size(1) * loss_map.size(2)) else: loss_CE = criterion(log_prob_maps, target_var) loss = loss_CE if params.train['beta'] != 0: prob_maps = F.softmax(output, dim=1) pred_map = prob_maps[:, 4:5, :, :].repeat(1, 3, 1, 1).float() target_map = (target_var == 4).unsqueeze(1).repeat(1, 3, 1, 1).float() pred_feat = vgg_model(pred_map) target_feat = vgg_model(target_map) loss_perceptual = criterion_perceptual(pred_feat, target_feat) loss = loss_CE + params.train['beta'] * loss_perceptual # measure accuracy and record loss pred = np.argmax(log_prob_maps.data.cpu().numpy(), axis=1) iou = utils.accuracy(pred, target.numpy(), num_class=params.model['out_c'] - 1) if params.model['out_c'] == 5: iou_nuclei = utils.accuracy(np.uint8((pred > 0) * (pred < 4)), np.uint8((target.numpy() > 0) * (target.numpy() < 4)), num_class=2) else: iou_nuclei = utils.accuracy(np.uint8((pred == 1)), np.uint8((target.numpy() == 1)), num_class=2) if params.train['beta'] != 0: result = [ loss.item(), loss_CE.item(), loss_perceptual.item(), iou_nuclei, iou ] else: result = [loss.item(), loss_CE.item(), 0, iou_nuclei, iou] results.update(result, input.size(0)) del output, target_var, log_prob_maps, loss logger.info('\t=> Val Avg: Loss {r[0]:.4f}' '\tLoss_CE {r[1]:.4f}' '\tLoss_Per {r[2]:.4f}' '\tIoU-nuclei {r[3]:.4f}' '\tIoU {r[4]:.4f}'.format(r=results.avg)) return results.avg