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
