scorevision: push artifact

miner.py

@@ -173,6 +173,18 @@ import json
 import threading
 from datetime import datetime, timezone
 from concurrent.futures import ThreadPoolExecutor, as_completed
+import inspect
+
+# ── Latency logger (per-request timing to /home/miner/latency.log) ──────
+import logging as _lat_logging
+_lat_logger = _lat_logging.getLogger("sv_latency")
+_lat_logger.setLevel(_lat_logging.INFO)
+_lat_logger.propagate = False
+if not _lat_logger.handlers:
+    _lat_fh = _lat_logging.FileHandler("/home/miner/latency.log")
+    _lat_fh.setFormatter(_lat_logging.Formatter(
+        "%(asctime)s.%(msecs)03d %(message)s", datefmt="%Y-%m-%d %H:%M:%S"))
+    _lat_logger.addHandler(_lat_fh)
 
 logger = logging.getLogger(__name__)
 
@@ -263,6 +275,14 @@ 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 = 15                # hard cap on person detections per image
 
+# ── Frame quality gating (Laplacian variance) ───────────────────────────────
+PER_BLUR_THRESHOLD = 50.0       # Laplacian variance below this = severely blurry
+PER_BLUR_CONF_PENALTY = 0.85    # multiply confs by this for blurry frames (reduce FP)
+
+# ── Adaptive CLAHE config ───────────────────────────────────────────────────
+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
+
 # ── 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
@@ -1194,12 +1214,20 @@ class Miner:
         return inp, ratio, pl, pt
 
     def _per_enhance(self, img_bgr):
-        """CLAHE contrast enhancement (clip=12) on LAB L-channel."""
+        """Adaptive CLAHE: only apply to low-contrast frames, mild clip=2.0."""
         lab = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2LAB)
         l, a, b = cv2.split(lab)
-        clahe = cv2.createCLAHE(clipLimit=12.0, tileGridSize=(8, 8))
-        l = clahe.apply(l)
-        return cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
+        if float(l.std()) < PER_CLAHE_CONTRAST_THRESH:
+            clahe = cv2.createCLAHE(clipLimit=PER_CLAHE_CLIP, tileGridSize=(8, 8))
+            l = clahe.apply(l)
+            return cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
+        return img_bgr  # skip CLAHE on normal-contrast images
+
+    @staticmethod
+    def _frame_blur_score(img_bgr):
+        """Laplacian variance blur metric. Lower = blurrier."""
+        gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+        return cv2.Laplacian(gray, cv2.CV_64F).var()
 
     def _per_decode(self, raw, ratio, pl, pt, oh, ow, conf_thresh):
         pred = raw[0]
@@ -1714,6 +1742,10 @@ class Miner:
         oh, ow = image_bgr.shape[:2]
         t_start = time.monotonic()
 
+        # Frame quality gating — detect severely blurry frames
+        blur_score = self._frame_blur_score(image_bgr)
+        is_blurry = blur_score < PER_BLUR_THRESHOLD
+
         # Collect all boxes in original pixel coords
         all_boxes = []   # list of [N, 4] arrays
         all_confs = []   # list of [N] arrays
@@ -1754,6 +1786,10 @@ class Miner:
         if len(merged_b) == 0:
             return []
 
+        # Blur confidence penalty — reduce FP on severely blurry frames
+        if is_blurry:
+            merged_s = merged_s * PER_BLUR_CONF_PENALTY
+
         # Sanity filters
         img_area = float(oh * ow)
         out = []
@@ -1785,10 +1821,46 @@ class Miner:
 
         return out
 
+    # ── Element detection (stack frame inspection) ──────────────────────────
+    _CHALLENGE_TYPE_MAP = {2: 'person', 12: 'vehicle'}
+
+    def _detect_element_hint(self) -> str:
+        """Detect whether this request is for person or vehicle.
+
+        Reads challenge_type_id from the chute template predict() metadata
+        via stack frame inspection. Returns 'person', 'vehicle', or 'both'.
+        """
+        frame = None
+        try:
+            frame = inspect.currentframe()
+            for _ in range(10):
+                frame = frame.f_back
+                if frame is None:
+                    break
+                meta = frame.f_locals.get('metadata')
+                if isinstance(meta, dict) and 'challenge_type_id' in meta:
+                    ct_id = meta['challenge_type_id']
+                    return self._CHALLENGE_TYPE_MAP.get(ct_id, 'both')
+        except Exception:
+            pass
+        finally:
+            del frame
+        return 'both'
+
     # ── Unified inference ──────────────────────────────────���────────────────
 
-    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+    def _infer_single(self, image_bgr: ndarray, element_hint: str = 'both') -> list[BoundingBox]:
         self._cached_pose_data = None  # reset before each frame
+
+        if element_hint == 'person':
+            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
+
+        # Fallback: run both (original behavior)
         if ENABLE_PARALLEL:
             veh_future = self._executor.submit(self._infer_vehicle, image_bgr)
             per_future = self._executor.submit(self._infer_person, image_bgr)
@@ -1856,21 +1928,46 @@ class Miner:
     ) -> list[TVFrameResult]:
         t_start = time.perf_counter()
 
+        # Detect element type from caller metadata
+        element_hint = self._detect_element_hint()
+        t_setup = time.perf_counter()
+        dt_setup = (t_setup - t_start) * 1000
+
+        _lat_logger.info(
+            "REQUEST batch=%d hint=%s setup=%.1fms",
+            len(batch_images), element_hint, dt_setup,
+        )
+
         results: list[TVFrameResult] = []
         for idx, image in enumerate(batch_images):
             t_img = time.perf_counter()
-            boxes = self._infer_single(image)
-            dt_img = (time.perf_counter() - t_img) * 1000
-            logger.info(f"[miner] image {idx}: {len(boxes)} boxes in {dt_img:.0f}ms "
-                        f"(shape={image.shape}, TTA={ENABLE_TTA}, PAR={ENABLE_PARALLEL})")
+            boxes = self._infer_single(image, element_hint=element_hint)
+            t_post = time.perf_counter()
+            dt_infer = (t_post - t_img) * 1000
+
             keypoints = [(0, 0) for _ in range(max(0, int(n_keypoints)))]
             results.append(TVFrameResult(
                 frame_id=offset + idx, boxes=boxes, keypoints=keypoints,
             ))
-
-        dt_total = (time.perf_counter() - t_start) * 1000
+            dt_post = (time.perf_counter() - t_post) * 1000
+
+            if idx < 3 or idx == len(batch_images) - 1:
+                _lat_logger.info(
+                    "  IMG %d/%d boxes=%d infer=%.1fms post=%.1fms shape=%s",
+                    idx, len(batch_images), len(boxes), dt_infer, dt_post,
+                    image.shape,
+                )
+
+        t_done = time.perf_counter()
+        dt_total = (t_done - t_start) * 1000
+        total_boxes = sum(len(r.boxes) for r in results)
+
+        _lat_logger.info(
+            "DONE batch=%d boxes=%d total=%.1fms setup=%.1fms hint=%s",
+            len(batch_images), total_boxes, dt_total, dt_setup, element_hint,
+        )
         logger.info(f"[miner] predict_batch: {len(batch_images)} images, "
-                    f"{sum(len(r.boxes) for r in results)} total boxes, {dt_total:.0f}ms")
+                    f"{total_boxes} total boxes, {dt_total:.0f}ms (hint={element_hint})")
 
         threading.Thread(
             target=self._replay_save,
@@ -1879,4 +1976,4 @@ class Miner:
         ).start()
 
         return results
-# Miner v3.15 — background TRT engine build + CUDA-first fallback 20260402
+# Miner v3.18 — element detection + per-step timing — background TRT engine build + CUDA-first fallback 20260402