scorevision: push artifact

README.md

@@ -0,0 +1,10 @@
+# ScoreVision SN44 Unified Miner
+
+Dual-model approach: vehicle (YOLO11s) + person (YOLO11s).
+Runs both models on every image and merges all detections.
+
+## Classes
+- cls_id 0: bus (vehicle eval) / person (person eval)
+- cls_id 1: car
+- cls_id 2: truck
+- cls_id 3: motorcycle

chute_config.yml

@@ -7,16 +7,10 @@ Image:
 NodeSelector:
   gpu_count: 1
   min_vram_gb_per_gpu: 16
-  max_hourly_price_per_gpu: 0.50
-  exclude:
-    - "5090"
-    - b200
-    - h200
-    - mi300x
 
 Chute:
-  timeout_seconds: 900
+  timeout_seconds: 300
   concurrency: 4
   max_instances: 5
   scaling_threshold: 0.5
-  shutdown_after_seconds: 288000
+  shutdown_after_seconds: 600

class_names.txt

@@ -0,0 +1,5 @@
+bus
+car
+truck
+motorcycle
+person

miner.py

@@ -163,22 +163,27 @@ logger = logging.getLogger(__name__)
 # ── Vehicle config ──────────────────────────────────────────────────────────
 VEH_MODEL_TO_OUT: dict[int, int] = {0: 1, 1: 0, 2: 2, 3: 3}
 VEH_NUM_CLASSES = 4
-VEH_CONF_PER_CLASS = {0: 0.15, 1: 0.30, 2: 0.20, 3: 0.15}
-VEH_CONF_DEFAULT = 0.35
+VEH_CONF_THRES = 0.35
 VEH_TTA_CONF = 0.10
-VEH_WBF_IOU = 0.40
+VEH_NMS_IOU = 0.50
+
+# ── Vehicle box sanity filters ─────────────────────────────────────────────
+VEH_MIN_WH = 8
+VEH_MIN_AREA = 196
+VEH_MAX_ASPECT = 8.0
+VEH_MAX_AREA_RATIO = 0.95
+VEH_MAX_DET = 150
 
 # ── Person config (TTA consensus) ───────────────────────────────────────────
-PER_CONF_LOW = 0.32
-PER_CONF_HIGH = 0.55
+PER_CONF_LOW = 0.45
+PER_CONF_HIGH = 0.58
 PER_CONSENSUS_IOU = 0.50
-PER_WBF_IOU = 0.40
 PER_RTF_BUDGET = 8.0
 
 # ── Person box sanity filters ──────────────────────────────────────────────
 PER_MIN_WH = 8
 PER_MIN_AREA = 14 * 14
-PER_MAX_ASPECT = 8.0
+PER_MAX_ASPECT = 6.0
 PER_MAX_AREA_RATIO = 0.80
 
 # ── Shared ──────────────────────────────────────────────────────────────────
@@ -309,6 +314,48 @@ def _wbf_single(boxes_list, scores_list, iou_thr=0.45, skip_thr=0.0001):
     return np.array(fused_b), np.array(fused_s)
 
 
+def _nms_per_class_boost(boxes, scores, labels, iou_thr=0.50):
+    """Per-class hard NMS with max-score cluster boosting.
+    Surviving box keeps its coordinates but gets the max confidence
+    among all boxes in its overlap cluster."""
+    if len(boxes) == 0:
+        return np.empty((0, 4)), np.empty(0), np.empty(0, dtype=int)
+
+    out_b, out_s, out_l = [], [], []
+    for cls in np.unique(labels):
+        m = labels == cls
+        cb, cs = boxes[m], scores[m]
+        order = cs.argsort()[::-1]
+        cb, cs = cb[order], cs[order]
+
+        suppressed = set()
+        for i in range(len(cb)):
+            if i in suppressed:
+                continue
+            max_score = float(cs[i])
+            for j in range(i + 1, len(cb)):
+                if j in suppressed:
+                    continue
+                xx1 = max(cb[i, 0], cb[j, 0])
+                yy1 = max(cb[i, 1], cb[j, 1])
+                xx2 = min(cb[i, 2], cb[j, 2])
+                yy2 = min(cb[i, 3], cb[j, 3])
+                inter = max(0, xx2 - xx1) * max(0, yy2 - yy1)
+                a1 = (cb[i, 2] - cb[i, 0]) * (cb[i, 3] - cb[i, 1])
+                a2 = (cb[j, 2] - cb[j, 0]) * (cb[j, 3] - cb[j, 1])
+                iou = inter / (a1 + a2 - inter + 1e-9)
+                if iou >= iou_thr:
+                    max_score = max(max_score, float(cs[j]))
+                    suppressed.add(j)
+            out_b.append(cb[i])
+            out_s.append(max_score)
+            out_l.append(cls)
+
+    if not out_b:
+        return np.empty((0, 4)), np.empty(0), np.empty(0, dtype=int)
+    return np.array(out_b), np.array(out_s), np.array(out_l, dtype=int)
+
+
 class BoundingBox(BaseModel):
     x1: int
     y1: int
@@ -422,60 +469,78 @@ class Miner:
 
     def _infer_vehicle(self, image_bgr):
         oh, ow = image_bgr.shape[:2]
-        all_b, all_s, all_l = [], [], []
-
-        def _collect(boxes, confs, cls_ids):
-            if len(boxes) == 0:
-                return
-            out_cls = np.array([VEH_MODEL_TO_OUT[int(c)] for c in cls_ids])
-            norm = boxes.copy()
-            norm[:, [0, 2]] /= ow
-            norm[:, [1, 3]] /= oh
-            norm = np.clip(norm, 0, 1)
-            all_b.append(norm)
-            all_s.append(confs)
-            all_l.append(out_cls)
 
         if ENABLE_TTA:
-            _collect(*self._veh_run_pass(image_bgr, VEH_TTA_CONF))
+            boxes1, confs1, cls1 = self._veh_run_pass(image_bgr, VEH_TTA_CONF)
             flipped = cv2.flip(image_bgr, 1)
-            bx, sc, cl = self._veh_run_pass(flipped, VEH_TTA_CONF)
-            if len(bx):
-                bx[:, 0], bx[:, 2] = ow - bx[:, 2], ow - bx[:, 0]
-            _collect(bx, sc, cl)
+            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])
         else:
-            bx, confs, cls_ids = self._veh_run_pass(image_bgr, VEH_TTA_CONF)
-            _collect(bx, confs, cls_ids)
+            boxes, confs, cls_ids = self._veh_run_pass(image_bgr, VEH_CONF_THRES)
 
-        if not all_b:
+        if len(boxes) == 0:
             return []
 
-        fb, fs, fl = _wbf_multi(all_b, all_s, all_l, iou_thr=VEH_WBF_IOU, skip_thr=WBF_SKIP_THR)
+        # Remap model classes to output classes
+        out_cls = np.array([VEH_MODEL_TO_OUT[int(c)] for c in cls_ids])
 
-        if len(fb) == 0:
-            return []
+        # Per-class hard NMS with max-score cluster boosting
+        boxes, confs, out_cls = _nms_per_class_boost(
+            boxes, confs, out_cls, iou_thr=VEH_NMS_IOU)
 
-        fb[:, [0, 2]] *= ow
-        fb[:, [1, 3]] *= oh
+        if len(boxes) == 0:
+            return []
 
-        keep = np.array([
-            fs[i] >= VEH_CONF_PER_CLASS.get(int(fl[i]), VEH_CONF_DEFAULT)
-            for i in range(len(fs))
-        ])
+        # Global confidence filter (needed after TTA where lower threshold was used)
+        keep = confs >= VEH_CONF_THRES
         if not keep.any():
             return []
-        fb, fs, fl = fb[keep], fs[keep], fl[keep]
+        boxes, confs, out_cls = boxes[keep], confs[keep], out_cls[keep]
+
+        # Sanity filters
+        img_area = float(oh * ow)
+        sane = []
+        for i in range(len(boxes)):
+            bw = boxes[i, 2] - boxes[i, 0]
+            bh = boxes[i, 3] - boxes[i, 1]
+            if bw < VEH_MIN_WH or bh < VEH_MIN_WH:
+                continue
+            area = bw * bh
+            if area < VEH_MIN_AREA:
+                continue
+            if max(bw, bh) / max(min(bw, bh), 1e-6) > VEH_MAX_ASPECT:
+                continue
+            if area / img_area > VEH_MAX_AREA_RATIO:
+                continue
+            sane.append(i)
+
+        if not sane:
+            return []
+        boxes, confs, out_cls = boxes[sane], confs[sane], out_cls[sane]
+
+        # Limit max detections
+        if len(boxes) > VEH_MAX_DET:
+            top_k = np.argsort(confs)[::-1][:VEH_MAX_DET]
+            boxes, confs, out_cls = boxes[top_k], confs[top_k], out_cls[top_k]
 
         out = []
-        for i in range(len(fb)):
-            b = fb[i]
+        for i in range(len(boxes)):
+            b = boxes[i]
             out.append(BoundingBox(
                 x1=max(0, min(ow, math.floor(b[0]))),
                 y1=max(0, min(oh, math.floor(b[1]))),
                 x2=max(0, min(ow, math.ceil(b[2]))),
                 y2=max(0, min(oh, math.ceil(b[3]))),
-                cls_id=int(fl[i]),
-                conf=max(0.0, min(1.0, float(fs[i]))),
+                cls_id=int(out_cls[i]),
+                conf=max(0.0, min(1.0, float(confs[i]))),
             ))
         return out
 
@@ -485,7 +550,8 @@ class Miner:
         h, w = img.shape[:2]
         r = min(self.per_h / h, self.per_w / w)
         nw, nh = int(round(w * r)), int(round(h * r))
-        img_r = cv2.resize(img, (nw, nh), interpolation=cv2.INTER_LINEAR)
+        interp = cv2.INTER_CUBIC if r > 1.0 else cv2.INTER_LINEAR
+        img_r = cv2.resize(img, (nw, nh), interpolation=interp)
         dw, dh = self.per_w - nw, self.per_h - nh
         pl, pt = dw // 2, dh // 2
         img_p = cv2.copyMakeBorder(
@@ -514,10 +580,10 @@ class Miner:
             boxes, confs = pred[keep, :4], confs[keep]
             if len(boxes) == 0:
                 return np.empty((0, 4)), np.empty(0)
-            boxes[:, 0] = (boxes[:, 0] - pl) / ratio
-            boxes[:, 2] = (boxes[:, 2] - pl) / ratio
-            boxes[:, 1] = (boxes[:, 1] - pt) / ratio
-            boxes[:, 3] = (boxes[:, 3] - pt) / ratio
+            boxes[:, 0] = np.floor((boxes[:, 0] - pl) / ratio)
+            boxes[:, 1] = np.floor((boxes[:, 1] - pt) / ratio)
+            boxes[:, 2] = np.ceil((boxes[:, 2] - pl) / ratio)
+            boxes[:, 3] = np.ceil((boxes[:, 3] - pt) / ratio)
             boxes = np.clip(boxes, 0, [[ow, oh, ow, oh]])
             return boxes, confs
 
@@ -533,10 +599,10 @@ class Miner:
         if len(boxes) == 0:
             return np.empty((0, 4)), np.empty(0)
         cx, cy, bw, bh = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
-        x1 = np.clip((cx - bw / 2 - pl) / ratio, 0, ow)
-        y1 = np.clip((cy - bh / 2 - pt) / ratio, 0, oh)
-        x2 = np.clip((cx + bw / 2 - pl) / ratio, 0, ow)
-        y2 = np.clip((cy + bh / 2 - pt) / ratio, 0, oh)
+        x1 = np.clip(np.floor((cx - bw / 2 - pl) / ratio), 0, ow)
+        y1 = np.clip(np.floor((cy - bh / 2 - pt) / ratio), 0, oh)
+        x2 = np.clip(np.ceil((cx + bw / 2 - pl) / ratio), 0, ow)
+        y2 = np.clip(np.ceil((cy + bh / 2 - pt) / ratio), 0, oh)
         return np.stack([x1, y1, x2, y2], axis=1), confs
 
     def _per_run_pass(self, image_bgr, conf_thresh):
@@ -564,51 +630,63 @@ class Miner:
 
         kept_b, kept_s = [], []
 
-        for i in range(len(boxes_orig)):
-            kept_b.append(boxes_orig[i])
-            kept_s.append(confs_orig[i])
-
-        if has_flip:
-            for i in range(len(boxes_flip)):
-                if confs_flip[i] < PER_CONF_HIGH:
-                    continue
-                if len(boxes_orig) > 0:
-                    xx1 = np.maximum(boxes_flip[i, 0], boxes_orig[:, 0])
-                    yy1 = np.maximum(boxes_flip[i, 1], boxes_orig[:, 1])
-                    xx2 = np.minimum(boxes_flip[i, 2], boxes_orig[:, 2])
-                    yy2 = np.minimum(boxes_flip[i, 3], boxes_orig[:, 3])
-                    inter = np.maximum(0, xx2 - xx1) * np.maximum(0, yy2 - yy1)
-                    a1 = (boxes_flip[i, 2] - boxes_flip[i, 0]) * (boxes_flip[i, 3] - boxes_flip[i, 1])
-                    a2 = (boxes_orig[:, 2] - boxes_orig[:, 0]) * (boxes_orig[:, 3] - boxes_orig[:, 1])
-                    iou = inter / (a1 + a2 - inter + 1e-9)
-                    if np.max(iou) >= 0.3:
-                        continue
-                kept_b.append(boxes_flip[i])
-                kept_s.append(confs_flip[i])
+        if not has_flip or len(boxes_flip) == 0:
+            # No flip available — keep all original boxes
+            for i in range(len(boxes_orig)):
+                kept_b.append(boxes_orig[i])
+                kept_s.append(float(confs_orig[i]))
+        else:
+            # Consensus TTA merge
+            used_flip = set()
+
+            for i in range(len(boxes_orig)):
+                # Compute IoU with all flip boxes
+                xx1 = np.maximum(boxes_orig[i, 0], boxes_flip[:, 0])
+                yy1 = np.maximum(boxes_orig[i, 1], boxes_flip[:, 1])
+                xx2 = np.minimum(boxes_orig[i, 2], boxes_flip[:, 2])
+                yy2 = np.minimum(boxes_orig[i, 3], boxes_flip[:, 3])
+                inter = np.maximum(0, xx2 - xx1) * np.maximum(0, yy2 - yy1)
+                a1 = (boxes_orig[i, 2] - boxes_orig[i, 0]) * (boxes_orig[i, 3] - boxes_orig[i, 1])
+                a2 = (boxes_flip[:, 2] - boxes_flip[:, 0]) * (boxes_flip[:, 3] - boxes_flip[:, 1])
+                iou = inter / (a1 + a2 - inter + 1e-9)
+                best_j = int(np.argmax(iou))
+                best_iou = float(iou[best_j])
+
+                if confs_orig[i] >= PER_CONF_HIGH:
+                    # High-conf original: auto-accept, boost with flip match
+                    score = float(confs_orig[i])
+                    if best_iou >= PER_CONSENSUS_IOU:
+                        score = max(score, float(confs_flip[best_j]))
+                        used_flip.add(best_j)
+                    kept_b.append(boxes_orig[i])
+                    kept_s.append(score)
+                else:
+                    # Low-conf original: need confirmation from flip view
+                    if best_iou >= PER_CONSENSUS_IOU:
+                        score = max(float(confs_orig[i]), float(confs_flip[best_j]))
+                        used_flip.add(best_j)
+                        kept_b.append(boxes_orig[i])
+                        kept_s.append(score)
+                    # else: unconfirmed low-conf → drop
+
+            # Add unmatched high-conf flip boxes
+            for j in range(len(boxes_flip)):
+                if j not in used_flip and confs_flip[j] >= PER_CONF_HIGH:
+                    kept_b.append(boxes_flip[j])
+                    kept_s.append(float(confs_flip[j]))
 
         if not kept_b:
             return []
 
         kept_b = np.array(kept_b)
         kept_s = np.array(kept_s)
-        norm = kept_b.copy()
-        norm[:, [0, 2]] /= ow
-        norm[:, [1, 3]] /= oh
-        norm = np.clip(norm, 0, 1)
-
-        fb, fs = _wbf_single([norm], [kept_s], iou_thr=PER_WBF_IOU, skip_thr=WBF_SKIP_THR)
-
-        if len(fb) == 0:
-            return []
-
-        fb[:, [0, 2]] *= ow
-        fb[:, [1, 3]] *= oh
 
+        # Sanity filters (consensus merge handles dedup — no WBF needed)
         img_area = float(oh * ow)
         sane = []
-        for i in range(len(fb)):
-            bw = fb[i, 2] - fb[i, 0]
-            bh = fb[i, 3] - fb[i, 1]
+        for i in range(len(kept_b)):
+            bw = kept_b[i, 2] - kept_b[i, 0]
+            bh = kept_b[i, 3] - kept_b[i, 1]
             if bw < PER_MIN_WH or bh < PER_MIN_WH:
                 continue
             area = bw * bh
@@ -622,19 +700,19 @@ class Miner:
 
         if not sane:
             return []
-        fb = fb[sane]
-        fs = fs[sane]
+        kept_b = kept_b[sane]
+        kept_s = kept_s[sane]
 
         out = []
-        for i in range(len(fb)):
-            b = fb[i]
+        for i in range(len(kept_b)):
+            b = kept_b[i]
             out.append(BoundingBox(
-                x1=max(0, min(ow, math.floor(b[0]))),
-                y1=max(0, min(oh, math.floor(b[1]))),
-                x2=max(0, min(ow, math.ceil(b[2]))),
-                y2=max(0, min(oh, math.ceil(b[3]))),
+                x1=max(0, min(ow, int(b[0]))),
+                y1=max(0, min(oh, int(b[1]))),
+                x2=max(0, min(ow, int(b[2]))),
+                y2=max(0, min(oh, int(b[3]))),
                 cls_id=0,
-                conf=max(0.0, min(1.0, float(fs[i]))),
+                conf=max(0.0, min(1.0, kept_s[i])),
             ))
         return out
 
@@ -726,4 +804,4 @@ class Miner:
         ).start()
 
         return results
-# Miner v3.2 — letterbox person preprocessing + YOLO26s 960px 20260331
+# Miner v3.4 — consensus TTA, per-class NMS boost, vehicle sanity filters, floor/ceil decode 20260401

model_type.json

@@ -0,0 +1 @@
+{"task_type": "object-detection", "model_type": "yolov11-small-dual", "deploy": "2026-03-27T09:00Z"}

person_weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b23ca9c0a7efd6613753b66033d7c6637b338a79547562687d5e58ba5fb92d7c
-size 19258183
+oid sha256:aa6c46dca9dc995b8a641674e8f760b80d9af067bf2874e16a6addfd77a387bf
+size 10042378

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "onnx-runner-detection"
+version = "0.1.0"
+requires-python = ">=3.9"
+dependencies = [
+  "numpy>=1.23",
+  "onnxruntime>=1.16",
+  "opencv-python>=4.7",
+  "pillow>=9.5",
+]