subnet_bridge: copy winning miner repo into library

README.md

@@ -10,9 +10,9 @@ tags:
 manako:
   source: winner_fetch
   manifest_element_name: manak0/Detect-fire
-  winner_repo_id: navierstocks/fire-light
-  winner_revision: 95133792375f1fd3e5f192d0494c3b02f770cdc4
-  note: E=0.03088120 (map50=0.600000, size_mb=19.429295)
+  winner_repo_id: navierstocks/disaster
+  winner_revision: 3a0b049b490e28f3d29f0328c2af1a7799217933
+  note: E=0.03088868 (map50=0.600000, size_mb=19.424589)
 ---
 
 ## YOLO26 ONNX detector

miner.py

@@ -24,17 +24,17 @@ class TVFrameResult(BaseModel):
 
 
 class Miner:
-    """ONNX Runtime miner. Soft per-class NMS + sanity filter + flip TTA."""
+    """ONNX Runtime miner. Hard global NMS + sanity filter + per-class conf rescue."""
 
     class_names = ["fire", "smoke", "fire extinguisher"]
     input_size = 1280
-    iou_thres = 0.3
-    soft_sigma = 0.5
-    min_side = 8.0
+    iou_thres = 0.4
+    min_side = 12.0
     min_box_area = 144.0
     max_aspect_ratio = 6.0
-    max_det = 100
-    _conf_thres_array = np.array([0.25, 0.15, 0.15], dtype=np.float32)
+    max_det = 150
+    _conf_thres_array = np.array([0.25, 0.4, 0.2], dtype=np.float32)
+    _bonus_array = np.array([0.15, 0.35, 0.15], dtype=np.float32)
 
     def __init__(self, path_hf_repo: Path) -> None:
         model_path = path_hf_repo / "weights.onnx"
@@ -81,6 +81,7 @@ class Miner:
         self.input_width = self._safe_dim(self.input_shape[3], default=self.input_size)
 
         print(f"ONNX model loaded from: {model_path}")
+        print(f"ONNX providers: {self.session.get_providers()}")
         print(f"ONNX input: name={self.input_name}, shape={self.input_shape}")
         print("per-class conf: " + ", ".join(
             f"{n}={t:.3f}" for n, t in zip(self.class_names,
@@ -173,81 +174,9 @@ class Miner:
             order = rest[iou <= iou_thresh]
         return np.array(keep, dtype=np.intp)
 
-    @staticmethod
-    def _soft_nms(boxes: np.ndarray, scores: np.ndarray,
-                  sigma: float, score_thresh: float = 0.001
-                  ) -> tuple[np.ndarray, np.ndarray]:
-        n = len(boxes)
-        if n == 0:
-            return np.array([], dtype=np.intp), np.array([], dtype=np.float32)
-        boxes = boxes.astype(np.float32, copy=True)
-        scores = scores.astype(np.float32, copy=True)
-        order = np.arange(n)
-        for i in range(n):
-            max_pos = i + int(np.argmax(scores[i:]))
-            boxes[[i, max_pos]] = boxes[[max_pos, i]]
-            scores[[i, max_pos]] = scores[[max_pos, i]]
-            order[[i, max_pos]] = order[[max_pos, i]]
-            if i + 1 >= n:
-                break
-            xx1 = np.maximum(boxes[i, 0], boxes[i + 1:, 0])
-            yy1 = np.maximum(boxes[i, 1], boxes[i + 1:, 1])
-            xx2 = np.minimum(boxes[i, 2], boxes[i + 1:, 2])
-            yy2 = np.minimum(boxes[i, 3], boxes[i + 1:, 3])
-            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
-            a_i = max(0.0, float((boxes[i, 2] - boxes[i, 0]) *
-                                 (boxes[i, 3] - boxes[i, 1])))
-            a_j = (np.maximum(0.0, boxes[i + 1:, 2] - boxes[i + 1:, 0]) *
-                   np.maximum(0.0, boxes[i + 1:, 3] - boxes[i + 1:, 1]))
-            iou = inter / (a_i + a_j - inter + 1e-7)
-            scores[i + 1:] *= np.exp(-(iou ** 2) / sigma)
-        mask = scores > score_thresh
-        return order[mask], scores[mask]
-
-    def _per_class_hard_nms(self, boxes: np.ndarray, scores: np.ndarray,
-                            cls_ids: np.ndarray, iou_thresh: float
-                            ) -> np.ndarray:
-        if len(boxes) == 0:
-            return np.array([], dtype=np.intp)
-        all_keep: list[int] = []
-        for c in np.unique(cls_ids):
-            mask = cls_ids == c
-            indices = np.where(mask)[0]
-            keep = self._hard_nms(boxes[mask], scores[mask], iou_thresh)
-            all_keep.extend(indices[keep].tolist())
-        all_keep.sort()
-        return np.array(all_keep, dtype=np.intp)
-
-    def _per_class_soft_nms(self, boxes: np.ndarray, scores: np.ndarray,
-                            cls_ids: np.ndarray
-                            ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        if len(boxes) == 0:
-            return boxes, scores, cls_ids
-        out_b: list = []
-        out_s: list = []
-        out_c: list = []
-        for c in np.unique(cls_ids):
-            mask = cls_ids == c
-            sub_b = boxes[mask]
-            sub_s = scores[mask]
-            sub_c = cls_ids[mask]
-            idx, decayed = self._soft_nms(sub_b, sub_s, self.soft_sigma)
-            if len(idx) == 0:
-                continue
-            out_b.append(sub_b[idx])
-            out_s.append(decayed)
-            out_c.append(sub_c[idx])
-        if not out_b:
-            return (np.empty((0, 4), dtype=np.float32),
-                    np.empty((0,), dtype=np.float32),
-                    np.empty((0,), dtype=cls_ids.dtype))
-        return (np.concatenate(out_b, axis=0),
-                np.concatenate(out_s, axis=0),
-                np.concatenate(out_c, axis=0))
-
-    def _filter_sane_boxes(self, boxes: np.ndarray, scores: np.ndarray,
-                           cls_ids: np.ndarray, orig_size: tuple[int, int]
-                           ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def _filter_sane_boxes_op(self, boxes: np.ndarray, scores: np.ndarray,
+                              cls_ids: np.ndarray, orig_size: tuple[int, int]
+                              ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         if len(boxes) == 0:
             return boxes, scores, cls_ids
         orig_w, orig_h = orig_size
@@ -268,40 +197,39 @@ class Miner:
         )
         return boxes[keep], scores[keep], cls_ids[keep]
 
-    @staticmethod
-    def _max_score_per_cluster(post_boxes: np.ndarray,
-                               full_boxes: np.ndarray,
-                               full_scores: np.ndarray,
-                               iou_thresh: float) -> np.ndarray:
-        n = len(post_boxes)
-        if n == 0:
-            return np.empty(0, dtype=np.float32)
-        full_areas = (np.maximum(0.0, full_boxes[:, 2] - full_boxes[:, 0]) *
-                      np.maximum(0.0, full_boxes[:, 3] - full_boxes[:, 1]))
-        out = np.empty(n, dtype=np.float32)
-        for i in range(n):
-            bi = post_boxes[i]
-            xx1 = np.maximum(bi[0], full_boxes[:, 0])
-            yy1 = np.maximum(bi[1], full_boxes[:, 1])
-            xx2 = np.minimum(bi[2], full_boxes[:, 2])
-            yy2 = np.minimum(bi[3], full_boxes[:, 3])
-            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
-            a_i = max(0.0, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
-            iou = inter / (a_i + full_areas - inter + 1e-7)
-            cluster = iou >= iou_thresh
-            out[i] = float(np.max(full_scores[cluster])) if np.any(cluster) else 0.0
-        return out
+    def _conf_filter_mask(self, scores: np.ndarray,
+                          cls_ids: np.ndarray) -> np.ndarray:
+        """Boolean keep-mask: score >= per-class threshold, with a per-class
+        rescue — if a class has zero boxes passing, admit its top-1 candidate
+        when its score >= (per-class threshold - per-class bonus)."""
+        if len(scores) == 0:
+            return np.zeros(0, dtype=bool)
+        thr = self._conf_thres_array[cls_ids]
+        keep = scores >= thr
+        for c in np.unique(cls_ids):
+            b = float(self._bonus_array[c])
+            if b <= 0.0:
+                continue
+            cm = cls_ids == c
+            if keep[cm].any():
+                continue
+            idx = np.where(cm)[0]
+            top = int(idx[int(np.argmax(scores[idx]))])
+            if scores[top] >= self._conf_thres_array[c] - b:
+                keep[top] = True
+        return keep
 
     def _per_view_pipeline(self, boxes: np.ndarray, scores: np.ndarray,
                            cls_ids: np.ndarray, orig_size: tuple[int, int]
                            ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        boxes, scores, cls_ids = self._filter_sane_boxes(
+        boxes, scores, cls_ids = self._filter_sane_boxes_op(
             boxes, scores, cls_ids, orig_size
         )
         if len(boxes) == 0:
             return boxes, scores, cls_ids
         if len(boxes) > 1:
-            boxes, scores, cls_ids = self._per_class_soft_nms(boxes, scores, cls_ids)
+            keep = self._hard_nms(boxes, scores, self.iou_thres)
+            boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
         if len(scores) > self.max_det:
             top = np.argsort(-scores)[: self.max_det]
             boxes, scores, cls_ids = boxes[top], scores[top], cls_ids[top]
@@ -319,7 +247,7 @@ class Miner:
         scores = preds[:, 4].astype(np.float32)
         cls_ids = preds[:, 5].astype(np.int32)
 
-        keep = scores >= self._conf_thres_array[cls_ids]
+        keep = self._conf_filter_mask(scores, cls_ids)
         boxes = boxes[keep]
         scores = scores[keep]
         cls_ids = cls_ids[keep]
@@ -357,7 +285,7 @@ class Miner:
             cls_ids = np.argmax(cls_part, axis=1).astype(np.int32)
             scores = cls_part[np.arange(len(cls_part)), cls_ids]
 
-        keep = scores >= self._conf_thres_array[cls_ids]
+        keep = self._conf_filter_mask(scores, cls_ids)
         boxes_xywh = boxes_xywh[keep]
         scores = scores[keep]
         cls_ids = cls_ids[keep]
@@ -427,54 +355,12 @@ class Miner:
         outputs = self.session.run(self.output_names, {self.input_name: input_tensor})
         return self._postprocess(outputs[0], ratio, pad, orig_size)
 
-    def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
-        boxes_orig = self._predict_single(image)
-        flipped = cv2.flip(image, 1)
-        boxes_flip = self._predict_single(flipped)
-        w = image.shape[1]
-        boxes_flip = [
-            BoundingBox(
-                x1=w - b.x2, y1=b.y1, x2=w - b.x1, y2=b.y2,
-                cls_id=b.cls_id, conf=b.conf,
-            )
-            for b in boxes_flip
-        ]
-        all_boxes = boxes_orig + boxes_flip
-        if not all_boxes:
-            return []
-
-        coords = np.array(
-            [[b.x1, b.y1, b.x2, b.y2] for b in all_boxes], dtype=np.float32
-        )
-        scores = np.array([b.conf for b in all_boxes], dtype=np.float32)
-        cls_ids = np.array([b.cls_id for b in all_boxes], dtype=np.int32)
-
-        hard_keep = self._per_class_hard_nms(coords, scores, cls_ids, self.iou_thres)
-        if len(hard_keep) == 0:
-            return []
-        hard_keep = hard_keep[: self.max_det]
-        boosted = self._max_score_per_cluster(
-            coords[hard_keep], coords, scores, self.iou_thres
-        )
-
-        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(boosted[j]),
-            )
-            for j, i in enumerate(hard_keep)
-        ]
-
     def predict_batch(self, batch_images: list[ndarray], offset: int,
                       n_keypoints: int) -> list[TVFrameResult]:
         results: list[TVFrameResult] = []
         for frame_number_in_batch, image in enumerate(batch_images):
             try:
-                boxes = self._predict_tta(image)
+                boxes = self._predict_single(image)
             except Exception as e:
                 print(f"Inference failed for frame {offset + frame_number_in_batch}: {e}")
                 boxes = []

readme.md

@@ -10,9 +10,9 @@ tags:
 manako:
   source: winner_fetch
   manifest_element_name: manak0/Detect-fire
-  winner_repo_id: navierstocks/fire-light
-  winner_revision: 95133792375f1fd3e5f192d0494c3b02f770cdc4
-  note: E=0.03088120 (map50=0.600000, size_mb=19.429295)
+  winner_repo_id: navierstocks/disaster
+  winner_revision: 3a0b049b490e28f3d29f0328c2af1a7799217933
+  note: E=0.03088868 (map50=0.600000, size_mb=19.424589)
 ---
 
 ## YOLO26 ONNX detector

weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:40ec65251e308d8240c59ea7704956fc44823e750067e433f287aec71e8939ac
+oid sha256:2cbc3051c706b96f99e0223ca078af3e8fd69d40ee4ca659c6310b6abe2c87a7
 size 19407447