Upload folder using huggingface_hub

miner.py

@@ -71,7 +71,7 @@ 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.1
+        self.conf_thres = 0.07
         self.iou_thres = 0.6
         self.max_det = 300
         self.use_tta = True
@@ -223,6 +223,79 @@ class Miner:
         mask = scores > score_thresh
         return order[mask], scores[mask]
 
+    @staticmethod
+    def _hard_nms(
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        """
+        Standard NMS: keep one box per overlapping cluster (the one with highest score).
+        Returns indices of kept boxes (into the boxes/scores arrays).
+        """
+        N = len(boxes)
+        if N == 0:
+            return np.array([], dtype=np.intp)
+        boxes = np.asarray(boxes, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        order = np.argsort(scores)[::-1]
+        keep: list[int] = []
+        suppressed = np.zeros(N, dtype=bool)
+        for i in range(N):
+            idx = order[i]
+            if suppressed[idx]:
+                continue
+            keep.append(idx)
+            bi = boxes[idx]
+            for k in range(i + 1, N):
+                jdx = order[k]
+                if suppressed[jdx]:
+                    continue
+                bj = boxes[jdx]
+                xx1 = max(bi[0], bj[0])
+                yy1 = max(bi[1], bj[1])
+                xx2 = min(bi[2], bj[2])
+                yy2 = min(bi[3], bj[3])
+                inter = max(0.0, xx2 - xx1) * max(0.0, yy2 - yy1)
+                area_i = (bi[2] - bi[0]) * (bi[3] - bi[1])
+                area_j = (bj[2] - bj[0]) * (bj[3] - bj[1])
+                iou = inter / (area_i + area_j - inter + 1e-7)
+                if iou > iou_thresh:
+                    suppressed[jdx] = True
+        return np.array(keep)
+
+    @staticmethod
+    def _max_score_per_cluster(
+        coords: np.ndarray,
+        scores: np.ndarray,
+        keep_indices: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        """
+        For each kept box, return the max original score among itself and any
+        box that overlaps it with IOU >= iou_thresh (so TTA cluster keeps best conf).
+        """
+        n_keep = len(keep_indices)
+        if n_keep == 0:
+            return np.array([], dtype=np.float32)
+        out = np.empty(n_keep, dtype=np.float32)
+        coords = np.asarray(coords, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        for i in range(n_keep):
+            idx = keep_indices[i]
+            bi = coords[idx]
+            xx1 = np.maximum(bi[0], coords[:, 0])
+            yy1 = np.maximum(bi[1], coords[:, 1])
+            xx2 = np.minimum(bi[2], coords[:, 2])
+            yy2 = np.minimum(bi[3], coords[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            area_i = (bi[2] - bi[0]) * (bi[3] - bi[1])
+            areas_j = (coords[:, 2] - coords[:, 0]) * (coords[:, 3] - coords[:, 1])
+            iou = inter / (area_i + areas_j - inter + 1e-7)
+            in_cluster = iou >= iou_thresh
+            out[i] = float(np.max(scores[in_cluster]))
+        return out
+
     def _decode_final_dets(
         self,
         preds: np.ndarray,
@@ -420,7 +493,7 @@ class Miner:
         return self._postprocess(det_output, ratio, pad, orig_size)
 
     def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
-        """Horizontal-flip TTA: run inference on original + flipped, merge with Soft-NMS."""
+        """Horizontal-flip TTA: merge original + flipped via hard NMS."""
         boxes_orig = self._predict_single(image)
 
         flipped = cv2.flip(image, 1)
@@ -444,15 +517,23 @@ class Miner:
         )
         scores = np.array([b.conf for b in all_boxes], dtype=np.float32)
 
-        keep_idx, updated_scores = self._soft_nms(coords, scores)
+        hard_keep = self._hard_nms(coords, scores, self.iou_thres)
+        if len(hard_keep) == 0:
+            return []
+
+        # _hard_nms already orders kept indices by descending score.
+        hard_keep = hard_keep[: self.max_det]
 
         return [
             BoundingBox(
-                x1=all_boxes[i].x1, y1=all_boxes[i].y1,
-                x2=all_boxes[i].x2, y2=all_boxes[i].y2,
-                cls_id=all_boxes[i].cls_id, conf=float(s),
+                x1=all_boxes[i].x1,
+                y1=all_boxes[i].y1,
+                x2=all_boxes[i].x2,
+                y2=all_boxes[i].y2,
+                cls_id=all_boxes[i].cls_id,
+                conf=float(scores[i]),
             )
-            for i, s in zip(keep_idx, updated_scores)
+            for i in hard_keep
         ]
 
     def predict_batch(

weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:be6e4b7e468f655482d0f73509954721601eacb68d376d8191a14bdb7f3d3105
-size 19404973
+oid sha256:31ee30943eda5c04c67b76a612dff96dd6f6fdb44ea7ea28dd425493ce63a5ab
+size 19153171