scorevision: push artifact

miner.py

@@ -1,6 +1,6 @@
 """
-Score Vision SN44 — Unified miner v3.16 (2026-04-03). YOLO12s + TRT + CLAHE.
-Dual-model: vehicle (YOLO11m INT8 1280, CUDA) + person (YOLO12s FP16 960 end2end, TRT).
+Score Vision SN44 — Unified miner v3.19 (2026-04-04). YOLO12s + TRT + element detect.
+Dual-model: vehicle (YOLO11m INT8 1280, 1-pass) + person (YOLO12s FP16 960 end2end, TRT).
 Pose model: YOLOv8n-pose FP16 640 for false-positive filtering + keypoint box refinement.
 Vehicle weights loaded from secondary HF repo (meaculpitt/ScoreVision-Vehicle).
 Person weights loaded from primary HF repo (template downloads automatically).
@@ -10,7 +10,7 @@ Vehicle model (vehicle_weights.onnx):
   Output: 1=car, 2=truck, 3=motorcycle. Bus (cls_id=4) SUPPRESSED — not scored by validator.
   Per-class confidence thresholds: car 0.45, truck 0.45, motorcycle 0.35.
   Per-class aspect ratio bounds for FP filtering.
-  Flip TTA always enabled — compensates for higher confidence thresholds.
+  Single-pass (v3.19) — flip TTA removed for RTF improvement.
 
 Person model (person_weights.onnx):
   YOLO12s FP16 960px end2end [1,300,6]. Single class: 0=person.
@@ -293,6 +293,12 @@ PER_BLUR_CONF_PENALTY = 0.85    # multiply confs by this for blurry frames (redu
 PER_CLAHE_CLIP = 2.0            # mild CLAHE (was 12.0, too aggressive)
 PER_CLAHE_CONTRAST_THRESH = 40.0  # only apply CLAHE when L-channel std < this
 
+# ── Perspective scaling confidence penalty ─────────────────────────────────
+PERSP_DEVIATION_THRESH = 3.0    # ratio >3x or <1/3x triggers penalty
+PERSP_CONF_PENALTY = 0.85       # multiply conf by this for perspective violations
+PERSP_MIN_DETECTIONS = 3        # need ≥3 detections to estimate model
+PERSP_MIN_Y_SPREAD = 0.15       # min y-spread as fraction of image height
+
 # ── Pose FP filter + box refinement config ──────────────────────────────────
 POSE_CONF_THRESH = 0.25         # Minimum confidence for pose detection
 POSE_NMS_IOU = 0.65             # NMS IoU threshold for pose detections
@@ -731,31 +737,19 @@ class Miner:
         return self._veh_decode(raw, ratio, pl, pt, ow, oh, conf_thresh)
 
     def _infer_vehicle(self, image_bgr):
-        """Vehicle detection with flip TTA, per-class confidence, and aspect ratio filtering.
-
-        Pipeline:
-        1. Original pass at VEH_CONF_THRES
-        2. Flip TTA pass at VEH_TTA_CONF (always enabled)
-        3. Remap classes, per-class NMS
-        4. Per-class confidence filter (higher thresholds reduce FP)
-        5. Per-class aspect ratio filter
-        6. Skip bus (cls_id=4, not scored by validator)
+        """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. Skip bus (cls_id=4, not scored by validator)
         """
         oh, ow = image_bgr.shape[:2]
 
-        # Always run flip TTA for vehicle — compensates for higher per-class thresholds
-        boxes1, confs1, cls1 = self._veh_run_pass(image_bgr, VEH_CONF_THRES)
-        flipped = cv2.flip(image_bgr, 1)
-        boxes2, confs2, cls2 = self._veh_run_pass(flipped, VEH_TTA_CONF)
-        if len(boxes2):
-            boxes2[:, 0], boxes2[:, 2] = ow - boxes2[:, 2], ow - boxes2[:, 0]
-        parts = [(b, s, c) for b, s, c in
-                 [(boxes1, confs1, cls1), (boxes2, confs2, cls2)] if len(b)]
-        if not parts:
-            return []
-        boxes = np.concatenate([p[0] for p in parts])
-        confs = np.concatenate([p[1] for p in parts])
-        cls_ids = np.concatenate([p[2] for p in parts])
+        # Single pass — flip TTA removed in v3.19 (RTF 0.89→0.65 for 274 frames)
+        boxes, confs, cls_ids = self._veh_run_pass(image_bgr, VEH_CONF_THRES)
 
         if len(boxes) == 0:
             return []
@@ -1239,6 +1233,51 @@ class Miner:
         gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
         return cv2.Laplacian(gray, cv2.CV_64F).var()
 
+    @staticmethod
+    def _perspective_penalty(boxes, confs, image_h):
+        """Apply confidence penalty to perspective-anomalous person detections.
+
+        Model: expected_height(y) = alpha * (y_foot - y_vp), where y_vp = image_h / 3.
+        Alpha is estimated from the median height/distance ratio across detections.
+        Detections deviating >3x from expected get conf *= 0.85.
+        Fails open (returns confs unchanged) when model can't be estimated.
+        """
+        n = len(boxes)
+        if n < PERSP_MIN_DETECTIONS:
+            return confs
+
+        y_vp = image_h / 3.0
+        y_feet = boxes[:, 3]
+        heights = boxes[:, 3] - boxes[:, 1]
+
+        valid = y_feet > (y_vp + 10)
+        if valid.sum() < PERSP_MIN_DETECTIONS:
+            return confs
+
+        valid_y = y_feet[valid]
+        valid_h = heights[valid]
+
+        y_spread = (valid_y.max() - valid_y.min()) / image_h
+        if y_spread < PERSP_MIN_Y_SPREAD:
+            return confs
+
+        alpha = float(np.median(valid_h / (valid_y - y_vp)))
+        if alpha <= 0.01:
+            return confs
+
+        new_confs = confs.copy()
+        for i in range(n):
+            if y_feet[i] <= y_vp:
+                continue
+            expected_h = alpha * (y_feet[i] - y_vp)
+            if expected_h <= 0:
+                continue
+            ratio = heights[i] / expected_h
+            if ratio > PERSP_DEVIATION_THRESH or ratio < (1.0 / PERSP_DEVIATION_THRESH):
+                new_confs[i] *= PERSP_CONF_PENALTY
+
+        return new_confs
+
     def _per_decode(self, raw, ratio, pl, pt, oh, ow, conf_thresh):
         pred = raw[0]
         if pred.ndim != 2:
@@ -1777,6 +1816,15 @@ class Miner:
             all_boxes.append(boxes_flip)
             all_confs.append(confs_flip)
 
+        # Pass 3: CLAHE enhanced pass (low-contrast frames only, time-gated)
+        if time.monotonic() - t_start < PER_RTF_BUDGET * 0.5:
+            enhanced = self._per_enhance(image_bgr)
+            if enhanced is not image_bgr:  # CLAHE was applied (low contrast)
+                boxes_enh, confs_enh = self._per_run_pass(enhanced, PER_CONF_LOW)
+                if len(boxes_enh) > 0:
+                    all_boxes.append(boxes_enh)
+                    all_confs.append(confs_enh)
+
         if not all_boxes:
             return []
 
@@ -1800,6 +1848,9 @@ class Miner:
         if is_blurry:
             merged_s = merged_s * PER_BLUR_CONF_PENALTY
 
+        # Perspective scaling penalty — reduce conf for size-anomalous detections
+        merged_s = self._perspective_penalty(merged_b, merged_s, oh)
+
         # Sanity filters
         img_area = float(oh * ow)
         out = []
@@ -1866,9 +1917,10 @@ class Miner:
             return self._infer_person(image_bgr)
 
         if element_hint == 'vehicle':
-            vehicle_boxes = self._infer_vehicle(image_bgr)
-            vehicle_boxes = self._vehicle_parts_confirm(vehicle_boxes, [], image_bgr)
-            return vehicle_boxes
+            # Skip _vehicle_parts_confirm — it needs person_boxes for driver/rider
+            # confirmation which aren't available in vehicle-only mode. Without person
+            # detections, large vehicles with conf < 0.55 get falsely suppressed.
+            return self._infer_vehicle(image_bgr)
 
         # Fallback: run both (original behavior)
         if ENABLE_PARALLEL:
@@ -1986,4 +2038,4 @@ class Miner:
         ).start()
 
         return results
-# Miner v3.18 — element detection + per-step timing — background TRT engine build + CUDA-first fallback 20260402
+# Miner v3.19 — 1-pass vehicle + CLAHE pass + parts_confirm fix — element detection + per-step timing — background TRT engine build + CUDA-first fallback 20260402