def save_mask(args, pred_var, target_var, mask_path): outnames = pd.read_csv(args.test_csv, header=None) subjs = [] total = pred_var.size(0) for sample in range(total): outname = outnames.iloc[sample, 0].split(".")[0] outpath = mask_path + "/" + outname + ".png" outpath_pred = mask_path + "/pred_" + outname + ".png" subjname = outname.split("-")[0] if subjname not in subjs: subjs.append(subjname) LOG.info('[{}/{}] {}'.format(sample, total, subjname)) #pred = torch.round(pred_var[sample]).float().cpu() pred = pred_var[sample].float().cpu() target = target_var[sample].float().cpu() TP = torch.mul(pred, target) FP = pred - TP FN = target - TP TP = ToPILImage()(TP).convert('RGB') #green FP = ToPILImage()(FP).convert('RGB') #red FN = ToPILImage()(FN).convert('RGB') #blue numpixels = TP.size[0] * TP.size[1] colors = [] mask_colors = [] for pixel in range(numpixels): tp = TP.getdata()[pixel] fp = FP.getdata()[pixel] fn = FN.getdata()[pixel] if tp > (0, 0, 0): colors.append((65, 190, 215)) mask_colors.append((65, 190, 215)) elif fp > (0, 0, 0): colors.append((250, 180, 60)) mask_colors.append((0, 0, 0)) elif fn > (0, 0, 0): colors.append((200, 60, 85)) mask_colors.append((0, 0, 0)) else: colors.append((0, 0, 0)) mask_colors.append((0, 0, 0)) #colors.append( (fp[0], tp[0], fn[0]) ) mask = Image.new(TP.mode, TP.size) mask.putdata(colors) mask.save(outpath) mask_pred = Image.new(TP.mode, TP.size) mask_pred.putdata(mask_colors) mask_pred.save(outpath_pred) del target, pred, TP, FP, FN, colors, mask, mask_pred gc.collect() torch.cuda.empty_cache() LOG.info( '==============================================================================' ) LOG.info( '==============================================================================\n\n\n\n\n' ) return
def validate(eval_loader, model, log, global_step, epoch, save_pred=False, mask_path=None): meters = AverageMeterSet() model.eval() #switch to evaluate mode target_total = torch.randn(0, args.num_classes).double().cuda() #model_pred = torch.randn(0, args.num_classes).double().cuda() end = time.time() index = 0 for i, (input, target) in enumerate(eval_loader): target_var = torch.autograd.Variable(target).float().cuda() #target_var = torch.autograd.Variable(target).long() #one_hot = torch.zeros( target_var.size(0), args.num_classes, target_var.size(2), target_var.size(3) ) #target_onehot = one_hot.scatter_(1, target_var.data, 1) input_var = Variable(input).cuda() #target_var = Variable(target_onehot).cuda() ### compute output and loss model_output = model(input_var) loss = dice_loss(model_output, target_var) meters.update('loss', loss.item()) if save_pred: #sm = nn.Softmax() #sm_output= sm(model_output) model_sigmoid = torch.sigmoid(model_output) #since binary #model_pred = torch.round(model_sigmoid) model_pred = model_sigmoid.cpu() #model_pred = model_pred.data.numpy() #print(model_pred.shape[0]) #print(model_pred[0]) ###### #model_pred = np.argmax(model_sigmoid.detach(), axis = 1) #un one hot? ###### #model_pred = torch.cat((model_pred, model_sigmoid.data.double()), 0) #print(model_pred) outnames = pd.read_csv(args.test_csv, header=None) for sample in range(model_pred.size(0)): #for sample in range(model_pred.shape[0]): outname = outnames.iloc[index,0].split(".")[0] outpath = mask_path + "/" + outname + ".png" ####### #pred = model_pred[sample].float().unsqueeze(0) pred = model_pred[sample].float() ###### #pred = model_pred[sample].unsqueeze(0) #print(pred) #pred = pred.data.cpu() #print(pred) #print(pred.size()) #print(pred.type()) #pixels = visionF.to_pil_image(pred).convert('RGB') pixels = ToPILImage()(pred).convert('RGB') colors = [] for color in pixels.getdata(): colors.append( (color[0], 0, 0) ) # if color not black: colors.append(red) # else: colors.append(black) mask = Image.new(pixels.mode, pixels.size) mask.putdata(colors) mask.save(outpath) index = index + 1 #print(i, index, sample, outpath) #target_total = torch.cat((target_total, target_var.data.double()), 0) #pred_total = torch.cat((pred_total, model_pred.data.double()), 0) #LOG.info('pred preview {}'.format(pred_total.data)) #LOG.info('model_output.size {}'.format(model_output.size())) #LOG.info('model_sigmoid.size {}'.format(model_sigmoid.size())) ############# print progress to console if i % args.print_freq == 0: LOG.info( 'Test: [{0}/{1}]\t' 'Class {meters[loss]:.4f}\t' .format(i, len(eval_loader), meters=meters)) print('[{}/{}]: Dice score: {} %\n'.format(epoch, args.epochs, args.num_classes, loss)) #if save_pred: return loss, target_array, pred_array #else: return loss return loss
def validate(eval_loader, model, log, global_step, epoch, save_pred=False, mask_path=None): meters = AverageMeterSet() model.eval() #switch to evaluate mode target_total = torch.randn(0, 1).double().cuda() pred_total = torch.randn(0, 1).double().cuda() end = time.time() index = 0 for i, (input, target) in enumerate(eval_loader): inputs = Variable(input).cuda() targets = torch.autograd.Variable(target).float().cuda() #target_var = torch.autograd.Variable(target).long() #one_hot = torch.zeros( target_var.size(0), args.num_classes, target_var.size(2), target_var.size(3) ) #target_onehot = one_hot.scatter_(1, target_var.data, 1) #target_var = Variable(target_onehot).cuda() ### compute output and loss model_output = model(inputs) #LOG.info('model shape', model_output.shape) #LOG.info('mode', model_output[0,:,0:10,0:10]) #LOG.info('targets', targets[0,:,0:10,0:10]) model_out = torch.sigmoid(model_output) #since binary model_out = model_out[:, 1, :, :].unsqueeze(1) #LOG.info('mode', model_out[0,:,0:10,0:10]) #LOG.info('model squeeze', model_out.squeeze(1)[0,:,0:10,0:10]) #t = torch.Tensor([0.55]).cuda() #model_out = (model_out > t).float() * 1 #model_out = torch.round(model_out) #correction = torch.Tensor([1]).cuda() #model_out = torch.round(correction - model_out) #print('model corrected', model_out[0]) #print('targets', targets[0]) loss = dice_loss(model_out, targets) dice = 1 - loss meters.update('loss', loss.item()) target_total = torch.cat((target_total, targets.data.double()), 0) pred_total = torch.cat((pred_total, model_out.data.double()), 0) #LOG.info('loss = %s' %loss.item()) #LOG.info('dice = %s' %dice) #print('\ntargets', targets.shape) #print('model', model_out.shape) #print('targets total', target_total.shape) #print('pred total', pred_total.shape) outnames = pd.read_csv(args.test_csv, header=None) target_var = targets.cpu() pred_var = model_out.cpu() #if save_pred: if False: #sm = nn.Softmax() #sm_output= sm(model_output) #model_sigmoid = torch.sigmoid(model_output) #since binary #target_var = targets.cpu() #model_pred = model_out.cpu() #print(model_pred.shape[0]) #print(model_pred[0]) #print(target[0]) #model_pred = np.argmax(model_sigmoid.detach(), axis = 1) #un one hot? #model_pred = torch.cat((model_pred, model_sigmoid.data.double()), 0) #print(model_pred) for sample in range(model_pred.size(0)): outname = outnames.iloc[index, 0].split(".")[0] outpath = mask_path + "/" + outname + ".png" pred = pred_var[sample].float() target = target_var[sample].float() TP = torch.mul(pred, target) FP = pred - TP FN = target - TP #print('pred', model_pred[0].float()) #print('target', target_var[0].float()) ###### #pred = model_pred[sample].unsqueeze(0) #print(pred) #pred = pred.data.cpu() #print(pred) #print(pred.size()) #print(target.size()) #print(pred.type()) #pixels = visionF.to_pil_image(pred).convert('RGB') #pixels = ToPILImage()(pred).convert('RGB') TP = ToPILImage()(TP).convert('RGB') FP = ToPILImage()(FP).convert('RGB') FN = ToPILImage()(FN).convert('RGB') numpixels = TP.size[0] * TP.size[1] colors = [] for pixel in range(numpixels): tp = TP.getdata()[pixel] fp = FP.getdata()[pixel] fn = FN.getdata()[pixel] colors.append((fp[0], tp[0], fn[0])) #p = pred[pixel] #pred_by_pixel.append(p) #colors.append( (color[0], 0, 0) ) # if color not black: colors.append(red) # else: colors.append(black) mask = Image.new(TP.mode, TP.size) mask.putdata(colors) mask.save(outpath) index = index + 1 #target_total = torch.cat((target_total, target_var.data.double()), 0) #pred_total = torch.cat((pred_total, model_pred.data.double()), 0) #LOG.info('pred preview {}'.format(pred_total.data)) #LOG.info('model_output.size {}'.format(model_output.size())) #LOG.info('model_sigmoid.size {}'.format(model_sigmoid.size())) ############# print progress to console if i % args.print_freq == 0: LOG.info('Test: [{0}/{1}]\t' 'Dice {2}\t'.format(i, len(eval_loader), round(dice.item(), 4))) #import matplotlib.pyplot as plt #preds = pred_total.cpu().numpy() #plt.hist(preds.flatten(), bins="auto") #plt.show() overall_loss = dice_loss(pred_total, target_total) overall_dice = 1 - overall_loss print('[{}/{}] Overall Dice score: {}\n'.format( epoch, args.epochs, round(overall_dice.item(), 4))) if args.log: LOG.info('[{}/{}] Overall Dice score: {}'.format( epoch, args.epochs, round(overall_dice.item(), 4))) if save_pred: return overall_dice.item(), target_var.detach(), pred_var.detach( ), outnames else: return overall_dice.item()
def validate(eval_loader, model, log, global_step, epoch, save_pred=False, mask_path=None): meters = AverageMeterSet() model.eval() #switch to evaluate mode target_total = torch.randn(0, args.num_classes).double().cuda() end = time.time() index = 0 for i, (input, target) in enumerate(eval_loader): target_var = torch.autograd.Variable(target).float().cuda() input_var = Variable(input).cuda() ### compute output and loss model_output = model(input_var) model_out = torch.sigmoid(model_out) #since binary loss = dice_loss(model_output, target_var) meters.update('loss', loss.item()) if save_pred: ######################################################################### ############# Saving predictions ######################################## ######################################################################### model_pred = model_output.cpu() target_var = target_var.cpu() outnames = pd.read_csv(args.test_csv, header=None) for sample in range(model_pred.size(0)): outname = outnames.iloc[index, 0].split(".")[0] outpath = mask_path + "/" + outname + ".png" pred = model_pred[sample].float() target = target_var[sample].float() TP = torch.mul(pred, target) FP = pred - TP FN = target - TP TP = ToPILImage()(TP).convert('RGB') FP = ToPILImage()(FP).convert('RGB') FN = ToPILImage()(FN).convert('RGB') numpixels = TP.size[0] * TP.size[1] colors = [] for pixel in range(numpixels): tp = TP.getdata()[pixel] fp = FP.getdata()[pixel] fn = FN.getdata()[pixel] colors.append((fp[0], tp[0], fn[0])) mask = Image.new(TP.mode, TP.size) mask.putdata(colors) mask.save(outpath) index = index + 1 #target_total = torch.cat((target_total, target_var.data.double()), 0) #pred_total = torch.cat((pred_total, model_pred.data.double()), 0) #LOG.info('pred preview {}'.format(pred_total.data)) #LOG.info('model_output.size {}'.format(model_output.size())) #LOG.info('model_sigmoid.size {}'.format(model_sigmoid.size())) ############# print progress to console if i % args.print_freq == 0: LOG.info('Test: [{0}/{1}]\t' 'Class {meters[loss]:.4f}\t'.format(i, len(eval_loader), meters=meters)) print('[{}/{}]: Dice score: {} %\n'.format(epoch, args.epochs, args.num_classes, loss)) #if save_pred: return loss, target_array, pred_array #else: return loss return loss