Upload evaluation/metrics.py with huggingface_hub

evaluation/metrics.py

@@ -0,0 +1,166 @@
+"""
+Core evaluation metrics for face detection.
+
+Implements:
+- IoU computation (pairwise and matrix)
+- Average Precision (AP) with VOC-style 11-point interpolation
+- Recall at various IoU thresholds
+- WiderFace evaluation protocol helpers
+"""
+
+import numpy as np
+from typing import List, Tuple, Optional
+
+
+def compute_iou_matrix(boxes1: np.ndarray, boxes2: np.ndarray) -> np.ndarray:
+    """
+    Compute pairwise IoU between two sets of boxes.
+
+    Args:
+        boxes1: [N, 4] (x1, y1, x2, y2)
+        boxes2: [M, 4] (x1, y1, x2, y2)
+
+    Returns:
+        [N, M] IoU matrix
+    """
+    x1 = np.maximum(boxes1[:, 0:1], boxes2[:, 0:1].T)
+    y1 = np.maximum(boxes1[:, 1:2], boxes2[:, 1:2].T)
+    x2 = np.minimum(boxes1[:, 2:3], boxes2[:, 2:3].T)
+    y2 = np.minimum(boxes1[:, 3:4], boxes2[:, 3:4].T)
+
+    inter = np.maximum(0, x2 - x1) * np.maximum(0, y2 - y1)
+
+    area1 = (boxes1[:, 2] - boxes1[:, 0]) * (boxes1[:, 3] - boxes1[:, 1])
+    area2 = (boxes2[:, 2] - boxes2[:, 0]) * (boxes2[:, 3] - boxes2[:, 1])
+
+    union = area1[:, None] + area2[None, :] - inter
+    return inter / (union + 1e-6)
+
+
+def compute_ap(recall: np.ndarray, precision: np.ndarray,
+               use_11_point: bool = True) -> float:
+    """
+    Compute Average Precision from recall-precision curve.
+
+    WiderFace uses 11-point interpolation (VOC2007 style).
+
+    Args:
+        recall: [N] sorted recall values
+        precision: [N] corresponding precision values
+        use_11_point: Use 11-point interpolation (default: True)
+
+    Returns:
+        AP value
+    """
+    if use_11_point:
+        # 11-point interpolation
+        ap = 0.0
+        for t in np.arange(0, 1.1, 0.1):
+            if np.sum(recall >= t) == 0:
+                p = 0
+            else:
+                p = np.max(precision[recall >= t])
+            ap += p / 11
+        return ap
+    else:
+        # All-point interpolation (VOC2010+ style)
+        mrec = np.concatenate(([0.0], recall, [1.0]))
+        mpre = np.concatenate(([0.0], precision, [0.0]))
+
+        # Make precision monotonically decreasing
+        for i in range(len(mpre) - 1, 0, -1):
+            mpre[i - 1] = max(mpre[i - 1], mpre[i])
+
+        # Compute area under curve
+        idx = np.where(mrec[1:] != mrec[:-1])[0]
+        ap = np.sum((mrec[idx + 1] - mrec[idx]) * mpre[idx + 1])
+        return ap
+
+
+def compute_recall_at_iou(pred_boxes: np.ndarray, pred_scores: np.ndarray,
+                          gt_boxes: np.ndarray, iou_threshold: float = 0.5
+                          ) -> Tuple[float, np.ndarray, np.ndarray]:
+    """
+    Compute recall and precision at a given IoU threshold.
+
+    Args:
+        pred_boxes: [N, 4] predicted boxes sorted by score (descending)
+        pred_scores: [N] prediction scores
+        gt_boxes: [M, 4] ground truth boxes
+        iou_threshold: IoU threshold for matching
+
+    Returns:
+        (ap, recall_curve, precision_curve)
+    """
+    num_gt = gt_boxes.shape[0]
+    if num_gt == 0:
+        return 0.0, np.array([]), np.array([])
+
+    # Sort by score
+    order = np.argsort(-pred_scores)
+    pred_boxes = pred_boxes[order]
+
+    iou_matrix = compute_iou_matrix(pred_boxes, gt_boxes)
+
+    # Greedy matching
+    gt_matched = np.zeros(num_gt, dtype=bool)
+    tp = np.zeros(len(pred_boxes))
+    fp = np.zeros(len(pred_boxes))
+
+    for i in range(len(pred_boxes)):
+        if iou_matrix.shape[1] > 0:
+            best_gt = iou_matrix[i].argmax()
+            if iou_matrix[i, best_gt] >= iou_threshold and not gt_matched[best_gt]:
+                tp[i] = 1
+                gt_matched[best_gt] = True
+            else:
+                fp[i] = 1
+        else:
+            fp[i] = 1
+
+    tp_cumsum = np.cumsum(tp)
+    fp_cumsum = np.cumsum(fp)
+
+    recall = tp_cumsum / num_gt
+    precision = tp_cumsum / (tp_cumsum + fp_cumsum)
+
+    ap = compute_ap(recall, precision)
+    return ap, recall, precision
+
+
+def match_detections_to_gt(pred_boxes: np.ndarray, gt_boxes: np.ndarray,
+                           iou_threshold: float = 0.5
+                           ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Match predictions to ground truth for detailed analysis.
+
+    Returns:
+        (tp_mask, fp_mask, fn_indices)
+        tp_mask: [N] boolean, True for true positives
+        fp_mask: [N] boolean, True for false positives
+        fn_indices: indices of unmatched GT boxes (false negatives)
+    """
+    if len(pred_boxes) == 0:
+        return (np.array([], dtype=bool),
+                np.array([], dtype=bool),
+                np.arange(len(gt_boxes)))
+
+    if len(gt_boxes) == 0:
+        return (np.zeros(len(pred_boxes), dtype=bool),
+                np.ones(len(pred_boxes), dtype=bool),
+                np.array([], dtype=int))
+
+    iou_matrix = compute_iou_matrix(pred_boxes, gt_boxes)
+    gt_matched = np.zeros(len(gt_boxes), dtype=bool)
+    tp_mask = np.zeros(len(pred_boxes), dtype=bool)
+
+    for i in range(len(pred_boxes)):
+        best_gt = iou_matrix[i].argmax()
+        if iou_matrix[i, best_gt] >= iou_threshold and not gt_matched[best_gt]:
+            tp_mask[i] = True
+            gt_matched[best_gt] = True
+
+    fp_mask = ~tp_mask
+    fn_indices = np.where(~gt_matched)[0]
+
+    return tp_mask, fp_mask, fn_indices