NetC = NetC(ngpu=opt.ngpu) # NetC.apply(weights_init) print(NetC) if cuda: NetS = NetS.cuda() NetC = NetC.cuda() # criterion = criterion.cuda() # setup optimizer lr = opt.lr decay = opt.decay optimizerG = optim.Adam(NetS.parameters(), lr=lr, betas=(opt.beta1, 0.999)) optimizerD = optim.Adam(NetC.parameters(), lr=lr, betas=(opt.beta1, 0.999)) # load training data dataloader = loader(Dataset('./'), opt.batchSize) # load testing data dataloader_val = loader(Dataset_val('./'), opt.batchSize) max_iou = 0 NetS.train() for epoch in range(opt.niter): for i, data in enumerate(dataloader, 1): # train C NetC.zero_grad() input, label = Variable(data[0]), Variable(data[1]) if cuda: input = input.cuda() target = label.cuda() target = target.type(torch.FloatTensor) target = target.cuda()
mediastinums_data = sum(mediastinums_data, []) # # print(len(train_datas),len(train_labels),len(lungs_data),len(mediastinums_data)) # #loading test data test_datas = glob.glob('../data_5pictures/images_1/*.jpg') test_labels = glob.glob('../data_5pictures/masks_1/*.jpg') lungs_test = glob.glob('../data_5pictures/lungs_1/*jpg') mediastinums_test = glob.glob('../data_5pictures/med_1/*jpg') print('data info------------------------------------------------') print(len(train_datas), len(train_labels), len(test_datas), len(test_labels), len(lungs_data), len(mediastinums_data)) print(len(lungs_data), len(mediastinums_data), len(lungs_test), len(mediastinums_test), len(lungs_test), len(mediastinums_test)) dataloader = loader( Dataset(train_datas, train_labels, lungs_data, mediastinums_data), opt.batchSize) dataloader_val = loader( Dataset_val(test_datas, test_labels, lungs_test, mediastinums_test), opt.batchSize) # load testing data # dataloader_val = loader(Dataset_val('../../node/dataset/dataset_96_random_info/'), opt.batchSize) max_iou = 0 NetS.train() #TODO classfiy loss loss_function = nn.CrossEntropyLoss() def cross_loss(input, target): # input = input.cuda()
parser.add_argument("--outpath", default="./test_outputs") parser.add_argument('--batchSize', type=int, default=1) parser.add_argument('--ngpu', type=int, default=1) parser.add_argument('--weight_path', type=str) parser.add_argument("--exp_id", type=int) parser.add_argument("--store_images", default=False, action="store_true") parser.add_argument("--thinning", default=False, action="store_true") opt = parser.parse_args() try: os.makedirs(opt.outpath) except OSError: pass cuda = True dataloader_test = loader(Dataset_test('./'), opt.batchSize) cudnn.benchmark = True IoUs = [] hds = [] NetS = NetS(ngpu=opt.ngpu) NetS.load_state_dict(torch.load(opt.weight_path)) NetS.cuda() NetS.eval() for i, data in enumerate(dataloader_test, 1): input, label = Variable(data[0]), Variable(data[1]) if cuda: input = input.cuda() label = label.cuda()
def main(): from Dense-residual-block import NetC,NetS cuda = opt.cuda if cuda and not torch.cuda.is_available(): raise Exception("No GPU found, please run without --cuda") torch.manual_seed(opt.seed) if cuda: torch.cuda.manual_seed(opt.seed) cudnn.benchmark = True n_layers_list = [4, 5, 7, 10, 12, 15, 12, 10, 7, 5, 4] NetS = NetS(n_layers_list, 5) print(NetS) NetC = NetC(ngpu = opt.ngpu) print(NetC) if cuda: NetS = NetS.cuda() NetC = NetC.cuda() lr = opt.lr decay = opt.decay optimizerG = optim.Adam(NetS.parameters(), lr=lr, betas=(opt.beta1, 0.999)) optimizerD = optim.Adam(NetC.parameters(), lr=lr, betas=(opt.beta1, 0.999)) dataloader = loader(Dataset('./'),opt.batchSize) print(len(dataloader)) dataloader_val = loader(Dataset_val('./'), opt.batchSize) print(len(dataloader_val)) logger=Logger('./logs/Dense_Residual_block') max_Jac = 0 NetS.train() history = {split: {'epoch': [], 'Loss_D': [], 'Loss_G_joint': []} for split in ('train', 'val')} history1 = {split: {'epoch': [], 'Jac': [], 'Dsc': [], 'acc': [],'se':[], 'sp':[]} for split in ('train', 'val')} for epoch in range(opt.niter): for i, data in enumerate(dataloader, 1): NetC.zero_grad() input, label = Variable(data[0]), Variable(data[1]) if cuda: input = input.cuda() target = label.cuda() else: input=input target=label target = target.type(torch.FloatTensor) target = target.cuda() output = NetS(input) output = F.sigmoid(output) output = output.detach() output_masked = input.clone() input_mask = input.clone() for d in range(3): if d==0: output_masked[:, d:, :, :] = input_mask[:, d, :, :].unsqueeze(1) * output else: output_masked[:,:d:, :, :] = input_mask[:,d,:,:].unsqueeze(1) * output if cuda: output_masked = output_masked.cuda() result = NetC(output_masked) target_masked = input.clone() for d in range(3): if d==0: target_masked[:,d:,:,:] = input_mask[:,d,:,:].unsqueeze(1) * target else: target_masked[:,:d:,:,:] = input_mask[:,d,:,:].unsqueeze(1) * target if cuda: target_masked = target_masked.cuda() target_D = NetC(target_masked) target_D.detach() loss_D = -torch.mean(torch.abs(result - target_D)) loss_D.backward() optimizerD.step() for p in NetC.parameters(): p.data.clamp_(-0.05, 0.05) NetS.zero_grad() output = NetS(input) output = F.sigmoid(output) for d in range(3): if d==0: output_masked[:, d:, :, :] = input_mask[:, d, :, :].unsqueeze(1) * output else: output_masked[:, :d:, :, :] = input_mask[:, d, :, :].unsqueeze(1) * output if cuda: output_masked = output_masked.cuda() result = NetC(output_masked) for d in range(3): if d==0: target_masked[:, d:, :, :] = input_mask[:, d, :, :].unsqueeze(1) * target else: target_masked[:, :d:, :, :] = input_mask[:, d, :, :].unsqueeze(1) * target if cuda: target_masked = target_masked.cuda() target_G = NetC(target_masked) loss_dice = dice_loss(output,target) loss_G = torch.mean(torch.abs(result - target_G)) label_edge = getEdge(target_masked) _, pred3 = (torch.max(output_masked, 1)) pred_edge = getEdge(pred3) loss_G_joint = torch.mean(torch.abs(result - target_G)) + opt.a * EPE(label_edge,pred_edge)+opt.b*loss_dice loss_G_joint.backward() optimizerG.step() step = len(dataloader) * epoch + i info = {'D_loss': loss_D.data[0], 'G_loss': loss_G.data[0], 'loss_dice': loss_dice.data[0]} for tag, value in info.items(): logger.scalar_summary(tag, value, step) print("===> Epoch[{}]({}/{}): Batch Dice: {:.4f}".format(epoch, i, len(dataloader), 1 - loss_dice.data[0])) print("===> Epoch[{}]({}/{}): G_Loss: {:.4f}".format(epoch, i, len(dataloader), loss_G.data[0])) print("===> Epoch[{}]({}/{}): D_Loss: {:.4f}".format(epoch, i, len(dataloader), loss_D.data[0])) vutils.save_image(data[0], '%s/input.png' % opt.outpath, normalize=True) vutils.save_image(data[1], '%s/label.png' % opt.outpath, normalize=True) vutils.save_image(output.data, '%s/result.png' % opt.outpath, normalize=True) if epoch % 10 == 0: NetS.eval() Jacs, dices, accs,SEs,SPs= [], [],[],[],[] for i, data in enumerate(dataloader_val, 1): input, gt = Variable(data[0]), Variable(data[1]) if cuda: input = input.cuda() gt = gt.cuda() pred = NetS(input) pred[pred < 0.5] = 0 pred[pred >= 0.5] = 1 pred = pred.type(torch.LongTensor) pred_np = pred.data.cpu().numpy() gt = gt.data.cpu().numpy() for x in range(input.size()[0]): Jac = np.sum(pred_np[x][gt[x]==1]) / float(np.sum(pred_np[x]) + np.sum(gt[x]) - np.sum(pred_np[x][gt[x]==1])) Dsc = np.sum(pred_np[x][gt[x]==1])*2 / float(np.sum(pred_np[x]) + np.sum(gt[x])) acc = float(np.sum(pred_np[x][gt[x] == 1])+np.sum(pred_np[x][gt[x] == 0])) / float(np.sum(pred_np[x]) + np.sum(gt[x])+np.sum(pred_np[x][gt[x] == 1])+np.sum(pred_np[x][gt[x] == 0])) SE=np.sum(pred_np[x][gt[x]==1])/ float(np.sum(pred_np[x][gt[x]==1])+np.sum(pred_np[x])) SP=np.sum(pred_np[x][gt[x] == 0])/float(np.sum(pred_np[x][gt[x] == 0])+np.sum(gt[x])) Jacs.append(Jac) Dscs.append(Dsc) accs.append(acc) SEs.append(SE) SPs.append(SP) NetS.train() Jacs = np.array(Jacs, dtype=np.float64) Dscs = np.array(dices, dtype=np.float64) accs = np.array(accs, dtype=np.float64) SEs = np.array(SEs, dtype=np.float64) SPs = np.array(SPs, dtype=np.float64) mJac = np.mean(Jacs, axis=0) mDsc = np.mean(Dscs, axis=0) macc = np.mean(accs, axis=0) mSE= np.mean(SEs, axis=0) mSP = np.mean(SPs, axis=0) history1['train']['epoch'].append(epoch) history1['train']['Jac'].append(mJac) history1['train']['Dsc'].append(mDsc) history1['train']['acc'].append(macc) history1['train']['SE'].append(mSE) history1['train']['SP'].append(mSP) print('Plotting evaluation metrics figure...') plt.xlabel('Epoch') plt.ylabel('Jac_dice') fig = plt.figure() plt.plot(history1['train']['epoch'], history1['train']['Jac'], color='b', label='Jac') plt.plot(history1['train']['epoch'], history1['train']['Dsc'], color='c', label='Dsc') plt.plot(history1['train']['epoch'], history1['train']['acc'], color='y', label='acc') plt.plot(history1['train']['epoch'], history1['train']['SE'], color='g', label='SE') plt.plot(history1['train']['epoch'], history1['train']['SP'], color='r', label='SP') plt.legend() fig.savefig('{}/ evaluation metrics.png'.format(opt.ckpt), dpi=200) plt.close('all') info = {'Jac': mJac, 'DSC': mDsc,'acc':macc, 'SE':mSE, 'SP':mSP} for tag, value in info.items(): logger.scalar_summary(tag, value, epoch) print('mJac: {:.4f}'.format(mJac)) print('mDsc: {:.4f}'.format(mDsc)) print('macc: {:.4f}'.format(macc)) print('mSE: {:.4f}'.format(mSE)) print('mSP: {:.4f}'.format(mSP)) if mJac > max_Jac: max_Jac = mJac torch.save(NetS.state_dict(), '%s/NetS_epoch_%d.pth' % (opt.outpath, epoch)) vutils.save_image(data[0], '%s/input_val.png' % opt.outpath, normalize=True) vutils.save_image(data[1], '%s/label_val.png' % opt.outpath, normalize=True) pred = pred.type(torch.FloatTensor) vutils.save_image(pred.data, '%s/result_val.png' % opt.outpath, normalize=True) if epoch % 25 == 0: lr = lr*decay if lr <= 0.000001: lr = 0.000001 print('Learning Rate: {:.6f}'.format(lr)) print('Max mJac: {:.4f}'.format(max_Jac)) optimizerG = optim.Adam(NetS.parameters(), lr=lr, betas=(opt.beta1, 0.999)) optimizerD = optim.Adam(NetC.parameters(), lr=lr, betas=(opt.beta1, 0.999))
if cuda: NetS = NetS.cuda() #NetC = NetC.cuda() # setup optimizer lr = opt.lr decay = opt.decay optimizerG = optim.Adam(NetS.parameters(), lr=lr, betas=(opt.beta1, 0.999)) #optimizerD = optim.Adam(NetC.parameters(), lr=lr, betas=(opt.beta1, 0.999)) test_data = glob.glob('../data_5pictures/images_5/*.jpg') test_label = glob.glob('../data_5pictures/masks_5/*.jpg') test_lung = glob.glob('../data_5pictures/lungs_5/*.jpg') test_med = glob.glob('../data_5pictures/med_5/*.jpg') #dataloader = loader(Dataset(test_data),opt.batchSize) dataloader_val = loader( Dataset_val(test_data, test_label, test_lung, test_med), opt.batchSize) max_iou = 0 NetS.train() NetS.load_state_dict(torch.load('./outputs_att_info/NetS_epoch_137_5.pth')) print('load S ok') NetS.eval() # NetC.train() # NetC.load_state_dict(torch.load('./outputs/NetC_epoch_220.pth')) # print('load C ok') # NetC.eval() #分析训练数据 for i, data in enumerate(dataloader_val, 1): input, gt, lung, med, name = Variable(data[0]), Variable(
def main(batch_size, n_epochs, lr, beta1, decay, _run): assert torch.cuda.is_available() writer = SummaryWriter( os.path.join(base_path, "runs", "experiment-{}".format(_run._id))) model_path = os.path.join(fs_observer.dir, "best_model.pth") outputs_path = os.path.join(fs_observer.dir, "outputs") if not os.path.exists(outputs_path): os.mkdir(outputs_path) cudnn.benchmark = True s_model = SegmentorNet().cuda() c_model = CriticNet().cuda() s_optimizer = optim.Adam(s_model.parameters(), lr=lr, betas=(beta1, 0.999)) c_optimizer = optim.Adam(c_model.parameters(), lr=lr, betas=(beta1, 0.999)) s_scheduler = CyclicLR(s_optimizer, base_lr=lr, max_lr=lr * 10) c_scheduler = CyclicLR(c_optimizer, base_lr=lr, max_lr=lr * 10) dataloaders = { "train": loader(Dataset('./'), batch_size), "validation": loader(Dataset_val('./'), 36) } best_IoU = 0.0 s_model.train() for epoch in range(n_epochs): progress_bar = tqdm(dataloaders["train"], desc="Epoch {} - train".format(epoch)) s_losses = [] s_losses_joint = [] c_losses = [] dices = [] for i, (inputs, targets) in enumerate(progress_bar): c_model.zero_grad() inputs = Variable(inputs).cuda() targets = Variable(targets).cuda().type(torch.FloatTensor).cuda() outputs = s_model(inputs) outputs = F.sigmoid(outputs) outputs = outputs.detach() outputs_masked = inputs.clone() inputs_mask = inputs.clone() for d in range(3): outputs_masked[:, d, :, :] = inputs_mask[:, d, :, :].unsqueeze( 1) * outputs outputs_masked = outputs_masked.cuda() results = c_model(outputs_masked) targets_masked = inputs.clone() for d in range(3): targets_masked[:, d, :, :] = inputs_mask[:, d, :, :].unsqueeze( 1) * targets for d in range(3): targets_masked[:, d, :, :] = inputs_mask[:, d, :, :].unsqueeze( 1) * targets targets_masked = targets_masked.cuda() targets_D = c_model(targets_masked) loss_D = -torch.mean(torch.abs(results - targets_D)) loss_D.backward() c_optimizer.step() c_scheduler.batch_step() for p in c_model.parameters(): p.data.clamp_(-0.05, 0.05) s_model.zero_grad() outputs = s_model(inputs) outputs = F.sigmoid(outputs) for d in range(3): outputs_masked[:, d, :, :] = inputs_mask[:, d, :, :].unsqueeze( 1) * outputs outputs_masked = outputs_masked.cuda() results = c_model(outputs_masked) for d in range(3): targets_masked[:, d, :, :] = inputs_mask[:, d, :, :].unsqueeze( 1) * targets targets_masked = targets_masked.cuda() targets_G = c_model(targets_masked) loss_dice = dice_loss(outputs, targets) loss_G = torch.mean(torch.abs(results - targets_G)) loss_G_joint = loss_G + loss_dice loss_G_joint.backward() s_optimizer.step() s_scheduler.batch_step() c_losses.append(loss_D.data[0]) s_losses.append(loss_G.data[0]) s_losses_joint.append(loss_G_joint.data[0]) dices.append(loss_dice.data[0]) progress_bar.set_postfix( OrderedDict({ "c_loss": np.mean(c_losses), "s_loss": np.mean(s_losses), "s_loss_joint": np.mean(s_losses_joint), "dice": np.mean(dices) })) mean_c_loss = np.mean(c_losses) mean_s_loss = np.mean(s_losses) mean_s_loss_joint = np.mean(s_losses_joint) mean_dice = np.mean(dices) c_loss_tag = "train.c_loss" s_loss_tag = "train.s_loss" s_losses_joint_tag = "train.s_loss_joint" dice_loss_tag = "train.loss_dice" writer.add_scalar(c_loss_tag, mean_c_loss, epoch) writer.add_scalar(s_loss_tag, mean_s_loss, epoch) writer.add_scalar(s_losses_joint_tag, mean_s_loss_joint, epoch) writer.add_scalar(dice_loss_tag, mean_dice, epoch) if epoch % 10 == 0: progress_bar = tqdm(dataloaders["validation"], desc="Epoch {} - validation".format(epoch)) s_model.eval() IoUs, dices = [], [] for i, (inputs, targets) in enumerate(progress_bar): inputs = Variable(inputs).cuda() targets = Variable(targets).cuda() pred = s_model(inputs) pred[pred < 0.5] = 0 pred[pred >= 0.5] = 1 pred = pred.type(torch.LongTensor) pred_np = pred.data.cpu().numpy() targets = targets.data.cpu().numpy() for x in range(inputs.size()[0]): IoU = np.sum(pred_np[x][targets[x] == 1]) / float( np.sum(pred_np[x]) + np.sum(targets[x]) - np.sum(pred_np[x][targets[x] == 1])) dice = np.sum(pred_np[x][targets[x] == 1]) * 2 / float( np.sum(pred_np[x]) + np.sum(targets[x])) IoUs.append(IoU) dices.append(dice) progress_bar.set_postfix( OrderedDict({ "mIoU": np.mean(IoUs, axis=0), "mDice": np.mean(dices, axis=0) })) s_model.train() IoUs = np.array(IoUs, dtype=np.float64) dices = np.array(dices, dtype=np.float64) mIoU = np.mean(IoUs, axis=0) mDice = np.mean(dices, axis=0) miou_tag = "validation.miou" mdice_tag = "validation.mdice" writer.add_scalar(miou_tag, mIoU, epoch) writer.add_scalar(mdice_tag, mDice, epoch) writer.commit() if mIoU > best_IoU: best_IoU = mIoU torch.save(s_model, model_path) if epoch % 25 == 0: lr = max(lr * decay, 0.00000001) s_optimizer = optim.Adam(s_model.parameters(), lr=lr, betas=(beta1, 0.999)) c_optimizer = optim.Adam(c_model.parameters(), lr=lr, betas=(beta1, 0.999))