Upload folder using huggingface_hub

miner.py

@@ -18,7 +18,7 @@ class BoundingBox(BaseModel):
 
 
 class TVFrameResult(BaseModel):
-    frame_id: int
+    frame_id: int12
     boxes: list[BoundingBox]
     keypoints: list[tuple[int, int]]
 
@@ -71,11 +71,18 @@ 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.0
-        self.iou_thres = 0.6
-        self.max_det = 300
+        # Tuned for validator scoring: reduce FP (FALSE_POSITIVE pillar),
+        # preserve recall (MAP50, RECALL), improve precision.
+        self.conf_thres = 0.2  # Higher = fewer FP, slightly lower recall
+        self.iou_thres = 0.5   # Lower = suppress duplicate detections (FP)
+        self.max_det = 100     # Cap detections; sports ~20-30 persons
         self.use_tta = True
 
+        # Box sanity: filter tiny/spurious detections (common FP source)
+        self.min_box_area = 12 * 12  # ~144 px²
+        self.min_side = 8
+        self.max_aspect_ratio = 8.0
+
         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}")
@@ -264,6 +271,45 @@ class Miner:
                     suppressed[jdx] = True
         return np.array(keep)
 
+    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]:
+        """Filter out tiny, degenerate, or implausible boxes (common FP)."""
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        orig_w, orig_h = orig_size
+        image_area = float(orig_w * orig_h)
+        keep = []
+        for i, box in enumerate(boxes):
+            x1, y1, x2, y2 = box.tolist()
+            bw = x2 - x1
+            bh = y2 - y1
+            if bw <= 0 or bh <= 0:
+                continue
+            if bw < self.min_side or bh < self.min_side:
+                continue
+            area = bw * bh
+            if area < self.min_box_area:
+                continue
+            if area > 0.95 * image_area:
+                continue
+            ar = max(bw / max(bh, 1e-6), bh / max(bw, 1e-6))
+            if ar > self.max_aspect_ratio:
+                continue
+            keep.append(i)
+        if not keep:
+            return (
+                np.empty((0, 4), dtype=np.float32),
+                np.empty((0,), dtype=np.float32),
+                np.empty((0,), dtype=np.int32),
+            )
+        k = np.array(keep, dtype=np.intp)
+        return boxes[k], scores[k], cls_ids[k]
+
     @staticmethod
     def _max_score_per_cluster(
         coords: np.ndarray,
@@ -336,10 +382,25 @@ class Miner:
         boxes /= ratio
         boxes = self._clip_boxes(boxes, (orig_w, orig_h))
 
-        if apply_optional_dedup and len(boxes) > 1:
-            keep_idx, scores = self._soft_nms(boxes, scores)
-            boxes = boxes[keep_idx]
-            cls_ids = cls_ids[keep_idx]
+        # Box sanity filter (reduces FP)
+        boxes, scores, cls_ids = self._filter_sane_boxes(
+            boxes, scores, cls_ids, orig_size
+        )
+        if len(boxes) == 0:
+            return []
+
+        # NMS to remove duplicates (model may output overlapping boxes)
+        if len(boxes) > 1:
+            if apply_optional_dedup:
+                keep_idx, scores = self._soft_nms(boxes, scores)
+                boxes = boxes[keep_idx]
+                cls_ids = cls_ids[keep_idx]
+            else:
+                keep_idx = self._hard_nms(boxes, scores, self.iou_thres)
+                keep_idx = keep_idx[: self.max_det]
+                boxes = boxes[keep_idx]
+                scores = scores[keep_idx]
+                cls_ids = cls_ids[keep_idx]
 
         results: list[BoundingBox] = []
         for box, conf, cls_id in zip(boxes, scores, cls_ids):
@@ -408,11 +469,11 @@ class Miner:
             return []
 
         boxes = self._xywh_to_xyxy(boxes_xywh)
-        keep_idx, scores = self._soft_nms(boxes, scores)
-        keep_idx = keep_idx[: self.max_det]
-        scores = scores[: self.max_det]
 
+        keep_idx = self._hard_nms(boxes, scores, self.iou_thres)
+        keep_idx = keep_idx[: self.max_det]
         boxes = boxes[keep_idx]
+        scores = scores[keep_idx]
         cls_ids = cls_ids[keep_idx]
 
         pad_w, pad_h = pad
@@ -423,6 +484,12 @@ class Miner:
         boxes /= ratio
         boxes = self._clip_boxes(boxes, (orig_w, orig_h))
 
+        boxes, scores, cls_ids = self._filter_sane_boxes(
+            boxes, scores, cls_ids, (orig_w, orig_h)
+        )
+        if len(boxes) == 0:
+            return []
+
         results: list[BoundingBox] = []
         for box, conf, cls_id in zip(boxes, scores, cls_ids):
             x1, y1, x2, y2 = box.tolist()
@@ -493,7 +560,11 @@ class Miner:
         return self._postprocess(det_output, ratio, pad, orig_size)
 
     def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
-        """Horizontal-flip TTA: merge original + flipped via hard NMS."""
+        """
+        Horizontal-flip TTA: merge original + flipped via hard NMS.
+        Boost confidence for consensus detections (both views agree) to improve
+        mAP: validator sorts by confidence, so higher conf for TP helps PR curve.
+        """
         boxes_orig = self._predict_single(image)
 
         flipped = cv2.flip(image, 1)
@@ -521,9 +592,13 @@ class Miner:
         if len(hard_keep) == 0:
             return []
 
-        # _hard_nms already orders kept indices by descending score.
         hard_keep = hard_keep[: self.max_det]
 
+        # Boost confidence when both views agree (overlapping detections)
+        boosted = self._max_score_per_cluster(
+            coords, scores, hard_keep, self.iou_thres
+        )
+
         return [
             BoundingBox(
                 x1=all_boxes[i].x1,
@@ -531,9 +606,9 @@ class Miner:
                 x2=all_boxes[i].x2,
                 y2=all_boxes[i].y2,
                 cls_id=all_boxes[i].cls_id,
-                conf=float(scores[i]),
+                conf=float(boosted[j]),
             )
-            for i in hard_keep
+            for j, i in enumerate(hard_keep)
         ]
 
     def predict_batch(