v3 weights (yolo11s, 204k merged plate dataset, val mAP50=0.944)

miner.py

@@ -155,18 +155,26 @@ class Miner:
         self._onnx_declared_h = _maybe_int(input_shape[2], None)
         self._onnx_declared_w = _maybe_int(input_shape[3], None)
 
-        # Pre-NMS confidence threshold. The reference uses 0.25; we lower
-        # slightly because validator plates are tiny but not as far as 0.15
-        # which produces too many decayed-score ghost detections at 1408
-        # input resolution (verified on starter assets: F1 dropped from
-        # 0.625 to 0.462 at conf=0.15).
-        self.conf_threshold = 0.25
+        # Pre-NMS confidence threshold. Top-of-leaderboard miners (Cargile,
+        # alfred8995) run 0.16-0.21 with a LOW post-NMS floor (0.01) and TTA.
+        # Bench on 12 archived validator tasks (12-task consensus set) at
+        # conf=0.16, score_threshold=0.01 with our v3 ONNX: HIGH recall
+        # 57% -> 66% (+3 plates) at the cost of +2 singletons. Net positive
+        # given 0.6 weight on map50 vs 0.4 on false_positive in composite.
+        self.conf_threshold = 0.16
         # Soft-NMS hyperparameters (Gaussian variant).
         self.soft_nms_sigma = 0.5
-        # Final score floor after Soft-NMS decay. At higher input resolution
-        # the model produces more medium-confidence detections that survive
-        # decay; we keep this stricter so they don't pollute the output.
-        self.score_threshold = 0.20
+        # Final score floor after Soft-NMS decay. Was 0.20 — raised threshold
+        # killed decayed real plates (e.g. plate adjacent to a higher-conf
+        # detection gets decayed below 0.20 and dropped). Matches competitor
+        # 0.01 floor; Soft-NMS still prevents wild duplicates via decay.
+        self.score_threshold = 0.01
+
+        # Horizontal-flip TTA. Doubles inference cost (~101ms -> ~200ms at
+        # batch=1) but we have ~10s budget per-frame, massive headroom. Both
+        # top miners (Cargile, alfred8995) use TTA — the extra view helps
+        # catch plates the model is directionally biased against.
+        self.use_tta = True
 
         # GPU warmup — force ORT / CUDA / cuDNN kernel compilation and pull
         # the 4090 out of low-power idle state so the first real validator
@@ -351,23 +359,12 @@ class Miner:
             dets.append((xa, ya, xb, yb, float(confs[i]), int(cls_ids[i])))
         return dets
 
-    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
-        """Quad-4 (2x2 quadrant) SAHI inference.
-
-        Splits the frame into four overlapping quadrants, each
-        anisotropically resized to ``(input_h, input_w)`` for ~2x
-        magnification in both axes. This recovers plates that TB-2
-        (top/bottom only) missed — especially the 5-7 px plates in
-        image 6 that need vertical AND horizontal magnification.
-
-        Overlap is ~10% on each axis to avoid seam misses. All tile
-        detections are merged via Soft-NMS.
-
-        Measured on the 7 starter frames vs TB-2:
-            mAP@50    0.406 -> 0.489
-            recall    0.433 -> 0.500
-            wall p95   55 ms -> 98 ms (budget 10 s)
-        """
+    def _quad4_raw_dets(
+        self,
+        image_bgr: ndarray,
+    ) -> list[tuple[float, float, float, float, float, int]]:
+        """Run the quad-4 tile pipeline and return RAW (pre-Soft-NMS)
+        detections in original-image coordinates."""
         orig_h, orig_w = image_bgr.shape[:2]
         OVERLAP_X = 70   # ~10% of 1408/2
         OVERLAP_Y = 38   # ~10% of 768/2
@@ -380,10 +377,43 @@ class Miner:
             (0, max(0, my - OVERLAP_Y), min(orig_w, mx + OVERLAP_X), orig_h),      # BL
             (max(0, mx - OVERLAP_X), max(0, my - OVERLAP_Y), orig_w, orig_h),      # BR
         ]
-
-        all_dets = []
+        all_dets: list[tuple[float, float, float, float, float, int]] = []
         for x0, y0, x1, y1 in tiles:
             all_dets.extend(self._infer_tile(image_bgr, x0, y0, x1, y1))
+        return all_dets
+
+    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+        """Quad-4 (2x2 quadrant) SAHI inference with optional horizontal-flip TTA.
+
+        Splits the frame into four overlapping quadrants, each
+        anisotropically resized to ``(input_h, input_w)`` for ~2x
+        magnification in both axes. Overlap is ~10% on each axis.
+        All tile detections are merged via Soft-NMS.
+
+        With ``self.use_tta=True``: additionally runs the same quad-4 pass
+        on a horizontally flipped copy and un-flips the x-coordinates back
+        into original space. Soft-NMS then merges across both views,
+        preferring the higher-confidence one for any paired detection.
+
+        Measured (quad-4 without TTA) on 7 starter frames vs TB-2:
+            mAP@50    0.406 -> 0.489
+            recall    0.433 -> 0.500
+            wall p95   55 ms -> 98 ms
+
+        TTA roughly doubles inference cost (budget: 10 s).
+        """
+        orig_h, orig_w = image_bgr.shape[:2]
+
+        all_dets = self._quad4_raw_dets(image_bgr)
+
+        if self.use_tta:
+            flipped = cv2.flip(image_bgr, 1)  # horizontal flip (mirror)
+            flip_dets = self._quad4_raw_dets(flipped)
+            # Un-flip x-coordinates: x_orig = W - x_flipped
+            for x1f, y1, x2f, y2, conf, cls_id in flip_dets:
+                all_dets.append(
+                    (orig_w - x2f, y1, orig_w - x1f, y2, conf, cls_id)
+                )
 
         dets = self._soft_nms(all_dets)