| """Instance-level, class-aware localisation metrics.""" |
|
|
| from collections import defaultdict |
|
|
| from metrics._f_beta import ViolationCounts, aggregate_summary, summarise_counts |
| from metrics._labels import to_use_case_id |
| from schemas.ground_truth import GoldRecord |
| from schemas.inference import InferenceResponse |
|
|
|
|
| def _compute_iou(a: list[float], b: list[float]) -> float: |
| ax1, ay1, aw, ah = a |
| bx1, by1, bw, bh = b |
| intersection = max(0.0, min(ax1 + aw, bx1 + bw) - max(ax1, bx1)) * max( |
| 0.0, min(ay1 + ah, by1 + bh) - max(ay1, by1) |
| ) |
| union = aw * ah + bw * bh - intersection |
| return intersection / union if union > 0 else 0.0 |
|
|
|
|
| def maximum_match_pairs( |
| pred_boxes: list[list[float]], gt_boxes: list[list[float]], threshold: float |
| ) -> list[tuple[int, int, float]]: |
| """Return deterministic prediction/GT pairs and their IoUs. |
| |
| The aggregate scorer only needs the number of matches, while presentation |
| and audit tooling needs to show which exact boxes produced that number. |
| Keeping both readings on this one matcher prevents the image inspector from |
| drifting away from the published metric. |
| """ |
| candidates = [ |
| sorted( |
| ( |
| index |
| for index, gt in enumerate(gt_boxes) |
| if _compute_iou(box, gt) >= threshold |
| ), |
| key=lambda index: (-_compute_iou(box, gt_boxes[index]), index), |
| ) |
| for box in pred_boxes |
| ] |
| gt_owner: dict[int, int] = {} |
|
|
| def assign(pred_index: int, seen: set[int]) -> bool: |
| for gt_index in candidates[pred_index]: |
| if gt_index in seen: |
| continue |
| seen.add(gt_index) |
| owner = gt_owner.get(gt_index) |
| if owner is None or assign(owner, seen): |
| gt_owner[gt_index] = pred_index |
| return True |
| return False |
|
|
| for index in range(len(pred_boxes)): |
| assign(index, set()) |
| return sorted( |
| ( |
| (pred_index, gt_index, _compute_iou(pred_boxes[pred_index], gt_boxes[gt_index])) |
| for gt_index, pred_index in gt_owner.items() |
| ), |
| key=lambda pair: pair[0], |
| ) |
|
|
|
|
| def _maximum_matches( |
| pred_boxes: list[list[float]], gt_boxes: list[list[float]], threshold: float |
| ) -> int: |
| """Return the count used by the baseline aggregate report.""" |
| return len(maximum_match_pairs(pred_boxes, gt_boxes, threshold)) |
|
|
|
|
| def compute_localisation_metrics( |
| predictions: list[InferenceResponse], |
| ground_truths: list[GoldRecord], |
| iou_threshold: float = 0.50, |
| ) -> dict: |
| """Match every prediction and gold instance at most once, within its class.""" |
| gt_by_id = {record.image_id: record for record in ground_truths} |
| counts: dict[str, ViolationCounts] = defaultdict(ViolationCounts) |
| n_predictions = n_gt_boxes = evaluated = 0 |
| negatives = true_negatives = false_positive_images = 0 |
| for prediction in predictions: |
| record = gt_by_id.get(prediction.image_id) |
| if record is None or record.gold.reported: |
| continue |
| evaluated += 1 |
| n_predictions += len(prediction.detections) |
| n_gt_boxes += len(record.gold.violations) |
| gt_by_label: dict[str, list[list[float]]] = defaultdict(list) |
| pred_by_label: dict[str, list[list[float]]] = defaultdict(list) |
| for item in record.gold.violations: |
| gt_by_label[item.use_case_id].append(item.bbox) |
| for item in prediction.detections: |
| pred_by_label[to_use_case_id(item.category_id)].append(item.bbox) |
| for label in gt_by_label.keys() | pred_by_label.keys(): |
| gt_boxes, pred_boxes = gt_by_label[label], pred_by_label[label] |
| matches = _maximum_matches(pred_boxes, gt_boxes, iou_threshold) |
| counts[label].tp += matches |
| counts[label].fp += len(pred_boxes) - matches |
| counts[label].fn += len(gt_boxes) - matches |
| if record.gold.no_violation_detected: |
| negatives += 1 |
| if prediction.detections: |
| false_positive_images += 1 |
| else: |
| true_negatives += 1 |
| return { |
| "per_violation": summarise_counts(counts), |
| "summary": aggregate_summary(counts), |
| "iou_threshold": iou_threshold, |
| "n_images": evaluated, |
| "n_predictions": n_predictions, |
| "n_gt_boxes": n_gt_boxes, |
| "negative_images": negatives, |
| "true_negative_images": true_negatives, |
| "false_positive_images": false_positive_images, |
| "negative_false_positive_rate": round(false_positive_images / negatives, 4) if negatives else None, |
| } |
|
|
