scorevision: push artifact

miner.py

@@ -1,5 +1,5 @@
 """
-Score Vision SN44 — Unified miner v3.21 (2026-04-04). YOLO12s + TRT + bus fix + petrol.
+Score Vision SN44 — Unified miner v3.22 (2026-04-04). YOLO12s + TRT + petrol + veh TTA + conf tune + soft-NMS + PER_MAX_DET=100 (loose safety ceiling) + PER_CONF_LOW=0.60 (precision floor).
 Tri-model: vehicle (YOLO11m INT8 1280) + person (YOLO12s FP16 960 TRT) + petrol (end2end 640).
 Pose model: YOLOv8n-pose FP16 640 for false-positive filtering + keypoint box refinement.
 Vehicle weights loaded from secondary HF repo (meaculpitt/ScoreVision-Vehicle).
@@ -211,10 +211,10 @@ VEH_NMS_IOU = 0.50
 # ── Per-class vehicle confidence thresholds (output cls_id) ────────────────
 # Raising from uniform 0.35: reduces FP (avg 4.1 FFPI → target <2.0)
 VEH_CLASS_CONF: dict[int, float] = {
-    1: 0.45,    # car — most FP-prone class (75% of training data, overconfident)
-    2: 0.45,    # truck — moderate raise
-    3: 0.45,    # motorcycle — raised from 0.35 to reduce FP (small targets, easy to miss)
-    0: 0.45,    # bus — same threshold as car/truck (v3.20: unsuppressed)
+    1: 0.50,    # car — raised from 0.45, most FP-prone class (75% of training data)
+    2: 0.45,    # truck — keep
+    3: 0.50,    # motorcycle — raised from 0.45, small targets prone to FP
+    0: 0.45,    # bus — keep
 }
 
 # ── Per-class vehicle aspect ratio bounds (min_ratio, max_ratio) ───────────
@@ -269,8 +269,12 @@ VEH_PARTS_PLATE_MIN_PX = 120  # only check plates on medium+ vehicles      # Min
 VEH_PARTS_PLATE_CONF = 0.35      # Min plate detection confidence
 
 # ── Person config (TTA consensus) ───────────────────────────────────────────
-PER_CONF_LOW = 0.55
-PER_CONF_HIGH = 0.58
+PER_CONF_LOW = 0.60  # Was 0.55. Raised 2026-04-05 to match top peer precision floor after
+                     # observing the 3-way tied 52-box group (conf_min=0.585, composite=0.280) was
+                     # beaten by top peer's 44-box response (conf_min=0.716, composite=0.377).
+                     # 0.60 targets the precision/recall inflection point without the full 0.65+
+                     # aggression that might cost recall on sparse scenes.
+PER_CONF_HIGH = 0.58  # NOTE: dead code, not referenced anywhere. Kept for reference only.
 PER_CONSENSUS_IOU = 0.50
 PER_RTF_BUDGET = 8.0
 
@@ -285,7 +289,14 @@ PER_TILE_OVERLAP = 0.20          # 20% overlap between tiles
 PER_TILE_MIN_DIM_RATIO = 1.15   # tile when image dim > model_dim * this (~1104px for 960 model)
 PER_TILE_CONF = 0.55            # raised from 0.40 to match PER_CONF_LOW
 PER_NMS_IOU = 0.50              # NMS IoU for merging across passes (max-conf wins)
-PER_MAX_DET = 30                # hard cap on person detections per image (raised from 15: 17% of frames were hitting cap)
+PER_MAX_DET = 100               # Loose safety ceiling ONLY — not a count cap. Strategy is confidence-floor:
+                                # PER_CONF_LOW=0.60 is the real filter; any box above threshold passes.
+                                # Raised from 50 after 2026-04-05 investigation: top peers emit 77+ boxes on
+                                # crowd eval images, and the currently-running chute (rev 6b9d0d6) caps at 30
+                                # which is demonstrably hitting mAP50 0.39 on person crowd blocks. 50 would
+                                # still clip. 100 gives real headroom — only triggers on pathological runaway
+                                # FP cases where NMS has already failed. Previous values (10 spec'd, 50 first
+                                # fix) were too tight. See FAILURE_ANALYSIS.md (2026-04-05).
 
 # ── Frame quality gating (Laplacian variance) ───────────────────────────────
 PER_BLUR_THRESHOLD = 50.0       # Laplacian variance below this = severely blurry
@@ -350,7 +361,7 @@ TRT_WORKSPACE_GB = 4
 WBF_SKIP_THR = 0.0001
 
 # ── Speed config ────────────────────────────────────────────────────────────
-ENABLE_TTA = False
+ENABLE_TTA = True
 ENABLE_PARALLEL = True
 
 # ── Secondary HF repo for vehicle weights ───────────────────────────────────
@@ -796,20 +807,35 @@ class Miner:
         return self._veh_decode(raw, ratio, pl, pt, ow, oh, conf_thresh)
 
     def _infer_vehicle(self, image_bgr):
-        """Vehicle detection: single-pass 1280px, per-class NMS + confidence + aspect filter.
-
-        Pipeline (v3.19 — TTA removed for RTF, saves ~9ms/frame × 274 frames):
-        1. Single pass at VEH_CONF_THRES
-        2. Remap classes, per-class NMS
-        3. Per-class confidence filter (higher thresholds reduce FP)
-        4. Per-class aspect ratio filter
-        5. All 4 classes scored (v3.20: bus unsuppressed, cls_id=0)
+        """Vehicle detection: 1280px with optional flip TTA, per-class NMS + conf + aspect filter.
+
+        Pipeline (v3.22 — flip TTA re-enabled, RTF budget allows it):
+        1. Primary pass at VEH_CONF_THRES
+        2. Optional flip TTA pass at VEH_TTA_CONF (if ENABLE_TTA)
+        3. Remap classes, per-class NMS
+        4. Per-class confidence filter (higher thresholds reduce FP)
+        5. Per-class aspect ratio filter
+        6. All 4 classes scored (v3.20: bus unsuppressed, cls_id=0)
         """
         oh, ow = image_bgr.shape[:2]
 
-        # Single pass — flip TTA removed in v3.19 (RTF 0.89→0.65 for 274 frames)
+        # Primary pass
         boxes, confs, cls_ids = self._veh_run_pass(image_bgr, VEH_CONF_THRES)
 
+        # Flip TTA pass — horizontal flip, mirror boxes back
+        if ENABLE_TTA:
+            flipped = cv2.flip(image_bgr, 1)
+            f_boxes, f_confs, f_cls = self._veh_run_pass(flipped, VEH_TTA_CONF)
+            if len(f_boxes) > 0:
+                # Mirror x-coords: x1'=ow-x2, x2'=ow-x1
+                f_boxes[:, 0], f_boxes[:, 2] = ow - f_boxes[:, 2], ow - f_boxes[:, 0]
+                if len(boxes) > 0:
+                    boxes = np.concatenate([boxes, f_boxes])
+                    confs = np.concatenate([confs, f_confs])
+                    cls_ids = np.concatenate([cls_ids, f_cls])
+                else:
+                    boxes, confs, cls_ids = f_boxes, f_confs, f_cls
+
         if len(boxes) == 0:
             return []
 
@@ -1427,45 +1453,53 @@ class Miner:
         return boxes, confs
 
     @staticmethod
-    def _nms_max_conf(boxes, scores, iou_thr):
-        """NMS that keeps max confidence when boxes overlap.
-
-        Unlike WBF which averages scores (diluting strong detections),
-        this preserves sharp confidence values — critical for FP scoring.
+    @staticmethod
+    def _nms_max_conf(boxes, scores, iou_thr, sigma=0.5, min_conf=0.20):
+        """Soft-NMS with Gaussian decay (replaces hard NMS).
+
+        Instead of suppressing overlapping boxes entirely, decays their
+        confidence: score_j *= exp(-(iou^2) / sigma). This preserves
+        partially-occluded detections in crowds while still penalising
+        duplicates. Boxes whose confidence decays below min_conf are
+        removed.
         """
         if len(boxes) == 0:
             return np.empty((0, 4)), np.empty(0)
 
-        # Sort by confidence descending
-        order = np.argsort(-scores)
-        boxes = boxes[order]
-        scores = scores[order]
-
-        keep_b, keep_s = [], []
-        suppressed = set()
+        b = boxes.copy().astype(np.float64)
+        s = scores.copy().astype(np.float64)
+        n = len(s)
+        indices = list(range(n))
 
-        for i in range(len(boxes)):
-            if i in suppressed:
-                continue
-            keep_b.append(boxes[i])
-            keep_s.append(scores[i])
-
-            # Suppress lower-conf overlapping boxes
-            for j in range(i + 1, len(boxes)):
-                if j in suppressed:
-                    continue
-                xx1 = max(boxes[i, 0], boxes[j, 0])
-                yy1 = max(boxes[i, 1], boxes[j, 1])
-                xx2 = min(boxes[i, 2], boxes[j, 2])
-                yy2 = min(boxes[i, 3], boxes[j, 3])
-                inter = max(0, xx2 - xx1) * max(0, yy2 - yy1)
-                a1 = (boxes[i, 2] - boxes[i, 0]) * (boxes[i, 3] - boxes[i, 1])
-                a2 = (boxes[j, 2] - boxes[j, 0]) * (boxes[j, 3] - boxes[j, 1])
+        for i in range(n):
+            # Find current max-confidence box
+            max_idx = i
+            for j in range(i + 1, n):
+                if s[indices[j]] > s[indices[max_idx]]:
+                    max_idx = j
+            # Swap to front
+            indices[i], indices[max_idx] = indices[max_idx], indices[i]
+
+            ix = indices[i]
+            # Decay overlapping boxes
+            for j in range(i + 1, n):
+                jx = indices[j]
+                xx1 = max(b[ix, 0], b[jx, 0])
+                yy1 = max(b[ix, 1], b[jx, 1])
+                xx2 = min(b[ix, 2], b[jx, 2])
+                yy2 = min(b[ix, 3], b[jx, 3])
+                inter = max(0.0, xx2 - xx1) * max(0.0, yy2 - yy1)
+                a1 = (b[ix, 2] - b[ix, 0]) * (b[ix, 3] - b[ix, 1])
+                a2 = (b[jx, 2] - b[jx, 0]) * (b[jx, 3] - b[jx, 1])
                 iou = inter / (a1 + a2 - inter + 1e-9)
-                if iou >= iou_thr:
-                    suppressed.add(j)
+                if iou > 0:
+                    s[jx] *= np.exp(-(iou * iou) / sigma)
 
-        return np.array(keep_b), np.array(keep_s)
+        # Keep boxes above min_conf
+        keep = [indices[i] for i in range(n) if s[indices[i]] >= min_conf]
+        if not keep:
+            return np.empty((0, 4)), np.empty(0)
+        return b[keep], s[keep]
 
     # ── Pose FP filter + box refinement ──────────────────────────────────
 
@@ -1844,7 +1878,7 @@ class Miner:
         1. Full-image pass at native 960px
         2. Flip TTA pass
         3. Dynamic NMS merge (adapts IoU threshold to scene density)
-        4. Sanity filters + PER_MAX_DET cap
+        4. Sanity filters + PER_MAX_DET safety ceiling (conf-floor is the real filter)
         5. Pose FP filter + box refinement (if time allows)
         """
         oh, ow = image_bgr.shape[:2]
@@ -1894,7 +1928,8 @@ class Miner:
         nms_iou = 0.60 if n_raw > 30 else (0.40 if n_raw < 10 else PER_NMS_IOU)
         merged_b, merged_s = self._nms_max_conf(merged_b, merged_s, nms_iou)
 
-        # Hard cap on max detections (FP protection)
+        # Safety ceiling (not a count cap). PER_CONF_LOW=0.60 is the real filter.
+        # This only activates on pathological runaway-FP cases (>50 boxes post-NMS).
         if len(merged_s) > PER_MAX_DET:
             top_idx = np.argsort(merged_s)[-PER_MAX_DET:]
             merged_b = merged_b[top_idx]