mblt-vision-python 0.0.1__tar.gz → 0.0.2__tar.gz

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mblt-vision-python
-Version: 0.0.1
+Version: 0.0.2
 Summary: Mobilint NPU vision models: classification, detection, segmentation, pose
 Author: Mobilint
 License: BSD-3-Clause

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/__init__.py

@@ -19,7 +19,7 @@ from ._api import list_models as list_models
 from ._api import list_tasks as list_tasks
 from .wrapper import MBLT_Engine as MBLT_Engine
 
-__version__ = "0.0.1"
+__version__ = "0.0.2"
 
 _TASK_MODULES = (
     face_detection,

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/cli/val.py

@@ -439,10 +439,9 @@ def _run_validation(args: argparse.Namespace) -> float:
             )
             print(
                 "Validation score "
-                f"(Easy AP): {widerface_result.easy_ap:.5f}, "
-                f"(Medium AP): {widerface_result.medium_ap:.5f}, "
-                f"(Hard AP): {widerface_result.hard_ap:.5f}, "
-                f"(Mean AP): {widerface_result.mean_ap:.5f}"
+                f"(Hard AP, primary): {widerface_result.hard_ap:.5f}, "
+                f"(Medium AP, secondary): {widerface_result.medium_ap:.5f}, "
+                f"(Easy AP, secondary): {widerface_result.easy_ap:.5f}"
             )
             return widerface_result.primary_score
 

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/evaluation/eval_nyu_depth.py

@@ -31,27 +31,33 @@ class NYUDepthResult:
 
     @property
     def secondary_score(self) -> float:
-        """Return the secondary NYU Depth validation metric."""
+        """Return abs_rel for singular-score compatibility."""
 
         return self.abs_rel
 
+    @property
+    def secondary_scores(self) -> tuple[float, float]:
+        """Return abs_rel and RMSE in secondary-metric order."""
+
+        return self.abs_rel, self.rmse
+
 
 class NYUDepthMetricAccumulator:
-    """Accumulate median-aligned metrics over every valid NYU depth pixel."""
+    """Accumulate median-aligned metrics with equal weight for each image."""
 
     MIN_DEPTH = 0.001
     MAX_DEPTH = 100.0
 
     def __init__(self) -> None:
-        """Initialize zero-valued pixel sums."""
+        """Initialize zero-valued per-image metric sums."""
 
         self.delta1_sum = 0.0
         self.abs_rel_sum = 0.0
-        self.squared_error_sum = 0.0
-        self.valid_pixel_count = 0
+        self.rmse_sum = 0.0
+        self.valid_sample_count = 0
 
     def update(self, prediction: np.ndarray, target: np.ndarray) -> None:
-        """Median-align one prediction and add its valid-pixel statistics."""
+        """Median-align one prediction and add its per-image metric values."""
 
         prediction = _as_real_float32(prediction, "prediction")
         target = _as_real_float32(target, "target")
@@ -66,8 +72,7 @@ class NYUDepthMetricAccumulator:
         valid = (
             np.isfinite(target) & (target > self.MIN_DEPTH) & (target < self.MAX_DEPTH)
         )
-        valid_pixel_count = int(valid.sum())
-        if valid_pixel_count == 0:
+        if not valid.any():
             raise ValueError(
                 "NYU Depth sample has no valid pixels in the (0.001, 100.0) range."
             )
@@ -83,20 +88,22 @@ class NYUDepthMetricAccumulator:
         aligned = predicted * (median_target / median_prediction)
         aligned = np.clip(aligned, self.MIN_DEPTH, self.MAX_DEPTH)
         ratio = np.maximum(actual / aligned, aligned / actual)
-        self.delta1_sum += float(np.sum(ratio < 1.25))
-        self.abs_rel_sum += float(np.sum(np.abs(actual - aligned) / actual))
-        self.squared_error_sum += float(np.sum((actual - aligned) ** 2))
-        self.valid_pixel_count += valid_pixel_count
+        # Match Ultralytics' depth validator: median-align and calculate all
+        # metrics per image, then average validation images equally.
+        self.delta1_sum += float(np.mean(ratio < 1.25))
+        self.abs_rel_sum += float(np.mean(np.abs(actual - aligned) / actual))
+        self.rmse_sum += float(np.sqrt(np.mean((actual - aligned) ** 2)))
+        self.valid_sample_count += 1
 
     def result(self) -> NYUDepthResult:
-        """Return metrics pooled over all accumulated valid pixels."""
+        """Return mean per-image metrics."""
 
-        if self.valid_pixel_count == 0:
+        if self.valid_sample_count == 0:
             raise ValueError("NYU Depth evaluation received no valid pixels.")
         return NYUDepthResult(
-            delta1=self.delta1_sum / self.valid_pixel_count,
-            abs_rel=self.abs_rel_sum / self.valid_pixel_count,
-            rmse=float(np.sqrt(self.squared_error_sum / self.valid_pixel_count)),
+            delta1=self.delta1_sum / self.valid_sample_count,
+            abs_rel=self.abs_rel_sum / self.valid_sample_count,
+            rmse=self.rmse_sum / self.valid_sample_count,
         )
 
 
@@ -116,7 +123,7 @@ def _as_real_float32(values: np.ndarray, name: str) -> np.ndarray:
 def calculate_nyu_depth_metrics(
     prediction: np.ndarray, target: np.ndarray
 ) -> NYUDepthResult:
-    """Calculate official pooled metrics for one median-aligned NYU sample."""
+    """Calculate median-aligned NYU metrics for one sample."""
 
     accumulator = NYUDepthMetricAccumulator()
     accumulator.update(prediction, target)

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/evaluation/eval_widerface.py

@@ -34,22 +34,22 @@ class WiderFaceResult(NamedTuple):
     hard_ap: float
 
     @property
-    def mean_ap(self) -> float:
-        """Return the mean AP across Easy, Medium, and Hard."""
+    def primary_score(self) -> float:
+        """Return Hard-set AP as the primary WiderFace metric."""
 
-        return (self.easy_ap + self.medium_ap + self.hard_ap) / 3.0
+        return self.hard_ap
 
     @property
-    def primary_score(self) -> float:
-        """Return mean AP across the three validation splits."""
+    def secondary_score(self) -> float:
+        """Return Medium-set AP for singular-score compatibility."""
 
-        return self.mean_ap
+        return self.medium_ap
 
     @property
-    def secondary_score(self) -> float:
-        """Return Hard-set AP."""
+    def secondary_scores(self) -> tuple[float, float]:
+        """Return Medium- and Easy-set AP in secondary-metric order."""
 
-        return self.hard_ap
+        return self.medium_ap, self.easy_ap
 
 
 def _empty_prediction() -> np.ndarray:

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/base.py

@@ -195,7 +195,7 @@ class YOLODetectionPostBase(PostBase):
         conf_thres: float | None = None,
         iou_thres: float | None = None,
         multi_label: bool = False,
-    ) -> list[Any]:
+    ) -> Any:
         """Executes YOLO postprocessing.
 
         Includes rearranging, decoding, and NMS.
@@ -214,6 +214,10 @@ class YOLODetectionPostBase(PostBase):
         final_detections, proto_outs = self.extract_final_outputs(x)
         if final_detections is not None:
             if proto_outs is not None:
+                if not isinstance(final_detections, list):
+                    raise TypeError(
+                        "Mask prototypes require detections as a per-image list."
+                    )
                 return self.masking(final_detections, proto_outs)
             return final_detections
         checked_input = self.check_input(x)
@@ -291,7 +295,7 @@ class YOLODetectionPostBase(PostBase):
     def extract_final_outputs(
         self,
         x: TensorLike | ListTensorLike,
-    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+    ) -> tuple[list[torch.Tensor] | torch.Tensor | None, torch.Tensor | None]:
         """Extract already-decoded ONNX-style detections when present.
 
         Args:

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_anchor_post.py

@@ -99,15 +99,35 @@ class YOLOAnchorDetectionPost(YOLODetectionPostBase):
                 ``(batch, anchors, no)`` format, optionally paired with prototype masks in
                 segmentation subclasses.
         """
-        if len(x) != self.nl:
-            raise ValueError(f"Expected {self.nl} detection heads, got {len(x)}.")
+        # Decode-enabled MXQ artifacts prepend their already-decoded
+        # ``(batch, anchors, features)`` output to the raw detection heads.
+        # Only raw heads participate in anchor-grid decoding.
+        heads = [
+            tmp
+            for tmp in x
+            if (tmp.ndim == 4 and tmp.shape[3] == self.no * self.na)
+            or (tmp.ndim == 5 and tmp.shape[1] == self.na and tmp.shape[-1] == self.no)
+        ]
+        if len(heads) != self.nl:
+            shapes = ", ".join(str(tuple(tmp.shape)) for tmp in x)
+            raise ValueError(
+                f"Expected {self.nl} raw detection heads, got {len(heads)} "
+                f"from outputs: {shapes}."
+            )
         y = []
-        for i in range(self.nl):
-            tmp = x[i]
-            if tmp.shape[3] == self.no * self.na:
+        for tmp in heads:
+            if tmp.ndim == 4 and tmp.shape[3] == self.no * self.na:
                 y.append(
                     tmp.permute(0, 3, 1, 2)
                 )  # (b, 80, 80, 255) -> (b, 255, 80, 80)
+            elif tmp.ndim == 5 and tmp.shape[1] == self.na and tmp.shape[-1] == self.no:
+                # WongKinYiu YOLOv7 ONNX exports each head as
+                # (batch, anchors, height, width, features).
+                y.append(
+                    tmp.permute(0, 1, 4, 2, 3).reshape(
+                        tmp.shape[0], self.na * self.no, tmp.shape[2], tmp.shape[3]
+                    )
+                )
             else:
                 raise NotImplementedError(
                     f"Got unsupported shape for input: {tmp.shape}."

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_anchorless_post.py

@@ -9,6 +9,7 @@ from typing import Literal
 
 import torch
 
+from ..types import ListTensorLike, TensorLike
 from .base import YOLODetectionPostBase
 from .common import (
     YOLOOBBPostMixin,
@@ -563,6 +564,62 @@ class YOLOAnchorlessSegPost(YOLOSegPostMixin, YOLOAnchorlessDetectionPost):
 class YOLOAnchorlessPosePost(YOLOPosePostMixin, YOLOAnchorlessDetectionPost):
     """Postprocessing for YOLO pose estimation models without anchors."""
 
+    def extract_final_outputs(
+        self, x: TensorLike | ListTensorLike
+    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+        """Accept QBCompiler's decode-enabled candidate-first pose output.
+
+        Decode-enabled MXQs emit ``(B, anchors, 5 + keypoints)`` containing
+        ``xywh`` boxes, confidence, and decoded keypoint coordinates. Add the
+        single-class label column and convert the boxes once. QBCompiler leaves
+        visibility as near-zero logits in this layout, so normalize them as the
+        split-head pose decoder does.
+        """
+        if self.e2e and isinstance(x, (list, tuple)) and len(x) == 1:
+            value = x[0]
+            if isinstance(value, torch.Tensor):
+                tensor = value
+            else:
+                try:
+                    tensor = torch.as_tensor(value)
+                except (TypeError, ValueError):
+                    tensor = None
+            expected_dim = 5 + self.n_extra
+            if (
+                tensor is not None
+                and tensor.ndim == 3
+                and tensor.shape[-1] == expected_dim
+                # P6 decode-enabled artifacts do not preserve a valid
+                # keypoint-to-candidate association. Fall back to the legacy
+                # path (boxes only) rather than draw misleading skeletons.
+                and self.nl != 4
+            ):
+                labels = torch.zeros_like(tensor[..., :1])
+                boxes = tensor[..., :4].clone()
+                boxes[..., :2] -= boxes[..., 2:] / 2
+                boxes[..., 2:] += boxes[..., :2]
+                keypoints = tensor[..., 5:].reshape(*tensor.shape[:2], -1, 3).clone()
+                if not bool(torch.isfinite(keypoints[..., 2]).all()):
+                    raise ValueError("Decoded pose visibility logits must be finite.")
+                keypoints[..., 2] = keypoints[..., 2].sigmoid()
+                detections = torch.cat(
+                    (boxes, tensor[..., 4:5], labels, keypoints.flatten(2)), dim=-1
+                )
+                # Final-output extraction normally bypasses ``nms``.  These
+                # compiler candidates are dense, so retain the standard
+                # confidence-sorted NMS step before rendering pose skeletons.
+                retained_batches = self._final_detection_batches(detections)
+                selected_batches = []
+                for batch in retained_batches:
+                    order = torch.argsort(batch[:, 4], descending=True)
+                    ordered = batch[order]
+                    keep = non_max_suppression(
+                        ordered[:, :4], ordered[:, 4], self.iou_thres, max_output=300
+                    )
+                    selected_batches.append(ordered[keep])
+                return selected_batches, None
+        return super().extract_final_outputs(x)
+
     def rearrange(self, x: list[torch.Tensor]) -> torch.Tensor:
         """Rearranges model output tensors for pose estimation tasks.
 

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_dflfree_post.py

@@ -4,6 +4,7 @@ from typing import Any, cast
 
 import torch
 
+from ..types import ListTensorLike, TensorLike
 from .base import YOLODetectionPostBase
 from .common import (
     YOLOOBBPostMixin,
@@ -14,6 +15,7 @@ from .common import (
     dist2bbox,
     dist2rbox,
     dual_topk,
+    non_max_suppression,
     rotated_nms,
     yolo_multilabel_candidates,
 )
@@ -554,6 +556,41 @@ class YOLODFLFreeSegPost(YOLOSegPostMixin, YOLODFLFreeDetectionPost):
 class YOLODFLFreePosePost(YOLOPosePostMixin, YOLODFLFreeDetectionPost):
     """Postprocessing for YOLO NMS-free pose estimation models."""
 
+    def extract_final_outputs(
+        self, x: TensorLike | ListTensorLike
+    ) -> tuple[list[torch.Tensor] | None, torch.Tensor | None]:
+        """Accept YOLO26's decode-enabled score, xyxy, and keypoint outputs."""
+        if self.e2e and isinstance(x, (list, tuple)) and len(x) == 4:
+            tensors = [
+                value if isinstance(value, torch.Tensor) else torch.as_tensor(value)
+                for value in x
+            ]
+            converted_parts = self._collect_converted_parts(tensors, require_extra=True)
+            if converted_parts is not None:
+                converted, _ = converted_parts
+                boxes = converted[..., :4]
+                scores = converted[..., 4 : 4 + self.nc]
+                keypoints = converted[..., 4 + self.nc :]
+                keypoints = keypoints.reshape(*keypoints.shape[:2], -1, 3).clone()
+                if not bool(torch.isfinite(keypoints[..., 2]).all()):
+                    raise ValueError("Decoded pose visibility logits must be finite.")
+                keypoints[..., 2] = keypoints[..., 2].sigmoid()
+                labels = torch.zeros_like(scores)
+                detections = torch.cat(
+                    (boxes, scores, labels, keypoints.flatten(2)), dim=-1
+                )
+                retained_batches = self._final_detection_batches(detections)
+                selected_batches = []
+                for batch in retained_batches:
+                    order = torch.argsort(batch[:, 4], descending=True)
+                    ordered = batch[order]
+                    keep = non_max_suppression(
+                        ordered[:, :4], ordered[:, 4], self.iou_thres, max_output=300
+                    )
+                    selected_batches.append(ordered[keep])
+                return selected_batches, None
+        return super().extract_final_outputs(x)
+
     def non_e2e(self, x: list[torch.Tensor]) -> torch.Tensor | list[torch.Tensor]:
         """Return export-style pose outputs for both converted and raw split heads."""
 

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision/utils/postprocess/yolo_nmsfree_post.py

@@ -4,8 +4,10 @@ YOLO NMS-free postprocessing.
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import Any, cast
 
+import numpy as np
 import torch
 
 from .common import dist2bbox, dual_topk
@@ -17,6 +19,101 @@ class YOLONMSFreeDetectionPost(YOLOAnchorlessDetectionPost):
 
     max_det = 300
 
+    def _decoded_output_triplet(
+        self, x: Any
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor] | None:
+        """Return QBCompiler's ordered decoded class, confidence, and box outputs."""
+        if not isinstance(x, Sequence) or len(x) != 3:
+            return None
+        tensors = [
+            value if isinstance(value, torch.Tensor) else torch.as_tensor(value)
+            for value in x
+            if isinstance(value, (np.ndarray, torch.Tensor))
+        ]
+        if len(tensors) != 3:
+            return None
+        classes, confidence, boxes = tensors
+        if not (
+            classes.ndim == confidence.ndim == boxes.ndim == 3
+            and classes.shape[-1] == self.nc
+            and confidence.shape[-1] == 1
+            and boxes.shape[-1] == 4
+            and classes.shape[:2] == confidence.shape[:2] == boxes.shape[:2]
+        ):
+            return None
+        if not bool(torch.isfinite(classes).all()):
+            raise ValueError("Decoded YOLOv10 class probabilities must be finite.")
+        if not bool(((classes >= 0) & (classes <= 1)).all()):
+            raise ValueError("Decoded YOLOv10 class probabilities must be in [0, 1].")
+        if not bool(torch.isfinite(confidence).all()):
+            raise ValueError("Decoded YOLOv10 confidence values must be finite.")
+        if not bool(((confidence >= 0) & (confidence <= 1)).all()):
+            raise ValueError("Decoded YOLOv10 confidence values must be in [0, 1].")
+        if not bool(torch.isfinite(boxes).all()):
+            raise ValueError("Decoded YOLOv10 boxes must be finite.")
+        return classes, confidence, boxes
+
+    def extract_final_outputs(
+        self, x: Any
+    ) -> tuple[list[torch.Tensor] | torch.Tensor | None, torch.Tensor | None]:
+        """Accept QBCompiler's decode-enabled YOLOv10 output triplet.
+
+        The compiler emits class probabilities, the selected confidence, and
+        ``xyxy`` boxes separately as ``(B, A, C)``, ``(B, A, 1)``, and
+        ``(B, A, 4)``.  They are already decoded, but are not a conventional
+        six-column detection tensor, so normalize them before raw-head logic
+        sees the auxiliary tensors.
+        """
+        decoded = self._decoded_output_triplet(x)
+        if decoded is not None:
+            classes, confidence, boxes = decoded
+            batches = self._decoded_output_batches(classes, confidence, boxes)
+            if not self.e2e:
+                return self._stack_topk_outputs(batches), None
+            return batches, None
+        return super().extract_final_outputs(x)
+
+    def _decoded_output_batches(
+        self,
+        classes: torch.Tensor,
+        confidence: torch.Tensor,
+        boxes: torch.Tensor,
+    ) -> list[torch.Tensor]:
+        """Normalize a decoded triplet to filtered per-image detection rows."""
+
+        if self.nc == 1:
+            labels = torch.zeros_like(confidence)
+            detections = torch.cat((boxes, confidence, labels), dim=-1)
+            return [
+                batch[torch.argsort(batch[:, 4], descending=True)[: self.max_det]]
+                for batch in self._final_detection_batches(detections)
+            ]
+
+        candidate_mask = classes.amax(dim=-1) > self.conf_thres
+        candidate_boxes = boxes[candidate_mask]
+        if candidate_boxes.numel() and not bool(
+            (
+                (candidate_boxes[:, 2] > candidate_boxes[:, 0])
+                & (candidate_boxes[:, 3] > candidate_boxes[:, 1])
+            ).all()
+        ):
+            raise ValueError(
+                "Decoded YOLOv10 boxes must have positive xyxy area after "
+                "confidence filtering."
+            )
+        return [
+            self._final_detection_batches(
+                dual_topk(
+                    torch.cat((batch_boxes, batch_classes), dim=-1),
+                    self.nc,
+                    self.n_extra,
+                    max_det=self.max_det,
+                    conf_thres=self.conf_thres,
+                ).unsqueeze(0)
+            )[0]
+            for batch_classes, batch_boxes in zip(classes, boxes)
+        ]
+
     def non_e2e(self, x: list[torch.Tensor]) -> torch.Tensor:
         """Return the export-style output tensor for NMS-free YOLO models."""
         if len(x) == 2:

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/mblt_vision_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mblt-vision-python
-Version: 0.0.1
+Version: 0.0.2
 Summary: Mobilint NPU vision models: classification, detection, segmentation, pose
 Author: Mobilint
 License: BSD-3-Clause

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/tests/test_benchmark_vision.py

@@ -16,6 +16,7 @@ from mblt_vision.utils.evaluation import (
     ImageNetResult,
     NYUDepthResult,
     SemanticSegmentationResult,
+    WiderFaceResult,
 )
 
 
@@ -160,6 +161,39 @@ def test_benchmark_accepts_obb_model_task(
     assert metrics == {"map50_95": 0.5, "map50": 0.7}
 
 
+def test_benchmark_ranks_widerface_by_hard_ap(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    """Record Hard AP as primary while retaining Medium and Easy AP."""
+
+    class FakeModel:
+        post_cfg = {"task": "face_detection", "dataset": "widerface"}
+
+    import mblt_vision.utils.evaluation as evaluation_module
+
+    monkeypatch.setattr(
+        evaluation_module,
+        "eval_widerface",
+        lambda *args, **kwargs: WiderFaceResult(
+            easy_ap=0.8, medium_ap=0.7, hard_ap=0.6
+        ),
+    )
+    args = argparse.Namespace(
+        task="face_detection",
+        data_path=str(tmp_path),
+        batch_size=1,
+        conf_thres=None,
+        iou_thres=None,
+    )
+
+    score, score_name, metrics = benchmark_vision_models._evaluate(
+        FakeModel(), args, tmp_path
+    )
+
+    assert (score, score_name) == (0.6, "hard_ap")
+    assert metrics == {"easy_ap": 0.8, "medium_ap": 0.7, "hard_ap": 0.6}
+
+
 def test_benchmark_continues_after_evaluator_type_error(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path
 ) -> None:

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/tests/test_eval_nyu_depth.py

@@ -68,6 +68,18 @@ def test_nyu_depth_metrics_reject_nonreal_or_nonnumeric_inputs(dtype: np.dtype)
         eval_nyu_depth_module.calculate_nyu_depth_metrics(values, values)
 
 
+def test_nyu_depth_metrics_average_rmse_per_image() -> None:
+    """Match Ultralytics' equal-weighted, median-aligned depth metrics."""
+
+    accumulator = eval_nyu_depth_module.NYUDepthMetricAccumulator()
+    accumulator.update(np.array([1.0, 4.0]), np.array([1.0, 2.0]))
+    accumulator.update(np.array([1.0, 2.0, 3.0, 8.0]), np.array([1.0, 2.0, 3.0, 4.0]))
+
+    result = accumulator.result()
+    assert np.isclose(result.rmse, 1.2)
+    assert result.secondary_scores == (result.abs_rel, result.rmse)
+
+
 def test_nyu_depth_evaluation_rejects_wrong_model_taxonomy() -> None:
     """Require the model's declared depth taxonomy before loading a dataset."""
 

{mblt_vision_python-0.0.1 → mblt_vision_python-0.0.2}/tests/test_eval_widerface.py

@@ -14,6 +14,16 @@ eval_widerface_module = importlib.import_module(
 )
 
 
+def test_widerface_result_uses_hard_ap_as_primary() -> None:
+    """Rank by Hard AP and retain Medium then Easy as secondary metrics."""
+
+    result = eval_widerface_module.WiderFaceResult(0.8, 0.7, 0.6)
+
+    assert result.primary_score == 0.6
+    assert result.secondary_score == 0.7
+    assert result.secondary_scores == (0.7, 0.8)
+
+
 def test_widerface_evaluation_rejects_wrong_model_taxonomy() -> None:
     """Do not evaluate another detector taxonomy using WiderFace metadata."""