# -*- coding: utf-8 -*- # Implemented Metrics for Cell detection # # This code is based on the following repository: https://github.com/TissueImageAnalytics/PanNuke-metrics # # Implemented metrics are: # # Instance Segmentation Metrics # Binary PQ # Multiclass PQ # Neoplastic PQ # Non-Neoplastic PQ # Inflammatory PQ # Dead PQ # Inflammatory PQ # Dead PQ # # Detection and Classification Metrics # Precision, Recall, F1 # # Other # dice1, dice2, aji, aji_plus # # Binary PQ (bPQ): Assumes all nuclei belong to same class and reports the average PQ across tissue types. # Multi-Class PQ (mPQ): Reports the average PQ across the classes and tissue types. # Neoplastic PQ: Reports the PQ for the neoplastic class on all tissues. # Non-Neoplastic PQ: Reports the PQ for the non-neoplastic class on all tissues. # Inflammatory PQ: Reports the PQ for the inflammatory class on all tissues. # Connective PQ: Reports the PQ for the connective class on all tissues. # Dead PQ: Reports the PQ for the dead class on all tissues. # # @ Fabian Hörst, fabian.hoerst@uk-essen.de # Institute for Artifical Intelligence in Medicine, # University Medicine Essen from typing import List import numpy as np from scipy.optimize import linear_sum_assignment def get_fast_pq(true, pred, match_iou=0.5): """ `match_iou` is the IoU threshold level to determine the pairing between GT instances `p` and prediction instances `g`. `p` and `g` is a pair if IoU > `match_iou`. However, pair of `p` and `g` must be unique (1 prediction instance to 1 GT instance mapping). If `match_iou` < 0.5, Munkres assignment (solving minimum weight matching in bipartite graphs) is caculated to find the maximal amount of unique pairing. If `match_iou` >= 0.5, all IoU(p,g) > 0.5 pairing is proven to be unique and the number of pairs is also maximal. Fast computation requires instance IDs are in contiguous orderding i.e [1, 2, 3, 4] not [2, 3, 6, 10]. Please call `remap_label` beforehand and `by_size` flag has no effect on the result. Returns: [dq, sq, pq]: measurement statistic [paired_true, paired_pred, unpaired_true, unpaired_pred]: pairing information to perform measurement """ assert match_iou >= 0.0, "Cant' be negative" true = np.copy(true) #[256,256] pred = np.copy(pred) #(256,256) #pred是预测的mask true_id_list = list(np.unique(true)) pred_id_list = list(np.unique(pred)) #pred_id_list是预测的mask的id # if there is no background, fixing by adding it if 0 not in pred_id_list: pred_id_list = [0] + pred_id_list true_masks = [ None, ] for t in true_id_list[1:]: #t最大8 t_mask = np.array(true == t, np.uint8) true_masks.append(t_mask) #true_masks是真实的mask true_masks[1].shape =[256,256] pred_masks = [ None, ] for p in pred_id_list[1:]: #p最大9 p_mask = np.array(pred == p, np.uint8) pred_masks.append(p_mask) #pred_masks是预测的mask pred_masks[1].shape =[256,256] # prefill with value重新填充值 pairwise_iou = np.zeros( [len(true_id_list) - 1, len(pred_id_list) - 1], dtype=np.float64 ) # caching pairwise iou for all instances 为所有的实例缓存iou for true_id in true_id_list[1:]: # 0-th is background 0是背景 #import pdb; pdb.set_trace() t_mask = true_masks[true_id] # 256*256为true_id的mask，也就是找到正确的mask #import pdb; pdb.set_trace() pred_true_overlap = pred[t_mask > 0] # 256*256的mask中，找到预测的mask，这两者的交集也就是预测正确的mask，也就是说这个mask是正确的， #t_mask是真实的mask,pred[t_mask > 0]是预测的mask中的pred是用来找到预测的mask的，也就是说pred的形状和t_mask的形状是一样的 #import pdb; pdb.set_trace() pred_true_overlap_id = np.unique(pred_true_overlap) pred_true_overlap_id = list(pred_true_overlap_id) for pred_id in pred_true_overlap_id: if pred_id == 0: # ignore continue # overlaping background p_mask = pred_masks[pred_id] total = (t_mask + p_mask).sum() inter = (t_mask * p_mask).sum() iou = inter / (total - inter) pairwise_iou[true_id - 1, pred_id - 1] = iou # if match_iou >= 0.5: paired_iou = pairwise_iou[pairwise_iou > match_iou] pairwise_iou[pairwise_iou <= match_iou] = 0.0 paired_true, paired_pred = np.nonzero(pairwise_iou) paired_iou = pairwise_iou[paired_true, paired_pred] paired_true += 1 # index is instance id - 1 paired_pred += 1 # hence return back to original else: # * Exhaustive maximal unique pairing #### Munkres pairing with scipy library # the algorithm return (row indices, matched column indices) # if there is multiple same cost in a row, index of first occurence # is return, thus the unique pairing is ensure # inverse pair to get high IoU as minimum paired_true, paired_pred = linear_sum_assignment(-pairwise_iou) ### extract the paired cost and remove invalid pair paired_iou = pairwise_iou[paired_true, paired_pred] # now select those above threshold level # paired with iou = 0.0 i.e no intersection => FP or FN paired_true = list(paired_true[paired_iou > match_iou] + 1) paired_pred = list(paired_pred[paired_iou > match_iou] + 1) paired_iou = paired_iou[paired_iou > match_iou] # get the actual FP and FN unpaired_true = [idx for idx in true_id_list[1:] if idx not in paired_true] unpaired_pred = [idx for idx in pred_id_list[1:] if idx not in paired_pred] # print(paired_iou.shape, paired_true.shape, len(unpaired_true), len(unpaired_pred)) # tp = len(paired_true) fp = len(unpaired_pred) fn = len(unpaired_true) # get the F1-score i.e DQ dq = tp / (tp + 0.5 * fp + 0.5 * fn + 1.0e-6) # good practice? # get the SQ, no paired has 0 iou so not impact sq = paired_iou.sum() / (tp + 1.0e-6) return [dq, sq, dq * sq], [paired_true, paired_pred, unpaired_true, unpaired_pred] ##### def remap_label(pred, by_size=False): """ Rename all instance id so that the id is contiguous i.e [0, 1, 2, 3] not [0, 2, 4, 6]. The ordering of instances (which one comes first) is preserved unless by_size=True, then the instances will be reordered so that bigger nucler has smaller ID Args: pred : the 2d array contain instances where each instances is marked by non-zero integer by_size : renaming with larger nuclei has smaller id (on-top) """ pred_id = list(np.unique(pred)) if 0 in pred_id: pred_id.remove(0) if len(pred_id) == 0: return pred # no label if by_size: pred_size = [] for inst_id in pred_id: size = (pred == inst_id).sum() pred_size.append(size) # sort the id by size in descending order pair_list = zip(pred_id, pred_size) pair_list = sorted(pair_list, key=lambda x: x[1], reverse=True) pred_id, pred_size = zip(*pair_list) new_pred = np.zeros(pred.shape, np.int32) for idx, inst_id in enumerate(pred_id): new_pred[pred == inst_id] = idx + 1 return new_pred #### def binarize(x): """ convert multichannel (multiclass) instance segmetation tensor to binary instance segmentation (bg and nuclei), :param x: B*B*C (for PanNuke 256*256*5 ) :return: Instance segmentation 这段代码的作用是将多通道的mask转换为单通道的mask """ #x = np.transpose(x, (1, 2, 0)) #[256,256,5] out = np.zeros([x.shape[0], x.shape[1]]) #首先为out赋值为0，形状为256*256 count = 1 for i in range(x.shape[2]): #遍历通道数 x_ch = x[:, :, i] #[256,256] #取出每个通道的mask 形状为256*256 unique_vals = np.unique(x_ch) #找到每个通道的mask中的唯一值,形状为(1,) unique_vals = unique_vals.tolist() #将unique_vals转换为list unique_vals.remove(0) #移除0 for j in unique_vals: #遍历unique_vals,也就是遍历每个通道的mask中的唯一值 x_tmp = x_ch == j #找到每个通道的mask中的唯一值的mask,在创建一个布尔类型的数组，其中元素为 True 的位置表示原始数组 x_ch 中对应位置的元素等于 j，元素为 False 的位置表示不等于 j x_tmp_c = 1 - x_tmp #找到每个通道的mask中的唯一值的mask的补集 out *= x_tmp_c #将out中的值乘以x_tmp_c out += count * x_tmp #将out中的值加上count*x_tmp count += 1 out = out.astype("int32") return out def get_tissue_idx(tissue_indices, idx): for i in range(len(tissue_indices)): if tissue_indices[i].count(idx) == 1: tiss_idx = i return tiss_idx def cell_detection_scores( paired_true, paired_pred, unpaired_true, unpaired_pred, w: List = [1, 1] ): tp_d = paired_pred.shape[0] fp_d = unpaired_pred.shape[0] fn_d = unpaired_true.shape[0] # tp_tn_dt = (paired_pred == paired_true).sum() # fp_fn_dt = (paired_pred != paired_true).sum() prec_d = tp_d / (tp_d + fp_d) rec_d = tp_d / (tp_d + fn_d) f1_d = 2 * tp_d / (2 * tp_d + w[0] * fp_d + w[1] * fn_d) return f1_d, prec_d, rec_d def cell_type_detection_scores( paired_true, paired_pred, unpaired_true, unpaired_pred, type_id, w: List = [2, 2, 1, 1], exhaustive: bool = True, ): type_samples = (paired_true == type_id) | (paired_pred == type_id) paired_true = paired_true[type_samples] paired_pred = paired_pred[type_samples] tp_dt = ((paired_true == type_id) & (paired_pred == type_id)).sum() tn_dt = ((paired_true != type_id) & (paired_pred != type_id)).sum() fp_dt = ((paired_true != type_id) & (paired_pred == type_id)).sum() fn_dt = ((paired_true == type_id) & (paired_pred != type_id)).sum() if not exhaustive: ignore = (paired_true == -1).sum() fp_dt -= ignore fp_d = (unpaired_pred == type_id).sum() # fn_d = (unpaired_true == type_id).sum() prec_type = (tp_dt + tn_dt) / (tp_dt + tn_dt + w[0] * fp_dt + w[2] * fp_d) rec_type = (tp_dt + tn_dt) / (tp_dt + tn_dt + w[1] * fn_dt + w[3] * fn_d) f1_type = (2 * (tp_dt + tn_dt)) / ( 2 * (tp_dt + tn_dt) + w[0] * fp_dt + w[1] * fn_dt + w[2] * fp_d + w[3] * fn_d ) return f1_type, prec_type, rec_type