scorevision: push artifact

miner.py

@@ -1,5 +1,5 @@
 """
-Score Vision SN44 — Unified miner v3.24 (2026-04-07). Petrol v4 weights (960px, GDINO+Mapillary), petrol TTA consensus, hard geometric filter, provider logging. Vehicle: lazy FP32, 0-box trigger. Person: TTA consensus.
+Score Vision SN44 — Unified miner v3.25 (2026-04-07). Petrol SAHI tiling (512px/50% overlap + full-image + flip TTA, per-class NMS merge). Per-class conf: hose/pump 0.25, pboard/canopy 0.35. Vehicle: lazy FP32, 0-box trigger. Person: TTA consensus.
 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).
@@ -378,27 +378,18 @@ VEHICLE_HF_REPO = "meaculpitt/ScoreVision-Vehicle"
 
 # ── Petrol config ───────────────────────────────────────────────────────────
 PETROL_HF_REPO = "meaculpitt/ScoreVision-Petrol"
-PETROL_CONF = 0.30
-PETROL_CONF_ORIG = 0.35
-PETROL_TTA_MATCH_IOU = 0.50
-PETROL_IOU = 0.45
+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
+PETROL_TILE_SIZE = 512
+PETROL_TILE_OVERLAP = 0.5
 # 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
-# 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):
@@ -2166,229 +2157,194 @@ class Miner:
 
         return vehicle_boxes + person_boxes
 
-    # ── Petrol inference pipeline ───────────────────────────────────────────
+    # ── Petrol inference pipeline (SAHI tiling) ──────────────────────────────
 
-    def _petrol_preprocess(self, image_bgr: ndarray):
-        """Resize to model input, normalize to [0,1] float32 NCHW."""
+    def _petrol_letterbox(self, image_bgr):
+        """Letterbox resize to model input, return blob + undo params."""
         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."""
+        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:]
-        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 = []
+        results = []
         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 hard shape filters. Reject detections that fail."""
-        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
-            if cls_id == PETROL_CLS_CANOPY and aspect < PETROL_CANOPY_MIN_ASPECT:
-                continue
-            if cls_id == PETROL_CLS_PUMP and (aspect > PETROL_PUMP_MAX_ASPECT or bh < 30):
-                continue
-            if cls_id == PETROL_CLS_PRICEBOARD and (area_frac > PETROL_PRICEBOARD_MAX_AREA_FRAC or (bw * bh) < 200):
-                continue
-            if cls_id == PETROL_CLS_HOSE and (bw * bh) < 400:
-                continue
-            result.append((x1, y1, x2, y2, conf, cls_id))
-        return result
+            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
 
-    def _petrol_spatial_cooccurrence(self, dets, orig_h, orig_w):
-        """Proximity-based confidence adjustments for petrol objects."""
+    @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 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)
-
+            return []
+        by_cls = {}
+        for d in dets:
+            by_cls.setdefault(int(d[5]), []).append(d)
         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))
+        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_pass(self, image_bgr):
-        """Single petrol inference pass: preprocess -> forward -> decode."""
-        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:
-            return self._petrol_decode_end2end(out, orig_h, orig_w), orig_h, orig_w
-        else:
-            return self._petrol_decode_raw(out, orig_h, orig_w), orig_h, orig_w
+    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 flip TTA consensus merging."""
+        """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 = []
 
-        # Original pass
-        dets_orig, _, _ = self._petrol_run_pass(image_bgr)
+        # 1. Full-image pass (letterbox)
+        all_dets.extend(self._petrol_run_on_crop(image_bgr))
 
-        # Flip pass
+        # 2. Full-image flip TTA
         flipped = cv2.flip(image_bgr, 1)
-        dets_flip, _, _ = self._petrol_run_pass(flipped)
-        # Mirror flip boxes back
-        dets_flip = [(ow - x2, y1, ow - x1, y2, conf, cls_id)
-                     for x1, y1, x2, y2, conf, cls_id in dets_flip]
-
-        # Consensus merge: match across views
-        matched_orig = set()
-        matched_flip = set()
-        merged = []
-
-        for i, (ox1, oy1, ox2, oy2, oc, ocls) in enumerate(dets_orig):
-            for j, (fx1, fy1, fx2, fy2, fc, fcls) in enumerate(dets_flip):
-                if ocls != fcls or j in matched_flip:
+        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
-                ix1, iy1 = max(ox1, fx1), max(oy1, fy1)
-                ix2, iy2 = min(ox2, fx2), min(oy2, fy2)
-                inter = max(0, ix2 - ix1) * max(0, iy2 - iy1)
-                oa = (ox2 - ox1) * (oy2 - oy1)
-                fa = (fx2 - fx1) * (fy2 - fy1)
-                iou = inter / max(oa + fa - inter, 1e-6)
-                if iou >= PETROL_TTA_MATCH_IOU:
-                    conf = max(oc, fc)
-                    if conf >= PETROL_CONF:
-                        merged.append((ox1, oy1, ox2, oy2, conf, ocls))
-                    matched_orig.add(i)
-                    matched_flip.add(j)
-                    break
-
-        # Original-only: keep at stricter threshold
-        for i, det in enumerate(dets_orig):
-            if i not in matched_orig and det[4] >= PETROL_CONF_ORIG:
-                merged.append(det)
-
-        # Flip-only: discard
-
-        if not merged:
-            return []
-
-        merged = self._petrol_geometric_validate(merged, oh, ow)
-        merged = self._petrol_spatial_cooccurrence(merged, oh, ow)
+            filtered.append(d)
 
         out_boxes = []
-        for x1, y1, x2, y2, conf, cls_id in merged:
+        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=cls_id,
+                cls_id=int(cls_id),
                 conf=max(0.0, min(1.0, conf)),
             ))
         return out_boxes