def valid(net,
optimizer,
valid_loader,
use_lovasz=False,
save_imgs=False,
fold_num=0):
net.eval()
# keep track of losses
val_ious = []
val_iter_loss = 0.
# no gradients during validation
with torch.no_grad():
for i, data in enumerate(valid_loader):
valid_imgs = data['img'].to(device)
valid_msks = data['msk'].to(device)
valid_msk_bool = data['has_msk'].float().to(device)
# get predictions
msk_vpreds, bool_vpreds = net(valid_imgs)
msk_blend_vpreds = msk_vpreds * bool_vpreds.view(
valid_imgs.size(0), 1, 1, 1)
if save_imgs:
img_grid = vsn.utils.make_grid(valid_imgs, normalize=True)
msk_grid = vsn.utils.make_grid(msk_vpreds)
vsn.utils.save_image(
img_grid,
'../imgs/valid_imgs_fold-{}.png'.format(fold_num))
vsn.utils.save_image(
msk_grid,
'../imgs/valid_msks_fold-{}.png'.format(fold_num))
# calculate loss
if use_lovasz:
vloss = L.lovasz_hinge(msk_vpreds, valid_msks)
#vloss += focal_loss(msk_vpreds, valid_msks)
#vloss -= dice(msk_vpreds.sigmoid(), valid_msks)
else:
vloss = focal_loss(msk_vpreds, valid_msks)
vloss += L.lovasz_hinge(msk_vpreds, valid_msks)
#vloss -= dice(msk_vpreds.sigmoid(), valid_msks)
vloss += args.lambda_bool * bce(bool_vpreds,
valid_msk_bool.view(-1, 1))
vloss += args.lambda_bool * focal_loss(msk_blend_vpreds,
valid_msks)
#vloss += args.lambda_dice * dice(msk_vpreds.sigmoid(), valid_msks)
# get validation stats
val_iter_loss += vloss.item()
val_ious.append(
get_iou_vector(
valid_msks.cpu().numpy()[:, :, 13:114, 13:114],
msk_vpreds.sigmoid().cpu().numpy()[:, :, 13:114, 13:114]))
epoch_vloss = val_iter_loss / (len(valid_loader.dataset) / args.batch_size)
print('Avg Eval Loss: {:.4}, Avg IOU: {:.4}'.format(
epoch_vloss, np.mean(val_ious)))
return epoch_vloss, np.mean(val_ious)
def valid(net, optimizer, valid_loader, mtype='student', use_lovasz=False):
net.eval()
# keep track of losses
val_ious = []
val_iter_loss = 0.
# no gradients during validation
with torch.no_grad():
for i, data in enumerate(valid_loader):
valid_imgs = data['img'].cuda()
valid_msks = data['msk'].cuda()
valid_msk_bool = data['has_msk'].float().cuda()
# get predictions
msk_vpreds, bool_v = net(valid_imgs)
# calculate loss
if use_lovasz:
vloss = L.lovasz_hinge(msk_vpreds, valid_msks)
else:
vloss = focal_loss(msk_vpreds, valid_msks)
vloss += L.lovasz_hinge(msk_vpreds, valid_msks)
vloss += bce(bool_v, valid_msk_bool.view(-1, 1))
# get validation stats
val_iter_loss += vloss.item()
val_ious.append(
get_iou_vector(
valid_msks.cpu().numpy()[:, :, 13:114, 13:114],
msk_vpreds.sigmoid().cpu().numpy()[:, :, 13:114, 13:114]))
epoch_vloss = val_iter_loss / (len(valid_loader.dataset) / args.batch_size)
print('{} Avg Eval Loss: {:.4}, Avg IOU: {:.4}'.format(
mtype, epoch_vloss, np.mean(val_ious)))
return epoch_vloss, np.mean(val_ious)
def forward(self, output_weight, seg_feat, ind, target):
B, C, H, W = seg_feat.size()
weight = _tranpose_and_gather_feat(output_weight, ind)
seg_feat = seg_feat.view([-1, H, W]).unsqueeze(0)
weight = weight.view([-1, C, 3, 3])
pred_seg = F.conv2d(seg_feat, weight, stride=1, padding=1,
groups=B).view([B, -1, H, W])
loss = (L.lovasz_hinge(pred_seg, target, 255) +
L.lovasz_hinge(-pred_seg, 1 - target, -254)) / 2
return loss
def valid(net, optimizer, valid_loader, save_imgs=False, fold_num=0):
net.eval()
# keep track of losses
val_ious = []
val_iter_loss = 0.
# no gradients during validation
with torch.no_grad():
for i, data in enumerate(valid_loader):
valid_imgs = data['img'].to(device)
valid_msks = data['msk']
#valid_msks_half = data['msk_half'].to(device)
#valid_msks_qrtr = data['msk_qrtr'].to(device)
valid_msk_bool = data['has_msk'].to(device)
# get predictions
msk_vpreds = net(valid_imgs)
# calculate loss
# main mask loss
vloss = focal_loss(msk_vpreds[0], valid_msks[0].to(device))
vloss += L.lovasz_hinge(msk_vpreds[0], valid_msks[0].to(device))
# aux mask losses
for j in range(len(valid_msks)):
#print(msk_preds[i+1].size(), msks[i].size())
vloss += 0.1 * focal_loss(
msk_vpreds[j + 1][valid_msk_bool],
valid_msks[j][valid_msk_bool].to(device))
vloss += 0.1 * L.lovasz_hinge(
msk_vpreds[j + 1][valid_msk_bool],
valid_msks[j][valid_msk_bool].to(device))
# binary loss
vloss += 0.05 * bce(msk_vpreds[-1],
valid_msk_bool.float().view(-1, 1))
# get validation stats
val_iter_loss += vloss.item()
val_ious.append(
get_iou_vector(
valid_msks[0].cpu().numpy()[:, :, 13:114, 13:114],
msk_vpreds[0].sigmoid().cpu().numpy()[:, :, 13:114,
13:114]))
epoch_vloss = val_iter_loss / (len(valid_loader.dataset) / args.batch_size)
print('Avg Eval Loss: {:.4}, Avg IOU: {:.4}'.format(
epoch_vloss, np.mean(val_ious)))
return epoch_vloss, np.mean(val_ious)
def train(net,
optimizer,
train_loader,
batch_size,
freeze_bn=False,
use_lovasz=False,
swa=False):
'''
uses the data loader to grab a batch of images
pushes images through network and gathers predictions
updates network weights by evaluating the loss functions
'''
# set network to train mode
net.train(True, args.freeze_bn)
# keep track of our loss
iter_loss = 0.
# loop over the images for the desired amount
for i, data in enumerate(train_loader):
imgs = data['img'].cuda(async=True)
msks = data['msk'].cuda(async=True)
msk_bool = data['has_msk'].float().cuda(async=True)
if args.debug and i == 0:
img_grid = vsn.utils.make_grid(imgs, normalize=True)
msk_grid = vsn.utils.make_grid(msks)
vsn.utils.save_image(img_grid, '../imgs/train_imgs.png')
vsn.utils.save_image(msk_grid, '../imgs/train_msks.png')
# zero gradients from previous run
optimizer.zero_grad()
# get predictions
msk_preds, chck_preds = net(imgs)
# calculate loss
if use_lovasz:
loss = L.lovasz_hinge(msk_preds, msks)
else:
loss = focal_loss(msk_preds, msks)
loss -= dice(msk_preds.sigmoid(), msks)
loss += bce(chck_preds, msk_bool.view(-1, 1))
#loss += args.lambda_dice * dice(msk_preds.sigmoid(), msks)
#calculate gradients
loss.backward()
# update weights
optimizer.step()
# get training stats
iter_loss += loss.item()
# make a cool terminal output
sys.stdout.write('\r')
sys.stdout.write('B: {:>3}/{:<3} | {:.4}'.format(
i + 1, len(train_loader), loss.item()))
epoch_loss = iter_loss / (len(train_loader.dataset) / batch_size)
print('\n' + 'Avg Train Loss: {:.4}'.format(epoch_loss))
return epoch_loss
def train(student,
teacher,
optimizer,
train_loader,
w_t=0.,
e=0,
freeze_bn=False,
use_lovasz=False):
'''
uses the data loader to grab a batch of images
pushes images through network and gathers predictions
updates network weights by evaluating the loss functions
'''
# set network to train mode
student.train(True, freeze_bn)
teacher.train(True, freeze_bn)
# keep track of our loss
iter_loss = 0.
iter_closs = 0.
# loop over the images for the desired amount
for i, data in enumerate(train_loader):
imgs_a = data['img_a'].cuda()
imgs_b = data['img_b'].cuda()
msks = data['msk'].cuda()
labeled_bool = data['is_labeled'].cuda()
has_msk = data['has_msk'].float().cuda()
mask = labeled_bool == 1
if args.debug and i == 0:
#print('{} labeled, {} total'.format(len(imgs_a[mask]), len(imgs_a)))
img_a_grid = vsn.utils.make_grid(imgs_a, normalize=True)
img_b_grid = vsn.utils.make_grid(imgs_b, normalize=True)
msk_grid = vsn.utils.make_grid(msks)
vsn.utils.save_image(img_a_grid, '../imgs/train_mt_imgs_a.png')
vsn.utils.save_image(img_b_grid, '../imgs/train_mt_imgs_b.png')
vsn.utils.save_image(msk_grid, '../imgs/train_msks.png')
# zero gradients from previous run
optimizer.zero_grad()
# get predictions
preds_a, bool_a = student(imgs_a)
# calculate bce loss
if use_lovasz:
loss_s = L.lovasz_hinge(preds_a[mask], msks[mask])
else:
loss_s = focal_loss(preds_a[mask], msks[mask])
loss_s += L.lovasz_hinge(preds_a[mask], msks[mask])
loss_s += bce(bool_a[mask], has_msk[mask].view(-1, 1))
# get the teacher predictions
with torch.no_grad():
preds_b, bool_b = teacher(imgs_b)
loss_c = cl(preds_a, preds_b)
loss_c += cl(bool_a, bool_b)
loss = loss_s + w_t * loss_c
#calculate gradients
loss.backward()
# update weights
optimizer.step()
# get training stats
iter_loss += loss_s.item()
iter_closs += loss_c.item()
# update the teacher weights
grad_step = e * (len(train_loader.dataset) / args.batch_size) + (i + 1)
alpha = min(1. - 1. / (grad_step + 1), 0.99)
update_teacher(teacher, student, alpha=alpha)
# make a cool terminal output
sys.stdout.write('\r')
sys.stdout.write(
'B: {:>3}/{:<3} | loss: {:.4} | step: {} alpha: {:.4}'.format(
i + 1, len(train_loader), loss.item(), int(grad_step), alpha))
epoch_loss = iter_loss / (len(train_loader.dataset) / args.batch_size)
epoch_closs = iter_closs / (len(train_loader.dataset) / args.batch_size)
print('\n' + 'Avg Train Loss: {:.4}, Avg Consist. Loss: {:.4}'.format(
epoch_loss, epoch_closs))
return epoch_loss
def train(net, optimizer, train_loader, freeze_bn=False, swa=False):
'''
uses the data loader to grab a batch of images
pushes images through network and gathers predictions
updates network weights by evaluating the loss functions
'''
# set network to train mode
#if args.gpu == 99:
net.train()
#else:
# net.train(mode=True, freeze_bn=args.freeze_bn)
# keep track of our loss
iter_loss = 0.
# loop over the images for the desired amount
for i, data in enumerate(train_loader):
imgs = data['img'].to(device)
msks = data['msk']
msk_bool = data['has_msk'].to(device)
if args.debug and i == 0:
img_grid = vsn.utils.make_grid(imgs, normalize=True)
msk_grid = vsn.utils.make_grid(msks)
#msk_hgrid = vsn.utils.make_grid(msks_half)
#msk_qgrid = vsn.utils.make_grid(msks_qrtr)
vsn.utils.save_image(img_grid, '../imgs/train_imgs.png')
vsn.utils.save_image(msk_grid, '../imgs/train_msks.png')
#vsn.utils.save_image(msk_hgrid, '../imgs/train_msks_half.png')
#vsn.utils.save_image(msk_qgrid, '../imgs/train_msks_qrtr.png')
# get predictions
msk_preds = net(imgs)
#print(len(msk_preds), len(msks))
# calculate loss
# main mask loss
loss = focal_loss(msk_preds[0], msks[0].to(device))
loss += L.lovasz_hinge(msk_preds[0], msks[0].to(device))
# aux mask losses
for j in range(len(msks)):
#print(msk_preds[j+1].size(), msks[j].size())
loss += 0.1 * focal_loss(msk_preds[j + 1][msk_bool],
msks[j][msk_bool].to(device))
loss += 0.1 * L.lovasz_hinge(msk_preds[j + 1][msk_bool],
msks[j][msk_bool].to(device))
# binary loss
loss += 0.05 * bce(msk_preds[-1], msk_bool.float().view(-1, 1))
# zero gradients from previous run
optimizer.zero_grad()
#calculate gradients
loss.backward()
# update weights
optimizer.step()
# get training stats
iter_loss += loss.item()
# make a cool terminal output
sys.stdout.write('\r')
sys.stdout.write('B: {:>3}/{:<3} | {:.4}'.format(
i + 1, len(train_loader), loss.item()))
epoch_loss = iter_loss / (len(train_loader.dataset) / args.batch_size)
print('\n' + 'Avg Train Loss: {:.4}'.format(epoch_loss))
return epoch_loss
