Upload folder using huggingface_hub

miner.py

@@ -48,17 +48,26 @@ class Miner:
     iou_thres = 0.3
     cross_iou_thresh = 0.8
     max_det = 150
+
+    # Final box tightening, applied about each box's own center AFTER NMS /
+    # cross-class dedup so the tuned IoU thresholds above still see the raw
+    # geometry. `box_shrink` is the fraction of width/height the box keeps:
+    # 1.0 = unchanged, 0.96 pulls each edge inward by 2% of that dimension.
+    # A box is never shrunk below `min_box_size` px, and never below its own
+    # original size.
+    box_shrink = 0.98
+    min_box_size = 2.0
     
     _conf_thres_array = np.array(
-        [0.38, 0.38, 0.22, 0.12, 0.33, 0.20], dtype=np.float32,
+        [0.38, 0.38, 0.22, 0.20, 0.33, 0.20], dtype=np.float32,
     )
     _bonus_array = np.array(
         [0.2, 0.25, 0.12, 0.09, 0.21, 0.06], dtype=np.float32,
     )
     
     def __init__(self, path_hf_repo: Path) -> None:
-        # model_path = path_hf_repo / "weights-all.onnx"
         model_path = path_hf_repo / "weights.onnx"
+        # model_path = path_hf_repo / "weights.onnx"
         print("ORT version:", ort.__version__)
 
         try:
@@ -443,20 +452,43 @@ class Miner:
         boxes, scores, cls_ids = self._per_view_pipeline(boxes, scores, cls_ids)
         return self._build_results(boxes, scores, cls_ids)
 
-    @staticmethod
-    def _build_results(boxes: np.ndarray, scores: np.ndarray,
+    def _shrink_boxes(self, boxes: np.ndarray) -> np.ndarray:
+        """Scale every xyxy box toward its own center by `box_shrink`.
+        Center, class and score are untouched; only the extent changes."""
+        scale = float(self.box_shrink)
+        if len(boxes) == 0 or scale >= 1.0:
+            return boxes
+        boxes = np.asarray(boxes, dtype=np.float32)
+        cx = (boxes[:, 0] + boxes[:, 2]) * 0.5
+        cy = (boxes[:, 1] + boxes[:, 3]) * 0.5
+        w = np.maximum(0.0, boxes[:, 2] - boxes[:, 0])
+        h = np.maximum(0.0, boxes[:, 3] - boxes[:, 1])
+        # Shrink, but never past min_box_size and never larger than the original
+        # (the floor must not inflate an already-tiny detection).
+        new_w = np.minimum(np.maximum(w * scale, self.min_box_size), w)
+        new_h = np.minimum(np.maximum(h * scale, self.min_box_size), h)
+        out = np.empty_like(boxes)
+        out[:, 0] = cx - new_w * 0.5
+        out[:, 1] = cy - new_h * 0.5
+        out[:, 2] = cx + new_w * 0.5
+        out[:, 3] = cy + new_h * 0.5
+        return out
+
+    def _build_results(self, boxes: np.ndarray, scores: np.ndarray,
                        cls_ids: np.ndarray) -> list[BoundingBox]:
+        boxes = self._shrink_boxes(boxes)
         results: list[BoundingBox] = []
         for box, conf, cls_id in zip(boxes, scores, cls_ids):
             x1, y1, x2, y2 = box.tolist()
-            if x2 <= x1 or y2 <= y1:
+            # Round to nearest instead of floor/ceil: the old outward
+            # rounding grew every box by up to 1 px on each of the 4 edges.
+            ix1, iy1 = int(round(x1)), int(round(y1))
+            ix2, iy2 = int(round(x2)), int(round(y2))
+            if ix2 <= ix1 or iy2 <= iy1:
                 continue
             results.append(
                 BoundingBox(
-                    x1=int(math.floor(x1)),
-                    y1=int(math.floor(y1)),
-                    x2=int(math.ceil(x2)),
-                    y2=int(math.ceil(y2)),
+                    x1=ix1, y1=iy1, x2=ix2, y2=iy2,
                     cls_id=int(cls_id),
                     conf=float(conf),
                 )