import argparse import os from random import seed, shuffle import random import time import sys from PIL import Image from test import count_label_unlabel Image.MAX_IMAGE_PIXELS = None join = os.path.join import numpy as np import torch from torch.utils.data import DataLoader import torch.nn.functional as F import monai import torch.optim as optim from dataloaders.dataset import get_train_loader, get_val_loader, get_val_WSI_loader from monai.data import decollate_batch, PILReader from monai.inferers import sliding_window_inference from utils.Metrics import DiceMetric from utils.losses import DiceLoss, KDLoss, entropy_loss import logging import csv from networks.unet import UNet from core.networks import MTNet_Plus from tensorboardX import SummaryWriter from medpy import metric from torch import nn def get_arguments(): parser = argparse.ArgumentParser(description="Digest Path 2019 Pytorch implementation") parser.add_argument("--dataset_root", type=str, default="", help="training images") parser.add_argument("--batch_size", type=int, default=16, help="Train batch size") parser.add_argument("--labeled_bs", type=int, default=8) parser.add_argument("--num_class", type=int, default=2, help="Train class num") parser.add_argument("--input_size", default=256) parser.add_argument("--lr", type=float, default=2e-3) parser.add_argument("--weight_decay", type=float, default=5e-4) parser.add_argument("--gpu", nargs="+", type=int) parser.add_argument("--save_folder", default="model") parser.add_argument("--num_workers", default=6) parser.add_argument("--max_epoch", default=40, type=int) parser.add_argument('--consistency', type=float, default=0.1, help='consistency') parser.add_argument('--consistency_rampup', type=float, default=30.0, help='consistency_rampup') parser.add_argument("--portion", default=5, type=int) return parser.parse_args() def get_deeplab(args, ema=False): model = MTNet_Plus(model_name="resnet50", num_classes=args.num_class, use_group_norm=True) model = torch.nn.DataParallel(model, device_ids=args.gpu).cuda() param_groups = model.get_parameter_groups(None) optimizer = optim.SGD( [ {"params": param_groups[0], "lr": args.lr}, {"params": param_groups[1], "lr": 2 * args.lr}, {"params": param_groups[2], "lr": 10 * args.lr}, {"params": param_groups[3], "lr": 20 * args.lr}, ], # params=model.module.parameters(), # lr=args.lr, momentum=0.9, weight_decay=args.weight_decay, nesterov=True, ) if ema: for param in model.parameters(): param.detach_() return model, optimizer def update_ema_variables(model, ema_model): # Use the true average until the exponential average is more correct alpha = 0.99 # print('alpha:',alpha) for ema_param, param in zip(ema_model.parameters(), model.parameters()): ema_param.data.mul_(alpha).add_(1 - alpha, param.data) def get_files(data_root): new_file = [] img_names = os.listdir(data_root+'images') for img_name in img_names: image_root = data_root+'images/'+img_name label_root = data_root+'labels/'+img_name[:-4]+'_mask.png' new_sample = {'img':image_root, 'label':label_root} new_file.append(new_sample) return new_file def sigmoid_rampup(current, rampup_length): """Exponential rampup from https://arxiv.org/abs/1610.02242""" if rampup_length == 0: return 1.0 else: current = np.clip(current, 0.0, rampup_length) phase = 1.0 - current / rampup_length return float(np.exp(-5.0 * phase * phase)) def get_current_consistency_weight(epoch): # Consistency ramp-up from https://arxiv.org/abs/1610.02242 return args.consistency * sigmoid_rampup(epoch, args.consistency_rampup) def train(model, ema_model, train_loader, optimizer, iter_num, epoch, labeled_names, unlabeled_names): model.train() kd_loss = KDLoss(T=10) epoch_loss = 0 scaler = torch.cuda.amp.GradScaler() for batch_data in train_loader: batch_names = batch_data['img_meta_dict']['filename_or_obj'] labeled_names = labeled_names + batch_names[:args.labeled_bs] unlabeled_names = unlabeled_names + batch_names[args.labeled_bs:] inputs, labels = batch_data["img"].float().cuda(), batch_data["label"].cuda() unlabeled_inputs = inputs[args.labeled_bs:] # generate the classification model logits_labels = torch.zeros((inputs.shape[0])).long().cuda() for i in range(inputs.shape[0]): seg_label = labels[i].cpu().numpy() if np.max(seg_label) == 1: logits_labels[i] = 1 logits_labels_onehot = F.one_hot(logits_labels, num_classes=2) with torch.cuda.amp.autocast(): outputs1, outputs2, outputs3, logits, cams = model(inputs) # print(outputs.shape, logits.shape) outputs1_soft = torch.softmax(outputs1, dim=1) outputs2_soft = torch.softmax(outputs2, dim=1) outputs3_soft = torch.softmax(outputs3, dim=1) outputs_soft_avg = (outputs1_soft+outputs2_soft+outputs3_soft)/3 outputs_avg = (outputs1+outputs2+outputs3)/3 logits_soft = torch.softmax(logits, dim=1) # print(cams.shape) loss_sup_seg = (0.5*dice_loss(outputs1_soft[:args.labeled_bs], labels[:args.labeled_bs])+0.5*F.cross_entropy(outputs1[:args.labeled_bs], labels[:args.labeled_bs,0,:,:].long()) + \ 0.5*dice_loss(outputs2_soft[:args.labeled_bs], labels[:args.labeled_bs])+0.5*F.cross_entropy(outputs2[:args.labeled_bs], labels[:args.labeled_bs,0,:,:].long()) + \ 0.5*dice_loss(outputs3_soft[:args.labeled_bs], labels[:args.labeled_bs])+0.5*F.cross_entropy(outputs3[:args.labeled_bs], labels[:args.labeled_bs,0,:,:].long()))/3 loss_cls = F.binary_cross_entropy_with_logits(logits[:args.labeled_bs], logits_labels_onehot[:args.labeled_bs].float()) if epoch < 15: consistency_weight = 0 else: consistency_weight = args.consistency cross_loss1 = kd_loss(outputs1.permute(0, 2, 3, 1).reshape(-1, 2),outputs2.detach().permute(0, 2, 3, 1).reshape(-1, 2)) + \ kd_loss(outputs1.permute(0, 2, 3, 1).reshape(-1, 2),outputs3.detach().permute(0, 2, 3, 1).reshape(-1, 2)) cross_loss2 = kd_loss(outputs2.permute(0, 2, 3, 1).reshape(-1, 2),outputs1.detach().permute(0, 2, 3, 1).reshape(-1, 2)) + \ kd_loss(outputs2.permute(0, 2, 3, 1).reshape(-1, 2),outputs3.detach().permute(0, 2, 3, 1).reshape(-1, 2)) cross_loss3 = kd_loss(outputs3.permute(0, 2, 3, 1).reshape(-1, 2),outputs1.detach().permute(0, 2, 3, 1).reshape(-1, 2)) + \ kd_loss(outputs3.permute(0, 2, 3, 1).reshape(-1, 2),outputs2.detach().permute(0, 2, 3, 1).reshape(-1, 2)) consistency_loss_cross = (cross_loss1+cross_loss2+cross_loss3)/3 consistency_task = torch.mean((outputs_soft_avg-cams)**2) """entropy minimization for segmentation branch, or classification branch""" en_loss = entropy_loss(outputs_soft_avg, C=2) consistency_loss = consistency_loss_cross + consistency_task + en_loss loss_sup = loss_sup_seg + 0.1*loss_cls loss = loss_sup + consistency_weight * consistency_loss update_ema_variables(model, ema_model) optimizer.zero_grad() scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() for param_group in optimizer.param_groups: lr_ = param_group['lr'] epoch_loss += loss.item() print('train_loss:', epoch_loss/len(train_loader), 'multi-task consistency_loss:', consistency_weight * consistency_loss.item(), \ 'cross consistency loss:', consistency_loss_cross.item(), 'task loss:', consistency_task.item(), 'entropy loss:', en_loss.item()) return epoch_loss/len(train_loader), lr_, labeled_names, unlabeled_names def validate(model, val_loader, save_img=False, save_heatmap=False): acc, count = 0, 0 model.eval() dice = 0 dice_count = 0 # dice_metric = DiceMetric(num_class=args.num_class) with torch.no_grad(): for val_data in val_loader: val_images, val_labels = val_data["img"].cuda(), val_data["label"].cuda() # generate the classification model logits_labels = torch.zeros((val_labels.shape[0],)) for i in range(val_labels.shape[0]): seg_label = val_labels[i].cpu().numpy() if np.max(seg_label) == 1: logits_labels[i] = 1 val_outputs, val_outputs2, val_outputs3, val_logits, val_cams = model(val_images) # softmax # val_outputs_soft = torch.softmax(val_outputs, dim=1) # no softmax val_outputs = F.relu(val_outputs) val_outputs_soft = val_outputs / (F.adaptive_max_pool2d(val_outputs, 1) + 1e-5) val_outputs2 = F.relu(val_outputs2) val_outputs2_soft = val_outputs2 / (F.adaptive_max_pool2d(val_outputs2, 1) + 1e-5) val_outputs3 = F.relu(val_outputs3) val_outputs3_soft = val_outputs3 / (F.adaptive_max_pool2d(val_outputs3, 1) + 1e-5) logits_labels = logits_labels.numpy() val_logits = val_logits.cpu().numpy() val_logits = val_logits.argmax(1) acc += np.sum(logits_labels == val_logits) count += val_logits.shape[0] for i in range(len(logits_labels)): if logits_labels[i] == 1: # val_outputs = (torch.softmax(val_outputs, dim=1)+val_cams)/2 val_output_i = val_outputs[i].argmax(0).cpu().numpy().astype(np.uint8) val_label_i = val_labels[i].cpu().numpy().astype(np.uint8) # print(val_output_i.max(), val_label_i.max()) dice += metric.dc(val_output_i, val_label_i) # print(dice) dice_count += 1 # dice_metric.add_batch(val_outputs[i], val_labels[:, 0, :, :]) if save_img: batch_names = val_data['img_meta_dict']['filename_or_obj'] sample_name = batch_names[i] sample_name = sample_name.split('/')[-1] val_numpy = val_outputs_soft[i].permute(0, 2, 1).cpu().numpy() val_pred = val_numpy[1] val_pred = np.array(val_pred*255, dtype=np.uint8) Image.fromarray(val_pred).save('test_results_patch_hard/branch1/'+sample_name[:-4]+'.png') val_numpy = val_outputs2_soft[i].permute(0, 2, 1).cpu().numpy() val_pred = val_numpy[1] val_pred = np.array(val_pred*255, dtype=np.uint8) Image.fromarray(val_pred).save('test_results_patch_hard/branch2/'+sample_name[:-4]+'.png') val_numpy = val_outputs3_soft[i].permute(0, 2, 1).cpu().numpy() val_pred = val_numpy[1] val_pred = np.array(val_pred*255, dtype=np.uint8) Image.fromarray(val_pred).save('test_results_patch_hard/branch3/'+sample_name[:-4]+'.png') val_numpy = ((val_outputs_soft[i]+val_outputs2_soft[i]+val_outputs3_soft[i])/3).permute(0, 2, 1).cpu().numpy() val_pred = val_numpy[1] val_pred = np.array(val_pred*255, dtype=np.uint8) Image.fromarray(val_pred).save('test_results_patch/avg/'+sample_name[:-4]+'.png') if save_heatmap: batch_names = val_data['img_meta_dict']['filename_or_obj'] sample_name = batch_names[i] sample_name = sample_name.split('/')[-1] val_numpy = val_cams[i].permute(0, 2, 1).cpu().numpy() val_pred = val_numpy[1] # print(np.max(val_pred), np.min(val_pred)) val_pred = np.array(val_pred*255, dtype=np.uint8) Image.fromarray(val_pred).save('test_results_patch/branch1_cams/'+sample_name[:-4]+'.png') print(dice/(dice_count+1e-5), acc/count) return dice/(dice_count+1e-5)*100 def validate_WSI(model, val_loader, save_folder): model.eval() dice, count = 0, 0 dice_list = [] with torch.no_grad(): for val_data in val_loader: val_images, val_labels = val_data["img"].cuda(), val_data["label"].cuda() val_outputs,val_outputs2,val_outputs3,val_cams = sliding_window_inference(val_images, [args.input_size, args.input_size], 4, model, overlap=0.25) val_label = val_labels[0].cpu().numpy().astype(np.uint8) # val_outputs = (val_outputs+val_outputs2+val_outputs3)/3 # for segmentation, use threshold val_outputs_soft = torch.softmax(val_outputs, dim=1) val_pred = val_outputs[0].argmax(0).cpu().numpy().astype(np.uint8) dice_cur = metric.dc(val_pred, val_label) dice += dice_cur dice_list.append(dice_cur) count += 1 # save pics batch_names = val_data['img_meta_dict']['filename_or_obj'] sample_name = batch_names[0] sample_name = sample_name.split('/')[-1] val_numpy = val_outputs[0].permute(0, 2, 1).cpu().numpy() val_pred = val_numpy.argmax(0) val_pred = np.array(val_pred*255, dtype=np.uint8) if not os.path.exists(save_folder): os.mkdir(save_folder) Image.fromarray(val_pred).save(save_folder+sample_name[:-4]+'.png') print(dice/count) return dice/count*100 def setup_seed(seed): torch.manual_seed(seed) torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) np.random.seed(seed) random.seed(seed) os.environ['PYTHONHASHSEED'] = str(seed) if __name__ == '__main__': args = get_arguments() portion = args.portion l = logging.getLogger(__name__) fileHandler = logging.FileHandler(f'log/cdma_plus_{portion}.log', mode='a') l.setLevel(logging.INFO) l.addHandler(fileHandler) # set rand seed setup_seed(1) labeled_data_root = f'/mnt/data2/lanfz/datasets/digestpath2019/tissue-train-{portion}-patch/' all_data_root = '/mnt/data2/lanfz/datasets/digestpath2019/tissue-train-100-patch/' val_data_root = '/mnt/data2/lanfz/datasets/digestpath2019/tissue-val-patch/' test_data_root = '/mnt/data2/lanfz/datasets/digestpath2019/tissue-test-patch/' labeled_files = get_files(labeled_data_root) all_data_files = get_files(all_data_root) np.random.shuffle(labeled_files) labeled_num = len(labeled_files) all_data_num = len(all_data_files) labeled_data_img_names = [] for i in range(labeled_num): img_path = labeled_files[i]['img'] img_name = img_path.split('/') img_name = img_name[-1] labeled_data_img_names.append(img_name) labeled_idxs = [] unlabeled_idxs = [] for i in range(all_data_num): img_path = all_data_files[i]['img'] img_name = img_path.split('/') img_name = img_name[-1] if img_name in labeled_data_img_names: labeled_idxs.append(i) else: unlabeled_idxs.append(i) l.info(f'labeled:{labeled_num},unlabeled:{all_data_num-labeled_num}') print(f'labeled:{labeled_num},unlabeled:{all_data_num-labeled_num}') val_files = get_files(val_data_root) test_files = get_files(test_data_root) l.info(f'training files:{all_data_num}, valid files:{len(val_files)}') print(f'training files:{all_data_num}, valid files:{len(val_files)}') train_loader = get_train_loader(args, all_data_files, labeled_idxs, unlabeled_idxs) val_loader = get_val_loader(args, val_files) test_loader = get_val_loader(args, test_files) dice_loss = DiceLoss(n_classes=args.num_class) max_epoch = 150 iter_num = 0 print(f'max_epoch:{max_epoch}') l.info(f'max_epoch:{max_epoch}') max_dice = 0 # set gpu torch.cuda.set_device(args.gpu[0]) # get model model, optimizer = get_deeplab(args) scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[max_epoch//4, max_epoch//2, max_epoch*3//4], gamma=0.5) model_ema, _ = get_deeplab(args, ema=True) labeled_names = [] unlabeled_names = [] for epoch in range(max_epoch): t0 = time.time() train_loss, cur_lr, labeled_names, unlabeled_names = train(model, model_ema, train_loader, optimizer, iter_num, epoch, labeled_names, unlabeled_names) t1 = time.time() val_dice = validate(model, val_loader) t2 = time.time() scheduler.step() iter_num = (epoch+1)*len(train_loader) print("training/validation time: {0:.2f}s/{1:.2f}s".format(t1 - t0, t2 - t1)) if val_dice > max_dice: max_dice = val_dice best_epoch = epoch+1 print(f'cur_best dice:{max_dice}') torch.save(model.state_dict(), f'model/cdma_plus_{portion}_best.pth') # # test print('------------test-------------') save_folder = f'test_results/{portion}_multi_task_lanfz/' test_WSI_data_root = '/mnt/data2/lanfz/datasets/digestpath2019/tissue-test/' test_WSI_files = get_files(test_WSI_data_root) test_WSI_loader = get_val_WSI_loader(test_WSI_files, args) # test in WSI test_model = MTNet_Plus(model_name="resnet50", num_classes=args.num_class, use_group_norm=True, train=False).cuda() test_model.eval() ckpt = torch.load(f'model/cmda_plus_{portion}_best.pth', map_location="cpu") test_model.load_state_dict(ckpt, strict=True) validate(test_model, test_loader, save_img=True, save_heatmap=True) val_dice = validate_WSI(test_model, test_WSI_loader, save_folder) l.info('test dice {0:.4f}'.format(val_dice))