Fixed calculaton of roc_auc_score metric (#3081)

Author: Anna Grebneva

tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/README.md

@@ -48,7 +48,8 @@ Supported representations: `ClassificationAnnotation`, `TextClassificationAnnota
   * `pixel_level`- evaluate metric on pixel level for anomaly segmentation (Optional, default False) .
 * `metthews_correlation_coef` - [Matthews correlation coefficient (MCC)](https://en.wikipedia.org/wiki/Matthews_correlation_coefficient) for binary classification. Metric is calculated as a percentage. Direction of metric's growth is higher-better. Supported representations: `ClassificationAnnotation`, `TextClassificationAnnotation`, `ClassificationPrediction`.
 * `roc_auc_score` - [ROC AUC score](https://en.wikipedia.org/wiki/Receiver_operating_characteristic) for binary classification. Metric is calculated as a percentage. Direction of metric's growth is higher-better. Supported representations: `ClassificationAnnotation`, `TextClassificationAnnotation`, `ClassificationPrediction` `ArgMaxClassificationPrediction`, `AnomalySegmentationAnnotation`, `AnomalySegmentationPrediction`.
-  * `pixel_level`- evaluate metric on pixel level for anomaly segmentation (Optional, default False)
+  * `pixel_level`- evaluate metric on pixel level for anomaly segmentation (Optional, default False).
+  * `calculate_hot_label` - calculate one hot label for annotation and prediction before metric evaluation calculation for anomaly segmentation (Optional, default False).
 * `acer_score` - metric for the classification tasks. Can be obtained from the following formula: `ACER = (APCER + BPCER)/2 = ((fp / (tn + fp)) + (fn / (fn + tp)))/2`. For more details about metrics see the section 9.3: <https://arxiv.org/abs/2007.12342>. Metric is calculated as a percentage. Direction of metric's growth is higher-worse. Supported representations: `ClassificationAnnotation`, `TextClassificationAnnotation`, `ClassificationPrediction`.
 * `clip_accuracy` - classification video-level accuracy metric. Metric is calculated as a percentage. Direction of metric's growth is higher-better. Supported representations: `ClassificationAnnotation`, `ClassificationPrediction`.
 * `map` - mean average precision. Metric is calculated as a percentage. Direction of metric's growth is higher-better. Supported representations: `DetectionAnnotation`, `DetectionPrediction`.

tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/classification.py

@@ -551,13 +551,18 @@ def parameters(cls):
         params.update({
             'pixel_level': BoolField(
                 optional=True, default=False,
-                description='calculate metic on pixel level, for anomaly segmentation only')
+                description='calculate metric on pixel level, for anomaly segmentation only'),
+            'calculate_hot_label': BoolField(
+                optional=True, default=False,
+                description='calculate one hot label for annotation and prediction before metric evaluation '
+                            'for anomaly segmentation')
         })
         return params
 
     def configure(self):
         self.reset()
         self.pixel_level = self.get_value_from_config('pixel_level')
+        self.calculate_hot_label = self.get_value_from_config('calculate_hot_label')
 
     def update(self, annotation, prediction):
         if (
@@ -581,19 +586,12 @@ def update(self, annotation, prediction):
     def one_hot_labels(targets, results):
         max_v = int(max(np.max(targets) + 1, np.max(results) + 1))
         gt_bin = np.zeros((len(targets), max_v))
-        pred_bin = np.zeros((len(targets), max_v))
+        pred_bin = np.zeros((len(results), max_v))
         np.put_along_axis(gt_bin, np.expand_dims(np.array(targets).astype(int), 1), 1, axis=1)
         np.put_along_axis(pred_bin, np.expand_dims(np.array(results).astype(int), 1), 1, axis=1)
 
         return gt_bin, pred_bin
 
-    def roc(self, y_true, y_score):
-        per_class_area = []
-        for i in range(y_true.shape[-1]):
-            per_class_area.append(self.roc_curve_area(y_true[:, i], y_score[:, i]))
-        average_area = self.roc_curve_area(y_true.ravel(), y_score.ravel())
-        return average_area, per_class_area
-
     def roc_curve_area(self, gt, pred):
         desc_score_indices = np.argsort(pred, kind="mergesort")[::-1]
         y_score = pred[desc_score_indices]
@@ -602,10 +600,14 @@ def roc_curve_area(self, gt, pred):
         threshold_idxs = np.r_[distinct_value_indices, y_true.size - 1]
         tps = np.cumsum(y_true)[threshold_idxs]
         fps = 1 + threshold_idxs - tps
+
+        tps = np.r_[0, tps]
+        fps = np.r_[0, fps]
+
         if max(fps) > 0:
-            fps /= fps[-1]
+            fps = fps / fps[-1]
         if max(tps) > 0:
-            tps /= tps[-1]
+            tps = tps / tps[-1]
         area = self.roc_auc_score(fps, tps)
         return area
 
@@ -620,7 +622,7 @@ def roc_auc_score(fpr, tpr):
 
     def evaluate(self, annotations, predictions):
         all_results = self.results if np.isscalar(self.results[-1]) else np.concatenate(self.results)
-        all_targets = self.targets if np.isscalar(self.results[-1]) else np.concatenate(self.results)
+        all_targets = self.targets if np.isscalar(self.targets[-1]) else np.concatenate(self.targets)
         roc_auc = self.auc_score(all_targets, all_results)
         return roc_auc
 
@@ -629,8 +631,8 @@ def reset(self):
         self.results = []
 
     def auc_score(self, targets, results):
-        gt, dt = self.one_hot_labels(targets, results)
-        avg_area, _ = self.roc(gt, dt)
+        (gt, dt) = self.one_hot_labels(targets, results) if self.calculate_hot_label else (targets, results)
+        avg_area = self.roc_curve_area(np.array(gt).ravel(), np.array(dt).ravel())
         return avg_area