Upload folder using huggingface_hub

miner.py

@@ -25,44 +25,40 @@ class TVFrameResult(BaseModel):
 
 class Miner:
     """
-    YOLO ONNX miner for car wash detection. Single forward pass per frame (no TTA).
+    YOLO (NMS-free) ONNX miner for road-sign detection. One forward pass per
+    frame — no TTA.
 
-    Classes: broom, drainage gate, nozzle, track
+    Class: single 'road sign'.
 
-    Pipeline per frame: preprocess -> ONNX -> decode -> per-class conf threshold
-    (+ rescue bonus) -> un-letterbox -> sanity filter -> per-class NMS ->
-    cross-class dedup -> same-class cluster score boost -> results.
+    Pipeline per frame: preprocess -> ONNX -> decode -> conf threshold (+ rescue
+    bonus) -> un-letterbox -> sanity filter -> per-class NMS -> cross-class dedup
+    -> same-class cluster score boost -> results.
 
-    Speed characteristics:
-      - The detection pipeline runs exactly ONCE per frame.
-      - `_max_score_per_cluster` (the cluster boost) is a single vectorized IoU
-        matrix, so cost stays flat as the number of detected objects grows
-        instead of scaling like a Python loop.
-      - `_hard_nms` precomputes box areas once; `pre_nms_topk` bounds NMS cost
-        on pathologically crowded frames.
+    Speed: the detection pipeline runs exactly ONCE per frame (the old redundant
+    second NMS/dedup pass is gone), and the cluster boost is a single vectorized
+    IoU matrix, so cost stays flat as the number of detected objects grows.
     """
 
-    class_names = ['broom', 'drainage gate', 'nozzle', 'track']
-    input_size = 640
-    cross_iou_thresh = 0.9
+    class_names = ['road sign']
+    input_size = 1536
+    cross_iou_thresh = 0.8
     max_det = 300
-    # NMS is O(n^2). If a frame yields a huge candidate list, keep only the
-    # top-K by score before NMS. Set high enough to never touch real detections.
+    # NMS is O(n^2); if a frame yields a huge candidate list, keep the top-K by
+    # score before NMS. Set high enough never to touch real detections.
     pre_nms_topk = 1000
     #overlap_suppress_threshold = 0.85
 
-    # Per-class confidence thresholds
-    _conf_thres_array = np.array([0.35, 0.7, 0.4, 0.7], dtype=np.float32)
-    _extra_conf_thres_array = np.array([0.32, 0.3, 0.36, 0.3], dtype=np.float32)
+    # Per-class confidence threshold
+    _conf_thres_array = np.array([0.32], dtype=np.float32)
 
-    # Per-class IoU thresholds for same-class NMS
-    _iou_thres_array = np.array([0.6, 0.7, 0.5, 0.7], dtype=np.float32)
+    # Per-class IoU threshold for same-class NMS
+    _iou_thres_array = np.array([0.8], dtype=np.float32)
 
     # Per-class rescue bonus
-    _bonus_array = np.array([0.2, 0.2, 0.0, 0.2], dtype=np.float32)
+    _bonus_array = np.array([0.2], dtype=np.float32)
 
-    # Per-class minimum box area  (0=broom, 1=drainage gate, 2=nozzle, 3=track)
-    _min_box_area_array = np.array([144.0, 144.0, 4.0, 64.0], dtype=np.float32)
+    # Per-class minimum box area (index 0 = road sign)
+    _min_box_area_array = np.array([9.0], dtype=np.float32)
 
     def __init__(self, path_hf_repo: Path) -> None:
         self.path_hf_repo = path_hf_repo
@@ -87,7 +83,6 @@ class Miner:
         )
         print("Created ORT session with preferred CUDA provider list")
         print("ORT session providers:", self.session.get_providers())
-        # If CUDAExecutionProvider is NOT listed above, you are running on CPU.
 
         self.input_name = self.session.get_inputs()[0].name
         input_shape = self.session.get_inputs()[0].shape
@@ -95,9 +90,9 @@ class Miner:
         self.input_h = self._safe_dim(input_shape[2], default=self.input_size)
         self.input_w = self._safe_dim(input_shape[3], default=self.input_size)
 
-        # Same-class cluster score boost. Raises the confidence of overlapping
-        # same-class survivors to their cluster max. Part of the current tuned
-        # behaviour; set False to disable (slightly faster, changes confidences).
+        # Same-class cluster score boost (raises overlapping same-class survivors
+        # to their cluster max). Part of the current tuned behaviour; for a single
+        # class it is nearly a no-op. Set False to disable.
         self.use_cluster_boost = True
         self._avg_iou = float(np.mean(self._iou_thres_array))
 
@@ -113,7 +108,7 @@ class Miner:
             print(f"warmup skipped: {e}")
 
     def __repr__(self) -> str:
-        return f"Car Wash Miner classes={len(self.class_names)}"
+        return f"road sign Miner classes={len(self.class_names)}"
 
     @staticmethod
     def _safe_dim(value, default: int) -> int:
@@ -150,30 +145,19 @@ class Miner:
         )
         return out, r, pad_w, pad_h
 
-    def _preprocess(self, image_bgr: np.ndarray,
-                   allow_pad: bool = True) -> tuple[np.ndarray, dict]:
+    def _preprocess(self, image_bgr: ndarray) -> tuple[np.ndarray, dict]:
         orig_h, orig_w = image_bgr.shape[:2]
-        extra_left = 0
-        extra_right = 0
-        if allow_pad and orig_w == orig_h:          # only pad when allowed
-            target_w = int(orig_w * 1.05)
-            if target_w > orig_w:
-                total_extra = target_w - orig_w
-                extra_left = total_extra // 2
-                extra_right = total_extra - extra_left
-                image_bgr = cv2.copyMakeBorder(
-                    image_bgr, 0, 0, extra_left, extra_right,
-                    cv2.BORDER_CONSTANT, value=(114, 114, 114),
-                )
         rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
         img, ratio, pad_w, pad_h = self._letterbox(rgb, (self.input_w, self.input_h))
         x = img.astype(np.float32) / 255.0
         x = np.transpose(x, (2, 0, 1))[None, ...]
         x = np.ascontiguousarray(x)
         return x, {
-            "orig_h": orig_h, "orig_w": orig_w,
-            "ratio": ratio, "pad_w": pad_w, "pad_h": pad_h,
-            "extra_left": extra_left, "extra_right": extra_right,
+            "orig_h": orig_h,
+            "orig_w": orig_w,
+            "ratio": ratio,
+            "pad_w": pad_w,
+            "pad_h": pad_h,
         }
 
     # ─── Vectorized box operations ───────────────────────────────
@@ -314,15 +298,11 @@ class Miner:
         return out.astype(np.float32)
 
     def _conf_filter_mask(self, scores: np.ndarray,
-                          cls_ids: np.ndarray, extra_left: int) -> np.ndarray:
+                          cls_ids: np.ndarray) -> np.ndarray:
         """Per-class threshold with rescue bonus for missed classes."""
         if len(scores) == 0:
             return np.zeros(0, dtype=bool)
-        thr = 0
-        if extra_left > 0:
-            thr = self._extra_conf_thres_array[cls_ids]
-        else:
-            thr = self._conf_thres_array[cls_ids]
+        thr = self._conf_thres_array[cls_ids]
         keep = scores >= thr
         for c in np.unique(cls_ids):
             b = float(self._bonus_array[c])
@@ -365,11 +345,10 @@ class Miner:
 
     def _decode_yolo_output(self, preds: np.ndarray, ratio: float,
                            pad: tuple[float, float],
-                           orig_size: tuple[int, int],
-                           extra: tuple[int, int] = (0, 0)
+                           orig_size: tuple[int, int]
                            ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """Decode -> conf filter -> un-letterbox -> sanity+NMS+dedup.
-        Returns (boxes, scores, cls_ids) in ORIGINAL image coords."""
+        """Decode NMS-free output [1,N,6]=(x1,y1,x2,y2,conf,cls) -> conf filter ->
+        un-letterbox -> sanity+NMS+dedup. Returns arrays in ORIGINAL coords."""
         empty = (np.empty((0, 4), np.float32), np.empty(0, np.float32),
                  np.empty(0, np.int32))
         if preds.ndim == 3 and preds.shape[0] == 1:
@@ -388,33 +367,15 @@ class Miner:
         if len(boxes) == 0:
             return empty
 
-        extra_left, _extra_right = extra
-
-        keep = self._conf_filter_mask(scores, cls_ids, extra_left)
+        keep = self._conf_filter_mask(scores, cls_ids)
         boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
         if len(boxes) == 0:
             return empty
 
-        # 1) undo letterbox -> coords in the PADDED (widened) image
         pad_w, pad_h = pad
         boxes[:, [0, 2]] -= pad_w
         boxes[:, [1, 3]] -= pad_h
         boxes /= ratio
-
-        # 2) undo left/right pre-padding -> original-image coords
-        if extra_left:
-            boxes[:, [0, 2]] -= extra_left
-
-        # 2b) drop boxes whose CENTER falls in the black padding bars
-        if extra_left or _extra_right:
-            orig_w, orig_h = orig_size
-            cx = (boxes[:, 0] + boxes[:, 2]) * 0.5
-            inside = (cx >= 0) & (cx <= orig_w)
-            boxes, scores, cls_ids = boxes[inside], scores[inside], cls_ids[inside]
-            if len(boxes) == 0:
-                return empty
-
-        # 3) clip to ORIGINAL image bounds
         boxes = self._clip_boxes(boxes, orig_size)
 
         return self._per_view_pipeline(boxes, scores, cls_ids, orig_size)
@@ -441,9 +402,9 @@ class Miner:
             )
         return results
 
-    # ─── Inference ────────────────────────────────────────────────
+    # ─── Inference (single view, no TTA) ──────────────────────────
 
-    def _predict_single(self, image_bgr: np.ndarray, allow_pad: bool = True
+    def _predict_single(self, image_bgr: np.ndarray
                         ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """One forward pass -> decoded (boxes, scores, cls_ids) in original coords."""
         if image_bgr is None or not isinstance(image_bgr, np.ndarray):
@@ -451,22 +412,20 @@ class Miner:
         if image_bgr.dtype != np.uint8:
             image_bgr = image_bgr.astype(np.uint8)
 
-        inp, meta = self._preprocess(image_bgr, allow_pad=allow_pad)
+        inp, meta = self._preprocess(image_bgr)
         outputs = self.session.run(None, {self.input_name: inp})
 
         ratio = float(meta["ratio"])
         pad = (float(meta["pad_w"]), float(meta["pad_h"]))
         orig_size = (int(meta["orig_w"]), int(meta["orig_h"]))
-        extra = (int(meta["extra_left"]), int(meta["extra_right"]))
 
-        return self._decode_yolo_output(outputs[0], ratio, pad, orig_size, extra)
+        return self._decode_yolo_output(outputs[0], ratio, pad, orig_size)
 
     def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
-        """Single-view inference (no TTA)."""
         orig_h, orig_w = image_bgr.shape[:2]
         orig_size = (orig_w, orig_h)
 
-        boxes, scores, cls_ids = self._predict_single(image_bgr, allow_pad=True)
+        boxes, scores, cls_ids = self._predict_single(image_bgr)
         if len(boxes) == 0:
             return []
 

weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:17f8cd5cf9253b555a05bd6ac874bcbe2a892298f008d2f01a0fd4e4c6c0a867
-size 9760190
+oid sha256:9ad0e8fc7e38bd4c5f5c8f4cfece75dcc2fa6a41c2cf71e4cba9672c87b98687
+size 9757809