scorevision: push artifact

chute_config.yml

@@ -8,7 +8,7 @@ Image:
 NodeSelector:
   gpu_count: 1
   min_vram_gb_per_gpu: 16
-  max_hourly_price_per_gpu: 2.0
+  max_hourly_price_per_gpu: 0.50
   exclude:
   - '5090'
   - b200

miner.py

@@ -1,6 +1,6 @@
 """
-Score Vision SN44 — Unified miner v3.20 (2026-04-04). YOLO12s + TRT + bus fix.
-Dual-model: vehicle (YOLO11m INT8 1280, 1-pass) + person (YOLO12s FP16 960 end2end, TRT).
+Score Vision SN44 — Unified miner v3.21 (2026-04-04). YOLO12s + TRT + bus fix + petrol.
+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).
 Person weights loaded from primary HF repo (template downloads automatically).
@@ -27,8 +27,10 @@ Pose model (pose_weights.onnx):
   3. Box refinement: blend detected box with tight keypoint bbox for better fit.
   Face detector (optional): if face_session loaded, face inside box → never suppress.
 
-Both vehicle + person models run on every image. All detections merged.
+Vehicle + person models run on every image when hint='both'. All detections merged.
 Vehicle eval uses cls_id 1-3. Person eval uses cls_id 0 only.
+Petrol model runs only when challenge_type_id is unrecognized (not 2 or 12).
+Petrol weights loaded from meaculpitt/ScoreVision-Petrol HF repo.
 """
 
 import os
@@ -283,7 +285,7 @@ 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 = 15                # hard cap on person detections per image
+PER_MAX_DET = 30                # hard cap on person detections per image (raised from 15: 17% of frames were hitting cap)
 
 # ── Frame quality gating (Laplacian variance) ───────────────────────────────
 PER_BLUR_THRESHOLD = 50.0       # Laplacian variance below this = severely blurry
@@ -354,6 +356,29 @@ ENABLE_PARALLEL = True
 # ── Secondary HF repo for vehicle weights ───────────────────────────────────
 VEHICLE_HF_REPO = "meaculpitt/ScoreVision-Vehicle"
 
+# ── Petrol config ───────────────────────────────────────────────────────────
+PETROL_HF_REPO = "meaculpitt/ScoreVision-Petrol"
+PETROL_CONF = 0.25
+PETROL_IOU = 0.45
+# Class IDs (petrol model output — independent of person/vehicle cls_ids
+# because element_hint routing ensures only one pipeline runs per challenge)
+PETROL_CLS_HOSE = 0
+PETROL_CLS_PUMP = 1
+PETROL_CLS_PRICEBOARD = 2
+PETROL_CLS_CANOPY = 3
+# Geometric validation thresholds
+PETROL_CANOPY_MIN_ASPECT = 0.8
+PETROL_PUMP_MAX_ASPECT = 4.0
+PETROL_PRICEBOARD_MAX_AREA_FRAC = 0.15
+PETROL_HOSE_MIN_AREA_FRAC = 0.0005
+PETROL_GEOM_PENALTY = 0.10
+# Spatial co-occurrence
+PETROL_COOCCUR_PUMP_CANOPY = 0.05
+PETROL_COOCCUR_PUMP_HOSE = 0.08
+PETROL_COOCCUR_CANOPY_HOSE = 0.05
+PETROL_COOCCUR_SUPPRESS = 0.03
+PETROL_COOCCUR_PROXIMITY = 0.5
+
 
 def _wbf_multi(boxes_list, scores_list, labels_list, iou_thr=0.55, skip_thr=0.0001):
     """Weighted Boxes Fusion (multi-class). Boxes in [0,1] normalized coords."""
@@ -624,6 +649,40 @@ class Miner:
             self.plate_session = None
             logger.info("[init] No plate model found, plate confirmation disabled")
 
+        # Petrol model — download from dedicated HF repo
+        try:
+            from huggingface_hub import snapshot_download as _sd
+            petrol_path = Path(_sd(PETROL_HF_REPO))
+            petrol_weights = str(petrol_path / "weights.onnx")
+            logger.info(f"[init] Petrol weights from {PETROL_HF_REPO}")
+        except Exception as e:
+            logger.warning(f"[init] Petrol secondary repo failed ({e}), trying primary repo")
+            petrol_weights = str(path_hf_repo / "weights.onnx")
+            if not Path(petrol_weights).exists():
+                petrol_weights = None
+                logger.warning("[init] No petrol weights found — petrol inference disabled")
+
+        if petrol_weights and Path(petrol_weights).exists():
+            self.petrol_session = ort.InferenceSession(
+                petrol_weights,
+                providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+            )
+            self.petrol_input_name = self.petrol_session.get_inputs()[0].name
+            petrol_shape = self.petrol_session.get_inputs()[0].shape
+            self.petrol_h = int(petrol_shape[2])
+            self.petrol_w = int(petrol_shape[3])
+            # Detect output format
+            petrol_out_shape = self.petrol_session.get_outputs()[0].shape
+            self._petrol_end2end = (
+                len(petrol_out_shape) == 3
+                and petrol_out_shape[2] == 6
+                and (petrol_out_shape[1] or 0) <= 1000
+            )
+            logger.info(f"[init] Petrol model loaded: {petrol_shape}, end2end={self._petrol_end2end}")
+        else:
+            self.petrol_session = None
+            self._petrol_end2end = False
+
         # Pose cache — populated by _pose_filter_refine, read by vehicle parts
         self._cached_pose_data = None
 
@@ -1886,10 +1945,12 @@ class Miner:
     _CHALLENGE_TYPE_MAP = {2: 'person', 12: 'vehicle'}
 
     def _detect_element_hint(self) -> str:
-        """Detect whether this request is for person or vehicle.
+        """Detect whether this request is for person, vehicle, or petrol.
 
         Reads challenge_type_id from the chute template predict() metadata
-        via stack frame inspection. Returns 'person', 'vehicle', or 'both'.
+        via stack frame inspection. Returns 'person', 'vehicle', 'petrol', or 'both'.
+        Any unrecognized challenge_type_id routes to petrol (the only other
+        element on this chute).
         """
         frame = None
         try:
@@ -1901,7 +1962,10 @@ class Miner:
                 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')
+                    hint = self._CHALLENGE_TYPE_MAP.get(ct_id)
+                    if hint:
+                        return hint
+                    return 'petrol' if self.petrol_session else 'both'
         except Exception:
             pass
         finally:
@@ -1922,6 +1986,9 @@ class Miner:
             # detections, large vehicles with conf < 0.55 get falsely suppressed.
             return self._infer_vehicle(image_bgr)
 
+        if element_hint == 'petrol' and self.petrol_session:
+            return self._infer_petrol(image_bgr)
+
         # Fallback: run both (original behavior)
         if ENABLE_PARALLEL:
             veh_future = self._executor.submit(self._infer_vehicle, image_bgr)
@@ -1938,6 +2005,187 @@ class Miner:
 
         return vehicle_boxes + person_boxes
 
+    # ── Petrol inference pipeline ───────────────────────────────────────────
+
+    def _petrol_preprocess(self, image_bgr: ndarray):
+        """Resize to model input, normalize to [0,1] float32 NCHW."""
+        h, w = image_bgr.shape[:2]
+        rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+        resized = cv2.resize(rgb, (self.petrol_w, self.petrol_h))
+        x = resized.astype(np.float32) / 255.0
+        x = np.transpose(x, (2, 0, 1))[None, ...]
+        return x, (h, w)
+
+    def _petrol_decode_end2end(self, out, orig_h, orig_w):
+        """Decode end-to-end [1, N, 6] output: [x1,y1,x2,y2,conf,cls_id]."""
+        pred = out[0]
+        if pred.ndim != 2 or pred.shape[1] != 6:
+            return []
+        confs = pred[:, 4]
+        keep = confs >= PETROL_CONF
+        pred = pred[keep]
+        if pred.shape[0] == 0:
+            return []
+        sx = orig_w / float(self.petrol_w)
+        sy = orig_h / float(self.petrol_h)
+        results = []
+        for i in range(pred.shape[0]):
+            results.append((
+                pred[i, 0] * sx, pred[i, 1] * sy,
+                pred[i, 2] * sx, pred[i, 3] * sy,
+                float(pred[i, 4]), int(pred[i, 5]),
+            ))
+        return results
+
+    def _petrol_decode_raw(self, out, orig_h, orig_w):
+        """Decode raw [1, 4+nc, N] output with NMS."""
+        pred = out[0]
+        if pred.ndim != 2:
+            return []
+        if pred.shape[0] < pred.shape[1]:
+            pred = pred.T
+        if pred.shape[1] < 5:
+            return []
+        boxes = pred[:, :4]
+        cls_scores = pred[:, 4:]
+        if cls_scores.shape[1] == 0:
+            return []
+        cls_ids = np.argmax(cls_scores, axis=1)
+        confs = np.max(cls_scores, axis=1)
+        keep = confs >= PETROL_CONF
+        boxes, confs, cls_ids = boxes[keep], confs[keep], cls_ids[keep]
+        if boxes.shape[0] == 0:
+            return []
+        sx = orig_w / float(self.petrol_w)
+        sy = orig_h / float(self.petrol_h)
+        dets = []
+        for i in range(boxes.shape[0]):
+            cx, cy, bw, bh = boxes[i].tolist()
+            dets.append((
+                (cx - bw / 2.0) * sx, (cy - bh / 2.0) * sy,
+                (cx + bw / 2.0) * sx, (cy + bh / 2.0) * sy,
+                float(confs[i]), int(cls_ids[i]),
+            ))
+        # Simple NMS
+        if not dets:
+            return dets
+        arr_b = np.array([[d[0], d[1], d[2], d[3]] for d in dets], dtype=np.float32)
+        arr_s = np.array([d[4] for d in dets], dtype=np.float32)
+        order = arr_s.argsort()[::-1]
+        kept = []
+        while order.size > 0:
+            i = order[0]
+            kept.append(i)
+            xx1 = np.maximum(arr_b[i, 0], arr_b[order[1:], 0])
+            yy1 = np.maximum(arr_b[i, 1], arr_b[order[1:], 1])
+            xx2 = np.minimum(arr_b[i, 2], arr_b[order[1:], 2])
+            yy2 = np.minimum(arr_b[i, 3], arr_b[order[1:], 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            area_i = (arr_b[i, 2] - arr_b[i, 0]) * (arr_b[i, 3] - arr_b[i, 1])
+            area_r = (arr_b[order[1:], 2] - arr_b[order[1:], 0]) * (arr_b[order[1:], 3] - arr_b[order[1:], 1])
+            iou = inter / np.maximum(area_i + area_r - inter, 1e-6)
+            order = order[np.where(iou <= PETROL_IOU)[0] + 1]
+        return [dets[idx] for idx in kept]
+
+    def _petrol_geometric_validate(self, dets, orig_h, orig_w):
+        """Per-class shape filters: aspect ratio + area checks."""
+        img_area = max(orig_h * orig_w, 1)
+        result = []
+        for x1, y1, x2, y2, conf, cls_id in dets:
+            bw = max(x2 - x1, 1)
+            bh = max(y2 - y1, 1)
+            aspect = bw / bh
+            area_frac = (bw * bh) / img_area
+            penalty = 0.0
+            if cls_id == PETROL_CLS_CANOPY and aspect < PETROL_CANOPY_MIN_ASPECT:
+                penalty = PETROL_GEOM_PENALTY
+            elif cls_id == PETROL_CLS_PUMP and aspect > PETROL_PUMP_MAX_ASPECT:
+                penalty = PETROL_GEOM_PENALTY
+            elif cls_id == PETROL_CLS_PRICEBOARD and area_frac > PETROL_PRICEBOARD_MAX_AREA_FRAC:
+                penalty = PETROL_GEOM_PENALTY
+            elif cls_id == PETROL_CLS_HOSE and area_frac < PETROL_HOSE_MIN_AREA_FRAC:
+                penalty = PETROL_GEOM_PENALTY
+            new_conf = max(0.0, conf - penalty)
+            if new_conf >= PETROL_CONF:
+                result.append((x1, y1, x2, y2, new_conf, cls_id))
+        return result
+
+    def _petrol_spatial_cooccurrence(self, dets, orig_h, orig_w):
+        """Proximity-based confidence adjustments for petrol objects."""
+        if not dets:
+            return dets
+        n = len(dets)
+        adjustments = [0.0] * n
+        diag = math.sqrt(orig_h ** 2 + orig_w ** 2)
+        prox = PETROL_COOCCUR_PROXIMITY * diag
+
+        centers = [((x1 + x2) / 2, (y1 + y2) / 2) for x1, y1, x2, y2, _, _ in dets]
+        cls_map = {}
+        for i, (_, _, _, _, _, cls_id) in enumerate(dets):
+            cls_map.setdefault(cls_id, []).append(i)
+
+        def near(i, j):
+            dx = centers[i][0] - centers[j][0]
+            dy = centers[i][1] - centers[j][1]
+            return math.sqrt(dx * dx + dy * dy) < prox
+
+        # Pump + Canopy boost
+        for pi in cls_map.get(PETROL_CLS_PUMP, []):
+            for ci in cls_map.get(PETROL_CLS_CANOPY, []):
+                if near(pi, ci):
+                    adjustments[pi] = max(adjustments[pi], PETROL_COOCCUR_PUMP_CANOPY)
+                    adjustments[ci] = max(adjustments[ci], PETROL_COOCCUR_PUMP_CANOPY)
+        # Pump + Hose boost
+        for pi in cls_map.get(PETROL_CLS_PUMP, []):
+            for hi in cls_map.get(PETROL_CLS_HOSE, []):
+                if near(pi, hi):
+                    adjustments[hi] = max(adjustments[hi], PETROL_COOCCUR_PUMP_HOSE)
+        # Canopy + Hose boost
+        for ci in cls_map.get(PETROL_CLS_CANOPY, []):
+            for hi in cls_map.get(PETROL_CLS_HOSE, []):
+                if near(ci, hi):
+                    adjustments[hi] = max(adjustments[hi], PETROL_COOCCUR_CANOPY_HOSE)
+        # Suppress isolated low-conf (not price boards)
+        for i, (_, _, _, _, conf, cls_id) in enumerate(dets):
+            if cls_id == PETROL_CLS_PRICEBOARD or conf > 0.60:
+                continue
+            if not any(near(i, j) for j in range(n) if j != i):
+                adjustments[i] = min(adjustments[i], adjustments[i] - PETROL_COOCCUR_SUPPRESS)
+
+        result = []
+        for i, (x1, y1, x2, y2, conf, cls_id) in enumerate(dets):
+            new_conf = min(1.0, max(0.0, conf + adjustments[i]))
+            if new_conf >= PETROL_CONF:
+                result.append((x1, y1, x2, y2, new_conf, cls_id))
+        return result
+
+    def _infer_petrol(self, image_bgr: ndarray) -> list[BoundingBox]:
+        """Full petrol inference pipeline: preprocess → forward → decode → validate → cooccurrence."""
+        inp, (orig_h, orig_w) = self._petrol_preprocess(image_bgr)
+        out = self.petrol_session.run(None, {self.petrol_input_name: inp})[0]
+
+        if self._petrol_end2end:
+            dets = self._petrol_decode_end2end(out, orig_h, orig_w)
+        else:
+            dets = self._petrol_decode_raw(out, orig_h, orig_w)
+        if not dets:
+            return []
+
+        dets = self._petrol_geometric_validate(dets, orig_h, orig_w)
+        dets = self._petrol_spatial_cooccurrence(dets, orig_h, orig_w)
+
+        out_boxes = []
+        for x1, y1, x2, y2, conf, cls_id in dets:
+            out_boxes.append(BoundingBox(
+                x1=max(0, min(orig_w, math.floor(x1))),
+                y1=max(0, min(orig_h, math.floor(y1))),
+                x2=max(0, min(orig_w, math.ceil(x2))),
+                y2=max(0, min(orig_h, math.ceil(y2))),
+                cls_id=cls_id,
+                conf=max(0.0, min(1.0, conf)),
+            ))
+        return out_boxes
+
     # -- Replay buffer -------------------------------------------------------
     REPLAY_DIR = Path("/home/miner/replay_buffer")
     REPLAY_MAX = 100