src/test.py

import logging
import os.path
import torch
from utils.util import setup_logger
from config.config_args import *
import numpy as np
from torch.backends import cudnn
from src.config.config_setup import build_model, get_dataloader
import time, random
import torch.nn.functional as F
from src.utils.util import _bbox_mask
from src.utils import scribble, boundary_selection
import torchio as tio
import surface_distance
from surface_distance import metrics

def init_seeds(seed=0, cuda_deterministic=True):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
    if cuda_deterministic:  # slower, more reproducible
        cudnn.deterministic = True
        cudnn.benchmark = False
    else:  # faster, less reproducible
        cudnn.deterministic = False
        cudnn.benchmark = True


class Tester(object):
    def __init__(self, args, logger, ckpt):
        self.args = args
        self.logger = logger

        self.val_data = get_dataloader(args, split='test')

        a = time.time()
        print('loading models and setting up')
        self.sam = build_model(args, checkpoint=ckpt)

        self.image_encoder = self.sam.image_encoder
        self.prompt_encoder = self.sam.prompt_encoder
        self.mask_decoder = self.sam.mask_decoder

        # self._load_pretrain_model(ckpt)

    def _load_pretrain_model(self, ckpt):
        model_dict = torch.load(ckpt, map_location=self.args.device)
        state_dict = model_dict
        self.sam.load_state_dict(state_dict['model_state_dict'])

    def validate(self, epoch_num):
        self.image_encoder.eval()
        self.prompt_encoder.eval()
        self.mask_decoder.eval()

        if self.args.data == 'lits':
            loss = self.validater_sliding_window(epoch_num)
        else:
            loss = self.validater(epoch_num)
        return loss


    def validater_sliding_window(self, epoch_num):
        with torch.no_grad():
            dice_summary, nsd_summary = [], []
            for idx, (subject_dict, image_path, subject_dict_save) in enumerate(self.val_data):
                if subject_dict['label']['data'][0].sum() <= 0:
                    self.logger.info(image_path, 'label volume too small, and it has been skipped for validation')
                    continue
                mean_dice = 0
                subject = tio.Subject(image=tio.ScalarImage(tensor=subject_dict['image']['data'][0].float(), affine=subject_dict['image']['affine'][0]),
                                      label=tio.LabelMap(tensor=subject_dict['label']['data'][0].float(), affine=subject_dict['label']['affine'][0]))
                grid_sampler = tio.inference.GridSampler(subject, 128, 16)
                patch_loader = torch.utils.data.DataLoader(grid_sampler, batch_size=1)
                aggregator = tio.inference.GridAggregator(grid_sampler, overlap_mode='average')


                for idx_patch, patches_batch in enumerate(patch_loader):
                    image, label = patches_batch['image'][tio.DATA].to(self.args.device), patches_batch['label'][tio.DATA].to(self.args.device)
                    print(torch.count_nonzero(label))
                    print('how many voxels')
                    locations = patches_batch[tio.LOCATION]

                    if torch.count_nonzero(label) == 0:
                        print('found empty patch')
                        masks = torch.zeros([1, 1, 128, 128, 128])
                    else:
                        # _, masks = self._interaction(self.sam, image, label, iter_nums=self.args.iter_nums, train=False, return_each_iter=True)
                        _, masks = self._interaction(self.sam, image, label, iter_nums=self.args.iter_nums, train=False)

                    aggregator.add_batch(masks, locations)
                masks_iter_final = aggregator.get_output_tensor()
                mean_dice_sub = self.get_dice_score(torch.sigmoid(masks_iter_final), subject.label.data)

                mean_dice += mean_dice_sub
                dice_summary.append(mean_dice)

                ssd = surface_distance.compute_surface_distances(
                    (subject.label.data == 1)[0].cpu().numpy(),
                    (torch.sigmoid(masks_iter_final) > 0.5)[0].cpu().numpy(),
                    spacing_mm=(1,1,1)
                )
                nsd = metrics.compute_surface_dice_at_tolerance(ssd, 5)

                nsd_summary.append(nsd)
                print(mean_dice_sub)

                if self.args.save_predictions:
                    save_test_dir = os.path.join(self.args.save_test_dir, 'prism_prediction', self.args.data, self.args.save_name, str(self.args.iter_nums))
                    if not os.path.exists(save_test_dir):
                        os.makedirs(save_test_dir)
                    a = torch.sigmoid(masks_iter_final) > 0.5
                    a = a[0].float().cpu().numpy()
                    import SimpleITK as sitk
                    prediction = sitk.GetImageFromArray(a)
                    if self.args.data == 'lits':
                        base_name = image_path[0].split('/')[-2] + '_' +image_path[0].split('/')[-1]
                    if self.args.refine_test:
                        pred_name = base_name.replace('.nii.gz', '._pred.nii.gz')
                    else:
                        pred_name = base_name.replace('.nii.gz', '._pred_no_refine.nii.gz')
                    save_path = os.path.join(save_test_dir, pred_name)
                    sitk.WriteImage(prediction, save_path)

                    if self.args.iter_nums == 1:
                        if self.args.refine_test:
                            image_name = base_name.replace('.nii.gz', '._image.nii.gz')
                        else:
                            image_name = base_name.replace('.nii.gz', '._image_no_refine.nii.gz')
                        b = subject_dict_save['image']['data'][0][0].float().cpu().numpy()
                        image_save = sitk.GetImageFromArray(b)
                        sitk.WriteImage(image_save, os.path.join(save_test_dir, image_name))

                        if self.args.refine_test:
                            label_name = base_name.replace('.nii.gz', '._label.nii.gz')
                        else:
                            label_name = base_name.replace('.nii.gz', '._label_no_refine.nii.gz')
                        c = subject_dict_save['label']['data'][0][0].float().cpu().numpy()
                        label_save = sitk.GetImageFromArray(c)
                        sitk.WriteImage(label_save, os.path.join(save_test_dir, label_name))



                self.logger.info(
                    'epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.val_data)) +
                    ' subject: ' + str(image_path) + ' mean nsd over clicks:' + str(nsd) + ' mean dice over clicks:' + str(mean_dice) +
                    ' stich left and right side (total size): ' + str(label.size(1)))
            self.logger.info("- Val metrics mean dice: " + str(np.mean(dice_summary)) + "- Val metrics nsd: " + str(np.mean(nsd_summary)))

            from scipy import stats
            data = dice_summary
            # Calculate mean
            mean = np.mean(data)
            # Calculate standard error of the mean (SEM)
            sem = stats.sem(data)
            # Determine the t-value for the 95% confidence interval
            # Degrees of freedom
            df = len(data) - 1
            # t-value for 95% CI
            t_value = stats.t.ppf(0.975, df)
            # Calculate the margin of error
            margin_of_error = sem * t_value
            # Calculate the 95% CI
            ci_lower = mean - margin_of_error
            ci_upper = mean + margin_of_error
            self.logger.info("- ci_lower dice: " + str(ci_lower) + "- ci_lower dice: " + str(ci_upper))

        return dice_summary

    def validater(self, epoch_num):
        device = self.args.device
        with torch.no_grad():
            loss_summary, nsd_summary = [], []
            # for idx, data in enumerate(val_data):
            # img, label = data['image'].to(device), data['label'].to(device)
            for idx, (image, label, image_path, subject_dict_save) in enumerate(self.val_data):

                image, label = image.to(device), label.to(device)

                if self.args.data == 'kits' and image.size(1) > 1:
                    label_final, masks_final = torch.zeros([1, 1, int(image.size(2) * 2), image.size(3), image.size(4)]), torch.zeros([self.args.iter_nums, 1, int(image.size(2) * 2), image.size(3), image.size(4)])

                    for channel_num in range(image.size(1)):
                        masks = self.interaction(self.sam, image[:, channel_num, :].unsqueeze(1), label[:, channel_num, :].unsqueeze(1))
                        start_point, end_pont = 0 + channel_num * image.size(2), image.size(2) + channel_num * image.size(2)

                        masks_final[:, 0, start_point: end_pont, :] = masks[:, 0, :]
                        label_final[0, 0, start_point: end_pont, :] = label[0, channel_num, :]

                    masks, label = masks_final, label_final
                else:
                    masks = self.interaction(self.sam, image, label)

                # masks = self.interaction(self.sam, image, label)

                dice = self.get_dice_score(torch.sigmoid(masks), label)
                loss_summary.append(dice)

                ssd = surface_distance.compute_surface_distances(
                    (label == 1)[0][0].cpu().numpy(),
                    (torch.sigmoid(masks) > 0.5)[0][0].cpu().numpy(),
                    spacing_mm=(1, 1, 1)
                )
                nsd = metrics.compute_surface_dice_at_tolerance(ssd, 5)

                nsd_summary.append(nsd)

                if self.args.save_predictions:
                    save_test_dir = os.path.join(self.args.save_test_dir, 'prism_prediction', self.args.data,
                                                 self.args.save_name, str(self.args.iter_nums))
                    if not os.path.exists(save_test_dir):
                        os.makedirs(save_test_dir)
                    a = torch.sigmoid(masks) > 0.5
                    a = a.float().cpu().numpy()
                    import SimpleITK as sitk
                    prediction = sitk.GetImageFromArray(a)
                    if self.args.data == 'colon':
                        base_name = image_path[0].split('/')[-1]
                    else:
                        base_name = image_path[0].split('/')[-2] + '_' + image_path[0].split('/')[-1]
                    if self.args.refine_test:
                        pred_name = base_name.replace('.nii.gz', '._pred.nii.gz')
                    else:
                        pred_name = base_name.replace('.nii.gz', '._pred_no_refine.nii.gz')
                    save_path = os.path.join(save_test_dir, pred_name)
                    sitk.WriteImage(prediction, save_path)

                    if self.args.iter_nums == 1:
                        if self.args.refine_test:
                            image_name = base_name.replace('.nii.gz', '._image.nii.gz')
                        else:
                            image_name = base_name.replace('.nii.gz', '._image_no_refine.nii.gz')
                        b = subject_dict_save['image']['data'][0][0].float().cpu().numpy()
                        image_save = sitk.GetImageFromArray(b)
                        sitk.WriteImage(image_save, os.path.join(save_test_dir, image_name))

                        if self.args.refine_test:
                            label_name = base_name.replace('.nii.gz', '._label.nii.gz')
                        else:
                            label_name = base_name.replace('.nii.gz', '._label_no_refine.nii.gz')
                        c = subject_dict_save['label']['data'][0][0].float().cpu().numpy()
                        label_save = sitk.GetImageFromArray(c)
                        sitk.WriteImage(label_save, os.path.join(save_test_dir, label_name))

                self.logger.info(
                    'epoch: {}/{}, iter: {}/{}'.format(epoch_num, self.args.max_epoch, idx, len(self.val_data)) +
                    ' subject: ' + str(image_path) + ' mean nsd over clicks:' + str(nsd) + ' mean dice over clicks:' + str(dice) +
                    ' stich left and right side (total size): ' + str(label.size(1)))

            self.logger.info("- Val metrics mean dice: " + str(np.mean(loss_summary)) + "- Val metrics nsd: " + str(np.mean(nsd_summary)))
            from scipy import stats
            data = loss_summary
            # Calculate mean
            mean = np.mean(data)
            # Calculate standard error of the mean (SEM)
            sem = stats.sem(data)
            # Determine the t-value for the 95% confidence interval
            # Degrees of freedom
            df = len(data) - 1
            # t-value for 95% CI
            t_value = stats.t.ppf(0.975, df)
            # Calculate the margin of error
            margin_of_error = sem * t_value
            # Calculate the 95% CI
            ci_lower = mean - margin_of_error
            ci_upper = mean + margin_of_error
            self.logger.info("- ci_lower dice: " + str(ci_lower) + "- ci_lower dice: " + str(ci_upper))

        return loss_summary

    def get_next_click3D_torch_2(self, prev_seg, gt_semantic_seg):

        mask_threshold = 0.5

        batch_points = []
        batch_labels = []
        # dice_list = []

        pred_masks = (prev_seg > mask_threshold)
        true_masks = (gt_semantic_seg > 0)
        fn_masks = torch.logical_and(true_masks, torch.logical_not(pred_masks))
        fp_masks = torch.logical_and(torch.logical_not(true_masks), pred_masks)
        print('fn: {}, fp: {}'.format(torch.count_nonzero(fn_masks) / torch.count_nonzero(true_masks),
                                      torch.count_nonzero(fp_masks) / torch.count_nonzero(true_masks)))
        to_point_mask = torch.logical_or(fn_masks, fp_masks)
        #to_point_mask = fn_masks
        for i in range(gt_semantic_seg.shape[0]):
            bp_list, bl_list = [], []
            points = torch.argwhere(to_point_mask[i])
            if self.args.num_clicks > len(points):
                click_size = len(points)
            else:
                click_size = self.args.num_clicks

            dynamic_size = random.randint(1, click_size) if self.args.dynamic else click_size

            point_index = np.random.choice(len(points), size=dynamic_size, replace=False)
            points_select = points[point_index]  # each row tensor([0, x, y, z]), size --> num_clicks x 4
            # point = points[np.random.randint(len(points))] # tensor([0, x, y, z])
            for click_index in range(dynamic_size):
                point = points_select[click_index]
                if fn_masks[i, 0, point[1], point[2], point[3]]:
                    is_positive = True
                else:
                    is_positive = False

                bp = point[1:].clone().detach().reshape(1, 1, 3)
                bl = torch.tensor([int(is_positive), ]).reshape(1, 1)
                bp_list.append(bp)
                bl_list.append(bl)

            if self.args.use_scribble:
                #sample_method = random.choice(['line', 'center', 'default'])
                sample_method = 'center'
                scribble_types = {
                    'line': 'LineScribble',
                    'center': 'CenterlineScribble',
                    'default': 'ContourScribble'
                }

                def create_scribble_mask(scribble_type, data):
                    scribble_object = getattr(scribble, scribble_type)()
                    scribble_mask = scribble_object.batch_scribble(data).permute(1, 2, 3, 0)
                    return scribble_mask > 0

                # fg = gt_semantic_seg[i].permute(3, 0, 1, 2).float()
                # bg = (torch.ones_like(pred_masks[i, :]).float() - gt_semantic_seg[i].float()).permute(3, 0, 1, 2)
                fg, bg = fn_masks[0].permute(3, 0, 1, 2).float(), fp_masks[0].permute(3, 0, 1, 2).float()

                scribble_type = scribble_types.get(sample_method, scribble_types['default'])

                scribble_mask_fg = create_scribble_mask(scribble_type, fg)
                #fg_coors = torch.argwhere(scribble_mask_fg)[:, 1:].unsqueeze(0)[:, 0: 100, :]  # for computation only
                fg_coors = torch.argwhere(scribble_mask_fg)[:, 1:].unsqueeze(0)
                if self.args.efficient_scribble:
                    fg_coors = fg_coors[:, 0: 10000, :]  # for computation only# for computation only
                fg_coors_label = torch.ones(1, fg_coors.size(1))
                bp_list.append(fg_coors)
                bl_list.append(fg_coors_label)
                # x,y,z = bp_list[-1][0, 99, 0], bp_list[-1][0, 99, 1], bp_list[-1][0, 99, 2]
                # print(gt_semantic_seg[i, 0, x,y,z])

                #if sample_method == 'default':
                if torch.count_nonzero(fp_masks) > 0:
                    scribble_mask_bg = create_scribble_mask(scribble_type, bg)
                    bg_coors = torch.argwhere(scribble_mask_bg)[:, 1:].unsqueeze(0)
                    if self.args.efficient_scribble:
                        bg_coors = bg_coors[:, 0: 10000, :]
                    bg_coors_label = torch.zeros(1, bg_coors.size(1))
                    bp_list.append(bg_coors)
                    bl_list.append(bg_coors_label)

            batch_points.append(torch.cat(bp_list, dim=1))
            batch_labels.append(torch.cat(bl_list, dim=1))

            smallest_n = min(tensor.size(1) for tensor in batch_labels)
            batch_points = [tensor[:, :smallest_n] if tensor.size(1) > smallest_n else tensor for tensor in
                            batch_points]
            batch_labels = [tensor[:, :smallest_n] if tensor.size(1) > smallest_n else tensor for tensor in
                            batch_labels]

            # Check the shapes of the adjusted tensors
            for i, tensor in enumerate(batch_points):
                print(f"Tensor {i + 1} shape: {tensor.shape}")


        return batch_points, batch_labels

    def get_points(self, prev_masks, label):
        batch_points, batch_labels = self.get_next_click3D_torch_2(prev_masks, label)

        points_co = torch.cat(batch_points, dim=0).to(self.args.device)
        points_la = torch.cat(batch_labels, dim=0).to(self.args.device)

        self.click_points.append(points_co)
        self.click_labels.append(points_la)

        points_input = points_co
        labels_input = points_la

        bbox_coords = _bbox_mask(label[:, 0, :]).to(self.args.device) if self.args.use_box else None
        return points_input, labels_input, bbox_coords


    def batch_forward(self, sam_model, features, image_embedding, image, prev_masks, points=None, boxes=None):
        prev_masks = F.interpolate(prev_masks, scale_factor=0.25)
        features = [features[i].to(self.args.device) for i in range(0, len(features))]

        # sparse_embeddings --> (B, 2, embed_dim) 2 represents concat of coordination and its label
        # dense_embeddings --> (B, embed_dim, W, H, D), whd values are customized
        new_point_embedding, new_image_embedding = sam_model.prompt_encoder(
            points=points,
            boxes=boxes,
            masks=prev_masks,
            image_embeddings=image_embedding.to(self.args.device)
        )

        mask, pred_dice = sam_model.mask_decoder(
            prompt_embeddings=new_point_embedding,  # (B, 2, 256)
            image_embeddings=new_image_embedding,  # (B, 256, 64, 64)
            feature_list=features,
        )

        return mask, pred_dice

    def interaction(self, sam_model, image, label):
        image_embedding, feature_list = self.sam.image_encoder(image)

        self.click_points = []
        self.click_labels = []
        prev_masks = torch.zeros_like(label).to(label.device)
        for iter_num in range(self.args.iter_nums):
            prev_masks_sigmoid = torch.sigmoid(prev_masks) if iter_num > 0 else prev_masks

            points_input, labels_input, bbox_input = self.get_points(prev_masks_sigmoid, label)
            mask, pred_dice = self.batch_forward(sam_model, feature_list, image_embedding, image, prev_masks, points=[points_input, labels_input], boxes=bbox_input)

            if self.args.multiple_outputs:
                pred_best_dice, pred_dice_max_index = torch.max(pred_dice, dim=1)
                mask_best = mask[:, pred_dice_max_index, :]
            else:
                mask_best, pred_best_dice = mask, pred_dice
            # FIXME refine or not
            if self.args.refine and self.args.refine_test:
                mask_refine, error_map = self.sam.mask_decoder.refine(image, mask_best, [self.click_points, self.click_labels], mask_best.detach())
                print('dice before refine {} and after {}'.format(
                    self.get_dice_score(torch.sigmoid(mask_best), label),
                    self.get_dice_score(torch.sigmoid(mask_refine), label))
                )
                mask_best = mask_refine

            prev_masks = mask_best
            dice = self.get_dice_score(torch.sigmoid(prev_masks).cpu().numpy(), label.cpu().numpy())
            print('---')
            print(f'Dice: {dice:.4f}, pred_dice: {pred_best_dice}, label: {labels_input}')

        return prev_masks



    def _interaction(self, sam_model, image, label, iter_nums, train=False, return_each_iter=False):
        if return_each_iter:
            return_mask_total_iter = torch.zeros([iter_nums, 1, image.size(2), image.size(3), image.size(4)])

        image_embedding, feature_list = self.sam.image_encoder(image)
        self.click_points = []
        self.click_labels = []
        return_loss = 0
        prev_masks = torch.zeros_like(label, dtype=torch.float).to(label.device)
        for iter_num in range(iter_nums):
            prev_masks_sigmoid = torch.sigmoid(prev_masks) if iter_num > 0 else prev_masks

            if self.args.init_learning and iter_num == 0:
                boundary, margin, content = boundary_selection.find_boundary_map(label)
                use_content = True
                for batch_index in range(label.size(0)):
                    if torch.count_nonzero(content[batch_index]) < self.args.num_clicks:
                        use_content = False
                if use_content:
                    label_sample = content
                else:
                    label_sample = label
            else:
                label_sample = label

            points_input, labels_input, box_input = self.get_points(prev_masks_sigmoid, label_sample, label)
            mask, dice_pred = self.batch_forward(sam_model, feature_list, image_embedding, image, prev_masks, points=[points_input, labels_input], boxes=box_input)

            # ========================================================
            if self.args.multiple_outputs:
                dice_pred_best, max_label_index = torch.max(dice_pred, dim=1)
                mask_list = [mask[i, max_label_index[i], :].unsqueeze(0) for i in range(mask.size(0))]
                mask_best = torch.stack(mask_list, dim=0)
            else:
                mask_best = mask

            # ========================================================

            if self.args.refine and self.args.refine_test:
                mask_refine, error_map = self.sam.mask_decoder.refine(image, mask_best, [self.click_points, self.click_labels], mask_best.detach())
                self.logger.info('dice before refine {} and after {}, label 0: {}, label 1: {}'.format(
                    self.get_dice_score(torch.sigmoid(mask_best), label), self.get_dice_score(torch.sigmoid(mask_refine), label),
                    str(labels_input.numel() - torch.count_nonzero(labels_input)), str(torch.count_nonzero(labels_input)) ) )
                mask_best = mask_refine  # FIXME refine or not

            loss = self.get_dice_score(torch.sigmoid(mask_best), label) # dice

            return_loss += loss
            prev_masks = mask_best

            if return_each_iter:
                return_mask_total_iter[iter_num, :] = mask_best
        if return_each_iter:
            print(return_mask_total_iter.shape)
            return return_loss / iter_nums, return_mask_total_iter
        else:
            return return_loss / iter_nums, prev_masks

    def get_dice_score(self, prev_masks, label):
        def compute_dice(mask_pred, mask_gt):
            mask_threshold = 0.5

            mask_pred = (mask_pred > mask_threshold)
            mask_gt = (mask_gt > 0)

            volume_sum = mask_gt.sum() + mask_pred.sum()
            if volume_sum == 0:
                return np.NaN
            volume_intersect = (mask_gt & mask_pred).sum()
            return 2 * volume_intersect / volume_sum

        pred_masks = (prev_masks > 0.5)
        true_masks = (label > 0)
        dice_list = []
        for i in range(true_masks.shape[0]):
            dice_list.append(compute_dice(pred_masks[i], true_masks[i]))
        return (sum(dice_list) / len(dice_list)).item()




def main():
    init_seeds()
    args = parser.parse_args()
    check_and_setup_parser(args)

    log_name = 'test_' + args.save_name
    setup_logger(logger_name=log_name, root=args.save_dir, screen=True, tofile=True)
    logger = logging.getLogger(log_name)
    logger.info(str(args))

    #ckpt = '/home/hao/Hao/3D_medical_foundation_model/src/implementation/log/colon/3DSAM/best.pth.tar'
    ckpt = os.path.join(args.save_dir, args.checkpoint + '.pth.tar')
    with torch.no_grad():
        tester = Tester(args, logger, ckpt)
        loss = tester.validate(epoch_num=0)

        print(loss)

    logger.info("- Test done")

if __name__ == "__main__":
    main()