scorevision: push artifact

miner.py

@@ -1,6 +1,6 @@
 """
-Score Vision SN44 — Unified miner v3.27 (2026-04-08). Petrol v5 weights (mAP50=0.618) + SAHI 640/40%. R9c vehicle FP16 (mAP50=0.929). Per-class conf: hose/pump 0.25, pboard/canopy 0.35. Person: TTA consensus.
-Tri-model: vehicle (YOLO11m INT8 1280) + person (YOLO12s FP16 960 TRT) + petrol (end2end 640).
+Score Vision SN44 — Unified miner v3.28 (2026-04-08). R9c vehicle FP16 (mAP50=0.929). Person: TTA consensus.
+Dual-model: vehicle (YOLO11m INT8 1280) + person (YOLO12s FP16 960 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).
@@ -29,8 +29,6 @@ Pose model (pose_weights.onnx):
 
 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
@@ -376,20 +374,6 @@ 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           # base conf for hose + pump
-PETROL_CONF_HIGH = 0.35      # stricter conf for price_board + canopy (reduce tile FPs)
-PETROL_NMS_IOU = 0.45
-# SAHI tiling (640/40% = 6 tiles + full + flip = 8 passes, ~5.6s on chute GPU)
-PETROL_TILE_SIZE = 640
-PETROL_TILE_OVERLAP = 0.4
-# 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
 
 
 def _wbf_multi(boxes_list, scores_list, labels_list, iou_thr=0.55, skip_thr=0.0001):
@@ -678,43 +662,6 @@ 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
-            )
-            petrol_actual = self.petrol_session.get_providers()
-            logger.warning(f"[init] Petrol session ACTIVE providers: {petrol_actual}")
-            if "CUDAExecutionProvider" not in petrol_actual:
-                logger.error("[init] ⚠ PETROL IS ON CPU — CUDA EP NOT ACTIVE")
-            logger.info(f"[init] Petrol model loaded: {self.petrol_h}x{self.petrol_w}, 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
@@ -2096,12 +2043,10 @@ class Miner:
     _CHALLENGE_TYPE_MAP = {2: 'person', 12: 'vehicle'}
 
     def _detect_element_hint(self) -> str:
-        """Detect whether this request is for person, vehicle, or petrol.
+        """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', 'petrol', or 'both'.
-        Any unrecognized challenge_type_id routes to petrol (the only other
-        element on this chute).
+        via stack frame inspection. Returns 'person', 'vehicle', or 'both'.
         """
         frame = None
         try:
@@ -2116,7 +2061,7 @@ class Miner:
                     hint = self._CHALLENGE_TYPE_MAP.get(ct_id)
                     if hint:
                         return hint
-                    return 'petrol' if self.petrol_session else 'both'
+                    return 'both'
         except Exception:
             pass
         finally:
@@ -2138,9 +2083,6 @@ class Miner:
             vehicle_boxes = self._infer_vehicle(image_bgr)
             return self._vehicle_parts_confirm(vehicle_boxes, [], 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)
@@ -2157,197 +2099,6 @@ class Miner:
 
         return vehicle_boxes + person_boxes
 
-    # ── Petrol inference pipeline (SAHI tiling) ──────────────────────────────
-
-    def _petrol_letterbox(self, image_bgr):
-        """Letterbox resize to model input, return blob + undo params."""
-        h, w = image_bgr.shape[:2]
-        scale = min(self.petrol_h / h, self.petrol_w / w)
-        nh, nw = int(h * scale), int(w * scale)
-        resized = cv2.resize(image_bgr, (nw, nh))
-        canvas = np.full((self.petrol_h, self.petrol_w, 3), 114, dtype=np.uint8)
-        dy, dx = (self.petrol_h - nh) // 2, (self.petrol_w - nw) // 2
-        canvas[dy:dy + nh, dx:dx + nw] = resized
-        rgb = cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB)
-        blob = rgb.astype(np.float32) / 255.0
-        blob = np.transpose(blob, (2, 0, 1))[None, ...]
-        return blob, scale, dx, dy
-
-    def _petrol_decode(self, out, orig_h, orig_w, scale, dx, dy):
-        """Decode end2end [1,N,6] or raw [1,C,N] output with letterbox undo."""
-        pred = out[0]
-        if pred.ndim != 2:
-            return []
-        # End-to-end: [N, 6] = x1,y1,x2,y2,conf,cls
-        if pred.shape[1] == 6:
-            results = []
-            for i in range(pred.shape[0]):
-                conf = float(pred[i, 4])
-                if conf < PETROL_CONF:
-                    continue
-                x1 = (float(pred[i, 0]) - dx) / scale
-                y1 = (float(pred[i, 1]) - dy) / scale
-                x2 = (float(pred[i, 2]) - dx) / scale
-                y2 = (float(pred[i, 3]) - dy) / scale
-                cls_id = int(pred[i, 5])
-                x1, y1 = max(0.0, x1), max(0.0, y1)
-                x2, y2 = min(float(orig_w), x2), min(float(orig_h), y2)
-                if x2 > x1 + 2 and y2 > y1 + 2:
-                    results.append([x1, y1, x2, y2, conf, cls_id])
-            return results
-        # Raw: [C, N] → transpose to [N, C], decode cx,cy,w,h + class scores
-        if pred.shape[0] < pred.shape[1]:
-            pred = pred.T
-        if pred.shape[1] < 5:
-            return []
-        boxes = pred[:, :4]
-        cls_scores = pred[:, 4:]
-        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]
-        results = []
-        for i in range(boxes.shape[0]):
-            cx, cy, bw, bh = boxes[i].tolist()
-            x1 = ((cx - bw / 2.0) - dx) / scale
-            y1 = ((cy - bh / 2.0) - dy) / scale
-            x2 = ((cx + bw / 2.0) - dx) / scale
-            y2 = ((cy + bh / 2.0) - dy) / scale
-            x1, y1 = max(0.0, x1), max(0.0, y1)
-            x2, y2 = min(float(orig_w), x2), min(float(orig_h), y2)
-            if x2 > x1 + 2 and y2 > y1 + 2:
-                results.append([x1, y1, x2, y2, float(confs[i]), int(cls_ids[i])])
-        return results
-
-    @staticmethod
-    def _petrol_nms(dets, iou_thresh=PETROL_NMS_IOU):
-        """Per-class NMS on list of [x1,y1,x2,y2,conf,cls_id]."""
-        if not dets:
-            return []
-        by_cls = {}
-        for d in dets:
-            by_cls.setdefault(int(d[5]), []).append(d)
-        result = []
-        for cls_dets in by_cls.values():
-            arr = np.array(cls_dets, dtype=np.float32)
-            boxes, scores = arr[:, :4], arr[:, 4]
-            order = scores.argsort()[::-1]
-            kept = []
-            while order.size > 0:
-                i = order[0]
-                kept.append(i)
-                if order.size == 1:
-                    break
-                xx1 = np.maximum(boxes[i, 0], boxes[order[1:], 0])
-                yy1 = np.maximum(boxes[i, 1], boxes[order[1:], 1])
-                xx2 = np.minimum(boxes[i, 2], boxes[order[1:], 2])
-                yy2 = np.minimum(boxes[i, 3], boxes[order[1:], 3])
-                inter = np.maximum(0, xx2 - xx1) * np.maximum(0, yy2 - yy1)
-                area_i = (boxes[i, 2] - boxes[i, 0]) * (boxes[i, 3] - boxes[i, 1])
-                area_r = (boxes[order[1:], 2] - boxes[order[1:], 0]) * (boxes[order[1:], 3] - boxes[order[1:], 1])
-                iou = inter / np.maximum(area_i + area_r - inter, 1e-6)
-                order = order[np.where(iou <= iou_thresh)[0] + 1]
-            for k in kept:
-                result.append(cls_dets[k])
-        return result
-
-    def _petrol_run_on_crop(self, crop_bgr):
-        """Run petrol model on a single crop, return dets in crop coords."""
-        ch, cw = crop_bgr.shape[:2]
-        blob, scale, dx, dy = self._petrol_letterbox(crop_bgr)
-        out = self.petrol_session.run(None, {self.petrol_input_name: blob})[0]
-        return self._petrol_decode(out, ch, cw, scale, dx, dy)
-
-    @staticmethod
-    def _petrol_tiles(img_h, img_w, tile_size, overlap):
-        """Generate tile coordinates (y1, x1, y2, x2)."""
-        stride = max(1, int(tile_size * (1.0 - overlap)))
-        tiles = []
-        y = 0
-        while True:
-            x = 0
-            while True:
-                y1, x1 = y, x
-                y2 = min(y + tile_size, img_h)
-                x2 = min(x + tile_size, img_w)
-                # Snap small trailing tiles to image edge
-                if y2 - y1 < tile_size * 0.4:
-                    y1 = max(0, img_h - tile_size)
-                    y2 = img_h
-                if x2 - x1 < tile_size * 0.4:
-                    x1 = max(0, img_w - tile_size)
-                    x2 = img_w
-                tiles.append((y1, x1, y2, x2))
-                x += stride
-                if x >= img_w:
-                    break
-            y += stride
-            if y >= img_h:
-                break
-        # Deduplicate
-        seen = set()
-        unique = []
-        for t in tiles:
-            if t not in seen:
-                seen.add(t)
-                unique.append(t)
-        return unique
-
-    def _infer_petrol(self, image_bgr: ndarray) -> list[BoundingBox]:
-        """Petrol inference with SAHI tiling + flip TTA, merged via NMS."""
-        if not hasattr(self, '_petrol_providers_logged'):
-            provs = self.petrol_session.get_providers()
-            logger.warning(f"[petrol] First inference — active providers: {provs}")
-            self._petrol_providers_logged = True
-
-        oh, ow = image_bgr.shape[:2]
-        all_dets = []
-
-        # 1. Full-image pass (letterbox)
-        all_dets.extend(self._petrol_run_on_crop(image_bgr))
-
-        # 2. Full-image flip TTA
-        flipped = cv2.flip(image_bgr, 1)
-        flip_dets = self._petrol_run_on_crop(flipped)
-        for d in flip_dets:
-            d[0], d[2] = ow - d[2], ow - d[0]  # mirror x coords
-        all_dets.extend(flip_dets)
-
-        # 3. SAHI tile passes
-        tiles = self._petrol_tiles(oh, ow, PETROL_TILE_SIZE, PETROL_TILE_OVERLAP)
-        for ty1, tx1, ty2, tx2 in tiles:
-            crop = image_bgr[ty1:ty2, tx1:tx2]
-            tile_dets = self._petrol_run_on_crop(crop)
-            for d in tile_dets:
-                d[0] += tx1; d[1] += ty1  # offset to full-image coords
-                d[2] += tx1; d[3] += ty1
-            all_dets.extend(tile_dets)
-
-        # 4. Per-class NMS merge
-        merged = self._petrol_nms(all_dets)
-
-        # 5. Apply per-class confidence thresholds
-        # Hose + pump: PETROL_CONF (0.25)  — already filtered in decode
-        # Price board + canopy: PETROL_CONF_HIGH (0.35) — stricter to reduce tile FPs
-        filtered = []
-        for d in merged:
-            cls_id = int(d[5])
-            if cls_id in (PETROL_CLS_PRICEBOARD, PETROL_CLS_CANOPY):
-                if d[4] < PETROL_CONF_HIGH:
-                    continue
-            filtered.append(d)
-
-        out_boxes = []
-        for x1, y1, x2, y2, conf, cls_id in filtered:
-            out_boxes.append(BoundingBox(
-                x1=max(0, min(ow, math.floor(x1))),
-                y1=max(0, min(oh, math.floor(y1))),
-                x2=max(0, min(ow, math.ceil(x2))),
-                y2=max(0, min(oh, math.ceil(y2))),
-                cls_id=int(cls_id),
-                conf=max(0.0, min(1.0, conf)),
-            ))
-        return out_boxes
 
     # -- Replay buffer -------------------------------------------------------
     REPLAY_DIR = Path("/home/miner/replay_buffer")