subnet_bridge: copy winning miner repo into library

README.md

@@ -0,0 +1,23 @@
+---
+tags:
+- element_type:detect
+- model:yolov11-nano
+- object:person
+manako:
+  description: Roboflow - generated by element_trainer service to detect person
+  source: element_trainer/800e961b-eb64-4380-880c-f1ed67abd563
+  prompt_hints: null
+  input_payload:
+  - name: frame
+    type: image
+    description: RGB frame
+  output_payload:
+  - name: detections
+    type: detections
+    description: List of detections
+  evaluation_score: null
+  last_benchmark:
+    type: synthetic_fixed
+    ran_at: '2026-03-06T02:20:51.927289Z'
+    result_path: benchmark/synthetic/1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb.json
+---

benchmark/synthetic/1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb.json

@@ -0,0 +1,214 @@
+{
+  "meta": {
+    "element_id": "manak0/Detect-Person",
+    "run_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "benchmark_type": "synthetic_fixed",
+    "saved_at": "2026-03-06T02:20:51.927289Z",
+    "result_path": "benchmark/synthetic/1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb.json",
+    "split_ref": "private_final"
+  },
+  "results": {
+    "overall_iou": 0.6932410264986374,
+    "per_class_iou": {
+      "person": 0.6932410264986374
+    },
+    "map_50": 0.3755112726134544,
+    "map_50_90": 0.21786430796282266,
+    "precision": 0.8950531668978271,
+    "recall": 0.3885989562424729,
+    "per_class_map_50": {
+      "person": 0.3755112726134544
+    },
+    "per_class_map_50_90": {
+      "person": 0.21786430796282266
+    },
+    "per_class_precision": {
+      "person": 0.8950531668978271
+    },
+    "per_class_recall": {
+      "person": 0.3885989562424729
+    },
+    "matched_images": 165,
+    "gt_count": 4982,
+    "pred_count": 2163,
+    "classes": [
+      "person"
+    ],
+    "dataset_id": "800e961b-eb64-4380-880c-f1ed67abd563",
+    "dataset_version_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "run_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "split_ref": "private_final",
+    "selected_frame_count": 165,
+    "selected_frame_indices": [
+      1,
+      6,
+      9,
+      12,
+      22,
+      25,
+      26,
+      27,
+      28,
+      32,
+      38,
+      40,
+      42,
+      50,
+      51,
+      52,
+      53,
+      54,
+      55,
+      57,
+      60,
+      67,
+      77,
+      80,
+      81,
+      88,
+      96,
+      97,
+      98,
+      101,
+      104,
+      105,
+      114,
+      115,
+      120,
+      122,
+      128,
+      129,
+      131,
+      136,
+      137,
+      141,
+      145,
+      146,
+      148,
+      152,
+      155,
+      156,
+      159,
+      161,
+      163,
+      165,
+      166,
+      171,
+      172,
+      174,
+      176,
+      186,
+      189,
+      190,
+      196,
+      199,
+      200,
+      201,
+      202,
+      213,
+      214,
+      218,
+      226,
+      234,
+      235,
+      236,
+      238,
+      239,
+      243,
+      245,
+      251,
+      255,
+      259,
+      260,
+      268,
+      270,
+      274,
+      275,
+      278,
+      279,
+      283,
+      287,
+      289,
+      291,
+      300,
+      301,
+      303,
+      307,
+      310,
+      311,
+      318,
+      319,
+      321,
+      322,
+      326,
+      329,
+      330,
+      332,
+      333,
+      335,
+      336,
+      341,
+      342,
+      343,
+      344,
+      346,
+      348,
+      354,
+      357,
+      358,
+      360,
+      362,
+      367,
+      372,
+      373,
+      376,
+      378,
+      379,
+      381,
+      384,
+      385,
+      395,
+      398,
+      399,
+      401,
+      417,
+      418,
+      428,
+      431,
+      432,
+      433,
+      434,
+      438,
+      440,
+      442,
+      443,
+      444,
+      446,
+      447,
+      455,
+      458,
+      459,
+      465,
+      468,
+      469,
+      470,
+      475,
+      476,
+      480,
+      483,
+      489,
+      492,
+      493,
+      494,
+      495,
+      496,
+      498,
+      499,
+      500
+    ],
+    "evaluated_version_ids": [
+      "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb"
+    ],
+    "skipped_missing_pairs": 0
+  }
+}

benchmark/synthetic/index.json

@@ -0,0 +1,16 @@
+[
+  {
+    "run_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "saved_at": "2026-03-06T02:20:51.927289Z",
+    "result_path": "benchmark/synthetic/1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb.json",
+    "overall_iou": 0.6932410264986374,
+    "map_50": 0.3755112726134544,
+    "map_50_90": 0.21786430796282266,
+    "precision": 0.8950531668978271,
+    "recall": 0.3885989562424729,
+    "matched_images": 165,
+    "gt_count": 4982,
+    "pred_count": 2163,
+    "split_ref": "private_final"
+  }
+]

benchmark/synthetic/latest.json

@@ -0,0 +1,214 @@
+{
+  "meta": {
+    "element_id": "manak0/Detect-Person",
+    "run_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "benchmark_type": "synthetic_fixed",
+    "saved_at": "2026-03-06T02:20:51.927289Z",
+    "result_path": "benchmark/synthetic/1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb.json",
+    "split_ref": "private_final"
+  },
+  "results": {
+    "overall_iou": 0.6932410264986374,
+    "per_class_iou": {
+      "person": 0.6932410264986374
+    },
+    "map_50": 0.3755112726134544,
+    "map_50_90": 0.21786430796282266,
+    "precision": 0.8950531668978271,
+    "recall": 0.3885989562424729,
+    "per_class_map_50": {
+      "person": 0.3755112726134544
+    },
+    "per_class_map_50_90": {
+      "person": 0.21786430796282266
+    },
+    "per_class_precision": {
+      "person": 0.8950531668978271
+    },
+    "per_class_recall": {
+      "person": 0.3885989562424729
+    },
+    "matched_images": 165,
+    "gt_count": 4982,
+    "pred_count": 2163,
+    "classes": [
+      "person"
+    ],
+    "dataset_id": "800e961b-eb64-4380-880c-f1ed67abd563",
+    "dataset_version_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "run_id": "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb",
+    "split_ref": "private_final",
+    "selected_frame_count": 165,
+    "selected_frame_indices": [
+      1,
+      6,
+      9,
+      12,
+      22,
+      25,
+      26,
+      27,
+      28,
+      32,
+      38,
+      40,
+      42,
+      50,
+      51,
+      52,
+      53,
+      54,
+      55,
+      57,
+      60,
+      67,
+      77,
+      80,
+      81,
+      88,
+      96,
+      97,
+      98,
+      101,
+      104,
+      105,
+      114,
+      115,
+      120,
+      122,
+      128,
+      129,
+      131,
+      136,
+      137,
+      141,
+      145,
+      146,
+      148,
+      152,
+      155,
+      156,
+      159,
+      161,
+      163,
+      165,
+      166,
+      171,
+      172,
+      174,
+      176,
+      186,
+      189,
+      190,
+      196,
+      199,
+      200,
+      201,
+      202,
+      213,
+      214,
+      218,
+      226,
+      234,
+      235,
+      236,
+      238,
+      239,
+      243,
+      245,
+      251,
+      255,
+      259,
+      260,
+      268,
+      270,
+      274,
+      275,
+      278,
+      279,
+      283,
+      287,
+      289,
+      291,
+      300,
+      301,
+      303,
+      307,
+      310,
+      311,
+      318,
+      319,
+      321,
+      322,
+      326,
+      329,
+      330,
+      332,
+      333,
+      335,
+      336,
+      341,
+      342,
+      343,
+      344,
+      346,
+      348,
+      354,
+      357,
+      358,
+      360,
+      362,
+      367,
+      372,
+      373,
+      376,
+      378,
+      379,
+      381,
+      384,
+      385,
+      395,
+      398,
+      399,
+      401,
+      417,
+      418,
+      428,
+      431,
+      432,
+      433,
+      434,
+      438,
+      440,
+      442,
+      443,
+      444,
+      446,
+      447,
+      455,
+      458,
+      459,
+      465,
+      468,
+      469,
+      470,
+      475,
+      476,
+      480,
+      483,
+      489,
+      492,
+      493,
+      494,
+      495,
+      496,
+      498,
+      499,
+      500
+    ],
+    "evaluated_version_ids": [
+      "1ada5b1e-38b8-4bdc-967a-d8a27b0e6afb"
+    ],
+    "skipped_missing_pairs": 0
+  }
+}

chute_config.yml

@@ -0,0 +1,18 @@
+Image:
+  from_base: parachutes/python:3.12
+  run_command:
+    - pip install --upgrade setuptools wheel
+    - pip install 'numpy>=1.23' 'onnxruntime>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9' 'torch<2.6'
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 24
+  min_memory_gb: 32
+  min_cpu_count: 32
+
+Chute:
+  timeout_seconds: 900
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  shutdown_after_seconds: 288000

class_names.txt

@@ -0,0 +1 @@
+person

main.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import cv2
+
+from miner import Miner
+
+
+CLASS_NAMES = ['person']
+MODEL_TYPE = 'ultralytics-yolo'
+
+
+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 _to_detection(box: Any) -> 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 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)
+    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]:
+    errors: list[str] = []
+    for n_keypoints in _candidate_keypoint_counts(miner):
+        try:
+            return miner.predict_batch([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"]
+    results = _predict_batch_with_fallbacks(miner, image)
+    if not results:
+        return [[]]
+    frame_boxes = _extract_boxes(results[0])
+    detections = [_to_detection(box) 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,175 @@
+from pathlib import Path
+import math
+
+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:
+    """
+    Auto-generated by subnet_bridge from a Manako element repo.
+    This miner is intentionally self-contained for chute import restrictions.
+    """
+
+    def __init__(self, path_hf_repo: Path) -> None:
+        self.path_hf_repo = path_hf_repo
+        self.class_names = ['person']
+        self.session = ort.InferenceSession(
+            str(path_hf_repo / "weights.onnx"),
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        self.input_name = self.session.get_inputs()[0].name
+        input_shape = self.session.get_inputs()[0].shape
+        # expected [N, C, H, W]
+        self.input_h = int(input_shape[2])
+        self.input_w = int(input_shape[3])
+        self.conf_threshold = 0.25
+        self.iou_threshold = 0.45
+
+    def __repr__(self) -> str:
+        return f"ONNX Miner session={type(self.session).__name__} classes={len(self.class_names)}"
+
+    def _preprocess(self, image_bgr: ndarray) -> tuple[np.ndarray, tuple[int, int]]:
+        h, w = image_bgr.shape[:2]
+        rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+        resized = cv2.resize(rgb, (self.input_w, self.input_h))
+        x = resized.astype(np.float32) / 255.0
+        x = np.transpose(x, (2, 0, 1))[None, ...]
+        return x, (h, w)
+
+    def _normalize_predictions(self, raw: np.ndarray) -> np.ndarray:
+        # Common ultralytics export shapes:
+        # - [1, C, N] where C=4+num_classes
+        # - [1, N, C]
+        pred = raw[0]
+        if pred.ndim != 2:
+            raise ValueError(f"Unexpected prediction shape: {raw.shape}")
+        if pred.shape[0] < pred.shape[1]:
+            pred = pred.transpose(1, 0)
+        return pred
+
+    def _nms(self, dets: list[tuple[float, float, float, float, float, int]]) -> list[tuple[float, float, float, float, float, int]]:
+        if not dets:
+            return []
+
+        boxes = np.array([[d[0], d[1], d[2], d[3]] for d in dets], dtype=np.float32)
+        scores = np.array([d[4] for d in dets], dtype=np.float32)
+        order = scores.argsort()[::-1]
+        keep = []
+
+        while order.size > 0:
+            i = order[0]
+            keep.append(i)
+
+            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])
+
+            w = np.maximum(0.0, xx2 - xx1)
+            h = np.maximum(0.0, yy2 - yy1)
+            inter = w * h
+
+            area_i = (boxes[i, 2] - boxes[i, 0]) * (boxes[i, 3] - boxes[i, 1])
+            area_rest = (boxes[order[1:], 2] - boxes[order[1:], 0]) * (boxes[order[1:], 3] - boxes[order[1:], 1])
+            union = np.maximum(area_i + area_rest - inter, 1e-6)
+            iou = inter / union
+
+            remaining = np.where(iou <= self.iou_threshold)[0]
+            order = order[remaining + 1]
+
+        return [dets[idx] for idx in keep]
+
+    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+        inp, (orig_h, orig_w) = self._preprocess(image_bgr)
+        out = self.session.run(None, {self.input_name: inp})[0]
+        pred = self._normalize_predictions(out)
+
+        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 >= self.conf_threshold
+
+        boxes = boxes[keep]
+        confs = confs[keep]
+        cls_ids = cls_ids[keep]
+
+        if boxes.shape[0] == 0:
+            return []
+
+        sx = orig_w / float(self.input_w)
+        sy = orig_h / float(self.input_h)
+
+        dets: list[tuple[float, float, float, float, float, int]] = []
+        for i in range(boxes.shape[0]):
+            cx, cy, bw, bh = boxes[i].tolist()
+            x1 = (cx - bw / 2.0) * sx
+            y1 = (cy - bh / 2.0) * sy
+            x2 = (cx + bw / 2.0) * sx
+            y2 = (cy + bh / 2.0) * sy
+            dets.append((x1, y1, x2, y2, float(confs[i]), int(cls_ids[i])))
+
+        dets = self._nms(dets)
+
+        out_boxes: list[BoundingBox] = []
+        for x1, y1, x2, y2, conf, cls_id in dets:
+            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)))
+            out_boxes.append(
+                BoundingBox(
+                    x1=ix1,
+                    y1=iy1,
+                    x2=ix2,
+                    y2=iy2,
+                    cls_id=cls_id,
+                    conf=max(0.0, min(1.0, conf)),
+                )
+            )
+        return out_boxes
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        results: list[TVFrameResult] = []
+        for idx, image in enumerate(batch_images):
+            boxes = self._infer_single(image)
+            keypoints = [(0, 0) for _ in range(max(0, int(n_keypoints)))]
+            results.append(
+                TVFrameResult(
+                    frame_id=offset + idx,
+                    boxes=boxes,
+                    keypoints=keypoints,
+                )
+            )
+        return results

model_type.json

@@ -0,0 +1,4 @@
+{
+  "task_type": "object-detection",
+  "model_type": "yolov11-nano"
+}

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "miner-element-adapter"
+version = "0.1.0"
+requires-python = ">=3.9"
+
+dependencies = [
+  "numpy>=1.23",
+  "onnxruntime>=1.16",
+  "opencv-python>=4.7",
+  "pillow>=9.5",
+  "huggingface_hub>=0.19.4",
+  "pydantic>=2.0",
+  "pyyaml>=6.0",
+  "aiohttp>=3.9",
+  "torch<2.6",
+]

test_miner.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""
+Test script for Detect-Person miner.
+Loads images from a folder, runs predict_batch, and saves result images with bounding boxes.
+"""
+from pathlib import Path
+import argparse
+import sys
+
+import cv2
+import numpy as np
+
+# Add parent dir so we can import miner
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from miner import Miner
+
+
+IMAGE_EXTENSIONS = {".jpg", ".jpeg", ".png", ".bmp", ".webp"}
+BOX_COLOR = (0, 255, 0)      # Green (BGR)
+LABEL_COLOR = (0, 255, 0)    # Green
+FONT_SCALE = 0.6
+FONT_THICKNESS = 2
+BOX_THICKNESS = 2
+
+
+def list_images(folder: Path) -> list[Path]:
+    """Collect image paths from folder, sorted by name."""
+    paths = [p for p in folder.iterdir() if p.suffix.lower() in IMAGE_EXTENSIONS]
+    return sorted(paths)
+
+
+def load_images(paths: list[Path]) -> tuple[list[np.ndarray], list[Path]]:
+    """Load images as BGR numpy arrays. Returns (images, successful_paths)."""
+    images = []
+    successful_paths = []
+    for p in paths:
+        img = cv2.imread(str(p))
+        if img is None:
+            print(f"Warning: Could not load {p}", file=sys.stderr)
+            continue
+        images.append(img)
+        successful_paths.append(p)
+    return images, successful_paths
+
+
+def draw_detections(
+    image: np.ndarray,
+    boxes: list,
+    class_names: list[str],
+) -> np.ndarray:
+    """Draw bounding boxes and labels on image. Returns a copy."""
+    out = image.copy()
+    for box in boxes:
+        x1, y1 = box.x1, box.y1
+        x2, y2 = box.x2, box.y2
+        cls_name = class_names[box.cls_id] if box.cls_id < len(class_names) else str(box.cls_id)
+        label = f"{cls_name} {box.conf:.2f}"
+        cv2.rectangle(out, (x1, y1), (x2, y2), BOX_COLOR, BOX_THICKNESS)
+        (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, FONT_SCALE, FONT_THICKNESS)
+        cv2.rectangle(out, (x1, y1 - th - 8), (x1 + tw + 4, y1), BOX_COLOR, -1)
+        cv2.putText(
+            out, label,
+            (x1 + 2, y1 - 4),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            FONT_SCALE,
+            (0, 0, 0),
+            FONT_THICKNESS,
+        )
+    return out
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Test Detect-Person miner: run detection on images and save visualized results.",
+    )
+    parser.add_argument(
+        "images_dir",
+        type=Path,
+        help="Folder containing images to process",
+    )
+    parser.add_argument(
+        "--model-dir",
+        type=Path,
+        default=None,
+        help="Path to model directory (contains weights.onnx). Default: same as script",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=None,
+        help="Output folder for result images. Default: images_dir/results",
+    )
+    parser.add_argument(
+        "--batch-size",
+        type=int,
+        default=8,
+        help="Batch size for predict_batch (default: 8)",
+    )
+    parser.add_argument(
+        "--show",
+        action="store_true",
+        help="Display each result image in a window (requires display)",
+    )
+    args = parser.parse_args()
+
+    images_dir = args.images_dir
+    if not images_dir.is_dir():
+        print(f"Error: Not a directory: {images_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    image_paths = list_images(images_dir)
+    if not image_paths:
+        print(f"Error: No images found in {images_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    model_dir = args.model_dir or Path(__file__).resolve().parent
+    if not (model_dir / "weights.onnx").exists():
+        print(f"Error: weights.onnx not found in {model_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    output_dir = args.output or (images_dir / "results")
+    output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"Output: {output_dir}")
+
+    print("Loading Miner...")
+    miner = Miner(model_dir)
+    print(f"  {miner}")
+
+    images, valid_paths = load_images(image_paths)
+    if len(images) != len(image_paths):
+        print(f"Loaded {len(images)} / {len(image_paths)} images (some failed)", file=sys.stderr)
+
+    total_detections = 0
+    for i in range(0, len(images), args.batch_size):
+        batch = images[i : i + args.batch_size]
+        batch_paths = valid_paths[i : i + args.batch_size]
+        offset = i
+        results = miner.predict_batch(batch, offset=offset, n_keypoints=0)
+
+        for j, (result, img_path) in enumerate(zip(results, batch_paths)):
+            vis = draw_detections(batch[j], result.boxes, miner.class_names)
+            total_detections += len(result.boxes)
+            out_path = output_dir / f"{img_path.stem}_det{img_path.suffix}"
+            cv2.imwrite(str(out_path), vis)
+            print(f"  {img_path.name} -> {out_path.name} ({len(result.boxes)} detections)")
+
+            if args.show:
+                cv2.imshow("Detect-Person Result", vis)
+                key = cv2.waitKey(0)
+                if key == ord("q"):
+                    args.show = False
+
+    if args.show:
+        cv2.destroyAllWindows()
+
+    print(f"\nDone. Total detections: {total_detections}. Results saved to {output_dir}")
+
+
+if __name__ == "__main__":
+    main()

weights.onnx

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