data/TFAL_visualization.py

import os,tqdm,sys,time,argparse,tqdm
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'lib'))
import numpy as np
import torch.cuda.amp as amp
scaler = amp.GradScaler()

import torch.nn as nn
import torch.nn.functional as F
from torch.nn.functional import one_hot 
import torch.utils.data
import torch.distributed as dist
from net.Ours.TFAL_Module import TFAL_get_affinity,TFAL_select_Mask_test
from utils.summary import DisablePrint
from utils.LoadModel import load_model_full_fortest
from skimage import io
from sklearn.preprocessing import MinMaxScaler

##------------------------------ Training settings ------------------------------##
parser = argparse.ArgumentParser(description='real-time segmentation')

parser.add_argument('--local_rank', type=int, default=0)
parser.add_argument('--dist', action='store_true')

parser.add_argument('--root_dir', type=str, default='./results/endo18')
parser.add_argument('--dataset', type=str, default='endovis2018')
parser.add_argument('--data_tag', type=str, default='type')
parser.add_argument('--log_name', type=str, default='Uncertainty_test')
parser.add_argument('--data_type', type=str, choices=['clean','noisy'], default='noisy')
parser.add_argument('--data_ver', type=int, default=4 )
parser.add_argument('--arch', type=str, choices=['puredeeplab18','swinPlus'], default='puredeeplab18')
parser.add_argument('--pre_log_name', type=str, default='DLV3PLUS_clean_ver_0')
parser.add_argument('--pre_checkpoint', type=str, default=None) #!!

parser.add_argument('--lr', type=float, default=1e-4)
parser.add_argument('--weight_decay', type=float, default=1e-4)
parser.add_argument('--batch_size', type=int, default=1)
parser.add_argument('--num_epochs', type=int, default=100)
parser.add_argument('--loss', type=str, default='ohem')

parser.add_argument('--gpus', type=str, default='2')
parser.add_argument('--downsample', type=int, default=1)
parser.add_argument('--h', type=int, default=256)
parser.add_argument('--w', type=int, default=320)

parser.add_argument('--log_interval', type=int, default=50)
parser.add_argument('--val_interval', type=int, default=1)
parser.add_argument('--num_workers', type=int, default=3)

parser.add_argument('--t', type=int, default=1)
parser.add_argument('--step', type=int, default=1)

parser.add_argument('--ver', type=int, default=0)
parser.add_argument('--tag', type=int, default=1)

parser.add_argument('--global_n', type=int, default=0)

parser.add_argument('--pretrain_ep', type=int, default=None)
parser.add_argument('--decay', type=int, default=2)

parser.add_argument('--reset', type=str, default=None)
parser.add_argument('--reset_ep', type=int)

cfg = parser.parse_args()

color_map = {
    0: [0,0,0], # background-tissue
    1: [0,255,0], # instrument-shaft
    2: [0,255,255], # instrument-clasper
    3: [125,255,12], # instrument-wrist
    4: [255,55,0], # kidney-parenchyma，
    5: [24,55,125], # covered-kidney，
    6: [187,155,25], # thread，
    7: [0,255,125], # clamps，
    8: [255,255,125], # suturing-needle
    9: [123,15,175], # suction-instrument，
    10: [124,155,5], # small-intestine
    11: [12,255,141] # ultrasound-probe,
}

def label2rgb(ind_im, color_map=color_map):
	rgb_im = np.zeros((ind_im.shape[0], ind_im.shape[1], 3))

	for i, rgb in color_map.items():
		rgb_im[(ind_im==i)] = rgb

	return rgb_im

def main():

    ################################################ def part ################################################

    ##------------------------------ compute feature based affinity confidence ------------------------------##   
    def affinity_confidence():
        print('\n computing affinity confidence test...')
        model.eval()
        Procedures = np.array([1,2,3,4,5,6,7,9,10,11,12,13,14,15,16])
        weight = np.array([0.4,0.4,0.4,0.4,0.4,0.4,0.5,0.6,0.7,0.8,1,1,1,1,1])
        p_sum_for_each_vedio = np.zeros((15,))
        n_sum_for_each_vedio = np.zeros((15,))
        count = np.zeros((15,))
        weight_final = np.zeros((15,))

        tic = time.perf_counter()
        for batch_idx, batch in tqdm.tqdm(enumerate(train_loader)):
            # if batch_idx < 6:
            #     continue
            for k in batch:
                if not k=='path':
                    batch[k] = batch[k].to(device=cfg.device).float()
            #print('shape:', batch['image'].shape) #4, 3, 272, 480
            with torch.no_grad():
                #print(batch['image'].shape)
                outputs , feature = model(batch['image'])
                outputs_1 , feature_1 = model(batch['image_1'])
                B, C, H, W = feature_1.shape
                label_ds = F.interpolate(batch['label'].unsqueeze(0), size=[H,W], mode='nearest').squeeze(0)
                label_1_ds = F.interpolate(batch['label_1'].unsqueeze(0), size=[H,W], mode='nearest').squeeze(0)

                _,p,n,_,_,_,_,_ = TFAL_select_Mask_test(feature, feature_1, label_ds, label_1_ds, class_num =classes , p_thershold = 0.5, n_thershold = 0.5, select = 'intersection', H = cfg.h, W = cfg.w)

                if batch['path'][0] < 9:
                    ins = batch['path'][0].numpy() - 1
                else:
                    ins = batch['path'][0].numpy() - 2

                p_sum_for_each_vedio[ins] += p.cpu().numpy()  
                n_sum_for_each_vedio[ins] += n.cpu().numpy()
                count[ins] += 1

        print('Frame number for each video:')
        print(count)

        AC_pn = (p_sum_for_each_vedio + count - n_sum_for_each_vedio) / count
        sort_p = np.argsort(p_sum_for_each_vedio)
        sort_n = np.argsort(count-n_sum_for_each_vedio)
        sort_pn = np.argsort(AC_pn)

        for i in range(len(weight_final)):
            weight_final[sort_pn[i]] = weight[i]

        print('Positive affinity for each video:')
        print(p_sum_for_each_vedio / count)
        print('Negative affinity for each video:')
        print((count-n_sum_for_each_vedio) / count)
        print('Affinity confidence for each video:')
        print(AC_pn)

        p_thershold = np.mean(p_sum_for_each_vedio / count)
        n_thershold = np.mean((count-n_sum_for_each_vedio) / count)
        print('p_thershold:',p_thershold)
        print('n_thershold:',n_thershold)

        print('Sort according to positive affinity from small to large:',Procedures[sort_p])
        print('Sort according to negative affinity from small to large:',Procedures[sort_n])
        print('Sort according to affinity confidence from small to large:',Procedures[sort_pn])
        print('weight for each video:',weight_final)

        print(' compute uncertainty finished.')
        return      
    
    ##------------------------------ generate samples figures related to temporal affinity ------------------------------##  
    def feature_based_affinity_confidence_test():
        print('\n computing sample affinity confidence test...')
        model.eval()
        Procedures = np.array([1,2,3,4,5,6,7,9,10,11,12,13,14,15,16])
        weight = np.array([0.2,0.2,0.2,0.2,0.2,0.4,0.5,0.6,0.7,0.8,1,1,1,1,1])
        p_sum_for_each_vedio = np.zeros((15,))
        n_sum_for_each_vedio = np.zeros((15,))
        count = np.zeros((15,))
        weight_final = np.zeros((15,))
        label_diff_output = []

        p_thershold = 0.48319209465377816
        n_thershold = 0.78678705171334

        for batch_idx, batch in tqdm.tqdm(enumerate(train_loader)):

            if batch_idx < 0:
                continue

            for k in batch:
                if not k=='path':
#                     batch[k] = batch[k].to(device=cfg.device, nonw_blocking=True).float()
                    batch[k] = batch[k].to(device=cfg.device).float()

            ## get the difference between noisy label and ground truth label ##
            a,b,c = batch['label'].shape
            label_clean = torch.zeros(a,b,c).to(device=cfg.device).float()
            label_diff_output = np.zeros((a,b,c))
            print(label_clean.shape)
            print('batch %d testing' % batch_idx)
            for i in range(cfg.batch_size):
                print(train_clean_dataset[i+cfg.batch_size * batch_idx]['path'])
                label_clean[i] = train_clean_dataset[i+cfg.batch_size * batch_idx]['label']
            
            # get the noise variance map
            for i in range(cfg.batch_size):
                label_diff = one_hot(label_clean[i].to(torch.int64), num_classes=12)* one_hot(batch['label'][i].to(torch.int64), num_classes=12)

                label_diff = 1 - torch.sum(label_diff,dim=2)
                label_diff_output[i] = label_diff.cpu().numpy().astype(np.uint8)
            ## get the difference between noisy label and ground truth label ##

            outputs , feature = model(batch['image'])
            outputs_1 , feature_1 = model(batch['image_1'])

            ins,frame = batch['path']
            B, C, H, W = feature_1.shape
            for i in range(B):
                print('the image is seq_%d frame%03d' %(ins[i],frame[i]))

            output = F.softmax(outputs,dim=1)
            output_output = torch.argmax(output,dim=1).cpu().numpy().astype(np.uint8)
            label_ds = F.interpolate(batch['label'].unsqueeze(0), size=[H,W], mode='nearest').squeeze(0)
            label_1_ds = F.interpolate(batch['label_1'].unsqueeze(0), size=[H,W], mode='nearest').squeeze(0)

            pos_pix_p,p,n,confidence_map,mask1comwith2_p,dist1comwith2_p,dist1comwith2_n,logit1comwith2 = TFAL_select_Mask_test(feature, feature_1, label_ds, label_1_ds, class_num = 12 ,p_thershold = p_thershold, n_thershold = n_thershold, select = 'p',H=h,W=w)
            pos_pix_n,_,_,_,_,_,_,_= TFAL_select_Mask_test(feature, feature_1, label_ds, label_1_ds, class_num = 12 ,p_thershold = p_thershold, n_thershold = n_thershold, select = 'n',H=h,W=w)
            pos_pix_i,_,_,_,_,_,_,_ = TFAL_select_Mask_test(feature, feature_1, label_ds, label_1_ds, class_num = 12 ,p_thershold = p_thershold, n_thershold = n_thershold, select = 'intersection',H=h,W=w)
            pos_pix_u,_,_,_,_,_,_,_ = TFAL_select_Mask_test(feature, feature_1, label_ds, label_1_ds, class_num = 12 ,p_thershold = p_thershold, n_thershold = n_thershold, select = 'union',H=h,W=w)

            mask1comwith2_n = 1 - mask1comwith2_p
            pos_pix_p_output = pos_pix_p.cpu().numpy().astype(np.uint8)
            pos_pix_n_output = pos_pix_n.cpu().numpy().astype(np.uint8)
            pos_pix_i_output = pos_pix_i.cpu().numpy().astype(np.uint8)
            pos_pix_u_output = pos_pix_u.cpu().numpy().astype(np.uint8) # 1, 256, 320
            pos_pix_i_n_output = 1 - pos_pix_i_output

            mask1comwith2_p_output = mask1comwith2_p.cpu().numpy().astype(np.uint8)
            mask1comwith2_n_output = mask1comwith2_n.cpu().numpy().astype(np.uint8)
            min_max_scaler = MinMaxScaler()
            confidence_map = confidence_map.cpu().numpy()
            dist1comwith2_p = dist1comwith2_p.cpu().numpy()
            dist1comwith2_n = dist1comwith2_n.cpu().numpy()
            logit1comwith2 = logit1comwith2.cpu().detach().numpy()

            for i in range(B):
                confidence_map[i] = min_max_scaler.fit_transform(confidence_map[i].reshape(-1, 1)).squeeze(1)
                dist1comwith2_p[i] = min_max_scaler.fit_transform(dist1comwith2_p[i].reshape(-1, 1)).squeeze(1)
                dist1comwith2_n[i] = min_max_scaler.fit_transform(dist1comwith2_n[i].reshape(-1, 1)).squeeze(1)
            confidence_map = confidence_map.reshape(B, h, w)
            dist1comwith2_p = dist1comwith2_p.reshape(B, h, w)
            dist1comwith2_n = dist1comwith2_n.reshape(B, h, w)

            label_gt_output = batch['label'].cpu().numpy().astype(np.uint8) # 1, 256, 320
            label_corrected = pos_pix_i_n_output * batch['label'].cpu().detach().numpy() + pos_pix_i_output * output_output
            image_output = batch['image'].permute(0,2,3,1).cpu().numpy() # 256, 320, 3

            # --------------------------------- save the images ---------------------------------- $
            cfg.pix_p_vis_path = os.path.join(cfg.test_dir,'pos_pix_p_seq_{}_frame{:03d}.png')
            cfg.pix_n_vis_path = os.path.join(cfg.test_dir,'pos_pix_n_seq_{}_frame{:03d}.png')
            cfg.pix_i_vis_path = os.path.join(cfg.test_dir,'pos_pix_i_seq_{}_frame{:03d}.png')
            cfg.pix_u_vis_path = os.path.join(cfg.test_dir,'pos_pix_u_seq_{}_frame{:03d}.png')
            cfg.labelgt_vis_path = os.path.join(cfg.test_dir,'labelnoisy_seq_{}_frame{:03d}.png')
            cfg.image_vis_path = os.path.join(cfg.test_dir,'image_seq_{}_frame{:03d}.png')
            cfg.labeldiff_vis_path = os.path.join(cfg.test_dir,'labeldiff_seq_{}_frame{:03d}.png')
            cfg.modelpred_vis_path = os.path.join(cfg.test_dir,'modelpred_seq_{}_frame{:03d}.png')
            cfg.labelcorrected_vis_path = os.path.join(cfg.test_dir,'labelcorrected_seq_{}_frame{:03d}.png')
            cfg.confidence_map_vis_path = os.path.join(cfg.test_dir,'affinity_confidence_map_seq_{}_frame{:03d}.png')
            cfg.p_map_vis_path = os.path.join(cfg.test_dir,'p_map_seq_{}_frame{:03d}.png')
            cfg.n_map_vis_path = os.path.join(cfg.test_dir,'n_map_seq_{}_frame{:03d}.png')
            cfg.p_affinity_map_vis_path = os.path.join(cfg.test_dir,'p_affinity_map_seq_{}_frame{:03d}.png')
            cfg.n_affinity_map_vis_path = os.path.join(cfg.test_dir,'n_affinity_map_seq_{}_frame{:03d}.png')
            cfg.cos_sim_map_vis_path = os.path.join(cfg.test_dir,'cos_sim__map_seq_{}_frame{:03d}.png')

            for i in range(B):
                save_pix_p_pth = cfg.pix_p_vis_path.format(ins[i],frame[i])
                save_pix_n_pth = cfg.pix_n_vis_path.format(ins[i],frame[i])
                save_pix_i_pth = cfg.pix_i_vis_path.format(ins[i],frame[i])
                save_pix_u_pth = cfg.pix_u_vis_path.format(ins[i],frame[i])
                save_labelgt_pth = cfg.labelgt_vis_path.format(ins[i],frame[i])
                save_image_pth = cfg.image_vis_path.format(ins[i],frame[i])
                save_labeldiff_pth = cfg.labeldiff_vis_path.format(ins[i],frame[i])
                save_modelpred_pth = cfg.modelpred_vis_path.format(ins[i],frame[i])
                save_labelcorrected_pth = cfg.labelcorrected_vis_path.format(ins[i],frame[i])
                save_confidence_map_path = cfg.confidence_map_vis_path.format(ins[i],frame[i])
                save_p_map_path = cfg.p_map_vis_path.format(ins[i],frame[i])
                save_n_map_path = cfg.n_map_vis_path.format(ins[i],frame[i])
                save_p_affinity_map_path = cfg.p_affinity_map_vis_path.format(ins[i],frame[i])
                save_n_affinity_map_path = cfg.n_affinity_map_vis_path.format(ins[i],frame[i])
                save_cos_sim_map_path = cfg.cos_sim_map_vis_path.format(ins[i],frame[i])

                predict = label2rgb(label_gt_output[i]).astype(np.uint8)
                predict_model = label2rgb(output_output[i]).astype(np.uint8)
                predict_corrected = label2rgb(label_corrected[i]).astype(np.uint8)

                io.imsave(save_pix_p_pth, pos_pix_p_output[i] * 255)
                io.imsave(save_pix_n_pth, pos_pix_n_output[i] * 255)
                io.imsave(save_pix_i_pth, pos_pix_i_output[i] * 255)
                io.imsave(save_pix_u_pth, pos_pix_u_output[i] * 255)
                io.imsave(save_labelgt_pth, predict)
                io.imsave(save_image_pth, image_output[i])
                io.imsave(save_labeldiff_pth, label_diff_output[i] * 255)
                io.imsave(save_modelpred_pth, predict_model)
                io.imsave(save_labelcorrected_pth, predict_corrected)
                io.imsave(save_confidence_map_path, confidence_map[i])
                io.imsave(save_p_map_path, mask1comwith2_p_output[i] * 255)
                io.imsave(save_n_map_path, mask1comwith2_n_output[i] * 255)
                io.imsave(save_p_affinity_map_path, dist1comwith2_p[i])
                io.imsave(save_n_affinity_map_path, dist1comwith2_n[i])
                io.imsave(save_cos_sim_map_path, logit1comwith2[i] * 255)
            print('feature based uncertainty test finished.')

            if batch_idx >= 0:
                print('testing break.')
                break
        return  

    ################################################ def part ################################################   
    
    ################################################ main part ################################################
    ##------------------------------ Enviroment ------------------------------##

    os.environ['CUDA_VISIBLE_DEVICES']=cfg.gpus
    torch.backends.cudnn.benchmark = True  # disable this if OOM at beginning of training
    num_gpus = torch.cuda.device_count()
    
    if cfg.dist:
        cfg.device = torch.device('cuda:%d' % cfg.local_rank)
        torch.cuda.set_device(cfg.local_rank)
        dist.init_process_group(backend='nccl', init_method='env://',
                                world_size=num_gpus, rank=cfg.local_rank)
    else:
        cfg.device = torch.device('cuda')

    cfg.log_name += '_ver_' + str(cfg.ver)

        # logger
    cfg.log_dir = os.path.join(cfg.root_dir, cfg.log_name, 'logs')
    cfg.ckpt_dir = os.path.join(cfg.root_dir, cfg.log_name, 'ckpt')
    cfg.test_dir = os.path.join(cfg.root_dir, cfg.log_name, 'sample_test')
    os.makedirs(cfg.test_dir, exist_ok=True)

    print(cfg)
    ##------------------------------ dataset ------------------------------##
    print('Setting up data...')
    
    if cfg.dataset=='endovis2018':
        h,w = [cfg.h,cfg.w]
        ori_h, ori_w = [1024, 1280]
        print('size of data %d, %d.' %(h,w))
        if cfg.data_type=='clean':
            from dataset.Endovis2018_backbone import endovis2018
            train_dataset = endovis2018('train_clean', t=cfg.t, arch='swinPlus',rate=1, global_n=cfg.global_n,h = h, w = w)
            val_dataset = endovis2018('test_part', t=cfg.t,arch='swinPlus', rate=1, global_n=cfg.global_n,h = h, w = w)
            classes = train_dataset.class_num
        elif cfg.data_type=='noisy':
            from dataset.Endovis2018_backbone import endovis2018
            train_dataset = endovis2018('train', t=cfg.t, arch='swinPlus',rate=1, global_n=cfg.global_n, data_ver=cfg.data_ver,h = h, w = w)
            train_clean_dataset = endovis2018('train_clean', t=cfg.t, arch='swinPlus',rate=1, global_n=cfg.global_n, data_ver=cfg.data_ver,h = h, w = w)
            val_dataset = endovis2018('test_part', t=cfg.t,arch='swinPlus', rate=1, global_n=cfg.global_n, data_ver=cfg.data_ver,h = h, w = w)
            classes = train_dataset.class_num
    ##------------------------------ build model ------------------------------##        
    if 'puredeeplab' in cfg.arch:
        from net.Ours.base18 import DeepLabV3Plus
        model = DeepLabV3Plus(train_dataset.class_num, 18)
    elif 'swin' in cfg.arch:
        from net.Ours.base18 import TswinPlus
        model = TswinPlus(train_dataset.class_num,h,w)

    else:
        raise NotImplementedError
    # load pretrain model
    if cfg.pre_log_name is not None:
        cfg.pre_ckpt_path = os.path.join(cfg.root_dir, cfg.pre_log_name, 'ckpt', 'epoch_1_checkpoint.t7')
        print('initialize the model from:', cfg.pre_ckpt_path)
        model = load_model_full_fortest(model, cfg.pre_ckpt_path)
    ##------------------------------ combile model ------------------------------## 
    torch.cuda.empty_cache()
    print('Starting computing...')

    gpus = cfg.gpus.split(',')
    if len(cfg.gpus)>1:
        model = nn.DataParallel(model, device_ids=list(map(int,gpus))).cuda()
    else:
        model = model.to(cfg.device)
    ##------------------------------ dataloader ------------------------------## 
    train_loader = torch.utils.data.DataLoader(train_dataset,
                                batch_size=cfg.batch_size,
                                shuffle= False,
                                num_workers=cfg.num_workers,
                                pin_memory=True,
                                drop_last=True)
    
    ##------------------------------ compute feature based affinity confidence ------------------------------##
    # enable this esction if you want to compute the affinity confidence for the dataset
    affinity_confidence()

    ##------------------------------ generate samples figures related to temporal affinity ------------------------------## 
    # enable this esction if you want to generate samples figures related to temporal affinity
    feature_based_affinity_confidence_test()

    ################################################ main part ################################################

if __name__ == '__main__':
    with DisablePrint(local_rank=cfg.local_rank):
        main()