data/train_CDMA.py

import argparse
import os
import random
import time
import sys
from PIL import Image
Image.MAX_IMAGE_PIXELS = None
join = os.path.join
import numpy as np
import torch
from torch import nn
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
from core.networks import MTNet
from tensorboardX import SummaryWriter


def get_arguments():
    parser = argparse.ArgumentParser(description="CDMA Pytorch implementation on Digest Path 2019 ")
    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=1e-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=150, type=int)
    parser.add_argument('--consistency', type=float, default=0.1, help='consistency')
    parser.add_argument("--portion", default=5, type=int)
    return parser.parse_args()

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 get_deeplab(args, ema=False):
    model = MTNet("resnet50", num_classes=args.num_class, use_group_norm=True)
    model = torch.nn.DataParallel(model, device_ids=args.gpu).cuda()
    param_groups = model.module.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},
        ],
        momentum=0.9,
        weight_decay=args.weight_decay,
        nesterov=True,
    )
    if ema:
        for param in model.module.parameters():
                param.detach_()
    return model, optimizer

def train(model, train_loader, optimizer, iter_num, epoch):
    model.train()
    kd_loss = KDLoss(T=10)
    epoch_loss_sup = 0
    epoch_loss_en = 0
    epoch_loss_cross = 0
    epoch_loss_unsup = 0
    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()

        outputs1, outputs2, outputs3 = model(inputs)

        outputs1_soft = torch.softmax(outputs1, dim=1)
        outputs2_soft = torch.softmax(outputs2, dim=1)
        outputs3_soft = torch.softmax(outputs3, dim=1)

        loss_sup = 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())

        loss_sup = loss_sup/3

        # entropy loss
        outputs_avg_soft = (outputs1_soft+outputs2_soft+outputs3_soft)/3
        en_loss = entropy_loss(outputs_avg_soft, C=2)

        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))

        cross_consist = (cross_loss1 + cross_loss2 + cross_loss3)/3

        # overall function
        cross_weight = args.consistency
        en_weight = args.consistency
        en_loss = en_weight * en_loss
        cross_loss = cross_weight*cross_consist
        if epoch < 15:
            consistency_loss = torch.tensor((0,)).cuda()
        else:
            consistency_loss = cross_loss + en_loss
        loss = loss_sup + consistency_loss

        iter_num += 1
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        for param_group in optimizer.param_groups:
            lr_ = param_group['lr']

        epoch_loss_unsup += consistency_loss.item()
        epoch_loss_sup += loss_sup.item()
        epoch_loss_en += en_loss.item()
        epoch_loss_cross += cross_loss.item()
    print('sup loss:', epoch_loss_sup/len(train_loader), "unsup loss", epoch_loss_unsup/len(train_loader),'en_loss:', epoch_loss_en/(len(train_loader)),\
        'cdma cross_loss:', epoch_loss_cross/(len(train_loader)))
    return epoch_loss_sup/len(train_loader), lr_

def validate(model, val_loader):
    model.eval()
    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()
            val_outputs1, _, _ = model(val_images)
            val_outputs = val_outputs1
            dice_metric.add_batch(val_outputs,val_labels[:,0,:,:])
    dice_value = dice_metric.compute_dice()
    print(dice_value)
    return dice_value

def validate_WSI(model, val_loader, overlap=0.25, save_folder=None, save_csv=None):
    model.eval()
    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()
            val_outputs = sliding_window_inference(val_images, [args.input_size, args.input_size], 4, model, overlap=overlap)
            preds = val_outputs
            dice_metric.add_batch(preds, val_labels[:, 0, :, :])
            # 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 = preds[0].permute(0, 2, 1).cpu().numpy()
            val_pred = val_numpy.argmax(0)
            val_pred = np.array(val_pred*255, dtype=np.uint8)

            if save_folder:
                if not os.path.exists(save_folder):
                    os.mkdir(save_folder)
                Image.fromarray(val_pred).save(save_folder+sample_name[:-4]+'.png')
    dice_value = dice_metric.compute_dice(save=save_csv)
    print(dice_value)
    return dice_value

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
    writer = SummaryWriter(f'tensorborad/cdma/deeplab/{portion}_portion')
    logging.basicConfig(level=logging.INFO, filename=f'log/cdma_{portion}.txt')

    # 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)
    
    logging.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)

    logging.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)

    dice_loss = DiceLoss(n_classes=args.num_class)

    max_epoch = args.max_epoch
    iter_num = 0
    print(f'max_epoch:{max_epoch}')
    logging.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])

    labeled_names = []
    unlabeled_names = []
    for epoch in range(max_epoch):
        t0 = time.time()
        train_loss, cur_lr = train(model, train_loader, optimizer, iter_num, epoch)

        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.mean() > max_dice:
            max_dice = val_dice.mean()
            best_epoch = epoch+1
            print(f'cur_best dice:{max_dice}')
            torch.save(model.module.state_dict(), f'model/cdma_{portion}_best.pth')
    # # test
    print('------------test-------------')
    save_folder = f'test_results/{portion}_cdma/'
    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_model = MTNet("resnet50", num_classes=args.num_class, use_group_norm=True, train=False).cuda()
    test_model.eval()
    ckpt = torch.load(f'model/cmda_{portion}_best.pth', map_location="cpu")
    test_model.load_state_dict(ckpt, strict=True)
    test_dice_WSI = validate_WSI(test_model, test_WSI_loader, overlap=0.25, save_folder=save_folder, save_csv=f'results_csv/cdma_{portion}.csv')
    logging.info('test dice {0:.4f}'.format(test_dice_WSI))