| |
| |
| |
| |
| |
| |
|
|
| import numpy as np |
| from sklearn.metrics import confusion_matrix |
| import torch |
| from medpy import metric |
|
|
|
|
| def get_soft_label(input_tensor, num_class, data_type='float'): |
| """ |
| convert a label tensor to one-hot label |
| input_tensor: tensor with shae [B, 1, D, H, W] or [B, 1, H, W] |
| output_tensor: shape [B, num_class, D, H, W] or [B, num_class, H, W] |
| """ |
|
|
| shape = input_tensor.shape |
| if len(shape) == 5: |
| output_tensor = torch.nn.functional.one_hot( |
| input_tensor[:, 0], num_classes=num_class).permute(0, 4, 1, 2, 3) |
| elif len(shape) == 4: |
| output_tensor = torch.nn.functional.one_hot( |
| input_tensor[:, 0], num_classes=num_class).permute(0, 3, 1, 2) |
| else: |
| raise ValueError( |
| "dimention of data can only be 4 or 5: {0:}".format(len(shape))) |
|
|
| if(data_type == 'float'): |
| output_tensor = output_tensor.float() |
| elif(data_type == 'double'): |
| output_tensor = output_tensor.double() |
| else: |
| raise ValueError( |
| "data type can only be float and double: {0:}".format(data_type)) |
|
|
| return output_tensor |
|
|
|
|
| def reshape_prediction_and_ground_truth(predict, soft_y): |
| """ |
| reshape input variables of shape [B, C, D, H, W] to [voxel_n, C] |
| """ |
| tensor_dim = len(predict.size()) |
| num_class = list(predict.size())[1] |
| if(tensor_dim == 5): |
| soft_y = soft_y.permute(0, 2, 3, 4, 1) |
| predict = predict.permute(0, 2, 3, 4, 1) |
| elif(tensor_dim == 4): |
| soft_y = soft_y.permute(0, 2, 3, 1) |
| predict = predict.permute(0, 2, 3, 1) |
| else: |
| raise ValueError("{0:}D tensor not supported".format(tensor_dim)) |
|
|
| predict = torch.reshape(predict, (-1, num_class)) |
| soft_y = torch.reshape(soft_y, (-1, num_class)) |
|
|
| return predict, soft_y |
|
|
|
|
| def get_classwise_dice(predict, soft_y, pix_w=None): |
| """ |
| get dice scores for each class in predict (after softmax) and soft_y |
| """ |
|
|
| if(pix_w is None): |
| y_vol = torch.sum(soft_y, dim=0) |
| p_vol = torch.sum(predict, dim=0) |
| intersect = torch.sum(soft_y * predict, dim=0) |
| else: |
| y_vol = torch.sum(soft_y * pix_w, dim=0) |
| p_vol = torch.sum(predict * pix_w, dim=0) |
| intersect = torch.sum(soft_y * predict * pix_w, dim=0) |
| dice_score = (2.0 * intersect + 1e-5) / (y_vol + p_vol + 1e-5) |
| return dice_score |
|
|
|
|
| def cal_dice(prediction, label, num=2): |
| total_dice = np.zeros(num-1) |
| for i in range(1, num): |
| prediction_tmp = (prediction == i) |
| label_tmp = (label == i) |
| prediction_tmp = prediction_tmp.astype(np.float) |
| label_tmp = label_tmp.astype(np.float) |
|
|
| dice = 2 * np.sum(prediction_tmp * label_tmp) / \ |
| (np.sum(prediction_tmp) + np.sum(label_tmp)) |
| total_dice[i - 1] += dice |
|
|
| return total_dice |
|
|
|
|
| def calculate_metric_percase(pred, gt): |
| dc = metric.binary.dc(pred, gt) |
| jc = metric.binary.jc(pred, gt) |
| hd = metric.binary.hd95(pred, gt) |
| asd = metric.binary.asd(pred, gt) |
|
|
| return dc, jc, hd, asd |
|
|
|
|
| def dice(input, target, ignore_index=None): |
| smooth = 1. |
| |
| iflat = input.clone().view(-1) |
| tflat = target.clone().view(-1) |
| if ignore_index is not None: |
| mask = tflat == ignore_index |
| tflat[mask] = 0 |
| iflat[mask] = 0 |
| intersection = (iflat * tflat).sum() |
|
|
| return (2. * intersection + smooth) / (iflat.sum() + tflat.sum() + smooth) |
|
|
|
|
| class DiceMetric: |
| def __init__(self, num_class): |
| self.num_classes = num_class |
| self.train_dice_list = [] |
|
|
| def add_batch(self, pred, gt): |
| n = pred.shape[0] |
| for i in range(n): |
| pred_seg = torch.argmax(pred[i], dim=0) |
| pred_seg = pred_seg.cpu().numpy() |
| outputs_argmax = np.expand_dims((np.expand_dims(pred_seg, 0)), 0) |
| outputs_argmax = torch.tensor(outputs_argmax).long() |
|
|
| soft_out = get_soft_label(outputs_argmax, self.num_classes) |
| labels_prob = gt[i].unsqueeze(0).unsqueeze(0).long() |
| labels_prob = get_soft_label(labels_prob, self.num_classes) |
| soft_out, labels_prob = reshape_prediction_and_ground_truth( |
| soft_out, labels_prob) |
| dice_list = get_classwise_dice(soft_out.cpu(), labels_prob) |
| self.train_dice_list.append(dice_list.cpu().numpy()) |
|
|
| def compute_dice(self, verbose=False): |
| train_dice_list = np.asarray(self.train_dice_list)*100 |
| train_dice_list = train_dice_list[1:] |
| train_cls_dice = train_dice_list.mean(axis=0) |
| train_avg_dice = train_dice_list.mean(axis=1) |
| train_std_dice = train_avg_dice.std() |
| train_scalers = {'avg_dice': train_avg_dice.mean( |
| ), 'class_dice': train_cls_dice, 'std_dice': train_std_dice} |
|
|
| if verbose: |
| print("%.2f" % train_cls_dice.mean()) |
| else: |
| print("%.2f" % train_cls_dice.mean()) |
| return train_cls_dice.mean() |
|
|
