scale-nucleus 0.1.24__py3-none-any.whl → 0.6.4__py3-none-any.whl

nucleus/metrics/geometry.py

@@ -0,0 +1,198 @@
+from typing import List, Tuple, Union
+
+import numpy as np
+
+TOLERANCE = 1e-8
+
+
+class GeometryPolygon:
+    def __init__(
+        self,
+        points: Union[np.ndarray, List[Tuple[float, float]]],
+        is_rectangle: bool = False,
+    ):
+        self.points = (
+            points if isinstance(points, np.ndarray) else np.array(points)
+        )
+        self.is_rectangle = is_rectangle
+        points_x = self.points[:, 0]
+        points_y = self.points[:, 1]
+        if is_rectangle:
+            self.signed_area = np.abs(self.points[2] - self.points[0]).prod()
+            self.area = self.signed_area
+        else:
+            self.signed_area = (
+                points_x @ np.roll(points_y, -1)
+                - points_x @ np.roll(points_y, 1)
+            ) / 2
+            self.area = np.abs(self.signed_area)
+
+    def __len__(self):
+        return len(self.points)
+
+    def __getitem__(self, idx):
+        return self.points[idx]
+
+    def __repr__(self) -> str:
+        return f"GeometryPolygon({self.points})"
+
+
+# alpha * a1 + (1 - alpha) * a2 = beta * b1 + (1 - beta) * b2
+def segment_intersection(
+    segment1: Tuple[np.ndarray, np.ndarray],
+    segment2: Tuple[np.ndarray, np.ndarray],
+) -> Tuple[float, float, np.ndarray]:
+    a1, a2 = segment1
+    b1, b2 = segment2
+    x2_x2 = b2[0] - a2[0]
+    y2_y2 = b2[1] - a2[1]
+    x1x2 = a1[0] - a2[0]
+    y1y2 = a1[1] - a2[1]
+    y1_y2_ = b1[1] - b2[1]
+    x1_x2_ = b1[0] - b2[0]
+
+    if np.abs(y1_y2_ * x1x2 - x1_x2_ * y1y2) < TOLERANCE:
+        beta = 1.0
+    else:
+        beta = (x2_x2 * y1y2 - y2_y2 * x1x2) / (y1_y2_ * x1x2 - x1_x2_ * y1y2)
+
+    if x1x2 == 0:
+        alpha = (y2_y2 + y1_y2_ * beta) / (y1y2 + TOLERANCE)
+    else:
+        alpha = (x2_x2 + x1_x2_ * beta) / (x1x2 + TOLERANCE)
+
+    return alpha, beta, alpha * a1 + (1 - alpha) * a2
+
+
+def convex_polygon_intersection_area(
+    polygon_a: GeometryPolygon, polygon_b: GeometryPolygon
+) -> float:
+    # pylint: disable=R0912
+    sa = polygon_a.signed_area
+    sb = polygon_b.signed_area
+    if sa * sb < 0:
+        sign = -1
+    else:
+        sign = 1
+    na = len(polygon_a)
+    nb = len(polygon_b)
+    ps = []  # point set
+    for i in range(na):
+        a1 = polygon_a[i - 1]
+        a2 = polygon_a[i]
+        flag = False
+        sum_s = 0
+        for j in range(nb):
+            b1 = polygon_b[j - 1]
+            b2 = polygon_b[j]
+            sum_s += np.abs(GeometryPolygon([a1, b1, b2]).signed_area)
+
+        if np.abs(np.abs(sum_s) - np.abs(sb)) < TOLERANCE:
+            flag = True
+
+        if flag:
+            ps.append(a1)
+        for j in range(nb):
+            b1 = polygon_b[j - 1]
+            b2 = polygon_b[j]
+            a, b, p = segment_intersection((a1, a2), (b1, b2))
+            if 0 < a < 1 and 0 < b < 1:
+                ps.append(p)
+
+    for i in range(nb):
+        a1 = polygon_b[i - 1]
+        a2 = polygon_b[i]
+        flag = False
+        sum_s = 0
+        for j in range(na):
+            b1 = polygon_a[j - 1]
+            b2 = polygon_a[j]
+            sum_s += np.abs(GeometryPolygon([a1, b1, b2]).signed_area)
+        if np.abs(np.abs(sum_s) - np.abs(sa)) < TOLERANCE:
+            flag = True
+        if flag:
+            ps.append(a1)
+
+    def unique(ar):
+        res = []
+        for i, a in enumerate(ar):
+            if np.abs(a - ar[i - 1]).sum() > TOLERANCE:
+                res.append(a)
+
+        return res
+
+    ps = sorted(ps, key=lambda x: (x[0] + TOLERANCE * x[1]))
+    ps = unique(ps)
+
+    if len(ps) == 0:
+        return 0
+
+    tmp = ps[0]
+
+    res = []
+    res.append(tmp)
+    ps = sorted(
+        ps[1:],
+        key=lambda x: -((x - tmp) @ np.array((0, 1)) / len(x - tmp)),
+    )
+    res.extend(ps)
+
+    return GeometryPolygon(res).signed_area * sign
+
+
+def area(box):
+    if box[2] <= box[0] or box[3] <= box[1]:
+        return 0
+    return (box[2] - box[0]) * (box[3] - box[1])
+
+
+def iou(box_a, box_b):
+    box_c = intersection(box_a, box_b)
+    return area(box_c) / (area(box_a) + area(box_b) - area(box_c))
+
+
+def intersection(box_a, box_b):
+    """boxes are left, top, right, bottom where left < right and top < bottom"""
+    box_c = [
+        max(box_a[0], box_b[0]),
+        max(box_a[1], box_b[1]),
+        min(box_a[2], box_b[2]),
+        min(box_a[3], box_b[3]),
+    ]
+    return box_c
+
+
+def rectangle_intersection_area(
+    polygon_a: GeometryPolygon, polygon_b: GeometryPolygon
+) -> float:
+    minx_a, miny_a = np.min(polygon_a.points, axis=0)
+    maxx_a, maxy_a = np.max(polygon_a.points, axis=0)
+    minx_b, miny_b = np.min(polygon_b.points, axis=0)
+    maxx_b, maxy_b = np.max(polygon_b.points, axis=0)
+
+    minx_c = max(minx_a, minx_b)
+    miny_c = max(miny_a, miny_b)
+    maxx_c = min(maxx_a, maxx_b)
+    maxy_c = min(maxy_a, maxy_b)
+    return max(maxx_c - minx_c, 0) * max(maxy_c - miny_c, 0)
+
+
+def polygon_intersection_area(
+    polygon_a: GeometryPolygon, polygon_b: GeometryPolygon
+) -> float:
+    if polygon_a.is_rectangle and polygon_b.is_rectangle:
+        return rectangle_intersection_area(polygon_a, polygon_b)
+
+    na = len(polygon_a)
+    nb = len(polygon_b)
+    res = 0.0
+    for i in range(1, na - 1):
+        sa = polygon_a[[0, i, i + 1]]
+        for j in range(1, nb - 1):
+            sb = polygon_b[[0, j, j + 1]]
+            tmp = convex_polygon_intersection_area(
+                GeometryPolygon(sa), GeometryPolygon(sb)
+            )
+            res += tmp
+
+    return np.abs(res)

nucleus/metrics/metric_utils.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+
+def compute_average_precision(recall, precision):
+    """Compute the average precision, given the recall and precision curves.
+    Code originally from https://github.com/rbgirshick/py-faster-rcnn.
+    # Arguments
+        recall:    The recall curve (list).
+        precision: The precision curve (list).
+    # Returns
+        The average precision as computed in py-faster-rcnn.
+    """
+    # correct AP calculation
+    # first append sentinel values at the end
+    mrec = np.concatenate(([0.0], recall, [1.0]))
+    mpre = np.concatenate(([0.0], precision, [0.0]))
+
+    # compute the precision envelope
+    for i in range(mpre.size - 1, 0, -1):
+        mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+    # to calculate area under PR curve, look for points
+    # where X axis (recall) changes value
+    i = np.where(mrec[1:] != mrec[:-1])[0]
+
+    # and sum (\Delta recall) * prec
+    ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+    return ap

nucleus/metrics/polygon_metrics.py

@@ -0,0 +1,480 @@
+import sys
+from abc import abstractmethod
+from typing import List, Union
+
+import numpy as np
+
+from nucleus.annotation import AnnotationList, BoxAnnotation, PolygonAnnotation
+from nucleus.prediction import BoxPrediction, PolygonPrediction, PredictionList
+
+from .base import Metric, ScalarResult
+from .filters import confidence_filter, polygon_label_filter
+from .metric_utils import compute_average_precision
+from .polygon_utils import (
+    BoxOrPolygonAnnotation,
+    BoxOrPolygonPrediction,
+    get_true_false_positives_confidences,
+    group_boxes_or_polygons_by_label,
+    iou_assignments,
+    label_match_wrapper,
+    num_true_positives,
+)
+
+
+class PolygonMetric(Metric):
+    """Abstract class for metrics of box and polygons.
+
+    The PolygonMetric class automatically filters incoming annotations and
+    predictions for only box and polygon annotations. It also filters
+    predictions whose confidence is less than the provided confidence_threshold.
+    Finally, it provides support for enforcing matching labels. If
+    `enforce_label_match` is set to True, then annotations and predictions will
+    only be matched if they have the same label.
+
+    To create a new concrete PolygonMetric, override the `eval` function
+    with logic to define a metric between box/polygon annotations and predictions.
+    ::
+
+        from typing import List
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import ScalarResult, PolygonMetric
+        from nucleus.metrics.polygon_utils import BoxOrPolygonAnnotation, BoxOrPolygonPrediction
+
+        class MyPolygonMetric(PolygonMetric):
+            def eval(
+                self,
+                annotations: List[BoxOrPolygonAnnotation],
+                predictions: List[BoxOrPolygonPrediction],
+            ) -> ScalarResult:
+                value = (len(annotations) - len(predictions)) ** 2
+                weight = len(annotations)
+                return ScalarResult(value, weight)
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = MyPolygonMetric()
+        metric(annotations, predictions)
+    """
+
+    def __init__(
+        self,
+        enforce_label_match: bool = False,
+        confidence_threshold: float = 0.0,
+    ):
+        """Initializes PolygonMetric abstract object.
+
+        Args:
+            enforce_label_match: whether to enforce that annotation and prediction labels must match. Default False
+            confidence_threshold: minimum confidence threshold for predictions. Must be in [0, 1]. Default 0.0
+        """
+        self.enforce_label_match = enforce_label_match
+        assert 0 <= confidence_threshold <= 1
+        self.confidence_threshold = confidence_threshold
+
+    @abstractmethod
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        # Main evaluation function that subclasses must override.
+        pass
+
+    def aggregate_score(self, results: List[ScalarResult]) -> ScalarResult:  # type: ignore[override]
+        return ScalarResult.aggregate(results)
+
+    def __call__(
+        self, annotations: AnnotationList, predictions: PredictionList
+    ) -> ScalarResult:
+        if self.confidence_threshold > 0:
+            predictions = confidence_filter(
+                predictions, self.confidence_threshold
+            )
+        polygon_annotations: List[Union[BoxAnnotation, PolygonAnnotation]] = []
+        polygon_annotations.extend(annotations.box_annotations)
+        polygon_annotations.extend(annotations.polygon_annotations)
+        polygon_predictions: List[Union[BoxPrediction, PolygonPrediction]] = []
+        polygon_predictions.extend(predictions.box_predictions)
+        polygon_predictions.extend(predictions.polygon_predictions)
+
+        eval_fn = label_match_wrapper(self.eval)
+        result = eval_fn(
+            polygon_annotations,
+            polygon_predictions,
+            enforce_label_match=self.enforce_label_match,
+        )
+        return result
+
+
+class PolygonIOU(PolygonMetric):
+    """Calculates the average IOU between box or polygon annotations and predictions.
+    ::
+
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import PolygonIOU
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = PolygonIOU()
+        metric(annotations, predictions)
+    """
+
+    # TODO: Remove defaults once these are surfaced more cleanly to users.
+    def __init__(
+        self,
+        enforce_label_match: bool = False,
+        iou_threshold: float = 0.0,
+        confidence_threshold: float = 0.0,
+    ):
+        """Initializes PolygonIOU object.
+
+        Args:
+            enforce_label_match: whether to enforce that annotation and prediction labels must match. Defaults to False
+            iou_threshold: IOU threshold to consider detection as valid. Must be in [0, 1]. Default 0.0
+            confidence_threshold: minimum confidence threshold for predictions. Must be in [0, 1]. Default 0.0
+        """
+        assert (
+            0 <= iou_threshold <= 1
+        ), "IoU threshold must be between 0 and 1."
+        self.iou_threshold = iou_threshold
+        super().__init__(enforce_label_match, confidence_threshold)
+
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        iou_assigns = iou_assignments(
+            annotations, predictions, self.iou_threshold
+        )
+        weight = max(len(annotations), len(predictions))
+        avg_iou = iou_assigns.sum() / max(weight, sys.float_info.epsilon)
+        return ScalarResult(avg_iou, weight)
+
+
+class PolygonPrecision(PolygonMetric):
+    """Calculates the precision between box or polygon annotations and predictions.
+    ::
+
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import PolygonPrecision
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = PolygonPrecision()
+        metric(annotations, predictions)
+    """
+
+    # TODO: Remove defaults once these are surfaced more cleanly to users.
+    def __init__(
+        self,
+        enforce_label_match: bool = False,
+        iou_threshold: float = 0.5,
+        confidence_threshold: float = 0.0,
+    ):
+        """Initializes PolygonPrecision object.
+
+        Args:
+            enforce_label_match: whether to enforce that annotation and prediction labels must match. Defaults to False
+            iou_threshold: IOU threshold to consider detection as valid. Must be in [0, 1]. Default 0.5
+            confidence_threshold: minimum confidence threshold for predictions. Must be in [0, 1]. Default 0.0
+        """
+        assert (
+            0 <= iou_threshold <= 1
+        ), "IoU threshold must be between 0 and 1."
+        self.iou_threshold = iou_threshold
+        super().__init__(enforce_label_match, confidence_threshold)
+
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        true_positives = num_true_positives(
+            annotations, predictions, self.iou_threshold
+        )
+        weight = len(predictions)
+        return ScalarResult(
+            true_positives / max(weight, sys.float_info.epsilon), weight
+        )
+
+
+class PolygonRecall(PolygonMetric):
+    """Calculates the recall between box or polygon annotations and predictions.
+    ::
+
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import PolygonRecall
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = PolygonRecall()
+        metric(annotations, predictions)
+    """
+
+    # TODO: Remove defaults once these are surfaced more cleanly to users.
+    def __init__(
+        self,
+        enforce_label_match: bool = False,
+        iou_threshold: float = 0.5,
+        confidence_threshold: float = 0.0,
+    ):
+        """Initializes PolygonRecall object.
+
+        Args:
+            enforce_label_match: whether to enforce that annotation and prediction labels must match. Defaults to False
+            iou_threshold: IOU threshold to consider detection as valid. Must be in [0, 1]. Default 0.5
+            confidence_threshold: minimum confidence threshold for predictions. Must be in [0, 1]. Default 0.0
+        """
+        assert (
+            0 <= iou_threshold <= 1
+        ), "IoU threshold must be between 0 and 1."
+        self.iou_threshold = iou_threshold
+        super().__init__(enforce_label_match, confidence_threshold)
+
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        true_positives = num_true_positives(
+            annotations, predictions, self.iou_threshold
+        )
+        weight = len(annotations) + sys.float_info.epsilon
+        return ScalarResult(
+            true_positives / max(weight, sys.float_info.epsilon), weight
+        )
+
+
+class PolygonAveragePrecision(PolygonMetric):
+    """Calculates the average precision between box or polygon annotations and predictions.
+    ::
+
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import PolygonAveragePrecision
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = PolygonAveragePrecision(label="car")
+        metric(annotations, predictions)
+    """
+
+    # TODO: Remove defaults once these are surfaced more cleanly to users.
+    def __init__(
+        self,
+        label,
+        iou_threshold: float = 0.5,
+    ):
+        """Initializes PolygonRecall object.
+
+        Args:
+            iou_threshold: IOU threshold to consider detection as valid. Must be in [0, 1]. Default 0.5
+        """
+        assert (
+            0 <= iou_threshold <= 1
+        ), "IoU threshold must be between 0 and 1."
+        self.iou_threshold = iou_threshold
+        self.label = label
+        super().__init__(enforce_label_match=False, confidence_threshold=0)
+
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        annotations_filtered = polygon_label_filter(annotations, self.label)
+        predictions_filtered = polygon_label_filter(predictions, self.label)
+        (
+            true_false_positives,
+            confidences,
+        ) = get_true_false_positives_confidences(
+            annotations_filtered, predictions_filtered, self.iou_threshold
+        )
+        idxes = np.argsort(-confidences)
+        true_false_positives_sorted = true_false_positives[idxes]
+        cumulative_true_positives = np.cumsum(true_false_positives_sorted)
+        total_predictions = np.arange(1, len(true_false_positives) + 1)
+        precisions = cumulative_true_positives / total_predictions
+        recalls = cumulative_true_positives / len(annotations)
+        average_precision = compute_average_precision(precisions, recalls)
+        weight = 1
+        return ScalarResult(average_precision, weight)
+
+
+class PolygonMAP(PolygonMetric):
+    """Calculates the mean average precision between box or polygon annotations and predictions.
+    ::
+
+        from nucleus import BoxAnnotation, Point, PolygonPrediction
+        from nucleus.annotation import AnnotationList
+        from nucleus.prediction import PredictionList
+        from nucleus.metrics import PolygonMAP
+
+        box_anno = BoxAnnotation(
+            label="car",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="image_1",
+            annotation_id="image_1_car_box_1",
+            metadata={"vehicle_color": "red"}
+        )
+
+        polygon_pred = PolygonPrediction(
+            label="bus",
+            vertices=[Point(100, 100), Point(150, 200), Point(200, 100)],
+            reference_id="image_2",
+            annotation_id="image_2_bus_polygon_1",
+            confidence=0.8,
+            metadata={"vehicle_color": "yellow"}
+        )
+
+        annotations = AnnotationList(box_annotations=[box_anno])
+        predictions = PredictionList(polygon_predictions=[polygon_pred])
+        metric = PolygonMAP()
+        metric(annotations, predictions)
+    """
+
+    # TODO: Remove defaults once these are surfaced more cleanly to users.
+    def __init__(
+        self,
+        iou_threshold: float = 0.5,
+    ):
+        """Initializes PolygonRecall object.
+
+        Args:
+            iou_threshold: IOU threshold to consider detection as valid. Must be in [0, 1]. Default 0.5
+        """
+        assert (
+            0 <= iou_threshold <= 1
+        ), "IoU threshold must be between 0 and 1."
+        self.iou_threshold = iou_threshold
+        super().__init__(enforce_label_match=False, confidence_threshold=0)
+
+    def eval(
+        self,
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+    ) -> ScalarResult:
+        grouped_inputs = group_boxes_or_polygons_by_label(
+            annotations, predictions
+        )
+        results: List[ScalarResult] = []
+        for label, group in grouped_inputs.items():
+            annotations_group, predictions_group = group
+            metric = PolygonAveragePrecision(label)
+            result = metric.eval(annotations_group, predictions_group)
+            results.append(result)
+        average_result = ScalarResult.aggregate(results)
+        return average_result