kubeedge
/
sedna
Not watched
1
0
Fork 0
Code
Releases 12 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: c5cf783d96
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5cf783d96'
${ noResults }
sedna/examples/lifelong_learning/cityscapes/RFNet/utils/metrics.py

209 lines
10 kB
Raw Blame History 

  1. import numpy as np

  2. import cv2

  3. 

  4. class Evaluator(object):

  5.     def __init__(self, num_class):

  6.         self.num_class = num_class

  7.         self.confusion_matrix = np.zeros((self.num_class,)*2)  # shape:(num_class, num_class)

  8.         self.curr_confusion_matrix = np.zeros((self.num_class,)*2)

  9.         self.future_confusion_matrix = np.zeros((self.num_class,)*2)

  10. 

  11.     def Pixel_Accuracy(self):

  12.         Acc = np.diag(self.confusion_matrix).sum() / self.confusion_matrix.sum()

  13.         return Acc

  14.     

  15.     def Pixel_Accuracy_Class_Curb(self):

  16.         Acc = np.diag(self.confusion_matrix) / self.confusion_matrix.sum(axis=1)

  17.         print('-----------Acc of each classes-----------')

  18.         print("road         : %.6f" % (Acc[0] * 100.0), "%\t")

  19.         print("sidewalk     : %.6f" % (Acc[1] * 100.0), "%\t")

  20.         Acc = np.nanmean(Acc[:2])

  21.         return Acc

  22.         

  23. 

  24.     def Pixel_Accuracy_Class(self):

  25.         Acc = np.diag(self.confusion_matrix) / self.confusion_matrix.sum(axis=1)

  26.         print('-----------Acc of each classes-----------')

  27.         print("road         : %.6f" % (Acc[0] * 100.0), "%\t")

  28.         print("sidewalk     : %.6f" % (Acc[1] * 100.0), "%\t")

  29.         print("building     : %.6f" % (Acc[2] * 100.0), "%\t")

  30.         print("wall         : %.6f" % (Acc[3] * 100.0), "%\t")

  31.         print("fence        : %.6f" % (Acc[4] * 100.0), "%\t")

  32.         print("pole         : %.6f" % (Acc[5] * 100.0), "%\t")

  33.         print("traffic light: %.6f" % (Acc[6] * 100.0), "%\t")

  34.         print("traffic sign : %.6f" % (Acc[7] * 100.0), "%\t")

  35.         print("vegetation   : %.6f" % (Acc[8] * 100.0), "%\t")

  36.         print("terrain      : %.6f" % (Acc[9] * 100.0), "%\t")

  37.         print("sky          : %.6f" % (Acc[10] * 100.0), "%\t")

  38.         print("person       : %.6f" % (Acc[11] * 100.0), "%\t")

  39.         print("rider        : %.6f" % (Acc[12] * 100.0), "%\t")

  40.         print("car          : %.6f" % (Acc[13] * 100.0), "%\t")

  41.         print("truck        : %.6f" % (Acc[14] * 100.0), "%\t")

  42.         print("bus          : %.6f" % (Acc[15] * 100.0), "%\t")

  43.         print("train        : %.6f" % (Acc[16] * 100.0), "%\t")

  44.         print("motorcycle   : %.6f" % (Acc[17] * 100.0), "%\t")

  45.         print("bicycle      : %.6f" % (Acc[18] * 100.0), "%\t")

  46.         print("dynamic      : %.6f" % (Acc[19] * 100.0), "%\t")

  47.         print("stair        : %.6f" % (Acc[20] * 100.0), "%\t")

  48.         if self.num_class == 20:

  49.             print("small obstacles: %.6f" % (Acc[19] * 100.0), "%\t")

  50.         Acc = np.nanmean(Acc)

  51.         return Acc

  52. 

  53.     def Mean_Intersection_over_Union(self):

  54.         # print(np.shape(self.confusion_matrix))

  55.         MIoU = np.diag(self.confusion_matrix) / (

  56.                     np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -

  57.                     np.diag(self.confusion_matrix))

  58. 

  59.         # print MIoU of each class

  60.         print('-----------IoU of each classes-----------')

  61.         print("road         : %.6f" % (MIoU[0] * 100.0), "%\t")

  62.         print("sidewalk     : %.6f" % (MIoU[1] * 100.0), "%\t")

  63.         print("building     : %.6f" % (MIoU[2] * 100.0), "%\t")

  64.         print("wall         : %.6f" % (MIoU[3] * 100.0), "%\t")

  65.         print("fence        : %.6f" % (MIoU[4] * 100.0), "%\t")

  66.         print("pole         : %.6f" % (MIoU[5] * 100.0), "%\t")

  67.         print("traffic light: %.6f" % (MIoU[6] * 100.0), "%\t")

  68.         print("traffic sign : %.6f" % (MIoU[7] * 100.0), "%\t")

  69.         print("vegetation   : %.6f" % (MIoU[8] * 100.0), "%\t")

  70.         print("terrain      : %.6f" % (MIoU[9] * 100.0), "%\t")

  71.         print("sky          : %.6f" % (MIoU[10] * 100.0), "%\t")

  72.         print("person       : %.6f" % (MIoU[11] * 100.0), "%\t")

  73.         print("rider        : %.6f" % (MIoU[12] * 100.0), "%\t")

  74.         print("car          : %.6f" % (MIoU[13] * 100.0), "%\t")

  75.         print("truck        : %.6f" % (MIoU[14] * 100.0), "%\t")

  76.         print("bus          : %.6f" % (MIoU[15] * 100.0), "%\t")

  77.         print("train        : %.6f" % (MIoU[16] * 100.0), "%\t")

  78.         print("motorcycle   : %.6f" % (MIoU[17] * 100.0), "%\t")

  79.         print("bicycle      : %.6f" % (MIoU[18] * 100.0), "%\t")

  80.         print("stair      : %.6f" % (MIoU[19] * 100.0), "%\t")

  81.         print("curb        : %.6f" % (MIoU[20] * 100.0), "%\t")

  82.         print("ramp        : %.6f" % (MIoU[21] * 100.0), "%\t")

  83.         if self.num_class == 20:

  84.             print("small obstacles: %.6f" % (MIoU[19] * 100.0), "%\t")

  85. 

  86.         MIoU = np.nanmean(MIoU)

  87.         return MIoU

  88.     

  89.     def Mean_Intersection_over_Union_Curb(self):

  90.         MIoU = np.diag(self.confusion_matrix) / (

  91.                     np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -

  92.                     np.diag(self.confusion_matrix))

  93. 

  94.         # print MIoU of each class

  95.         print('-----------IoU of each classes-----------')

  96.         print("road         : %.6f" % (MIoU[0] * 100.0), "%\t")

  97.         print("sidewalk     : %.6f" % (MIoU[1] * 100.0), "%\t")

  98.         print("stair     : %.6f" % (MIoU[19] * 100.0), "%\t")

  99.         

  100.         if self.num_class == 20:

  101.             print("small obstacles: %.6f" % (MIoU[19] * 100.0), "%\t")

  102. 

  103.         MIoU = np.nanmean(MIoU[[0, 1, 19]])

  104.         return MIoU

  105. 

  106.     def Frequency_Weighted_Intersection_over_Union(self):

  107.         freq = np.sum(self.confusion_matrix, axis=1) / np.sum(self.confusion_matrix)

  108.         iu = np.diag(self.confusion_matrix) / (

  109.                     np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -

  110.                     np.diag(self.confusion_matrix))

  111. 

  112.         FWIoU = (freq[freq > 0] * iu[freq > 0]).sum()

  113.         return FWIoU

  114. 

  115.     def Frequency_Weighted_Intersection_over_Union_Curb(self):

  116.         freq = np.sum(self.confusion_matrix, axis=1) / np.sum(self.confusion_matrix)

  117.         iu = np.diag(self.confusion_matrix) / (

  118.                 np.sum(self.confusion_matrix, axis=1) + np.sum(self.confusion_matrix, axis=0) -

  119.                 np.diag(self.confusion_matrix))

  120. 

  121.         # FWIoU = (freq[freq > 0] * iu[freq > 0]).sum()

  122.         CFWIoU = freq[freq > 0] * iu[freq > 0]

  123.         print('-----------FWIoU of each classes-----------')

  124.         print("road         : %.6f" % (CFWIoU[0] * 100.0), "%\t")

  125.         print("sidewalk     : %.6f" % (CFWIoU[1] * 100.0), "%\t")

  126. 

  127.         return np.nanmean(CFWIoU[:2])

  128. 

  129.     def Current_Intersection_over_Union(self):

  130.         MIoU = np.diag(self.curr_confusion_matrix) / (

  131.                     np.sum(self.curr_confusion_matrix, axis=1) + np.sum(self.curr_confusion_matrix, axis=0) -

  132.                     np.diag(self.curr_confusion_matrix))

  133.         MIoU = np.nanmean(MIoU[[0, 1, 19]])

  134.         return MIoU

  135. 

  136.     def Future_Intersection_over_Union(self):

  137.         MIoU = np.diag(self.future_confusion_matrix) / (

  138.                     np.sum(self.future_confusion_matrix, axis=1) + np.sum(self.future_confusion_matrix, axis=0) -

  139.                     np.diag(self.future_confusion_matrix))

  140.         MIoU = np.nanmean(MIoU[[0, 1, 19]])

  141.         return MIoU

  142. 

  143.     def _generate_current_matrix(self, gt_image, pre_image):

  144.         _, input_height, input_width = np.shape(pre_image)

  145. 

  146.         closest = np.array([

  147.             [0, int(input_height)],

  148.             [int(input_width),

  149.             int(input_height)],

  150.             [int(0.882 * input_width + .5),

  151.             int(.8 * input_height + .5)],

  152.             [int(0.118 * input_width + .5),

  153.              int(.8 * input_height + .5)]

  154.         ])

  155.         mask_current = np.zeros((input_height, input_width), dtype=np.int8)

  156.         mask_current = cv2.fillPoly(mask_current, [closest], 1)

  157.         mask = (gt_image >= 0) & (gt_image < self.num_class) & (mask_current == 1)

  158.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]

  159.         count = np.bincount(label, minlength=self.num_class**2)

  160.         confusion_matrix = count.reshape(self.num_class, self.num_class)

  161.         return confusion_matrix

  162. 

  163.     def _generate_future_matrix(self, gt_image, pre_image):

  164.         _, input_height, input_width = np.shape(pre_image)

  165. 

  166.         future = np.array([

  167.             [int(0.118 * input_width + .5),

  168.             int(.8 * input_height + .5)],

  169.             [int(0.882 * input_width + .5),

  170.             int(.8 * input_height + .5)],

  171.             [int(.765 * input_width + .5),

  172.             int(.66 * input_height + .5)],

  173.             [int(.235 * input_width + .5),

  174.             int(.66 * input_height + .5)]

  175.         ])

  176.         mask_future = np.zeros((input_height, input_width), dtype=np.int8)

  177.         mask_future = cv2.fillPoly(mask_future, [future], 1)

  178.         mask = (gt_image >= 0) & (gt_image < self.num_class) & (mask_future == 1)

  179.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]

  180.         count = np.bincount(label, minlength=self.num_class**2)

  181.         confusion_matrix = count.reshape(self.num_class, self.num_class)

  182.         return confusion_matrix

  183. 

  184.     def _generate_matrix(self, gt_image, pre_image):

  185.         mask = (gt_image >= 0) & (gt_image < self.num_class)

  186.         label = self.num_class * gt_image[mask].astype('int') + pre_image[mask]

  187.         count = np.bincount(label, minlength=self.num_class**2)

  188.         confusion_matrix = count.reshape(self.num_class, self.num_class)

  189.         return confusion_matrix

  190. 

  191.     # def add_trape_batch(self, gt_image, pre_image):

  192.     #     assert gt_image.shape == pre_image.shape

  193.     #     self.trape_confusion_matrix += self._generate_trape_matrix(gt_image, pre_image)

  194. 

  195.     def add_batch(self, gt_image, pre_image):

  196.         assert gt_image.shape == pre_image.shape

  197.         self.confusion_matrix += self._generate_matrix(gt_image, pre_image)

  198.         self.curr_confusion_matrix += self._generate_current_matrix(gt_image, pre_image)

  199.         self.future_confusion_matrix += self._generate_future_matrix(gt_image, pre_image)

  200. 

  201.     def reset(self):

  202.         self.confusion_matrix = np.zeros((self.num_class,) * 2)

  203.         self.curr_confusion_matrix = np.zeros((self.num_class,)*2)

  204.         self.future_confusion_matrix = np.zeros((self.num_class,)*2)

  205. 

  206. 

  207.