def calc_loss(pred, target, metrics, phase='train', bce_weight=0.5): bce = F.binary_cross_entropy_with_logits(pred, target) pred = torch.sigmoid(pred) # convering tensor to numpy to remove from the computationl graph if phase == 'test': pred = (pred > 0.50).float() #with 0.55 is a little better dice = dice_loss(pred, target) jaccard_loss = metric_jaccard(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) metrics['bce'] = bce.data.cpu().numpy() * target.size(0) metrics['loss'] = loss.data.cpu().numpy() * target.size(0) metrics['dice'] = 1 - dice.data.cpu().numpy() * target.size(0) metrics[ 'jaccard'] = 1 - jaccard_loss.data.cpu().numpy() * target.size(0) else: dice = dice_loss(pred, target) jaccard_loss = metric_jaccard(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) metrics['dice_loss'] += dice.data.cpu().numpy() * target.size(0) metrics['jaccard_loss'] += jaccard_loss.data.cpu().numpy( ) * target.size(0) return loss
def calc_loss_paral(pred_hr, target_hr, pred_vhr_lab, target_vhr_lab, pred_vhr_unlab, target_vhr_unlab_up, metrics, weight_loss=0.1, bce_weight=0.5): #loss for HR model bce_l1 = F.binary_cross_entropy_with_logits(pred_hr, target_hr) pred_hr = torch.sigmoid(pred_hr) dice_l1 = dice_loss(pred_hr, target_hr) loss_l1 = bce_l1 * bce_weight + dice_l1 * (1 - bce_weight) #loss for HR model label bce_l2 = F.binary_cross_entropy_with_logits(pred_vhr_lab, target_vhr_lab) pred_vhr_lab = torch.sigmoid((pred_vhr_lab)) dice_l2 = dice_loss(pred_vhr_lab, target_vhr_lab) loss_l2 = bce_l2 * bce_weight + dice_l2 * (1 - bce_weight) #loss for VHR model unlabel bce_l3 = F.binary_cross_entropy_with_logits(pred_vhr_unlab, target_vhr_unlab_up) pred_vhr_unlab = torch.sigmoid((pred_vhr_unlab)) dice_l3 = dice_loss(pred_vhr_unlab, target_vhr_unlab_up) loss_l3 = bce_l3 * bce_weight + dice_l3 * (1 - bce_weight) #loss for full-network loss = (loss_l1 + loss_l2 + loss_l3 * weight_loss) metrics['loss_HR'] += loss_l1.data.cpu().numpy() * target_hr.size(0) metrics['loss_VHR_lab'] += loss_l2.data.cpu().numpy( ) * target_vhr_lab.size(0) metrics['loss_VHR_unlab'] += loss_l3.data.cpu().numpy( ) * target_vhr_unlab_up.size(0) metrics['loss'] += loss.data.cpu().numpy() * ( target_vhr_lab.size(0) + target_vhr_unlab_up.size(0) ) #* target.size(0) metrics['loss_dice_lb'] += dice_l2.data.cpu().numpy( ) * target_vhr_lab.size(0) metrics['loss_dice_unlab'] += dice_l3.data.cpu().numpy( ) * target_vhr_unlab_up.size(0) #cambiar por hr_label return loss
def calc_loss(pred, target, metrics, bce_weight=0.5): bce = F.binary_cross_entropy_with_logits(pred, target) pred = torch.sigmoid(pred) dice = dice_loss(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) pred_flat = pred.view(-1).data.cpu().numpy() target_flat = target.view(-1).data.cpu().numpy() # pred_flat[pred_flat>=0.5]=1 # pred_flat[pred_flat < 0.5] = 0 #pred_flat = pred_flat//255 # acc = np.sum(pred_flat==target_flat)/pred_flat.shape[0] # f1score = f1_score(pred_flat,target_flat) #pixel_acc = torch.true_divide(torch.sum(pred_flat==target.view(-1)),pred.view(-1).shape[0]) metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['dice'] += dice.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) #metrics['pixel_acc'] = acc #metrics['f1_score'] = f1score return loss
def __init__(self, config, train_loader, valid_loader, test_loader): self.train_loader = train_loader self.valid_loader = valid_loader self.test_loader = test_loader self.net = None self.optimizer = None self.criterion = dice_loss(scale=1) #self.criterion = torch.nn.BCELoss() self.lr = config.lr self.beta1 = config.beta1 self.beta2 = config.beta2 if config.train_dataset == 'african': self.img_size = (640, 640) elif config.train_dataset == 'asian': self.img_size = (640, 480) elif config.train_dataset == 'mobile': self.img_size = (384, 384) self.num_epochs = config.num_epochs self.batch_size = config.batch_size self.train_dataset = config.train_dataset self.model_path = config.model_path self.result_path = config.result_path + '/' + config.train_dataset self.mode = config.mode self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.best_mIoU = 0 self.testdata_augmentation = T.Compose([T.ToTensor()]) self.build_model()
def run_cv(img_size, pre_trained): image_files = get_img_files() kf = KFold(n_splits=N_CV, random_state=RANDOM_STATE, shuffle=True) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") for n, (train_idx, val_idx) in enumerate(kf.split(image_files)): train_files = image_files[train_idx] val_files = image_files[val_idx] writer = SummaryWriter() def on_after_epoch(m, df_hist): save_best_model(n, m, df_hist) write_on_board(writer, df_hist) log_hist(df_hist) criterion = dice_loss(scale=2) data_loaders = get_data_loaders(train_files, val_files, img_size) trainer = Trainer(data_loaders, criterion, device, on_after_epoch) model = MobileNetV2_unet(pre_trained=pre_trained) model.to(device) optimizer = Adam(model.parameters(), lr=LR) hist = trainer.train(model, optimizer, num_epochs=N_EPOCHS) hist.to_csv('{}/{}-hist.csv'.format(OUT_DIR, n), index=False) writer.close() break
def train(): json_file = open("parameters.json") parameters = json.load(json_file) json_file.close() net = VNet() net = torch.nn.DataParallel(net, device_ids=[0, 1, 2, 3]) net.cuda() cudnn.benchmark = True optimizer = torch.optim.Adam(net.parameters(), lr = parameters["lr"]) criterion = nn.BCELoss() promise_dataset = PromiseDataset(is_train = True) train_loader = torch.utils.data.DataLoader(dataset = promise_dataset, batch_size = parameters["batch_size"]) for epoch in range(parameters["num_epochs"]): net.train() for i, (data, label) in enumerate(train_loader): optimizer.zero_grad() output = net(data) loss = dice_loss(output, label) loss.backward() optimizer.step() print ('Epoch [{}/{}], Loss: {:.4f}' .format(epoch+1, parameters["num_epochs"], loss.item())) torch.save(net.state_dict(), "weights/promise12_weight.pth")
def grad(model, inputs, targets): with tf.GradientTape() as t: model_output = model(inputs) current_dice_loss = loss_lib.dice_loss(targets[0], model_output[0]) current_bboxes_loss = loss_lib.masked_mae_loss(targets[1], model_output[1]) total_loss = current_dice_loss + current_bboxes_loss total_grad = t.gradient(total_loss, model.trainable_variables) return current_dice_loss, current_bboxes_loss, total_loss, total_grad
def train_one_epoch(model, optimizer, data_loader, device, epoch, num_epochs, tb_writer): model.train() losses = np.array([]) metrics = np.array([]) bi0 = epoch * len(data_loader) # batch index logger.info(('\n' + '%10s' * 2) % ('Epoch', 'loss')) pbar = tqdm(enumerate(data_loader), total=len(data_loader)) s = ('%10s' + '%10.4f') % ( '-/%g' % (num_epochs - 1), 0.0) pbar.set_description(s) for i, (imgs, targets) in pbar: imgs, targets = imgs.to(device), targets.to(device) if opt.model == 'deeplabv3': preds = model(imgs)['out'] targets = targets.long() elif opt.model == 'hrnet_w18' or opt.model == 'hrnet_w48': preds = model(imgs) h, w = preds.shape[2], preds.shape[3] targets = F.interpolate(targets.float(), size=(h, w), mode='nearest').long() elif opt.model == 'dilated_unet': preds = model(imgs) targets = targets.long() if opt.loss == 'ce': loss = ce_loss(targets, preds) elif opt.loss == 'dice': loss = dice_loss(targets, preds) elif opt.loss == 'jaccard': loss = jaccard_loss(targets, preds) else: logger.critical('unsupported loss function') exit(1) optimizer.zero_grad() loss.backward() optimizer.step() with torch.no_grad(): # cv2_imshow(imgs[0], preds[0]) losses = np.append(losses, loss.item()) # metrics = np.append(metrics, metric) # avg_loss = moving_avg(losses, 10) # avg_metric = moving_avg(metrics, 10) # print('[{:d}]{:d}/{:d}: loss={:4f}, dice={:4f}'.format(epoch, i + 1, len(data_loader), # avg_loss, avg_metric)) # logger.info('[{:d}]{:d}/{:d}: dice loss={:4f}'.format(epoch, i + 1, len(data_loader), loss.item())) s = ('%10s' + '%10.4f') % ( '%g/%g' % (epoch, num_epochs - 1), loss.item()) pbar.set_description(s) bi = bi0 + i tb_writer.add_scalar('train_batch_loss', loss.item(), bi) epoch_loss = losses.mean() # epoch_recent_metric = moving_avg(metrics, 10) return epoch_loss
def calc_loss(pred, target, metrics, bce_weight=0.5): bce = F.binary_cross_entropy_with_logits(pred.float(), target.float()) pred = torch.sigmoid(pred) dice = dice_loss(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['dice'] += dice.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) return loss
def calc_loss(pred, target, metrics, bce_weight=0.5): bce = F.binary_cross_entropy_with_logits(pred, target) pred = torch.sigmoid(pred) dice = dice_loss(pred, target) iou_score = iou(pred, target) aed_score = aed(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) metrics['iou'] += iou_score.sum() metrics['aed'] += aed_score.sum() metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['dice'] += dice.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) return loss
def calc_loss(pred, target, metrics, bce_weight=0.5): pred=pred.type('torch.FloatTensor') target=target.type('torch.FloatTensor') bce = F.binary_cross_entropy_with_logits(pred, target) pred = F.sigmoid(pred) dice = dice_loss(pred, target) gc_loss = cal_gc(pred,target) loss = bce * bce_weight + dice * (1 - bce_weight)+gc_loss metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['dice'] += dice.data.cpu().numpy() * target.size(0) metrics['gc_loss'] += gc_loss.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) return loss
def calc_loss(pred, target, metrics, bce_weight=0.5): """ Validate F.binary_cross_entropy_with_logits(pred, target, reduction='none').mean() and F.binary_cross_entropy_with_logits(pred, target, reduction='mean') are same: Rsult : Validated binary_cross_entropy_with_logits_test.py """ bce = F.binary_cross_entropy_with_logits(pred, target, reduction='mean') pred = torch.sigmoid(pred) dice = dice_loss(pred, target) loss = bce * bce_weight + dice * (1 - bce_weight) metrics['bce'] += bce.data.cpu().numpy() * target.size(0) metrics['dice'] += dice.data.cpu().numpy() * target.size(0) metrics['loss'] += loss.data.cpu().numpy() * target.size(0) return loss
def __init__(self, model_root_channel=8, img_size=256, batch_size=20, n_channel=1, n_class=2): self.drop_rate = tf.placeholder(tf.float32) self.training = tf.placeholder(tf.bool) self.batch_size = batch_size self.model_channel = model_root_channel self.X = tf.placeholder(tf.float32, [None, img_size, img_size, n_channel], name='X') self.Y = tf.placeholder(tf.float32, [None, img_size, img_size, n_class], name='Y') self.logits = self.neural_net() self.foreground_predicted, self.background_predicted = tf.split( self.logits, [1, 1], 3) self.foreground_truth, self.background_truth = tf.split( self.Y, [1, 1], 3) # # Cross_Entropy # self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=self.logits, labels=self.Y)) self.loss = loss.dice_loss(output=self.logits, target=self.Y) # self.accuracy = layer.iou_coe(output=self.logits, target=self.Y) with tf.name_scope('Metrics'): self.accuracy = layer.mean_iou(self.foreground_predicted, self.foreground_truth) # TB tf.summary.scalar('loss', self.loss) tf.summary.scalar('accuracy', self.accuracy)
run_id = int(runs[-1].split('_')[-1]) + 1 if runs else 0 save_dir = os.path.join(save_dir_root, 'run') # Network definition # if backbone == 'xception': # net = deeplab_xception.DeepLabv3_plus(nInputChannels=3, n_classes=12, os=16, pretrained=False) # elif backbone == 'resnet': # net = deeplab_resnet.DeepLabv3_plus(nInputChannels=3, n_classes=12, os=16, pretrained=False) # else: # raise NotImplementedError net = cenet.CE_Net_backbone_DAC_with_inception(num_classes=1, num_channels=3) modelName = 'CEnet-' + backbone + '-voc' criterion_mask = loss.dice_loss() # criterion_edge = loss.weighted_cross_entropy(num_classes=12) # criterion = loss.FocalLoss(gamma=2) print("Backbone network is {}".format(backbone)) if resume_epoch == 0: print("Training deeplabv3+ from scratch...") else: print("Initializing weights from: {}...".format( os.path.join(save_dir, 'models', modelName + '_epoch-' + str(resume_epoch - 1) + '.pth'))) net.load_state_dict( torch.load(os.path.join( save_dir, 'models', modelName + '_epoch-' + str(resume_epoch - 1) + '.pth'),
net.train() for i, data in enumerate(train_data): # wrap data in Variables inputs, labels = data if cuda: inputs, labels = inputs.cuda(), labels.cuda() inputs, labels = Variable(inputs), Variable(labels) # forward pass and loss calculation outputs = net(inputs) # get either dice loss or cross-entropy if dice: outputs = outputs[:, 1, :, :].unsqueeze(dim=1) loss = dice_loss(outputs, labels) else: labels = labels.squeeze(dim=1) loss = criterion(outputs, labels) # empty gradients, perform backward pass and update weights optimizer.zero_grad() loss.backward() optimizer.step() # save and print statistics running_loss += loss.data[0] # print statistics if dice: print(' [epoch %d] - train dice loss: %.3f' %
train_data = Dataset_brain_4(file_path) batch_size = 64 train_loader = data.DataLoader(dataset=train_data, batch_size=batch_size, shuffle=True, drop_last=True, num_workers=4) unet = Unet(4) optimizer = torch.optim.Adam(unet.parameters(), lr=0.001) unet.cuda() unet.train() EPOCH = 30 print(EPOCH) for epoch in range(EPOCH): batch_score = 0 num_batch = 0 for i, (img, label) in enumerate(train_loader): seg = unet(img.float().cuda()) loss = dice_loss(seg, label.float().cuda()) optimizer.zero_grad() loss.backward() optimizer.step() seg = seg.cpu() seg[seg >= 0.5] = 1. seg[seg != 1] = 0. batch_score += dice_score(seg, label.float()).data.numpy() num_batch += img.size(0) batch_score /= num_batch print('EPOCH %d : train_score = %.4f' % (epoch, batch_score)) torch.save(unet.state_dict(), model_save)
out_src, _ = discriminator(x_hat, t2.float().cuda()) d_loss_gp = gradient_penalty(out_src, x_hat) # d_loss_gp.backward(retain_graph=True) d_loss = d_loss_real + d_loss_fake + LAMBDA_CLS * d_loss_cls + LAMBDA_GP * d_loss_gp optimizer_d.zero_grad() d_loss.backward() optimizer_d.step() ############################################## generator fake = generator(t2.float().cuda(), label) out_src, out_cls = discriminator(fake, t2.float().cuda()) g_loss_fake = -torch.mean(out_src.sum([1, 2, 3])) g_loss_cls = classification_loss(out_cls, label) g_loss_rec = torch.mean( torch.abs(real.float().cuda() - fake).sum([1, 2, 3])) pred = unet(fake, label) g_loss_seg = dice_loss(pred, seg.float().cuda()) g_loss = g_loss_fake + LAMBDA_CLS * g_loss_cls + g_loss_rec * LAMBDA_REC + g_loss_seg * LAMBDA_SEG optimizer_g.zero_grad() g_loss.backward() optimizer_g.step() ############################################## segmentor fake = generator(t2.float().cuda(), label) pred = unet(fake.detach(), label) pred_2 = unet(real.float().cuda(), label) s_loss = dice_loss(pred, seg.float().cuda()) s_loss_2 = dice_loss(pred_2, seg.float().cuda()) s_loss = 0.7 * s_loss + 0.3 * s_loss_2 optimizer_s.zero_grad() s_loss.backward() optimizer_s.step()
loss_ = 0. tm_ = 0. tj_ = 0. th_ = 0. acc_ = 0. progress.set_description('Epoch: %s' % str(ep+1)) for idx, batch_data in enumerate(train): X, y_mask, y_joint, y_height = batch_data['img'].cuda(), batch_data['mask'].cuda(), batch_data['joint'].cuda(), batch_data['height'].cuda() optimizer.zero_grad() mask_o, joint_o, height_o = net(X) loss_m = w1_loss * (dice_loss(mask_o, y_mask, 0) + dice_loss(mask_o, y_mask, 1))/2 loss_j = w2_loss * nn.CrossEntropyLoss()(joint_o, y_joint) loss_h = w3_loss * height_loss(height_o, y_height) loss = loss_h + loss_m + loss_j pred = torch.argmax(height_o, 1) loss.backward() optimizer.step() progress.update(1) loss_ += loss.item() tm_ += loss_m.item() tj_ += loss_j.item()