subnet_bridge: copy winning miner repo into library

README.md

@@ -0,0 +1,49 @@
+---
+tags:
+- element_type:detect
+- model:onnxruntime
+- subnet:winner
+- object:fire
+- object:smoke
+- object:fire extinguisher
+
+manako:
+  source: winner_fetch
+  manifest_element_name: manak0/Detect-fire
+  winner_repo_id: meaculpitt/ScoreVision-Fire
+  winner_revision: 71ae3d3e59ced8b330eea5e95710318175bb1342
+  note: E=0.11785877 (map50=0.600000, size_mb=5.090839)
+---
+
+# ScoreVision-Fire — meaculpitt v2.1
+
+SN44 fire-detection miner for the `manak0/Detect-fire` element.
+
+## Pipeline
+- **Architecture**: yolo26n
+- **Resolution**: 1408×768 input → letterbox → 960×960
+- **Preprocessing**: `cv2.dnn.blobFromImage` (fused C++ resize+normalize+transpose)
+- **Inference**: single-pass FP16 ONNX, NMS baked in
+- **Output shape**: `[1, 300, 6]` (xyxy, conf, cls)
+- **Latency**: ~35 ms p95 on RTX 4090 (fits the 50 ms gate)
+
+## Classes (validator GT order, NOT the published class_names.txt order)
+- 0: fire
+- 1: smoke
+- 2: fire extinguisher
+
+Verified by audit of alfred8995/fire001 (scores 1.00) and navierstocks/fire
+(scores 0.96): both use [fire, smoke, fire_extinguisher] and the validator's
+GT order matches. Our model was trained with [fire, fire_ext, smoke]; miner.py
+applies cls_remap=[0,2,1] to translate model output to validator index.
+
+## Training
+- 22,796 training images (validator-synth + Simuletic + D-Fire + z5atr, SHA1 deduped)
+- 2,532 validation images (random 90/10 split, seed=42)
+- 100 epochs, yolo26n, imgsz=960, batch=8, AdamW lr0=0.001 cos_lr
+- CCTV augmentation chain (cctv_aug_patch)
+
+## Benchmarks
+- Broader merged val mAP50: 0.785
+- Validator-distribution synth val mAP50: 0.640 (+24.7 pts above 0.393 baseline)
+- Per-class on synth val: fire=0.523, fire_extinguisher=0.647, smoke=0.749

chute_config.yml

@@ -0,0 +1,29 @@
+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
+  # SN44 chute platform mandates TEE + pro_6000 include for new elements
+  # (verified by crime + beverage deploys 2026-05-04). Cheaper-GPU config
+  # caused repeated 500 ContentTypeError on POST /chutes/.
+  max_hourly_price_per_gpu: 2.00
+  include:
+    - "pro_6000"
+  exclude:
+    - "5090"
+    - b200
+    - h200
+    - h20
+    - mi300x
+
+Chute:
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 288000   # 80h idle
+  tee: true

class_names.txt

@@ -0,0 +1,3 @@
+fire
+smoke
+fire extinguisher

main.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+
+
+def _load_local_miner_class():
+    miner_path = Path(__file__).resolve().parent / "miner.py"
+    spec = importlib.util.spec_from_file_location("manako_bridge_local_miner", str(miner_path))
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Could not load miner module from {miner_path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    miner_class = getattr(module, "Miner", None)
+    if miner_class is None:
+        raise RuntimeError(f"miner.py does not export Miner in {miner_path}")
+    return miner_class
+
+
+Miner = _load_local_miner_class()
+
+
+CLASS_NAMES = ['fire', 'smoke', 'fire extinguisher']
+MODEL_TYPE = 'onnxruntime'
+
+
+def _to_dict(value: Any) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return value
+    if hasattr(value, "model_dump") and callable(value.model_dump):
+        dumped = value.model_dump()
+        if isinstance(dumped, dict):
+            return dumped
+    if hasattr(value, "__dict__"):
+        return dict(value.__dict__)
+    return {}
+
+
+def _extract_boxes(frame_result: Any) -> list[Any]:
+    frame = _to_dict(frame_result)
+    boxes = frame.get("boxes", [])
+    if isinstance(boxes, list):
+        return boxes
+    return []
+
+
+def _resolve_runtime_class_names(miner: Any) -> list[str]:
+    value = getattr(miner, "class_names", None)
+    if isinstance(value, (list, tuple)):
+        resolved = [str(item) for item in value]
+        if resolved:
+            return resolved
+    return list(CLASS_NAMES)
+
+
+def _to_detection(box: Any, class_names: list[str]) -> dict[str, Any]:
+    payload = _to_dict(box)
+    cls_id = int(payload.get("cls_id", 0))
+    x1 = float(payload.get("x1", 0.0))
+    y1 = float(payload.get("y1", 0.0))
+    x2 = float(payload.get("x2", 0.0))
+    y2 = float(payload.get("y2", 0.0))
+    width = max(0.0, x2 - x1)
+    height = max(0.0, y2 - y1)
+    return {
+        "x": x1 + width / 2.0,
+        "y": y1 + height / 2.0,
+        "width": width,
+        "height": height,
+        "confidence": float(payload.get("conf", 0.0)),
+        "class_id": cls_id,
+        "class": class_names[cls_id] if 0 <= cls_id < len(class_names) else str(cls_id),
+    }
+
+
+def _normalize_image_for_miner(image: Any) -> Any:
+    if image is None or hasattr(image, "shape"):
+        return image
+    if isinstance(image, (bytes, bytearray, memoryview)):
+        try:
+            buffer = np.frombuffer(bytes(image), dtype=np.uint8)
+            decoded = cv2.imdecode(buffer, cv2.IMREAD_COLOR)
+            if decoded is not None:
+                return decoded
+        except Exception:
+            return image
+    if hasattr(image, "convert") and callable(image.convert):
+        try:
+            rgb = image.convert("RGB")
+            array = np.array(rgb)
+            if getattr(array, "ndim", 0) == 3 and array.shape[-1] == 3:
+                return cv2.cvtColor(array, cv2.COLOR_RGB2BGR)
+            return array
+        except Exception:
+            return image
+    try:
+        array = np.asarray(image)
+        if getattr(array, "shape", None):
+            return array
+    except Exception:
+        return image
+    return image
+
+
+def load_model(onnx_path: str | None = None, data_dir: str | None = None):
+    del onnx_path
+    repo_dir = Path(data_dir) if data_dir else Path(__file__).resolve().parent
+    miner = Miner(repo_dir)
+    class_names = _resolve_runtime_class_names(miner)
+    return {
+        "miner": miner,
+        "model_type": MODEL_TYPE,
+        "class_names": class_names,
+    }
+
+
+def _candidate_keypoint_counts(miner: Any) -> list[int]:
+    counts: list[int] = [0]
+    for attr in ("n_keypoints", "num_keypoints", "keypoint_count", "num_joints"):
+        value = getattr(miner, attr, None)
+        if isinstance(value, int) and value > 0:
+            counts.append(value)
+    counts.append(32)
+
+    seen: set[int] = set()
+    ordered: list[int] = []
+    for count in counts:
+        if count in seen:
+            continue
+        seen.add(count)
+        ordered.append(count)
+    return ordered
+
+
+def _predict_batch_with_fallbacks(miner: Any, image: Any) -> list[Any]:
+    normalized_image = _normalize_image_for_miner(image)
+    errors: list[str] = []
+    for n_keypoints in _candidate_keypoint_counts(miner):
+        try:
+            return miner.predict_batch([normalized_image], offset=0, n_keypoints=n_keypoints)
+        except Exception as exc:
+            errors.append(f"n_keypoints={n_keypoints} -> {exc}")
+            continue
+    raise RuntimeError("predict_batch failed for all keypoint candidates: " + " | ".join(errors))
+
+
+def run_model(model: Any, image: Any = None, onnx_path: str | None = None, data_dir: str | None = None):
+    del onnx_path
+    if image is None:
+        image = model
+        model = load_model(data_dir=data_dir)
+    miner = model["miner"]
+    class_names = model.get("class_names")
+    if not isinstance(class_names, list):
+        class_names = list(CLASS_NAMES)
+    results = _predict_batch_with_fallbacks(miner, image)
+    if not results:
+        return [[]]
+    frame_boxes = _extract_boxes(results[0])
+    detections = [_to_detection(box, class_names) for box in frame_boxes]
+    return [detections]
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Usage: main.py <image_path>", file=sys.stderr)
+        raise SystemExit(1)
+    image_path = sys.argv[1]
+    image = cv2.imread(image_path, cv2.IMREAD_COLOR)
+    if image is None:
+        print(f"Could not read image: {image_path}", file=sys.stderr)
+        raise SystemExit(1)
+    data_dir = os.path.dirname(os.path.abspath(__file__))
+    model = load_model(data_dir=data_dir)
+    output = run_model(model, image)
+    print(json.dumps(output, indent=2))
+
+
+if __name__ == "__main__":
+    main()

miner.py

@@ -0,0 +1,235 @@
+# build-marker: fire-v2-blob-imgsz960
+"""SN44 fire detection miner — yolo26n single-pass @ imgsz=960.
+
+v2 (2026-05-09): trained on merged 25k pool (validator-synth + D-Fire +
+Simuletic + z5atr). FP16 ONNX, ~5 MB. Single forward pass at imgsz=960
+fits the 50 ms p95 latency gate (~35 ms on 4090, blobFromImage preproc).
+
+SAHI tiling was tested but blew the latency budget (5x preproc/postproc
+overhead). Code preserved at fire/deploy/miner_sahi.py for later experiments.
+
+Classes (validator order from manak0/Detect-fire class_names.txt):
+  0=fire, 1=fire extinguisher, 2=smoke
+
+Single ONNX expected at path_hf_repo/weights.onnx (yolo26n e2e [1,300,6]).
+"""
+import math
+from pathlib import Path
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+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:
+    def __init__(self, path_hf_repo) -> None:
+        self.path_hf_repo = Path(path_hf_repo)
+        # Validator's actual GT class order is [fire, smoke, fire extinguisher]
+        # — verified by audit of alfred8995/fire001 (scores 1.00) and
+        # navierstocks/fire (scores 0.96), both using this order. The published
+        # manak0/Detect-fire class_names.txt list [fire, fire_ext, smoke] does
+        # NOT match the actual scoring index.
+        # Our model was trained with [fire, fire_ext, smoke] (cls=1=ext, cls=2=smoke).
+        # cls_remap translates model output index → validator GT index.
+        self.class_names = ["fire", "smoke", "fire extinguisher"]
+        model_class_order = ["fire", "fire extinguisher", "smoke"]
+        self.cls_remap = np.array(
+            [self.class_names.index(n) for n in model_class_order],
+            dtype=np.int32,
+        )  # → [0, 2, 1]: model cls 0→0, 1→2, 2→1
+
+        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()]
+        self.input_dtype = (np.float16
+                            if 'float16' in self.session.get_inputs()[0].type
+                            else np.float32)
+
+        self.input_h = 960
+        self.input_w = 960
+        self.conf_thres_per_class = np.array([0.20, 0.20, 0.20], dtype=np.float32)
+        self.iou_thresh = 0.5
+        self.cross_iou_thresh = 0.7
+        self.max_det = 100
+        self.min_box_area = 64
+        self.min_side = 6
+        self.max_aspect_ratio = 10.0
+
+        warm = np.zeros((768, 1408, 3), dtype=np.uint8)
+        for _ in range(3):
+            try: self._infer_single(warm)
+            except Exception: break
+
+    def __repr__(self):
+        thr = ",".join(f"{n[:4]}={t:.2f}" for n, t
+                       in zip(self.class_names, self.conf_thres_per_class.tolist()))
+        return (f"FireMiner v2  yolo26n@{self.input_w} single-pass blob  "
+                f"conf=[{thr}]  iou={self.iou_thresh}")
+
+    def _preprocess(self, image_bgr):
+        """Letterbox + cv2.dnn.blobFromImage (fused C++ resize/normalize/transpose)."""
+        h, w = image_bgr.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_bgr, (nw, nh), interpolation=interp)
+        else:
+            resized = image_bgr
+        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
+        # blobFromImage: fused BGR→RGB (swapRB) + /255 + transpose CHW + add batch dim
+        blob = cv2.dnn.blobFromImage(
+            canvas, scalefactor=1/255.0,
+            size=(self.input_w, self.input_h),
+            mean=(0, 0, 0), swapRB=True, crop=False,
+        )
+        if self.input_dtype == np.float16:
+            blob = blob.astype(np.float16)
+        return blob, ratio, (float(dx), float(dy))
+
+    def _infer_single(self, image_bgr):
+        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_all = out[:, 4].astype(np.float32)
+        cls_all = self.cls_remap[out[:, 5].astype(np.int32)]
+        cls_idx = np.clip(cls_all, 0, len(self.conf_thres_per_class) - 1)
+        keep = confs_all >= self.conf_thres_per_class[cls_idx]
+        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)]
+        boxes[:, [0, 2]] = (boxes[:, [0, 2]] - dx) / ratio
+        boxes[:, [1, 3]] = (boxes[:, [1, 3]] - dy) / ratio
+        oh, ow = image_bgr.shape[:2]
+        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, ow - 1)
+        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, oh - 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, confs, cls_ids = boxes[keep_idx], confs[keep_idx], 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, ow, oh)
+
+    @staticmethod
+    def _hard_nms(boxes, scores, iou_thresh):
+        n = len(boxes)
+        if n == 0: return np.array([], dtype=np.intp)
+        order = np.argsort(scores)[::-1]
+        keep, 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, yy1 = max(bi[0], bj[0]), max(bi[1], bj[1])
+                xx2, yy2 = min(bi[2], bj[2]), 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, scores, cls_ids, iou_thresh):
+        if len(boxes) == 0: return np.array([], dtype=np.intp)
+        all_keep = []
+        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, scores, cls_ids, iou_thresh):
+        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 = []
+        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]
+
+    def _to_boundingboxes(self, boxes, confs, cls_ids, orig_w, orig_h):
+        out = []
+        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
+
+    def predict_batch(self, batch_images, offset, n_keypoints):
+        results = []
+        for idx, image in enumerate(batch_images):
+            boxes = self._infer_single(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-nano"
+}

pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "miner-element-adapter"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+dependencies = [
+  "numpy>=1.23",
+  "onnxruntime[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",
+  "torch",
+  "torchvision",
+]

weights.onnx

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