v8 ep-10 YOLO26s weights + shape-dispatch miner.py + defensive guards

README.md

@@ -0,0 +1,53 @@
+---
+license: cc-by-4.0
+tags:
+- element_type:detect
+- model:yolov11-small
+- object:numberplate
+- subnet:sn44
+- element:manak0/Detect-number-plates-1-0
+manako:
+  element_id: manak0/Detect-number-plates-1-0
+  description: License plate / number plate detector for SN44 element manak0/Detect-number-plates-1-0
+  source: meaculpitt/ScoreVision
+  prompt_hints: null
+  input_payload:
+  - name: frame
+    type: image
+    description: RGB frame (validator native resolution 1408x768)
+  output_payload:
+  - name: detections
+    type: detections
+    description: List of license plate bounding boxes (single class "numberplate", absolute pixel xyxy)
+  evaluation_score: null
+  last_benchmark: null
+---
+
+# meaculpitt/ScoreVision-Numberplate
+
+Single-element chute for the SN44 element
+**`manak0/Detect-number-plates-1-0`** (activates 2026-04-12T12:02 UTC).
+
+- Architecture: YOLO11s exported to ONNX (≤30 MB hard cap)
+- Input: 1408×768 RGB frames (the validator's native resolution)
+- Output: bounding boxes around license plates (single class
+  `numberplate`, absolute-pixel xyxy coordinates)
+- Inference: ONNX Runtime CUDA EP, Gaussian Soft-NMS (sigma=0.5)
+  for plate-dense scenes
+- Latency target: p95 ≤ 50 ms end-to-end
+
+Trained on a 344k-image combined corpus of:
+- Roboflow license-plate-recognition-rxg4e v4
+- Roboflow vehicle-registration-plates-trudk v2
+- Roboflow car-license-fj1kd v4
+- helpme-8ixem/anpr-iuzao (real CCTV ANPR footage)
+- CCPD2019 (Chinese City Parking Dataset, ~200k overhead surveillance frames)
+
+## Sibling repos in this org
+
+- [`meaculpitt/ScoreVision-Vehicle`](https://huggingface.co/meaculpitt/ScoreVision-Vehicle) — vehicle (manak0/Detect-detect-vehicle), served by the `insect` chute
+- [`meaculpitt/ScoreVision-Petrol`](https://huggingface.co/meaculpitt/ScoreVision-Petrol) — petrol station components
+
+This repo (`ScoreVision-Numberplate`) is intentionally a separate
+single-element submission deployed under its own chute slug, not part
+of the unified `insect` chute.

miner.py

@@ -176,6 +176,17 @@ class Miner:
         # catch plates the model is directionally biased against.
         self.use_tta = True
 
+        # Dual-threshold TTA verification gate (hermes-style, seen in the
+        # hermestech00/numberplate0 HF repo). Final-output gate:
+        #   - conf >= conf_high               → pass unconditionally
+        #   - conf in [conf_threshold, conf_high)  → must have a flip-view
+        #                                        match with IoU >= tta_match_iou
+        #                                        to survive
+        # Uses TTA as a cross-view VERIFIER, not just a recall booster.
+        # Skips when use_tta=False.
+        self.conf_high = 0.90
+        self.tta_match_iou = 0.01
+
         # GPU warmup — force ORT / CUDA / cuDNN kernel compilation and pull
         # the 4090 out of low-power idle state so the first real validator
         # frame doesn't pay a ~20 ms DVFS spin-up tax. SCOREVISION_WARMUP_CALLS
@@ -327,6 +338,32 @@ class Miner:
         rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)
         x = np.transpose(rgb.astype(np.float32) / 255.0, (2, 0, 1))[None, ...]
         out = self.session.run(None, {self.input_name: x})[0]
+
+        # Scale factors from model-input space -> crop -> original image coords.
+        sx = cw / self.input_w
+        sy = ch / self.input_h
+
+        # Shape-dispatch: detect end2end export format (YOLO26 family: [1, N, 6]
+        # with N<=300, per-row [x1, y1, x2, y2, conf, cls_id] already NMS'd) vs
+        # raw YOLO11/v8 export ([1, C, anchors] or [1, anchors, C] with cx/cy/w/h
+        # + per-class scores, pre-NMS).
+        if out.ndim == 3 and out.shape[-1] == 6:
+            rows = out[0]  # [N, 6]
+            confs_all = rows[:, 4]
+            keep = confs_all >= self.conf_threshold
+            rows = rows[keep]
+            if rows.shape[0] == 0:
+                return []
+            dets_e2e: list[tuple[float, float, float, float, float, int]] = []
+            for i in range(rows.shape[0]):
+                x1m, y1m, x2m, y2m, conf, cls_id = rows[i].tolist()
+                xa = x1m * sx + x0
+                ya = y1m * sy + y0
+                xb = x2m * sx + x0
+                yb = y2m * sy + y0
+                dets_e2e.append((xa, ya, xb, yb, float(conf), int(cls_id)))
+            return dets_e2e
+
         pred = self._normalize_predictions(out)
 
         if pred.shape[1] < 5:
@@ -346,9 +383,6 @@ class Miner:
         if boxes_m.shape[0] == 0:
             return []
 
-        # Model-space (input_w x input_h) -> crop-space -> original image
-        sx = cw / self.input_w
-        sy = ch / self.input_h
         dets: list[tuple[float, float, float, float, float, int]] = []
         for i in range(boxes_m.shape[0]):
             cx, cy, bw, bh = boxes_m[i].tolist()
@@ -451,24 +485,57 @@ class Miner:
 
         all_dets = self._quad4_raw_dets(image_bgr)
 
+        # Adaptive conf fallback: if the quad-4 pass produced nothing, retry
+        # once at a lower pre-NMS threshold. Rescues archived floor-drops
+        # where the model had plate signal but nothing crossed 0.18 anywhere
+        # in the 4 tiles (observed on validator tasks 57803/57836/57848).
+        if not all_dets:
+            _orig_conf = self.conf_threshold
+            try:
+                self.conf_threshold = 0.10
+                all_dets = self._quad4_raw_dets(image_bgr)
+            finally:
+                self.conf_threshold = _orig_conf
+            if all_dets:
+                _cuda_log.warning(
+                    "adaptive conf fallback rescued %d raw dets at conf=0.10",
+                    len(all_dets),
+                )
+
+        # Keep flipped-view detections SEPARATE from original, so we can use
+        # them as a cross-view verifier (hermes-style gate) later — not just
+        # merge them into all_dets as a recall booster.
+        flip_dets_unflipped: list[tuple] = []
         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(
+                flip_dets_unflipped.append(
                     (orig_w - x2f, y1, orig_w - x1f, y2, conf, cls_id)
                 )
+            # Still merge flip into all_dets so dedup + NMS sees both views
+            # (preserves existing TTA recall behaviour).
+            all_dets.extend(flip_dets_unflipped)
 
         # TTA-aware cluster-dedup: collapse near-duplicate detections of the
         # same plate (e.g. original + unflipped TTA view) BEFORE Soft-NMS,
         # which would otherwise decay but not kill the lower-conf copy at
         # our low score_threshold=0.01. Without this step the deployed miner
         # emitted 2-3 outputs per plate (verified on validator task 57820).
+        pre_nms_count = len(all_dets)
         all_dets = self._cluster_dedup(all_dets, iou_thresh=0.3)
 
         dets = self._soft_nms(all_dets)
 
+        # (Dual-threshold TTA gate tried here and reverted 2026-04-21: on our
+        # YOLO11s ONNX the gate cost −0.037 map50-proxy to save only +0.023 FP,
+        # net −0.013 composite on 20 post-jump archive tasks. Pattern is the
+        # right one for hermes's YOLO26s (higher recall, more conf >=0.90 boxes)
+        # but hurts YOLO11s. Keep self.conf_high + self.tta_match_iou params in
+        # __init__ in case v7/v8 training closes the recall gap and makes the
+        # gate net-positive — can re-add this block then.)
+
         out_boxes: list[BoundingBox] = []
         for x1, y1, x2, y2, conf, cls_id in dets:
             ix1 = max(0, min(orig_w, math.floor(x1)))
@@ -497,6 +564,37 @@ class Miner:
                     conf=max(0.0, min(1.0, conf)),
                 )
             )
+
+        # Silent-empty-submission guard: if the pipeline found raw detections
+        # but every one was filtered to nothing, bypass F1a/F1b and emit the
+        # post-NMS detections above score_threshold. Accepts a potential FP
+        # over a guaranteed zero — which scored 0.000-0.010 on validator
+        # tasks 57803/57836/57848 even though the model had clear plate
+        # signal in the tiles.
+        if pre_nms_count > 0 and not out_boxes:
+            _cuda_log.warning(
+                "empty-submission guard: %d raw dets → 0 filtered; emitting raw",
+                pre_nms_count,
+            )
+            for x1, y1, x2, y2, conf, cls_id in dets:
+                if conf < self.score_threshold:
+                    continue
+                ix1 = max(0, min(orig_w, math.floor(x1)))
+                iy1 = max(0, min(orig_h, math.floor(y1)))
+                ix2 = max(0, min(orig_w, math.ceil(x2)))
+                iy2 = max(0, min(orig_h, math.ceil(y2)))
+                if ix2 <= ix1 or iy2 <= iy1:
+                    continue
+                out_boxes.append(
+                    BoundingBox(
+                        x1=ix1,
+                        y1=iy1,
+                        x2=ix2,
+                        y2=iy2,
+                        cls_id=cls_id,
+                        conf=max(0.0, min(1.0, conf)),
+                    )
+                )
         return out_boxes
 
     # ---------------------------------------------------------------- entry

numberplate_weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c62bedf6d9d5ca79b6d663efb4fe105ed9785712603a488ee49c79e530179cc
-size 19770499
+oid sha256:75e91a8ee137d2f52eef752527a3b3ff1159c5b4417c5b40f205af090fb0ea00
+size 19579923

yolo26n.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b09cc8bf347f0fc8a5f7657480587f25db09b34bf33b0652110fb03a8ad4fef
+size 5544453