data/code/train_3d_mix.py

import os
import sys
from tqdm import tqdm
from tensorboardX import SummaryWriter
import shutil
import argparse
import logging
import time
import random
import numpy as np
import torch
import torch.optim as optim
from torchvision import transforms
import torch.nn.functional as F
import torch.backends.cudnn as cudnn
from torch.utils.data import DataLoader
from utils import ramps, losses, test_patch
from dataloaders.dataset import *
from networks.net_factory import net_factory

parser = argparse.ArgumentParser()
parser.add_argument('--name', type=str,  default='CoactSeg', help='name')
parser.add_argument('--root_path', type=str, default='./', help='Name of Dataset')
parser.add_argument('--exp', type=str,  default='reg', help='exp_name')
parser.add_argument('--model', type=str,  default='vnet', help='model_name')
parser.add_argument('--max_iteration', type=int,  default=20000, help='maximum iteration to train')
parser.add_argument('--batch_size', type=int, default=4, help='batch_size of labeled data per gpu')
parser.add_argument('--base_lr', type=float,  default=0.01, help='maximum epoch number to train')
parser.add_argument('--deterministic', type=int,  default=1, help='whether use deterministic training')
parser.add_argument('--seed', type=int,  default=1337, help='random seed')
parser.add_argument('--gpu', type=str,  default='0', help='GPU to use')
parser.add_argument('--patch_size', type=int,  default=80, help='the size of patch')

args = parser.parse_args()

snapshot_path = args.root_path + "model/{}_{}/{}".format(args.name, args.exp, args.model)

num_classes = 2
patch_size = (args.patch_size, args.patch_size, args.patch_size)
args.root_path = args.root_path+'data/'
train_data_path = args.root_path

os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
max_iterations = args.max_iteration
base_lr = args.base_lr
batch_size = args.batch_size

if args.deterministic:
    cudnn.benchmark = False
    cudnn.deterministic = True
    torch.manual_seed(args.seed)
    torch.cuda.manual_seed(args.seed)
    random.seed(args.seed)
    np.random.seed(args.seed)


if __name__ == "__main__":
    ## make logger file
    if not os.path.exists(snapshot_path):
        os.makedirs(snapshot_path)
    if os.path.exists(snapshot_path + '/code'):
        shutil.rmtree(snapshot_path + '/code')
    shutil.copytree('./code/', snapshot_path + '/code', shutil.ignore_patterns(['.git','__pycache__']))

    logging.basicConfig(filename=snapshot_path+"/log.txt", level=logging.INFO,
                        format='[%(asctime)s.%(msecs)03d] %(message)s', datefmt='%H:%M:%S')
    logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
    logging.info(str(args))
    
    model = net_factory(net_type=args.model, in_chns=3, class_num=num_classes, mode="train")
    db_train = MS(base_dir=train_data_path,
                    split='train',
                    transform = transforms.Compose([
                        RandomRotFlip(),
                        RandomRot(),
                        WeightCrop(patch_size),
                        ToTensor(),
                        ]))
    labeled_idxs = list(range(32))
    unlabeled_idxs = list(range(32, 62))
    batch_sampler = TwoStreamBatchSampler(labeled_idxs, unlabeled_idxs, batch_size, batch_size)
    trainloader = DataLoader(db_train, batch_sampler=batch_sampler, pin_memory=True, num_workers=2)
    
    optimizer = optim.Adam(model.parameters(), lr=base_lr)

    writer = SummaryWriter(snapshot_path+'/log')
    logging.info("{} itertations per epoch".format(len(trainloader)))
    iter_num = 0
    best_dice = 0
    max_epoch = max_iterations // len(trainloader) + 1
    lr_ = base_lr
    iterator = tqdm(range(max_epoch), ncols=70)
    for epoch_num in iterator:
        time1 = time.time()
        for i_batch, sampled_batch in enumerate(trainloader):
            volume_batch_1, volume_batch_2, label_batch = sampled_batch['image_1'], sampled_batch['image_2'], sampled_batch['label']
            volume_batch_sub = volume_batch_2 - volume_batch_1
            volume_batch = torch.cat([volume_batch_1, volume_batch_2, volume_batch_sub], dim=1)
            volume_batch, label_batch = volume_batch.cuda(), label_batch.cuda()

            model.train()
            outputs_1, outputs_2, outputs_3 = model(volume_batch)

            y1 = F.softmax(outputs_1, dim=1)
            y2 = F.softmax(outputs_2, dim=1)
            y3 = F.softmax(outputs_3, dim=1)

            # for public dataset
            # only containing the new lesion labels
            label_new_lesions = label_batch[:batch_size,...]

            loss_seg_public = F.cross_entropy(outputs_3[:batch_size,...], label_new_lesions)
            loss_seg_dice_public = losses.Binary_dice_loss(y3[:batch_size,1,...], label_new_lesions == 1)

            selected_new_lesions_y1 = torch.masked_select(y1[:batch_size,1,...], label_new_lesions==1)
            selected_new_lesions_y2 = torch.masked_select(y2[:batch_size,1,...], label_new_lesions==1)

            selected_new_lesions_gt = torch.masked_select(label_new_lesions, label_new_lesions==1)

            loss_reg_pseudo = losses.mse_loss(selected_new_lesions_y1, 1-selected_new_lesions_gt) + losses.mse_loss(selected_new_lesions_y2, selected_new_lesions_gt)

            # for inhouse dataset
            # containing all lesions
            loss_seg_1 = F.cross_entropy(outputs_1[batch_size:,...], label_batch[batch_size:,...])
            loss_seg_2 = F.cross_entropy(outputs_2[batch_size:,...], label_batch[batch_size:,...])

            loss_seg_dice_1 = losses.Binary_dice_loss(y1[batch_size:,1,...], label_batch[batch_size:,...] == 1)
            loss_seg_dice_2 = losses.Binary_dice_loss(y2[batch_size:,1,...], label_batch[batch_size:,...] == 1)

            loss_seg_inhouse = loss_seg_1 + loss_seg_2
            loss_seg_dice_inhouse = loss_seg_dice_1 + loss_seg_dice_2

            loss_reg_inhouse = losses.mse_loss(y1[batch_size:,...], y2[batch_size:,...])
            
            iter_num = iter_num + 1
            
            loss_seg = loss_seg_inhouse + loss_seg_public
            loss_reg = loss_reg_inhouse + loss_reg_pseudo
            loss_seg_dice = loss_seg_dice_inhouse +  loss_seg_dice_public

            writer.add_scalar('loss/1_loss_seg_dice', loss_seg_dice, iter_num)
            writer.add_scalar('loss/2_loss_seg_ce', loss_seg, iter_num)
            writer.add_scalar('loss/3_loss_seg_reg', loss_reg, iter_num)
            
            if iter_num < 10000:
                loss = loss_seg_dice
            else:
                loss = loss_seg_dice + loss_reg

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            logging.info('iteration %d : loss : %03f, loss_seg_dice: %03f, loss_seg_ce: %03f, loss_reg: %03f' % (iter_num, loss, loss_seg_dice, loss_seg, loss_reg))

            if iter_num >= 0:#200 and iter_num % 200 == 0:
                sample_index = np.random.randint(0, batch_size)
                img_double = ramps.get_imgs(y1, y2, y3, volume_batch, label_batch, sample_index)
                writer.add_images('Epoch_%d_Iter_%d_Double'% (epoch_num, iter_num), img_double)
                sample_index = np.random.randint(batch_size, 2*batch_size)
                img_single = ramps.get_imgs(y1, y2, y3, volume_batch, label_batch, sample_index)
                writer.add_images('Epoch_%d_Iter_%d_Single'% (epoch_num, iter_num), img_single)

            if iter_num >= 0:#5000 and iter_num % 200 == 0:
                model.eval()
                dice_sample = test_patch.var_all_case(model, num_classes=num_classes, patch_size=patch_size, stride_xy=20, stride_z=20)
                if dice_sample > best_dice:
                    best_dice = dice_sample
                    save_mode_path = os.path.join(snapshot_path,  'iter_{}_dice_{}.pth'.format(iter_num, best_dice))
                    save_best_path = os.path.join(snapshot_path,'{}_best_model.pth'.format(args.model))
                    torch.save(model.state_dict(), save_mode_path)
                    torch.save(model.state_dict(), save_best_path)
                    logging.info("save best model to {}".format(save_mode_path))
                writer.add_scalar('Var_dice/Dice', dice_sample, iter_num)
                writer.add_scalar('Var_dice/Best_dice', best_dice, iter_num)
                model.train()

            if iter_num >= max_iterations:
                save_mode_path = os.path.join(snapshot_path, 'iter_' + str(iter_num) + '.pth')
                torch.save(model.state_dict(), save_mode_path)
                logging.info("save model to {}".format(save_mode_path))
                break
        if iter_num >= max_iterations:
            iterator.close()
            break
    writer.close()