mirror of https://github.com/alibaba/EasyCV.git
118 lines
4.1 KiB
Python
118 lines
4.1 KiB
Python
# Copyright (c) Alibaba, Inc. and its affiliates.
|
|
import matplotlib.pyplot as plt
|
|
import numpy as np
|
|
|
|
|
|
def ap_per_class(tp,
|
|
conf,
|
|
pred_cls,
|
|
target_cls,
|
|
plot=False,
|
|
fname='precision-recall_curve.png'):
|
|
""" Compute the average precision, given the recall and precision curves.
|
|
Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
|
|
|
|
Args:
|
|
tp: True positives (nparray, nx1 or nx10).
|
|
conf: Objectness value from 0-1 (nparray).
|
|
pred_cls: Predicted object classes (nparray).
|
|
target_cls: True object classes (nparray).
|
|
plot: Plot precision-recall curve at mAP@0.5
|
|
fname: Plot filename
|
|
|
|
Returns:
|
|
The average precision as computed in py-faster-rcnn.
|
|
"""
|
|
|
|
# Sort by objectness
|
|
i = np.argsort(-conf)
|
|
tp, conf, pred_cls = tp[i], conf[i], pred_cls[i]
|
|
|
|
# Find unique classes
|
|
unique_classes = np.unique(target_cls)
|
|
|
|
# Create Precision-Recall curve and compute AP for each class
|
|
px, py = np.linspace(0, 1, 1000), [] # for plotting
|
|
pr_score = 0.1 # score to evaluate P and R https://github.com/ultralytics/yolov3/issues/898
|
|
s = [unique_classes.shape[0], tp.shape[1]
|
|
] # number class, number iou thresholds (i.e. 10 for mAP0.5...0.95)
|
|
ap, p, r = np.zeros(s), np.zeros(s), np.zeros(s)
|
|
for ci, c in enumerate(unique_classes):
|
|
i = pred_cls == c
|
|
n_gt = (target_cls == c).sum() # Number of ground truth objects
|
|
n_p = i.sum() # Number of predicted objects
|
|
|
|
if n_p == 0 or n_gt == 0:
|
|
continue
|
|
else:
|
|
# Accumulate FPs and TPs
|
|
fpc = (1 - tp[i]).cumsum(0)
|
|
tpc = tp[i].cumsum(0)
|
|
|
|
# Recall
|
|
recall = tpc / (n_gt + 1e-16) # recall curve
|
|
r[ci] = np.interp(
|
|
-pr_score, -conf[i], recall[:, 0]
|
|
) # r at pr_score, negative x, xp because xp decreases
|
|
|
|
# Precision
|
|
precision = tpc / (tpc + fpc) # precision curve
|
|
p[ci] = np.interp(-pr_score, -conf[i],
|
|
precision[:, 0]) # p at pr_score
|
|
|
|
# AP from recall-precision curve
|
|
py.append(np.interp(px, recall[:, 0],
|
|
precision[:, 0])) # precision at mAP@0.5
|
|
for j in range(tp.shape[1]):
|
|
ap[ci, j] = compute_ap(recall[:, j], precision[:, j])
|
|
|
|
# Compute F1 score (harmonic mean of precision and recall)
|
|
f1 = 2 * p * r / (p + r + 1e-16)
|
|
|
|
if plot:
|
|
py = np.stack(py, axis=1)
|
|
fig, ax = plt.subplots(1, 1, figsize=(5, 5))
|
|
ax.plot(px, py, linewidth=0.5, color='grey') # plot(recall, precision)
|
|
ax.plot(px, py.mean(1), linewidth=2, color='blue', label='all classes')
|
|
ax.set_xlabel('Recall')
|
|
ax.set_ylabel('Precision')
|
|
ax.set_xlim(0, 1)
|
|
ax.set_ylim(0, 1)
|
|
plt.legend()
|
|
fig.tight_layout()
|
|
fig.savefig(fname, dpi=200)
|
|
|
|
return p, r, ap, f1, unique_classes.astype('int32')
|
|
|
|
|
|
def compute_ap(recall, precision):
|
|
""" Compute the average precision, given the recall and precision curves.
|
|
Source: https://github.com/rbgirshick/py-faster-rcnn.
|
|
|
|
Args:
|
|
recall: The recall curve (list).
|
|
precision: The precision curve (list).
|
|
|
|
Returns:
|
|
The average precision as computed in py-faster-rcnn.
|
|
"""
|
|
|
|
# Append sentinel values to beginning and end
|
|
mrec = np.concatenate(([0.], recall, [min(recall[-1] + 1E-3, 1.)]))
|
|
mpre = np.concatenate(([0.], precision, [0.]))
|
|
|
|
# Compute the precision envelope
|
|
mpre = np.flip(np.maximum.accumulate(np.flip(mpre)))
|
|
|
|
# Integrate area under curve
|
|
method = 'interp' # methods: 'continuous', 'interp'
|
|
if method == 'interp':
|
|
x = np.linspace(0, 1, 101) # 101-point interp (COCO)
|
|
ap = np.trapz(np.interp(x, mrec, mpre), x) # integrate
|
|
else: # 'continuous'
|
|
i = np.where(
|
|
mrec[1:] != mrec[:-1])[0] # points where x axis (recall) changes
|
|
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) # area under curve
|
|
|
|
return ap
|