Merge pull request #813 from will-jl944/develop_jf

Add confusion matrix computation

dygraph/paddlex/cv/models/base.py

@@ -333,10 +333,10 @@ class BaseModel:
             eval_epoch_tic = time.time()
             if (i + 1) % save_interval_epochs == 0 or i == num_epochs - 1:
                 if eval_dataset is not None and eval_dataset.num_samples > 0:
-                    self.eval_metrics = self.evaluate(
+                    self.eval_metrics, self.eval_details = self.evaluate(
                         eval_dataset,
                         batch_size=eval_batch_size,
-                        return_details=False)
+                        return_details=True)
                     # 保存最优模型
                     if local_rank == 0:
                         logging.info('[EVAL] Finished, Epoch={}, {} .'.format(

dygraph/paddlex/cv/models/detector.py

@@ -419,6 +419,9 @@ class BaseDetector(BaseModel):
             if return_details:
                 return scores, self.eval_details
             return scores
+        if return_details:
+            return None, None
+        return None
 
     def predict(self, img_file, transforms=None):
         """

dygraph/paddlex/cv/models/segmenter.py

@@ -85,11 +85,13 @@ class BaseSegmenter(BaseModel):
             origin_shape = [label.shape[-2:]]
             # TODO: 替换cv2后postprocess移出run
             pred = self._postprocess(pred, origin_shape, transforms=inputs[2])
-            intersect_area, pred_area, label_area = metrics.calculate_area(
+            intersect_area, pred_area, label_area = paddleseg.utils.metrics.calculate_area(
                 pred, label, self.num_classes)
             outputs['intersect_area'] = intersect_area
             outputs['pred_area'] = pred_area
             outputs['label_area'] = label_area
+            outputs['conf_mat'] = metrics.confusion_matrix(pred, label,
+                                                           self.num_classes)
         if mode == 'train':
             loss_list = metrics.loss_computation(
                 logits_list=net_out, labels=inputs[1], losses=self.losses)
@@ -328,6 +330,7 @@ class BaseSegmenter(BaseModel):
         intersect_area_all = 0
         pred_area_all = 0
         label_area_all = 0
+        conf_mat_all = []
         logging.info(
             "Start to evaluate(total_samples={}, total_steps={})...".format(
                 eval_dataset.num_samples,
@@ -339,16 +342,19 @@ class BaseSegmenter(BaseModel):
                 pred_area = outputs['pred_area']
                 label_area = outputs['label_area']
                 intersect_area = outputs['intersect_area']
+                conf_mat = outputs['conf_mat']
 
                 # Gather from all ranks
                 if nranks > 1:
                     intersect_area_list = []
                     pred_area_list = []
                     label_area_list = []
+                    conf_mat_list = []
                     paddle.distributed.all_gather(intersect_area_list,
                                                   intersect_area)
                     paddle.distributed.all_gather(pred_area_list, pred_area)
                     paddle.distributed.all_gather(label_area_list, label_area)
+                    paddle.distributed.all_gather(conf_mat_list, conf_mat)
 
                     # Some image has been evaluated and should be eliminated in last iter
                     if (step + 1) * nranks > len(eval_dataset):
@@ -356,23 +362,25 @@ class BaseSegmenter(BaseModel):
                         intersect_area_list = intersect_area_list[:valid]
                         pred_area_list = pred_area_list[:valid]
                         label_area_list = label_area_list[:valid]
+                        conf_mat_list = conf_mat_list[:valid]
 
-                    for i in range(len(intersect_area_list)):
-                        intersect_area_all = intersect_area_all + intersect_area_list[
-                            i]
-                        pred_area_all = pred_area_all + pred_area_list[i]
-                        label_area_all = label_area_all + label_area_list[i]
+                    intersect_area_all += sum(intersect_area_list)
+                    pred_area_all += sum(pred_area_list)
+                    label_area_all += sum(label_area_list)
+                    conf_mat_all.extend(conf_mat_list)
 
                 else:
                     intersect_area_all = intersect_area_all + intersect_area
                     pred_area_all = pred_area_all + pred_area
                     label_area_all = label_area_all + label_area
-        class_iou, miou = metrics.mean_iou(intersect_area_all, pred_area_all,
-                                           label_area_all)
+                    conf_mat_all.append(conf_mat)
+        class_iou, miou = paddleseg.utils.metrics.mean_iou(
+            intersect_area_all, pred_area_all, label_area_all)
         # TODO 确认是按oacc还是macc
-        class_acc, oacc = metrics.accuracy(intersect_area_all, pred_area_all)
-        kappa = metrics.kappa(intersect_area_all, pred_area_all,
-                              label_area_all)
+        class_acc, oacc = paddleseg.utils.metrics.accuracy(intersect_area_all,
+                                                           pred_area_all)
+        kappa = paddleseg.utils.metrics.kappa(intersect_area_all,
+                                              pred_area_all, label_area_all)
         category_f1score = metrics.f1_score(intersect_area_all, pred_area_all,
                                             label_area_all)
         eval_metrics = OrderedDict(
@@ -381,6 +389,10 @@ class BaseSegmenter(BaseModel):
                 'category_F1-score'
             ], [miou, class_iou, oacc, class_acc, kappa, category_f1score]))
 
+        if return_details:
+            conf_mat = sum(conf_mat_all)
+            eval_details = {'confusion_matrix': conf_mat.tolist()}
+            return eval_metrics, eval_details
         return eval_metrics
 
     def predict(self, img_file, transforms=None):

dygraph/paddlex/cv/models/utils/seg_metrics.py

@@ -14,7 +14,6 @@
 
 import numpy as np
 import paddle
-import paddle.nn.functional as F
 
 
 def loss_computation(logits_list, labels, losses):
@@ -27,135 +26,6 @@ def loss_computation(logits_list, labels, losses):
     return loss_list
 
 
-def calculate_area(pred, label, num_classes, ignore_index=255):
-    """
-    Calculate intersect, prediction and label area
-
-    Args:
-        pred (Tensor): The prediction by model.
-        label (Tensor): The ground truth of image.
-        num_classes (int): The unique number of target classes.
-        ignore_index (int): Specifies a target value that is ignored. Default: 255.
-
-    Returns:
-        Tensor: The intersection area of prediction and the ground on all class.
-        Tensor: The prediction area on all class.
-        Tensor: The ground truth area on all class
-    """
-    if len(pred.shape) == 4:
-        pred = paddle.squeeze(pred, axis=1)
-    if len(label.shape) == 4:
-        label = paddle.squeeze(label, axis=1)
-    if not pred.shape == label.shape:
-        raise ValueError('Shape of `pred` and `label should be equal, '
-                         'but there are {} and {}.'.format(pred.shape,
-                                                           label.shape))
-
-    # Delete ignore_index
-    mask = label != ignore_index
-    pred = pred + 1
-    label = label + 1
-    pred = pred * mask
-    label = label * mask
-    pred = F.one_hot(pred, num_classes + 1)
-    label = F.one_hot(label, num_classes + 1)
-    pred = pred[:, :, :, 1:]
-    label = label[:, :, :, 1:]
-
-    pred_area = []
-    label_area = []
-    intersect_area = []
-
-    for i in range(num_classes):
-        pred_i = pred[:, :, :, i]
-        label_i = label[:, :, :, i]
-        pred_area_i = paddle.sum(pred_i)
-        label_area_i = paddle.sum(label_i)
-        intersect_area_i = paddle.sum(pred_i * label_i)
-        pred_area.append(pred_area_i)
-        label_area.append(label_area_i)
-        intersect_area.append(intersect_area_i)
-    pred_area = paddle.concat(pred_area)
-    label_area = paddle.concat(label_area)
-    intersect_area = paddle.concat(intersect_area)
-    return intersect_area, pred_area, label_area
-
-
-def mean_iou(intersect_area, pred_area, label_area):
-    """
-    Calculate iou.
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes.
-        pred_area (Tensor): The prediction area on all classes.
-        label_area (Tensor): The ground truth area on all classes.
-
-    Returns:
-        np.ndarray: iou on all classes.
-        float: mean iou of all classes.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    label_area = label_area.numpy()
-    union = pred_area + label_area - intersect_area
-    class_iou = []
-    for i in range(len(intersect_area)):
-        if union[i] == 0:
-            iou = 0
-        else:
-            iou = intersect_area[i] / union[i]
-        class_iou.append(iou)
-    miou = np.mean(class_iou)
-    return np.array(class_iou), miou
-
-
-def accuracy(intersect_area, pred_area):
-    """
-    Calculate accuracy
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes..
-        pred_area (Tensor): The prediction area on all classes.
-
-    Returns:
-        np.ndarray: accuracy on all classes.
-        float: mean accuracy.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    class_acc = []
-    for i in range(len(intersect_area)):
-        if pred_area[i] == 0:
-            acc = 0
-        else:
-            acc = intersect_area[i] / pred_area[i]
-        class_acc.append(acc)
-    macc = np.sum(intersect_area) / np.sum(pred_area)
-    return np.array(class_acc), macc
-
-
-def kappa(intersect_area, pred_area, label_area):
-    """
-    Calculate kappa coefficient
-
-    Args:
-        intersect_area (Tensor): The intersection area of prediction and ground truth on all classes..
-        pred_area (Tensor): The prediction area on all classes.
-        label_area (Tensor): The ground truth area on all classes.
-
-    Returns:
-        float: kappa coefficient.
-    """
-    intersect_area = intersect_area.numpy()
-    pred_area = pred_area.numpy()
-    label_area = label_area.numpy()
-    total_area = np.sum(label_area)
-    po = np.sum(intersect_area) / total_area
-    pe = np.sum(pred_area * label_area) / (total_area * total_area)
-    kappa = (po - pe) / (1 - pe)
-    return kappa
-
-
 def f1_score(intersect_area, pred_area, label_area):
     intersect_area = intersect_area.numpy()
     pred_area = pred_area.numpy()
@@ -172,3 +42,21 @@ def f1_score(intersect_area, pred_area, label_area):
             f1_sco = 2 * prec * rec / (prec + rec)
         class_f1_sco.append(f1_sco)
     return np.array(class_f1_sco)
+
+
+def confusion_matrix(pred, label, num_classes, ignore_index=255):
+    label = paddle.transpose(label, (0, 2, 3, 1))
+    pred = paddle.transpose(pred, (0, 2, 3, 1))
+    mask = label != ignore_index
+
+    label = paddle.masked_select(label, mask)
+    pred = paddle.masked_select(pred, mask)
+
+    cat_matrix = num_classes * label + pred
+    conf_mat = paddle.histogram(
+        cat_matrix,
+        bins=num_classes * num_classes,
+        min=0,
+        max=num_classes * num_classes - 1).reshape([num_classes, num_classes])
+
+    return conf_mat

dygraph/requirements.txt

@@ -1,4 +1,4 @@
--r PaddleClas/requirements.txt
+-r ./PaddleClas/requirements.txt
 -r ./PaddleSeg/requirements.txt
 ./PaddleSeg
 -r ./PaddleDetection/requirements.txt

dygraph/tutorials/train/instance_segmentation/mask_rcnn_r50_fpn.py

@@ -1,7 +1,7 @@
 import paddlex as pdx
 from paddlex import transforms as T
 
-# 下载和解压昆虫检测数据集
+# 下载和解压小度熊分拣数据集
 dataset = 'https://bj.bcebos.com/paddlex/datasets/xiaoduxiong_ins_det.tar.gz'
 pdx.utils.download_and_decompress(dataset, path='./')