scorevision: push artifact

miner.py

@@ -410,14 +410,17 @@ class Miner:
 
     def _predict_single(self, image: np.ndarray) -> list[BoundingBox]:
         (boxes, scores, cls_ids), (fb_b, fb_s, fb_c) = self._forward_with_fallback(image)
+        ih, iw = image.shape[:2]
         if len(boxes) > 0:
-            return self._build_results(boxes, scores, cls_ids)
+            return self._build_results(boxes, scores, cls_ids, image_size=(iw, ih))
         # FALLBACK: nothing passed conf_thres — return single top-conf box
         # (any class, any conf > 0) so the validator's mAP isn't a hard zero.
         if len(fb_b) == 0:
             return []
         i = int(np.argmax(fb_s))
-        return self._build_results(fb_b[i:i + 1], fb_s[i:i + 1], fb_c[i:i + 1])
+        return self._build_results(
+            fb_b[i:i + 1], fb_s[i:i + 1], fb_c[i:i + 1], image_size=(iw, ih)
+        )
 
     def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
         """Hflip TTA: merge primary + flipped via per-class hard-NMS,
@@ -457,11 +460,99 @@ class Miner:
         if len(boxes) == 0:
             return []
 
-        return self._build_results(boxes, scores, cls_ids)
+        ih, iw = image.shape[:2]
+        return self._build_results(boxes, scores, cls_ids, image_size=(iw, ih))
+
+    def _filter_balaclava_geometry(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        image_size: tuple[int, int] | None = None,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        # Real-balaclava prior (from 43 manual GT labels):
+        #   aspect ratio max(w/h, h/w):  p5=1.11, median=1.33, p99=1.71
+        #   rel area % of image:         p1=0.041, p5=0.070, p10=0.087
+        # FP balaclavas frequently violate these (very thin/wide boxes from
+        # face-fragment matches, or tiny ~0.01%-area boxes from texture noise).
+        BALACLAVA = 0
+        ASPECT_MAX = 1.8     # above p99 of real
+        REL_AREA_MIN = 0.0004  # below p1 of real (0.04%)
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        is_bal = cls_ids == BALACLAVA
+        if not is_bal.any():
+            return boxes, scores, cls_ids
+        keep = np.ones(len(boxes), dtype=bool)
+        if image_size is not None:
+            iw, ih = image_size
+            img_area = max(1.0, iw * ih)
+        else:
+            img_area = None
+        for i in np.where(is_bal)[0]:
+            x1, y1, x2, y2 = boxes[i]
+            bw = max(1.0, x2 - x1)
+            bh = max(1.0, y2 - y1)
+            aspect = max(bw / bh, bh / bw)
+            if aspect > ASPECT_MAX:
+                keep[i] = False
+                continue
+            if img_area is not None:
+                rel = (bw * bh) / img_area
+                if rel < REL_AREA_MIN:
+                    keep[i] = False
+        return boxes[keep], scores[keep], cls_ids[keep]
+
+    def _suppress_balaclava_under_hoodie(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        # Validator rule: "balaclavas worn under a hoodie hood are IGNORED
+        # (a hoodie includes the jacket and its hood)". A small balaclava
+        # box can sit fully inside a much larger hoodie box — IoU between
+        # them stays low (intersection / large union), but containment
+        # (intersection / balaclava_area) is ~1.0. So drop any balaclava
+        # whose containment by any hoodie box is >= COVER_THRESH.
+        BALACLAVA, HOODIE = 0, 1
+        COVER_THRESH = 0.5
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        is_hood = cls_ids == HOODIE
+        is_bal  = cls_ids == BALACLAVA
+        if not is_hood.any() or not is_bal.any():
+            return boxes, scores, cls_ids
+        hood_boxes = boxes[is_hood]
+        keep = np.ones(len(boxes), dtype=bool)
+        for i in np.where(is_bal)[0]:
+            bx1, by1, bx2, by2 = boxes[i]
+            bal_area = max(1.0, (bx2 - bx1) * (by2 - by1))
+            ix1 = np.maximum(bx1, hood_boxes[:, 0])
+            iy1 = np.maximum(by1, hood_boxes[:, 1])
+            ix2 = np.minimum(bx2, hood_boxes[:, 2])
+            iy2 = np.minimum(by2, hood_boxes[:, 3])
+            iw = np.clip(ix2 - ix1, 0.0, None)
+            ih = np.clip(iy2 - iy1, 0.0, None)
+            inter = iw * ih
+            cover = inter / bal_area
+            if (cover >= COVER_THRESH).any():
+                keep[i] = False
+        return boxes[keep], scores[keep], cls_ids[keep]
 
     def _build_results(
-        self, boxes: np.ndarray, scores: np.ndarray, cls_ids: np.ndarray
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        image_size: tuple[int, int] | None = None,
     ) -> list[BoundingBox]:
+        boxes, scores, cls_ids = self._filter_balaclava_geometry(
+            boxes, scores, cls_ids, image_size
+        )
+        boxes, scores, cls_ids = self._suppress_balaclava_under_hoodie(
+            boxes, scores, cls_ids
+        )
         results: list[BoundingBox] = []
         for box, conf, cls_id in zip(boxes, scores, cls_ids):
             x1, y1, x2, y2 = box.tolist()