v1 crime weights (yolo26s 1280 e2e, 6 classes validator-aligned, 8.7k merged dataset, val mAP50=0.8301)

README.md

@@ -0,0 +1,21 @@
+---
+tags:
+- element_type:detect
+- model:yolov26-small
+- object:balaclava
+- object:hoodie
+- object:glove
+- object:bat
+- object:spray-paint
+- object:graffiti
+manako:
+  description: SN44 crime detection — YOLOv26-small trained natively in validator class order [balaclava, hoodie, glove, bat, spray paint, graffiti] on a multi-source merged ~8.7k-image dataset (Roboflow Universe — test-pvctt/cover-no-aug, baseball-v1/baseball-and-bat, test-el83b/glove-absoo, natalieglove-ykc4i/glove-0pewz, student-b2pa9/hoodie-hjihp, ahmads-workspace-spqp0/wibu-detector-5okbw, gama-yvduk/hoodie-hnu6d, brave-official/hoodie, labeling-dataset-hology-70-train/deteksi-hoodie, trucks-i0qg4/spray-drulu, itmo-0kdik/graffiti-wvjbp).
+  input_payload:
+  - name: frame
+    type: image
+    description: RGB frame
+  output_payload:
+  - name: detections
+    type: detections
+    description: List of detections (balaclava / hoodie / glove / bat / spray paint / graffiti) with bbox + confidence
+---

chute_config.yml

@@ -0,0 +1,27 @@
+Image:
+  from_base: parachutes/python:3.12
+  run_command:
+    - pip install --upgrade setuptools wheel
+    - pip install 'numpy>=1.23' 'onnxruntime-gpu[cuda,cudnn]>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9'
+    - pip install torch torchvision
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 16
+  max_hourly_price_per_gpu: 0.5    # ← lower than beverage's $2.00; experimental
+  exclude:                          # ← exclude-only (no include pinning, unlike beverage)
+    - "5090"
+    - b200
+    - h200
+    - h20
+    - mi300x
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 288000   # 80h idle (matches beverage)
+  # tee: false — omitted entirely (beverage uses tee: true; the SN44 repo
+  # example doesn't require TEE; testing whether crime element scores
+  # without it).

class_names.txt

@@ -0,0 +1,6 @@
+balaclava
+hoodie
+glove
+bat
+spray paint
+graffiti

miner.py

@@ -0,0 +1,343 @@
+# build-marker: v1-yolo26s-1280-tta
+"""SN44 crime detection miner — single-element chute for manak0/Detect-crime.
+
+Adapted from beverage v5 miner.py with these crime-specific changes:
+  - class_names = ["balaclava","hoodie","glove","bat","spray paint","graffiti"]
+  - cls_remap = identity (model trained natively in validator class order, no remap needed)
+  - conf_threshold = 0.52 (alfred-aligned, slightly looser than beverage's 0.55)
+  - iou_thresh = 0.4 (slightly tighter than beverage's 0.5)
+  - min_box_area = 196 (14x14 px², larger than beverage's 100; kills tiny FPs aggressively)
+  - weights.onnx is yolo26s e2e at 1280x1280 input
+
+Pipeline:
+  preprocess (letterbox 1280, cubic upscale) -> ONNX (e2e [1,300,6])
+  -> conf filter -> per-class hard NMS -> cross-class dedup -> geometry filter
+  -> TTA (h-flip + conf-boost on consensus) -> BoundingBox list
+"""
+import math
+from pathlib import Path
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from numpy import ndarray
+from pydantic import BaseModel
+
+
+class BoundingBox(BaseModel):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    cls_id: int
+    conf: float
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: list[BoundingBox]
+    keypoints: list[tuple[int, int]]
+
+
+class Miner:
+    """yolo26s e2e ONNX miner for manak0/Detect-crime.
+    Chute platform calls predict_batch(batch_images, offset, n_keypoints).
+    """
+
+    def __init__(self, path_hf_repo) -> None:
+        self.path_hf_repo = Path(path_hf_repo)
+
+        # Validator class order — model trained natively in this order so identity remap.
+        self.class_names = ["balaclava", "hoodie", "glove", "bat", "spray paint", "graffiti"]
+        self.cls_remap = np.arange(len(self.class_names), dtype=np.int32)
+
+        try:
+            ort.preload_dlls()
+        except Exception:
+            pass
+
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        try:
+            self.session = ort.InferenceSession(
+                str(self.path_hf_repo / "weights.onnx"),
+                sess_options=sess_options,
+                providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+            )
+        except Exception:
+            self.session = ort.InferenceSession(
+                str(self.path_hf_repo / "weights.onnx"),
+                sess_options=sess_options,
+                providers=["CPUExecutionProvider"],
+            )
+
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [o.name for o in self.session.get_outputs()]
+
+        # Match exported ONNX resolution.
+        self.input_h = 1280
+        self.input_w = 1280
+
+        # alfred-aligned crime thresholds.
+        self.conf_threshold = 0.52
+        self.iou_thresh = 0.4              # per-class hard NMS
+        self.cross_iou_thresh = 0.7        # cross-class dedup
+        self.max_det = 150
+        self.use_tta = True
+
+        # Geometry filters (alfred crime values).
+        self.min_box_area = 196            # 14x14 px²
+        self.min_side = 8
+        self.max_aspect_ratio = 8.0
+
+        # GPU warmup.
+        warm = np.zeros((self.input_h, self.input_w, 3), dtype=np.uint8)
+        for _ in range(5):
+            try:
+                self._infer_single(warm)
+            except Exception:
+                break
+
+    def __repr__(self) -> str:
+        return (
+            f"CrimeMiner v1 input={self.input_h}x{self.input_w} "
+            f"classes={len(self.class_names)} use_tta={self.use_tta} "
+            f"providers={self.session.get_providers()}"
+        )
+
+    # ---------------------------------------------------------------- preproc
+    def _letterbox(self, image: ndarray) -> tuple[ndarray, float, tuple[float, float]]:
+        """Aspect-preserving resize + 114-grey pad to (input_h, input_w).
+        Cubic when upscaling (small-object fidelity), linear when downscaling.
+        """
+        h, w = image.shape[:2]
+        ratio = min(self.input_w / w, self.input_h / h)
+        nw, nh = int(round(w * ratio)), int(round(h * ratio))
+        if (nw, nh) != (w, h):
+            interp = cv2.INTER_CUBIC if ratio > 1.0 else cv2.INTER_LINEAR
+            resized = cv2.resize(image, (nw, nh), interpolation=interp)
+        else:
+            resized = image
+        canvas = np.full((self.input_h, self.input_w, 3), 114, dtype=np.uint8)
+        dy = (self.input_h - nh) // 2
+        dx = (self.input_w - nw) // 2
+        canvas[dy:dy + nh, dx:dx + nw] = resized
+        return canvas, ratio, (float(dx), float(dy))
+
+    def _preprocess(self, image_bgr: ndarray):
+        canvas, ratio, pad = self._letterbox(image_bgr)
+        rgb = cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB)
+        x = (rgb.astype(np.float32) / 255.0).transpose(2, 0, 1)[None, ...]
+        return np.ascontiguousarray(x, dtype=np.float32), ratio, pad
+
+    # ---------------------------------------------------------------- nms helpers
+    @staticmethod
+    def _hard_nms(boxes: ndarray, scores: ndarray, iou_thresh: float) -> ndarray:
+        n = len(boxes)
+        if n == 0:
+            return np.array([], dtype=np.intp)
+        order = np.argsort(scores)[::-1]
+        keep: list[int] = []
+        suppressed = np.zeros(n, dtype=bool)
+        for i in range(n):
+            idx = order[i]
+            if suppressed[idx]:
+                continue
+            keep.append(int(idx))
+            bi = boxes[idx]
+            for k in range(i + 1, n):
+                jdx = order[k]
+                if suppressed[jdx]:
+                    continue
+                bj = boxes[jdx]
+                xx1 = max(bi[0], bj[0]); yy1 = max(bi[1], bj[1])
+                xx2 = min(bi[2], bj[2]); yy2 = min(bi[3], bj[3])
+                inter = max(0.0, xx2 - xx1) * max(0.0, yy2 - yy1)
+                ai = (bi[2] - bi[0]) * (bi[3] - bi[1])
+                aj = (bj[2] - bj[0]) * (bj[3] - bj[1])
+                iou = inter / (ai + aj - inter + 1e-7)
+                if iou > iou_thresh:
+                    suppressed[jdx] = True
+        return np.array(keep, dtype=np.intp)
+
+    def _per_class_hard_nms(
+        self, boxes: ndarray, scores: ndarray, cls_ids: ndarray, iou_thresh: float
+    ) -> ndarray:
+        if len(boxes) == 0:
+            return np.array([], dtype=np.intp)
+        all_keep: list[int] = []
+        for c in np.unique(cls_ids):
+            mask = cls_ids == c
+            indices = np.where(mask)[0]
+            keep = self._hard_nms(boxes[mask], scores[mask], iou_thresh)
+            all_keep.extend(indices[keep].tolist())
+        all_keep.sort()
+        return np.array(all_keep, dtype=np.intp)
+
+    @staticmethod
+    def _cross_class_dedup(
+        boxes: ndarray, scores: ndarray, cls_ids: ndarray, iou_thresh: float
+    ) -> tuple[ndarray, ndarray, ndarray]:
+        """Suppress high-overlap duplicates across classes (FP reducer)."""
+        n = len(boxes)
+        if n <= 1:
+            return boxes, scores, cls_ids
+        areas = np.maximum(0.0, boxes[:, 2] - boxes[:, 0]) * np.maximum(0.0, boxes[:, 3] - boxes[:, 1])
+        order = np.lexsort((-scores, -areas))
+        suppressed = np.zeros(n, dtype=bool)
+        keep: list[int] = []
+        for i in order:
+            if suppressed[i]:
+                continue
+            keep.append(int(i))
+            bi = boxes[i]
+            xx1 = np.maximum(bi[0], boxes[:, 0]); yy1 = np.maximum(bi[1], boxes[:, 1])
+            xx2 = np.minimum(bi[2], boxes[:, 2]); yy2 = np.minimum(bi[3], boxes[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            ai = max(1e-7, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            iou = inter / (ai + areas - inter + 1e-7)
+            dup = iou > iou_thresh
+            dup[i] = False
+            suppressed |= dup
+        kept = np.array(keep, dtype=np.intp)
+        return boxes[kept], scores[kept], cls_ids[kept]
+
+    @staticmethod
+    def _max_score_per_cluster(
+        coords: ndarray, scores: ndarray, keep_idx: ndarray, iou_thresh: float
+    ) -> ndarray:
+        """For each kept box, return max original score among any overlapping cluster member."""
+        if len(keep_idx) == 0:
+            return np.array([], dtype=np.float32)
+        out = np.empty(len(keep_idx), dtype=np.float32)
+        for j, idx in enumerate(keep_idx):
+            bi = coords[idx]
+            xx1 = np.maximum(bi[0], coords[:, 0]); yy1 = np.maximum(bi[1], coords[:, 1])
+            xx2 = np.minimum(bi[2], coords[:, 2]); yy2 = np.minimum(bi[3], coords[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            ai = (bi[2] - bi[0]) * (bi[3] - bi[1])
+            aj = (coords[:, 2] - coords[:, 0]) * (coords[:, 3] - coords[:, 1])
+            iou = inter / (ai + aj - inter + 1e-7)
+            out[j] = float(np.max(scores[iou >= iou_thresh]))
+        return out
+
+    # ---------------------------------------------------------------- inference
+    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+        inp, ratio, (dx, dy) = self._preprocess(image_bgr)
+        out = self.session.run(self.output_names, {self.input_name: inp})[0]
+        if out.ndim == 3:
+            out = out[0]
+
+        confs = out[:, 4].astype(np.float32)
+        keep = confs >= self.conf_threshold
+        if not keep.any():
+            return []
+        out = out[keep]
+
+        boxes = out[:, :4].astype(np.float32).copy()
+        confs = out[:, 4].astype(np.float32)
+        cls_ids = self.cls_remap[out[:, 5].astype(np.int32)]
+
+        # Reverse letterbox: model-space xyxy -> original-image xyxy
+        boxes[:, [0, 2]] = (boxes[:, [0, 2]] - dx) / ratio
+        boxes[:, [1, 3]] = (boxes[:, [1, 3]] - dy) / ratio
+
+        orig_h, orig_w = image_bgr.shape[:2]
+        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, orig_w - 1)
+        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, orig_h - 1)
+
+        if len(boxes) > 1:
+            keep_idx = self._per_class_hard_nms(boxes, confs, cls_ids, self.iou_thresh)
+            keep_idx = keep_idx[: self.max_det]
+            boxes = boxes[keep_idx]
+            confs = confs[keep_idx]
+            cls_ids = cls_ids[keep_idx]
+            boxes, confs, cls_ids = self._cross_class_dedup(
+                boxes, confs, cls_ids, self.cross_iou_thresh
+            )
+
+        return self._to_boundingboxes(boxes, confs, cls_ids, orig_w, orig_h)
+
+    def _infer_tta(self, image_bgr: ndarray) -> list[BoundingBox]:
+        """H-flip TTA: union(orig, flipped) -> per-class NMS -> conf-boost."""
+        boxes_orig = self._infer_single(image_bgr)
+
+        h, w = image_bgr.shape[:2]
+        flipped = cv2.flip(image_bgr, 1)
+        boxes_flip_raw = self._infer_single(flipped)
+        boxes_flip = [
+            BoundingBox(x1=w - b.x2, y1=b.y1, x2=w - b.x1, y2=b.y2,
+                        cls_id=b.cls_id, conf=b.conf)
+            for b in boxes_flip_raw
+        ]
+
+        all_boxes = boxes_orig + boxes_flip
+        if not all_boxes:
+            return []
+
+        coords = np.array([[b.x1, b.y1, b.x2, b.y2] for b in all_boxes], dtype=np.float32)
+        scores = np.array([b.conf for b in all_boxes], dtype=np.float32)
+        cls_ids = np.array([b.cls_id for b in all_boxes], dtype=np.int32)
+
+        keep_idx = self._per_class_hard_nms(coords, scores, cls_ids, self.iou_thresh)
+        if len(keep_idx) == 0:
+            return []
+        keep_idx = keep_idx[: self.max_det]
+        boosted = self._max_score_per_cluster(coords, scores, keep_idx, self.iou_thresh)
+
+        out_boxes: list[BoundingBox] = []
+        for j, idx in enumerate(keep_idx):
+            b = all_boxes[idx]
+            out_boxes.append(BoundingBox(
+                x1=b.x1, y1=b.y1, x2=b.x2, y2=b.y2,
+                cls_id=b.cls_id,
+                conf=max(0.0, min(1.0, float(boosted[j]))),
+            ))
+        return out_boxes
+
+    def _to_boundingboxes(
+        self, boxes: ndarray, confs: ndarray, cls_ids: ndarray,
+        orig_w: int, orig_h: int,
+    ) -> list[BoundingBox]:
+        out: list[BoundingBox] = []
+        for i in range(len(boxes)):
+            x1, y1, x2, y2 = boxes[i]
+            ix1 = max(0, min(orig_w, math.floor(x1)))
+            iy1 = max(0, min(orig_h, math.floor(y1)))
+            ix2 = max(0, min(orig_w, math.ceil(x2)))
+            iy2 = max(0, min(orig_h, math.ceil(y2)))
+            if ix2 <= ix1 or iy2 <= iy1:
+                continue
+            bw, bh = ix2 - ix1, iy2 - iy1
+            if bw * bh < self.min_box_area:
+                continue
+            if min(bw, bh) < self.min_side:
+                continue
+            ar = max(bw / max(bh, 1), bh / max(bw, 1))
+            if ar > self.max_aspect_ratio:
+                continue
+            out.append(BoundingBox(
+                x1=ix1, y1=iy1, x2=ix2, y2=iy2,
+                cls_id=int(cls_ids[i]),
+                conf=max(0.0, min(1.0, float(confs[i]))),
+            ))
+        return out
+
+    # ---------------------------------------------------------------- entry
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        infer = self._infer_tta if self.use_tta else self._infer_single
+        results: list[TVFrameResult] = []
+        for idx, image in enumerate(batch_images):
+            boxes = infer(image)
+            results.append(TVFrameResult(
+                frame_id=offset + idx,
+                boxes=boxes,
+                keypoints=[(0, 0) for _ in range(max(0, int(n_keypoints)))],
+            ))
+        return results

model_type.json

@@ -0,0 +1,4 @@
+{
+  "task_type": "object-detection",
+  "model_type": "yolov26-small"
+}

weights.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14cfd547ec7b6f2e675546492236b4ded323076bd72d38cf30591e2105c69ea0
+size 19409670