Duplicate from manak0/Detect-road-signs

Co-authored-by: Mohammed Terry-Jack <MTerryJack@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,28 @@
+---
+tags:
+- element_type:detect
+- model:yolov11-nano
+- object:road sign
+manako:
+  description: Manako baseline - generated by element_trainer service to detect road
+    sign
+  source: element_trainer/road-signs
+  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-05-14T11:30:33.077393Z'
+    result_path: benchmark/synthetic/all_versions_2026-05-14T11-30-01.642192Z.json
+  score:
+    size_mb: 10.803857
+    performance_map50: 0.5919211196881521
+    E: 0.05478794468384319
+---

benchmark/synthetic/all_versions_2026-05-14T11-30-01.642192Z.json

@@ -0,0 +1,100 @@
+{
+  "meta": {
+    "element_id": "manak0/Detect-road-signs",
+    "run_id": "all_versions_2026-05-14T11-30-01.642192Z",
+    "benchmark_type": "synthetic_fixed",
+    "saved_at": "2026-05-14T11:30:33.077393Z",
+    "result_path": "benchmark/synthetic/all_versions_2026-05-14T11-30-01.642192Z.json"
+  },
+  "results": {
+    "overall_iou": 0.6995314762064266,
+    "per_class_iou": {
+      "road sign": 0.6995314762064266
+    },
+    "map_50": 0.5919211196881521,
+    "map_50_90": 0.46679792345917676,
+    "precision": 0.8596491228070176,
+    "recall": 0.6068111455108359,
+    "per_class_map_50": {
+      "road sign": 0.5919211196881521
+    },
+    "per_class_map_50_90": {
+      "road sign": 0.46679792345917676
+    },
+    "per_class_precision": {
+      "road sign": 0.8596491228070176
+    },
+    "per_class_recall": {
+      "road sign": 0.6068111455108359
+    },
+    "matched_images": 50,
+    "gt_count": 323,
+    "pred_count": 228,
+    "classes": [
+      "road sign"
+    ],
+    "dataset_id": "ea690ab5-a4de-45f0-8f0f-e3b07e3eefba",
+    "dataset_version_id": "all_versions",
+    "run_id": "all_versions_2026-05-14T11-30-01.642192Z",
+    "split_ref": null,
+    "selected_frame_count": 50,
+    "selected_frame_indices": [
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50
+    ],
+    "evaluated_version_ids": [
+      "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+      "34396eaa-58e0-47fa-89b1-bbebf46c4789",
+      "0d9ebe06-47c2-40d0-87ef-8cad3dc39c63"
+    ],
+    "skipped_missing_pairs": 0
+  }
+}

benchmark/synthetic/bd9e3e46-9c3e-499f-9864-6b6890d53b21.json

@@ -0,0 +1,98 @@
+{
+  "meta": {
+    "element_id": "manak0/Detect-road-signs",
+    "run_id": "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+    "benchmark_type": "synthetic_fixed",
+    "saved_at": "2026-04-27T15:38:54.020844Z",
+    "result_path": "benchmark/synthetic/bd9e3e46-9c3e-499f-9864-6b6890d53b21.json"
+  },
+  "results": {
+    "overall_iou": 0.6995314762064266,
+    "per_class_iou": {
+      "road sign": 0.6995314762064266
+    },
+    "map_50": 0.5919211196881521,
+    "map_50_90": 0.46679792345917676,
+    "precision": 0.8596491228070176,
+    "recall": 0.6068111455108359,
+    "per_class_map_50": {
+      "road sign": 0.5919211196881521
+    },
+    "per_class_map_50_90": {
+      "road sign": 0.46679792345917676
+    },
+    "per_class_precision": {
+      "road sign": 0.8596491228070176
+    },
+    "per_class_recall": {
+      "road sign": 0.6068111455108359
+    },
+    "matched_images": 50,
+    "gt_count": 323,
+    "pred_count": 228,
+    "classes": [
+      "road sign"
+    ],
+    "dataset_id": "ea690ab5-a4de-45f0-8f0f-e3b07e3eefba",
+    "dataset_version_id": "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+    "run_id": "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+    "split_ref": null,
+    "selected_frame_count": 50,
+    "selected_frame_indices": [
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50
+    ],
+    "evaluated_version_ids": [
+      "bd9e3e46-9c3e-499f-9864-6b6890d53b21"
+    ],
+    "skipped_missing_pairs": 0
+  }
+}

benchmark/synthetic/index.json

@@ -0,0 +1,28 @@
+[
+  {
+    "run_id": "all_versions_2026-05-14T11-30-01.642192Z",
+    "saved_at": "2026-05-14T11:30:33.077393Z",
+    "result_path": "benchmark/synthetic/all_versions_2026-05-14T11-30-01.642192Z.json",
+    "overall_iou": 0.6995314762064266,
+    "map_50": 0.5919211196881521,
+    "map_50_90": 0.46679792345917676,
+    "precision": 0.8596491228070176,
+    "recall": 0.6068111455108359,
+    "matched_images": 50,
+    "gt_count": 323,
+    "pred_count": 228
+  },
+  {
+    "run_id": "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+    "saved_at": "2026-04-27T15:38:54.020844Z",
+    "result_path": "benchmark/synthetic/bd9e3e46-9c3e-499f-9864-6b6890d53b21.json",
+    "overall_iou": 0.6995314762064266,
+    "map_50": 0.5919211196881521,
+    "map_50_90": 0.46679792345917676,
+    "precision": 0.8596491228070176,
+    "recall": 0.6068111455108359,
+    "matched_images": 50,
+    "gt_count": 323,
+    "pred_count": 228
+  }
+]

benchmark/synthetic/latest.json

@@ -0,0 +1,100 @@
+{
+  "meta": {
+    "element_id": "manak0/Detect-road-signs",
+    "run_id": "all_versions_2026-05-14T11-30-01.642192Z",
+    "benchmark_type": "synthetic_fixed",
+    "saved_at": "2026-05-14T11:30:33.077393Z",
+    "result_path": "benchmark/synthetic/all_versions_2026-05-14T11-30-01.642192Z.json"
+  },
+  "results": {
+    "overall_iou": 0.6995314762064266,
+    "per_class_iou": {
+      "road sign": 0.6995314762064266
+    },
+    "map_50": 0.5919211196881521,
+    "map_50_90": 0.46679792345917676,
+    "precision": 0.8596491228070176,
+    "recall": 0.6068111455108359,
+    "per_class_map_50": {
+      "road sign": 0.5919211196881521
+    },
+    "per_class_map_50_90": {
+      "road sign": 0.46679792345917676
+    },
+    "per_class_precision": {
+      "road sign": 0.8596491228070176
+    },
+    "per_class_recall": {
+      "road sign": 0.6068111455108359
+    },
+    "matched_images": 50,
+    "gt_count": 323,
+    "pred_count": 228,
+    "classes": [
+      "road sign"
+    ],
+    "dataset_id": "ea690ab5-a4de-45f0-8f0f-e3b07e3eefba",
+    "dataset_version_id": "all_versions",
+    "run_id": "all_versions_2026-05-14T11-30-01.642192Z",
+    "split_ref": null,
+    "selected_frame_count": 50,
+    "selected_frame_indices": [
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      16,
+      17,
+      18,
+      19,
+      20,
+      21,
+      22,
+      23,
+      24,
+      25,
+      26,
+      27,
+      28,
+      29,
+      30,
+      31,
+      32,
+      33,
+      34,
+      35,
+      36,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      46,
+      47,
+      48,
+      49,
+      50
+    ],
+    "evaluated_version_ids": [
+      "bd9e3e46-9c3e-499f-9864-6b6890d53b21",
+      "34396eaa-58e0-47fa-89b1-bbebf46c4789",
+      "0d9ebe06-47c2-40d0-87ef-8cad3dc39c63"
+    ],
+    "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.8'
+
+NodeSelector:
+  gpu_count: 1
+  min_vram_gb_per_gpu: 16
+  include:
+    - pro_6000
+
+Chute:
+  timeout_seconds: 300
+  concurrency: 4
+  max_instances: 5
+  scaling_threshold: 0.5
+  tee: true

class_names.txt

@@ -0,0 +1 @@
+road sign

main.py

@@ -0,0 +1,679 @@
+# Auto-generated ONNX runner. This file is self-contained for a single model.
+import json
+import os
+import sys
+from typing import Any, Dict, List, Tuple
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from PIL import Image
+
+
+def read_json(path: str) -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def read_text_lines(path: str) -> List[str]:
+    with open(path, "r", encoding="utf-8") as f:
+        return [line.strip() for line in f.readlines() if line.strip()]
+
+
+def load_environment(data_dir: str) -> Dict[str, Any]:
+    env_path = os.path.join(data_dir, "environment.json")
+    if not os.path.exists(env_path):
+        return {}
+    env = read_json(env_path)
+    preproc = env.get("PREPROCESSING")
+    if isinstance(preproc, str):
+        try:
+            env["PREPROCESSING"] = json.loads(preproc)
+        except json.JSONDecodeError:
+            env["PREPROCESSING"] = {}
+    return env
+
+
+def load_class_names(data_dir: str, environment: Dict[str, Any]) -> List[str]:
+    class_path = os.path.join(data_dir, "class_names.txt")
+    if os.path.exists(class_path):
+        return read_text_lines(class_path)
+    class_map = environment.get("CLASS_MAP")
+    if isinstance(class_map, dict):
+        class_names = []
+        for i in range(len(class_map.keys())):
+            class_names.append(class_map[str(i)])
+        return class_names
+    return []
+
+
+def load_keypoints_metadata(data_dir: str) -> List[Dict[str, Any]]:
+    meta_path = os.path.join(data_dir, "keypoints_metadata.json")
+    if not os.path.exists(meta_path):
+        return []
+    return read_json(meta_path)
+
+
+def load_image(value: Any) -> Tuple[np.ndarray, bool]:
+    if isinstance(value, np.ndarray):
+        return value, True
+    if isinstance(value, Image.Image):
+        return np.asarray(value.convert("RGB")), False
+    if isinstance(value, (bytes, bytearray)):
+        image = cv2.imdecode(np.frombuffer(value, np.uint8), cv2.IMREAD_COLOR)
+        return image, True
+    if isinstance(value, str):
+        image = cv2.imread(value, cv2.IMREAD_COLOR)
+        if image is None:
+            raise ValueError(f"Could not read image: {value}")
+        return image, True
+    raise ValueError(f"Unsupported image input type: {type(value)}")
+
+
+def static_crop_should_be_applied(preprocessing_config: dict) -> bool:
+    cfg = preprocessing_config.get("static-crop")
+    return bool(cfg and cfg.get("enabled"))
+
+
+def take_static_crop(image: np.ndarray, crop_parameters: Dict[str, int]) -> np.ndarray:
+    height, width = image.shape[:2]
+    x_min = int(crop_parameters["x_min"] / 100 * width)
+    y_min = int(crop_parameters["y_min"] / 100 * height)
+    x_max = int(crop_parameters["x_max"] / 100 * width)
+    y_max = int(crop_parameters["y_max"] / 100 * height)
+    return image[y_min:y_max, x_min:x_max, :]
+
+
+def apply_grayscale_conversion(image: np.ndarray) -> np.ndarray:
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    return cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+
+
+def apply_contrast_stretching(image: np.ndarray) -> np.ndarray:
+    p2, p98 = np.percentile(image, (2, 98))
+    image = np.clip(image, p2, p98)
+    if p98 - p2 > 0:
+        image = (image - p2) * (255.0 / (p98 - p2))
+    return image.astype(np.uint8)
+
+
+def apply_histogram_equalisation(image: np.ndarray) -> np.ndarray:
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    image = cv2.equalizeHist(image)
+    return cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+
+
+def apply_adaptive_equalisation(image: np.ndarray) -> np.ndarray:
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    clahe = cv2.createCLAHE(clipLimit=0.03, tileGridSize=(8, 8))
+    image = clahe.apply(image)
+    return cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+
+
+def apply_preproc(image: np.ndarray, preproc: Dict[str, Any]) -> Tuple[np.ndarray, Tuple[int, int]]:
+    h, w = image.shape[:2]
+    img_dims = (h, w)
+    if static_crop_should_be_applied(preproc):
+        image = take_static_crop(image, preproc["static-crop"])
+    if preproc.get("contrast", {}).get("enabled"):
+        ctype = preproc.get("contrast", {}).get("type")
+        if ctype == "Contrast Stretching":
+            image = apply_contrast_stretching(image)
+        elif ctype == "Histogram Equalization":
+            image = apply_histogram_equalisation(image)
+        elif ctype == "Adaptive Equalization":
+            image = apply_adaptive_equalisation(image)
+    if preproc.get("grayscale", {}).get("enabled"):
+        image = apply_grayscale_conversion(image)
+    return image, img_dims
+
+
+def resize_image_keeping_aspect_ratio(image: np.ndarray, desired_size: Tuple[int, int]) -> np.ndarray:
+    height, width = image.shape[:2]
+    ratio = min(desired_size[1] / height, desired_size[0] / width)
+    new_width = int(width * ratio)
+    new_height = int(height * ratio)
+    return cv2.resize(image, (new_width, new_height))
+
+
+def letterbox_image(image: np.ndarray, desired_size: Tuple[int, int], color: Tuple[int, int, int]) -> np.ndarray:
+    resized = resize_image_keeping_aspect_ratio(image, desired_size)
+    new_height, new_width = resized.shape[:2]
+    top = (desired_size[1] - new_height) // 2
+    bottom = desired_size[1] - new_height - top
+    left = (desired_size[0] - new_width) // 2
+    right = desired_size[0] - new_width - left
+    return cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color)
+
+
+def get_resize_method(preproc: Dict[str, Any]) -> str:
+    resize = preproc.get("resize")
+    if not resize:
+        return "Stretch to"
+    method = resize.get("format", "Stretch to")
+    if method in {"Fit (reflect edges) in", "Fit within", "Fill (with center crop) in"}:
+        return "Fit (black edges) in"
+    if method not in {"Stretch to", "Fit (black edges) in", "Fit (white edges) in", "Fit (grey edges) in"}:
+        return "Stretch to"
+    return method
+
+
+def preprocess_image(image: Any, preproc: Dict[str, Any], input_hw: Tuple[int, int]) -> Tuple[np.ndarray, Tuple[int, int]]:
+    np_image, is_bgr = load_image(image)
+    processed, img_dims = apply_preproc(np_image, preproc)
+    resize_method = get_resize_method(preproc)
+    h, w = input_hw
+    if resize_method == "Stretch to":
+        resized = cv2.resize(processed, (w, h))
+    elif resize_method == "Fit (white edges) in":
+        resized = letterbox_image(processed, (w, h), (255, 255, 255))
+    elif resize_method == "Fit (grey edges) in":
+        resized = letterbox_image(processed, (w, h), (114, 114, 114))
+    else:
+        resized = letterbox_image(processed, (w, h), (0, 0, 0))
+    if is_bgr:
+        resized = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)
+    img_in = resized.astype(np.float32)
+    img_in = np.transpose(img_in, (2, 0, 1))
+    img_in = np.expand_dims(img_in, axis=0)
+    return img_in, img_dims
+
+
+def sigmoid(x: np.ndarray) -> np.ndarray:
+    return 1.0 / (1.0 + np.exp(-x))
+
+
+def non_max_suppression_fast(boxes: np.ndarray, overlap_thresh: float) -> List[np.ndarray]:
+    if len(boxes) == 0:
+        return []
+    if boxes.dtype.kind == "i":
+        boxes = boxes.astype("float")
+    pick = []
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2]
+    y2 = boxes[:, 3]
+    conf = boxes[:, 4]
+    area = (x2 - x1 + 1) * (y2 - y1 + 1)
+    idxs = np.argsort(conf)
+    while len(idxs) > 0:
+        last = len(idxs) - 1
+        i = idxs[last]
+        pick.append(i)
+        xx1 = np.maximum(x1[i], x1[idxs[:last]])
+        yy1 = np.maximum(y1[i], y1[idxs[:last]])
+        xx2 = np.minimum(x2[i], x2[idxs[:last]])
+        yy2 = np.minimum(y2[i], y2[idxs[:last]])
+        w = np.maximum(0, xx2 - xx1 + 1)
+        h = np.maximum(0, yy2 - yy1 + 1)
+        overlap = (w * h) / area[idxs[:last]]
+        idxs = np.delete(idxs, np.concatenate(([last], np.where(overlap > overlap_thresh)[0])))
+    return boxes[pick].astype("float")
+
+
+def w_np_non_max_suppression(
+    prediction: np.ndarray,
+    conf_thresh: float = 0.25,
+    iou_thresh: float = 0.45,
+    class_agnostic: bool = False,
+    max_detections: int = 300,
+    max_candidate_detections: int = 3000,
+    num_masks: int = 0,
+    box_format: str = "xywh",
+):
+    num_classes = prediction.shape[2] - 5 - num_masks
+    if box_format == "xywh":
+        pred_view = prediction[:, :, :4]
+        x1 = pred_view[:, :, 0] - pred_view[:, :, 2] / 2
+        y1 = pred_view[:, :, 1] - pred_view[:, :, 3] / 2
+        x2 = pred_view[:, :, 0] + pred_view[:, :, 2] / 2
+        y2 = pred_view[:, :, 1] + pred_view[:, :, 3] / 2
+        pred_view[:, :, 0] = x1
+        pred_view[:, :, 1] = y1
+        pred_view[:, :, 2] = x2
+        pred_view[:, :, 3] = y2
+    elif box_format != "xyxy":
+        raise ValueError(f"box_format must be 'xywh' or 'xyxy', got {box_format}")
+
+    batch_predictions = []
+    for np_image_pred in prediction:
+        np_conf_mask = np_image_pred[:, 4] >= conf_thresh
+        if not np.any(np_conf_mask):
+            batch_predictions.append([])
+            continue
+        np_image_pred = np_image_pred[np_conf_mask]
+        if np_image_pred.shape[0] == 0:
+            batch_predictions.append([])
+            continue
+        cls_confs = np_image_pred[:, 5 : num_classes + 5]
+        if cls_confs.shape[1] == 0:
+            batch_predictions.append([])
+            continue
+        np_class_conf = np.max(cls_confs, axis=1, keepdims=True)
+        np_class_pred = np.argmax(cls_confs, axis=1, keepdims=True)
+        if num_masks > 0:
+            np_mask_pred = np_image_pred[:, 5 + num_classes :]
+            np_detections = np.concatenate(
+                [
+                    np_image_pred[:, :5],
+                    np_class_conf,
+                    np_class_pred.astype(np.float32),
+                    np_mask_pred,
+                ],
+                axis=1,
+            )
+        else:
+            np_detections = np.concatenate(
+                [np_image_pred[:, :5], np_class_conf, np_class_pred.astype(np.float32)],
+                axis=1,
+            )
+        filtered_predictions = []
+        if class_agnostic:
+            sorted_indices = np.argsort(-np_detections[:, 4])
+            np_detections_sorted = np_detections[sorted_indices]
+            filtered_predictions.extend(non_max_suppression_fast(np_detections_sorted, iou_thresh))
+        else:
+            np_unique_labels = np.unique(np_class_pred)
+            for c in np_unique_labels:
+                class_mask = np.atleast_1d(np_class_pred.squeeze() == c)
+                np_detections_class = np_detections[class_mask]
+                if np_detections_class.shape[0] == 0:
+                    continue
+                sorted_indices = np.argsort(-np_detections_class[:, 4])
+                np_detections_sorted = np_detections_class[sorted_indices]
+                filtered_predictions.extend(non_max_suppression_fast(np_detections_sorted, iou_thresh))
+
+        if filtered_predictions:
+            filtered_np = np.array(filtered_predictions)
+            idx = np.argsort(-filtered_np[:, 4])
+            filtered_np = filtered_np[idx]
+            if len(filtered_np) > max_detections:
+                filtered_np = filtered_np[:max_detections]
+            batch_predictions.append(list(filtered_np))
+        else:
+            batch_predictions.append([])
+    return batch_predictions
+
+
+def get_static_crop_dimensions(orig_shape: Tuple[int, int], preproc: dict) -> Tuple[Tuple[int, int], Tuple[int, int]]:
+    if not static_crop_should_be_applied(preproc):
+        return (0, 0), orig_shape
+    crop = preproc["static-crop"]
+    x_min, y_min, x_max, y_max = (crop[k] / 100.0 for k in ["x_min", "y_min", "x_max", "y_max"])
+    crop_shift_x, crop_shift_y = (round(x_min * orig_shape[1]), round(y_min * orig_shape[0]))
+    cropped_percent_x = x_max - x_min
+    cropped_percent_y = y_max - y_min
+    new_shape = (round(orig_shape[0] * cropped_percent_y), round(orig_shape[1] * cropped_percent_x))
+    return (crop_shift_x, crop_shift_y), new_shape
+
+
+def post_process_bboxes(
+    predictions: List[List[List[float]]],
+    infer_shape: Tuple[int, int],
+    img_dims: List[Tuple[int, int]],
+    preproc: dict,
+    resize_method: str,
+) -> List[List[List[float]]]:
+    scaled_predictions = []
+    for i, batch_predictions in enumerate(predictions):
+        if len(batch_predictions) == 0:
+            scaled_predictions.append([])
+            continue
+        np_batch_predictions = np.array(batch_predictions)
+        predicted_bboxes = np_batch_predictions[:, :4]
+        (crop_shift_x, crop_shift_y), origin_shape = get_static_crop_dimensions(img_dims[i], preproc)
+        if resize_method == "Stretch to":
+            scale_height = origin_shape[0] / infer_shape[0]
+            scale_width = origin_shape[1] / infer_shape[1]
+            predicted_bboxes[:, 0] *= scale_width
+            predicted_bboxes[:, 2] *= scale_width
+            predicted_bboxes[:, 1] *= scale_height
+            predicted_bboxes[:, 3] *= scale_height
+        else:
+            scale = min(infer_shape[0] / origin_shape[0], infer_shape[1] / origin_shape[1])
+            inter_h = round(origin_shape[0] * scale)
+            inter_w = round(origin_shape[1] * scale)
+            pad_x = (infer_shape[1] - inter_w) / 2
+            pad_y = (infer_shape[0] - inter_h) / 2
+            predicted_bboxes[:, 0] -= pad_x
+            predicted_bboxes[:, 2] -= pad_x
+            predicted_bboxes[:, 1] -= pad_y
+            predicted_bboxes[:, 3] -= pad_y
+            predicted_bboxes /= scale
+        predicted_bboxes[:, 0] = np.round(np.clip(predicted_bboxes[:, 0], 0, origin_shape[1]))
+        predicted_bboxes[:, 2] = np.round(np.clip(predicted_bboxes[:, 2], 0, origin_shape[1]))
+        predicted_bboxes[:, 1] = np.round(np.clip(predicted_bboxes[:, 1], 0, origin_shape[0]))
+        predicted_bboxes[:, 3] = np.round(np.clip(predicted_bboxes[:, 3], 0, origin_shape[0]))
+        predicted_bboxes[:, 0] += crop_shift_x
+        predicted_bboxes[:, 2] += crop_shift_x
+        predicted_bboxes[:, 1] += crop_shift_y
+        predicted_bboxes[:, 3] += crop_shift_y
+        np_batch_predictions[:, :4] = predicted_bboxes
+        scaled_predictions.append(np_batch_predictions.tolist())
+    return scaled_predictions
+
+
+def post_process_keypoints(
+    predictions: List[List[List[float]]],
+    keypoints_start_index: int,
+    infer_shape: Tuple[int, int],
+    img_dims: List[Tuple[int, int]],
+    preproc: dict,
+    resize_method: str,
+) -> List[List[List[float]]]:
+    scaled_predictions = []
+    for i, batch_predictions in enumerate(predictions):
+        if len(batch_predictions) == 0:
+            scaled_predictions.append([])
+            continue
+        np_batch_predictions = np.array(batch_predictions)
+        keypoints = np_batch_predictions[:, keypoints_start_index:]
+        (crop_shift_x, crop_shift_y), origin_shape = get_static_crop_dimensions(img_dims[i], preproc)
+        if resize_method == "Stretch to":
+            scale_width = origin_shape[1] / infer_shape[1]
+            scale_height = origin_shape[0] / infer_shape[0]
+            for k in range(keypoints.shape[1] // 3):
+                keypoints[:, k * 3] *= scale_width
+                keypoints[:, k * 3 + 1] *= scale_height
+        else:
+            scale = min(infer_shape[0] / origin_shape[0], infer_shape[1] / origin_shape[1])
+            inter_w = int(origin_shape[1] * scale)
+            inter_h = int(origin_shape[0] * scale)
+            pad_x = (infer_shape[1] - inter_w) / 2
+            pad_y = (infer_shape[0] - inter_h) / 2
+            for k in range(keypoints.shape[1] // 3):
+                keypoints[:, k * 3] -= pad_x
+                keypoints[:, k * 3] /= scale
+                keypoints[:, k * 3 + 1] -= pad_y
+                keypoints[:, k * 3 + 1] /= scale
+        for k in range(keypoints.shape[1] // 3):
+            keypoints[:, k * 3] = np.round(np.clip(keypoints[:, k * 3], 0, origin_shape[1]))
+            keypoints[:, k * 3 + 1] = np.round(np.clip(keypoints[:, k * 3 + 1], 0, origin_shape[0]))
+            keypoints[:, k * 3] += crop_shift_x
+            keypoints[:, k * 3 + 1] += crop_shift_y
+        np_batch_predictions[:, keypoints_start_index:] = keypoints
+        scaled_predictions.append(np_batch_predictions.tolist())
+    return scaled_predictions
+
+
+def masks2poly(masks: np.ndarray) -> List[np.ndarray]:
+    segments = []
+    for mask in masks:
+        if mask.dtype == np.bool_:
+            m_uint8 = mask
+            if not m_uint8.flags.c_contiguous:
+                m_uint8 = np.ascontiguousarray(m_uint8)
+            m_uint8 = m_uint8.view(np.uint8)
+        elif mask.dtype == np.uint8:
+            m_uint8 = mask if mask.flags.c_contiguous else np.ascontiguousarray(mask)
+        else:
+            m_bool = mask > 0
+            if not m_bool.flags.c_contiguous:
+                m_bool = np.ascontiguousarray(m_bool)
+            m_uint8 = m_bool.view(np.uint8)
+        if not np.any(m_uint8):
+            segments.append(np.zeros((0, 2), dtype=np.float32))
+            continue
+        contours = cv2.findContours(m_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
+        if contours:
+            contours = np.array(contours[np.array([len(x) for x in contours]).argmax()]).reshape(-1, 2)
+        else:
+            contours = np.zeros((0, 2))
+        segments.append(contours.astype("float32"))
+    return segments
+
+
+def post_process_polygons(
+    origin_shape: Tuple[int, int],
+    polys: List[List[Tuple[float, float]]],
+    infer_shape: Tuple[int, int],
+    preproc: dict,
+    resize_method: str,
+) -> List[List[Tuple[float, float]]]:
+    (crop_shift_x, crop_shift_y), origin_shape = get_static_crop_dimensions(origin_shape, preproc)
+    new_polys = []
+    if resize_method == "Stretch to":
+        width_ratio = origin_shape[1] / infer_shape[1]
+        height_ratio = origin_shape[0] / infer_shape[0]
+        for poly in polys:
+            new_polys.append([(p[0] * width_ratio, p[1] * height_ratio) for p in poly])
+    else:
+        scale = min(infer_shape[0] / origin_shape[0], infer_shape[1] / origin_shape[1])
+        inter_w = int(origin_shape[1] * scale)
+        inter_h = int(origin_shape[0] * scale)
+        pad_x = (infer_shape[1] - inter_w) / 2
+        pad_y = (infer_shape[0] - inter_h) / 2
+        for poly in polys:
+            new_polys.append([((p[0] - pad_x) / scale, (p[1] - pad_y) / scale) for p in poly])
+    shifted_polys = []
+    for poly in new_polys:
+        shifted_polys.append([(p[0] + crop_shift_x, p[1] + crop_shift_y) for p in poly])
+    return shifted_polys
+
+
+def preprocess_segmentation_masks(protos: np.ndarray, masks_in: np.ndarray, shape: Tuple[int, int]) -> np.ndarray:
+    c, mh, mw = protos.shape
+    masks = protos.astype(np.float32)
+    masks = masks.reshape((c, -1))
+    masks = masks_in @ masks
+    masks = sigmoid(masks)
+    masks = masks.reshape((-1, mh, mw))
+    gain = min(mh / shape[0], mw / shape[1])
+    pad = (mw - shape[1] * gain) / 2, (mh - shape[0] * gain) / 2
+    top, left = int(pad[1]), int(pad[0])
+    bottom, right = int(mh - pad[1]), int(mw - pad[0])
+    return masks[:, top:bottom, left:right]
+
+
+def crop_mask(masks: np.ndarray, boxes: np.ndarray) -> np.ndarray:
+    n, h, w = masks.shape
+    x1, y1, x2, y2 = np.split(boxes[:, :, None], 4, 1)
+    r = np.arange(w, dtype=x1.dtype)[None, None, :]
+    c = np.arange(h, dtype=x1.dtype)[None, :, None]
+    masks = masks * ((r >= x1) * (r < x2) * (c >= y1) * (c < y2))
+    return masks
+
+
+def process_mask_accurate(protos: np.ndarray, masks_in: np.ndarray, bboxes: np.ndarray, shape: Tuple[int, int]) -> np.ndarray:
+    masks = preprocess_segmentation_masks(protos, masks_in, shape)
+    if len(masks.shape) == 2:
+        masks = np.expand_dims(masks, axis=0)
+    masks = masks.transpose((1, 2, 0))
+    masks = cv2.resize(masks, (shape[1], shape[0]), cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = np.expand_dims(masks, axis=2)
+    masks = masks.transpose((2, 0, 1))
+    masks = crop_mask(masks, bboxes)
+    masks[masks < 0.5] = 0
+    return masks
+
+
+def process_mask_tradeoff(protos: np.ndarray, masks_in: np.ndarray, bboxes: np.ndarray, shape: Tuple[int, int], tradeoff_factor: float) -> np.ndarray:
+    c, mh, mw = protos.shape
+    masks = preprocess_segmentation_masks(protos, masks_in, shape)
+    if len(masks.shape) == 2:
+        masks = np.expand_dims(masks, axis=0)
+    masks = masks.transpose((1, 2, 0))
+    ih, iw = shape
+    h = int(mh * (1 - tradeoff_factor) + ih * tradeoff_factor)
+    w = int(mw * (1 - tradeoff_factor) + iw * tradeoff_factor)
+    if tradeoff_factor != 0:
+        masks = cv2.resize(masks, (w, h), cv2.INTER_LINEAR)
+    if len(masks.shape) == 2:
+        masks = np.expand_dims(masks, axis=2)
+    masks = masks.transpose((2, 0, 1))
+    c, mh, mw = masks.shape
+    scale_x = mw / iw
+    scale_y = mh / ih
+    bboxes = bboxes.copy()
+    bboxes[:, 0] *= scale_x
+    bboxes[:, 2] *= scale_x
+    bboxes[:, 1] *= scale_y
+    bboxes[:, 3] *= scale_y
+    masks = crop_mask(masks, bboxes)
+    masks[masks < 0.5] = 0
+    return masks
+
+
+def process_mask_fast(protos: np.ndarray, masks_in: np.ndarray, bboxes: np.ndarray, shape: Tuple[int, int]) -> np.ndarray:
+    ih, iw = shape
+    c, mh, mw = protos.shape
+    masks = preprocess_segmentation_masks(protos, masks_in, shape)
+    scale_x = mw / iw
+    scale_y = mh / ih
+    bboxes = bboxes.copy()
+    bboxes[:, 0] *= scale_x
+    bboxes[:, 2] *= scale_x
+    bboxes[:, 1] *= scale_y
+    bboxes[:, 3] *= scale_y
+    masks = crop_mask(masks, bboxes)
+    masks[masks < 0.5] = 0
+    return masks
+
+
+def load_onnx_session(onnx_path: str, providers: List[str] = None) -> ort.InferenceSession:
+    if providers is None:
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+    return ort.InferenceSession(onnx_path, providers=providers)
+
+
+def find_default_onnx(data_dir: str) -> str:
+    candidates = [f for f in os.listdir(data_dir) if f.lower().endswith(".onnx")]
+    candidates.sort()
+    if not candidates:
+        raise FileNotFoundError(f"No .onnx file found in {data_dir}")
+    if len(candidates) > 1:
+        # Prefer weights.onnx if present.
+        for name in candidates:
+            if name.lower() == "weights.onnx":
+                return os.path.join(data_dir, name)
+    return os.path.join(data_dir, candidates[0])
+
+
+def get_input_hw(session: ort.InferenceSession, preproc: Dict[str, Any]) -> Tuple[int, int]:
+    inputs = session.get_inputs()[0]
+    shape = inputs.shape
+    h, w = shape[2], shape[3]
+    if isinstance(h, str) or isinstance(w, str) or h is None or w is None:
+        resize = preproc.get("resize") if preproc else None
+        if resize:
+            h = int(resize.get("height", 640))
+            w = int(resize.get("width", 640))
+        else:
+            h, w = 640, 640
+    return int(h), int(w)
+
+
+def build_meta(data_dir: str, session: ort.InferenceSession) -> Dict[str, Any]:
+    environment = load_environment(data_dir)
+    preproc = environment.get("PREPROCESSING") or {}
+    class_names = load_class_names(data_dir, environment)
+    resize_method = get_resize_method(preproc)
+    input_hw = get_input_hw(session, preproc)
+    keypoints_metadata = load_keypoints_metadata(data_dir)
+    return {
+        "environment": environment,
+        "preproc": preproc,
+        "class_names": class_names,
+        "resize_method": resize_method,
+        "input_hw": input_hw,
+        "keypoints_metadata": keypoints_metadata,
+    }
+
+
+def normalize_rgb(img_in: np.ndarray, means: List[float], stds: List[float]) -> np.ndarray:
+    img_in = img_in.astype(np.float32)
+    img_in /= 255.0
+    img_in[:, 0, :, :] = (img_in[:, 0, :, :] - means[0]) / stds[0]
+    img_in[:, 1, :, :] = (img_in[:, 1, :, :] - means[1]) / stds[1]
+    img_in[:, 2, :, :] = (img_in[:, 2, :, :] - means[2]) / stds[2]
+    return img_in
+
+
+MODEL_TASK_TYPE = "object-detection"
+
+
+def preprocess_for_model(image: Any, meta: Dict[str, Any]) -> Tuple[np.ndarray, Tuple[int, int]]:
+    img_in, img_dims = preprocess_image(image, meta["preproc"], meta["input_hw"])
+    img_in = img_in.astype(np.float32)
+    img_in /= 255.0
+    return img_in, img_dims
+
+
+def pack_predictions(predictions: np.ndarray) -> np.ndarray:
+    predictions = predictions.transpose(0, 2, 1)
+    boxes = predictions[:, :, :4]
+    class_confs = predictions[:, :, 4:]
+    confs = np.expand_dims(np.max(class_confs, axis=2), axis=2)
+    return np.concatenate([boxes, confs, class_confs], axis=2)
+
+
+def postprocess_predictions(predictions: np.ndarray, meta: Dict[str, Any], img_dims: List[Tuple[int, int]],
+                            confidence: float = 0.4, iou_threshold: float = 0.3, max_detections: int = 300):
+    preds = w_np_non_max_suppression(
+        predictions,
+        conf_thresh=confidence,
+        iou_thresh=iou_threshold,
+        class_agnostic=False,
+        max_detections=max_detections,
+        box_format="xywh",
+    )
+    infer_shape = meta["input_hw"]
+    preds = post_process_bboxes(preds, infer_shape, img_dims, meta["preproc"], meta["resize_method"])
+    class_names = meta["class_names"]
+    results = []
+    for batch_preds in preds:
+        batch_out = []
+        for pred in batch_preds:
+            cls_id = int(pred[6])
+            batch_out.append({
+                "x": (pred[0] + pred[2]) / 2,
+                "y": (pred[1] + pred[3]) / 2,
+                "width": pred[2] - pred[0],
+                "height": pred[3] - pred[1],
+                "confidence": float(pred[4]),
+                "class_id": cls_id,
+                "class": class_names[cls_id] if cls_id < len(class_names) else str(cls_id),
+            })
+        results.append(batch_out)
+    return results
+
+
+def load_model(onnx_path: str | None = None, data_dir: str | None = None):
+    data_dir = data_dir or os.path.dirname(os.path.abspath(__file__))
+    onnx_path = onnx_path or find_default_onnx(data_dir)
+    session = load_onnx_session(onnx_path)
+    meta = build_meta(data_dir, session)
+    model_type_fn = globals().get("load_model_type")
+    model_type = model_type_fn(data_dir) if callable(model_type_fn) else "unknown"
+    return {"session": session, "meta": meta, "model_type": model_type}
+
+
+def run_model(model: Any, image: Any = None, onnx_path: str | None = None, data_dir: str | None = None):
+    if image is None:
+        image = model
+        model = load_model(onnx_path=onnx_path, data_dir=data_dir)
+    session = model["session"]
+    meta = model["meta"]
+    model_type = model["model_type"]
+
+    img_in, img_dims = preprocess_for_model(image, meta)
+    input_name = session.get_inputs()[0].name
+    outputs = session.run(None, {input_name: img_in})
+    predictions = pack_predictions(outputs[0])
+    return postprocess_predictions(predictions, meta, [img_dims])
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: main.py <image_path> [onnx_path]", file=sys.stderr)
+        sys.exit(1)
+    image_path = sys.argv[1]
+    data_dir = os.path.dirname(os.path.abspath(__file__))
+    onnx_path = sys.argv[2] if len(sys.argv) > 2 else find_default_onnx(data_dir)
+    results = run_model(image_path, onnx_path=onnx_path, data_dir=data_dir)
+    print(json.dumps(results, 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 = ['road sign']
+        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,11 @@
+[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",
+]

weights.onnx

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