scorevision: push artifact

miner.py

@@ -98,11 +98,24 @@ class Miner:
         self.input_height = self._safe_dim(self.input_shape[2], default=1280)
         self.input_width = self._safe_dim(self.input_shape[3], default=1280)
 
-        self.conf_thres = 0.20
+        # Tuned on local benchmark vs rival-proxy GT (5/2/2026):
+        # V3 = consensus filter + hflip TTA. Multi-scale, cross-class tighter,
+        # strict-consensus-across-multi-views all tested and either hurt or
+        # matched. V3 is the local optimum.
+        self.conf_thres = 0.40
         self.iou_thres = 0.5
         self.cross_iou_thresh = 0.7
         self.max_det = 300
         self.use_tta = True
+        # Consensus TTA — our edge. None of the top miners (5FBnd/5CiAr/5CtY4)
+        # do this; they keep all-view union and only boost cluster scores.
+        self.use_consensus_tta = True
+        self.consensus_iou = 0.5
+        self.require_strict_consensus = False
+        # Multi-scale tested + abandoned: it loosened consensus and hurt FP
+        # suppression more than it helped recall on rival-proxy GT.
+        self.use_multi_scale_tta = False
+        self.tta_scale = 0.85
 
         # Sanity filter — reject obviously bad boxes
         self.min_box_area = 6 * 6
@@ -387,12 +400,40 @@ class Miner:
             return []
         return self._build_results(boxes, scores, cls_ids)
 
+    def _forward_scaled(self, image: np.ndarray, scale: float):
+        """Forward pass on a scale-augmented image; transform boxes back to original coords."""
+        if scale == 1.0:
+            return self._forward(image)
+        h, w = image.shape[:2]
+        nh, nw = int(round(h * scale)), int(round(w * scale))
+        scaled = cv2.resize(image, (nw, nh), interpolation=cv2.INTER_CUBIC if scale > 1.0 else cv2.INTER_LINEAR)
+        b, s, c = self._forward(scaled)
+        if len(b):
+            b = b / scale  # scale boxes back to original image coords
+            b = self._clip_boxes(b, (w, h))
+        return b, s, c
+
     def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
-        """Hflip TTA: merge primary + flipped via per-class hard-NMS,
-        then cross-class dedup, with consensus-confidence boost."""
+        """Multi-view TTA with consensus filter.
+
+        Views (configurable):
+          v1 = primary forward (1.0x)
+          v2 = horizontal flip
+          v3 = downscaled forward (tta_scale, e.g. 0.85x) — catches small objects
+
+        Consensus filter (use_consensus_tta=True):
+          A box from v1 is kept iff it is confirmed by ≥1 OTHER view (v2 or v3)
+          at IoU >= consensus_iou with same class. Score = max across confirming
+          views. None of the top miners do this — this is our edge.
+
+        Merge (use_consensus_tta=False, fallback): union all views, per-class
+        hard-NMS, max-score boost on clusters.
+        """
         ow = image.shape[1]
+        # v1: primary
         b1, s1, c1 = self._forward(image)
 
+        # v2: hflip
         flipped = cv2.flip(image, 1)
         b2, s2, c2 = self._forward(flipped)
         if len(b2):
@@ -400,19 +441,87 @@ class Miner:
             x2f = ow - b2[:, 0]
             b2 = np.stack([x1f, b2[:, 1], x2f, b2[:, 3]], axis=1)
 
-        if len(b1) == 0 and len(b2) == 0:
+        # v3: multi-scale (0.85x)
+        if self.use_multi_scale_tta:
+            b3, s3, c3 = self._forward_scaled(image, self.tta_scale)
+        else:
+            b3 = np.empty((0, 4), dtype=np.float32)
+            s3 = np.empty((0,), dtype=np.float32)
+            c3 = np.empty((0,), dtype=np.int32)
+
+        if len(b1) == 0 and len(b2) == 0 and len(b3) == 0:
             return []
 
-        boxes = np.concatenate([b1, b2], axis=0) if len(b2) else b1
-        scores = np.concatenate([s1, s2], axis=0) if len(b2) else s1
-        cls_ids = np.concatenate([c1, c2], axis=0) if len(b2) else c1
+        if self.use_consensus_tta:
+            if len(b1) == 0:
+                return []
+            # Per-view best-IoU helper.
+            def best_iou_match(box, cls, vb, vc, vs):
+                if len(vb) == 0:
+                    return 0.0, 0.0
+                same_cls = vc == cls
+                if not same_cls.any():
+                    return 0.0, 0.0
+                xx1 = np.maximum(box[0], vb[:, 0])
+                yy1 = np.maximum(box[1], vb[:, 1])
+                xx2 = np.minimum(box[2], vb[:, 2])
+                yy2 = np.minimum(box[3], vb[:, 3])
+                inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+                a_i = (box[2] - box[0]) * (box[3] - box[1])
+                a_j = (vb[:, 2] - vb[:, 0]) * (vb[:, 3] - vb[:, 1])
+                ious = inter / (a_i + a_j - inter + 1e-7)
+                ious = np.where(same_cls, ious, 0.0)
+                idx = int(ious.argmax())
+                return float(ious[idx]), float(vs[idx])
+
+            keep_b = []; keep_s = []; keep_c = []
+            for i in range(len(b1)):
+                iou_h, sc_h = best_iou_match(b1[i], c1[i], b2, c2, s2)
+                iou_m, sc_m = best_iou_match(b1[i], c1[i], b3, c3, s3) if len(b3) else (0.0, 0.0)
+                if self.require_strict_consensus and self.use_multi_scale_tta:
+                    # Both hflip AND multi-scale must confirm.
+                    if iou_h >= self.consensus_iou and iou_m >= self.consensus_iou:
+                        keep_b.append(b1[i]); keep_c.append(c1[i])
+                        keep_s.append(max(float(s1[i]), sc_h, sc_m))
+                else:
+                    # ANY one other view confirming is enough.
+                    if max(iou_h, iou_m) >= self.consensus_iou:
+                        keep_b.append(b1[i]); keep_c.append(c1[i])
+                        # Score = max across confirming views.
+                        partners = [float(s1[i])]
+                        if iou_h >= self.consensus_iou: partners.append(sc_h)
+                        if iou_m >= self.consensus_iou: partners.append(sc_m)
+                        keep_s.append(max(partners))
+            if not keep_b:
+                return []
+            boxes = np.asarray(keep_b, dtype=np.float32)
+            scores = np.asarray(keep_s, dtype=np.float32)
+            cls_ids = np.asarray(keep_c, dtype=np.int32)
+            keep = self._per_class_hard_nms(boxes, scores, cls_ids, self.iou_thres)
+            if len(keep) == 0:
+                return []
+            keep = keep[: self.max_det]
+            boxes = boxes[keep]
+            scores = scores[keep]
+            cls_ids = cls_ids[keep]
+            boxes, scores, cls_ids = self._cross_class_dedup(
+                boxes, scores, cls_ids, self.cross_iou_thresh
+            )
+            return self._build_results(boxes, scores, cls_ids)
+
+        # Merge mode (fallback): union all available views.
+        parts_b = [b1] + ([b2] if len(b2) else []) + ([b3] if len(b3) else [])
+        parts_s = [s1] + ([s2] if len(b2) else []) + ([s3] if len(b3) else [])
+        parts_c = [c1] + ([c2] if len(b2) else []) + ([c3] if len(b3) else [])
+        boxes = np.concatenate(parts_b, axis=0) if len(parts_b) > 1 else b1
+        scores = np.concatenate(parts_s, axis=0) if len(parts_s) > 1 else s1
+        cls_ids = np.concatenate(parts_c, axis=0) if len(parts_c) > 1 else c1
 
         keep = self._per_class_hard_nms(boxes, scores, cls_ids, self.iou_thres)
         if len(keep) == 0:
             return []
         keep = keep[: self.max_det]
 
-        # Consensus-confidence boost: cluster by IoU and take max score.
         boosted = self._max_score_per_cluster(boxes, scores, keep, self.iou_thres)
 
         boxes = boxes[keep]