AC: added alternatives sklearn if it is not available (#1854)

Author: eaidova

tools/accuracy_checker/accuracy_checker/metrics/reid.py

@@ -26,16 +26,70 @@
 )
 from ..config import BaseField, BoolField, NumberField
 from .metric import FullDatasetEvaluationMetric
-from ..utils import UnsupportedPackage
+
+
+def _auc(x, y):
+    if x.shape[0] < 2:
+        raise ValueError('At least 2 points are needed to compute'
+                         ' area under curve, but x.shape = {}'.format(x.shape))
+    direction = 1
+    dx = np.diff(x)
+    if np.any(dx < 0):
+        if np.all(dx <= 0):
+            direction = -1
+        else:
+            raise ValueError("x is neither increasing nor decreasing "
+                             ": {}.".format(x))
+    area = direction * np.trapz(y, x)
+    return area
+
+
+def _binary_clf_curve(y_true, y_score):
+    pos_label = 1.
+
+    # make y_true a boolean vector
+    y_true = (y_true == pos_label)
+
+    # sort scores and corresponding truth values
+    desc_score_indices = np.argsort(y_score, kind="mergesort")[::-1]
+    y_score = y_score[desc_score_indices]
+    y_true = y_true[desc_score_indices]
+    weight = 1.
+
+    distinct_value_indices = np.where(np.diff(y_score))[0]
+    threshold_idxs = np.r_[distinct_value_indices, y_true.size - 1]
+
+    # accumulate the true positives with decreasing threshold
+    tps = np.cumsum((y_true * weight), axis=None, dtype=np.float64)[threshold_idxs]
+    fps = 1 + threshold_idxs - tps
+    return fps, tps, y_score[threshold_idxs]
+
+
+def _precision_recall_curve(y_true, probas_pred):
+
+    fps, tps, thresholds = _binary_clf_curve(y_true, probas_pred,)
+
+    precision = tps / (tps + fps)
+    precision[np.isnan(precision)] = 0
+    recall = tps / tps[-1]
+
+    # stop when full recall attained
+    # and reverse the outputs so recall is decreasing
+    last_ind = tps.searchsorted(tps[-1])
+    sl = slice(last_ind, None, -1)
+    return np.r_[precision[sl], 1], np.r_[recall[sl], 0], thresholds[sl]
+
 
 try:
     from sklearn.metrics import auc, precision_recall_curve
 except ImportError as import_error:
-    auc = UnsupportedPackage("sklearn.metrics.auc", import_error.msg)
-    precision_recall_curve = UnsupportedPackage("sklearn.metrics.precision_recall_curve", import_error.msg)
+    auc = _auc
+    precision_recall_curve = _precision_recall_curve
+
 
 PairDesc = namedtuple('PairDesc', 'image1 image2 same')
 
+
 def _average_binary_score(binary_metric, y_true, y_score):
     def binary_target(y):
         return not (len(np.unique(y)) > 2) or (y.ndim >= 2 and len(y[0]) > 1)
@@ -287,6 +341,7 @@ def get_subset(container, subset_bounds):
 
         return subset
 
+
 class FaceRecognitionTAFAPairMetric(FullDatasetEvaluationMetric):
     __provider__ = 'face_recognition_tafa_pair_metric'
 
@@ -337,6 +392,7 @@ def evaluate(self, annotations, predictions):
 
         return [(tp+tn) / (tp+fp+tn+fn)]
 
+
 class NormalizedEmbeddingAccuracy(FullDatasetEvaluationMetric):
     """
     Accuracy score calculated with normalized embedding dot products
@@ -407,6 +463,7 @@ def evaluate(self, annotations, predictions):
             return 0
         return tp/(tp+fp)
 
+
 def regroup_pairs(annotations, predictions):
     image_indexes = {}
 
@@ -424,10 +481,12 @@ def regroup_pairs(annotations, predictions):
 
     return pairs
 
+
 def extract_embeddings(annotation, prediction, query):
     embeddings = [pred.embedding for pred, ann in zip(prediction, annotation) if ann.query == query]
     return np.stack(embeddings) if embeddings else embeddings
 
+
 def get_gallery_query_pids(annotation):
     gallery_pids = np.asarray([ann.person_id for ann in annotation if not ann.query])
     query_pids = np.asarray([ann.person_id for ann in annotation if ann.query])
@@ -574,10 +633,6 @@ def get_embedding_distances(annotation, prediction, train=False):
 
 
 def binary_average_precision(y_true, y_score, interpolated_auc=True):
-    if isinstance(auc, UnsupportedPackage):
-        auc.raise_error("reid metric")
-    if isinstance(precision_recall_curve, UnsupportedPackage):
-        precision_recall_curve.raise_error("reid metric")
     def _average_precision(y_true_, y_score_):
         precision, recall, _ = precision_recall_curve(y_true_, y_score_)
         if not interpolated_auc: